koishi-plugin-chat-patch 2.3.0 → 2.4.0

package/src/file-manager.ts

@@ -7,16 +7,16 @@ import path from 'node:path'
 import fs from 'node:fs'
 
 export class FileManager {
-  private dataFilePath: string
-  private fileOperationLock = Promise.resolve()
+  private chatHistoryDir: string // 聊天记录根目录
+  private metadataFilePath: string // 元数据文件路径（存储bots、channels、pinned等信息）
   private logger: Logger
   private utils: Utils
 
   private memoryCache: ChatData | null = null
 
-  private pendingMessages: MessageInfo[] = []
+  private pendingMessages: Map<string, MessageInfo[]> = new Map() // 按channelKey分组的待写入消息
 
-  private writeTimer: (() => void) | null = null
+  private writeTimers: Map<string, (() => void)> = new Map() // 每个频道独立的写入定时器
 
   private readonly WRITE_DEBOUNCE_MS = 1000
 
@@ -24,45 +24,175 @@ export class FileManager {
     private ctx: Context,
     private config: Config
   ) {
-    this.dataFilePath = path.resolve(ctx.baseDir, 'data', 'chat-patch', 'chat-data.json')
+    const baseDir = path.resolve(ctx.baseDir, 'data', 'chat-patch')
+    this.chatHistoryDir = path.join(baseDir, 'chat-history')
+    this.metadataFilePath = path.join(baseDir, 'metadata.json')
     this.logger = ctx.logger('chat-patch')
     this.utils = new Utils(config)
 
+    // 清理旧版本的单文件存储
+    this.cleanupOldDataFiles(baseDir)
+
     this.memoryCache = this.readChatDataFromFile()
   }
 
-  private ensureDataDir() {
-    const dir = path.dirname(this.dataFilePath)
-    if (!fs.existsSync(dir)) {
-      fs.mkdirSync(dir, { recursive: true })
+  // 清理旧版本的JSON文件
+  private cleanupOldDataFiles(baseDir: string) {
+    const oldFiles = ['chat-data.json', 'data.json', 'messages.json']
+    for (const fileName of oldFiles) {
+      const filePath = path.join(baseDir, fileName)
+      if (fs.existsSync(filePath)) {
+        try {
+          fs.unlinkSync(filePath)
+          this.logger.info(`已删除旧版本数据文件: ${fileName}`)
+        } catch (error) {
+          this.logger.warn(`删除旧版本数据文件失败: ${fileName}`, error)
+        }
+      }
     }
   }
 
-  readChatDataFromFile(): ChatData {
+  // 确保目录存在
+  private ensureDir(dirPath: string) {
+    if (!fs.existsSync(dirPath)) {
+      fs.mkdirSync(dirPath, { recursive: true })
+    }
+  }
+
+  // 获取频道消息文件路径
+  private getChannelFilePath(selfId: string, channelId: string): string {
+    const botDir = path.join(this.chatHistoryDir, selfId)
+    this.ensureDir(botDir)
+    return path.join(botDir, `${channelId}.json`)
+  }
+
+  // 读取单个频道的消息
+  private readChannelMessages(selfId: string, channelId: string): MessageInfo[] {
+    const filePath = this.getChannelFilePath(selfId, channelId)
+    if (!fs.existsSync(filePath)) {
+      return []
+    }
+
+    try {
+      const jsonData = fs.readFileSync(filePath, 'utf8')
+      const messages = JSON.parse(jsonData)
+      return Array.isArray(messages) ? messages : []
+    } catch (error) {
+      this.logger.error(`读取频道消息失败 [${selfId}:${channelId}]:`, error)
+      return []
+    }
+  }
+
+  // 写入单个频道的消息
+  private writeChannelMessages(selfId: string, channelId: string, messages: MessageInfo[]) {
+    const filePath = this.getChannelFilePath(selfId, channelId)
+    try {
+      const jsonData = JSON.stringify(messages, null, 2)
+      fs.writeFileSync(filePath, jsonData, 'utf8')
+    } catch (error) {
+      this.logger.error(`写入频道消息失败 [${selfId}:${channelId}]:`, error)
+    }
+  }
+
+  // 读取元数据（bots、channels、pinned等）
+  private readMetadata(): Omit<ChatData, 'messages'> {
+    if (!fs.existsSync(this.metadataFilePath)) {
+      return {
+        bots: {},
+        channels: {},
+        pinnedBots: [],
+        pinnedChannels: []
+      }
+    }
+
+    try {
+      const jsonData = fs.readFileSync(this.metadataFilePath, 'utf8')
+      const data = JSON.parse(jsonData)
+      return {
+        bots: data.bots || {},
+        channels: data.channels || {},
+        pinnedBots: data.pinnedBots || [],
+        pinnedChannels: data.pinnedChannels || [],
+        lastSaveTime: data.lastSaveTime
+      }
+    } catch (error) {
+      this.logger.error('读取元数据失败:', error)
+      return {
+        bots: {},
+        channels: {},
+        pinnedBots: [],
+        pinnedChannels: []
+      }
+    }
+  }
+
+  // 写入元数据
+  private writeMetadata(metadata: Omit<ChatData, 'messages'>) {
+    try {
+      this.ensureDir(path.dirname(this.metadataFilePath))
+      const dataToWrite = {
+        ...metadata,
+        lastSaveTime: Date.now()
+      }
+      const jsonData = JSON.stringify(dataToWrite, null, 2)
+      fs.writeFileSync(this.metadataFilePath, jsonData, 'utf8')
+    } catch (error) {
+      this.logger.error('写入元数据失败:', error)
+    }
+  }
+
+  // 扫描所有频道消息文件并加载到内存
+  private loadAllChannelMessages(): Record<string, MessageInfo[]> {
+    const messages: Record<string, MessageInfo[]> = {}
+
+    if (!fs.existsSync(this.chatHistoryDir)) {
+      return messages
+    }
+
+    try {
+      const botDirs = fs.readdirSync(this.chatHistoryDir)
+      for (const botId of botDirs) {
+        const botDir = path.join(this.chatHistoryDir, botId)
+        const stat = fs.statSync(botDir)
+        if (!stat.isDirectory()) continue
 
+        const channelFiles = fs.readdirSync(botDir)
+        for (const fileName of channelFiles) {
+          if (!fileName.endsWith('.json')) continue
+
+          const channelId = fileName.replace('.json', '')
+          const channelKey = `${botId}:${channelId}`
+          messages[channelKey] = this.readChannelMessages(botId, channelId)
+        }
+      }
+    } catch (error) {
+      this.logger.error('加载频道消息失败:', error)
+    }
+
+    return messages
+  }
+
+  readChatDataFromFile(): ChatData {
+    // 如果已有缓存，直接返回
     if (this.memoryCache) {
       return this.memoryCache
     }
 
+    // 异步加载数据
     process.nextTick(() => {
       try {
-        if (fs.existsSync(this.dataFilePath)) {
-          const jsonData = fs.readFileSync(this.dataFilePath, 'utf8')
-          const data = JSON.parse(jsonData)
-          this.memoryCache = {
-            bots: data.bots || {},
-            channels: data.channels || {},
-            messages: data.messages || {},
-            pinnedBots: data.pinnedBots || [],
-            pinnedChannels: data.pinnedChannels || [],
-            lastSaveTime: data.lastSaveTime
-          }
+        const metadata = this.readMetadata()
+        const messages = this.loadAllChannelMessages()
+        this.memoryCache = {
+          ...metadata,
+          messages
         }
       } catch (error) {
         this.logger.error('读取聊天数据失败:', error)
       }
     })
 
+    // 先返回空数据
     this.memoryCache = {
       bots: {},
       channels: {},
@@ -74,52 +204,64 @@ export class FileManager {
   }
 
   writeChatDataToFile(data: ChatData) {
-
     data.lastSaveTime = Date.now()
     this.memoryCache = data
 
     process.nextTick(() => {
       try {
-        this.ensureDataDir()
-        const jsonData = JSON.stringify(data, null, 2)
-        fs.writeFileSync(this.dataFilePath, jsonData, 'utf8')
+        // 写入元数据
+        const { messages, ...metadata } = data
+        this.writeMetadata(metadata)
+
+        // 写入各个频道的消息
+        for (const [channelKey, channelMessages] of Object.entries(messages)) {
+          const [selfId, channelId] = channelKey.split(':')
+          if (selfId && channelId) {
+            this.writeChannelMessages(selfId, channelId, channelMessages)
+          }
+        }
       } catch (error) {
         this.logger.error('写入聊天数据失败:', error)
       }
     })
   }
 
-  private scheduleWrite() {
-
-    if (this.writeTimer) {
-      this.writeTimer()
-      this.writeTimer = null
+  // 为特定频道安排写入
+  private scheduleWrite(channelKey: string) {
+    // 取消之前的定时器
+    const existingTimer = this.writeTimers.get(channelKey)
+    if (existingTimer) {
+      existingTimer()
     }
 
-    this.writeTimer = this.ctx.setTimeout(() => {
-
+    // 创建新的定时器
+    const timer = this.ctx.setTimeout(() => {
       process.nextTick(() => {
-        this.flushPendingMessages()
+        this.flushPendingMessages(channelKey)
       })
-      this.writeTimer = null
+      this.writeTimers.delete(channelKey)
     }, this.WRITE_DEBOUNCE_MS)
+
+    this.writeTimers.set(channelKey, timer)
   }
 
-  private flushPendingMessages() {
-    if (this.pendingMessages.length === 0) return
+  // 刷新特定频道的待写入消息
+  private flushPendingMessages(channelKey: string) {
+    const messagesToWrite = this.pendingMessages.get(channelKey)
+    if (!messagesToWrite || messagesToWrite.length === 0) return
 
-    const messagesToWrite = [...this.pendingMessages]
-    this.pendingMessages = []
+    this.pendingMessages.delete(channelKey)
 
     const data = this.memoryCache || this.readChatDataFromFile()
+    const [selfId, channelId] = channelKey.split(':')
 
-    for (const messageInfo of messagesToWrite) {
-      const channelKey = `${messageInfo.selfId}:${messageInfo.channelId}`
+    if (!selfId || !channelId) return
 
-      if (!data.messages[channelKey]) {
-        data.messages[channelKey] = []
-      }
+    if (!data.messages[channelKey]) {
+      data.messages[channelKey] = []
+    }
 
+    for (const messageInfo of messagesToWrite) {
       const existingMessage = data.messages[channelKey].find(m => m.id === messageInfo.id)
       if (existingMessage) {
         continue
@@ -131,15 +273,19 @@ export class FileManager {
 
       const cleanedMessageInfo = this.utils.cleanBase64Content(messageInfo) as MessageInfo
       data.messages[channelKey].push(cleanedMessageInfo)
+    }
 
-      if (data.messages[channelKey].length > this.config.maxMessagesPerChannel) {
-        data.messages[channelKey].sort((a, b) => a.timestamp - b.timestamp)
-        data.messages[channelKey] = data.messages[channelKey].slice(-this.config.maxMessagesPerChannel)
-      }
+    // 限制消息数量
+    if (data.messages[channelKey].length > this.config.maxMessagesPerChannel) {
+      data.messages[channelKey].sort((a, b) => a.timestamp - b.timestamp)
+      data.messages[channelKey] = data.messages[channelKey].slice(-this.config.maxMessagesPerChannel)
     }
 
-    this.writeChatDataToFile(data)
-    this.logInfo(`批量写入 ${messagesToWrite.length} 条消息`)
+    // 只写入这个频道的消息文件
+    this.writeChannelMessages(selfId, channelId, data.messages[channelKey])
+    this.memoryCache = data
+
+    this.logInfo(`批量写入 ${messagesToWrite.length} 条消息到频道 ${channelKey}`)
   }
 
   cleanExcessMessages(data: ChatData): ChatData {
@@ -169,11 +315,16 @@ export class FileManager {
   }
 
   async addMessageToFile(messageInfo: MessageInfo) {
+    const channelKey = `${messageInfo.selfId}:${messageInfo.channelId}`
 
-    this.pendingMessages.push(messageInfo)
+    // 添加到待写入队列
+    if (!this.pendingMessages.has(channelKey)) {
+      this.pendingMessages.set(channelKey, [])
+    }
+    this.pendingMessages.get(channelKey)!.push(messageInfo)
 
+    // 更新内存缓存
     const data = this.memoryCache || this.readChatDataFromFile()
-    const channelKey = `${messageInfo.selfId}:${messageInfo.channelId}`
 
     if (!data.messages[channelKey]) {
       data.messages[channelKey] = []
@@ -195,16 +346,17 @@ export class FileManager {
       this.memoryCache = data
     }
 
-    this.scheduleWrite()
+    // 安排写入
+    this.scheduleWrite(channelKey)
   }
 
   dispose() {
-    if (this.writeTimer) {
-      this.writeTimer()
-      this.writeTimer = null
+    // 取消所有定时器
+    for (const [channelKey, timer] of this.writeTimers.entries()) {
+      timer()
+      this.flushPendingMessages(channelKey)
     }
-
-    this.flushPendingMessages()
+    this.writeTimers.clear()
   }
 
   private logInfo(...args: any[]) {