@devchitchat/chat 0.0.0

package/src/services/BotService.js

@@ -0,0 +1,148 @@
+/**
+ * BotService — manages bot user accounts and API tokens.
+ *
+ * Bots are regular users with the "bot" role. They authenticate to the
+ * WebSocket using a long-lived bot token instead of a session cookie.
+ * The token is hashed before storage; the plain token is returned once
+ * at creation time and never retrievable again.
+ */
+import { newId } from '../util/ids.js'
+import { randomToken, hashToken } from '../util/crypto.js'
+import { ServiceError } from '../util/errors.js'
+
+export class BotService {
+  constructor({ authService, authRepo, channelRepo, nowFn = () => Date.now() }) {
+    this.authService = authService
+    this.authRepo = authRepo
+    this.channelRepo = channelRepo
+    this.nowFn = nowFn
+  }
+
+  // ── Bot accounts ───────────────────────────────────────────────────────────
+
+  createBot({ handle, displayName, tokenLabel, requestingUserId }) {
+    this._requireAdmin(requestingUserId)
+    const h = handle?.trim()
+    const name = displayName?.trim() || h
+    if (!h) throw new ServiceError('BAD_REQUEST', 'Handle is required')
+    if (this.authRepo.isHandleTaken({ handle: h })) throw new ServiceError('CONFLICT', 'Handle already taken')
+
+    const userId = newId('u')
+    const now = this.nowFn()
+    this.authRepo.insertBotUser({ userId, handle: h, displayName: name, now })
+
+    const { tokenId, token } = this._insertToken({ userId, label: tokenLabel, now })
+    return { userId, handle: h, displayName: name, roles: ['bot'], tokenId, token }
+  }
+
+  listBots({ requestingUserId }) {
+    this._requireAdmin(requestingUserId)
+    return this.authRepo.listUsers()
+      .filter(row => {
+        try { return JSON.parse(row.roles_json).includes('bot') } catch { return false }
+      })
+      .map(row => ({
+        user_id:      row.user_id,
+        handle:       row.handle,
+        display_name: row.display_name,
+        roles:        JSON.parse(row.roles_json),
+        created_at:   row.created_at,
+        tokens:       this.authRepo.listBotTokens({ userId: row.user_id }),
+      }))
+  }
+
+  getBot({ userId, requestingUserId }) {
+    this._requireAdmin(requestingUserId)
+    const row = this.authRepo.findUserById({ userId })
+    if (!row) throw new ServiceError('NOT_FOUND', 'Bot not found')
+    const roles = JSON.parse(row.roles_json)
+    if (!roles.includes('bot')) throw new ServiceError('NOT_FOUND', 'Bot not found')
+    return {
+      user_id:      row.user_id,
+      handle:       row.handle,
+      display_name: row.display_name,
+      roles,
+      tokens:       this.authRepo.listBotTokens({ userId }),
+      channels:     this._getBotChannels(userId),
+    }
+  }
+
+  // ── Bot tokens ─────────────────────────────────────────────────────────────
+
+  createToken({ userId, label, ttlMs = null, requestingUserId }) {
+    this._requireAdmin(requestingUserId)
+    const now = this.nowFn()
+    const expiresAt = ttlMs != null ? now + ttlMs : null
+    return this._insertToken({ userId, label, now, expiresAt })
+  }
+
+  revokeToken({ tokenId, requestingUserId }) {
+    this._requireAdmin(requestingUserId)
+    this.authRepo.revokeBotToken({ tokenId, now: this.nowFn() })
+  }
+
+  revokeAllTokens({ userId, requestingUserId }) {
+    this._requireAdmin(requestingUserId)
+    this.authRepo.revokeAllBotTokens({ userId, now: this.nowFn() })
+  }
+
+  /** Called by ChatServer hello handler to authenticate a bot WS connection. */
+  authenticateToken(plainToken) {
+    const tokenHash = hashToken(plainToken)
+    const row = this.authRepo.findBotTokenByHash({ tokenHash, now: this.nowFn() })
+    if (!row) throw new ServiceError('UNAUTHORIZED', 'Invalid bot token')
+    this.authRepo.touchBotToken({ tokenId: row.token_id, now: this.nowFn() })
+    return {
+      userId:      row.user_id,
+      handle:      row.handle,
+      displayName: row.display_name,
+      roles:       JSON.parse(row.roles_json),
+    }
+  }
+
+  // ── Bot channel membership ─────────────────────────────────────────────────
+
+  setBotChannels({ userId, channelIds, requestingUserId }) {
+    this._requireAdmin(requestingUserId)
+    const now = this.nowFn()
+
+    // Current active memberships
+    const current = this._getBotChannels(userId).map(c => c.channel_id)
+    const next = Array.isArray(channelIds) ? channelIds : []
+
+    const toJoin  = next.filter(id => !current.includes(id))
+    const toLeave = current.filter(id => !next.includes(id))
+
+    for (const channelId of toJoin) {
+      this.channelRepo.upsertMembership({ channelId, userId, role: 'member', now })
+    }
+    for (const channelId of toLeave) {
+      this.channelRepo.setMemberLeft({ channelId, userId, now })
+    }
+  }
+
+  _getBotChannels(userId) {
+    return this.channelRepo.listAccessible({ userId })
+  }
+
+  // ── Internals ──────────────────────────────────────────────────────────────
+
+  _insertToken({ userId, label, now, expiresAt = null }) {
+    const token = randomToken()
+    const tokenId = newId('bt')
+    this.authRepo.insertBotToken({
+      tokenId, userId,
+      tokenHash: hashToken(token),
+      label: label?.trim() || null,
+      now,
+      expiresAt,
+    })
+    return { tokenId, token, expiresAt }
+  }
+
+  _requireAdmin(userId) {
+    const user = this.authService.getUser(userId)
+    const roles = user?.roles ?? []
+    if (!roles.includes('admin')) throw new ServiceError('FORBIDDEN', 'Admin role required')
+  }
+}

package/src/services/ChannelService.js

@@ -0,0 +1,176 @@
+import { newId } from '../util/ids.js'
+import { ServiceError } from '../util/errors.js'
+import { buildDmChannelName } from '../core/dm.js'
+
+export class ChannelService {
+  constructor({ channelRepo, hubService, nowFn = () => Date.now() }) {
+    this.channelRepo = channelRepo
+    this.hubService = hubService
+    this.nowFn = nowFn
+  }
+
+  createChannel({ hubId, kind, name, topic = null, visibility = 'public', createdByUserId, userRoles = [] }) {
+    if (!['text', 'voice'].includes(kind)) throw new ServiceError('BAD_REQUEST', 'Invalid channel kind')
+    if (!name?.trim()) throw new ServiceError('BAD_REQUEST', 'Channel name required')
+    if (!this.hubService.canAccessHub(hubId, createdByUserId, userRoles)) throw new ServiceError('FORBIDDEN', 'Cannot access hub')
+
+    const channelId = newId('c')
+    const now = this.nowFn()
+
+    this.channelRepo.insertChannelWithOwner({ channelId, hubId, kind, name: name.trim(), topic, visibility, createdByUserId, now })
+
+    return { channel_id: channelId, hub_id: hubId, kind, name: name.trim(), topic, visibility }
+  }
+
+  listChannels(userId, userRoles = [], hubId = null) {
+    const isAdmin = userRoles.includes('admin')
+    const isGuest = userRoles.includes('guest')
+    if (hubId) {
+      return isAdmin
+        ? this.channelRepo.listInHub({ hubId })
+        : this.channelRepo.listAccessibleInHub({ hubId, userId, isGuest })
+    }
+    return isAdmin
+      ? this.channelRepo.listAll()
+      : this.channelRepo.listAccessible({ userId, isGuest })
+  }
+
+  joinChannel({ channelId, userId, userRoles = [] }) {
+    const channel = this.getChannel(channelId)
+    if (!channel || channel.deleted_at) throw new ServiceError('NOT_FOUND', 'Channel not found')
+    if (channel.hub_id !== null && !this.hubService.canAccessHub(channel.hub_id, userId, userRoles)) throw new ServiceError('FORBIDDEN', 'Cannot access hub')
+
+    if (channel.visibility === 'private') {
+      const member = this.getMembership(channelId, userId)
+      if (!member || member.left_at || member.banned_at) throw new ServiceError('FORBIDDEN', 'Not a member of this channel')
+      return { channel_id: channelId, kind: channel.kind }
+    }
+
+    this.channelRepo.upsertMembership({ channelId, userId, role: 'member', now: this.nowFn() })
+    return { channel_id: channelId, kind: channel.kind }
+  }
+
+  leaveChannel({ channelId, userId }) {
+    const channel = this.getChannel(channelId)
+    // DM and private channels have permanent membership — the WS topic unsubscribes
+    // but the DB row is preserved. Private channel members cannot re-add themselves,
+    // so clearing left_at here would lock them out until an owner re-adds them.
+    const isPermanent = channel?.kind === 'dm' || channel?.visibility === 'private'
+    if (!isPermanent) {
+      this.channelRepo.setMemberLeft({ channelId, userId, now: this.nowFn() })
+    }
+    return { channel_id: channelId }
+  }
+
+  isMember(channelId, userId) {
+    const member = this.getMembership(channelId, userId)
+    return !!member && !member.left_at && !member.banned_at
+  }
+
+  canAccessChannel(channelId, userId, roles = []) {
+    if (roles.includes('admin')) return true
+    const channel = this.getChannel(channelId)
+    if (!channel || channel.deleted_at) return false
+    // DM channels (hub_id = null) skip the hub access check — membership is the sole gate
+    if (channel.hub_id !== null && !this.hubService.canAccessHub(channel.hub_id, userId, roles)) return false
+    if (channel.visibility === 'public' && !roles.includes('guest')) return true
+    return this.isMember(channelId, userId)
+  }
+
+  listChannelMembers(channelId) {
+    return this.channelRepo.listActiveMembers({ channelId })
+  }
+
+  addMember({ channelId, createdByUserId, targetUserId }) {
+    const adder = this.getMembership(channelId, createdByUserId)
+    if (!adder || !['owner', 'mod'].includes(adder.role)) throw new ServiceError('FORBIDDEN', 'Only owner or mod can add members')
+    const channel = this.getChannel(channelId)
+    if (!channel) throw new ServiceError('NOT_FOUND', 'Channel not found')
+    const existing = this.getMembership(channelId, targetUserId)
+    if (existing && !existing.left_at && !existing.banned_at) throw new ServiceError('BAD_REQUEST', 'User is already a member')
+
+    this.channelRepo.upsertMembership({ channelId, userId: targetUserId, role: 'member', now: this.nowFn() })
+
+    return { channel_id: channelId, user_id: targetUserId }
+  }
+
+  removeMember({ channelId, removedByUserId, targetUserId }) {
+    const remover = this.getMembership(channelId, removedByUserId)
+    if (!remover || !['owner', 'mod'].includes(remover.role)) throw new ServiceError('FORBIDDEN', 'Only owner or mod can remove members')
+    if (removedByUserId === targetUserId) throw new ServiceError('BAD_REQUEST', 'Use leaveChannel to leave a channel')
+    const target = this.getMembership(channelId, targetUserId)
+    if (!target || target.left_at || target.banned_at) throw new ServiceError('BAD_REQUEST', 'User is not a member')
+
+    this.channelRepo.setMemberLeft({ channelId, userId: targetUserId, now: this.nowFn() })
+
+    return { channel_id: channelId, user_id: targetUserId }
+  }
+
+  getChannel(channelId) {
+    return this.channelRepo.findById({ channelId })
+  }
+
+  getMembership(channelId, userId) {
+    return this.channelRepo.findMembership({ channelId, userId })
+  }
+
+  findOrCreateDm({ userId, targetUserId }) {
+    if (userId === targetUserId) throw new ServiceError('BAD_REQUEST', 'Cannot DM yourself')
+    const name = buildDmChannelName(userId, targetUserId)
+    const existing = this.channelRepo.findDmByName({ name })
+    if (existing) return { channel_id: existing.channel_id, is_new: false }
+    const channelId = newId('c')
+    this.channelRepo.insertDmChannel({ channelId, name, userIdA: userId, userIdB: targetUserId, now: this.nowFn() })
+    return { channel_id: channelId, is_new: true }
+  }
+
+  listDms({ userId }) {
+    return this.channelRepo.listDmsByUser({ userId })
+  }
+
+  ensureDefaultChannel(hubId, createdByUserId) {
+    const existing = this.channelRepo.findByHubAndName({ hubId, name: 'general' })
+    if (existing) return existing
+    return this.createChannel({ hubId, kind: 'text', name: 'general', topic: 'General discussions', visibility: 'public', createdByUserId, userRoles: ['admin'] })
+  }
+
+  updateChannel({ channelId, userId, roles = [], name = null, topic = null, visibility = null }) {
+    const channel = this.getChannel(channelId)
+    if (!channel || channel.deleted_at) throw new ServiceError('NOT_FOUND', 'Channel not found')
+    const membership = this.getMembership(channelId, userId)
+    const isOwner = membership && membership.role === 'owner' && !membership.left_at && !membership.banned_at
+    if (!roles.includes('admin') && channel.created_by_user_id !== userId && !isOwner) throw new ServiceError('FORBIDDEN', 'Cannot update channel')
+    if (name === null && topic === null && visibility === null) throw new ServiceError('BAD_REQUEST', 'No fields to update')
+
+    const patch = {}
+    if (name !== null) {
+      if (!name.trim()) throw new ServiceError('BAD_REQUEST', 'Channel name cannot be empty')
+      patch.name = name.trim()
+    }
+    if (topic !== null) patch.topic = topic
+    if (visibility !== null) {
+      if (!['public', 'private'].includes(visibility)) throw new ServiceError('BAD_REQUEST', 'Channel visibility must be public or private')
+      patch.visibility = visibility
+    }
+
+    this.channelRepo.patchChannel({ channelId, ...patch })
+    return this.getChannel(channelId)
+  }
+
+  deleteChannel({ channelId, userId, roles = [] }) {
+    const channel = this.getChannel(channelId)
+    if (!channel || channel.deleted_at) throw new ServiceError('NOT_FOUND', 'Channel not found')
+    const membership = this.getMembership(channelId, userId)
+    const isOwner = membership && membership.role === 'owner' && !membership.left_at && !membership.banned_at
+    if (!roles.includes('admin') && channel.created_by_user_id !== userId && !isOwner) throw new ServiceError('FORBIDDEN', 'Cannot delete channel')
+
+    this.channelRepo.softDeleteChannel({ channelId, now: this.nowFn() })
+    return { channel_id: channel.channel_id, hub_id: channel.hub_id }
+  }
+
+  reorderChannels({ hubId, channelIds, userId, userRoles = [] }) {
+    if (!this.hubService.canAccessHub(hubId, userId, userRoles)) throw new ServiceError('FORBIDDEN', 'Cannot access hub')
+    if (!Array.isArray(channelIds) || channelIds.length === 0) throw new ServiceError('BAD_REQUEST', 'channelIds must be a non-empty array')
+    return this.channelRepo.reorderChannels({ hubId, channelIds })
+  }
+}

package/src/services/DeliveryService.js

@@ -0,0 +1,28 @@
+export class DeliveryService {
+  constructor({ deliveryRepo, nowFn = () => Date.now() }) {
+    this.deliveryRepo = deliveryRepo
+    this.nowFn = nowFn
+  }
+
+  getOrCreate({ channelId, userId }) {
+    const existing = this.deliveryRepo.findByChannelAndUser({ channelId, userId })
+    if (existing) return existing
+    return this.deliveryRepo.create({ channelId, userId, now: this.nowFn() })
+  }
+
+  advance({ channelId, userId, afterSeq }) {
+    this.deliveryRepo.advance({ channelId, userId, afterSeq, now: this.nowFn() })
+  }
+
+  advanceMention({ channelId, userId, mentionSeq, priority = 'normal' }) {
+    // Ensure a delivery row exists before updating mention_seq.
+    // If Linda has never navigated to this channel, there is no row yet and
+    // the UPDATE in advanceMention would silently affect 0 rows, losing the mention.
+    this.getOrCreate({ channelId, userId })
+    this.deliveryRepo.advanceMention({ channelId, userId, mentionSeq, priority })
+  }
+
+  buildDigestData({ userId }) {
+    return this.deliveryRepo.buildDigestData({ userId })
+  }
+}

package/src/services/HubService.js

@@ -0,0 +1,133 @@
+import { newId } from '../util/ids.js'
+import { ServiceError } from '../util/errors.js'
+
+export class HubService {
+  constructor({ hubRepo, nowFn = () => Date.now() }) {
+    this.hubRepo = hubRepo
+    this.nowFn = nowFn
+  }
+
+  createHub({ name, description = null, visibility = 'public', createdByUserId }) {
+    if (!['public', 'restricted'].includes(visibility)) throw new ServiceError('BAD_REQUEST', 'Invalid hub visibility')
+    if (!name?.trim()) throw new ServiceError('BAD_REQUEST', 'Hub name required')
+    const hubId = newId('h')
+    const now = this.nowFn()
+
+    this.hubRepo.insertHubWithOwner({ hubId, name: name.trim(), description, visibility, createdByUserId, now })
+
+    return { hub_id: hubId, name: name.trim(), description, visibility }
+  }
+
+  listHubs(userId, roles = []) {
+    if (roles.includes('admin')) return this.hubRepo.listAllHubs()
+    return this.hubRepo.listAccessibleHubs({ userId })
+  }
+
+  canAccessHub(hubId, userId, roles = []) {
+    if (roles.includes('admin')) return true
+    const hub = this.getHub(hubId)
+    if (!hub || hub.deleted_at) return false
+    if (hub.visibility === 'public' && !roles.includes('guest')) return true
+    const member = this.getHubMembership(hubId, userId)
+    return !!member && !member.left_at
+  }
+
+  getHub(hubId) {
+    return this.hubRepo.findById({ hubId })
+  }
+
+  getHubMembership(hubId, userId) {
+    return this.hubRepo.findMembership({ hubId, userId })
+  }
+
+  joinHub(hubId, userId) {
+    const hub = this.getHub(hubId)
+    if (!hub || hub.deleted_at) throw new ServiceError('NOT_FOUND', 'Hub not found')
+    this.hubRepo.upsertMembership({ hubId, userId, now: this.nowFn() })
+    return { hub_id: hubId }
+  }
+
+  leaveHub(hubId, userId) {
+    this.hubRepo.setMemberLeft({ hubId, userId, now: this.nowFn() })
+    return { hub_id: hubId }
+  }
+
+  ensureDefaultHub(createdByUserId) {
+    const existing = this.hubRepo.findByName({ name: 'Lobby' })
+    if (existing) return existing
+    return this.createHub({ name: 'Lobby', description: 'Main hub for general discussions', visibility: 'public', createdByUserId })
+  }
+
+  updateHub({ hubId, userId, roles = [], name = null, description = null, visibility = null }) {
+    const hub = this.getHub(hubId)
+    if (!hub || hub.deleted_at) throw new ServiceError('NOT_FOUND', 'Hub not found')
+    if (!roles.includes('admin') && hub.created_by_user_id !== userId) throw new ServiceError('FORBIDDEN', 'Cannot update hub')
+    if (name === null && description === null && visibility === null) throw new ServiceError('BAD_REQUEST', 'No fields to update')
+
+    const patch = {}
+    if (name !== null) {
+      if (!name.trim()) throw new ServiceError('BAD_REQUEST', 'Hub name cannot be empty')
+      patch.name = name.trim()
+    }
+    if (description !== null) patch.description = description
+    if (visibility !== null) {
+      if (!['public', 'restricted'].includes(visibility)) throw new ServiceError('BAD_REQUEST', 'Hub visibility must be public or restricted')
+      patch.visibility = visibility
+    }
+
+    this.hubRepo.patchHub({ hubId, ...patch })
+    return this.getHub(hubId)
+  }
+
+  addHubMember({ hubId, targetUserId, requestingUserId, requestingRoles = [] }) {
+    const hub = this.getHub(hubId)
+    if (!hub || hub.deleted_at) throw new ServiceError('NOT_FOUND', 'Hub not found')
+    const isAdmin = requestingRoles.includes('admin')
+    const isCreator = hub.created_by_user_id === requestingUserId
+    if (!isAdmin && !isCreator) throw new ServiceError('FORBIDDEN', 'Admin or hub creator required')
+    this.hubRepo.upsertMembership({ hubId, userId: targetUserId, now: this.nowFn() })
+    return { hub_id: hubId, user_id: targetUserId }
+  }
+
+  removeHubMember({ hubId, targetUserId, requestingUserId, requestingRoles = [] }) {
+    const hub = this.getHub(hubId)
+    if (!hub || hub.deleted_at) throw new ServiceError('NOT_FOUND', 'Hub not found')
+    const isAdmin = requestingRoles.includes('admin')
+    const isCreator = hub.created_by_user_id === requestingUserId
+    if (!isAdmin && !isCreator) throw new ServiceError('FORBIDDEN', 'Admin or hub creator required')
+    this.hubRepo.setMemberLeft({ hubId, userId: targetUserId, now: this.nowFn() })
+    return { hub_id: hubId, user_id: targetUserId }
+  }
+
+  listHubMembers({ hubId, requestingUserId, requestingRoles = [] }) {
+    const hub = this.getHub(hubId)
+    if (!hub || hub.deleted_at) throw new ServiceError('NOT_FOUND', 'Hub not found')
+    const isAdmin = requestingRoles.includes('admin')
+    const membership = this.getHubMembership(hubId, requestingUserId)
+    const isMember = membership && !membership.left_at
+    if (!isAdmin && !isMember) throw new ServiceError('FORBIDDEN', 'Hub membership required')
+    return this.hubRepo.listMembers({ hubId })
+  }
+
+  reorderHubs({ hubIds, userId, userRoles = [] }) {
+    if (!Array.isArray(hubIds) || hubIds.length === 0) throw new ServiceError('BAD_REQUEST', 'hub_ids required')
+    if (!userRoles.includes('admin')) {
+      // Non-admins can only reorder hubs they own or are a member of — the list query
+      // already scopes to accessible hubs, so any hub_id not in that set is silently ignored.
+    }
+    this.hubRepo.reorderHubs({ hubIds })
+    return this.listHubs(userId, userRoles)
+  }
+
+  deleteHub({ hubId, userId, roles = [] }) {
+    const hub = this.getHub(hubId)
+    if (!hub || hub.deleted_at) throw new ServiceError('NOT_FOUND', 'Hub not found')
+    if (!roles.includes('admin') && hub.created_by_user_id !== userId) throw new ServiceError('FORBIDDEN', 'Cannot delete hub')
+
+    const channelIds = this.hubRepo.listActiveChannelIds({ hubId })
+    const now = this.nowFn()
+    this.hubRepo.softDeleteHub({ hubId, now })
+
+    return { hub_id: hubId, channel_ids: channelIds }
+  }
+}

package/src/services/MessageService.js

@@ -0,0 +1,122 @@
+import { newId } from '../util/ids.js'
+import { ServiceError } from '../util/errors.js'
+import { validateEditPermission, validateEditText, assertMessageEditable, validateDeletePermission } from '../core/messages.js'
+
+export class MessageService {
+  constructor({ messageRepo, nowFn = () => Date.now(), channelService, searchService, uploadService = null, reactionService = null }) {
+    this.messageRepo = messageRepo
+    this.nowFn = nowFn
+    this.channelService = channelService
+    this.searchService = searchService
+    this.uploadService = uploadService
+    this.reactionService = reactionService
+  }
+
+  setUploadService(uploadService) {
+    this.uploadService = uploadService
+  }
+
+  sendMessage({ channelId, userId, text, clientMsgId = null, priority = 'normal', attachments = [] }) {
+    if (!this.channelService.isMember(channelId, userId)) throw new ServiceError('FORBIDDEN', 'Not a member of channel')
+    if (!text?.trim() && attachments.length === 0) throw new ServiceError('BAD_REQUEST', 'Message text or attachment required')
+    if (!['normal', 'async', 'now'].includes(priority)) throw new ServiceError('BAD_REQUEST', 'Invalid priority')
+
+    const msgId = newId('m')
+    const now = this.nowFn()
+    const trimmed = text?.trim() ?? ''
+
+    const attachmentsJson = attachments.length > 0 ? JSON.stringify(attachments) : null
+
+    const { seq } = this.messageRepo.insertMessage({
+      msgId, channelId, userId, now, text: trimmed, clientMsgId, priority, attachmentsJson
+    })
+
+    if (trimmed) {
+      this.searchService.indexMessage({ msg_id: msgId, channel_id: channelId, seq, user_id: userId, ts: now, text: trimmed })
+    }
+
+    let enrichedAttachments = attachments
+    if (this.uploadService && attachments.length > 0) {
+      const uploadIds = attachments.map(a => a.upload_id).filter(Boolean)
+      if (uploadIds.length > 0) {
+        this.uploadService.linkToMessage({ uploadIds, msgId, userId, channelId })
+        // Enrich with full upload details so consumers get url, mime_type, original_name.
+        enrichedAttachments = attachments.map(a => {
+          if (!a.upload_id) return a
+          const row = this.uploadService.getUpload({ uploadId: a.upload_id })
+          if (!row) return a
+          return {
+            upload_id:     row.upload_id,
+            url:           `/uploads/${row.upload_id}/${encodeURIComponent(row.original_name)}`,
+            original_name: row.original_name,
+            mime_type:     row.mime_type,
+            size_bytes:    row.size_bytes,
+          }
+        })
+      }
+    }
+
+    return { msg_id: msgId, seq, ts: now, priority, attachments: enrichedAttachments }
+  }
+
+  editMessage({ msgId, channelId, userId, newText }) {
+    const msg = this.messageRepo.getById(msgId)
+    if (!msg) throw new ServiceError('NOT_FOUND', 'Message not found')
+    if (msg.channel_id !== channelId) throw new ServiceError('BAD_REQUEST', 'Message does not belong to this channel')
+
+    assertMessageEditable(msg.deleted_at)
+    validateEditPermission(userId, msg.user_id)
+    const trimmed = validateEditText(newText)
+
+    const editedAt = this.nowFn()
+    this.messageRepo.updateMessage({ msgId, text: trimmed, editedAt })
+
+    this.searchService.indexMessage({ msg_id: msgId, channel_id: channelId, seq: msg.seq, user_id: msg.user_id, ts: msg.ts, text: trimmed })
+
+    return { msgId, channelId, text: trimmed, editedAt }
+  }
+
+  deleteMessage({ msgId, channelId, userId }) {
+    const msg = this.messageRepo.getById(msgId)
+    if (!msg) throw new ServiceError('NOT_FOUND', 'Message not found')
+    if (msg.channel_id !== channelId) throw new ServiceError('BAD_REQUEST', 'Message does not belong to this channel')
+    if (msg.deleted_at != null) throw new ServiceError('BAD_REQUEST', 'Message already deleted')
+
+    validateDeletePermission(userId, msg.user_id)
+
+    this.messageRepo.deleteMessage({ msgId, deletedAt: this.nowFn() })
+    this.searchService.removeMessage({ msgId })
+
+    return { msgId, channelId, seq: msg.seq }
+  }
+
+  listMessages({ channelId, userId, afterSeq = 0, limit = 50 }) {
+    if (!this.channelService.isMember(channelId, userId)) throw new ServiceError('FORBIDDEN', 'Not a member of channel')
+
+    const rows = this.messageRepo.listMessages({ channelId, afterSeq, limit })
+    const lastSeq = rows.length ? rows[rows.length - 1].seq : afterSeq
+    const messages = this.reactionService
+      ? this.reactionService.enrichWithReactions({ messages: rows, requestingUserId: userId })
+      : rows
+    return { messages, next_after_seq: lastSeq }
+  }
+
+  listLatestMessages({ channelId, userId, limit = 50 }) {
+    if (!this.channelService.isMember(channelId, userId)) throw new ServiceError('FORBIDDEN', 'Not a member of channel')
+    const rows = this.messageRepo.listLatestMessages({ channelId, limit })
+    const messages = this.reactionService
+      ? this.reactionService.enrichWithReactions({ messages: rows, requestingUserId: userId })
+      : rows
+    return { messages }
+  }
+
+  listMessagesBefore({ channelId, userId, beforeSeq, limit = 50 }) {
+    if (!this.channelService.isMember(channelId, userId)) throw new ServiceError('FORBIDDEN', 'Not a member of channel')
+    const rows = this.messageRepo.listMessagesBefore({ channelId, beforeSeq, limit })
+    const hasMore = rows.length === limit
+    const messages = this.reactionService
+      ? this.reactionService.enrichWithReactions({ messages: rows, requestingUserId: userId })
+      : rows
+    return { messages, has_more: hasMore }
+  }
+}

package/src/services/NotificationService.js

@@ -0,0 +1,45 @@
+export class NotificationService {
+  constructor({ deliveryService, authService }) {
+    this.deliveryService = deliveryService
+    this.authService = authService
+  }
+
+  /**
+   * Build the reconnect digest for a user.
+   * Returns { channels, dms } — only entries with unread > 0 or a pending mention.
+   *
+   * @param {string} userId
+   * @param {number} [lastSeenAt] — epoch ms of last session activity; used for away_duration_ms
+   */
+  buildDigest(userId, lastSeenAt = null) {
+    const rows = this.deliveryService.buildDigestData({ userId })
+    const channels = []
+    const dms = []
+
+    for (const row of rows) {
+      const unread = Math.max(0, (row.max_seq ?? 0) - (row.after_seq ?? 0))
+      const hasMention = (row.mention_seq ?? 0) > (row.after_seq ?? 0)
+      if (unread === 0 && !hasMention) continue
+
+      if (row.kind === 'dm') {
+        const other = row.other_user_id ? this.authService.getUser(row.other_user_id) : null
+        dms.push({
+          channel_id: row.channel_id,
+          with_user: { user_id: row.other_user_id, display_name: other?.display_name ?? row.other_user_id },
+          unread,
+        })
+      } else {
+        channels.push({
+          channel_id: row.channel_id,
+          name: row.name,
+          unread,
+          mentions: hasMention ? 1 : 0,
+          urgent: hasMention && row.mention_priority === 'now',
+        })
+      }
+    }
+
+    const away_duration_ms = lastSeenAt ? Math.max(0, Date.now() - lastSeenAt) : null
+    return { channels, dms, away_duration_ms }
+  }
+}