koishi-plugin-chat-patch 2.2.0 → 2.4.0

package/lib/index.js

@@ -54,7 +54,6 @@ var Utils = class {
   static {
     __name(this, "Utils");
   }
-  // 检查平台是否被屏蔽
   isPlatformBlocked(platform) {
     if (!this.config.blockedPlatforms || this.config.blockedPlatforms.length === 0) {
       return false;
@@ -72,7 +71,6 @@ var Utils = class {
     }
     return false;
   }
-  // 递归提取所有文本内容的函数
   extractTextContent(elements) {
     let text = "";
     for (const element of elements) {
@@ -88,7 +86,6 @@ var Utils = class {
     }
     return text;
   }
-  // 检查字符串是否为base64格式
   isBase64(str) {
     if (!str || typeof str !== "string") return false;
     if (str.startsWith("data:")) {
@@ -100,7 +97,6 @@ var Utils = class {
     }
     return false;
   }
-  // 持久化 base64 图片并返回本地文件 URL
   persistBase64Image(base64Data) {
     if (!this.ctx || !base64Data.startsWith("data:image/")) return base64Data;
     try {
@@ -127,8 +123,6 @@ var Utils = class {
     } catch (e) {
     }
   }
-  // 清理对象中的base64内容，改为持久化存储
-  // isBotMessage: 是否为机器人发送的消息
   cleanBase64Content(obj, isBotMessage = false) {
     if (obj === null || obj === void 0) {
       return obj;
@@ -184,95 +178,130 @@ var MessageHandler = class {
   }
   logger;
   utils;
-  // 存储正确的 channelId 映射，key 是 selfId，value 是正确的 channelId
   correctChannelIds = /* @__PURE__ */ new Map();
-  // 设置正确的 channelId
+  recordUserMessage(session, timestamp) {
+    setImmediate(() => {
+      this.processUserMessage(session, timestamp).catch((error) => {
+        this.logger.error("记录用户消息失败:", error);
+      });
+    });
+  }
+  recordBotMessage(session, timestamp) {
+    setImmediate(() => {
+      this.processBotMessage(session, timestamp).catch((error) => {
+        this.logger.error("记录机器人消息失败:", error);
+      });
+    });
+  }
   setCorrectChannelId(selfId, channelId) {
     this.correctChannelIds.set(selfId, channelId);
     this.logInfo("设置正确的 channelId:", { selfId, channelId });
   }
-  // 获取正确的 channelId
   getCorrectChannelId(selfId) {
     return this.correctChannelIds.get(selfId);
   }
-  // 更新机器人信息到JSON文件
-  async updateBotInfoToFile(session) {
-    const data = this.fileManager.readChatDataFromFile();
-    const botInfo = {
-      selfId: session.selfId,
-      platform: session.platform || "unknown",
-      username: session.bot.user?.name || `Bot-${session.selfId}`,
-      avatar: session.bot.user?.avatar,
-      status: "online"
-    };
-    data.bots[session.selfId] = botInfo;
-    this.fileManager.writeChatDataToFile(data);
-    this.logInfo("更新机器人信息到文件:", botInfo.username);
+  updateBotInfoToFile(session) {
+    setImmediate(() => {
+      try {
+        const data = this.fileManager.readChatDataFromFile();
+        const botInfo = {
+          selfId: session.selfId,
+          platform: session.platform || "unknown",
+          username: session.bot.user?.name || `Bot-${session.selfId}`,
+          avatar: session.bot.user?.avatar,
+          status: "online"
+        };
+        data.bots[session.selfId] = botInfo;
+        this.fileManager.writeChatDataToFile(data);
+        this.logInfo("更新机器人信息到文件:", botInfo.username);
+      } catch (error) {
+        this.logger.error("更新机器人信息失败:", error);
+      }
+    });
   }
-  // 更新频道信息到JSON文件
-  async updateChannelInfoToFile(session) {
+  updateChannelInfoToFile(session) {
     const isDirect = session.isDirect || session.channelId?.includes("private");
-    let guildName = session.channelId;
     const directUserName = session.username || session.event?.user?.name || session.userId;
     const data = this.fileManager.readChatDataFromFile();
-    if (!isDirect) {
-      try {
-        if (session.guildId && session.bot.getGuild && typeof session.bot.getGuild === "function") {
-          const guild = await session.bot.getGuild(session.guildId);
-          guildName = guild?.name || session.channelId;
-        }
-        if (session.guildId && !session.bot.getGuild && session.bot.getChannel && typeof session.bot.getChannel === "function") {
-          try {
-            const channel = await session.bot.getChannel(session.guildId);
-            guildName = channel?.name || session.channelId;
-          } catch (channelError) {
-            this.logInfo("获取频道信息失败，使用频道ID作为备用:", channelError);
-          }
-        }
-      } catch (error) {
-        this.logInfo("获取频道信息失败，使用频道ID作为备用:", error);
-        guildName = session.channelId;
-      }
-    }
-    if (!data.channels[session.selfId]) {
-      data.channels[session.selfId] = {};
-    }
-    const existingChannel = data.channels[session.selfId][session.channelId];
-    let finalName;
+    const existingChannel = data.channels[session.selfId]?.[session.channelId];
+    let immediateName = session.channelId;
     if (isDirect) {
       if (directUserName && directUserName !== session.userId) {
-        finalName = `私聊（${directUserName}）`;
+        immediateName = `私聊（${directUserName}）`;
       } else if (existingChannel?.name && !existingChannel.name.includes("未知")) {
-        finalName = existingChannel.name;
+        immediateName = existingChannel.name;
       } else if (session.platform && session.platform.toLowerCase().includes("sandbox")) {
-        finalName = `私聊（${session.userId}）`;
+        immediateName = `私聊（${session.userId}）`;
       } else {
-        finalName = "私聊（未知用户）";
+        immediateName = "私聊（未知用户）";
       }
-    } else {
-      finalName = guildName || session.channelId;
+    } else if (existingChannel?.guildName) {
+      immediateName = existingChannel.guildName;
     }
-    const channelInfo = {
-      id: session.channelId,
-      name: finalName,
-      type: session.type || 0,
-      channelId: session.channelId,
-      guildName,
-      isDirect: !!isDirect
-    };
-    if (existingChannel && existingChannel.name !== finalName) {
-      this.logInfo("更新频道名称:", {
-        channelId: session.channelId,
-        oldName: existingChannel.name,
-        newName: finalName
-      });
-    }
-    data.channels[session.selfId][session.channelId] = channelInfo;
-    this.fileManager.writeChatDataToFile(data);
-    this.logInfo("更新频道信息到文件:", channelInfo.name);
-    return guildName;
+    setImmediate(async () => {
+      try {
+        let guildName = session.channelId;
+        if (!isDirect) {
+          try {
+            if (session.guildId && session.bot.getGuild && typeof session.bot.getGuild === "function") {
+              const guild = await session.bot.getGuild(session.guildId);
+              guildName = guild?.name || session.channelId;
+            } else if (session.guildId && !session.bot.getGuild && session.bot.getChannel && typeof session.bot.getChannel === "function") {
+              try {
+                const channel = await session.bot.getChannel(session.guildId);
+                guildName = channel?.name || session.channelId;
+              } catch (channelError) {
+                this.logInfo("获取频道信息失败，使用频道ID作为备用:", channelError);
+              }
+            }
+          } catch (error) {
+            this.logInfo("获取频道信息失败，使用频道ID作为备用:", error);
+            guildName = session.channelId;
+          }
+        }
+        const freshData = this.fileManager.readChatDataFromFile();
+        if (!freshData.channels[session.selfId]) {
+          freshData.channels[session.selfId] = {};
+        }
+        const existingChannel2 = freshData.channels[session.selfId][session.channelId];
+        let finalName;
+        if (isDirect) {
+          if (directUserName && directUserName !== session.userId) {
+            finalName = `私聊（${directUserName}）`;
+          } else if (existingChannel2?.name && !existingChannel2.name.includes("未知")) {
+            finalName = existingChannel2.name;
+          } else if (session.platform && session.platform.toLowerCase().includes("sandbox")) {
+            finalName = `私聊（${session.userId}）`;
+          } else {
+            finalName = "私聊（未知用户）";
+          }
+        } else {
+          finalName = guildName || session.channelId;
+        }
+        const channelInfo = {
+          id: session.channelId,
+          name: finalName,
+          type: session.type || 0,
+          channelId: session.channelId,
+          guildName,
+          isDirect: !!isDirect
+        };
+        if (existingChannel2 && existingChannel2.name !== finalName) {
+          this.logInfo("更新频道名称:", {
+            channelId: session.channelId,
+            oldName: existingChannel2.name,
+            newName: finalName
+          });
+        }
+        freshData.channels[session.selfId][session.channelId] = channelInfo;
+        this.fileManager.writeChatDataToFile(freshData);
+        this.logInfo("更新频道信息到文件:", channelInfo.name);
+      } catch (error) {
+        this.logger.error("异步更新频道信息失败:", error);
+      }
+    });
+    return immediateName;
   }
-  // 下载并缓存媒体文件
   async downloadAndCacheMedia(url, type) {
     try {
       if (!url || url.startsWith("data:") || url.startsWith("file:")) return url;
@@ -298,37 +327,44 @@ var MessageHandler = class {
       return url;
     }
   }
-  // 处理消息中的媒体元素并缓存
-  // 只缓存用户的图片和语音，不缓存视频和文件
-  async processMediaElements(elements, isUserMessage = true) {
-    if (!elements) return elements;
-    for (const el of elements) {
-      if (["image", "img", "mface"].includes(el.type)) {
-        const src = el.attrs.src || el.attrs.url || el.attrs.file;
-        if (src && isUserMessage) {
-          el.attrs.src = await this.downloadAndCacheMedia(src, "image");
-        }
-      } else if (el.type === "audio") {
-        const src = el.attrs.src || el.attrs.url || el.attrs.file;
-        if (src && isUserMessage) {
-          el.attrs.src = await this.downloadAndCacheMedia(src, "media");
+  processMediaElementsAsync(elements, isUserMessage = true) {
+    if (!elements) return;
+    setImmediate(async () => {
+      try {
+        for (const el of elements) {
+          if (["image", "img", "mface"].includes(el.type)) {
+            const src = el.attrs.src || el.attrs.url || el.attrs.file;
+            if (src && isUserMessage) {
+              this.downloadAndCacheMedia(src, "image").catch((e) => {
+                this.logger.warn("缓存图片失败:", e);
+              });
+            }
+          } else if (el.type === "audio") {
+            const src = el.attrs.src || el.attrs.url || el.attrs.file;
+            if (src && isUserMessage) {
+              this.downloadAndCacheMedia(src, "media").catch((e) => {
+                this.logger.warn("缓存语音失败:", e);
+              });
+            }
+          }
+          if (el.children) this.processMediaElementsAsync(el.children, isUserMessage);
         }
+      } catch (error) {
+        this.logger.error("处理媒体元素失败:", error);
       }
-      if (el.children) await this.processMediaElements(el.children, isUserMessage);
-    }
-    return elements;
+    });
   }
-  async broadcastMessageEvent(session) {
+  async processUserMessage(session, timestamp) {
     try {
-      await this.updateBotInfoToFile(session);
-      const guildName = await this.updateChannelInfoToFile(session);
+      if (!timestamp) timestamp = Date.now();
+      this.updateBotInfoToFile(session);
+      const guildName = this.updateChannelInfoToFile(session);
       const isDirect = session.isDirect || session.channelId?.includes("private");
-      const timestamp = Date.now();
       if (session.elements) {
-        await this.processMediaElements(session.elements, true);
+        this.processMediaElementsAsync(session.elements, true);
       }
       if (session.quote?.elements) {
-        await this.processMediaElements(session.quote.elements, true);
+        this.processMediaElementsAsync(session.quote.elements, true);
       }
       let quoteInfo = void 0;
       if (session.quote) {
@@ -400,18 +436,17 @@ var MessageHandler = class {
       };
       this.ctx.console.broadcast("chat-message-event", messageEvent);
     } catch (error) {
-      this.logger.error("广播消息事件失败:", error);
+      this.logger.error("处理用户消息失败:", error);
     }
   }
-  // 处理机器人发送的消息
-  async broadcastBotMessageEvent(session) {
+  async processBotMessage(session, timestamp) {
     try {
+      if (!timestamp) timestamp = Date.now();
       const correctChannelId = this.getCorrectChannelId(session.selfId);
       const finalChannelId = correctChannelId || session.channelId;
-      await this.updateBotInfoToFile(session);
-      const guildName = await this.updateChannelInfoToFile(session);
+      this.updateBotInfoToFile(session);
+      const guildName = this.updateChannelInfoToFile(session);
       const isDirect = session.isDirect || finalChannelId?.includes("private");
-      const timestamp = Date.now();
       let content = session.content || "";
       if (!content && session.event?.message?.elements) {
         content = this.utils.extractTextContent(session.event.message.elements).trim();
@@ -488,7 +523,7 @@ var MessageHandler = class {
       };
       this.ctx.console.broadcast("chat-bot-message-event", messageEvent);
     } catch (error) {
-      this.logger.error("广播机器人消息事件失败:", error);
+      this.logger.error("处理机器人消息失败:", error);
     }
   }
   logInfo(...args) {
@@ -505,62 +540,237 @@ var FileManager = class {
   constructor(ctx, config) {
     this.ctx = ctx;
     this.config = config;
-    this.dataFilePath = import_node_path2.default.resolve(ctx.baseDir, "data", "chat-patch", "chat-data.json");
+    const baseDir = import_node_path2.default.resolve(ctx.baseDir, "data", "chat-patch");
+    this.chatHistoryDir = import_node_path2.default.join(baseDir, "chat-history");
+    this.metadataFilePath = import_node_path2.default.join(baseDir, "metadata.json");
     this.logger = ctx.logger("chat-patch");
     this.utils = new Utils(config);
+    this.cleanupOldDataFiles(baseDir);
+    this.memoryCache = this.readChatDataFromFile();
   }
   static {
     __name(this, "FileManager");
   }
-  dataFilePath;
-  fileOperationLock = Promise.resolve();
+  chatHistoryDir;
+  // 聊天记录根目录
+  metadataFilePath;
+  // 元数据文件路径（存储bots、channels、pinned等信息）
   logger;
   utils;
+  memoryCache = null;
+  pendingMessages = /* @__PURE__ */ new Map();
+  // 按channelKey分组的待写入消息
+  writeTimers = /* @__PURE__ */ new Map();
+  // 每个频道独立的写入定时器
+  WRITE_DEBOUNCE_MS = 1e3;
+  // 清理旧版本的JSON文件
+  cleanupOldDataFiles(baseDir) {
+    const oldFiles = ["chat-data.json", "data.json", "messages.json"];
+    for (const fileName of oldFiles) {
+      const filePath = import_node_path2.default.join(baseDir, fileName);
+      if (import_node_fs2.default.existsSync(filePath)) {
+        try {
+          import_node_fs2.default.unlinkSync(filePath);
+          this.logger.info(`已删除旧版本数据文件: ${fileName}`);
+        } catch (error) {
+          this.logger.warn(`删除旧版本数据文件失败: ${fileName}`, error);
+        }
+      }
+    }
+  }
   // 确保目录存在
-  ensureDataDir() {
-    const dir = import_node_path2.default.dirname(this.dataFilePath);
-    if (!import_node_fs2.default.existsSync(dir)) {
-      import_node_fs2.default.mkdirSync(dir, { recursive: true });
+  ensureDir(dirPath) {
+    if (!import_node_fs2.default.existsSync(dirPath)) {
+      import_node_fs2.default.mkdirSync(dirPath, { recursive: true });
     }
   }
-  // 从JSON文件读取数据
-  readChatDataFromFile() {
+  // 获取频道消息文件路径
+  getChannelFilePath(selfId, channelId) {
+    const botDir = import_node_path2.default.join(this.chatHistoryDir, selfId);
+    this.ensureDir(botDir);
+    return import_node_path2.default.join(botDir, `${channelId}.json`);
+  }
+  // 读取单个频道的消息
+  readChannelMessages(selfId, channelId) {
+    const filePath = this.getChannelFilePath(selfId, channelId);
+    if (!import_node_fs2.default.existsSync(filePath)) {
+      return [];
+    }
     try {
-      if (import_node_fs2.default.existsSync(this.dataFilePath)) {
-        const jsonData = import_node_fs2.default.readFileSync(this.dataFilePath, "utf8");
-        const data = JSON.parse(jsonData);
-        return {
-          bots: data.bots || {},
-          channels: data.channels || {},
-          messages: data.messages || {},
-          pinnedBots: data.pinnedBots || [],
-          pinnedChannels: data.pinnedChannels || [],
-          lastSaveTime: data.lastSaveTime
-        };
+      const jsonData = import_node_fs2.default.readFileSync(filePath, "utf8");
+      const messages = JSON.parse(jsonData);
+      return Array.isArray(messages) ? messages : [];
+    } catch (error) {
+      this.logger.error(`读取频道消息失败 [${selfId}:${channelId}]:`, error);
+      return [];
+    }
+  }
+  // 写入单个频道的消息
+  writeChannelMessages(selfId, channelId, messages) {
+    const filePath = this.getChannelFilePath(selfId, channelId);
+    try {
+      const jsonData = JSON.stringify(messages, null, 2);
+      import_node_fs2.default.writeFileSync(filePath, jsonData, "utf8");
+    } catch (error) {
+      this.logger.error(`写入频道消息失败 [${selfId}:${channelId}]:`, error);
+    }
+  }
+  // 读取元数据（bots、channels、pinned等）
+  readMetadata() {
+    if (!import_node_fs2.default.existsSync(this.metadataFilePath)) {
+      return {
+        bots: {},
+        channels: {},
+        pinnedBots: [],
+        pinnedChannels: []
+      };
+    }
+    try {
+      const jsonData = import_node_fs2.default.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: []
+      };
+    }
+  }
+  // 写入元数据
+  writeMetadata(metadata) {
+    try {
+      this.ensureDir(import_node_path2.default.dirname(this.metadataFilePath));
+      const dataToWrite = {
+        ...metadata,
+        lastSaveTime: Date.now()
+      };
+      const jsonData = JSON.stringify(dataToWrite, null, 2);
+      import_node_fs2.default.writeFileSync(this.metadataFilePath, jsonData, "utf8");
+    } catch (error) {
+      this.logger.error("写入元数据失败:", error);
+    }
+  }
+  // 扫描所有频道消息文件并加载到内存
+  loadAllChannelMessages() {
+    const messages = {};
+    if (!import_node_fs2.default.existsSync(this.chatHistoryDir)) {
+      return messages;
+    }
+    try {
+      const botDirs = import_node_fs2.default.readdirSync(this.chatHistoryDir);
+      for (const botId of botDirs) {
+        const botDir = import_node_path2.default.join(this.chatHistoryDir, botId);
+        const stat = import_node_fs2.default.statSync(botDir);
+        if (!stat.isDirectory()) continue;
+        const channelFiles = import_node_fs2.default.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);
+      this.logger.error("加载频道消息失败:", error);
     }
-    return {
+    return messages;
+  }
+  readChatDataFromFile() {
+    if (this.memoryCache) {
+      return this.memoryCache;
+    }
+    process.nextTick(() => {
+      try {
+        const metadata = this.readMetadata();
+        const messages = this.loadAllChannelMessages();
+        this.memoryCache = {
+          ...metadata,
+          messages
+        };
+      } catch (error) {
+        this.logger.error("读取聊天数据失败:", error);
+      }
+    });
+    this.memoryCache = {
       bots: {},
       channels: {},
       messages: {},
       pinnedBots: [],
       pinnedChannels: []
     };
+    return this.memoryCache;
   }
-  // 写入数据到JSON文件
   writeChatDataToFile(data) {
-    try {
-      this.ensureDataDir();
-      data.lastSaveTime = Date.now();
-      const jsonData = JSON.stringify(data, null, 2);
-      import_node_fs2.default.writeFileSync(this.dataFilePath, jsonData, "utf8");
-    } catch (error) {
-      this.logger.error("写入聊天数据失败:", error);
+    data.lastSaveTime = Date.now();
+    this.memoryCache = data;
+    process.nextTick(() => {
+      try {
+        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);
+      }
+    });
+  }
+  // 为特定频道安排写入
+  scheduleWrite(channelKey) {
+    const existingTimer = this.writeTimers.get(channelKey);
+    if (existingTimer) {
+      existingTimer();
     }
+    const timer = this.ctx.setTimeout(() => {
+      process.nextTick(() => {
+        this.flushPendingMessages(channelKey);
+      });
+      this.writeTimers.delete(channelKey);
+    }, this.WRITE_DEBOUNCE_MS);
+    this.writeTimers.set(channelKey, timer);
+  }
+  // 刷新特定频道的待写入消息
+  flushPendingMessages(channelKey) {
+    const messagesToWrite = this.pendingMessages.get(channelKey);
+    if (!messagesToWrite || messagesToWrite.length === 0) return;
+    this.pendingMessages.delete(channelKey);
+    const data = this.memoryCache || this.readChatDataFromFile();
+    const [selfId, channelId] = channelKey.split(":");
+    if (!selfId || !channelId) return;
+    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;
+      }
+      if (!messageInfo.timestamp) {
+        messageInfo.timestamp = Date.now();
+      }
+      const cleanedMessageInfo = this.utils.cleanBase64Content(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);
+    }
+    this.writeChannelMessages(selfId, channelId, data.messages[channelKey]);
+    this.memoryCache = data;
+    this.logInfo(`批量写入 ${messagesToWrite.length} 条消息到频道 ${channelKey}`);
   }
-  // 清理超量消息
   cleanExcessMessages(data) {
     let cleanedCount = 0;
     const cleanedMessages = {};
@@ -583,56 +793,37 @@ var FileManager = class {
       messages: cleanedMessages
     };
   }
-  // 添加消息到JSON文件（使用锁机制防止并发冲突）
   async addMessageToFile(messageInfo) {
-    this.fileOperationLock = this.fileOperationLock.then(async () => {
-      const data = this.readChatDataFromFile();
-      const channelKey = `${messageInfo.selfId}:${messageInfo.channelId}`;
-      if (!data.messages[channelKey]) {
-        data.messages[channelKey] = [];
-      }
-      const existingMessage = data.messages[channelKey].find((m) => m.id === messageInfo.id);
-      if (existingMessage) {
-        this.logInfo("消息已存在，跳过保存:", {
-          channelKey,
-          messageId: messageInfo.id,
-          existingType: existingMessage.type,
-          existingContent: existingMessage.content,
-          newType: messageInfo.type,
-          newContent: messageInfo.content
-        });
-        return;
-      }
+    const channelKey = `${messageInfo.selfId}:${messageInfo.channelId}`;
+    if (!this.pendingMessages.has(channelKey)) {
+      this.pendingMessages.set(channelKey, []);
+    }
+    this.pendingMessages.get(channelKey).push(messageInfo);
+    const data = this.memoryCache || this.readChatDataFromFile();
+    if (!data.messages[channelKey]) {
+      data.messages[channelKey] = [];
+    }
+    const existingMessage = data.messages[channelKey].find((m) => m.id === messageInfo.id);
+    if (!existingMessage) {
       if (!messageInfo.timestamp) {
         messageInfo.timestamp = Date.now();
       }
       const cleanedMessageInfo = this.utils.cleanBase64Content(messageInfo);
-      const beforeCount = data.messages[channelKey].length;
       data.messages[channelKey].push(cleanedMessageInfo);
-      const afterCount = data.messages[channelKey].length;
       if (data.messages[channelKey].length > this.config.maxMessagesPerChannel) {
         data.messages[channelKey].sort((a, b) => a.timestamp - b.timestamp);
-        const removedCount = data.messages[channelKey].length - this.config.maxMessagesPerChannel;
         data.messages[channelKey] = data.messages[channelKey].slice(-this.config.maxMessagesPerChannel);
-        this.logInfo(`频道 ${channelKey} 达到消息上限，清理了 ${removedCount} 条旧消息`);
       }
-      this.writeChatDataToFile(data);
-      const isCommandMessage = messageInfo.content?.startsWith("++") || messageInfo.content?.startsWith(".");
-      this.logInfo("添加消息到文件:", {
-        channelKey,
-        messageId: messageInfo.id,
-        content: messageInfo.content,
-        type: messageInfo.type,
-        userId: messageInfo.userId,
-        username: messageInfo.username,
-        timestamp: messageInfo.timestamp,
-        isCommandMessage,
-        消息数变化: `${beforeCount} -> ${afterCount} -> ${data.messages[channelKey].length}`
-      });
-    }).catch((error) => {
-      this.logger.error("保存消息时发生错误:", error);
-    });
-    await this.fileOperationLock;
+      this.memoryCache = data;
+    }
+    this.scheduleWrite(channelKey);
+  }
+  dispose() {
+    for (const [channelKey, timer] of this.writeTimers.entries()) {
+      timer();
+      this.flushPendingMessages(channelKey);
+    }
+    this.writeTimers.clear();
   }
   logInfo(...args) {
     if (this.config.loggerinfo) {
@@ -658,7 +849,6 @@ var ApiHandlers = class {
     __name(this, "ApiHandlers");
   }
   logger;
-  // 当前临时缓存的视频文件路径
   currentTempVideo = null;
   registerApiHandlers() {
     this.ctx.console.addListener("clear-all-indexeddb-data", async () => {
@@ -681,7 +871,6 @@ var ApiHandlers = class {
             channels: data.channels || {},
             pinnedBots: data.pinnedBots || [],
             pinnedChannels: data.pinnedChannels || [],
-            // 不返回 messages，由前端按需拉取
             messages: {}
           }
         };
@@ -1118,7 +1307,6 @@ var ApiHandlers = class {
       }
     });
   }
-  // 检查是否为文件 URL
   isFileUrl(url) {
     try {
       const parsedUrl = new import_node_url2.URL(url);
@@ -1127,7 +1315,6 @@ var ApiHandlers = class {
       return false;
     }
   }
-  // 创建文件 URL
   createFileUrl(filePath) {
     try {
       return (0, import_node_url2.pathToFileURL)(filePath).href;
@@ -1136,7 +1323,6 @@ var ApiHandlers = class {
       return `file://${filePath}`;
     }
   }
-  // 处理本地文件请求
   async handleLocalFileRequest(fileUrl) {
     try {
       const filePath = (0, import_node_url2.fileURLToPath)(fileUrl);
@@ -1158,13 +1344,11 @@ var ApiHandlers = class {
       };
     }
   }
-  // 设置定时清理临时文件
   setupTempFileCleanup() {
-    setInterval(() => {
+    this.ctx.setInterval(() => {
       this.cleanupMediaCache();
     }, 5 * 60 * 1e3);
   }
-  // 统一清理媒体缓存
   async cleanupMediaCache() {
     const baseDir = this.ctx.baseDir + "/data/chat-patch/persist-media";
     if (!require("node:fs").existsSync(baseDir)) return;
@@ -1291,23 +1475,55 @@ async function apply(ctx, config) {
     消息频道数: Object.keys(cleanedData.messages).length,
     总消息数: Object.values(cleanedData.messages).reduce((total, msgs) => total + msgs.length, 0)
   });
-  ctx.on("message", async (session) => {
-    if (utils.isPlatformBlocked(session.platform || "unknown")) {
-      logInfo(`忽略来自被屏蔽平台的消息: ${session.platform}`);
-      return;
-    }
-    await messageHandler.broadcastMessageEvent(session);
+  ctx.on("message", (session) => {
+    if (utils.isPlatformBlocked(session.platform || "unknown")) return;
+    const timestamp = Date.now();
+    ctx.console.broadcast("chat-message-event", {
+      type: "message",
+      selfId: session.selfId,
+      platform: session.platform || "unknown",
+      channelId: session.channelId,
+      messageId: session.event?.message?.id || `msg-${timestamp}`,
+      content: session.content || "",
+      userId: session.userId || "unknown",
+      username: session.username || session.userId || "unknown",
+      avatar: session.event?.user?.avatar,
+      timestamp,
+      isDirect: session.isDirect,
+      elements: utils.cleanBase64Content(session.elements, false),
+      bot: {
+        avatar: session.bot.user?.avatar,
+        name: session.bot.user?.name
+      }
+    });
+    messageHandler.recordUserMessage(session, timestamp);
   });
-  ctx.on("before-send", async (session) => {
-    if (utils.isPlatformBlocked(session.platform || "unknown")) {
-      logInfo(`忽略来自被屏蔽平台的机器人消息: ${session.platform}`);
-      return;
-    }
-    await messageHandler.broadcastBotMessageEvent(session);
+  ctx.on("before-send", (session) => {
+    if (utils.isPlatformBlocked(session.platform || "unknown")) return;
+    const timestamp = Date.now();
+    ctx.console.broadcast("chat-bot-message-event", {
+      type: "bot-message",
+      selfId: session.selfId,
+      platform: session.platform || "unknown",
+      channelId: session.channelId,
+      messageId: `bot-msg-${timestamp}`,
+      content: session.content || "",
+      userId: session.selfId,
+      username: session.bot.user?.name || `Bot-${session.selfId}`,
+      avatar: session.bot.user?.avatar,
+      timestamp,
+      sending: true,
+      elements: utils.cleanBase64Content(session.event?.message?.elements, true),
+      bot: {
+        avatar: session.bot.user?.avatar,
+        name: session.bot.user?.name
+      }
+    });
+    messageHandler.recordBotMessage(session, timestamp);
   });
   ctx.on("ready", async () => {
     logInfo("插件启动完成，开始监听消息");
-    setInterval(() => {
+    ctx.setInterval(() => {
       const data = fileManager.readChatDataFromFile();
       const cleanedData2 = fileManager.cleanExcessMessages(data);
       const originalCount2 = Object.values(data.messages).reduce((total, msgs) => total + msgs.length, 0);
@@ -1323,6 +1539,10 @@ async function apply(ctx, config) {
     dev: import_node_path3.default.resolve(__dirname, "../client/index.ts"),
     prod: import_node_path3.default.resolve(__dirname, "../dist")
   });
+  ctx.on("dispose", () => {
+    fileManager.dispose();
+    logInfo("插件已卸载，所有待处理的消息已写入");
+  });
 }
 __name(apply, "apply");
 // Annotate the CommonJS export names for ESM import in node: