koishi-plugin-chat-patch 2.4.5 → 3.0.1

package/lib/index.js

@@ -39,13 +39,13 @@ __export(src_exports, {
   usage: () => usage
 });
 module.exports = __toCommonJS(src_exports);
-var import_node_path3 = __toESM(require("node:path"));
+var import_node_path5 = __toESM(require("node:path"));
 
 // src/utils.ts
-var import_node_fs = require("node:fs");
 var import_node_path = require("node:path");
 var import_node_crypto = require("node:crypto");
 var import_node_url = require("node:url");
+var import_node_fs = require("node:fs");
 var Utils = class {
   constructor(config, ctx) {
     this.config = config;
@@ -54,6 +54,8 @@ var Utils = class {
   static {
     __name(this, "Utils");
   }
+  persistImageWriteCount = 0;
+  pendingTasks = /* @__PURE__ */ new Set();
   isPlatformBlocked(platform) {
     if (!this.config.blockedPlatforms || this.config.blockedPlatforms.length === 0) {
       return false;
@@ -97,33 +99,48 @@ var Utils = class {
     }
     return false;
   }
-  persistBase64Image(base64Data) {
+  async persistBase64ImageAsync(base64Data) {
     if (!this.ctx || !base64Data.startsWith("data:image/")) return base64Data;
     try {
       const dir = (0, import_node_path.join)(this.ctx.baseDir, "data", "chat-patch", "persist-images");
-      if (!(0, import_node_fs.existsSync)(dir)) (0, import_node_fs.mkdirSync)(dir, { recursive: true });
+      await import_node_fs.promises.mkdir(dir, { recursive: true });
       const hash = (0, import_node_crypto.createHash)("md5").update(base64Data).digest("hex");
       const ext = base64Data.split(";")[0].split("/")[1] || "png";
-      const filename = `${Date.now()}_${hash}.${ext}`;
+      const filename = `${hash}.${ext}`;
       const filePath = (0, import_node_path.join)(dir, filename);
-      const base64Content = base64Data.split(",")[1];
-      (0, import_node_fs.writeFileSync)(filePath, Buffer.from(base64Content, "base64"));
-      this.cleanupPersistImages(dir);
+      if (!await this.fileExists(filePath)) {
+        const base64Content = base64Data.split(",")[1];
+        await import_node_fs.promises.writeFile(filePath, Buffer.from(base64Content, "base64"));
+      }
+      this.persistImageWriteCount += 1;
+      if (this.persistImageWriteCount % 20 === 0) {
+        this.trackTask(this.cleanupPersistImagesAsync(dir));
+      }
       return (0, import_node_url.pathToFileURL)(filePath).href;
-    } catch (e) {
+    } catch {
       return base64Data;
     }
   }
-  cleanupPersistImages(dir) {
+  async cleanupPersistImagesAsync(dir) {
     try {
-      const files = (0, import_node_fs.readdirSync)(dir).map((name2) => ({ name: name2, path: (0, import_node_path.join)(dir, name2), mtime: (0, import_node_fs.statSync)((0, import_node_path.join)(dir, name2)).mtimeMs })).sort((a, b) => b.mtime - a.mtime);
-      if (files.length > this.config.maxPersistImages) {
-        files.slice(this.config.maxPersistImages).forEach((f) => (0, import_node_fs.unlinkSync)(f.path));
+      const fileNames = await import_node_fs.promises.readdir(dir);
+      const files = await Promise.all(fileNames.map(async (name2) => {
+        const filePath = (0, import_node_path.join)(dir, name2);
+        const stats = await import_node_fs.promises.stat(filePath);
+        return { path: filePath, mtime: stats.mtimeMs };
+      }));
+      files.sort((a, b) => b.mtime - a.mtime);
+      for (const file of files.slice(this.config.maxPersistImages)) {
+        try {
+          await import_node_fs.promises.unlink(file.path);
+        } catch {
+          continue;
+        }
       }
-    } catch (e) {
+    } catch {
     }
   }
-  cleanBase64Content(obj, isBotMessage = false) {
+  async cleanBase64ContentAsync(obj, isBotMessage = false) {
     if (obj === null || obj === void 0) {
       return obj;
     }
@@ -132,17 +149,20 @@ var Utils = class {
         if (isBotMessage && !obj.startsWith("data:image/")) {
           return "[富媒体内容已省略]";
         }
-        return this.persistBase64Image(obj);
+        return await this.persistBase64ImageAsync(obj);
       }
       return obj;
     }
     if (Array.isArray(obj)) {
-      return obj.map((item) => this.cleanBase64Content(item, isBotMessage));
+      const cleanedItems = await Promise.all(obj.map((item) => this.cleanBase64ContentAsync(item, isBotMessage)));
+      return cleanedItems;
     }
     if (typeof obj === "object") {
       const cleaned = {};
-      for (const [key, value] of Object.entries(obj)) {
-        if (isBotMessage && obj.type && !["text", "image", "img"].includes(obj.type)) {
+      const source = obj;
+      for (const [key, value] of Object.entries(source)) {
+        const type = typeof source.type === "string" ? source.type : void 0;
+        if (isBotMessage && type && !["text", "image", "img"].includes(type)) {
           if (typeof value === "string" && (key === "src" || key === "url" || key === "file") && this.isBase64(value)) {
             cleaned[key] = "[富媒体内容已省略]";
             continue;
@@ -152,78 +172,90 @@ var Utils = class {
           if (isBotMessage && !value.startsWith("data:image/")) {
             cleaned[key] = "[富媒体内容已省略]";
           } else {
-            cleaned[key] = this.persistBase64Image(value);
+            cleaned[key] = await this.persistBase64ImageAsync(value);
           }
         } else {
-          cleaned[key] = this.cleanBase64Content(value, isBotMessage);
+          cleaned[key] = await this.cleanBase64ContentAsync(value, isBotMessage);
         }
       }
       return cleaned;
     }
     return obj;
   }
+  async dispose() {
+    await Promise.allSettled([...this.pendingTasks]);
+  }
+  trackTask(task) {
+    this.pendingTasks.add(task);
+    void task.finally(() => {
+      this.pendingTasks.delete(task);
+    });
+  }
+  async fileExists(filePath) {
+    try {
+      await import_node_fs.promises.access(filePath);
+      return true;
+    } catch {
+      return false;
+    }
+  }
 };
 
 // src/message-handler.ts
+var import_node_fs2 = require("node:fs");
+var import_node_path2 = __toESM(require("node:path"));
+var import_node_crypto2 = require("node:crypto");
 var MessageHandler = class {
-  constructor(ctx, config, fileManager) {
+  constructor(ctx, config, fileManager, logger) {
     this.ctx = ctx;
     this.config = config;
     this.fileManager = fileManager;
-    this.logger = ctx.logger("chat-patch");
+    this.logger = logger;
     this.utils = new Utils(config);
   }
   static {
     __name(this, "MessageHandler");
   }
-  logger;
   utils;
   correctChannelIds = /* @__PURE__ */ new Map();
+  scheduledTasks = /* @__PURE__ */ new Set();
+  channelRefreshInFlight = /* @__PURE__ */ new Set();
+  lastChannelRefreshAt = /* @__PURE__ */ new Map();
+  CHANNEL_REFRESH_TTL_MS = 10 * 60 * 1e3;
   recordUserMessage(session, timestamp) {
-    setImmediate(() => {
-      this.processUserMessage(session, timestamp).catch((error) => {
-        this.logger.error("记录用户消息失败:", error);
-      });
+    this.scheduleTask("记录用户消息", async () => {
+      await this.processUserMessage(session, timestamp);
     });
   }
   recordBotMessage(session, timestamp) {
-    setImmediate(() => {
-      this.processBotMessage(session, timestamp).catch((error) => {
-        this.logger.error("记录机器人消息失败:", error);
-      });
+    this.scheduleTask("记录机器人消息", async () => {
+      await this.processBotMessage(session, timestamp);
     });
   }
   setCorrectChannelId(selfId, channelId) {
     this.correctChannelIds.set(selfId, channelId);
-    this.logInfo("设置正确的 channelId:", { selfId, channelId });
+    this.logger.logInfo("设置正确的 channelId:", { selfId, channelId });
   }
   getCorrectChannelId(selfId) {
     return this.correctChannelIds.get(selfId);
   }
   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);
-      }
+    this.scheduleTask("更新机器人信息", async () => {
+      const botInfo = {
+        selfId: session.selfId,
+        platform: session.platform || "unknown",
+        username: session.bot.user?.name || `Bot-${session.selfId}`,
+        avatar: session.bot.user?.avatar,
+        status: "online"
+      };
+      await this.fileManager.upsertBotInfo(botInfo);
+      this.logger.logInfo("更新机器人信息到文件:", botInfo.username);
     });
   }
   updateChannelInfoToFile(session) {
     const isDirect = session.isDirect || session.channelId?.includes("private");
     const directUserName = session.username || session.event?.user?.name || session.userId;
-    const data = this.fileManager.readChatDataFromFile();
-    const existingChannel = data.channels[session.selfId]?.[session.channelId];
+    const existingChannel = this.fileManager.getCachedChannelInfo(session.selfId, session.channelId);
     let immediateName = session.channelId;
     if (isDirect) {
       if (directUserName && directUserName !== session.userId) {
@@ -238,68 +270,12 @@ var MessageHandler = class {
     } else if (existingChannel?.guildName) {
       immediateName = existingChannel.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);
-      }
-    });
+    const channelKey = `${session.selfId}:${session.channelId}`;
+    if (this.shouldRefreshChannelInfo(channelKey, existingChannel, isDirect, session.channelId, directUserName)) {
+      this.scheduleTask("更新频道信息", async () => {
+        await this.refreshChannelInfo(session, existingChannel, isDirect, directUserName);
+      });
+    }
     return immediateName;
   }
   async downloadAndCacheMedia(url, type) {
@@ -309,18 +285,15 @@ var MessageHandler = class {
       let folder = "media";
       if (type === "image") folder = "images";
       else if (type === "avatar") folder = "avatars";
-      const dir = require("node:path").join(this.ctx.baseDir, "data", "chat-patch", "persist-media", folder);
-      if (!require("node:fs").existsSync(dir)) {
-        require("node:fs").mkdirSync(dir, { recursive: true });
-      }
-      const crypto = require("node:crypto");
-      const hash = crypto.createHash("md5").update(url).digest("hex");
-      const ext = require("node:path").extname(new URL(url).pathname) || (type === "image" ? ".jpg" : ".mp4");
+      const dir = import_node_path2.default.join(this.ctx.baseDir, "data", "chat-patch", "persist-media", folder);
+      await import_node_fs2.promises.mkdir(dir, { recursive: true });
+      const hash = (0, import_node_crypto2.createHash)("md5").update(url).digest("hex");
+      const ext = import_node_path2.default.extname(new URL(url).pathname) || (type === "image" ? ".jpg" : ".mp4");
       const filename = `${hash}${ext}`;
-      const filePath = require("node:path").join(dir, filename);
-      if (!require("node:fs").existsSync(filePath)) {
+      const filePath = import_node_path2.default.join(dir, filename);
+      if (!await this.fileExists(filePath)) {
         const buffer = await this.ctx.http.get(url, { responseType: "arraybuffer" });
-        require("node:fs").writeFileSync(filePath, Buffer.from(buffer));
+        await import_node_fs2.promises.writeFile(filePath, Buffer.from(buffer));
       }
       const normalizedPath = filePath.replace(/\\/g, "/");
       return `/vite/@fs/${normalizedPath}`;
@@ -331,29 +304,8 @@ var MessageHandler = class {
   }
   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);
-      }
+    this.scheduleTask("处理媒体元素", async () => {
+      await this.processMediaElements(elements, isUserMessage);
     });
   }
   async processUserMessage(session, timestamp) {
@@ -407,14 +359,18 @@ var MessageHandler = class {
         timestamp,
         channelId: session.channelId,
         selfId: session.selfId,
-        elements: this.utils.cleanBase64Content(elements, false),
+        elements,
         type: "user",
         guildName,
         platform: session.platform || "unknown",
-        quote: quoteInfo ? this.utils.cleanBase64Content(quoteInfo, false) : void 0,
+        quote: quoteInfo,
         isDirect: !!isDirect
       };
+      messageInfo.elements = await this.utils.cleanBase64ContentAsync(messageInfo.elements, false);
+      messageInfo.quote = messageInfo.quote ? await this.utils.cleanBase64ContentAsync(messageInfo.quote, false) : void 0;
       await this.fileManager.addMessageToFile(messageInfo);
+      const eventElements = await this.utils.cleanBase64ContentAsync(elements, false);
+      const eventQuote = quoteInfo ? await this.utils.cleanBase64ContentAsync(quoteInfo, false) : void 0;
       const messageEvent = {
         type: "message",
         selfId: session.selfId,
@@ -428,8 +384,8 @@ var MessageHandler = class {
         timestamp,
         guildName,
         channelType: session.type || 0,
-        elements: this.utils.cleanBase64Content(elements, false),
-        quote: quoteInfo ? this.utils.cleanBase64Content(quoteInfo, false) : void 0,
+        elements: eventElements,
+        quote: eventQuote,
         isDirect: session.isDirect,
         bot: {
           avatar: session.bot.user?.avatar,
@@ -457,9 +413,7 @@ var MessageHandler = class {
       const quoteMatch = content.match(/<quote id="([^"]+)"\/>/);
       if (quoteMatch) {
         const quoteId = quoteMatch[1];
-        const data = this.fileManager.readChatDataFromFile();
-        const channelKey = `${session.selfId}:${finalChannelId}`;
-        const quotedMsg = data.messages[channelKey]?.find((m) => m.id === quoteId);
+        const quotedMsg = await this.fileManager.findChannelMessageById(session.selfId, finalChannelId, quoteId);
         if (quotedMsg) {
           const realId = quotedMsg.id.startsWith("bot-msg-") ? quotedMsg.realId : quotedMsg.id;
           quoteInfo = {
@@ -491,7 +445,7 @@ var MessageHandler = class {
         timestamp,
         channelId: finalChannelId,
         selfId: session.selfId,
-        elements: this.utils.cleanBase64Content(session.event?.message?.elements, true),
+        elements: await this.utils.cleanBase64ContentAsync(session.event?.message?.elements, true),
         type: "bot",
         guildName,
         platform: session.platform || "unknown",
@@ -501,6 +455,7 @@ var MessageHandler = class {
         // 标记为正在发送
       };
       await this.fileManager.addMessageToFile(messageInfo);
+      const eventElements = await this.utils.cleanBase64ContentAsync(session.event?.message?.elements, true);
       const messageEvent = {
         type: "bot-message",
         selfId: session.selfId,
@@ -514,7 +469,7 @@ var MessageHandler = class {
         timestamp,
         guildName,
         channelType: session.event?.channel?.type || session.type || 0,
-        elements: this.utils.cleanBase64Content(session.event?.message?.elements, true),
+        elements: eventElements,
         quote: quoteInfo,
         isDirect: !!isDirect,
         sending: true,
@@ -528,333 +483,1276 @@ var MessageHandler = class {
       this.logger.error("处理机器人消息失败:", error);
     }
   }
-  logInfo(...args) {
-    if (this.config.loggerinfo) {
-      this.logger.info(...args);
+  dispose() {
+    void this.utils.dispose();
+    for (const dispose of this.scheduledTasks) {
+      dispose();
+    }
+    this.scheduledTasks.clear();
+  }
+  scheduleTask(label, task) {
+    const dispose = this.ctx.setTimeout(() => {
+      this.scheduledTasks.delete(dispose);
+      void task().catch((error) => {
+        this.logger.error(`${label}失败:`, error);
+      });
+    }, 0);
+    this.scheduledTasks.add(dispose);
+  }
+  shouldRefreshChannelInfo(channelKey, existingChannel, isDirect, channelId, directUserName) {
+    if (this.channelRefreshInFlight.has(channelKey)) {
+      return false;
+    }
+    const lastRefresh = this.lastChannelRefreshAt.get(channelKey) || 0;
+    if (Date.now() - lastRefresh < this.CHANNEL_REFRESH_TTL_MS) {
+      return false;
+    }
+    if (isDirect) {
+      return !directUserName && (!existingChannel || existingChannel.name.includes("未知"));
+    }
+    return !existingChannel?.guildName || existingChannel.guildName === channelId;
+  }
+  async refreshChannelInfo(session, existingChannel, isDirect, directUserName) {
+    const channelKey = `${session.selfId}:${session.channelId}`;
+    this.channelRefreshInFlight.add(channelKey);
+    try {
+      let guildName = existingChannel?.guildName || session.channelId;
+      if (!isDirect) {
+        guildName = await this.resolveGuildName(session);
+      }
+      const finalName = this.buildChannelName(session, existingChannel, isDirect, directUserName, guildName);
+      const channelInfo = {
+        id: session.channelId,
+        name: finalName,
+        type: session.type || 0,
+        channelId: session.channelId,
+        guildName,
+        isDirect: !!isDirect
+      };
+      await this.fileManager.upsertChannelInfo(session.selfId, session.channelId, channelInfo);
+      this.lastChannelRefreshAt.set(channelKey, Date.now());
+      this.logger.logInfo("更新频道信息到文件:", channelInfo.name);
+    } finally {
+      this.channelRefreshInFlight.delete(channelKey);
+    }
+  }
+  async resolveGuildName(session) {
+    try {
+      if (session.guildId && session.bot.getGuild && typeof session.bot.getGuild === "function") {
+        const guild = await session.bot.getGuild(session.guildId);
+        return guild?.name || session.channelId;
+      }
+      if (session.guildId && session.bot.getChannel && typeof session.bot.getChannel === "function") {
+        const channel = await session.bot.getChannel(session.guildId);
+        return channel?.name || session.channelId;
+      }
+    } catch (error) {
+      this.logger.logInfo("获取频道信息失败，使用频道ID作为备用:", error);
+    }
+    return session.channelId;
+  }
+  buildChannelName(session, existingChannel, isDirect, directUserName, guildName) {
+    if (isDirect) {
+      if (directUserName && directUserName !== session.userId) {
+        return `私聊（${directUserName}）`;
+      }
+      if (existingChannel?.name && !existingChannel.name.includes("未知")) {
+        return existingChannel.name;
+      }
+      if (session.platform && session.platform.toLowerCase().includes("sandbox")) {
+        return `私聊（${session.userId}）`;
+      }
+      return "私聊（未知用户）";
+    }
+    return guildName || session.channelId;
+  }
+  async processMediaElements(elements, isUserMessage) {
+    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) {
+          try {
+            await this.downloadAndCacheMedia(src, "image");
+          } catch (error) {
+            this.logger.warn("缓存图片失败:", error);
+          }
+        }
+      } else if (el.type === "audio") {
+        const src = el.attrs.src || el.attrs.url || el.attrs.file;
+        if (src && isUserMessage) {
+          try {
+            await this.downloadAndCacheMedia(src, "media");
+          } catch (error) {
+            this.logger.warn("缓存语音失败:", error);
+          }
+        }
+      }
+      if (el.children?.length) {
+        await this.processMediaElements(el.children, isUserMessage);
+      }
+    }
+  }
+  async fileExists(filePath) {
+    try {
+      await import_node_fs2.promises.access(filePath);
+      return true;
+    } catch {
+      return false;
     }
   }
 };
 
 // src/file-manager.ts
-var import_node_path2 = __toESM(require("node:path"));
-var import_node_fs2 = __toESM(require("node:fs"));
+var import_node_path3 = __toESM(require("node:path"));
+var import_node_fs3 = require("node:fs");
 var FileManager = class {
-  constructor(ctx, config) {
+  constructor(ctx, config, logger) {
     this.ctx = ctx;
     this.config = config;
-    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();
+    this.logger = logger;
+    const baseDir = import_node_path3.default.resolve(ctx.baseDir, "data", "chat-patch");
+    this.storageBaseDir = import_node_path3.default.join(baseDir, "v2");
+    this.chatHistoryDir = import_node_path3.default.join(this.storageBaseDir, "chat-history");
+    this.metadataFilePath = import_node_path3.default.join(this.storageBaseDir, "metadata.json");
+    this.utils = new Utils(config, ctx);
+    this.ctx.setTimeout(() => {
+      void this.cleanupLegacyStorage(baseDir);
+    }, 0);
   }
   static {
     __name(this, "FileManager");
   }
+  storageBaseDir;
   chatHistoryDir;
   // 聊天记录根目录
   metadataFilePath;
   // 元数据文件路径（存储bots、channels、pinned等信息）
-  logger;
   utils;
-  memoryCache = null;
+  memoryCache = this.createEmptyChatData();
+  channelMessagesCache = /* @__PURE__ */ new Map();
+  recentMessageIdsCache = /* @__PURE__ */ new Map();
+  pendingBotMessageIds = /* @__PURE__ */ new Map();
+  messageChunkLocationCache = /* @__PURE__ */ new Map();
+  dirtyChannelKeys = /* @__PURE__ */ new Set();
   pendingMessages = /* @__PURE__ */ new Map();
   // 按channelKey分组的待写入消息
   writeTimers = /* @__PURE__ */ new Map();
   // 每个频道独立的写入定时器
+  metadataLoadPromise = null;
+  channelLoadPromises = /* @__PURE__ */ new Map();
+  writeQueue = Promise.resolve();
+  disposed = false;
   WRITE_DEBOUNCE_MS = 1e3;
-  // 清理旧版本的JSON文件
-  cleanupOldDataFiles(baseDir) {
+  RECENT_MESSAGE_ID_CACHE_SIZE = 200;
+  async initialize() {
+    await this.ensureMetadataLoaded();
+  }
+  readChatDataFromFile() {
+    this.memoryCache.messages = this.getChannelMessagesCacheSnapshot();
+    return this.memoryCache;
+  }
+  getCachedChannelInfo(selfId, channelId) {
+    return this.memoryCache.channels[selfId]?.[channelId];
+  }
+  async readMetadataOnly() {
+    await this.ensureMetadataLoaded();
+    const { messages, ...metadata } = this.memoryCache;
+    return { ...metadata };
+  }
+  async upsertBotInfo(botInfo) {
+    await this.ensureMetadataLoaded();
+    const current = this.memoryCache.bots[botInfo.selfId];
+    if (current && this.isSameBotInfo(current, botInfo)) {
+      return;
+    }
+    this.memoryCache.bots[botInfo.selfId] = botInfo;
+    this.scheduleMetadataWrite();
+  }
+  async upsertChannelInfo(selfId, channelId, channelInfo) {
+    await this.ensureMetadataLoaded();
+    if (!this.memoryCache.channels[selfId]) {
+      this.memoryCache.channels[selfId] = {};
+    }
+    const current = this.memoryCache.channels[selfId][channelId];
+    if (current && this.isSameChannelInfo(current, channelInfo)) {
+      return;
+    }
+    this.memoryCache.channels[selfId][channelId] = channelInfo;
+    this.scheduleMetadataWrite();
+  }
+  async setPinnedBots(pinnedBots) {
+    await this.ensureMetadataLoaded();
+    this.memoryCache.pinnedBots = [...pinnedBots];
+    this.scheduleMetadataWrite();
+  }
+  async setPinnedChannels(pinnedChannels) {
+    await this.ensureMetadataLoaded();
+    this.memoryCache.pinnedChannels = [...pinnedChannels];
+    this.scheduleMetadataWrite();
+  }
+  // 清理旧版本数据目录
+  async cleanupLegacyStorage(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) {
+      const filePath = import_node_path3.default.join(baseDir, fileName);
+      try {
+        await import_node_fs3.promises.unlink(filePath);
+        this.logger.logInfo(`已删除旧版本数据文件: ${fileName}`);
+      } catch (error) {
+        if (!this.isFileMissingError(error)) {
           this.logger.warn(`删除旧版本数据文件失败: ${fileName}`, error);
         }
       }
     }
+    const legacyPaths = [
+      import_node_path3.default.join(baseDir, "metadata.json"),
+      import_node_path3.default.join(baseDir, "chat-history")
+    ];
+    for (const legacyPath of legacyPaths) {
+      try {
+        await import_node_fs3.promises.rm(legacyPath, { recursive: true, force: true });
+        this.logger.logInfo(`已清理旧版数据路径: ${legacyPath}`);
+      } catch (error) {
+        this.logger.warn(`清理旧版数据路径失败: ${legacyPath}`, error);
+      }
+    }
+  }
+  // 确保目录存在
+  async ensureDir(dirPath) {
+    await import_node_fs3.promises.mkdir(dirPath, { recursive: true });
+  }
+  // 读取单个频道的消息（公共方法）
+  async readChannelMessages(selfId, channelId) {
+    await this.ensureMetadataLoaded();
+    const channelKey = `${selfId}:${channelId}`;
+    const cached = this.getCachedChannelMessages(channelKey);
+    if (cached) {
+      return cached;
+    }
+    const existingPromise = this.channelLoadPromises.get(channelKey);
+    if (existingPromise) {
+      return existingPromise;
+    }
+    const loadPromise = this.loadChannelMessages(selfId, channelId);
+    this.channelLoadPromises.set(channelKey, loadPromise);
+    try {
+      return await loadPromise;
+    } finally {
+      this.channelLoadPromises.delete(channelKey);
+    }
+  }
+  async readChannelMessagesPage(selfId, channelId, limit, offset = 0) {
+    await this.ensureMetadataLoaded();
+    const indexData = await this.loadOrCreateChannelIndex(selfId, channelId);
+    if (limit <= 0 || offset >= indexData.totalMessages) {
+      return {
+        messages: [],
+        total: indexData.totalMessages
+      };
+    }
+    const entry = this.createStoredChannelEntry(selfId, channelId);
+    const collected = [];
+    let skipped = 0;
+    for (let chunkIndex = indexData.chunks.length - 1; chunkIndex >= 0; chunkIndex -= 1) {
+      const chunk = indexData.chunks[chunkIndex];
+      const chunkMessages = await this.readChunkMessages(entry.channelDirPath, chunk.fileName);
+      for (let messageIndex = chunkMessages.length - 1; messageIndex >= 0; messageIndex -= 1) {
+        if (skipped < offset) {
+          skipped += 1;
+          continue;
+        }
+        collected.push(chunkMessages[messageIndex]);
+        if (collected.length >= limit) {
+          return {
+            messages: collected.reverse(),
+            total: indexData.totalMessages
+          };
+        }
+      }
+    }
+    return {
+      messages: collected.reverse(),
+      total: indexData.totalMessages
+    };
+  }
+  async findChannelMessageById(selfId, channelId, messageId) {
+    await this.ensureMetadataLoaded();
+    const channelKey = `${selfId}:${channelId}`;
+    const cachedMessages = this.peekCachedChannelMessages(channelKey);
+    const cachedMatched = cachedMessages?.find((message) => message.id === messageId);
+    if (cachedMatched) {
+      return cachedMatched;
+    }
+    const entry = this.createStoredChannelEntry(selfId, channelId);
+    const indexData = await this.loadOrCreateChannelIndex(selfId, channelId);
+    for (let chunkIndex = indexData.chunks.length - 1; chunkIndex >= 0; chunkIndex -= 1) {
+      const chunk = indexData.chunks[chunkIndex];
+      const messages = await this.readChunkMessages(entry.channelDirPath, chunk.fileName);
+      const matched = messages.find((message) => message.id === messageId);
+      if (matched) {
+        return matched;
+      }
+    }
+    return null;
+  }
+  // 读取元数据（bots、channels、pinned等）
+  async readMetadata() {
+    try {
+      const jsonData = await import_node_fs3.promises.readFile(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) {
+      if (this.isFileMissingError(error)) {
+        return {
+          bots: {},
+          channels: {},
+          pinnedBots: [],
+          pinnedChannels: []
+        };
+      }
+      this.logger.error("读取元数据失败:", error);
+      return {
+        bots: {},
+        channels: {},
+        pinnedBots: [],
+        pinnedChannels: []
+      };
+    }
+  }
+  // 写入元数据
+  async writeMetadata(metadata) {
+    try {
+      await this.ensureDir(import_node_path3.default.dirname(this.metadataFilePath));
+      const dataToWrite = {
+        ...metadata,
+        lastSaveTime: Date.now()
+      };
+      const jsonData = JSON.stringify(dataToWrite, null, 2);
+      await this.atomicWriteTextFile(this.metadataFilePath, jsonData);
+    } catch (error) {
+      this.logger.error("写入元数据失败:", error);
+    }
+  }
+  // 为特定频道安排写入
+  scheduleWrite(channelKey) {
+    const existingTimer = this.writeTimers.get(channelKey);
+    if (existingTimer) {
+      existingTimer();
+    }
+    const timer = this.ctx.setTimeout(() => {
+      this.writeTimers.delete(channelKey);
+      void this.flushPendingMessages(channelKey);
+    }, this.WRITE_DEBOUNCE_MS);
+    this.writeTimers.set(channelKey, timer);
+  }
+  // 刷新特定频道的待写入消息
+  async flushPendingMessages(channelKey) {
+    const messagesToWrite = this.pendingMessages.get(channelKey);
+    if (!messagesToWrite || messagesToWrite.length === 0) return;
+    this.pendingMessages.delete(channelKey);
+    const cachedMessages = this.peekCachedChannelMessages(channelKey);
+    const [selfId, channelId] = channelKey.split(":");
+    if (!selfId || !channelId) return;
+    const uniqueMessages = this.deduplicateMessages(messagesToWrite);
+    if (!uniqueMessages.length) {
+      return;
+    }
+    if (cachedMessages) {
+      const nextMessages = this.mergeChannelMessages(cachedMessages, uniqueMessages);
+      this.setCachedChannelMessages(channelKey, this.limitChannelMessages(nextMessages));
+    }
+    this.rememberRecentMessageIds(channelKey, uniqueMessages.map((message) => message.id));
+    this.enqueueWrite(async () => {
+      await this.appendMessagesToChannel(selfId, channelId, uniqueMessages);
+      this.logger.logInfo(`批量写入 ${uniqueMessages.length} 条消息到频道 ${channelKey}`);
+    });
+  }
+  cleanExcessMessages(data) {
+    let cleanedCount = 0;
+    const cleanedMessages = {};
+    for (const [channelKey, messages] of Object.entries(data.messages)) {
+      if (messages.length > this.config.maxMessagesPerChannel) {
+        const sortedMessages = [...messages].sort((a, b) => a.timestamp - b.timestamp);
+        const keptMessages = sortedMessages.slice(-this.config.maxMessagesPerChannel);
+        cleanedCount += messages.length - keptMessages.length;
+        cleanedMessages[channelKey] = keptMessages;
+        this.logger.logInfo(`频道 ${channelKey} 清理了 ${messages.length - keptMessages.length} 条旧消息，保留最新 ${keptMessages.length} 条`);
+      } else {
+        cleanedMessages[channelKey] = messages;
+      }
+    }
+    if (cleanedCount > 0) {
+      this.logger.logInfo("总共清理超量消息:", cleanedCount, "条");
+    }
+    return {
+      ...data,
+      messages: cleanedMessages
+    };
+  }
+  async addMessageToFile(messageInfo) {
+    await this.ensureMetadataLoaded();
+    const channelKey = `${messageInfo.selfId}:${messageInfo.channelId}`;
+    if (!messageInfo.timestamp) {
+      messageInfo.timestamp = Date.now();
+    }
+    const cleanedMessageInfo = await this.utils.cleanBase64ContentAsync(messageInfo, false);
+    const pendingMessages = this.pendingMessages.get(channelKey) || [];
+    if (pendingMessages.some((message) => message.id === cleanedMessageInfo.id)) {
+      return;
+    }
+    const cachedMessages = this.peekCachedChannelMessages(channelKey);
+    if (cachedMessages?.some((message) => message.id === cleanedMessageInfo.id)) {
+      return;
+    }
+    if (!cachedMessages) {
+      if (this.hasRecentMessageId(channelKey, cleanedMessageInfo.id)) {
+        return;
+      }
+      const existsInStorage = await this.channelMessageExists(messageInfo.selfId, messageInfo.channelId, cleanedMessageInfo.id);
+      if (existsInStorage) {
+        return;
+      }
+    }
+    pendingMessages.push(cleanedMessageInfo);
+    this.pendingMessages.set(channelKey, pendingMessages);
+    this.rememberRecentMessageIds(channelKey, [cleanedMessageInfo.id]);
+    if (cleanedMessageInfo.type === "bot" && cleanedMessageInfo.sending) {
+      this.registerPendingBotMessage(channelKey, cleanedMessageInfo.id);
+    }
+    if (cachedMessages) {
+      const nextMessages = this.mergeChannelMessages(cachedMessages, [cleanedMessageInfo]);
+      this.setCachedChannelMessages(channelKey, this.limitChannelMessages(nextMessages));
+    }
+    this.scheduleWrite(channelKey);
+  }
+  async cleanupExcessMessagesInStorage() {
+    let cleanedCount = 0;
+    for (const channelKey of [...this.dirtyChannelKeys]) {
+      const [selfId, channelId] = channelKey.split(":");
+      if (!selfId || !channelId) {
+        this.dirtyChannelKeys.delete(channelKey);
+        continue;
+      }
+      const indexData = await this.loadOrCreateChannelIndex(selfId, channelId);
+      if (indexData.totalMessages <= this.config.maxMessagesPerChannel) {
+        this.dirtyChannelKeys.delete(channelKey);
+        continue;
+      }
+      const removedCount = await this.trimChannelToLimit(selfId, channelId, indexData, this.config.maxMessagesPerChannel);
+      if (!removedCount) {
+        continue;
+      }
+      cleanedCount += removedCount;
+      if (this.peekCachedChannelMessages(channelKey)) {
+        this.setCachedChannelMessages(channelKey, await this.loadChannelMessagesNoCache(selfId, channelId));
+      }
+      this.dirtyChannelKeys.delete(channelKey);
+      this.logger.logInfo(`频道 ${channelKey} 清理了 ${removedCount} 条旧消息，保留最新 ${indexData.totalMessages} 条`);
+    }
+    if (cleanedCount > 0) {
+      this.logger.logInfo("定期清理完成，清理了", cleanedCount, "条超量消息");
+    }
+  }
+  async getAllChannelMessageCounts() {
+    const counts = {};
+    await this.scanStoredChannels(async (entry) => {
+      counts[entry.channelKey] = await this.countChannelMessages(entry.selfId, entry.channelId);
+    });
+    return counts;
+  }
+  async deleteChannelData(selfId, channelId) {
+    await this.ensureMetadataLoaded();
+    const channelKey = `${selfId}:${channelId}`;
+    const deletedMessages = await this.countChannelMessages(selfId, channelId);
+    this.deleteCachedChannelMessages(channelKey);
+    this.deleteRecentMessageIds(channelKey);
+    this.deletePendingBotMessages(channelKey);
+    this.deleteMessageChunkLocations(channelKey);
+    this.dirtyChannelKeys.delete(channelKey);
+    this.pendingMessages.delete(channelKey);
+    const timer = this.writeTimers.get(channelKey);
+    if (timer) {
+      timer();
+      this.writeTimers.delete(channelKey);
+    }
+    if (this.memoryCache.channels[selfId]?.[channelId]) {
+      delete this.memoryCache.channels[selfId][channelId];
+      if (!Object.keys(this.memoryCache.channels[selfId]).length) {
+        delete this.memoryCache.channels[selfId];
+      }
+    }
+    this.memoryCache.pinnedChannels = this.memoryCache.pinnedChannels.filter((item) => item !== channelKey);
+    await this.removeChannelStorage(selfId, channelId);
+    this.scheduleMetadataWrite();
+    return { deletedMessages };
+  }
+  async deleteBotData(selfId) {
+    await this.ensureMetadataLoaded();
+    const botDir = import_node_path3.default.join(this.chatHistoryDir, selfId);
+    const channels = await this.listBotChannels(selfId);
+    let deletedMessages = 0;
+    for (const entry of channels) {
+      deletedMessages += await this.countChannelMessages(entry.selfId, entry.channelId);
+      this.deleteCachedChannelMessages(entry.channelKey);
+      this.deleteRecentMessageIds(entry.channelKey);
+      this.deletePendingBotMessages(entry.channelKey);
+      this.deleteMessageChunkLocations(entry.channelKey);
+      this.dirtyChannelKeys.delete(entry.channelKey);
+      this.pendingMessages.delete(entry.channelKey);
+      const timer = this.writeTimers.get(entry.channelKey);
+      if (timer) {
+        timer();
+        this.writeTimers.delete(entry.channelKey);
+      }
+    }
+    const deletedChannels = channels.length;
+    delete this.memoryCache.bots[selfId];
+    delete this.memoryCache.channels[selfId];
+    this.memoryCache.pinnedBots = this.memoryCache.pinnedBots.filter((item) => item !== selfId);
+    this.memoryCache.pinnedChannels = this.memoryCache.pinnedChannels.filter((item) => !item.startsWith(`${selfId}:`));
+    try {
+      await import_node_fs3.promises.rm(botDir, { recursive: true, force: true });
+    } catch (error) {
+      this.logger.error(`删除机器人目录失败 [${selfId}]:`, error);
+    }
+    this.scheduleMetadataWrite();
+    return {
+      deletedChannels,
+      deletedMessages
+    };
+  }
+  async updateUserProfileInBotData(selfId, userId, userName, avatar) {
+    await this.ensureMetadataLoaded();
+    let changed = false;
+    const botChannels = this.memoryCache.channels[selfId] || {};
+    const possibleChannelIds = [
+      userId,
+      `private:${userId}`,
+      `direct:${userId}`
+    ];
+    for (const channelId of possibleChannelIds) {
+      const channel = botChannels[channelId];
+      if (!channel || !channel.isDirect || !userName) {
+        continue;
+      }
+      const newName = `私聊（${userName}）`;
+      if (channel.name !== newName) {
+        channel.name = newName;
+        changed = true;
+      }
+    }
+    const channels = await this.listBotChannels(selfId);
+    for (const entry of channels) {
+      const entryChanged = await this.updateUserProfileInChannel(entry.selfId, entry.channelId, userId, userName, avatar);
+      if (!entryChanged) {
+        continue;
+      }
+      if (this.peekCachedChannelMessages(entry.channelKey)) {
+        this.setCachedChannelMessages(entry.channelKey, await this.loadChannelMessagesNoCache(entry.selfId, entry.channelId));
+      }
+      changed = true;
+    }
+    if (changed) {
+      this.scheduleMetadataWrite();
+    }
+    return changed;
+  }
+  async markLatestBotMessageAsSent(selfId, channelId, realId) {
+    const channelKey = `${selfId}:${channelId}`;
+    const tempMessageId = this.peekLatestPendingBotMessageId(channelKey);
+    let matched;
+    if (tempMessageId) {
+      matched = await this.findAndUpdateBotMessageByTempId(selfId, channelId, tempMessageId, realId);
+      this.consumePendingBotMessageId(channelKey, tempMessageId);
+    }
+    if (!matched) {
+      matched = await this.findAndUpdateLatestBotMessage(selfId, channelId, realId);
+    }
+    if (!matched) {
+      return void 0;
+    }
+    const cachedMessages = this.peekCachedChannelMessages(channelKey);
+    if (cachedMessages) {
+      const cachedMatched = cachedMessages.find((message) => message.id === matched?.id);
+      if (cachedMatched) {
+        cachedMatched.realId = realId;
+        cachedMatched.sending = false;
+        this.setCachedChannelMessages(channelKey, cachedMessages);
+      }
+    }
+    return matched;
+  }
+  async dispose() {
+    this.disposed = true;
+    for (const [channelKey, timer] of this.writeTimers.entries()) {
+      timer();
+      await this.flushPendingMessages(channelKey);
+    }
+    this.writeTimers.clear();
+    await this.writeQueue;
+    await this.utils.dispose();
+  }
+  createEmptyChatData() {
+    return {
+      bots: {},
+      channels: {},
+      messages: {},
+      pinnedBots: [],
+      pinnedChannels: []
+    };
+  }
+  async ensureMetadataLoaded() {
+    if (!this.metadataLoadPromise) {
+      this.metadataLoadPromise = this.loadMetadataIntoCache();
+    }
+    await this.metadataLoadPromise;
+  }
+  async loadMetadataIntoCache() {
+    const metadata = await this.readMetadata();
+    this.memoryCache = {
+      ...metadata,
+      messages: this.getChannelMessagesCacheSnapshot()
+    };
+  }
+  async loadChannelMessages(selfId, channelId) {
+    const messages = await this.loadChannelMessagesNoCache(selfId, channelId);
+    this.setCachedChannelMessages(`${selfId}:${channelId}`, messages);
+    return messages;
+  }
+  async loadChannelMessagesNoCache(selfId, channelId) {
+    const indexData = await this.loadOrCreateChannelIndex(selfId, channelId);
+    const channelDirPath = this.getChannelDirPath(selfId, channelId);
+    const messages = [];
+    const channelKey = `${selfId}:${channelId}`;
+    for (const chunk of indexData.chunks) {
+      const chunkMessages = await this.readChunkMessages(channelDirPath, chunk.fileName);
+      messages.push(...chunkMessages);
+      this.rememberMessageChunkLocation(channelKey, chunk.fileName, chunkMessages.map((message) => message.id));
+    }
+    this.rememberRecentMessageIds(channelKey, messages.slice(-this.getRecentMessageIdCacheLimit()).map((message) => message.id));
+    return messages;
+  }
+  scheduleMetadataWrite() {
+    this.enqueueWrite(async () => {
+      const { messages, ...metadata } = this.readChatDataFromFile();
+      await this.writeMetadata(metadata);
+    });
+  }
+  enqueueWrite(task) {
+    if (this.disposed) {
+      return;
+    }
+    this.writeQueue = this.writeQueue.then(task).catch((error) => {
+      this.logger.error("写入任务失败:", error);
+    });
+  }
+  async listStoredChannels() {
+    const result = [];
+    await this.scanStoredChannels(async (entry) => {
+      result.push(entry);
+    });
+    return result;
+  }
+  async listBotChannels(selfId) {
+    const result = [];
+    await this.scanStoredChannels(async (entry) => {
+      if (entry.selfId === selfId) {
+        result.push(entry);
+      }
+    }, selfId);
+    return result;
+  }
+  async scanStoredChannels(visitor, botIdFilter) {
+    try {
+      const botDirs = await import_node_fs3.promises.readdir(this.chatHistoryDir, { withFileTypes: true });
+      for (const botEntry of botDirs) {
+        const botName = this.normalizeDirentName(botEntry.name);
+        if (!botEntry.isDirectory()) continue;
+        if (botIdFilter && botName !== botIdFilter) continue;
+        const botDir = import_node_path3.default.join(this.chatHistoryDir, botName);
+        const channelEntries = await import_node_fs3.promises.readdir(botDir, { withFileTypes: true });
+        for (const channelEntry of channelEntries) {
+          const channelId = await this.resolveStoredChannelId(botName, channelEntry);
+          if (!channelId) {
+            continue;
+          }
+          await visitor(this.createStoredChannelEntry(botName, channelId));
+        }
+      }
+    } catch (error) {
+      if (!this.isFileMissingError(error)) {
+        this.logger.error("扫描频道文件失败:", error);
+      }
+    }
+  }
+  createStoredChannelEntry(selfId, channelId) {
+    const channelDirPath = this.getChannelDirPath(selfId, channelId);
+    return {
+      selfId,
+      channelId,
+      channelKey: `${selfId}:${channelId}`,
+      channelDirPath,
+      indexFilePath: this.getChannelIndexPath(selfId, channelId)
+    };
+  }
+  async resolveStoredChannelId(selfId, entry) {
+    const entryName = this.normalizeDirentName(entry.name);
+    if (!entry.isDirectory()) {
+      return void 0;
+    }
+    const encodedChannelId = entryName;
+    const channelDirPath = import_node_path3.default.join(this.chatHistoryDir, selfId, encodedChannelId);
+    const indexFilePath = import_node_path3.default.join(channelDirPath, "index.json");
+    try {
+      const jsonData = await import_node_fs3.promises.readFile(indexFilePath, "utf8");
+      const indexData = JSON.parse(jsonData);
+      if (typeof indexData.channelId === "string") {
+        return indexData.channelId;
+      }
+    } catch (error) {
+      if (!this.isFileMissingError(error)) {
+        this.logger.error(`读取频道索引失败 [${selfId}:${entryName}]:`, error);
+      }
+    }
+    return this.decodeChannelId(encodedChannelId);
+  }
+  getBotDirPath(selfId) {
+    return import_node_path3.default.join(this.chatHistoryDir, selfId);
+  }
+  getEncodedChannelId(channelId) {
+    return encodeURIComponent(channelId);
+  }
+  decodeChannelId(encodedChannelId) {
+    try {
+      return decodeURIComponent(encodedChannelId);
+    } catch {
+      return encodedChannelId;
+    }
+  }
+  normalizeDirentName(name2) {
+    return typeof name2 === "string" ? name2 : name2.toString("utf8");
+  }
+  getChannelDirPath(selfId, channelId) {
+    return import_node_path3.default.join(this.getBotDirPath(selfId), this.getEncodedChannelId(channelId));
+  }
+  getChannelIndexPath(selfId, channelId) {
+    return import_node_path3.default.join(this.getChannelDirPath(selfId, channelId), "index.json");
+  }
+  getChunkFilePath(channelDirPath, fileName) {
+    return import_node_path3.default.join(channelDirPath, fileName);
+  }
+  createEmptyChannelIndex(channelId) {
+    return {
+      version: 1,
+      channelId,
+      totalMessages: 0,
+      nextChunkId: 1,
+      chunks: []
+    };
+  }
+  createChunkFileName(chunkId) {
+    return `chunk-${String(chunkId).padStart(6, "0")}.json`;
+  }
+  async loadOrCreateChannelIndex(selfId, channelId) {
+    const entry = this.createStoredChannelEntry(selfId, channelId);
+    try {
+      const jsonData = await import_node_fs3.promises.readFile(entry.indexFilePath, "utf8");
+      const indexData2 = JSON.parse(jsonData);
+      const normalizedIndexData = this.normalizeChannelIndex(channelId, indexData2);
+      this.syncDirtyChannelState(entry.channelKey, normalizedIndexData.totalMessages);
+      return normalizedIndexData;
+    } catch (error) {
+      if (!this.isFileMissingError(error)) {
+        this.logger.error(`读取频道索引失败 [${entry.channelKey}]:`, error);
+      }
+    }
+    const indexData = this.createEmptyChannelIndex(channelId);
+    await this.ensureDir(entry.channelDirPath);
+    await this.writeChannelIndex(entry.indexFilePath, indexData);
+    this.syncDirtyChannelState(entry.channelKey, indexData.totalMessages);
+    return indexData;
   }
-  // 确保目录存在
-  ensureDir(dirPath) {
-    if (!import_node_fs2.default.existsSync(dirPath)) {
-      import_node_fs2.default.mkdirSync(dirPath, { recursive: true });
-    }
+  normalizeChannelIndex(channelId, indexData) {
+    return {
+      version: 1,
+      channelId,
+      totalMessages: indexData.totalMessages || 0,
+      nextChunkId: indexData.nextChunkId || (indexData.chunks?.length || 0) + 1,
+      chunks: Array.isArray(indexData.chunks) ? indexData.chunks : []
+    };
   }
-  // 获取频道消息文件路径
-  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`);
+  async writeChannelIndex(indexFilePath, indexData) {
+    await this.ensureDir(import_node_path3.default.dirname(indexFilePath));
+    await this.atomicWriteTextFile(indexFilePath, JSON.stringify(indexData, null, 2));
   }
-  // 读取单个频道的消息（公共方法）
-  readChannelMessages(selfId, channelId) {
-    const filePath = this.getChannelFilePath(selfId, channelId);
-    if (!import_node_fs2.default.existsSync(filePath)) {
-      return [];
-    }
+  async readChunkMessages(channelDirPath, fileName) {
     try {
-      const jsonData = import_node_fs2.default.readFileSync(filePath, "utf8");
+      const jsonData = await import_node_fs3.promises.readFile(this.getChunkFilePath(channelDirPath, fileName), "utf8");
       const messages = JSON.parse(jsonData);
       return Array.isArray(messages) ? messages : [];
     } catch (error) {
-      this.logger.error(`读取频道消息失败 [${selfId}:${channelId}]:`, error);
+      if (!this.isFileMissingError(error)) {
+        this.logger.error(`读取消息分块失败 [${channelDirPath}/${fileName}]:`, 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);
+  async writeChunkMessages(channelDirPath, fileName, messages) {
+    await this.ensureDir(channelDirPath);
+    await this.atomicWriteTextFile(this.getChunkFilePath(channelDirPath, fileName), JSON.stringify(messages, null, 2));
+  }
+  async writeMessagesToChunks(channelDirPath, indexData, messages) {
+    const oldChunks = [...indexData.chunks];
+    indexData.chunks = [];
+    indexData.totalMessages = 0;
+    indexData.nextChunkId = 1;
+    for (let offset = 0; offset < messages.length; offset += this.config.messageChunkSize) {
+      const chunkMessages = messages.slice(offset, offset + this.config.messageChunkSize);
+      const chunkId = indexData.nextChunkId;
+      const fileName = this.createChunkFileName(chunkId);
+      await this.writeChunkMessages(channelDirPath, fileName, chunkMessages);
+      indexData.chunks.push({ id: chunkId, fileName, messageCount: chunkMessages.length });
+      indexData.nextChunkId += 1;
+      indexData.totalMessages += chunkMessages.length;
+    }
+    for (const chunk of oldChunks) {
+      try {
+        await import_node_fs3.promises.unlink(this.getChunkFilePath(channelDirPath, chunk.fileName));
+      } catch (error) {
+        if (!this.isFileMissingError(error)) {
+          this.logger.warn(`删除旧消息分块失败 [${channelDirPath}/${chunk.fileName}]:`, error);
+        }
+      }
     }
+    await this.writeChannelIndex(import_node_path3.default.join(channelDirPath, "index.json"), indexData);
   }
-  // 读取元数据（bots、channels、pinned等）
-  readMetadata() {
-    if (!import_node_fs2.default.existsSync(this.metadataFilePath)) {
-      return {
-        bots: {},
-        channels: {},
-        pinnedBots: [],
-        pinnedChannels: []
-      };
+  async appendMessagesToChannel(selfId, channelId, messages) {
+    if (!messages.length) {
+      return;
     }
-    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: []
-      };
+    const entry = this.createStoredChannelEntry(selfId, channelId);
+    const indexData = await this.loadOrCreateChannelIndex(selfId, channelId);
+    await this.ensureDir(entry.channelDirPath);
+    let remainingMessages = [...messages];
+    const lastChunk = indexData.chunks[indexData.chunks.length - 1];
+    if (lastChunk && lastChunk.messageCount < this.config.messageChunkSize) {
+      const chunkMessages = await this.readChunkMessages(entry.channelDirPath, lastChunk.fileName);
+      const writableCount = this.config.messageChunkSize - chunkMessages.length;
+      const appendMessages = remainingMessages.slice(0, writableCount);
+      if (appendMessages.length) {
+        chunkMessages.push(...appendMessages);
+        lastChunk.messageCount = chunkMessages.length;
+        indexData.totalMessages += appendMessages.length;
+        remainingMessages = remainingMessages.slice(appendMessages.length);
+        await this.writeChunkMessages(entry.channelDirPath, lastChunk.fileName, chunkMessages);
+        this.rememberMessageChunkLocation(entry.channelKey, lastChunk.fileName, appendMessages.map((message) => message.id));
+      }
     }
+    while (remainingMessages.length) {
+      const chunkMessages = remainingMessages.slice(0, this.config.messageChunkSize);
+      const chunkId = indexData.nextChunkId;
+      const fileName = this.createChunkFileName(chunkId);
+      await this.writeChunkMessages(entry.channelDirPath, fileName, chunkMessages);
+      indexData.chunks.push({ id: chunkId, fileName, messageCount: chunkMessages.length });
+      indexData.nextChunkId += 1;
+      indexData.totalMessages += chunkMessages.length;
+      this.rememberMessageChunkLocation(entry.channelKey, fileName, chunkMessages.map((message) => message.id));
+      remainingMessages = remainingMessages.slice(chunkMessages.length);
+    }
+    this.syncDirtyChannelState(entry.channelKey, indexData.totalMessages);
+    await this.writeChannelIndex(entry.indexFilePath, indexData);
   }
-  // 只读取元数据，不加载消息（公共方法）
-  readMetadataOnly() {
-    return this.readMetadata();
+  async trimChannelToLimit(selfId, channelId, indexData, limit) {
+    const entry = this.createStoredChannelEntry(selfId, channelId);
+    let overflow = indexData.totalMessages - limit;
+    if (overflow <= 0) {
+      return 0;
+    }
+    let removedCount = 0;
+    while (overflow > 0 && indexData.chunks.length) {
+      const chunk = indexData.chunks[0];
+      if (chunk.messageCount <= overflow) {
+        const removedChunkMessages = await this.readChunkMessages(entry.channelDirPath, chunk.fileName);
+        overflow -= chunk.messageCount;
+        removedCount += chunk.messageCount;
+        indexData.totalMessages -= chunk.messageCount;
+        indexData.chunks.shift();
+        this.forgetRecentMessageIds(entry.channelKey, removedChunkMessages.map((message) => message.id));
+        this.forgetMessageChunkLocation(entry.channelKey, removedChunkMessages.map((message) => message.id));
+        try {
+          await import_node_fs3.promises.unlink(this.getChunkFilePath(entry.channelDirPath, chunk.fileName));
+        } catch (error) {
+          if (!this.isFileMissingError(error)) {
+            this.logger.warn(`删除消息分块失败 [${entry.channelKey}:${chunk.fileName}]:`, error);
+          }
+        }
+        continue;
+      }
+      const chunkMessages = await this.readChunkMessages(entry.channelDirPath, chunk.fileName);
+      const keptMessages = chunkMessages.slice(overflow);
+      const removedMessages = chunkMessages.slice(0, overflow);
+      removedCount += overflow;
+      indexData.totalMessages -= overflow;
+      chunk.messageCount = keptMessages.length;
+      overflow = 0;
+      this.forgetRecentMessageIds(entry.channelKey, removedMessages.map((message) => message.id));
+      this.forgetMessageChunkLocation(entry.channelKey, removedMessages.map((message) => message.id));
+      await this.writeChunkMessages(entry.channelDirPath, chunk.fileName, keptMessages);
+    }
+    this.syncDirtyChannelState(entry.channelKey, indexData.totalMessages);
+    await this.writeChannelIndex(entry.indexFilePath, indexData);
+    return removedCount;
   }
-  // 写入元数据
-  writeMetadata(metadata) {
+  async countChannelMessages(selfId, channelId) {
+    const entry = this.createStoredChannelEntry(selfId, channelId);
     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");
+      const jsonData = await import_node_fs3.promises.readFile(entry.indexFilePath, "utf8");
+      const indexData = JSON.parse(jsonData);
+      if (typeof indexData.totalMessages === "number") {
+        return indexData.totalMessages;
+      }
     } catch (error) {
-      this.logger.error("写入元数据失败:", error);
+      if (!this.isFileMissingError(error)) {
+        this.logger.error(`读取频道索引失败 [${entry.channelKey}]:`, error);
+      }
     }
+    return 0;
   }
-  // 扫描所有频道消息文件并加载到内存
-  loadAllChannelMessages() {
-    const messages = {};
-    if (!import_node_fs2.default.existsSync(this.chatHistoryDir)) {
-      return messages;
-    }
+  async removeChannelStorage(selfId, channelId) {
+    const entry = this.createStoredChannelEntry(selfId, channelId);
     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);
+      await import_node_fs3.promises.rm(entry.channelDirPath, { recursive: true, force: true });
+    } catch (error) {
+      this.logger.error(`删除频道目录失败 [${entry.channelKey}]:`, error);
+    }
+  }
+  async updateUserProfileInChannel(selfId, channelId, userId, userName, avatar) {
+    const entry = this.createStoredChannelEntry(selfId, channelId);
+    const indexData = await this.loadOrCreateChannelIndex(selfId, channelId);
+    let changed = false;
+    for (const chunk of indexData.chunks) {
+      const messages = await this.readChunkMessages(entry.channelDirPath, chunk.fileName);
+      let chunkChanged = false;
+      for (const message of messages) {
+        if (message.userId !== userId) {
+          continue;
+        }
+        if (userName && message.username !== userName) {
+          message.username = userName;
+          chunkChanged = true;
+        }
+        if (avatar && message.avatar !== avatar) {
+          message.avatar = avatar;
+          chunkChanged = true;
         }
       }
-    } catch (error) {
-      this.logger.error("加载频道消息失败:", error);
+      if (!chunkChanged) {
+        continue;
+      }
+      await this.writeChunkMessages(entry.channelDirPath, chunk.fileName, messages);
+      changed = true;
     }
-    return messages;
+    return changed;
   }
-  readChatDataFromFile() {
-    if (this.memoryCache) {
-      return this.memoryCache;
+  async findAndUpdateLatestBotMessage(selfId, channelId, realId) {
+    const entry = this.createStoredChannelEntry(selfId, channelId);
+    const indexData = await this.loadOrCreateChannelIndex(selfId, channelId);
+    for (let index = indexData.chunks.length - 1; index >= 0; index -= 1) {
+      const chunk = indexData.chunks[index];
+      const messages = await this.readChunkMessages(entry.channelDirPath, chunk.fileName);
+      const matched = [...messages].reverse().find((message) => message.type === "bot" && message.sending);
+      if (!matched) {
+        continue;
+      }
+      matched.realId = realId;
+      matched.sending = false;
+      await this.writeChunkMessages(entry.channelDirPath, chunk.fileName, messages);
+      return matched;
     }
-    process.nextTick(() => {
-      try {
-        const metadata = this.readMetadata();
-        const messages = this.loadAllChannelMessages();
-        this.memoryCache = {
-          ...metadata,
-          messages
-        };
-      } catch (error) {
-        this.logger.error("读取聊天数据失败:", error);
+    return void 0;
+  }
+  async findAndUpdateBotMessageByTempId(selfId, channelId, tempMessageId, realId) {
+    const channelKey = `${selfId}:${channelId}`;
+    const pendingMessages = this.pendingMessages.get(channelKey);
+    const pendingMatched = pendingMessages?.find((message) => message.id === tempMessageId);
+    if (pendingMatched) {
+      pendingMatched.realId = realId;
+      pendingMatched.sending = false;
+      return pendingMatched;
+    }
+    const cachedMessages = this.peekCachedChannelMessages(channelKey);
+    const cachedMatched = cachedMessages?.find((message) => message.id === tempMessageId);
+    if (cachedMatched) {
+      cachedMatched.realId = realId;
+      cachedMatched.sending = false;
+      this.setCachedChannelMessages(channelKey, cachedMessages);
+    }
+    const entry = this.createStoredChannelEntry(selfId, channelId);
+    const chunkFileName = this.getMessageChunkLocation(channelKey, tempMessageId);
+    if (chunkFileName) {
+      const chunkMessages = await this.readChunkMessages(entry.channelDirPath, chunkFileName);
+      const matched = chunkMessages.find((message) => message.id === tempMessageId);
+      if (matched) {
+        matched.realId = realId;
+        matched.sending = false;
+        await this.writeChunkMessages(entry.channelDirPath, chunkFileName, chunkMessages);
+        return matched;
       }
-    });
-    this.memoryCache = {
-      bots: {},
-      channels: {},
-      messages: {},
-      pinnedBots: [],
-      pinnedChannels: []
-    };
-    return this.memoryCache;
+    }
+    const indexData = await this.loadOrCreateChannelIndex(selfId, channelId);
+    for (let index = indexData.chunks.length - 1; index >= 0; index -= 1) {
+      const chunk = indexData.chunks[index];
+      const chunkMessages = await this.readChunkMessages(entry.channelDirPath, chunk.fileName);
+      const matched = chunkMessages.find((message) => message.id === tempMessageId);
+      if (!matched) {
+        continue;
+      }
+      matched.realId = realId;
+      matched.sending = false;
+      await this.writeChunkMessages(entry.channelDirPath, chunk.fileName, chunkMessages);
+      this.rememberMessageChunkLocation(channelKey, chunk.fileName, [matched.id]);
+      return matched;
+    }
+    return cachedMatched;
   }
-  writeChatDataToFile(data) {
-    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);
+  deduplicateMessages(messages) {
+    const seen = /* @__PURE__ */ new Set();
+    const deduplicated = [];
+    for (const message of messages) {
+      if (seen.has(message.id)) {
+        continue;
       }
-    });
+      seen.add(message.id);
+      deduplicated.push(message);
+    }
+    return deduplicated;
   }
-  // 为特定频道安排写入
-  scheduleWrite(channelKey) {
-    const existingTimer = this.writeTimers.get(channelKey);
-    if (existingTimer) {
-      existingTimer();
+  getCachedChannelMessages(channelKey) {
+    const cached = this.channelMessagesCache.get(channelKey);
+    if (!cached) {
+      return void 0;
     }
-    const timer = this.ctx.setTimeout(() => {
-      process.nextTick(() => {
-        this.flushPendingMessages(channelKey);
-      });
-      this.writeTimers.delete(channelKey);
-    }, this.WRITE_DEBOUNCE_MS);
-    this.writeTimers.set(channelKey, timer);
+    this.channelMessagesCache.delete(channelKey);
+    this.channelMessagesCache.set(channelKey, cached);
+    this.memoryCache.messages = this.getChannelMessagesCacheSnapshot();
+    return cached;
   }
-  // 刷新特定频道的待写入消息
-  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] = [];
+  peekCachedChannelMessages(channelKey) {
+    return this.channelMessagesCache.get(channelKey);
+  }
+  setCachedChannelMessages(channelKey, messages) {
+    this.channelMessagesCache.delete(channelKey);
+    this.channelMessagesCache.set(channelKey, messages);
+    this.rememberRecentMessageIds(channelKey, messages.slice(-this.getRecentMessageIdCacheLimit()).map((message) => message.id));
+    while (this.channelMessagesCache.size > this.config.channelCacheLimit) {
+      const oldestKey = this.channelMessagesCache.keys().next().value;
+      if (!oldestKey) {
+        break;
+      }
+      this.channelMessagesCache.delete(oldestKey);
+      this.deleteRecentMessageIds(oldestKey);
+      this.deleteMessageChunkLocations(oldestKey);
     }
-    for (const messageInfo of messagesToWrite) {
-      const existingMessage = data.messages[channelKey].find((m) => m.id === messageInfo.id);
-      if (existingMessage) {
+    this.memoryCache.messages = this.getChannelMessagesCacheSnapshot();
+  }
+  deleteCachedChannelMessages(channelKey) {
+    this.channelMessagesCache.delete(channelKey);
+    delete this.memoryCache.messages[channelKey];
+  }
+  getChannelMessagesCacheSnapshot() {
+    return Object.fromEntries(this.channelMessagesCache.entries());
+  }
+  mergeChannelMessages(baseMessages, appendedMessages) {
+    const merged = [...baseMessages];
+    const knownIds = new Set(baseMessages.map((message) => message.id));
+    for (const message of appendedMessages) {
+      if (knownIds.has(message.id)) {
         continue;
       }
-      if (!messageInfo.timestamp) {
-        messageInfo.timestamp = Date.now();
-      }
-      const cleanedMessageInfo = this.utils.cleanBase64Content(messageInfo);
-      data.messages[channelKey].push(cleanedMessageInfo);
+      knownIds.add(message.id);
+      merged.push(message);
     }
-    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);
+    return merged;
+  }
+  limitChannelMessages(messages) {
+    if (messages.length <= this.config.maxMessagesPerChannel) {
+      return messages;
     }
-    this.writeChannelMessages(selfId, channelId, data.messages[channelKey]);
-    this.memoryCache = data;
-    this.logInfo(`批量写入 ${messagesToWrite.length} 条消息到频道 ${channelKey}`);
+    return [...messages].sort((left, right) => left.timestamp - right.timestamp).slice(-this.config.maxMessagesPerChannel);
   }
-  cleanExcessMessages(data) {
-    let cleanedCount = 0;
-    const cleanedMessages = {};
-    for (const [channelKey, messages] of Object.entries(data.messages)) {
-      if (messages.length > this.config.maxMessagesPerChannel) {
-        const sortedMessages = [...messages].sort((a, b) => a.timestamp - b.timestamp);
-        const keptMessages = sortedMessages.slice(-this.config.maxMessagesPerChannel);
-        cleanedCount += messages.length - keptMessages.length;
-        cleanedMessages[channelKey] = keptMessages;
-        this.logInfo(`频道 ${channelKey} 清理了 ${messages.length - keptMessages.length} 条旧消息，保留最新 ${keptMessages.length} 条`);
-      } else {
-        cleanedMessages[channelKey] = messages;
+  async channelMessageExists(selfId, channelId, messageId) {
+    const entry = this.createStoredChannelEntry(selfId, channelId);
+    const channelKey = entry.channelKey;
+    if (this.hasRecentMessageId(channelKey, messageId)) {
+      return true;
+    }
+    const indexData = await this.loadOrCreateChannelIndex(selfId, channelId);
+    for (let chunkIndex = indexData.chunks.length - 1; chunkIndex >= 0; chunkIndex -= 1) {
+      const chunk = indexData.chunks[chunkIndex];
+      const messages = await this.readChunkMessages(entry.channelDirPath, chunk.fileName);
+      if (messages.some((message) => message.id === messageId)) {
+        this.rememberRecentMessageIds(channelKey, [messageId]);
+        return true;
       }
     }
-    if (cleanedCount > 0) {
-      this.logInfo("总共清理超量消息:", cleanedCount, "条");
+    return false;
+  }
+  syncDirtyChannelState(channelKey, totalMessages) {
+    if (totalMessages > this.config.maxMessagesPerChannel) {
+      this.dirtyChannelKeys.add(channelKey);
+      return;
     }
-    return {
-      ...data,
-      messages: cleanedMessages
-    };
+    this.dirtyChannelKeys.delete(channelKey);
   }
-  async addMessageToFile(messageInfo) {
-    const channelKey = `${messageInfo.selfId}:${messageInfo.channelId}`;
-    if (!this.pendingMessages.has(channelKey)) {
-      this.pendingMessages.set(channelKey, []);
+  registerPendingBotMessage(channelKey, messageId) {
+    const messageIds = this.pendingBotMessageIds.get(channelKey) || [];
+    messageIds.push(messageId);
+    this.pendingBotMessageIds.set(channelKey, messageIds);
+  }
+  peekLatestPendingBotMessageId(channelKey) {
+    const messageIds = this.pendingBotMessageIds.get(channelKey);
+    return messageIds?.[messageIds.length - 1];
+  }
+  consumePendingBotMessageId(channelKey, messageId) {
+    const messageIds = this.pendingBotMessageIds.get(channelKey);
+    if (!messageIds?.length) {
+      return;
     }
-    this.pendingMessages.get(channelKey).push(messageInfo);
-    const data = this.memoryCache || this.readChatDataFromFile();
-    if (!data.messages[channelKey]) {
-      data.messages[channelKey] = [];
+    const nextMessageIds = messageIds.filter((id) => id !== messageId);
+    if (nextMessageIds.length) {
+      this.pendingBotMessageIds.set(channelKey, nextMessageIds);
+      return;
     }
-    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);
-      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.pendingBotMessageIds.delete(channelKey);
+  }
+  deletePendingBotMessages(channelKey) {
+    this.pendingBotMessageIds.delete(channelKey);
+  }
+  getRecentMessageIdCacheLimit() {
+    return Math.max(this.RECENT_MESSAGE_ID_CACHE_SIZE, this.config.messageChunkSize * 2);
+  }
+  rememberRecentMessageIds(channelKey, messageIds) {
+    if (!messageIds.length) {
+      return;
+    }
+    const nextMessageIds = [...this.recentMessageIdsCache.get(channelKey) || []];
+    for (const messageId of messageIds) {
+      const existingIndex = nextMessageIds.indexOf(messageId);
+      if (existingIndex !== -1) {
+        nextMessageIds.splice(existingIndex, 1);
       }
-      this.memoryCache = data;
+      nextMessageIds.push(messageId);
     }
-    this.scheduleWrite(channelKey);
+    const maxSize = this.getRecentMessageIdCacheLimit();
+    this.recentMessageIdsCache.set(channelKey, nextMessageIds.slice(-maxSize));
   }
-  dispose() {
-    for (const [channelKey, timer] of this.writeTimers.entries()) {
-      timer();
-      this.flushPendingMessages(channelKey);
+  forgetRecentMessageIds(channelKey, messageIds) {
+    const currentMessageIds = this.recentMessageIdsCache.get(channelKey);
+    if (!currentMessageIds?.length || !messageIds.length) {
+      return;
     }
-    this.writeTimers.clear();
+    const nextMessageIds = currentMessageIds.filter((messageId) => !messageIds.includes(messageId));
+    if (nextMessageIds.length) {
+      this.recentMessageIdsCache.set(channelKey, nextMessageIds);
+      return;
+    }
+    this.recentMessageIdsCache.delete(channelKey);
   }
-  logInfo(...args) {
-    if (this.config.loggerinfo) {
-      this.logger.info(...args);
+  hasRecentMessageId(channelKey, messageId) {
+    const currentMessageIds = this.recentMessageIdsCache.get(channelKey);
+    return !!currentMessageIds?.includes(messageId);
+  }
+  deleteRecentMessageIds(channelKey) {
+    this.recentMessageIdsCache.delete(channelKey);
+  }
+  rememberMessageChunkLocation(channelKey, chunkFileName, messageIds) {
+    if (!messageIds.length) {
+      return;
+    }
+    const currentLocations = this.messageChunkLocationCache.get(channelKey) || /* @__PURE__ */ new Map();
+    for (const messageId of messageIds) {
+      currentLocations.set(messageId, chunkFileName);
+    }
+    this.messageChunkLocationCache.set(channelKey, currentLocations);
+  }
+  forgetMessageChunkLocation(channelKey, messageIds) {
+    const currentLocations = this.messageChunkLocationCache.get(channelKey);
+    if (!currentLocations || !messageIds.length) {
+      return;
+    }
+    for (const messageId of messageIds) {
+      currentLocations.delete(messageId);
+    }
+    if (!currentLocations.size) {
+      this.messageChunkLocationCache.delete(channelKey);
+    }
+  }
+  getMessageChunkLocation(channelKey, messageId) {
+    return this.messageChunkLocationCache.get(channelKey)?.get(messageId);
+  }
+  deleteMessageChunkLocations(channelKey) {
+    this.messageChunkLocationCache.delete(channelKey);
+  }
+  isSameBotInfo(left, right) {
+    return left.selfId === right.selfId && left.platform === right.platform && left.username === right.username && left.avatar === right.avatar && left.status === right.status;
+  }
+  isSameChannelInfo(left, right) {
+    return left.id === right.id && left.name === right.name && left.type === right.type && left.channelId === right.channelId && left.guildName === right.guildName && left.isDirect === right.isDirect;
+  }
+  isFileMissingError(error) {
+    return typeof error === "object" && error !== null && "code" in error && error.code === "ENOENT";
+  }
+  async atomicWriteTextFile(filePath, content) {
+    const tempFilePath = `${filePath}.${process.pid}.${Date.now()}.${Math.random().toString(16).slice(2)}.tmp`;
+    await import_node_fs3.promises.writeFile(
+      tempFilePath,
+      content,
+      "utf8"
+    );
+    try {
+      await import_node_fs3.promises.rename(tempFilePath, filePath);
+    } catch (error) {
+      if (this.isAtomicRenameReplaceError(error)) {
+        await import_node_fs3.promises.rm(filePath, { force: true });
+        await import_node_fs3.promises.rename(tempFilePath, filePath);
+        return;
+      }
+      try {
+        await import_node_fs3.promises.rm(tempFilePath, { force: true });
+      } catch {
+      }
+      throw error;
     }
   }
+  isAtomicRenameReplaceError(error) {
+    return typeof error === "object" && error !== null && "code" in error && (error.code === "EEXIST" || error.code === "EPERM");
+  }
 };
 
 // src/api-handlers.ts
 var import_koishi = require("koishi");
 var import_node_url2 = require("node:url");
-var import_node_fs3 = require("node:fs");
+var import_node_fs4 = require("node:fs");
+var import_node_path4 = __toESM(require("node:path"));
+var import_node_crypto3 = require("node:crypto");
 var mime = __toESM(require("mime-types"));
 var ApiHandlers = class {
-  constructor(ctx, config, fileManager, messageHandler) {
+  constructor(ctx, config, fileManager, messageHandler, logger) {
     this.ctx = ctx;
     this.config = config;
     this.fileManager = fileManager;
     this.messageHandler = messageHandler;
-    this.logger = ctx.logger("chat-patch");
+    this.logger = logger;
   }
   static {
     __name(this, "ApiHandlers");
   }
-  logger;
   currentTempVideo = null;
   registerApiHandlers() {
     this.ctx.console.addListener("clear-all-indexeddb-data", async () => {
@@ -868,7 +1766,7 @@ var ApiHandlers = class {
     });
     this.ctx.console.addListener("get-chat-data", async () => {
       try {
-        const data = this.fileManager.readMetadataOnly();
+        const data = await this.fileManager.readMetadataOnly();
         this.logInfo("获取基础聊天数据（仅元数据）");
         return {
           success: true,
@@ -888,21 +1786,18 @@ var ApiHandlers = class {
     });
     this.ctx.console.addListener("get-history-messages", async (requestData) => {
       try {
-        let messages = this.fileManager.readChannelMessages(requestData.selfId, requestData.channelId);
-        const sortedMessages = messages.sort((a, b) => b.timestamp - a.timestamp);
-        if (requestData.limit !== void 0) {
-          const limit = requestData.limit;
-          const offset = requestData.offset || 0;
-          messages = sortedMessages.slice(offset, offset + limit);
-          messages = messages.sort((a, b) => a.timestamp - b.timestamp);
-        } else {
-          messages = sortedMessages.sort((a, b) => a.timestamp - b.timestamp);
-        }
-        this.logInfo("获取历史消息:", `${requestData.selfId}:${requestData.channelId}`, "共", messages.length, "条消息");
+        const limit = Math.max(1, requestData.limit ?? this.config.messageChunkSize);
+        const result = await this.fileManager.readChannelMessagesPage(
+          requestData.selfId,
+          requestData.channelId,
+          limit,
+          requestData.offset || 0
+        );
+        this.logInfo("获取历史消息:", `${requestData.selfId}:${requestData.channelId}`, "共", result.messages.length, "条消息");
         return {
           success: true,
-          messages,
-          total: sortedMessages.length
+          messages: result.messages,
+          total: result.total
         };
       } catch (error) {
         this.logger.error("获取历史消息失败:", error);
@@ -911,11 +1806,7 @@ var ApiHandlers = class {
     });
     this.ctx.console.addListener("get-all-channel-message-counts", async () => {
       try {
-        const data = this.fileManager.readChatDataFromFile();
-        const counts = {};
-        for (const [channelKey, messages] of Object.entries(data.messages)) {
-          counts[channelKey] = messages.length;
-        }
+        const counts = await this.fileManager.getAllChannelMessageCounts();
         this.logInfo("获取所有频道消息数量:", {
           频道数: Object.keys(counts).length,
           总消息数: Object.values(counts).reduce((total, count) => total + count, 0)
@@ -946,16 +1837,13 @@ var ApiHandlers = class {
             viteUrl: `/vite/@fs/${normalizedPath2}`
           };
         }
-        const dir = require("node:path").join(this.ctx.baseDir, "data", "chat-patch", "persist-media", "images");
-        if (!require("node:fs").existsSync(dir)) {
-          require("node:fs").mkdirSync(dir, { recursive: true });
-        }
-        const crypto = require("node:crypto");
-        const hash = crypto.createHash("md5").update(data.url).digest("hex");
-        const ext = require("node:path").extname(new import_node_url2.URL(data.url).pathname) || ".jpg";
+        const dir = import_node_path4.default.join(this.ctx.baseDir, "data", "chat-patch", "persist-media", "images");
+        await import_node_fs4.promises.mkdir(dir, { recursive: true });
+        const hash = (0, import_node_crypto3.createHash)("md5").update(data.url).digest("hex");
+        const ext = import_node_path4.default.extname(new import_node_url2.URL(data.url).pathname) || ".jpg";
         const filename = `${hash}${ext}`;
-        const filePath = require("node:path").join(dir, filename);
-        if (!require("node:fs").existsSync(filePath)) {
+        const filePath = import_node_path4.default.join(dir, filename);
+        if (!await this.fileExists(filePath)) {
           const response = await fetch(data.url, {
             headers: {
               "User-Agent": "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/91.0.4472.124 Safari/537.36",
@@ -966,7 +1854,7 @@ var ApiHandlers = class {
             throw new Error(`HTTP ${response.status}: ${response.statusText}`);
           }
           const buffer = await response.arrayBuffer();
-          require("node:fs").writeFileSync(filePath, Buffer.from(buffer));
+          await import_node_fs4.promises.writeFile(filePath, Buffer.from(buffer));
         }
         const normalizedPath = filePath.replace(/\\/g, "/");
         return {
@@ -974,28 +1862,24 @@ var ApiHandlers = class {
           viteUrl: `/vite/@fs/${normalizedPath}`
         };
       } catch (error) {
-        this.logger.error("获取图片失败:", error);
-        return { success: false, error: error?.message || String(error) };
+        return { success: false, error: this.getClientErrorMessage(error) };
       }
     });
     this.ctx.console.addListener("clear-channel-history", async (data) => {
       try {
         this.logInfo("收到清理历史记录请求（已废弃，建议使用删除频道数据）:", data);
-        const chatData = this.fileManager.readChatDataFromFile();
         const channelKey = `${data.selfId}:${data.channelId}`;
-        if (!chatData.messages[channelKey]) {
+        const { deletedMessages } = await this.fileManager.deleteChannelData(data.selfId, data.channelId);
+        if (!deletedMessages) {
           return { success: true, message: "频道没有历史消息" };
         }
-        const originalCount = chatData.messages[channelKey].length;
-        delete chatData.messages[channelKey];
-        this.fileManager.writeChatDataToFile(chatData);
         this.logInfo(`频道 ${channelKey} 历史记录已清空:`, {
-          清理消息数: originalCount
+          清理消息数: deletedMessages
         });
         return {
           success: true,
-          message: `成功清理 ${originalCount} 条历史消息`,
-          clearedCount: originalCount,
+          message: `成功清理 ${deletedMessages} 条历史消息`,
+          clearedCount: deletedMessages,
           keptCount: 0
         };
       } catch (error) {
@@ -1017,13 +1901,12 @@ var ApiHandlers = class {
         }
         let messageContent = data.content;
         if (data.images && data.images.length > 0) {
-          const tempDir = this.ctx.baseDir + "/data/chat-patch/temp";
+          const tempDir = import_node_path4.default.join(this.ctx.baseDir, "data", "chat-patch", "temp");
+          const tempFiles = await this.safeReadDir(tempDir);
           for (const image of data.images) {
-            const files = require("fs").readdirSync(tempDir).filter(
-              (file) => file.includes(`temp_${image.tempId}`)
-            );
+            const files = tempFiles.filter((file) => file.includes(`temp_${image.tempId}`));
             if (files.length > 0) {
-              const imagePath = `${tempDir}/${files[0]}`;
+              const imagePath = import_node_path4.default.join(tempDir, files[0]);
               const fileUrl = this.createFileUrl(imagePath);
               messageContent += import_koishi.h.image(fileUrl).toString();
               this.logInfo("添加图片到消息:", { imagePath, fileUrl });
@@ -1036,14 +1919,9 @@ var ApiHandlers = class {
         this.logInfo("消息发送成功:", result);
         const messageId = Array.isArray(result) ? result[0] : result;
         if (messageId) {
-          const chatData = this.fileManager.readChatDataFromFile();
           const channelKey = `${data.selfId}:${data.channelId}`;
-          const messages = chatData.messages[channelKey] || [];
-          const msg = [...messages].reverse().find((m) => m.type === "bot" && m.sending);
+          const msg = await this.fileManager.markLatestBotMessageAsSent(data.selfId, data.channelId, messageId);
           if (msg) {
-            msg.realId = messageId;
-            msg.sending = false;
-            this.fileManager.writeChatDataToFile(chatData);
             this.ctx.console.broadcast("bot-message-updated", {
               channelKey,
               tempId: msg.id,
@@ -1074,20 +1952,7 @@ var ApiHandlers = class {
     this.ctx.console.addListener("delete-bot-data", async (data) => {
       try {
         this.logInfo("收到删除机器人数据请求:", data);
-        const chatData = this.fileManager.readChatDataFromFile();
-        let deletedChannels = 0;
-        let deletedMessages = 0;
-        if (chatData.channels[data.selfId]) {
-          deletedChannels = Object.keys(chatData.channels[data.selfId]).length;
-          delete chatData.channels[data.selfId];
-        }
-        const channelsToDelete = Object.keys(chatData.messages).filter((key) => key.startsWith(`${data.selfId}:`));
-        for (const channelKey of channelsToDelete) {
-          deletedMessages += chatData.messages[channelKey].length;
-          delete chatData.messages[channelKey];
-        }
-        delete chatData.bots[data.selfId];
-        this.fileManager.writeChatDataToFile(chatData);
+        const { deletedChannels, deletedMessages } = await this.fileManager.deleteBotData(data.selfId);
         this.logInfo(`机器人 ${data.selfId} 数据删除完成:`, {
           删除频道数: deletedChannels,
           删除消息数: deletedMessages
@@ -1106,17 +1971,8 @@ var ApiHandlers = class {
     this.ctx.console.addListener("delete-channel-data", async (data) => {
       try {
         this.logInfo("收到删除频道数据请求:", data);
-        const chatData = this.fileManager.readChatDataFromFile();
         const channelKey = `${data.selfId}:${data.channelId}`;
-        let deletedMessages = 0;
-        if (chatData.messages[channelKey]) {
-          deletedMessages = chatData.messages[channelKey].length;
-          delete chatData.messages[channelKey];
-        }
-        if (chatData.channels[data.selfId] && chatData.channels[data.selfId][data.channelId]) {
-          delete chatData.channels[data.selfId][data.channelId];
-        }
-        this.fileManager.writeChatDataToFile(chatData);
+        const { deletedMessages } = await this.fileManager.deleteChannelData(data.selfId, data.channelId);
         this.logInfo(`频道 ${channelKey} 数据删除完成:`, {
           删除消息数: deletedMessages
         });
@@ -1133,9 +1989,7 @@ var ApiHandlers = class {
     this.ctx.console.addListener("set-pinned-bots", async (data) => {
       try {
         this.logInfo("收到设置置顶机器人请求:", data.pinnedBots);
-        const chatData = this.fileManager.readChatDataFromFile();
-        chatData.pinnedBots = data.pinnedBots;
-        this.fileManager.writeChatDataToFile(chatData);
+        await this.fileManager.setPinnedBots(data.pinnedBots);
         return { success: true };
       } catch (error) {
         this.logger.error("设置置顶机器人失败:", error);
@@ -1145,9 +1999,7 @@ var ApiHandlers = class {
     this.ctx.console.addListener("set-pinned-channels", async (data) => {
       try {
         this.logInfo("收到设置置顶频道请求:", data.pinnedChannels);
-        const chatData = this.fileManager.readChatDataFromFile();
-        chatData.pinnedChannels = data.pinnedChannels;
-        this.fileManager.writeChatDataToFile(chatData);
+        await this.fileManager.setPinnedChannels(data.pinnedChannels);
         return { success: true };
       } catch (error) {
         this.logger.error("设置置顶频道失败:", error);
@@ -1162,12 +2014,10 @@ var ApiHandlers = class {
         const tempId = Date.now() + "_" + Math.random().toString(36).substring(2, 11);
         const extension = data.filename.split(".").pop()?.toLowerCase() || (data.isGif ? "gif" : "jpg");
         const tempFilename = `temp_${tempId}.${extension}`;
-        const tempDir = this.ctx.baseDir + "/data/chat-patch/temp";
-        if (!require("fs").existsSync(tempDir)) {
-          require("fs").mkdirSync(tempDir, { recursive: true });
-        }
-        const tempPath = `${tempDir}/${tempFilename}`;
-        require("fs").writeFileSync(tempPath, buffer);
+        const tempDir = import_node_path4.default.join(this.ctx.baseDir, "data", "chat-patch", "temp");
+        await import_node_fs4.promises.mkdir(tempDir, { recursive: true });
+        const tempPath = import_node_path4.default.join(tempDir, tempFilename);
+        await import_node_fs4.promises.writeFile(tempPath, buffer);
         this.logInfo("图片上传成功:", { tempPath, size: buffer.length, isGif: data.isGif });
         return {
           success: true,
@@ -1184,14 +2034,12 @@ var ApiHandlers = class {
     });
     this.ctx.console.addListener("delete-temp-image", async (data) => {
       try {
-        const tempDir = this.ctx.baseDir + "/data/chat-patch/temp";
-        const files = require("fs").readdirSync(tempDir).filter(
-          (file) => file.includes(`temp_${data.tempId}`)
-        );
+        const tempDir = import_node_path4.default.join(this.ctx.baseDir, "data", "chat-patch", "temp");
+        const files = (await this.safeReadDir(tempDir)).filter((file) => file.includes(`temp_${data.tempId}`));
         for (const file of files) {
-          const filePath = `${tempDir}/${file}`;
-          if (require("fs").existsSync(filePath)) {
-            require("fs").unlinkSync(filePath);
+          const filePath = import_node_path4.default.join(tempDir, file);
+          if (await this.fileExists(filePath)) {
+            await import_node_fs4.promises.unlink(filePath);
             this.logInfo("删除临时图片:", filePath);
           }
         }
@@ -1208,6 +2056,8 @@ var ApiHandlers = class {
           success: true,
           config: {
             maxMessagesPerChannel: this.config.maxMessagesPerChannel,
+            messageChunkSize: this.config.messageChunkSize,
+            channelCacheLimit: this.config.channelCacheLimit,
             maxPersistImages: this.config.maxPersistImages,
             loggerinfo: this.config.loggerinfo,
             blockedPlatforms: this.config.blockedPlatforms || [],
@@ -1231,44 +2081,8 @@ var ApiHandlers = class {
           if (user.avatar) {
             user.avatar = await this.messageHandler.downloadAndCacheMedia(user.avatar, "avatar");
           }
-          const chatData = this.fileManager.readChatDataFromFile();
-          let changed = false;
-          const botChannels = chatData.channels[data.selfId] || {};
-          const possibleChannelIds = [
-            data.userId,
-            `private:${data.userId}`,
-            `direct:${data.userId}`
-          ];
-          for (const channelId of possibleChannelIds) {
-            const channel = botChannels[channelId];
-            if (channel && channel.isDirect) {
-              const newName = `私聊（${user.name}）`;
-              if (channel.name !== newName) {
-                channel.name = newName;
-                changed = true;
-                this.logInfo("更新私聊频道名称:", { channelId, oldName: channel.name, newName });
-              }
-            }
-          }
-          const channelKeyPrefix = `${data.selfId}:`;
-          for (const [key, messages] of Object.entries(chatData.messages)) {
-            if (key.startsWith(channelKeyPrefix)) {
-              messages.forEach((msg) => {
-                if (msg.userId === data.userId) {
-                  if (user.name && msg.username !== user.name) {
-                    msg.username = user.name;
-                    changed = true;
-                  }
-                  if (user.avatar && msg.avatar !== user.avatar) {
-                    msg.avatar = user.avatar;
-                    changed = true;
-                  }
-                }
-              });
-            }
-          }
+          const changed = await this.fileManager.updateUserProfileInBotData(data.selfId, data.userId, user.name, user.avatar);
           if (changed) {
-            this.fileManager.writeChatDataToFile(chatData);
             this.ctx.console.broadcast("chat-data-updated", {});
           }
         }
@@ -1277,18 +2091,6 @@ var ApiHandlers = class {
         return { success: false, error: error?.message || "获取用户信息失败" };
       }
     });
-    this.ctx.console.addListener("debug-get-raw-data", async () => {
-      try {
-        const data = this.fileManager.readChatDataFromFile();
-        return {
-          success: true,
-          data
-        };
-      } catch (error) {
-        this.logger.error("获取原始数据失败:", error);
-        return { success: false, error: error?.message || String(error) };
-      }
-    });
     this.ctx.console.addListener("fetch-video-temp", async (data) => {
       try {
         this.logInfo("收到视频临时加载请求:", data.url);
@@ -1306,16 +2108,13 @@ var ApiHandlers = class {
             viteUrl: `/vite/@fs/${normalizedPath2}`
           };
         }
-        const dir = require("node:path").join(this.ctx.baseDir, "data", "chat-patch", "persist-media", "media");
-        if (!require("node:fs").existsSync(dir)) {
-          require("node:fs").mkdirSync(dir, { recursive: true });
-        }
-        const crypto = require("node:crypto");
-        const hash = crypto.createHash("md5").update(data.url).digest("hex");
-        const ext = require("node:path").extname(new import_node_url2.URL(data.url).pathname) || ".mp4";
+        const dir = import_node_path4.default.join(this.ctx.baseDir, "data", "chat-patch", "persist-media", "media");
+        await import_node_fs4.promises.mkdir(dir, { recursive: true });
+        const hash = (0, import_node_crypto3.createHash)("md5").update(data.url).digest("hex");
+        const ext = import_node_path4.default.extname(new import_node_url2.URL(data.url).pathname) || ".mp4";
         const filename = `${hash}${ext}`;
-        const filePath = require("node:path").join(dir, filename);
-        if (!require("node:fs").existsSync(filePath)) {
+        const filePath = import_node_path4.default.join(dir, filename);
+        if (!await this.fileExists(filePath)) {
           const response = await fetch(data.url, {
             headers: {
               "User-Agent": "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36",
@@ -1326,7 +2125,7 @@ var ApiHandlers = class {
             throw new Error(`HTTP ${response.status}: ${response.statusText}`);
           }
           const buffer = await response.arrayBuffer();
-          require("node:fs").writeFileSync(filePath, Buffer.from(buffer));
+          await import_node_fs4.promises.writeFile(filePath, Buffer.from(buffer));
           this.logInfo("视频下载成功:", { size: buffer.byteLength, path: filePath });
         }
         const normalizedPath = filePath.replace(/\\/g, "/");
@@ -1335,8 +2134,7 @@ var ApiHandlers = class {
           viteUrl: `/vite/@fs/${normalizedPath}`
         };
       } catch (error) {
-        this.logger.error("视频临时加载失败:", error);
-        return { success: false, error: error?.message || String(error) };
+        return { success: false, error: this.getClientErrorMessage(error) };
       }
     });
   }
@@ -1359,7 +2157,7 @@ var ApiHandlers = class {
   async handleLocalFileRequest(fileUrl) {
     try {
       const filePath = (0, import_node_url2.fileURLToPath)(fileUrl);
-      const buffer = (0, import_node_fs3.readFileSync)(filePath);
+      const buffer = await import_node_fs4.promises.readFile(filePath);
       const base64 = buffer.toString("base64");
       const contentType = mime.lookup(filePath) || "application/octet-stream";
       this.logInfo("成功读取本地文件:", { fileUrl, filePath, contentType });
@@ -1370,7 +2168,6 @@ var ApiHandlers = class {
         dataUrl: `data:${contentType};base64,${base64}`
       };
     } catch (error) {
-      this.logger.error("读取本地文件失败:", { fileUrl, error: error.message });
       return {
         success: false,
         error: `读取本地文件失败: ${error.message}`
@@ -1383,40 +2180,85 @@ var ApiHandlers = class {
     }, 5 * 60 * 1e3);
   }
   async cleanupMediaCache() {
-    const baseDir = this.ctx.baseDir + "/data/chat-patch/persist-media";
-    if (!require("node:fs").existsSync(baseDir)) return;
-    const cleanupDir = /* @__PURE__ */ __name((dirName, limit) => {
-      const dirPath = require("node:path").join(baseDir, dirName);
-      if (!require("node:fs").existsSync(dirPath)) return;
-      const files = require("node:fs").readdirSync(dirPath).map((file) => {
-        const filePath = require("node:path").join(dirPath, file);
-        const stats = require("node:fs").statSync(filePath);
-        return { name: file, path: filePath, mtime: stats.mtimeMs };
-      }).sort((a, b) => b.mtime - a.mtime);
-      if (files.length > limit) {
-        files.slice(limit).forEach((f) => {
-          try {
-            require("node:fs").unlinkSync(f.path);
-          } catch {
-          }
-        });
-      }
-    }, "cleanupDir");
-    cleanupDir("images", 100);
-    cleanupDir("media", 20);
+    const baseDir = import_node_path4.default.join(this.ctx.baseDir, "data", "chat-patch", "persist-media");
+    await this.cleanupMediaCacheDir(import_node_path4.default.join(baseDir, "images"), 100);
+    await this.cleanupMediaCacheDir(import_node_path4.default.join(baseDir, "media"), 20);
   }
   logInfo(...args) {
     if (this.config.loggerinfo) {
-      this.logger.info(...args);
+      Reflect.apply(this.logger.info, this.logger, args);
+    }
+  }
+  async fileExists(filePath) {
+    try {
+      await import_node_fs4.promises.access(filePath);
+      return true;
+    } catch {
+      return false;
     }
   }
+  async safeReadDir(dirPath) {
+    try {
+      return await import_node_fs4.promises.readdir(dirPath);
+    } catch {
+      return [];
+    }
+  }
+  async cleanupMediaCacheDir(dirPath, limit) {
+    const files = await this.safeReadDir(dirPath);
+    if (!files.length) {
+      return;
+    }
+    const fileStats = await Promise.all(files.map(async (fileName) => {
+      const filePath = import_node_path4.default.join(dirPath, fileName);
+      const stats = await import_node_fs4.promises.stat(filePath);
+      return { path: filePath, mtime: stats.mtimeMs };
+    }));
+    fileStats.sort((left, right) => right.mtime - left.mtime);
+    for (const file of fileStats.slice(limit)) {
+      try {
+        await import_node_fs4.promises.unlink(file.path);
+      } catch {
+        continue;
+      }
+    }
+  }
+  getClientErrorMessage(error) {
+    if (typeof error === "object" && error !== null && "message" in error && typeof error.message === "string") {
+      return error.message;
+    }
+    return String(error);
+  }
 };
 
+// src/logger.ts
+function createPluginLogger(logger, config) {
+  return {
+    logInfo(...args) {
+      if (config.loggerinfo) {
+        Reflect.apply(logger.info, logger, args);
+      }
+    },
+    info(...args) {
+      Reflect.apply(logger.info, logger, args);
+    },
+    warn(...args) {
+      Reflect.apply(logger.warn, logger, args);
+    },
+    error(...args) {
+      Reflect.apply(logger.error, logger, args);
+    }
+  };
+}
+__name(createPluginLogger, "createPluginLogger");
+
 // src/config.ts
 var import_koishi2 = require("koishi");
 var Config = import_koishi2.Schema.intersect([
   import_koishi2.Schema.object({
     maxMessagesPerChannel: import_koishi2.Schema.number().default(500).description("每个群组最大保存消息数量").min(50).max(1500).step(1),
+    messageChunkSize: import_koishi2.Schema.number().default(100).description("单个消息分块文件最大消息数量").min(20).max(500).step(1),
+    channelCacheLimit: import_koishi2.Schema.number().default(50).description("内存中最多缓存的频道消息数量").min(1).max(200).step(1),
     maxPersistImages: import_koishi2.Schema.number().default(100).description("持久化存储的图片缓存数量").min(10).max(500).step(1),
     blockedPlatforms: import_koishi2.Schema.array(import_koishi2.Schema.object({
       platformName: import_koishi2.Schema.string().description("平台名称或关键词"),
@@ -1462,118 +2304,49 @@ var usage = `
 ---
 `;
 async function apply(ctx, config) {
-  const logger = ctx.logger("chat-patch");
-  const mediaDir = import_node_path3.default.join(ctx.baseDir, "data", "chat-patch", "persist-media", "media");
-  if (require("node:fs").existsSync(mediaDir)) {
-    try {
-      const files = require("node:fs").readdirSync(mediaDir);
-      let deletedCount = 0;
-      for (const file of files) {
-        const filePath = import_node_path3.default.join(mediaDir, file);
-        try {
-          require("node:fs").unlinkSync(filePath);
-          deletedCount++;
-        } catch (e) {
-          logger.warn("删除媒体文件失败:", filePath, e);
-        }
-      }
-      if (deletedCount > 0) {
-        logger.info(`启动时清理了 ${deletedCount} 个旧版本的媒体缓存文件`);
-      }
-    } catch (e) {
-      logger.warn("清理媒体文件夹失败:", e);
-    }
-  }
-  const fileManager = new FileManager(ctx, config);
-  const messageHandler = new MessageHandler(ctx, config, fileManager);
-  const apiHandlers = new ApiHandlers(ctx, config, fileManager, messageHandler);
+  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 initialData = fileManager.readChatDataFromFile();
-  const cleanedData = fileManager.cleanExcessMessages(initialData);
-  const originalCount = Object.values(initialData.messages).reduce((total, msgs) => total + msgs.length, 0);
-  const cleanedCount = Object.values(cleanedData.messages).reduce((total, msgs) => total + msgs.length, 0);
-  if (originalCount !== cleanedCount) {
-    fileManager.writeChatDataToFile(cleanedData);
-  }
-  function logInfo(...args) {
-    if (config.loggerinfo) {
-      logger.info(...args);
-    }
-  }
-  __name(logInfo, "logInfo");
-  logInfo("插件加载完成，数据统计:", {
-    机器人数量: Object.keys(cleanedData.bots).length,
-    频道数量: Object.keys(cleanedData.channels).reduce((total, botId) => total + Object.keys(cleanedData.channels[botId] || {}).length, 0),
-    消息频道数: Object.keys(cleanedData.messages).length,
-    总消息数: Object.values(cleanedData.messages).reduce((total, msgs) => total + msgs.length, 0)
+  const metadata = await fileManager.readMetadataOnly();
+  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;
-    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);
+    messageHandler.recordUserMessage(session, Date.now());
   });
   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);
+    messageHandler.recordBotMessage(session, Date.now());
   });
+  let cleanupDelayTimer;
+  let cleanupInterval;
   ctx.on("ready", async () => {
-    logInfo("插件启动完成，开始监听消息");
-    ctx.setInterval(() => {
-      const data = fileManager.readChatDataFromFile();
-      const cleanedData2 = fileManager.cleanExcessMessages(data);
-      const originalCount2 = Object.values(data.messages).reduce((total, msgs) => total + msgs.length, 0);
-      const cleanedCount2 = Object.values(cleanedData2.messages).reduce((total, msgs) => total + msgs.length, 0);
-      if (originalCount2 !== cleanedCount2) {
-        fileManager.writeChatDataToFile(cleanedData2);
-        logInfo("定期清理完成，清理了", originalCount2 - cleanedCount2, "条超量消息");
-      }
+    pluginLogger.logInfo("插件启动完成，开始监听消息");
+    cleanupDelayTimer = ctx.setTimeout(() => {
+      void fileManager.cleanupExcessMessagesInStorage();
+    }, 15e3);
+    cleanupInterval = ctx.setInterval(() => {
+      void fileManager.cleanupExcessMessagesInStorage();
     }, 3e5);
   });
   apiHandlers.registerApiHandlers();
   ctx.console.addEntry({
-    dev: import_node_path3.default.resolve(__dirname, "../client/index.ts"),
-    prod: import_node_path3.default.resolve(__dirname, "../dist")
+    dev: import_node_path5.default.resolve(__dirname, "../client/index.ts"),
+    prod: import_node_path5.default.resolve(__dirname, "../dist")
   });
   ctx.on("dispose", () => {
-    fileManager.dispose();
-    logInfo("插件已卸载，所有待处理的消息已写入");
+    cleanupDelayTimer?.();
+    cleanupInterval?.();
+    messageHandler.dispose();
+    void fileManager.dispose();
+    pluginLogger.logInfo("插件已卸载，所有待处理的消息已写入");
   });
 }
 __name(apply, "apply");