koishi-plugin-chat-patch 5.5.0 → 5.6.0

package/src/gateway.ts

@@ -0,0 +1,259 @@
+import { Context } from 'koishi'
+import { Opcode } from '@satorijs/protocol'
+import {} from '@koishijs/plugin-http'
+import {} from '@koishijs/plugin-server'
+import {} from '@satorijs/plugin-server'
+
+import { Config } from './config'
+import { ChatDatabase } from './database'
+import { PluginLogger } from './logger'
+import { Recorder } from './recorder'
+import { resolveSatoriEndpoint, toSatoriEventUrl } from './satori'
+import { SatoriEventPayload, SatoriLoginInfo } from './types'
+
+const WS_OPEN = 1
+const RECONNECT_MAX_DELAY = 30000
+
+export type SatoriGatewayPayload =
+  | { kind: 'ready'; logins: SatoriLoginInfo[] }
+  | { kind: 'event'; event: SatoriEventPayload }
+  | { kind: 'status'; online: boolean }
+
+type SatoriGatewayHandler = (payload: SatoriGatewayPayload) => void
+
+function getObject(value: unknown): Record<string, unknown> {
+  return typeof value === 'object' && value !== null
+    ? value as Record<string, unknown>
+    : {}
+}
+
+function getString(value: unknown): string {
+  return typeof value === 'string' ? value : ''
+}
+
+function getNumber(value: unknown): number {
+  const num = Number(value)
+  return Number.isFinite(num) ? num : 0
+}
+
+export class SatoriGateway {
+  private socket?: WebSocket
+  private pingDispose?: () => void
+  private reconnectDispose?: () => void
+  private stopped = true
+  private retry = 0
+  private sequence = 0
+  private logins: SatoriLoginInfo[] = []
+  private online = false
+
+  constructor(
+    private ctx: Context,
+    private config: Config,
+    private database: ChatDatabase,
+    private recorder: Recorder,
+    private logger: PluginLogger,
+    private onPayload: SatoriGatewayHandler,
+  ) {}
+
+  async start() {
+    this.stopped = false
+    this.retry = 0
+    this.sequence = await this.loadSequence()
+    this.connect()
+  }
+
+  dispose() {
+    this.stopped = true
+    this.pingDispose?.()
+    this.reconnectDispose?.()
+    this.socket?.close()
+    this.socket = undefined
+    this.setOnline(false)
+  }
+
+  getLogins(): SatoriLoginInfo[] {
+    return this.logins.map((item) => ({ ...item }))
+  }
+
+  private async loadSequence(): Promise<number> {
+    const value = await this.database.getMeta('satori:sn')
+    return getNumber(value)
+  }
+
+  private connect() {
+    if (this.stopped) return
+    let socket: WebSocket
+    try {
+      socket = this.ctx.http.ws(toSatoriEventUrl(resolveSatoriEndpoint(this.ctx)))
+    } catch (error) {
+      this.logger.warn('Satori 连接创建失败:', error)
+      this.scheduleReconnect()
+      return
+    }
+    this.socket = socket
+
+    socket.addEventListener('open', () => {
+      if (this.socket !== socket) {
+        socket.close()
+        return
+      }
+      this.retry = 0
+      this.setOnline(true)
+      socket.send(JSON.stringify({
+        op: Opcode.IDENTIFY,
+        body: {
+          token: this.token,
+          sn: this.sequence || undefined,
+        },
+      }))
+      if (!this.pingDispose) {
+        this.pingDispose = this.ctx.setInterval(() => {
+          if (this.socket?.readyState === WS_OPEN) {
+            this.socket.send(JSON.stringify({ op: Opcode.PING, body: {} }))
+          }
+        }, 10000)
+      }
+    })
+
+    socket.addEventListener('message', (event) => {
+      void this.handleMessage(event.data).catch((error) => {
+        this.logger.warn('Satori 事件处理失败:', error)
+      })
+    })
+
+    socket.addEventListener('close', () => {
+      if (this.socket === socket) this.socket = undefined
+      this.pingDispose?.()
+      this.pingDispose = undefined
+      this.setOnline(false)
+      this.scheduleReconnect()
+    })
+
+    socket.addEventListener('error', () => {
+      socket.close()
+    })
+  }
+
+  private get token(): string {
+    return getString(this.ctx.satori?.server?.config?.token)
+  }
+
+  private scheduleReconnect() {
+    if (this.stopped || this.reconnectDispose) return
+    const delay = Math.min(RECONNECT_MAX_DELAY, 1000 * 2 ** this.retry)
+    this.retry += 1
+    this.logger.logInfo('Satori 将在', delay, 'ms 后重连')
+    this.reconnectDispose = this.ctx.setTimeout(() => {
+      this.reconnectDispose = undefined
+      this.connect()
+    }, delay)
+  }
+
+  private async handleMessage(data: unknown) {
+    let payload: { op?: unknown; body?: unknown }
+    try {
+      payload = JSON.parse(String(data)) as { op?: unknown; body?: unknown }
+    } catch {
+      this.logger.warn('Satori 消息解析失败')
+      return
+    }
+
+    if (payload.op === Opcode.READY) {
+      const body = getObject(payload.body)
+      this.logins = this.normalizeLogins(body.logins)
+      this.onPayload({ kind: 'ready', logins: this.getLogins() })
+      return
+    }
+
+    if (payload.op !== Opcode.EVENT) return
+
+    const body = getObject(payload.body)
+    const sn = getNumber(body.sn)
+    if (sn) {
+      this.sequence = sn
+      void this.database.setMeta('satori:sn', sn).catch((error) => {
+        this.logger.warn('Satori sequence 保存失败:', error)
+      })
+    }
+
+    const type = getString(body.type)
+    if (type === 'login-added' || type === 'login-updated') {
+      const next = this.normalizeLogins([body.login])
+      if (next.length) {
+        this.logins = this.logins.filter((item) => {
+          return !(item.platform === next[0].platform && item.selfId === next[0].selfId)
+        })
+        this.logins.push(next[0])
+        this.onPayload({ kind: 'ready', logins: this.getLogins() })
+      }
+      return
+    }
+    if (type === 'login-removed') {
+      const login = getObject(body.login)
+      const loginUser = getObject(login.user)
+      const platform = getString(body.platform) || getString(login.platform)
+      const selfId = getString(body.self_id) || getString(body.selfId) || getString(loginUser.id)
+      this.logins = this.logins.filter((item) => {
+        return !(item.platform === platform && item.selfId === selfId)
+      })
+      this.onPayload({ kind: 'ready', logins: this.getLogins() })
+      return
+    }
+
+    const login = getObject(body.login)
+    const loginUser = getObject(login.user)
+    const platform = getString(body.platform) || getString(login.platform)
+    const selfId = getString(body.self_id) || getString(body.selfId) || getString(loginUser.id)
+    const event: SatoriEventPayload = {
+      type: getString(body.type),
+      platform,
+      selfId,
+      timestamp: getNumber(body.timestamp) || Date.now(),
+      sn,
+      body,
+    }
+    if (this.isBlocked(platform)) return
+
+    try {
+      await this.recorder.handleEvent(body)
+    } catch (error) {
+      this.logger.warn('Satori 消息写入失败:', error)
+    }
+    this.onPayload({ kind: 'event', event })
+  }
+
+  private normalizeLogins(value: unknown): SatoriLoginInfo[] {
+    if (!Array.isArray(value)) return []
+    const result: SatoriLoginInfo[] = []
+    for (const item of value) {
+      const login = getObject(item)
+      const user = getObject(login.user)
+      const platform = getString(login.platform) || getString(user.platform)
+      const selfId = getString(login.self_id) || getString(login.selfId) || getString(user.id)
+      if (!platform || !selfId || this.isBlocked(platform)) continue
+      result.push({
+        platform,
+        selfId,
+        name: getString(user.name) || getString(user.nick) || getString(user.nickname) || selfId,
+        avatar: getString(user.avatar) || undefined,
+        status: getNumber(login.status),
+        features: Array.isArray(login.features) ? login.features.map(String) : [],
+      })
+    }
+    return result
+  }
+
+  private isBlocked(platform: string): boolean {
+    return (this.config.blockedPlatforms ?? []).some((item) => {
+      return item.exactMatch
+        ? platform === item.platformName
+        : platform.includes(item.platformName)
+    })
+  }
+
+  private setOnline(online: boolean) {
+    if (this.online === online) return
+    this.online = online
+    this.onPayload({ kind: 'status', online })
+  }
+}

package/src/index.ts

@@ -1,69 +1,79 @@
-import { Context } from 'koishi'
-import { Console } from '@koishijs/console'
-import path from 'node:path'
-
-import { Config } from './config'
-import { createPluginLogger } from './logger'
-import { ContactCacheService } from './cache'
-import { ChatDatabase } from './database'
+import { Context } from 'koishi'
+import { Console } from '@koishijs/console'
+import path from 'node:path'
+
+import { Config } from './config'
+import { createPluginLogger } from './logger'
+import { ContactCacheService } from './cache'
+import { ChatDatabase } from './database'
 import { Recorder } from './recorder'
+import { SatoriGateway } from './gateway'
 import { MediaManager } from './media'
 import { SelfMessageRecorder } from './self-message'
 import { registerBootstrap } from './bootstrap'
 import { registerWeb } from './web'
-
-export const name = 'chat-patch'
-export const reusable = false
-export const filter = false
+
+export const name = 'chat-patch'
+export const reusable = false
+export const filter = false
 export const inject = {
-  required: ['console', 'server', 'satori.server'],
+  required: ['console', 'server', 'http', 'satori.server'],
 }
-
-declare module 'koishi' {
-  interface Context {
-    console: Console
-  }
-}
-
-export const usage = `
----
-
-基于 Satori 协议的 Koishi 后台聊天室。
-需要在 Koishi 中启用 server-satori，并在插件内构建 web 应用。
-
----
-`
-
-export { Config } from './config'
-
-export async function apply(ctx: Context, config: Config) {
-  const pluginLogger = createPluginLogger(ctx.logger('chat-patch'), config)
-
-  const database = new ChatDatabase(ctx, config, pluginLogger)
-  await database.initialize()
-  const contactCache = new ContactCacheService(ctx, database, pluginLogger)
-
-  const media = new MediaManager(ctx, config, database, pluginLogger)
-  media.start()
-
-  const recorder = new Recorder(ctx, config, database, media, contactCache, pluginLogger)
-  recorder.start()
+
+declare module 'koishi' {
+  interface Context {
+    console: Console
+  }
+}
+
+export const usage = `
+---
+
+基于 Satori 协议的 Koishi 后台聊天室。
+需要在 Koishi 中启用 server-satori，并在插件内构建 web 应用。
+
+---
+`
+
+export { Config } from './config'
+
+export async function apply(ctx: Context, config: Config) {
+  const pluginLogger = createPluginLogger(ctx.logger('chat-patch'), config)
+
+  const database = new ChatDatabase(ctx, config, pluginLogger)
+  await database.initialize()
+  const contactCache = new ContactCacheService(ctx, database, pluginLogger)
+
+  const media = new MediaManager(ctx, config, database, pluginLogger)
+  media.start()
+
+  const recorder = new Recorder(config, database, media, contactCache, pluginLogger)
+  const gateway = new SatoriGateway(ctx, config, database, recorder, pluginLogger, (payload) => {
+    void ctx.console.broadcast('chat-patch/event', payload).catch((error) => {
+      pluginLogger.warn('推送前端事件失败:', error)
+    })
+  })
 
   const selfMessages = new SelfMessageRecorder(ctx, config, database, media, pluginLogger)
   selfMessages.start()
 
-  registerBootstrap(ctx, config, database, pluginLogger)
-  registerWeb(ctx, config, database, contactCache, media, pluginLogger)
-
-  ctx.console.addEntry({
-    dev: path.resolve(__dirname, '../client/index.ts'),
-    prod: path.resolve(__dirname, '../dist'),
+  void gateway.start().catch((error) => {
+    pluginLogger.warn('Satori 网关启动失败:', error)
   })
 
+  registerBootstrap(ctx, config, database, pluginLogger, () => gateway.getLogins())
+  registerWeb(ctx, config, database, contactCache, media, pluginLogger)
+
+  ctx.console.addEntry({
+    dev: path.resolve(__dirname, '../client/index.ts'),
+    prod: path.resolve(__dirname, '../dist'),
+  })
+
   ctx.on('dispose', async () => {
+    gateway.dispose()
     selfMessages.dispose()
     media.dispose()
-    await database.dispose()
-    pluginLogger.logInfo('chat-patch 已卸载')
-  })
-}
+    await database.dispose()
+    pluginLogger.logInfo('chat-patch 已卸载')
+  })
+}

package/src/recorder.ts

@@ -1,5 +1,3 @@
-import { Context, Session } from 'koishi'
-
 import { Config } from './config'
 import { ContactCacheService } from './cache'
 import { ChatDatabase } from './database'
@@ -9,13 +7,34 @@ import { PluginLogger } from './logger'
 
 const MESSAGE_TYPES = new Set(['message', 'message-created'])
 
+function getObject(value: unknown): Record<string, unknown> {
+  return typeof value === 'object' && value !== null
+    ? value as Record<string, unknown>
+    : {}
+}
+
+function getString(value: unknown): string {
+  return typeof value === 'string' ? value : ''
+}
+
+function getNumber(value: unknown): number {
+  const num = Number(value)
+  return Number.isFinite(num) ? num : 0
+}
+
 function normalizeGroupId(value: string): string {
   return String(value)
 }
 
+function isPrivateChannelType(value: unknown): boolean {
+  const num = Number(value)
+  if (Number.isFinite(num)) return num === 1
+  const text = String(value ?? '').toLowerCase()
+  return text === 'direct' || text === 'private'
+}
+
 export class Recorder {
   constructor(
-    private ctx: Context,
     private config: Config,
     private database: ChatDatabase,
     private media: MediaManager,
@@ -23,16 +42,19 @@ export class Recorder {
     private logger: PluginLogger,
   ) {}
 
-  start() {
-    this.ctx.on('internal/session', (session: Session) => {
-      if (session.type === 'message-deleted') {
-        void this.handleMessageDeleted(session).catch((error) => {
-          this.logger.warn('处理消息撤回失败:', error)
-        })
-        return
-      }
-      void this.handleSession(session)
-    })
+  // 后端直连 Satori 后，由 SatoriGateway 逐条送入原始事件
+  async handleEvent(body: Record<string, unknown>): Promise<boolean> {
+    const type = getString(body.type)
+    const login = getObject(body.login)
+    const platform = getString(body.platform) || getString(login.platform)
+    if (this.isBlocked(platform)) return false
+    if (type === 'message-deleted') {
+      await this.handleMessageDeleted(body)
+      return true
+    }
+    if (!MESSAGE_TYPES.has(type)) return false
+    await this.handleMessageCreated(body)
+    return true
   }
 
   private isBlocked(platform: string): boolean {
@@ -43,28 +65,32 @@ export class Recorder {
     })
   }
 
-  private async handleSession(session: Session) {
-    const platform = session.platform || 'unknown'
-    if (!MESSAGE_TYPES.has(session.type)) return
-    if (this.isBlocked(platform)) return
-
-    const event = session.toJSON()
-    const message = event.message
+  private async handleMessageCreated(body: Record<string, unknown>) {
+    const login = getObject(body.login)
+    const loginUser = getObject(login.user)
+    const platform = getString(body.platform) || getString(login.platform)
+    const selfId = getString(body.self_id) || getString(body.selfId) || getString(loginUser.id)
+    const message = getObject(body.message)
+    const channel = getObject(body.channel)
+    const guild = getObject(body.guild)
+    const user = getObject(body.user)
+    const sn = getNumber(body.sn)
+    const timestamp = getNumber(body.timestamp) || Date.now()
     const record: MessageRecord = {
-      id: message?.id || `local-${event.sn}`,
-      sequence: event.sn,
-      type: session.type,
+      id: getString(message.id) || `satori-${sn}`,
+      sequence: sn,
+      type: getString(body.type),
       platform,
-      selfId: session.selfId,
-      channelId: session.channelId,
-      guildId: session.guildId,
-      userId: session.userId,
-      timestamp: session.timestamp,
-      timestampMs: session.timestamp,
+      selfId,
+      channelId: getString(channel.id) || undefined,
+      guildId: getString(guild.id) || undefined,
+      userId: getString(user.id) || undefined,
+      timestamp,
+      timestampMs: timestamp,
       receivedAt: Date.now(),
-      content: session.content || message?.content,
-      elements: message?.elements as unknown[] | undefined,
-      raw: event,
+      content: getString(message.content) || getString(message.raw_message) || undefined,
+      elements: Array.isArray(message.elements) ? message.elements as unknown[] : undefined,
+      raw: body,
     }
 
     try {
@@ -72,52 +98,51 @@ export class Recorder {
     } catch (error) {
       this.logger.warn('写入历史消息失败:', error)
     }
-    void this.cacheMessageContacts(event).catch((error) => {
+    void this.cacheMessageContacts(body).catch((error) => {
       this.logger.warn('缓存消息联系人失败:', error)
     })
-    void this.cacheMessageMedia(event).catch((error) => {
+    void this.cacheMessageMedia(message, getString(channel.id)).catch((error) => {
       this.logger.warn('异步缓存消息媒体失败:', error)
     })
   }
 
-  private async handleMessageDeleted(session: Session) {
-    const platform = session.platform || 'unknown'
-    if (this.isBlocked(platform)) return
-    const event = session.toJSON()
-    const rawMessage = typeof event.message === 'object' && event.message !== null
-      ? event.message as Record<string, unknown>
-      : {}
-    const messageId = session.messageId || String(rawMessage.id ?? '')
-    const channelId = String(
-      event.channel?.id
-      || event.guild?.id
-      || session.channelId
-      || '',
-    )
+  private async handleMessageDeleted(body: Record<string, unknown>) {
+    const login = getObject(body.login)
+    const loginUser = getObject(login.user)
+    const platform = getString(body.platform) || getString(login.platform)
+    const selfId = getString(body.self_id) || getString(body.selfId) || getString(loginUser.id)
+    const message = getObject(body.message)
+    const channel = getObject(body.channel)
+    const guild = getObject(body.guild)
+    const messageId = getString(message.id)
+    const channelId = getString(channel.id) || getString(guild.id)
     if (!messageId || !channelId) return
     const patch = { revoked: true, revokedAt: Date.now() }
-    await this.database.updateMessageRevoked(platform, session.selfId, channelId, messageId, patch)
-    await this.database.updateSelfMessageByMessageId(platform, session.selfId, channelId, messageId, patch)
+    await this.database.updateMessageRevoked(platform, selfId, channelId, messageId, patch)
+    await this.database.updateSelfMessageByMessageId(platform, selfId, channelId, messageId, patch)
   }
 
-  private async cacheMessageContacts(event: ReturnType<Session['toJSON']>) {
-    const platform = event.platform || ''
-    const selfId = event.selfId || ''
-    const user = event.user
-    const guild = event.guild
-    const channel = event.channel
-    const member = event.member
-    const userId = user?.id || ''
-    const guildId = guild?.id || ''
-    const channelId = channel?.id || ''
-    const channelType = String(channel?.type ?? '')
-    const isPrivateChannel = channelType === '1'
-      || ['direct', 'private'].includes(channelType.toLowerCase())
+  private async cacheMessageContacts(body: Record<string, unknown>) {
+    const login = getObject(body.login)
+    const loginUser = getObject(login.user)
+    const platform = getString(body.platform) || getString(login.platform)
+    const selfId = getString(body.self_id) || getString(body.selfId) || getString(loginUser.id)
+    const user = getObject(body.user)
+    const guild = getObject(body.guild)
+    const channel = getObject(body.channel)
+    const member = getObject(body.member)
+    const userId = getString(user.id)
+    const guildId = getString(guild.id)
+    const channelId = getString(channel.id)
+    const isPrivateChannel = isPrivateChannelType(channel.type)
     const groupId = guildId || (isPrivateChannel ? '' : normalizeGroupId(channelId)) || ''
-    const userName = user?.name || user?.nick || member?.nick || member?.name || ''
-    const userAvatar = user?.avatar || member?.avatar || ''
-    const groupName = guild?.name || channel?.name || ''
-    const groupAvatar = guild?.avatar || ''
+    const userName = getString(user.name)
+      || getString(user.nick)
+      || getString(member.nick)
+      || getString(member.name)
+    const userAvatar = getString(user.avatar) || getString(member.avatar)
+    const groupName = getString(guild.name) || getString(channel.name)
+    const groupAvatar = getString(guild.avatar)
 
     if (groupId) {
       const groupItem = await this.contactCache.getGroup(
@@ -128,7 +153,7 @@ export class Recorder {
         channelId || groupId,
         groupName,
         groupAvatar,
-        channel?.type,
+        channel.type,
       )
       if (userId) {
         const userItem = await this.contactCache.getUser(
@@ -152,9 +177,9 @@ export class Recorder {
               id: userId,
               user_id: userId,
               nickname: userName || userItem?.name,
-              card: member?.nick || member?.name || '',
+              card: member.nick || member.name || '',
               avatar: userItem?.avatar || userAvatar || undefined,
-              role: member?.title || '',
+              role: member.title || '',
             },
           },
         )
@@ -173,12 +198,7 @@ export class Recorder {
     }
   }
 
-  private async cacheMessageMedia(event: ReturnType<Session['toJSON']>) {
-    const channelId = String(
-      event.channel?.id
-      || event.guild?.id
-      || '',
-    )
-    await this.media.cacheMessageMedia(event.message, channelId)
+  private async cacheMessageMedia(message: Record<string, unknown>, channelId: string) {
+    await this.media.cacheMessageMedia(message, channelId)
   }
 }

package/src/satori.ts

@@ -0,0 +1,19 @@
+import { Context } from 'koishi'
+import {} from '@koishijs/plugin-server'
+import {} from '@satorijs/plugin-server'
+
+export function resolveSatoriEndpoint(ctx: Context): string {
+  const url = ctx.satori?.server?.url ?? '/satori'
+  const clean = url.startsWith('undefined') ? url.slice(9) : url
+  if (/^https?:\/\//i.test(clean)) return clean
+  const base = ctx.server?.selfUrl ?? ctx.server?.config?.selfUrl ?? ''
+  return `${base}${clean.startsWith('/') ? clean : `/${clean}`}`
+}
+
+export function toSatoriEventUrl(endpoint: string): string {
+  const url = new URL(endpoint)
+  url.protocol = url.protocol === 'https:' ? 'wss:' : 'ws:'
+  url.pathname = `${url.pathname.replace(/\/+$/, '')}/v1/events`
+  url.search = ''
+  return url.href
+}