koishi-plugin-chat-patch 3.0.2 → 5.0.0

package/src/index.ts

@@ -1,20 +1,22 @@
-
+import { Context } from 'koishi'
 import { Console } from '@koishijs/console'
-import { Context, h } from 'koishi'
 import path from 'node:path'
 
-import { MessageHandler } from './message-handler'
-import { FileManager } from './file-manager'
-import { ApiHandlers } from './api-handlers'
 import { Config } from './config'
 import { createPluginLogger } from './logger'
-import { Utils } from './utils'
+import { ContactCacheService } from './cache'
+import { ChatDatabase } from './database'
+import { Recorder } from './recorder'
+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 = true
+export const filter = false
 export const inject = {
-  required: ['console']
+  required: ['console', 'server', 'satori.server'],
 }
 
 declare module 'koishi' {
@@ -24,12 +26,10 @@ declare module 'koishi' {
 }
 
 export const usage = `
-
 ---
 
-开启后，即可在koishi控制台操作机器人收发消息啦
-
-暂时只支持接受图文消息 / 发送文字消息
+基于 Satori 协议的 Koishi 后台聊天室。
+需要在 Koishi 中启用 server-satori，并在插件内构建 web 应用。
 
 ---
 `
@@ -39,52 +39,21 @@ export { Config } from './config'
 export async function apply(ctx: Context, config: Config) {
   const pluginLogger = createPluginLogger(ctx.logger('chat-patch'), config)
 
-  const fileManager = new FileManager(ctx, config, pluginLogger)
-  await fileManager.initialize()
-
-  const messageHandler = new MessageHandler(ctx, config, fileManager, pluginLogger)
-  const apiHandlers = new ApiHandlers(ctx, config, fileManager, messageHandler, pluginLogger)
-  const utils = new Utils(config, ctx)
+  const database = new ChatDatabase(ctx, config, pluginLogger)
+  await database.initialize()
+  const contactCache = new ContactCacheService(ctx, database, pluginLogger)
 
-  const metadata = await fileManager.readMetadataOnly()
+  const media = new MediaManager(ctx, config, database, pluginLogger)
+  media.start()
 
-  pluginLogger.logInfo('插件加载完成，元数据统计:', {
-    机器人数量: Object.keys(metadata.bots).length,
-    频道数量: Object.keys(metadata.channels).reduce((total, botId) =>
-      total + Object.keys(metadata.channels[botId] || {}).length, 0),
-    置顶机器人数量: metadata.pinnedBots.length,
-    置顶频道数量: metadata.pinnedChannels.length
-  })
-
-  ctx.on('message', (session) => {
-    if (utils.isPlatformBlocked(session.platform || 'unknown')) return
-
-    messageHandler.recordUserMessage(session, Date.now())
-  })
+  const recorder = new Recorder(ctx, config, database, media, contactCache, pluginLogger)
+  recorder.start()
 
-  ctx.on('before-send', (session) => {
-    if (utils.isPlatformBlocked(session.platform || 'unknown')) return
-
-    messageHandler.recordBotMessage(session, Date.now())
-  })
-
-  let cleanupDelayTimer: (() => void) | undefined
-  let cleanupInterval: (() => void) | undefined
-
-  ctx.on('ready', async () => {
-    pluginLogger.logInfo('插件启动完成，开始监听消息')
-
-    // 延后清理，避免和 Koishi 刚 ready 时的资源竞争。
-    cleanupDelayTimer = ctx.setTimeout(() => {
-      void fileManager.cleanupExcessMessagesInStorage()
-    }, 15000)
-
-    cleanupInterval = ctx.setInterval(() => {
-      void fileManager.cleanupExcessMessagesInStorage()
-    }, 300000)
-  })
+  const selfMessages = new SelfMessageRecorder(ctx, config, database, pluginLogger)
+  selfMessages.start()
 
-  apiHandlers.registerApiHandlers()
+  registerBootstrap(ctx, config, database, pluginLogger)
+  registerWeb(ctx, config, database, contactCache, pluginLogger)
 
   ctx.console.addEntry({
     dev: path.resolve(__dirname, '../client/index.ts'),
@@ -92,10 +61,9 @@ export async function apply(ctx: Context, config: Config) {
   })
 
   ctx.on('dispose', () => {
-    cleanupDelayTimer?.()
-    cleanupInterval?.()
-    messageHandler.dispose()
-    void fileManager.dispose()
-    pluginLogger.logInfo('插件已卸载，所有待处理的消息已写入')
+    selfMessages.dispose()
+    media.dispose()
+    void database.dispose()
+    pluginLogger.logInfo('chat-patch 已卸载')
   })
 }

package/src/media.ts

@@ -0,0 +1,302 @@
+import { Context } from 'koishi'
+import {} from '@koishijs/plugin-server'
+import { createHash } from 'node:crypto'
+import { createReadStream, promises as fs } from 'node:fs'
+import path from 'node:path'
+import { fileURLToPath } from 'node:url'
+import FileType from 'file-type'
+
+import { Config } from './config'
+import { ChatDatabase } from './database'
+import { PluginLogger } from './logger'
+
+function toExtension(value: string): string {
+  const ext = value.startsWith('.') ? value : `.${value}`
+  return ext.toLowerCase()
+}
+
+function toLocalFilePath(value: string): string | null {
+  if (value.startsWith('file://')) {
+    try {
+      return fileURLToPath(value)
+    } catch {
+      return null
+    }
+  }
+  if (/^[a-z]:[\\/]/i.test(value) || value.startsWith('\\\\')) return value
+  return null
+}
+
+export class MediaManager {
+  private mediaDir: string
+  private uploadDir: string
+  private cleanupTimer?: () => void
+
+  constructor(
+    private ctx: Context,
+    private config: Config,
+    private database: ChatDatabase,
+    private logger: PluginLogger,
+  ) {
+    this.mediaDir = path.resolve(ctx.baseDir, 'data', 'chat-patch', 'media')
+    this.uploadDir = path.resolve(ctx.baseDir, 'data', 'chat-patch', 'upload-media')
+  }
+
+  start() {
+    const route = `${this.config.basePath}/web/media`
+    this.ctx.server.get(route, async (koa) => {
+      const url = String(koa.query.url ?? '')
+      if (!url) {
+        koa.status = 400
+        koa.body = 'missing url'
+        return
+      }
+      const filePath = await this.cacheUrl(url)
+      if (!filePath) {
+        koa.status = 502
+        koa.body = 'download failed'
+        return
+      }
+      const size = (await fs.stat(filePath)).size
+      koa.type = path.extname(filePath) || 'application/octet-stream'
+      koa.set('Accept-Ranges', 'bytes')
+
+      const range = koa.headers.range
+      if (range) {
+        const match = /^bytes=(\d*)-(\d*)$/.exec(String(range))
+        if (!match) {
+          koa.status = 416
+          koa.set('Content-Range', `bytes */${size}`)
+          koa.body = ''
+          return
+        }
+        let start = 0
+        let end = size - 1
+        if (match[1] === '' && match[2]) {
+          start = Math.max(0, size - Number(match[2]))
+        } else if (match[1]) {
+          start = Number(match[1])
+          end = match[2] ? Number(match[2]) : end
+        }
+        if (!Number.isFinite(start) || !Number.isFinite(end) || start < 0 || start >= size) {
+          koa.status = 416
+          koa.set('Content-Range', `bytes */${size}`)
+          koa.body = ''
+          return
+        }
+        if (end >= size) end = size - 1
+        if (end < start) end = start
+        koa.status = 206
+        koa.set('Content-Range', `bytes ${start}-${end}/${size}`)
+        koa.set('Content-Length', String(end - start + 1))
+        koa.body = createReadStream(filePath, { start, end })
+        return
+      }
+
+      koa.set('Content-Length', String(size))
+      koa.body = createReadStream(filePath)
+    })
+
+    this.cleanupTimer = this.ctx.setInterval(() => {
+      void this.cleanup()
+    }, 10 * 60 * 1000)
+
+    // 每次插件启动时先按全局文件数清理一次
+    void this.cleanup()
+  }
+
+  dispose() {
+    this.cleanupTimer?.()
+  }
+
+  async cacheUrl(url: string, channelId = ''): Promise<string | null> {
+    try {
+      const filePath = await this.resolveAndDownload(url, channelId)
+      if (filePath) {
+        await this.database.recordMedia(url, filePath, channelId)
+      }
+      return filePath
+    } catch (error) {
+      this.logger.warn('媒体缓存失败:', url, error)
+      return null
+    }
+  }
+
+  private async resolveAndDownload(url: string, channelId: string): Promise<string | null> {
+    try {
+      await fs.mkdir(this.mediaDir, { recursive: true })
+      const localSource = toLocalFilePath(url)
+      if (localSource && await this.exists(localSource)) {
+        const hash = createHash('md5').update(url).digest('hex')
+        const ext = path.extname(localSource).toLowerCase() || '.bin'
+        const filePath = path.join(this.mediaDir, `${hash}${ext}`)
+        if (path.normalize(filePath) !== path.normalize(localSource)) {
+          if (!(await this.exists(filePath))) {
+            await fs.copyFile(localSource, filePath)
+          }
+        }
+        await this.database.recordMedia(url, filePath, channelId)
+        this.logger.logInfo('本地媒体已缓存:', filePath)
+        return filePath
+      }
+      const cached = await this.database.getMediaPath(url)
+      if (cached && await this.exists(cached)) {
+        return this.migrateCachedMedia(url, cached, channelId)
+      }
+
+      const hash = createHash('md5').update(url).digest('hex')
+      const urlExt = path.extname(new URL(url).pathname)
+      const fallbackPath = path.join(this.mediaDir, `${hash}${urlExt || '.bin'}`)
+      if (await this.exists(fallbackPath)) {
+        return this.migrateCachedMedia(url, fallbackPath, channelId)
+      }
+
+      const response = await fetch(url, {
+        headers: {
+          'User-Agent': 'Mozilla/5.0 KoishiChatPatch/1.0',
+        },
+      })
+      if (!response.ok) {
+        return null
+      }
+      const buffer = Buffer.from(await response.arrayBuffer())
+      const ext = await this.detectExtension(url, buffer)
+      const filename = `${hash}${ext}`
+      const filePath = path.join(this.mediaDir, filename)
+      await fs.writeFile(filePath, buffer)
+      this.logger.logInfo('媒体已缓存:', filename, buffer.length)
+      return filePath
+    } catch (error) {
+      return null
+    }
+  }
+
+  private async detectExtension(url: string, buffer: Buffer): Promise<string> {
+    try {
+      const detected = await FileType.fromBuffer(buffer)
+      if (detected?.ext) return toExtension(detected.ext)
+    } catch (error) {
+      this.logger.logInfo('媒体类型识别失败，回退 URL 后缀:', url, error)
+    }
+    const ext = path.extname(new URL(url).pathname)
+    return ext && ext !== '.bin' ? ext.toLowerCase() : '.bin'
+  }
+
+  private async migrateCachedMedia(url: string, filePath: string, channelId: string): Promise<string> {
+    try {
+      const buffer = await fs.readFile(filePath)
+      const ext = await this.detectExtension(url, buffer)
+      const currentExt = path.extname(filePath).toLowerCase()
+      if (ext === '.bin' || ext === currentExt) return filePath
+
+      const newPath = path.join(
+        path.dirname(filePath),
+        `${path.basename(filePath, path.extname(filePath))}${ext}`,
+      )
+      if (newPath === filePath) return filePath
+      if (await this.exists(newPath)) {
+        await fs.unlink(filePath)
+      } else {
+        await fs.rename(filePath, newPath)
+      }
+      await this.database.recordMedia(url, newPath, channelId)
+      return newPath
+    } catch (error) {
+      this.logger.warn('旧媒体缓存重命名失败:', url, error)
+      return filePath
+    }
+  }
+
+  private async cleanup() {
+    try {
+      const allFiles: Array<{ filePath: string; mtimeMs: number; channelId: string }> = []
+      for (const dir of [this.mediaDir, this.uploadDir]) {
+        try {
+          const entries = await fs.readdir(dir, { withFileTypes: true })
+          for (const entry of entries) {
+            if (!entry.isFile()) continue
+            const filePath = path.join(dir, entry.name)
+            try {
+              const stat = await fs.stat(filePath)
+              allFiles.push({ filePath, mtimeMs: stat.mtimeMs, channelId: '' })
+            } catch {
+              // 单个文件读取失败不影响其他文件清理
+            }
+          }
+        } catch {
+          // 目录不存在时跳过
+        }
+      }
+      if (!allFiles.length) return
+
+      const metadata = await this.database.getAllMedia()
+      const channelByPath = new Map(metadata.map((item) => [path.normalize(item.filePath), item.channelId]))
+      const uploadRoot = path.normalize(this.uploadDir)
+      for (const file of allFiles) {
+        const normalized = path.normalize(file.filePath)
+        file.channelId = channelByPath.get(normalized) ?? ''
+        if (!file.channelId && normalized.startsWith(uploadRoot)) {
+          file.channelId = 'upload'
+        }
+        if (!file.channelId) file.channelId = 'unknown'
+      }
+
+      if (allFiles.length <= this.config.maxMediaFiles) return
+
+      const groups = new Map<string, typeof allFiles>()
+      for (const file of allFiles) {
+        const list = groups.get(file.channelId) ?? []
+        list.push(file)
+        groups.set(file.channelId, list)
+      }
+      for (const list of groups.values()) {
+        list.sort((a, b) => b.mtimeMs - a.mtimeMs)
+      }
+
+      // 按频道/目录公平分配，避免一个群独占全部名额
+      const keep = new Set<string>()
+      const groupList = [...groups.values()]
+      let cursor = 0
+      for (let count = 0; count < this.config.maxMediaFiles && count < allFiles.length; count++) {
+        let picked = false
+        for (let offset = 0; offset < groupList.length; offset++) {
+          const group = groupList[(cursor + offset) % groupList.length]
+          const file = group.shift()
+          if (file) {
+            keep.add(file.filePath)
+            cursor = (cursor + offset + 1) % groupList.length
+            picked = true
+            break
+          }
+        }
+        if (!picked) break
+      }
+
+      let removed = 0
+      for (const file of allFiles) {
+        if (keep.has(file.filePath)) continue
+        try {
+          await fs.unlink(file.filePath)
+          removed += 1
+        } catch {
+          // 文件可能已被外部删除
+        }
+        await this.database.removeMediaByPath(file.filePath).catch(() => undefined)
+      }
+      if (removed > 0) {
+        this.logger.logInfo('媒体缓存已清理', removed, '个文件')
+      }
+    } catch {
+      // 清理失败时不阻塞插件启动
+    }
+  }
+
+  private async exists(filePath: string): Promise<boolean> {
+    try {
+      await fs.access(filePath)
+      return true
+    } catch {
+      return false
+    }
+  }
+}

package/src/recorder.ts

@@ -0,0 +1,175 @@
+import { Context, Session } from 'koishi'
+
+import { Config } from './config'
+import { ContactCacheService } from './cache'
+import { ChatDatabase } from './database'
+import { MediaManager } from './media'
+import { MessageRecord } from './types'
+import { PluginLogger } from './logger'
+
+const MESSAGE_TYPES = new Set(['message', 'message-created'])
+
+function normalizeGroupId(value: string): string {
+  const raw = value.replace(/^(?:group|room|chat|channel|guild):/i, '').trim()
+  const wrapped = raw.match(/^\[_?([\s\S]+?)_?\]$/)
+  return wrapped ? wrapped[1] : raw || value
+}
+
+export class Recorder {
+  constructor(
+    private ctx: Context,
+    private config: Config,
+    private database: ChatDatabase,
+    private media: MediaManager,
+    private contactCache: ContactCacheService,
+    private logger: PluginLogger,
+  ) {}
+
+  start() {
+    this.ctx.on('internal/session', (session: Session) => {
+      void this.handleSession(session)
+    })
+  }
+
+  private isBlocked(platform: string): boolean {
+    return (this.config.blockedPlatforms ?? []).some((item) => {
+      return item.exactMatch
+        ? platform === item.platformName
+        : platform.includes(item.platformName)
+    })
+  }
+
+  private async handleSession(session: Session) {
+    const platform = session.platform || 'unknown'
+    if (this.isBlocked(platform)) return
+    if (!MESSAGE_TYPES.has(session.type)) return
+
+    const event = session.toJSON()
+    const message = event.message
+    const record: MessageRecord = {
+      id: message?.id || `local-${event.sn}`,
+      sequence: event.sn,
+      type: session.type,
+      platform,
+      selfId: session.selfId,
+      channelId: session.channelId,
+      guildId: session.guildId,
+      userId: session.userId,
+      timestamp: session.timestamp,
+      timestampMs: session.timestamp,
+      receivedAt: Date.now(),
+      content: session.content || message?.content,
+      elements: message?.elements as unknown[] | undefined,
+      raw: event,
+    }
+
+    try {
+      await this.database.appendMessage(record)
+      void this.cacheMessageContacts(event).catch((error) => {
+        this.logger.warn('缓存消息联系人失败:', error)
+      })
+      void this.cacheMessageMedia(event).catch((error) => {
+        this.logger.warn('异步缓存消息媒体失败:', error)
+      })
+    } catch (error) {
+      this.logger.warn('写入历史消息失败:', error)
+    }
+  }
+
+  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())
+      || (!channelType && /^private:/i.test(channelId))
+    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 || ''
+
+    if (groupId) {
+      const groupItem = await this.contactCache.getGroup(
+        platform,
+        selfId,
+        groupId,
+        guildId || groupId,
+        channelId || groupId,
+        groupName,
+        groupAvatar,
+        channel?.type,
+      )
+      if (userId) {
+        const userItem = await this.contactCache.getUser(
+          platform,
+          selfId,
+          userId,
+          guildId || groupId,
+          undefined,
+          userName,
+          userAvatar,
+        )
+        await this.contactCache.recordGroupMember(
+          platform,
+          selfId,
+          groupId,
+          {
+            id: userId,
+            name: userItem?.name || userName || userId,
+            avatar: userItem?.avatar || userAvatar || undefined,
+            raw: {
+              id: userId,
+              user_id: userId,
+              nickname: userName || userItem?.name,
+              card: member?.nick || member?.name || '',
+              avatar: userItem?.avatar || userAvatar || undefined,
+              role: member?.title || '',
+            },
+          },
+        )
+      }
+      if (!groupItem) this.logger.logInfo('群组缓存未回源到可用身份:', groupId)
+    } else if (userId) {
+      await this.contactCache.getUser(
+        platform,
+        selfId,
+        userId,
+        undefined,
+        channelId,
+        userName,
+        userAvatar,
+      )
+    }
+  }
+
+  private async cacheMessageMedia(event: ReturnType<Session['toJSON']>) {
+    const elements = Array.isArray(event.message?.elements) ? event.message.elements : []
+    const channelId = String(
+      event.channel?.id
+      || event.guild?.id
+      || '',
+    )
+    const urls: string[] = []
+    const collect = (list: unknown[]) => {
+      for (const raw of list) {
+        const element = typeof raw === 'object' && raw !== null ? raw as Record<string, unknown> : {}
+        const attrs = typeof element.attrs === 'object' && element.attrs !== null ? element.attrs as Record<string, unknown> : {}
+        if (['img', 'image', 'mface', 'audio', 'video', 'file'].includes(String(element.type))) {
+          const url = String(attrs.src ?? attrs.url ?? attrs.file ?? '')
+          if (url) urls.push(url)
+        }
+        if (Array.isArray(element.children)) collect(element.children)
+      }
+    }
+    collect(elements)
+    await Promise.allSettled(urls.map((url) => this.media.cacheUrl(url, channelId)))
+  }
+}