@yiarce/dsh-chat 0.0.0-stage → 0.1.1

package/history-client.js

@@ -0,0 +1,109 @@
+import { durableEntry, sessionInfo } from './history-model.js'
+
+export class ChatHistoryClient {
+  constructor({ baseURL, onEvent, onError }) {
+    this.endpoint = new URL('./history', baseURL).href
+    this.onEvent = onEvent; this.onError = onError
+    this.binding = null; this.tail = Promise.resolve(); this.drafts = new Map()
+  }
+  get account() { return this.binding?.account }
+  get client() { return this.binding?.client }
+  get ready() { return Boolean(this.binding?.ready) }
+  receive(binding, event) {
+    if (this.binding !== binding || event.account !== binding.account) return
+    if (event.type === 'snapshot') {
+      // A plugin restart can reset an EventSource connection; snapshots repair gaps.
+      binding.revision = event.revision; binding.ready = true; binding.reportedError = false
+      this.onEvent(event)
+      binding.resolve?.(); binding.resolve = null
+    } else if (!binding.seen.has(event.revision)) {
+      binding.seen.add(event.revision)
+      if (binding.seen.size > 4096) binding.seen.delete(binding.seen.values().next().value)
+      binding.revision = Math.max(binding.revision, event.revision); this.onEvent(event)
+    }
+  }
+  async open(userId, server) {
+    const account = JSON.stringify([server, String(userId)])
+    if (this.binding?.account === account) return this.binding.ready ? undefined : this.binding.initialized
+    this.close()
+    const binding = { account, client: crypto.randomUUID(), revision: -1, ready: false, seen: new Set() }
+    this.binding = binding
+    binding.initialized = new Promise((resolve, reject) => { binding.resolve = resolve; binding.reject = reject })
+    binding.initialized.catch(() => {})
+    const url = new URL(this.endpoint + '/events')
+    url.searchParams.set('account', account); url.searchParams.set('client', binding.client)
+    const stream = binding.stream = new EventSource(url, { withCredentials: true })
+    const timeout = setTimeout(() => {
+      if (!binding.ready) { binding.reject?.(new Error('无法读取聊天记录，请检查插件存储服务')); binding.reject = null }
+    }, 10000)
+    binding.timer = timeout
+    stream.onmessage = event => {
+      try { this.receive(binding, JSON.parse(event.data)); if (binding.ready) clearTimeout(timeout) }
+      catch (error) { this.onError(error) }
+    }
+    stream.onerror = () => {
+      if (this.binding === binding && !binding.reportedError) { binding.reportedError = true; this.onError(new Error('聊天记录同步连接中断，正在重新连接')) }
+    }
+    return binding.initialized
+  }
+  request(action, fields = {}, binding = this.binding, keepalive = false) {
+    if (!binding) return Promise.reject(new Error('聊天记录尚未绑定账号'))
+    // Capture values now; queued writes must never inherit another account/draft.
+    const body = JSON.stringify({ action, account: binding.account, client: binding.client, ...fields })
+    const operation = async () => {
+      const response = await fetch(this.endpoint, { method: 'POST', credentials: 'same-origin', cache: 'no-store',
+        headers: { 'Content-Type': 'application/json' }, body, keepalive, signal: AbortSignal.timeout(15000) })
+      const data = await response.json()
+      if (!response.ok) throw new Error(data.error || '聊天记录保存失败')
+      if (data.event) this.receive(binding, data.event)
+      return data
+    }
+    const result = this.tail.then(operation)
+    this.tail = result.catch(() => {})
+    return result
+  }
+  put(item, entry, options = {}) {
+    return this.request('put', { key: item.key, session: sessionInfo(item), entry: durableEntry(entry), ...options })
+  }
+  session(item) { return this.request('session', { key: item.key, session: sessionInfo(item) }) }
+  recent(key) { return this.request('recent', { key }) }
+  async *sync(key, ids) {
+    const batches = []; let batch = [], length = 0
+    for (const id of ids) {
+      if (batch.length && (batch.length >= 100 || length + id.length > 12000)) { batches.push(batch); batch = []; length = 0 }
+      batch.push(id); length += id.length
+    }
+    if (batch.length || !batches.length) batches.push(batch)
+    for (let index = 0; index < batches.length; index++) yield await this.request('sync', { key, ids: batches[index], includeRecent: index === 0 })
+  }
+  read(key) { return this.request('read', { key }) }
+  change(action, key, id) { return this.request(action, { key, id }) }
+  contacts() { return this.request('contacts') }
+  contact(userId, relation, profile = {}) { return this.request('contact', { userId, relation, nickname: profile.nickname, avatar: profile.avatar }) }
+  requestFriend(fields) { return this.request('request', fields) }
+  dirty(key) { return this.drafts.get(key)?.binding === this.binding }
+  draft(key, text) {
+    if (!this.binding) return
+    const previous = this.drafts.get(key); clearTimeout(previous?.timer)
+    const value = { text, binding: this.binding }
+    value.timer = setTimeout(() => { void this.flushDraft(key).catch(this.onError) }, 250)
+    this.drafts.set(key, value)
+  }
+  cancelDraft(key) { const value = this.drafts.get(key); clearTimeout(value?.timer); this.drafts.delete(key) }
+  async flushDraft(key, keepalive = false) {
+    const value = this.drafts.get(key)
+    if (!value) return
+    clearTimeout(value.timer)
+    await this.request('draft', { key, draft: value.text }, value.binding, keepalive)
+    if (this.drafts.get(key) === value) this.drafts.delete(key)
+  }
+  close() {
+    const binding = this.binding
+    if (!binding) return
+    for (const key of this.drafts.keys()) void this.flushDraft(key, true).catch(this.onError)
+    binding.stream.close(); clearTimeout(binding.timer)
+    binding.reject?.(new Error('聊天记录账号已切换')); binding.reject = null
+    void this.request('end-client', {}, binding, true).catch(this.onError)
+    this.binding = null
+  }
+}

package/history-host.js

@@ -0,0 +1,86 @@
+import { ChatHistoryStore } from './history-store.js'
+
+export function registerHistory(ctx) {
+  let store, storageError, disposed = false
+  const life = new AbortController(), disconnects = new Map(), streams = new Map()
+  try { store = new ChatHistoryStore() } catch (error) { storageError = error }
+  const json = (value, status = 200) => Response.json(value, { status, headers: { 'Cache-Control': 'no-store' } })
+  const requireStore = () => { if (!store || disposed) throw new Error('聊天记录数据库不可用：' + (storageError?.message || '服务已关闭')); return store }
+  const identity = input => {
+    if (typeof input.account !== 'string' || input.account.length > 1200 || typeof input.client !== 'string' || !/^[\w-]{1,100}$/.test(input.client)) throw new Error('存储请求标识无效')
+    // list() validates the account structure without trusting it as a path.
+    const account = JSON.parse(input.account)
+    if (!Array.isArray(account) || account.length !== 2 || account.some(value => typeof value !== 'string' || !value || value.length > 512)) throw new Error('账号标识无效')
+    return input
+  }
+  ctx.effect(() => () => {
+    disposed = true; life.abort()
+    for (const timer of disconnects.values()) clearTimeout(timer)
+    disconnects.clear(); store?.close()
+  })
+  ctx.effect(() => ctx.connection.fetch.register({
+    path: '/api/yiarce-chat/history', methods: ['POST'], requestBody: 'streaming',
+    async fetch(request) {
+      try {
+        let bytes = 0; const chunks = []
+        for await (const chunk of request.body || []) {
+          bytes += chunk.byteLength
+          if (bytes > 64 * 1024) return json({ error: '存储请求过大' }, 413)
+          chunks.push(Buffer.from(chunk))
+        }
+        const input = identity(JSON.parse(Buffer.concat(chunks).toString())), db = requireStore()
+        const { account, client } = input
+        if (input.action === 'list') return json({ sessions: db.list(account), revision: db.revision() })
+        if (input.action === 'sync') return json(db.sync(account, input.key, input.ids, input.includeRecent))
+        if (input.action === 'recent') return json({ entries: db.recent(account, input.key), revision: db.revision() })
+        if (input.action === 'put') return json(db.put(account, client, input))
+        if (input.action === 'end-client') { db.endClient(account, client); return json({ ok: true }) }
+        return json(db.change(account, client, input))
+      } catch (error) { return json({ error: '聊天记录保存或读取失败：' + error.message }, 503) }
+    },
+  }))
+  ctx.effect(() => ctx.connection.fetch.register({
+    path: '/api/yiarce-chat/history/events', methods: ['GET'], requestBody: 'buffered',
+    async fetch(request) {
+      try {
+        const url = new URL(request.url)
+        const { account, client } = identity({ account: url.searchParams.get('account'), client: url.searchParams.get('client') })
+        const db = requireStore(), key = JSON.stringify([account, client])
+        clearTimeout(disconnects.get(key)); disconnects.delete(key)
+        streams.set(key, (streams.get(key) || 0) + 1)
+        const encoder = new TextEncoder()
+        let close = () => {}
+        const body = new ReadableStream({
+          start(output) {
+            let closed = false, unsubscribe = () => {}, heartbeat
+            close = () => {
+              if (closed) return
+              closed = true; unsubscribe(); clearInterval(heartbeat)
+              request.signal.removeEventListener('abort', close); life.signal.removeEventListener('abort', close)
+              try { output.close() } catch {}
+              const count = (streams.get(key) || 1) - 1
+              if (count) streams.set(key, count); else streams.delete(key)
+              if (!disposed && !count) {
+                const timer = setTimeout(() => {
+                  disconnects.delete(key)
+                  if (!disposed && !streams.has(key)) try { db.endClient(account, client) } catch {}
+                }, 3000)
+                timer.unref?.(); disconnects.set(key, timer)
+              }
+            }
+            const push = value => { if (!closed) try { output.enqueue(encoder.encode('data: ' + JSON.stringify(value) + '\n\n')) } catch { close() } }
+            request.signal.addEventListener('abort', close, { once: true }); life.signal.addEventListener('abort', close, { once: true })
+            if (request.signal.aborted || life.signal.aborted) { close(); return }
+            const sessions = db.list(account), contacts = db.contacts(account), requests = db.requests(account)
+            unsubscribe = db.subscribe(event => { if (event.account === account) push(event) })
+            push({ type: 'snapshot', account, sessions, contacts, requests, revision: db.revision() })
+            heartbeat = setInterval(() => { if (!closed) try { output.enqueue(encoder.encode(': heartbeat\n\n')) } catch { close() } }, 15000)
+            heartbeat.unref?.()
+          },
+          cancel() { close() },
+        })
+        return new Response(body, { headers: { 'Content-Type': 'text/event-stream', 'Cache-Control': 'no-store', 'X-Accel-Buffering': 'no' } })
+      } catch (error) { return json({ error: '聊天记录读取失败：' + error.message }, 503) }
+    },
+  }))
+}

package/history-model.js

@@ -0,0 +1,20 @@
+// Stable identifiers are shared by the browser and the SQLite service.
+export function entryId(message) {
+  if (message.clientMessageId) return 'client:' + message.fromUserId + ':' + message.clientMessageId
+  let image = message.sticker?.url || ''
+  try { if (image) image = new URL(image).href } catch {}
+  return 'server:' + JSON.stringify([message.seq || 0, message.fromUserId, message.toUserId || '', message.roomId || 0, message.sentAtMs || 0, message.content || '', image])
+}
+export function durableEntry(entry) {
+  const source = entry.message
+  const message = { ...source }
+  const url = source.sticker?.url
+  if (url && /^https?:\/\//.test(url)) message.sticker = { url }
+  else delete message.sticker
+  return { id: entry.id || entryId(source), message,
+    sendStatus: entry.sendStatus || 'sent', sendError: entry.sendError || '',
+    imagePending: Boolean(entry.imagePending || (entry.localImage && !message.sticker)) }
+}
+export function sessionInfo(item) {
+  return { key: item.key, kind: item.kind, id: String(item.id), name: item.name, avatar: item.avatar || '' }
+}

package/history-store.js

@@ -0,0 +1,238 @@
+import { DatabaseSync } from 'node:sqlite'
+import { mkdirSync } from 'node:fs'
+import { homedir } from 'node:os'
+import { join } from 'node:path'
+import { createHash } from 'node:crypto'
+import { entryId } from './history-model.js'
+
+function storagePath() {
+  let home = (process.env.DSH_HOME || '').trim() || join(homedir(), '.dsh')
+  if (home === '~') home = homedir()
+  else if (/^~[\\/]/.test(home)) home = join(homedir(), home.slice(2))
+  const profile = process.env.DSH_PROFILE_DIR || process.env.DSH_PROFILE || 'default'
+  const folder = join(home, 'yiarce-chat', createHash('sha256').update(profile).digest('hex').slice(0, 24))
+  mkdirSync(folder, { recursive: true })
+  return join(folder, 'history.sqlite')
+}
+const text = (value, max = 256) => typeof value === 'string' ? value.slice(0, max) : ''
+function roomKey(key) {
+  if (typeof key !== 'string' || key.length > 512 || !/^(room|private):[^\r\n]+$/.test(key)) throw new Error('会话标识无效')
+  return key
+}
+function accountId(account) {
+  let identity
+  try { identity = JSON.parse(account) } catch { throw new Error('账号标识无效') }
+  if (!Array.isArray(identity) || identity.length !== 2 || identity.some(value => typeof value !== 'string' || !value || value.length > 512)) throw new Error('账号标识无效')
+  return identity[1]
+}
+function cleanEntry(input, key, user) {
+  const source = input?.message
+  if (!source || typeof source !== 'object' || !text(source.fromUserId)) throw new Error('消息格式无效')
+  const message = {
+    fromUserId: text(source.fromUserId), fromNickname: text(source.fromNickname), fromAvatar: text(source.fromAvatar, 2048),
+    toUserId: text(source.toUserId), roomId: Number(source.roomId) || 0,
+    privateMsg: key.startsWith('private:'), content: text(source.content, 2000),
+    sentAtMs: Number(source.sentAtMs) || Date.now(), seq: Number(source.seq) || 0,
+    clientMessageId: text(source.clientMessageId),
+  }
+  if (source.sticker?.url) {
+    const url = new URL(source.sticker.url)
+    if (!['http:', 'https:'].includes(url.protocol) || url.username || url.password || url.href.length > 2048) throw new Error('图片地址无效')
+    message.sticker = { url: url.href }
+  }
+  const id = entryId(message)
+  if (input.id && input.id !== id) throw new Error('消息标识不一致')
+  const status = message.fromUserId !== user ? 'sent' : ['uploading', 'sending', 'sent', 'failed'].includes(input.sendStatus) ? input.sendStatus : 'sent'
+  return { id, message, sendStatus: status, sendError: text(input.sendError, 500), imagePending: Boolean(input.imagePending && !message.sticker) }
+}
+export class ChatHistoryStore {
+  constructor() {
+    this.db = new DatabaseSync(storagePath())
+    this.listeners = new Set()
+    this.db.exec(`
+      PRAGMA journal_mode=WAL;
+      PRAGMA foreign_keys=ON;
+      PRAGMA busy_timeout=5000;
+      CREATE TABLE IF NOT EXISTS history_meta (name TEXT PRIMARY KEY, value INTEGER NOT NULL);
+      INSERT OR IGNORE INTO history_meta VALUES ('revision', 0);
+      CREATE TABLE IF NOT EXISTS sessions (
+        account TEXT NOT NULL, session_key TEXT NOT NULL, kind TEXT NOT NULL, peer_id TEXT NOT NULL,
+        name TEXT NOT NULL, avatar TEXT NOT NULL DEFAULT '', preview TEXT NOT NULL DEFAULT '',
+        updated INTEGER NOT NULL DEFAULT 0, unread INTEGER NOT NULL DEFAULT 0, draft TEXT NOT NULL DEFAULT '',
+        PRIMARY KEY (account, session_key)
+      );
+      CREATE TABLE IF NOT EXISTS messages (
+        ordinal INTEGER PRIMARY KEY AUTOINCREMENT, account TEXT NOT NULL, session_key TEXT NOT NULL,
+        message_id TEXT NOT NULL, payload TEXT NOT NULL, status TEXT NOT NULL, error TEXT NOT NULL DEFAULT '',
+        image_pending INTEGER NOT NULL DEFAULT 0, owner TEXT NOT NULL DEFAULT '', revision INTEGER NOT NULL,
+        UNIQUE(account, session_key, message_id)
+      );
+      CREATE INDEX IF NOT EXISTS messages_recent ON messages(account, session_key, ordinal DESC);
+      CREATE TABLE IF NOT EXISTS message_tombstones (
+        account TEXT NOT NULL, session_key TEXT NOT NULL, message_id TEXT NOT NULL,
+        PRIMARY KEY(account, session_key, message_id)
+      );
+      CREATE TABLE IF NOT EXISTS contacts (
+        account TEXT NOT NULL, user_id TEXT NOT NULL, nickname TEXT NOT NULL DEFAULT '', avatar TEXT NOT NULL DEFAULT '',
+        relation TEXT NOT NULL, created INTEGER NOT NULL, updated INTEGER NOT NULL,
+        PRIMARY KEY(account, user_id)
+      );
+      CREATE TABLE IF NOT EXISTS friend_requests (
+        account TEXT NOT NULL, request_id TEXT NOT NULL, peer_id TEXT NOT NULL, direction TEXT NOT NULL,
+        status TEXT NOT NULL, nickname TEXT NOT NULL DEFAULT '', avatar TEXT NOT NULL DEFAULT '',
+        created INTEGER NOT NULL, updated INTEGER NOT NULL,
+        PRIMARY KEY(account, request_id)
+      );
+      CREATE INDEX IF NOT EXISTS friend_requests_peer ON friend_requests(account, peer_id, updated DESC);
+      UPDATE messages SET error=CASE WHEN status='uploading' THEN '图片上传未完成' ELSE '发送未完成，未自动重发' END,
+        status='failed' WHERE status IN ('uploading','sending');
+    `)
+  }
+  revision() { return this.db.prepare("SELECT value FROM history_meta WHERE name='revision'").get().value }
+  nextRevision() { this.db.prepare("UPDATE history_meta SET value=value+1 WHERE name='revision'").run(); return this.revision() }
+  transaction(work) {
+    this.db.exec('BEGIN IMMEDIATE')
+    try { const result = work(); this.db.exec('COMMIT'); return result } catch (error) { this.db.exec('ROLLBACK'); throw error }
+  }
+  emit(event, client) {
+    event.client = client
+    for (const listener of this.listeners) { try { listener(event) } catch {} }
+    return event
+  }
+  subscribe(listener) { this.listeners.add(listener); return () => this.listeners.delete(listener) }
+  session(account, key) {
+    const row = this.db.prepare(`SELECT s.*, (SELECT COUNT(*) FROM messages m WHERE m.account=s.account AND m.session_key=s.session_key) AS message_count
+      FROM sessions s WHERE account=? AND session_key=?`).get(account, key)
+    return row ? { key: row.session_key, kind: row.kind, id: row.peer_id, name: row.name, avatar: row.avatar,
+      preview: row.preview, updated: row.updated, unread: row.unread, draft: row.draft, messageCount: row.message_count } : null
+  }
+  ensureSession(account, info) {
+    const key = roomKey(info.key), kind = key.startsWith('room:') ? 'room' : 'private', id = key.slice(key.indexOf(':') + 1)
+    const oldName = this.db.prepare('SELECT name FROM sessions WHERE account=? AND session_key=?').get(account, key)?.name
+    this.db.prepare(`INSERT INTO sessions(account,session_key,kind,peer_id,name,avatar) VALUES (?,?,?,?,?,?)
+      ON CONFLICT(account,session_key) DO UPDATE SET name=CASE WHEN excluded.name<>'' THEN excluded.name ELSE sessions.name END,
+      avatar=CASE WHEN excluded.avatar<>'' THEN excluded.avatar ELSE sessions.avatar END`).run(account, key, kind, id,
+        key === 'room:1' ? '广场' : text(info.name) || oldName || (kind === 'room' ? id + ' 号房' : id), text(info.avatar, 2048))
+  }
+  list(account) {
+    accountId(account)
+    this.ensureSession(account, { key: 'room:1', name: '广场' })
+    return this.db.prepare('SELECT session_key FROM sessions WHERE account=? ORDER BY updated DESC').all(account).map(row => this.session(account, row.session_key))
+  }
+  entry(row) {
+    return { id: row.message_id, order: row.ordinal, message: JSON.parse(row.payload), sendStatus: row.status, sendError: row.error, imagePending: Boolean(row.image_pending), revision: row.revision }
+  }
+  contacts(account) {
+    accountId(account)
+    return this.db.prepare('SELECT user_id AS userId,nickname,avatar,relation,created,updated FROM contacts WHERE account=? ORDER BY updated DESC').all(account)
+  }
+  requests(account) {
+    accountId(account)
+    return this.db.prepare('SELECT request_id AS requestId,peer_id AS peerId,direction,status,nickname,avatar,created,updated FROM friend_requests WHERE account=? ORDER BY updated DESC').all(account)
+  }
+  sync(account, key, ids, includeRecent) {
+    accountId(account); roomKey(key)
+    if (!Array.isArray(ids) || ids.length > 100 || ids.some(id => typeof id !== 'string' || id.length > 8192)) throw new Error('同步消息标识无效')
+    const query = this.db.prepare('SELECT * FROM messages WHERE account=? AND session_key=? AND message_id=?')
+    return { requested: ids, entries: ids.map(id => query.get(account, key, id)).filter(Boolean).map(row => this.entry(row)),
+      recent: includeRecent ? this.recent(account, key) : [], revision: this.revision() }
+  }
+  recent(account, key) {
+    accountId(account); roomKey(key)
+    return this.db.prepare('SELECT * FROM messages WHERE account=? AND session_key=? ORDER BY ordinal DESC LIMIT 50').all(account, key).reverse().map(row => this.entry(row))
+  }
+  refreshPreview(account, key) {
+    const row = this.db.prepare('SELECT * FROM messages WHERE account=? AND session_key=? ORDER BY ordinal DESC LIMIT 1').get(account, key)
+    if (!row) { this.db.prepare("UPDATE sessions SET preview='',updated=0 WHERE account=? AND session_key=?").run(account, key); return }
+    const m = JSON.parse(row.payload), mine = m.fromUserId === accountId(account)
+    const preview = (mine ? '我: ' : key.startsWith('room:') ? (m.fromNickname || m.fromUserId) + ': ' : '') +
+      (m.sticker || row.image_pending ? '[图片]' + (m.content ? ' ' + m.content : '') : m.content || '')
+    this.db.prepare('UPDATE sessions SET preview=?,updated=? WHERE account=? AND session_key=?').run(preview, m.sentAtMs, account, key)
+  }
+  put(account, client, input) {
+    const user = accountId(account), key = roomKey(input.key), entry = cleanEntry(input.entry, key, user)
+    if (this.db.prepare('SELECT 1 FROM message_tombstones WHERE account=? AND session_key=? AND message_id=?').get(account, key, entry.id)) return { ignored: true }
+    const previous = this.db.prepare('SELECT * FROM messages WHERE account=? AND session_key=? AND message_id=?').get(account, key, entry.id)
+    if (previous && (previous.status === 'sent' && entry.sendStatus !== 'sent' || previous.payload === JSON.stringify(entry.message) && previous.status === entry.sendStatus && previous.error === entry.sendError && Boolean(previous.image_pending) === entry.imagePending)) return { entry: this.entry(previous), session: this.session(account, key), revision: this.revision() }
+    const event = this.transaction(() => {
+      this.ensureSession(account, { ...input.session, key })
+      const revision = this.nextRevision()
+      this.db.prepare(`INSERT INTO messages(account,session_key,message_id,payload,status,error,image_pending,owner,revision) VALUES (?,?,?,?,?,?,?,?,?)
+        ON CONFLICT(account,session_key,message_id) DO UPDATE SET payload=excluded.payload,status=excluded.status,error=excluded.error,image_pending=excluded.image_pending,revision=excluded.revision`).run(
+          account, key, entry.id, JSON.stringify(entry.message), entry.sendStatus, entry.sendError, Number(entry.imagePending), client, revision)
+      if (!previous && !input.read && entry.message.fromUserId !== user) this.db.prepare('UPDATE sessions SET unread=unread+1 WHERE account=? AND session_key=?').run(account, key)
+      if (input.read) this.db.prepare('UPDATE sessions SET unread=0 WHERE account=? AND session_key=?').run(account, key)
+      if (input.clearDraft) this.db.prepare("UPDATE sessions SET draft='' WHERE account=? AND session_key=?").run(account, key)
+      this.refreshPreview(account, key)
+      return { type: 'message', account, key, entry: this.entry(this.db.prepare('SELECT * FROM messages WHERE account=? AND session_key=? AND message_id=?').get(account, key, entry.id)), session: this.session(account, key), revision }
+    })
+    return { event: this.emit(event, client), entry: event.entry, session: event.session, revision: event.revision }
+  }
+  change(account, client, input) {
+    if (input.action === 'contacts') return { contacts: this.contacts(account), requests: this.requests(account), revision: this.revision() }
+    if (input.action === 'contact' || input.action === 'request') return this.changeRelation(account, client, input)
+    accountId(account)
+    const key = roomKey(input.key)
+    if (input.action === 'remove' && key === 'room:1') throw new Error('广场不能移除')
+    const event = this.transaction(() => {
+      const revision = this.nextRevision()
+      let pendingIds = []
+      if (input.action === 'session') this.ensureSession(account, { ...input.session, key })
+      else if (input.action === 'draft') this.db.prepare('UPDATE sessions SET draft=? WHERE account=? AND session_key=?').run(text(input.draft, 2000), account, key)
+      else if (input.action === 'read') this.db.prepare('UPDATE sessions SET unread=0 WHERE account=? AND session_key=?').run(account, key)
+      else if (input.action === 'delete') {
+        const id = text(input.id, 8192)
+        if (!id) throw new Error('消息标识无效')
+        this.db.prepare('INSERT OR IGNORE INTO message_tombstones VALUES (?,?,?)').run(account, key, id)
+        this.db.prepare('DELETE FROM messages WHERE account=? AND session_key=? AND message_id=?').run(account, key, id)
+        this.refreshPreview(account, key)
+      } else if (input.action === 'clear' || input.action === 'remove') {
+        pendingIds = this.db.prepare("SELECT message_id FROM messages WHERE account=? AND session_key=? AND status IN ('uploading','sending')").all(account, key).map(row => row.message_id)
+        this.db.prepare('INSERT OR IGNORE INTO message_tombstones SELECT account,session_key,message_id FROM messages WHERE account=? AND session_key=?').run(account, key)
+        this.db.prepare('DELETE FROM messages WHERE account=? AND session_key=?').run(account, key)
+        this.db.prepare("UPDATE sessions SET preview='',updated=0,unread=0 WHERE account=? AND session_key=?").run(account, key)
+        if (input.action === 'remove') this.db.prepare('DELETE FROM sessions WHERE account=? AND session_key=?').run(account, key)
+      } else throw new Error('存储操作无效')
+      return { type: input.action, account, key, id: input.id, pendingIds, session: this.session(account, key), revision }
+    })
+    return { event: this.emit(event, client) }
+  }
+  changeRelation(account, client, input) {
+    const now = Date.now(), id = text(input.userId || input.peerId, 512), action = input.action
+    if (!id) throw new Error('用户标识无效')
+    const event = this.transaction(() => {
+      const revision = this.nextRevision()
+      if (action === 'contact') {
+        const relation = ['friend', 'blocked', 'none'].includes(input.relation) ? input.relation : ''
+        if (!relation) throw new Error('联系人关系无效')
+        if (relation === 'none') this.db.prepare('DELETE FROM contacts WHERE account=? AND user_id=?').run(account, id)
+        else this.db.prepare(`INSERT INTO contacts(account,user_id,nickname,avatar,relation,created,updated) VALUES (?,?,?,?,?,?,?)
+          ON CONFLICT(account,user_id) DO UPDATE SET nickname=CASE WHEN excluded.nickname<>'' THEN excluded.nickname ELSE contacts.nickname END,
+          avatar=CASE WHEN excluded.avatar<>'' THEN excluded.avatar ELSE contacts.avatar END,relation=excluded.relation,updated=excluded.updated`).run(account,id,text(input.nickname),text(input.avatar,2048),relation,now,now)
+      } else {
+        const requestId = text(input.requestId, 200); const peerId = text(input.peerId || id, 512)
+        if (!requestId) throw new Error('申请标识无效')
+        const status = ['pending','accepted','rejected','released'].includes(input.status) ? input.status : ''
+        const direction = input.direction === 'incoming' ? 'incoming' : 'outgoing'
+        if (!status) throw new Error('申请状态无效')
+        this.db.prepare(`INSERT INTO friend_requests(account,request_id,peer_id,direction,status,nickname,avatar,created,updated) VALUES (?,?,?,?,?,?,?,?,?)
+          ON CONFLICT(account,request_id) DO UPDATE SET status=excluded.status,nickname=CASE WHEN excluded.nickname<>'' THEN excluded.nickname ELSE friend_requests.nickname END,
+          avatar=CASE WHEN excluded.avatar<>'' THEN excluded.avatar ELSE friend_requests.avatar END,updated=excluded.updated`).run(account,requestId,peerId,direction,status,text(input.nickname),text(input.avatar,2048),Number(input.created)||now,now)
+        if (status === 'accepted') this.db.prepare(`INSERT INTO contacts(account,user_id,nickname,avatar,relation,created,updated) VALUES (?,?,?,?,?,?,?)
+          ON CONFLICT(account,user_id) DO UPDATE SET relation='friend',updated=excluded.updated`).run(account,peerId,text(input.nickname),text(input.avatar,2048),'friend',now,now)
+      }
+      return { type: action, account, userId: id, requestId: input.requestId, relation: input.relation, status: input.status, contacts: this.contacts(account), requests: this.requests(account), revision }
+    })
+    return { event: this.emit(event, client), contacts: event.contacts, requests: event.requests }
+  }
+  endClient(account, client) {
+    const rows = this.db.prepare("SELECT * FROM messages WHERE account=? AND owner=? AND status IN ('uploading','sending')").all(account, client)
+    for (const row of rows) {
+      const entry = this.entry(row)
+      entry.sendError = entry.sendStatus === 'uploading' ? '图片上传未完成' : '发送未完成，未自动重发'
+      entry.sendStatus = 'failed'
+      this.put(account, client, { key: row.session_key, entry })
+    }
+  }
+  close() { this.listeners.clear(); this.db.close() }
+}

package/host.js

@@ -0,0 +1,67 @@
+import { registerHistory } from "./history-host.js"
+import { registerMedia } from "./media.js"
+import { readFileSync } from 'node:fs'
+import { AccountService, profileCredentialKey } from './login.js'
+
+export const name = '@yiarce/dsh-chat'
+export const inject = ['credentials', 'connection']
+
+export function apply(ctx) {
+  registerMedia(ctx)
+  registerHistory(ctx)
+  const key = profileCredentialKey(process.env.DSH_PROFILE_DIR || process.env.DSH_PROFILE || 'default')
+  const service = new AccountService(ctx.credentials, { key })
+  const restored = service.restore()
+  ctx.effect(() => () => service.dispose())
+  const json = (value, status = 200) => Response.json(value, { status, headers: { 'Cache-Control': 'no-store' } })
+  const assets = [
+    ["history-client.js", "history-client.js", "text/javascript; charset=utf-8"],
+    ["history-model.js", "history-model.js", "text/javascript; charset=utf-8"],
+    ["window-client.js", "window-client.js", "text/javascript; charset=utf-8"],
+    ["media-client.js", "media-client.js", "text/javascript; charset=utf-8"],
+    ["standalone.js", "standalone.js", "text/javascript; charset=utf-8"],
+    ["appearance.js", "appearance.js", "text/javascript; charset=utf-8"],
+    ["context-menu.js", "context-menu.js", "text/javascript; charset=utf-8"],
+    ['page', 'chat.html', 'text/html; charset=utf-8'],
+    ['page.js', 'page.js', 'text/javascript; charset=utf-8'],
+    ['page.css', 'page.css', 'text/css; charset=utf-8'],
+  ]
+  for (const [path, file, type] of assets) {
+    const body = readFileSync(new URL(file, import.meta.url))
+    ctx.effect(() => ctx.connection.fetch.register({
+      path: '/api/yiarce-chat/' + path, methods: ['GET'], requestBody: 'buffered',
+      fetch: () => new Response(body, { headers: { 'Content-Type': type, 'Cache-Control': 'no-store', 'Referrer-Policy': 'no-referrer' } }),
+    }))
+  }
+  ctx.effect(() => ctx.connection.fetch.register({
+    path: '/api/yiarce-chat/login', methods: ['GET', 'POST'], requestBody: 'buffered',
+    async fetch(request) {
+      try {
+        await restored
+        if (request.method === 'GET') return json(service.view())
+        let input
+        try { input = await request.json() } catch { return json({ error: 'invalid-request' }, 400) }
+        switch (input?.action) {
+          case 'begin': return json(service.beginSignIn())
+          case 'cancel':
+            if (typeof input.id !== 'string' || !input.id) return json({ error: 'invalid-request' }, 400)
+            return json(service.cancelAttempt(input.id))
+          case 'restore': return json(await service.restore())
+          case 'credential': {
+            const { token } = await service.chatCredential()
+            const server = new URL(process.env.CHAT_SERVER || 'http://101.35.239.136:34119')
+            if (!['http:', 'https:', 'ws:', 'wss:'].includes(server.protocol) || server.username || server.password) throw new Error('invalid-server')
+            server.protocol = ['https:', 'wss:'].includes(server.protocol) ? 'wss:' : 'ws:'
+            server.pathname = server.pathname.replace(/\/$/, '') + '/ws'
+            server.search = ''; server.hash = ''
+            server.searchParams.set('token', token)
+            return json({ wsUrl: server.href })
+          }
+          default: return json({ error: 'invalid-request' }, 400)
+        }
+      } catch (error) {
+        return json({ error: error.code || error.message || 'storage' }, error.code === 'auth-expired' ? 401 : 503)
+      }
+    },
+  }))
+}