koishi-plugin-chat-patch 3.0.2 → 5.0.1

package/lib/index.js

@@ -39,2303 +39,2296 @@ __export(src_exports, {
   usage: () => usage
 });
 module.exports = __toCommonJS(src_exports);
-var import_node_path5 = __toESM(require("node:path"));
+var import_node_path4 = __toESM(require("node:path"));
 
-// src/utils.ts
-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 _Utils {
-  constructor(config, ctx) {
-    this.config = config;
-    this.ctx = ctx;
-    this.persistImageWriteCount = 0;
-    this.pendingTasks = /* @__PURE__ */ new Set();
-  }
-  isPlatformBlocked(platform) {
-    if (!this.config.blockedPlatforms || this.config.blockedPlatforms.length === 0) {
-      return false;
-    }
-    for (const blockedPlatform of this.config.blockedPlatforms) {
-      if (blockedPlatform.exactMatch) {
-        if (platform === blockedPlatform.platformName) {
-          return true;
-        }
-      } else {
-        if (platform.includes(blockedPlatform.platformName)) {
-          return true;
-        }
-      }
-    }
-    return false;
-  }
-  extractTextContent(elements) {
-    let text = "";
-    for (const element of elements) {
-      if (element.type === "text") {
-        text += element.attrs?.content || "";
-      } else if (element.type === "p") {
-        if (element.children && element.children.length > 0) {
-          text += this.extractTextContent(element.children) + "\n";
-        }
-      } else if (element.children && element.children.length > 0) {
-        text += this.extractTextContent(element.children);
+// 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);
     }
-    return text;
-  }
-  isBase64(str) {
-    if (!str || typeof str !== "string") return false;
-    if (str.startsWith("data:")) {
-      return str.includes("base64,");
-    }
-    if (str.length > 100) {
-      const base64Regex = /^[A-Za-z0-9+/]*={0,2}$/;
-      return base64Regex.test(str);
-    }
-    return false;
-  }
-  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");
-      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 = `${hash}.${ext}`;
-      const filePath = (0, import_node_path.join)(dir, filename);
-      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));
+  };
+}
+__name(createPluginLogger, "createPluginLogger");
+
+// src/cache.ts
+function getString(value) {
+  return typeof value === "string" ? value : "";
+}
+__name(getString, "getString");
+function isUsableName(value, id) {
+  return Boolean(value) && value !== id && !/unknown user|unknown guild|unknown channel/i.test(value);
+}
+__name(isUsableName, "isUsableName");
+function normalizeGroupId(value) {
+  const raw = value.replace(/^(?:group|room|chat|channel|guild):/i, "").trim();
+  const wrapped = raw.match(/^\[_?([\s\S]+?)_?\]$/);
+  return wrapped ? wrapped[1] : raw || value;
+}
+__name(normalizeGroupId, "normalizeGroupId");
+function isPrivateChannelType(value) {
+  const num = Number(value);
+  if (Number.isFinite(num)) return num === 1;
+  const text = String(value ?? "").toLowerCase();
+  return text === "direct" || text === "private";
+}
+__name(isPrivateChannelType, "isPrivateChannelType");
+function normalizeCacheType(type) {
+  if (type === "user" || type === "friend") return "friend";
+  return "group";
+}
+__name(normalizeCacheType, "normalizeCacheType");
+function encodeKeyPart(value) {
+  return encodeURIComponent(value);
+}
+__name(encodeKeyPart, "encodeKeyPart");
+var _ContactCacheService = class _ContactCacheService {
+  constructor(ctx, database, logger) {
+    this.ctx = ctx;
+    this.database = database;
+    this.logger = logger;
+    this.inflight = /* @__PURE__ */ new Map();
+  }
+  // 查询单用户缓存；未命中时由后端调用 bot.getUser，并写入数据库
+  async getUser(platform, selfId, userId, guildId, channelId, fallbackName, fallbackAvatar) {
+    if (!userId || userId === "0") return null;
+    const guild = guildId && guildId !== "0" ? guildId : void 0;
+    const channel = channelId && channelId !== "0" ? channelId : void 0;
+    const item = await this.resolve(platform, selfId, "user", userId, async (bot) => {
+      let user = null;
+      let member = null;
+      try {
+        user = await bot.getUser(userId, guild);
+      } catch (error) {
+        this.logger.logInfo("用户身份回源失败:", userId, error);
       }
-      return (0, import_node_url.pathToFileURL)(filePath).href;
-    } catch {
-      return base64Data;
-    }
-  }
-  async cleanupPersistImagesAsync(dir) {
-    try {
-      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)) {
+      let name2 = getString(user?.name) || getString(user?.nick) || getString(user?.username) || getString(user?.nickname);
+      let avatar = getString(user?.avatar);
+      if (guild && (!name2 || !avatar)) {
         try {
-          await import_node_fs.promises.unlink(file.path);
-        } catch {
-          continue;
+          member = await bot.getGuildMember(guild, userId);
+        } catch (error) {
+          this.logger.logInfo("群成员身份回源失败:", userId, error);
         }
+        name2 = name2 || getString(member?.name) || getString(member?.nick) || getString(member?.user?.name) || getString(member?.user?.nick);
+        avatar = avatar || getString(member?.avatar) || getString(member?.user?.avatar);
       }
-    } catch {
-    }
-  }
-  async cleanBase64ContentAsync(obj, isBotMessage = false) {
-    if (obj === null || obj === void 0) {
-      return obj;
-    }
-    if (typeof obj === "string") {
-      if (this.isBase64(obj)) {
-        if (isBotMessage && !obj.startsWith("data:image/")) {
-          return "[富媒体内容已省略]";
-        }
-        return await this.persistBase64ImageAsync(obj);
+      const eventName = getString(fallbackName);
+      const eventAvatar = getString(fallbackAvatar);
+      if (!isUsableName(name2, userId) && isUsableName(eventName, userId)) {
+        name2 = eventName;
       }
-      return obj;
-    }
-    if (Array.isArray(obj)) {
-      const cleanedItems = await Promise.all(obj.map((item) => this.cleanBase64ContentAsync(item, isBotMessage)));
-      return cleanedItems;
-    }
-    if (typeof obj === "object") {
-      const cleaned = {};
-      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;
-          }
+      if (!avatar && eventAvatar) avatar = eventAvatar;
+      if (!name2 && !avatar) return null;
+      this.logger.logInfo("用户身份已回源并写入缓存:", userId, name2);
+      return {
+        id: userId,
+        name: name2 || userId,
+        avatar: avatar || void 0,
+        raw: {
+          id: userId,
+          user_id: userId,
+          name: name2,
+          nickname: name2,
+          avatar: avatar || void 0,
+          channel_id: channel || void 0,
+          guild_id: guild || void 0
         }
-        if (typeof value === "string" && (key === "src" || key === "url" || key === "file" || key === "data" || key === "content") && this.isBase64(value)) {
-          if (isBotMessage && !value.startsWith("data:image/")) {
-            cleaned[key] = "[富媒体内容已省略]";
-          } else {
-            cleaned[key] = await this.persistBase64ImageAsync(value);
-          }
-        } else {
-          cleaned[key] = await this.cleanBase64ContentAsync(value, isBotMessage);
+      };
+    }, {
+      name: fallbackName,
+      avatar: fallbackAvatar
+    });
+    if (!item) return null;
+    const needChannel = Boolean(channel && item.channelId !== channel);
+    const needGuild = Boolean(guild && item.guildId !== guild);
+    if (channel) item.channelId = channel;
+    if (guild) item.guildId = guild;
+    if (needChannel || needGuild) {
+      if (item.raw && typeof item.raw === "object") {
+        const raw = item.raw;
+        if (channel) raw.channel_id = channel;
+        if (guild) raw.guild_id = guild;
+      }
+      await this.database.appendContact(platform, selfId, "friend", item);
+    }
+    return item;
+  }
+  // 查询群/频道缓存；未命中时由后端调用 guild.get/channel.get，并写入数据库
+  async getGroup(platform, selfId, id, guildId, channelId, fallbackName, fallbackAvatar, channelType) {
+    const guild = guildId && guildId !== "0" ? guildId : void 0;
+    const channel = channelId && channelId !== "0" ? channelId : void 0;
+    if (isPrivateChannelType(channelType)) return null;
+    if (channelType === void 0 && (/^(?:private|direct):/i.test(id) || /^(?:private|direct):/i.test(channel || ""))) return null;
+    const rawId = id && id !== "0" ? normalizeGroupId(id) : "";
+    const cacheId = rawId || guild || normalizeGroupId(channel || "") || "";
+    if (!cacheId) return null;
+    const item = await this.resolve(platform, selfId, "group", cacheId, async (bot) => {
+      const [guildData, channelData] = await Promise.all([
+        guild ? this.safeGet(() => bot.getGuild(guild)) : cacheId ? this.safeGet(() => bot.getGuild(cacheId)) : Promise.resolve(null),
+        channel ? this.safeGet(() => bot.getChannel(channel, guild)) : Promise.resolve(null)
+      ]);
+      let name2 = getString(guildData?.name) || getString(channelData?.name);
+      let avatar = getString(guildData?.avatar) || getString(channelData?.avatar);
+      const eventName = getString(fallbackName);
+      const eventAvatar = getString(fallbackAvatar);
+      if (!isUsableName(name2, cacheId) && isUsableName(eventName, cacheId)) {
+        name2 = eventName;
+      }
+      if (!avatar && eventAvatar) avatar = eventAvatar;
+      if (!name2 && !avatar) return null;
+      this.logger.logInfo("群组身份已回源并写入缓存:", cacheId, name2);
+      return {
+        id: cacheId,
+        name: name2 || cacheId,
+        avatar: avatar || void 0,
+        raw: {
+          id: cacheId,
+          group_id: cacheId,
+          name: name2,
+          group_name: name2,
+          avatar: avatar || void 0,
+          channel_id: channel || void 0,
+          channel_type: channelType ?? void 0,
+          guild_id: guild || void 0
         }
-      }
-      return cleaned;
-    }
-    return obj;
-  }
-  async dispose() {
-    await Promise.allSettled([...this.pendingTasks]);
-  }
-  trackTask(task) {
-    this.pendingTasks.add(task);
-    void task.finally(() => {
-      this.pendingTasks.delete(task);
+      };
+    }, {
+      name: fallbackName,
+      avatar: fallbackAvatar
     });
+    if (!item) return null;
+    const needChannel = Boolean(channel && item.channelId !== channel);
+    const needGuild = Boolean(guild && item.guildId !== guild);
+    if (channel) item.channelId = channel;
+    if (guild) item.guildId = guild;
+    if (needChannel || needGuild) {
+      if (item.raw && typeof item.raw === "object") {
+        const raw = item.raw;
+        if (channel) raw.channel_id = channel;
+        if (guild) raw.guild_id = guild;
+      }
+      await this.database.appendContact(platform, selfId, "group", item);
+    }
+    return item;
+  }
+  // 收到群消息时更新该群对应的群友表
+  async recordGroupMember(platform, selfId, groupId, member) {
+    if (!platform || !selfId || !groupId || !member.id) return;
+    await this.database.appendGroupMember(platform, selfId, groupId, member);
+  }
+  // 同一身份的并发请求合并，避免首条消息同时触发多个回源
+  resolve(platform, selfId, type, id, fetcher, fallback) {
+    const canonical = normalizeCacheType(type);
+    const key = [platform, selfId, canonical, id].map(encodeKeyPart).join(":");
+    const existing = this.inflight.get(key);
+    if (existing) return existing;
+    const task = this.resolveUncached(platform, selfId, canonical, id, fetcher, fallback).finally(() => this.inflight.delete(key));
+    this.inflight.set(key, task);
+    return task;
+  }
+  async resolveUncached(platform, selfId, type, id, fetcher, fallback) {
+    const cached = await this.database.getContact(platform, selfId, type, id);
+    if (cached && !this.shouldRefreshWithFallback(cached, id, fallback)) {
+      return this.publicContact(cached);
+    }
+    const bot = this.ctx.bots.find((item2) => {
+      return item2.platform === platform && item2.selfId === selfId;
+    });
+    if (!bot) {
+      const fallbackItem = this.toFallbackContact(id, fallback);
+      if (fallbackItem) {
+        await this.database.appendContact(platform, selfId, type, fallbackItem);
+        return this.publicContact(fallbackItem);
+      }
+      return null;
+    }
+    const item = await fetcher(bot);
+    if (!item) return null;
+    await this.database.appendContact(platform, selfId, type, item);
+    return this.publicContact(item);
+  }
+  shouldRefreshWithFallback(cached, id, fallback) {
+    if (!fallback) return false;
+    const cachedNameUsable = isUsableName(cached.name, id);
+    const fallbackNameUsable = isUsableName(getString(fallback.name), id);
+    const hasCachedAvatar = Boolean(cached.avatar);
+    const hasFallbackAvatar = Boolean(getString(fallback.avatar));
+    return !cachedNameUsable && fallbackNameUsable || !hasCachedAvatar && hasFallbackAvatar;
+  }
+  toFallbackContact(id, fallback) {
+    const name2 = isUsableName(getString(fallback?.name), id) ? getString(fallback.name) : "";
+    const avatar = getString(fallback?.avatar);
+    if (!name2 && !avatar) return null;
+    return {
+      id,
+      name: name2 || id,
+      avatar: avatar || void 0
+    };
   }
-  async fileExists(filePath) {
+  async safeGet(getter) {
     try {
-      await import_node_fs.promises.access(filePath);
-      return true;
-    } catch {
-      return false;
+      return await getter();
+    } catch (error) {
+      this.logger.logInfo("群组身份回源失败:", error);
+      return null;
     }
   }
+  publicContact(item) {
+    return {
+      id: item.id,
+      name: item.name,
+      avatar: item.avatar || void 0,
+      channelId: item.channelId || void 0,
+      guildId: item.guildId || void 0,
+      raw: item.raw ?? void 0
+    };
+  }
 };
-__name(_Utils, "Utils");
-var Utils = _Utils;
+__name(_ContactCacheService, "ContactCacheService");
+var ContactCacheService = _ContactCacheService;
 
-// 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 _MessageHandler {
-  constructor(ctx, config, fileManager, logger) {
+// src/database.ts
+var import_level = require("level");
+var import_node_path = __toESM(require("node:path"));
+var import_node_crypto = require("node:crypto");
+function encodeKeyPart2(value) {
+  return encodeURIComponent(value);
+}
+__name(encodeKeyPart2, "encodeKeyPart");
+function decodeKeyPart(value) {
+  try {
+    return decodeURIComponent(value);
+  } catch {
+    return value;
+  }
+}
+__name(decodeKeyPart, "decodeKeyPart");
+function messagePrefix(platform, selfId, channelId) {
+  return `m:${encodeKeyPart2(platform)}:${encodeKeyPart2(selfId)}:${encodeKeyPart2(channelId)}:`;
+}
+__name(messagePrefix, "messagePrefix");
+function legacyMessagePrefix(platform, selfId, channelId) {
+  return `m:${platform}:${selfId}:${channelId}:`;
+}
+__name(legacyMessagePrefix, "legacyMessagePrefix");
+function messageKey(record) {
+  const time = String(record.timestamp).padStart(16, "0");
+  return `${messagePrefix(record.platform, record.selfId, record.channelId || "")}${time}:${encodeKeyPart2(record.id || "unknown")}`;
+}
+__name(messageKey, "messageKey");
+function selfMessagePrefix(platform, selfId, channelId) {
+  return `sm:${encodeKeyPart2(platform)}:${encodeKeyPart2(selfId)}:${encodeKeyPart2(channelId)}:`;
+}
+__name(selfMessagePrefix, "selfMessagePrefix");
+function selfMessageKey(record) {
+  const time = String(record.sentAt).padStart(16, "0");
+  return `${selfMessagePrefix(record.platform, record.selfId, record.channelId)}${time}:${encodeKeyPart2(record.id || "unknown")}`;
+}
+__name(selfMessageKey, "selfMessageKey");
+function contactKey(platform, selfId, type) {
+  return `c:${encodeKeyPart2(platform)}:${encodeKeyPart2(selfId)}:${encodeKeyPart2(type)}`;
+}
+__name(contactKey, "contactKey");
+function legacyContactKey(platform, selfId, type) {
+  return `c:${platform}:${selfId}:${type}`;
+}
+__name(legacyContactKey, "legacyContactKey");
+function groupMemberKey(platform, selfId, groupId) {
+  return `gm:${encodeKeyPart2(platform)}:${encodeKeyPart2(selfId)}:${encodeKeyPart2(groupId)}`;
+}
+__name(groupMemberKey, "groupMemberKey");
+function legacyGroupMemberKey(platform, selfId, groupId) {
+  return `gm:${platform}:${selfId}:${groupId}`;
+}
+__name(legacyGroupMemberKey, "legacyGroupMemberKey");
+function isPrivateChannelId(value) {
+  return typeof value === "string" && /^(?:private|direct):/i.test(value);
+}
+__name(isPrivateChannelId, "isPrivateChannelId");
+function isPrivateChannelType2(value) {
+  const num = Number(value);
+  if (Number.isFinite(num)) return num === 1;
+  const text = String(value ?? "").toLowerCase();
+  return text === "direct" || text === "private";
+}
+__name(isPrivateChannelType2, "isPrivateChannelType");
+function isUsableGroupContact(item) {
+  if (isPrivateChannelId(item.channelId)) return false;
+  if (typeof item.raw === "object" && item.raw !== null) {
+    const raw = item.raw;
+    if (isPrivateChannelType2(raw.channel_type) || isPrivateChannelId(raw.channel_id) || isPrivateChannelId(raw.channelId)) return false;
+  }
+  return true;
+}
+__name(isUsableGroupContact, "isUsableGroupContact");
+var _ChatDatabase = class _ChatDatabase {
+  constructor(ctx, config, logger) {
     this.ctx = ctx;
     this.config = config;
-    this.fileManager = fileManager;
     this.logger = logger;
-    this.correctChannelIds = /* @__PURE__ */ new Map();
-    this.scheduledTasks = /* @__PURE__ */ new Set();
-    this.channelRefreshInFlight = /* @__PURE__ */ new Set();
-    this.lastChannelRefreshAt = /* @__PURE__ */ new Map();
-    this.CHANNEL_REFRESH_TTL_MS = 10 * 60 * 1e3;
-    this.utils = new Utils(config);
-  }
-  recordUserMessage(session, timestamp) {
-    this.scheduleTask("记录用户消息", async () => {
-      await this.processUserMessage(session, timestamp);
-    });
+    this.opened = false;
+    const dir = import_node_path.default.resolve(ctx.baseDir, "data", "chat-patch", "db");
+    this.db = new import_level.Level(dir, { keyEncoding: "utf8", valueEncoding: "utf8" });
   }
-  recordBotMessage(session, timestamp) {
-    this.scheduleTask("记录机器人消息", async () => {
-      await this.processBotMessage(session, timestamp);
-    });
-  }
-  setCorrectChannelId(selfId, channelId) {
-    this.correctChannelIds.set(selfId, channelId);
-    this.logger.logInfo("设置正确的 channelId:", { selfId, channelId });
-  }
-  getCorrectChannelId(selfId) {
-    return this.correctChannelIds.get(selfId);
-  }
-  updateBotInfoToFile(session) {
-    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);
-    });
+  async initialize() {
+    await this.db.open();
+    this.opened = true;
+    this.logger.logInfo("LevelDB 已打开:", this.db.location);
   }
-  updateChannelInfoToFile(session) {
-    const isDirect = session.isDirect || session.channelId?.includes("private");
-    const directUserName = session.username || session.event?.user?.name || session.userId;
-    const existingChannel = this.fileManager.getCachedChannelInfo(session.selfId, session.channelId);
-    let immediateName = session.channelId;
-    if (isDirect) {
-      if (directUserName && directUserName !== session.userId) {
-        immediateName = `私聊（${directUserName}）`;
-      } else if (existingChannel?.name && !existingChannel.name.includes("未知")) {
-        immediateName = existingChannel.name;
-      } else if (session.platform && session.platform.toLowerCase().includes("sandbox")) {
-        immediateName = `私聊（${session.userId}）`;
-      } else {
-        immediateName = "私聊（未知用户）";
-      }
-    } else if (existingChannel?.guildName) {
-      immediateName = existingChannel.guildName;
-    }
-    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);
-      });
+  async dispose() {
+    if (!this.opened) return;
+    await this.db.close();
+    this.opened = false;
+    this.logger.logInfo("LevelDB closed");
+  }
+  async appendMessage(record) {
+    await this.db.put(messageKey(record), JSON.stringify(record));
+    await this.trimMessages(record.platform, record.selfId, record.channelId || "");
+  }
+  async upsertSelfMessage(record) {
+    if (record.messageId) {
+      await this.removeSelfMessageByMessageId(
+        record.platform,
+        record.selfId,
+        record.channelId,
+        record.messageId,
+        record.id
+      );
+    }
+    await this.db.put(selfMessageKey(record), JSON.stringify(record));
+    await this.trimSelfMessages(record.platform, record.selfId, record.channelId);
+  }
+  async listSelfMessages(platform, selfId, channelId, limit = this.config.historyPageSize) {
+    const result = [];
+    const prefix = selfMessagePrefix(platform, selfId, channelId);
+    for await (const [, value] of this.db.iterator({
+      gte: prefix,
+      lte: `${prefix}￿`,
+      reverse: true,
+      limit
+    })) {
+      const parsed = this.parseSelfMessage(value);
+      if (parsed) result.push(parsed);
     }
-    return immediateName;
+    return result;
   }
-  async downloadAndCacheMedia(url, type) {
-    try {
-      if (!url || url.startsWith("data:")) return url;
-      if (url.includes("/vite/@fs/")) return url;
-      let folder = "media";
-      if (type === "image") folder = "images";
-      else if (type === "avatar") folder = "avatars";
-      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 = import_node_path2.default.join(dir, filename);
-      if (!await this.fileExists(filePath)) {
-        const buffer = await this.ctx.http.get(url, { responseType: "arraybuffer" });
-        await import_node_fs2.promises.writeFile(filePath, Buffer.from(buffer));
-      }
-      const normalizedPath = filePath.replace(/\\/g, "/");
-      return `/vite/@fs/${normalizedPath}`;
-    } catch (e) {
-      this.logger.warn("下载并缓存媒体失败:", e);
-      return url;
+  async listSelfMessagesBefore(platform, selfId, channelId, beforeTime, limit = this.config.historyPageSize) {
+    const result = [];
+    const prefix = selfMessagePrefix(platform, selfId, channelId);
+    const before = `${prefix}${String(beforeTime).padStart(16, "0")}`;
+    for await (const [, value] of this.db.iterator({
+      gte: prefix,
+      lt: before,
+      reverse: true,
+      limit
+    })) {
+      const parsed = this.parseSelfMessage(value);
+      if (parsed) result.push(parsed);
     }
+    return result;
   }
-  processMediaElementsAsync(elements, isUserMessage = true) {
-    if (!elements) return;
-    this.scheduleTask("处理媒体元素", async () => {
-      await this.processMediaElements(elements, isUserMessage);
-    });
-  }
-  async processUserMessage(session, timestamp) {
-    try {
-      if (!timestamp) timestamp = Date.now();
-      this.updateBotInfoToFile(session);
-      const guildName = this.updateChannelInfoToFile(session);
-      const isDirect = session.isDirect || session.channelId?.includes("private");
-      if (session.elements) {
-        this.processMediaElementsAsync(session.elements, true);
-      }
-      if (session.quote?.elements) {
-        this.processMediaElementsAsync(session.quote.elements, true);
-      }
-      let quoteInfo = void 0;
-      if (session.quote) {
-        quoteInfo = {
-          messageId: session.quote.messageId || session.quote.id,
-          id: session.quote.id,
-          content: session.quote.content || "",
-          elements: session.quote.elements,
-          user: {
-            id: session.quote.user?.id || session.quote.user?.userId || "unknown",
-            name: session.quote.user?.name || session.quote.user?.username || "unknown",
-            userId: session.quote.user?.userId || session.quote.user?.id || "unknown",
-            avatar: session.quote.user?.avatar,
-            username: session.quote.user?.username || session.quote.user?.name || "unknown"
-          },
-          timestamp: session.quote.timestamp || Date.now()
-        };
-      }
-      let content = "";
-      let elements = [];
-      if (session.content) {
-        content = session.content;
-      } else if (session.stripped?.content) {
-        content = session.stripped.content;
-      }
-      if (session.elements) {
-        elements = session.elements;
-        if (!content) {
-          content = session.elements.filter((element) => element.type === "text").map((element) => element.attrs?.content || "").join("");
-        }
-      }
-      const messageInfo = {
-        id: session.event?.message?.id || `msg-${timestamp}`,
-        content: content || session.content || "",
-        userId: session.userId || session.event?.user?.id || "unknown",
-        username: session.username || session.event?.user?.name || session.userId || "unknown",
-        avatar: session.event?.user?.avatar,
-        timestamp,
-        channelId: session.channelId,
-        selfId: session.selfId,
-        elements,
-        type: "user",
-        guildName,
-        platform: session.platform || "unknown",
-        quote: quoteInfo,
-        isDirect: !!isDirect
+  async updateSelfMessageByMessageId(platform, selfId, _channelId, messageId, patch) {
+    const prefix = `sm:${encodeKeyPart2(platform)}:${encodeKeyPart2(selfId)}:`;
+    for await (const [key, value] of this.db.iterator({
+      gte: prefix,
+      lte: `${prefix}￿`
+    })) {
+      const parsed = this.parseSelfMessage(value);
+      if (!parsed || parsed.messageId !== messageId) continue;
+      const next = {
+        ...parsed,
+        ...patch,
+        id: parsed.id,
+        sentAt: parsed.sentAt
       };
-      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,
-        platform: session.platform || "unknown",
-        channelId: session.channelId,
-        messageId: session.event?.message?.id || `msg-${timestamp}`,
-        content: content || session.content || "",
-        userId: session.userId || session.event?.user?.id || "unknown",
-        username: session.username || session.event?.user?.name || session.userId || "unknown",
-        avatar: session.event?.user?.avatar,
-        timestamp,
-        guildName,
-        channelType: session.type || 0,
-        elements: eventElements,
-        quote: eventQuote,
-        isDirect: session.isDirect,
-        bot: {
-          avatar: session.bot.user?.avatar,
-          name: session.bot.user?.name
-        }
-      };
-      this.ctx.console.broadcast("chat-message-event", messageEvent);
-    } catch (error) {
-      this.logger.error("处理用户消息失败:", error);
+      await this.db.put(key, JSON.stringify(next));
+      return true;
     }
+    return false;
   }
-  async processBotMessage(session, timestamp) {
-    try {
-      if (!timestamp) timestamp = Date.now();
-      const correctChannelId = this.getCorrectChannelId(session.selfId);
-      const finalChannelId = correctChannelId || session.channelId;
-      this.updateBotInfoToFile(session);
-      const guildName = this.updateChannelInfoToFile(session);
-      const isDirect = session.isDirect || finalChannelId?.includes("private");
-      let content = session.content || "";
-      if (!content && session.event?.message?.elements) {
-        content = this.utils.extractTextContent(session.event.message.elements).trim();
-      }
-      let quoteInfo = void 0;
-      const quoteMatch = content.match(/<quote id="([^"]+)"\/>/);
-      if (quoteMatch) {
-        const quoteId = quoteMatch[1];
-        const quotedMsg = await this.fileManager.findChannelMessageById(session.selfId, finalChannelId, quoteId);
-        if (quotedMsg) {
-          const realId = quotedMsg.id.startsWith("bot-msg-") ? quotedMsg.realId : quotedMsg.id;
-          quoteInfo = {
-            messageId: realId || quotedMsg.id,
-            id: realId || quotedMsg.id,
-            content: quotedMsg.content,
-            elements: quotedMsg.elements,
-            user: {
-              id: quotedMsg.userId,
-              name: quotedMsg.username,
-              userId: quotedMsg.userId,
-              avatar: quotedMsg.avatar,
-              username: quotedMsg.username
-            },
-            timestamp: quotedMsg.timestamp
-          };
-          content = content.replace(/<quote id="[^"]+"\/>\s*/, "");
-          if (realId) {
-            session.content = session.content.replace(/id="[^"]+"/, `id="${realId}"`);
+  async findSelfForwardContent(platform, selfId, channelId, id) {
+    const prefixes = channelId ? [selfMessagePrefix(platform, selfId, channelId)] : [`sm:${encodeKeyPart2(platform)}:${encodeKeyPart2(selfId)}:`];
+    for (const prefix of prefixes) {
+      for await (const [, value] of this.db.iterator({
+        gte: prefix,
+        lte: `${prefix}￿`
+      })) {
+        const parsed = this.parseSelfMessage(value);
+        if (!parsed) continue;
+        if (parsed.forwardId === id || parsed.messageId === id) {
+          if (Array.isArray(parsed.forwardContent) && parsed.forwardContent.length > 0) {
+            return parsed.forwardContent;
           }
         }
       }
-      const messageInfo = {
-        id: `bot-msg-${timestamp}`,
-        content,
-        userId: session.selfId,
-        username: session.bot.user?.name || `Bot-${session.selfId}`,
-        avatar: session.bot.user?.avatar,
-        timestamp,
-        channelId: finalChannelId,
-        selfId: session.selfId,
-        elements: await this.utils.cleanBase64ContentAsync(session.event?.message?.elements, true),
-        type: "bot",
-        guildName,
-        platform: session.platform || "unknown",
-        quote: quoteInfo,
-        isDirect: !!isDirect,
-        sending: true
-        // 标记为正在发送
-      };
-      await this.fileManager.addMessageToFile(messageInfo);
-      const eventElements = await this.utils.cleanBase64ContentAsync(session.event?.message?.elements, true);
-      const messageEvent = {
-        type: "bot-message",
-        selfId: session.selfId,
-        platform: session.platform || "unknown",
-        channelId: finalChannelId,
-        messageId: `bot-msg-${timestamp}`,
-        content,
-        userId: session.selfId,
-        username: session.bot.user?.name || `Bot-${session.selfId}`,
-        avatar: session.bot.user?.avatar,
-        timestamp,
-        guildName,
-        channelType: session.event?.channel?.type || session.type || 0,
-        elements: eventElements,
-        quote: quoteInfo,
-        isDirect: !!isDirect,
-        sending: true,
-        bot: {
-          avatar: session.bot.user?.avatar,
-          name: session.bot.user?.name
-        }
-      };
-      this.ctx.console.broadcast("chat-bot-message-event", messageEvent);
-    } catch (error) {
-      this.logger.error("处理机器人消息失败:", error);
-    }
-  }
-  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);
+    return null;
   }
-  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;
+  async removeSelfMessageByMessageId(platform, selfId, _channelId, messageId, exceptId) {
+    const prefix = `sm:${encodeKeyPart2(platform)}:${encodeKeyPart2(selfId)}:`;
+    const toDelete = [];
+    for await (const [key, value] of this.db.iterator({
+      gte: prefix,
+      lte: `${prefix}￿`
+    })) {
+      const parsed = this.parseSelfMessage(value);
+      if (parsed && parsed.messageId === messageId && parsed.id !== exceptId) {
+        toDelete.push(key);
+      }
     }
-    if (isDirect) {
-      return !directUserName && (!existingChannel || existingChannel.name.includes("未知"));
+    if (toDelete.length) {
+      await this.db.batch(toDelete.map((key) => ({ type: "del", key })));
     }
-    return !existingChannel?.guildName || existingChannel.guildName === channelId;
   }
-  async refreshChannelInfo(session, existingChannel, isDirect, directUserName) {
-    const channelKey = `${session.selfId}:${session.channelId}`;
-    this.channelRefreshInFlight.add(channelKey);
+  parseSelfMessage(value) {
     try {
-      let guildName = existingChannel?.guildName || session.channelId;
-      if (!isDirect) {
-        guildName = await this.resolveGuildName(session);
+      const parsed = JSON.parse(value);
+      if (typeof parsed === "object" && parsed !== null) {
+        const record = parsed;
+        if (typeof record.id === "string" && typeof record.platform === "string" && typeof record.selfId === "string" && typeof record.channelId === "string" && typeof record.sentAt === "number") {
+          return record;
+        }
       }
-      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);
+    } catch {
+      this.logger.warn("机器人消息解析失败:", value.slice(0, 120));
     }
+    return null;
   }
-  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;
+  async listMessages(platform, selfId, channelId, limit = this.config.historyPageSize) {
+    const result = [];
+    for (const prefix of [messagePrefix(platform, selfId, channelId), legacyMessagePrefix(platform, selfId, channelId)]) {
+      for await (const [, value] of this.db.iterator({
+        gte: prefix,
+        lte: `${prefix}￿`,
+        reverse: true,
+        limit: limit - result.length
+      })) {
+        try {
+          const parsed = JSON.parse(value);
+          if (typeof parsed === "object" && parsed !== null) {
+            result.push(parsed);
+          }
+        } catch {
+          this.logger.warn("历史消息解析失败:", value.slice(0, 120));
+        }
       }
-    } catch (error) {
-      this.logger.logInfo("获取频道信息失败，使用频道ID作为备用:", error);
+      if (result.length >= limit) break;
     }
-    return session.channelId;
+    return result;
   }
-  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);
+  async listMessagesBefore(platform, selfId, channelId, beforeTime, limit = this.config.historyPageSize) {
+    const result = [];
+    for (const prefix of [messagePrefix(platform, selfId, channelId), legacyMessagePrefix(platform, selfId, channelId)]) {
+      const before = `${prefix}${String(beforeTime).padStart(16, "0")}`;
+      for await (const [, value] of this.db.iterator({
+        gte: prefix,
+        lt: before,
+        reverse: true,
+        limit: limit - result.length
+      })) {
+        try {
+          const parsed = JSON.parse(value);
+          if (typeof parsed === "object" && parsed !== null) {
+            result.push(parsed);
           }
+        } catch {
+          this.logger.warn("历史消息解析失败:", value.slice(0, 120));
         }
       }
-      if (el.children?.length) {
-        await this.processMediaElements(el.children, isUserMessage);
+      if (result.length >= limit) break;
+    }
+    return result;
+  }
+  async clearChannel(platform, selfId, channelId) {
+    const operations = [];
+    for (const prefix of [messagePrefix(platform, selfId, channelId), legacyMessagePrefix(platform, selfId, channelId)]) {
+      for await (const [key] of this.db.iterator({
+        gte: prefix,
+        lte: `${prefix}￿`
+      })) {
+        operations.push({ type: "del", key });
       }
     }
+    const selfPrefix = selfMessagePrefix(platform, selfId, channelId);
+    for await (const [key] of this.db.iterator({
+      gte: selfPrefix,
+      lte: `${selfPrefix}￿`
+    })) {
+      operations.push({ type: "del", key });
+    }
+    if (operations.length) await this.db.batch(operations);
   }
-  async fileExists(filePath) {
+  async getPinned() {
     try {
-      await import_node_fs2.promises.access(filePath);
-      return true;
+      const value = await this.db.get("meta:pinned");
+      const parsed = JSON.parse(value);
+      if (typeof parsed === "object" && parsed !== null) {
+        return parsed;
+      }
     } catch {
-      return false;
     }
+    return { bots: [], channels: [] };
   }
-};
-__name(_MessageHandler, "MessageHandler");
-var MessageHandler = _MessageHandler;
-
-// src/file-manager.ts
-var import_node_path3 = __toESM(require("node:path"));
-var import_node_fs3 = require("node:fs");
-var _FileManager = class _FileManager {
-  constructor(ctx, config, logger) {
-    this.ctx = ctx;
-    this.config = config;
-    this.logger = logger;
-    this.memoryCache = this.createEmptyChatData();
-    this.channelMessagesCache = /* @__PURE__ */ new Map();
-    this.recentMessageIdsCache = /* @__PURE__ */ new Map();
-    this.pendingBotMessageIds = /* @__PURE__ */ new Map();
-    this.messageChunkLocationCache = /* @__PURE__ */ new Map();
-    this.dirtyChannelKeys = /* @__PURE__ */ new Set();
-    this.pendingMessages = /* @__PURE__ */ new Map();
-    // 按channelKey分组的待写入消息
-    this.writeTimers = /* @__PURE__ */ new Map();
-    // 每个频道独立的写入定时器
-    this.metadataLoadPromise = null;
-    this.channelLoadPromises = /* @__PURE__ */ new Map();
-    this.writeQueue = Promise.resolve();
-    this.disposed = false;
-    this.WRITE_DEBOUNCE_MS = 1e3;
-    this.RECENT_MESSAGE_ID_CACHE_SIZE = 200;
-    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);
-  }
-  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 setPinned(state) {
+    await this.db.put("meta:pinned", JSON.stringify(state));
   }
-  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;
+  async getMeta(key) {
+    try {
+      return JSON.parse(await this.db.get(`meta:${key}`));
+    } catch {
+      return void 0;
     }
-    this.memoryCache.channels[selfId][channelId] = channelInfo;
-    this.scheduleMetadataWrite();
   }
-  async setPinnedBots(pinnedBots) {
-    await this.ensureMetadataLoaded();
-    this.memoryCache.pinnedBots = [...pinnedBots];
-    this.scheduleMetadataWrite();
+  async setMeta(key, value) {
+    await this.db.put(`meta:${key}`, JSON.stringify(value));
   }
-  async setPinnedChannels(pinnedChannels) {
-    await this.ensureMetadataLoaded();
-    this.memoryCache.pinnedChannels = [...pinnedChannels];
-    this.scheduleMetadataWrite();
+  async recordMedia(url, filePath, channelId = "") {
+    const key = `media:${(0, import_node_crypto.createHash)("md5").update(url).digest("hex")}`;
+    await this.db.put(key, JSON.stringify({ filePath, channelId }));
   }
-  // 清理旧版本数据目录
-  async cleanupLegacyStorage(baseDir) {
-    const oldFiles = ["chat-data.json", "data.json", "messages.json"];
-    for (const fileName of oldFiles) {
-      const filePath = import_node_path3.default.join(baseDir, fileName);
+  async getMediaPath(url) {
+    try {
+      const key = `media:${(0, import_node_crypto.createHash)("md5").update(url).digest("hex")}`;
+      const value = await this.db.get(key);
       try {
-        await import_node_fs3.promises.unlink(filePath);
-        this.logger.logInfo(`已删除旧版本数据文件: ${fileName}`);
-      } catch (error) {
-        if (!this.isFileMissingError(error)) {
-          this.logger.warn(`删除旧版本数据文件失败: ${fileName}`, error);
+        const parsed = JSON.parse(value);
+        if (typeof parsed === "object" && parsed !== null) {
+          const item = parsed;
+          return typeof item.filePath === "string" ? item.filePath : value;
         }
+      } catch {
       }
+      return value;
+    } catch {
+      return void 0;
     }
-    const legacyPaths = [
-      import_node_path3.default.join(baseDir, "metadata.json"),
-      import_node_path3.default.join(baseDir, "chat-history")
-    ];
-    for (const legacyPath of legacyPaths) {
+  }
+  async getAllMedia() {
+    const result = [];
+    for await (const [, value] of this.db.iterator({
+      gte: "media:",
+      lte: "media:￿"
+    })) {
       try {
-        await import_node_fs3.promises.rm(legacyPath, { recursive: true, force: true });
-        this.logger.logInfo(`已清理旧版数据路径: ${legacyPath}`);
-      } catch (error) {
-        this.logger.warn(`清理旧版数据路径失败: ${legacyPath}`, error);
+        const parsed = JSON.parse(value);
+        if (typeof parsed === "object" && parsed !== null) {
+          const item = parsed;
+          if (typeof item.filePath === "string") {
+            result.push({
+              filePath: item.filePath,
+              channelId: typeof item.channelId === "string" ? item.channelId : ""
+            });
+          }
+        } else if (typeof parsed === "string") {
+          result.push({ filePath: parsed, channelId: "" });
+        }
+      } catch {
+        result.push({ filePath: value, channelId: "" });
       }
     }
+    return result;
   }
-  // 确保目录存在
-  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;
+  async removeMediaByPath(filePath) {
+    const normalized = import_node_path.default.normalize(filePath);
+    const toDelete = [];
+    for await (const [key, value] of this.db.iterator({
+      gte: "media:",
+      lte: "media:￿"
+    })) {
+      let stored = value;
+      try {
+        const parsed = JSON.parse(value);
+        if (typeof parsed === "object" && parsed !== null) {
+          const item = parsed;
+          stored = typeof item.filePath === "string" ? item.filePath : value;
+        }
+      } catch {
+      }
+      if (import_node_path.default.normalize(stored) === normalized) toDelete.push(key);
     }
-    const loadPromise = this.loadChannelMessages(selfId, channelId);
-    this.channelLoadPromises.set(channelKey, loadPromise);
-    try {
-      return await loadPromise;
-    } finally {
-      this.channelLoadPromises.delete(channelKey);
+    if (toDelete.length) {
+      await this.db.batch(toDelete.map((key) => ({ type: "del", key })));
     }
   }
-  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
-          };
+  async getContacts(platform, selfId, type) {
+    for (const key of [contactKey(platform, selfId, type), legacyContactKey(platform, selfId, type)]) {
+      try {
+        const value = await this.db.get(key);
+        const parsed = JSON.parse(value);
+        if (Array.isArray(parsed)) {
+          const contacts = parsed;
+          return type === "group" ? contacts.filter(isUsableGroupContact) : contacts;
         }
+      } catch {
       }
     }
-    return {
-      messages: collected.reverse(),
-      total: indexData.totalMessages
-    };
+    return [];
   }
-  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;
+  async getContact(platform, selfId, type, id) {
+    const contacts = await this.getContacts(platform, selfId, type);
+    return contacts.find((item) => item.id === id) ?? 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 setContacts(platform, selfId, type, contacts) {
+    const next = type === "group" ? contacts.filter(isUsableGroupContact) : contacts;
+    await this.db.put(contactKey(platform, selfId, type), JSON.stringify(next));
+  }
+  async appendContact(platform, selfId, type, contact) {
+    if (type === "group" && !isUsableGroupContact(contact)) return;
+    const contacts = await this.getContacts(platform, selfId, type);
+    const next = contacts.filter((item) => item.id !== contact.id);
+    next.push(contact);
+    await this.setContacts(platform, selfId, type, next);
   }
-  // 写入元数据
-  async writeMetadata(metadata) {
+  async getContactsLegacy(platform, selfId, type) {
     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));
+      const value = await this.db.get(legacyContactKey(platform, selfId, type));
+      const parsed = JSON.parse(value);
+      if (!Array.isArray(parsed)) return [];
+      const contacts = parsed;
+      return type === "group" ? contacts.filter(isUsableGroupContact) : contacts;
+    } catch {
+      return [];
     }
-    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;
+  async getGroupMembers(platform, selfId, groupId) {
+    for (const key of [groupMemberKey(platform, selfId, groupId), legacyGroupMemberKey(platform, selfId, groupId)]) {
+      try {
+        const value = await this.db.get(key);
+        const parsed = JSON.parse(value);
+        return Array.isArray(parsed) ? parsed : [];
+      } catch {
       }
     }
-    if (cleanedCount > 0) {
-      this.logger.logInfo("总共清理超量消息:", cleanedCount, "条");
-    }
-    return {
-      ...data,
-      messages: cleanedMessages
-    };
+    return [];
   }
-  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;
+  async setGroupMembers(platform, selfId, groupId, members) {
+    await this.db.put(groupMemberKey(platform, selfId, groupId), JSON.stringify(members));
+  }
+  async getGroupMember(platform, selfId, groupId, userId) {
+    const members = await this.getGroupMembers(platform, selfId, groupId);
+    return members.find((item) => item.id === userId) ?? null;
+  }
+  async appendGroupMember(platform, selfId, groupId, member) {
+    const members = await this.getGroupMembers(platform, selfId, groupId);
+    const next = members.filter((item) => item.id !== member.id);
+    next.push(member);
+    await this.setGroupMembers(platform, selfId, groupId, next);
+  }
+  async getAllContacts() {
+    const result = [];
+    const byTriple = /* @__PURE__ */ new Map();
+    for await (const [key, value] of this.db.iterator({
+      gte: "c:",
+      lte: "c:￿"
+    })) {
+      if (!key.startsWith("c:")) continue;
+      let source = "legacy";
+      let platform = "";
+      let selfId = "";
+      let type = "";
+      const parts = key.slice(2).split(":");
+      if (parts.length === 3) {
+        platform = decodeKeyPart(parts[0]);
+        selfId = decodeKeyPart(parts[1]);
+        type = decodeKeyPart(parts[2]);
+        source = "new";
+      } else {
+        const typeIndex = key.lastIndexOf(":");
+        if (typeIndex <= 2) continue;
+        type = key.slice(typeIndex + 1);
+        const rest = key.slice(2, typeIndex);
+        const sep = rest.lastIndexOf(":");
+        if (sep <= 0) continue;
+        platform = rest.slice(0, sep);
+        selfId = rest.slice(sep + 1);
+      }
+      if (!platform || !selfId || !type) continue;
+      try {
+        const parsed = JSON.parse(value);
+        const entry = {
+          platform,
+          selfId,
+          type,
+          contacts: Array.isArray(parsed) ? parsed : []
+        };
+        if (entry.type === "group") {
+          entry.contacts = entry.contacts.filter(isUsableGroupContact);
+        }
+        const triple = JSON.stringify([platform, selfId, type]);
+        const existing = byTriple.get(triple);
+        if (!existing || existing.kind === "legacy" && source === "new") {
+          byTriple.set(triple, { kind: source, entry });
+        }
+      } catch {
+        this.logger.warn("联系人缓存解析失败:", key);
+      }
     }
-    const cachedMessages = this.peekCachedChannelMessages(channelKey);
-    if (cachedMessages?.some((message) => message.id === cleanedMessageInfo.id)) {
-      return;
+    for (const { entry } of byTriple.values()) {
+      result.push(entry);
     }
-    if (!cachedMessages) {
-      if (this.hasRecentMessageId(channelKey, cleanedMessageInfo.id)) {
-        return;
+    return result;
+  }
+  async trimMessages(platform, selfId, channelId) {
+    let count = 0;
+    const toDelete = [];
+    for (const prefix of [messagePrefix(platform, selfId, channelId), legacyMessagePrefix(platform, selfId, channelId)]) {
+      for await (const [key] of this.db.iterator({
+        gte: prefix,
+        lte: `${prefix}￿`
+      })) {
+        count += 1;
+        if (count > this.config.maxMessagesPerChannel) toDelete.push(key);
+      }
+    }
+    if (!toDelete.length) return;
+    await this.db.batch(toDelete.map((key) => ({ type: "del", key })));
+    this.logger.logInfo(`频道历史已裁剪 ${toDelete.length} 条`);
+  }
+  async trimSelfMessages(platform, selfId, channelId) {
+    let count = 0;
+    const toDelete = [];
+    const prefix = selfMessagePrefix(platform, selfId, channelId);
+    for await (const [key] of this.db.iterator({
+      gte: prefix,
+      lte: `${prefix}￿`
+    })) {
+      count += 1;
+      if (count > this.config.maxMessagesPerChannel) toDelete.push(key);
+    }
+    if (!toDelete.length) return;
+    await this.db.batch(toDelete.map((key) => ({ type: "del", key })));
+    this.logger.logInfo(`机器人消息已裁剪 ${toDelete.length} 条`);
+  }
+};
+__name(_ChatDatabase, "ChatDatabase");
+var ChatDatabase = _ChatDatabase;
+
+// src/recorder.ts
+var MESSAGE_TYPES = /* @__PURE__ */ new Set(["message", "message-created"]);
+function normalizeGroupId2(value) {
+  const raw = value.replace(/^(?:group|room|chat|channel|guild):/i, "").trim();
+  const wrapped = raw.match(/^\[_?([\s\S]+?)_?\]$/);
+  return wrapped ? wrapped[1] : raw || value;
+}
+__name(normalizeGroupId2, "normalizeGroupId");
+var _Recorder = class _Recorder {
+  constructor(ctx, config, database, media, contactCache, logger) {
+    this.ctx = ctx;
+    this.config = config;
+    this.database = database;
+    this.media = media;
+    this.contactCache = contactCache;
+    this.logger = logger;
+  }
+  start() {
+    this.ctx.on("internal/session", (session) => {
+      void this.handleSession(session);
+    });
+  }
+  isBlocked(platform) {
+    return (this.config.blockedPlatforms ?? []).some((item) => {
+      return item.exactMatch ? platform === item.platformName : platform.includes(item.platformName);
+    });
+  }
+  async handleSession(session) {
+    const platform = session.platform || "unknown";
+    if (this.isBlocked(platform)) return;
+    if (!MESSAGE_TYPES.has(session.type)) return;
+    const event = session.toJSON();
+    const message = event.message;
+    const record = {
+      id: message?.id || `local-${event.sn}`,
+      sequence: event.sn,
+      type: session.type,
+      platform,
+      selfId: session.selfId,
+      channelId: session.channelId,
+      guildId: session.guildId,
+      userId: session.userId,
+      timestamp: session.timestamp,
+      timestampMs: session.timestamp,
+      receivedAt: Date.now(),
+      content: session.content || message?.content,
+      elements: message?.elements,
+      raw: event
+    };
+    try {
+      await this.database.appendMessage(record);
+      void this.cacheMessageContacts(event).catch((error) => {
+        this.logger.warn("缓存消息联系人失败:", error);
+      });
+      void this.cacheMessageMedia(event).catch((error) => {
+        this.logger.warn("异步缓存消息媒体失败:", error);
+      });
+    } catch (error) {
+      this.logger.warn("写入历史消息失败:", error);
+    }
+  }
+  async cacheMessageContacts(event) {
+    const platform = event.platform || "";
+    const selfId = event.selfId || "";
+    const user = event.user;
+    const guild = event.guild;
+    const channel = event.channel;
+    const member = event.member;
+    const userId = user?.id || "";
+    const guildId = guild?.id || "";
+    const channelId = channel?.id || "";
+    const channelType = String(channel?.type ?? "");
+    const isPrivateChannel2 = channelType === "1" || ["direct", "private"].includes(channelType.toLowerCase()) || !channelType && /^private:/i.test(channelId);
+    const groupId = guildId || (isPrivateChannel2 ? "" : normalizeGroupId2(channelId)) || "";
+    const userName = user?.name || user?.nick || member?.nick || member?.name || "";
+    const userAvatar = user?.avatar || member?.avatar || "";
+    const groupName = guild?.name || channel?.name || "";
+    const groupAvatar = guild?.avatar || "";
+    if (groupId) {
+      const groupItem = await this.contactCache.getGroup(
+        platform,
+        selfId,
+        groupId,
+        guildId || groupId,
+        channelId || groupId,
+        groupName,
+        groupAvatar,
+        channel?.type
+      );
+      if (userId) {
+        const userItem = await this.contactCache.getUser(
+          platform,
+          selfId,
+          userId,
+          guildId || groupId,
+          void 0,
+          userName,
+          userAvatar
+        );
+        await this.contactCache.recordGroupMember(
+          platform,
+          selfId,
+          groupId,
+          {
+            id: userId,
+            name: userItem?.name || userName || userId,
+            avatar: userItem?.avatar || userAvatar || void 0,
+            raw: {
+              id: userId,
+              user_id: userId,
+              nickname: userName || userItem?.name,
+              card: member?.nick || member?.name || "",
+              avatar: userItem?.avatar || userAvatar || void 0,
+              role: member?.title || ""
+            }
+          }
+        );
       }
-      const existsInStorage = await this.channelMessageExists(messageInfo.selfId, messageInfo.channelId, cleanedMessageInfo.id);
-      if (existsInStorage) {
-        return;
+      if (!groupItem) this.logger.logInfo("群组缓存未回源到可用身份:", groupId);
+    } else if (userId) {
+      await this.contactCache.getUser(
+        platform,
+        selfId,
+        userId,
+        void 0,
+        channelId,
+        userName,
+        userAvatar
+      );
+    }
+  }
+  async cacheMessageMedia(event) {
+    const elements = Array.isArray(event.message?.elements) ? event.message.elements : [];
+    const channelId = String(
+      event.channel?.id || event.guild?.id || ""
+    );
+    const urls = [];
+    const collect = /* @__PURE__ */ __name((list) => {
+      for (const raw of list) {
+        const element = typeof raw === "object" && raw !== null ? raw : {};
+        const attrs = typeof element.attrs === "object" && element.attrs !== null ? element.attrs : {};
+        if (["img", "image", "mface", "audio", "video", "file"].includes(String(element.type))) {
+          const url = String(attrs.src ?? attrs.url ?? attrs.file ?? "");
+          if (url) urls.push(url);
+        }
+        if (Array.isArray(element.children)) collect(element.children);
       }
+    }, "collect");
+    collect(elements);
+    await Promise.allSettled(urls.map((url) => this.media.cacheUrl(url, channelId)));
+  }
+};
+__name(_Recorder, "Recorder");
+var Recorder = _Recorder;
+
+// src/media.ts
+var import_node_crypto2 = require("node:crypto");
+var import_node_fs = require("node:fs");
+var import_node_path2 = __toESM(require("node:path"));
+var import_node_url = require("node:url");
+var import_file_type = __toESM(require("file-type"));
+function toExtension(value) {
+  const ext = value.startsWith(".") ? value : `.${value}`;
+  return ext.toLowerCase();
+}
+__name(toExtension, "toExtension");
+function toLocalFilePath(value) {
+  if (value.startsWith("file://")) {
+    try {
+      return (0, import_node_url.fileURLToPath)(value);
+    } catch {
+      return null;
     }
-    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;
+  if (/^[a-z]:[\\/]/i.test(value) || value.startsWith("\\\\")) return value;
+  return null;
+}
+__name(toLocalFilePath, "toLocalFilePath");
+var _MediaManager = class _MediaManager {
+  constructor(ctx, config, database, logger) {
+    this.ctx = ctx;
+    this.config = config;
+    this.database = database;
+    this.logger = logger;
+    this.mediaDir = import_node_path2.default.resolve(ctx.baseDir, "data", "chat-patch", "media");
+    this.uploadDir = import_node_path2.default.resolve(ctx.baseDir, "data", "chat-patch", "upload-media");
+  }
+  start() {
+    const route = `${this.config.basePath}/web/media`;
+    this.ctx.server.get(route, async (koa) => {
+      const url = String(koa.query.url ?? "");
+      if (!url) {
+        koa.status = 400;
+        koa.body = "missing url";
+        return;
       }
-      const indexData = await this.loadOrCreateChannelIndex(selfId, channelId);
-      if (indexData.totalMessages <= this.config.maxMessagesPerChannel) {
-        this.dirtyChannelKeys.delete(channelKey);
-        continue;
+      const filePath = await this.cacheUrl(url);
+      if (!filePath) {
+        koa.status = 502;
+        koa.body = "download failed";
+        return;
       }
-      const removedCount = await this.trimChannelToLimit(selfId, channelId, indexData, this.config.maxMessagesPerChannel);
-      if (!removedCount) {
-        continue;
+      const size = (await import_node_fs.promises.stat(filePath)).size;
+      koa.type = import_node_path2.default.extname(filePath) || "application/octet-stream";
+      koa.set("Accept-Ranges", "bytes");
+      const range = koa.headers.range;
+      if (range) {
+        const match = /^bytes=(\d*)-(\d*)$/.exec(String(range));
+        if (!match) {
+          koa.status = 416;
+          koa.set("Content-Range", `bytes */${size}`);
+          koa.body = "";
+          return;
+        }
+        let start = 0;
+        let end = size - 1;
+        if (match[1] === "" && match[2]) {
+          start = Math.max(0, size - Number(match[2]));
+        } else if (match[1]) {
+          start = Number(match[1]);
+          end = match[2] ? Number(match[2]) : end;
+        }
+        if (!Number.isFinite(start) || !Number.isFinite(end) || start < 0 || start >= size) {
+          koa.status = 416;
+          koa.set("Content-Range", `bytes */${size}`);
+          koa.body = "";
+          return;
+        }
+        if (end >= size) end = size - 1;
+        if (end < start) end = start;
+        koa.status = 206;
+        koa.set("Content-Range", `bytes ${start}-${end}/${size}`);
+        koa.set("Content-Length", String(end - start + 1));
+        koa.body = (0, import_node_fs.createReadStream)(filePath, { start, end });
+        return;
       }
-      cleanedCount += removedCount;
-      if (this.peekCachedChannelMessages(channelKey)) {
-        this.setCachedChannelMessages(channelKey, await this.loadChannelMessagesNoCache(selfId, channelId));
+      koa.set("Content-Length", String(size));
+      koa.body = (0, import_node_fs.createReadStream)(filePath);
+    });
+    this.cleanupTimer = this.ctx.setInterval(() => {
+      void this.cleanup();
+    }, 10 * 60 * 1e3);
+    void this.cleanup();
+  }
+  dispose() {
+    this.cleanupTimer?.();
+  }
+  async cacheUrl(url, channelId = "") {
+    try {
+      const filePath = await this.resolveAndDownload(url, channelId);
+      if (filePath) {
+        await this.database.recordMedia(url, filePath, channelId);
       }
-      this.dirtyChannelKeys.delete(channelKey);
-      this.logger.logInfo(`频道 ${channelKey} 清理了 ${removedCount} 条旧消息，保留最新 ${indexData.totalMessages} 条`);
-    }
-    if (cleanedCount > 0) {
-      this.logger.logInfo("定期清理完成，清理了", cleanedCount, "条超量消息");
+      return filePath;
+    } catch (error) {
+      this.logger.warn("媒体缓存失败:", url, error);
+      return null;
     }
   }
-  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];
+  async resolveAndDownload(url, channelId) {
+    try {
+      await import_node_fs.promises.mkdir(this.mediaDir, { recursive: true });
+      const localSource = toLocalFilePath(url);
+      if (localSource && await this.exists(localSource)) {
+        const hash2 = (0, import_node_crypto2.createHash)("md5").update(url).digest("hex");
+        const ext2 = import_node_path2.default.extname(localSource).toLowerCase() || ".bin";
+        const filePath2 = import_node_path2.default.join(this.mediaDir, `${hash2}${ext2}`);
+        if (import_node_path2.default.normalize(filePath2) !== import_node_path2.default.normalize(localSource)) {
+          if (!await this.exists(filePath2)) {
+            await import_node_fs.promises.copyFile(localSource, filePath2);
+          }
+        }
+        await this.database.recordMedia(url, filePath2, channelId);
+        this.logger.logInfo("本地媒体已缓存:", filePath2);
+        return filePath2;
       }
-    }
-    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 cached = await this.database.getMediaPath(url);
+      if (cached && await this.exists(cached)) {
+        return this.migrateCachedMedia(url, cached, channelId);
       }
+      const hash = (0, import_node_crypto2.createHash)("md5").update(url).digest("hex");
+      const urlExt = import_node_path2.default.extname(new URL(url).pathname);
+      const fallbackPath = import_node_path2.default.join(this.mediaDir, `${hash}${urlExt || ".bin"}`);
+      if (await this.exists(fallbackPath)) {
+        return this.migrateCachedMedia(url, fallbackPath, channelId);
+      }
+      const response = await fetch(url, {
+        headers: {
+          "User-Agent": "Mozilla/5.0 KoishiChatPatch/1.0"
+        }
+      });
+      if (!response.ok) {
+        return null;
+      }
+      const buffer = Buffer.from(await response.arrayBuffer());
+      const ext = await this.detectExtension(url, buffer);
+      const filename = `${hash}${ext}`;
+      const filePath = import_node_path2.default.join(this.mediaDir, filename);
+      await import_node_fs.promises.writeFile(filePath, buffer);
+      this.logger.logInfo("媒体已缓存:", filename, buffer.length);
+      return filePath;
+    } catch (error) {
+      return null;
     }
-    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}:`));
+  }
+  async detectExtension(url, buffer) {
     try {
-      await import_node_fs3.promises.rm(botDir, { recursive: true, force: true });
+      const detected = await import_file_type.default.fromBuffer(buffer);
+      if (detected?.ext) return toExtension(detected.ext);
     } catch (error) {
-      this.logger.error(`删除机器人目录失败 [${selfId}]:`, error);
+      this.logger.logInfo("媒体类型识别失败，回退 URL 后缀:", url, error);
     }
-    this.scheduleMetadataWrite();
-    return {
-      deletedChannels,
-      deletedMessages
-    };
+    const ext = import_node_path2.default.extname(new URL(url).pathname);
+    return ext && ext !== ".bin" ? ext.toLowerCase() : ".bin";
   }
-  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;
+  async migrateCachedMedia(url, filePath, channelId) {
+    try {
+      const buffer = await import_node_fs.promises.readFile(filePath);
+      const ext = await this.detectExtension(url, buffer);
+      const currentExt = import_node_path2.default.extname(filePath).toLowerCase();
+      if (ext === ".bin" || ext === currentExt) return filePath;
+      const newPath = import_node_path2.default.join(
+        import_node_path2.default.dirname(filePath),
+        `${import_node_path2.default.basename(filePath, import_node_path2.default.extname(filePath))}${ext}`
+      );
+      if (newPath === filePath) return filePath;
+      if (await this.exists(newPath)) {
+        await import_node_fs.promises.unlink(filePath);
+      } else {
+        await import_node_fs.promises.rename(filePath, newPath);
       }
+      await this.database.recordMedia(url, newPath, channelId);
+      return newPath;
+    } catch (error) {
+      this.logger.warn("旧媒体缓存重命名失败:", url, error);
+      return filePath;
     }
-    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;
+  }
+  async cleanup() {
+    try {
+      const allFiles = [];
+      for (const dir of [this.mediaDir, this.uploadDir]) {
+        try {
+          const entries = await import_node_fs.promises.readdir(dir, { withFileTypes: true });
+          for (const entry of entries) {
+            if (!entry.isFile()) continue;
+            const filePath = import_node_path2.default.join(dir, entry.name);
+            try {
+              const stat = await import_node_fs.promises.stat(filePath);
+              allFiles.push({ filePath, mtimeMs: stat.mtimeMs, channelId: "" });
+            } catch {
+            }
+          }
+        } catch {
+        }
       }
-      if (this.peekCachedChannelMessages(entry.channelKey)) {
-        this.setCachedChannelMessages(entry.channelKey, await this.loadChannelMessagesNoCache(entry.selfId, entry.channelId));
+      if (!allFiles.length) return;
+      const metadata = await this.database.getAllMedia();
+      const channelByPath = new Map(metadata.map((item) => [import_node_path2.default.normalize(item.filePath), item.channelId]));
+      const uploadRoot = import_node_path2.default.normalize(this.uploadDir);
+      for (const file of allFiles) {
+        const normalized = import_node_path2.default.normalize(file.filePath);
+        file.channelId = channelByPath.get(normalized) ?? "";
+        if (!file.channelId && normalized.startsWith(uploadRoot)) {
+          file.channelId = "upload";
+        }
+        if (!file.channelId) file.channelId = "unknown";
+      }
+      if (allFiles.length <= this.config.maxMediaFiles) return;
+      const groups = /* @__PURE__ */ new Map();
+      for (const file of allFiles) {
+        const list = groups.get(file.channelId) ?? [];
+        list.push(file);
+        groups.set(file.channelId, list);
+      }
+      for (const list of groups.values()) {
+        list.sort((a, b) => b.mtimeMs - a.mtimeMs);
+      }
+      const keep = /* @__PURE__ */ new Set();
+      const groupList = [...groups.values()];
+      let cursor = 0;
+      for (let count = 0; count < this.config.maxMediaFiles && count < allFiles.length; count++) {
+        let picked = false;
+        for (let offset = 0; offset < groupList.length; offset++) {
+          const group = groupList[(cursor + offset) % groupList.length];
+          const file = group.shift();
+          if (file) {
+            keep.add(file.filePath);
+            cursor = (cursor + offset + 1) % groupList.length;
+            picked = true;
+            break;
+          }
+        }
+        if (!picked) break;
       }
-      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);
+      let removed = 0;
+      for (const file of allFiles) {
+        if (keep.has(file.filePath)) continue;
+        try {
+          await import_node_fs.promises.unlink(file.filePath);
+          removed += 1;
+        } catch {
+        }
+        await this.database.removeMediaByPath(file.filePath).catch(() => void 0);
       }
+      if (removed > 0) {
+        this.logger.logInfo("媒体缓存已清理", removed, "个文件");
+      }
+    } catch {
     }
-    return matched;
   }
-  async dispose() {
-    this.disposed = true;
-    for (const [channelKey, timer] of this.writeTimers.entries()) {
-      timer();
-      await this.flushPendingMessages(channelKey);
+  async exists(filePath) {
+    try {
+      await import_node_fs.promises.access(filePath);
+      return true;
+    } catch {
+      return false;
     }
-    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();
+};
+__name(_MediaManager, "MediaManager");
+var MediaManager = _MediaManager;
+
+// src/self-message.ts
+var import_koishi = require("koishi");
+var import_node_crypto3 = require("node:crypto");
+var KOISHI_STATUS_I18N_FALLBACK = {
+  "commands.status.messages.status.0": "离线",
+  "commands.status.messages.status.1": "运行中",
+  "commands.status.messages.status.2": "连接中",
+  "commands.status.messages.status.3": "异常"
+};
+function getString2(value) {
+  return typeof value === "string" ? value : "";
+}
+__name(getString2, "getString");
+function getNumber(value) {
+  const num = Number(value);
+  return Number.isFinite(num) ? num : 0;
+}
+__name(getNumber, "getNumber");
+function getObject(value) {
+  return typeof value === "object" && value !== null ? value : {};
+}
+__name(getObject, "getObject");
+function toSatoriElement(value) {
+  const raw = getObject(value);
+  const attrs = typeof raw.attrs === "object" && raw.attrs !== null ? raw.attrs : {};
+  const children = Array.isArray(raw.children) ? raw.children.map(toSatoriElement) : [];
+  return {
+    type: raw.type,
+    attrs,
+    children
+  };
+}
+__name(toSatoriElement, "toSatoriElement");
+function isForwardContainer(element) {
+  return element.type === "figure" || element.type === "forward" || element.type === "message" && ("forward" in (element.attrs ?? {}) || element.attrs?.forward === true);
+}
+__name(isForwardContainer, "isForwardContainer");
+function isPrivateChannel(value) {
+  return /^(?:private|direct):/i.test(value);
+}
+__name(isPrivateChannel, "isPrivateChannel");
+function toSegments(elements, resolveI18n) {
+  const result = [];
+  for (const raw of elements) {
+    const element = toSatoriElement(raw);
+    const attrs = element.attrs ?? {};
+    const type = getString2(element.type);
+    if (type === "text") {
+      result.push({ type: "text", text: getString2(attrs.content) });
+    } else if (type === "at") {
+      const id = getString2(attrs.id);
+      const name2 = getString2(attrs.name) || (attrs.type === "all" ? "所有人" : id);
+      result.push({ type: "at", qq: id, text: name2.startsWith("@") ? name2 : `@${name2}` });
+    } else if (type === "img" || type === "image") {
+      const src = getString2(attrs.src) || getString2(attrs.url) || getString2(attrs.file);
+      result.push({ type: "image", file: src, url: src, summary: getString2(attrs.title) });
+    } else if (type === "audio" || type === "record") {
+      const src = getString2(attrs.src) || getString2(attrs.url) || getString2(attrs.file);
+      result.push({ type: "record", file: src, url: src });
+    } else if (type === "video") {
+      const src = getString2(attrs.src) || getString2(attrs.url) || getString2(attrs.file);
+      result.push({ type: "video", file: src, url: src });
+    } else if (type === "file") {
+      const src = getString2(attrs.src) || getString2(attrs.url) || getString2(attrs.file);
+      result.push({ type: "file", file: src, url: src, name: getString2(attrs.name) });
+    } else if (type === "quote") {
+      result.push({ type: "reply", id: getString2(attrs.id) });
+    } else if (type === "json") {
+      result.push({ type: "json", data: getString2(attrs.data) || getString2(attrs.content) });
+    } else if (type === "xml") {
+      result.push({ type: "xml", data: getString2(attrs.data) || getString2(attrs.content) });
+    } else if (type === "markdown") {
+      result.push({ type: "markdown", content: getString2(attrs.content) });
+    } else if (isForwardContainer(element)) {
+      result.push({
+        type: "forward",
+        id: getString2(attrs.id),
+        content: toForwardNodes(element.children ?? [], resolveI18n) ?? []
+      });
+    } else if (type === "p") {
+      result.push(...toSegments(element.children ?? [], resolveI18n));
+      result.push({ type: "text", text: "\n" });
+    } else if (type === "br") {
+      result.push({ type: "text", text: "\n" });
+    } else if (type === "i18n") {
+      const path5 = getString2(attrs.path);
+      const resolved = resolveI18n ? resolveI18n(attrs) : "";
+      result.push({ type: "text", text: resolved || `[${path5 || "i18n"}]` });
+    } else if (element.children?.length) {
+      result.push(...toSegments(element.children, resolveI18n));
+    } else if (type && type !== "author" && type !== "button" && type !== "keyboard") {
+      result.push({ type: "text", text: `[${type}]` });
+    }
+  }
+  return result;
+}
+__name(toSegments, "toSegments");
+function toForwardNodes(elements, resolveI18n) {
+  const nodes = [];
+  const collect = /* @__PURE__ */ __name((list) => {
+    for (const element of list) {
+      if (element.type === "figure" || element.type === "forward") {
+        collect(element.children ?? []);
+        continue;
+      }
+      if (element.type !== "message") continue;
+      if (isForwardContainer(element)) {
+        collect(element.children ?? []);
+        continue;
+      }
+      const children = element.children ?? [];
+      const author = children.find((item) => item.type === "author");
+      const attrs = element.attrs ?? {};
+      const authorAttrs = author?.attrs ?? {};
+      const content = children.filter((item) => item.type !== "author");
+      nodes.push({
+        message_id: getString2(attrs.id),
+        time: getNumber(authorAttrs.time) || getNumber(attrs.time),
+        sender: {
+          user_id: getString2(authorAttrs.id),
+          nickname: getString2(authorAttrs.name),
+          avatar: getString2(authorAttrs.avatar)
+        },
+        message: toSegments(content, resolveI18n)
+      });
     }
-    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);
+  }, "collect");
+  collect(elements.map(toSatoriElement));
+  return nodes.length > 0 ? nodes : void 0;
+}
+__name(toForwardNodes, "toForwardNodes");
+function detectKind(elements) {
+  const stack = [...elements.map(toSatoriElement)];
+  while (stack.length) {
+    const element = stack.pop();
+    if (!element) continue;
+    const type = getString2(element.type);
+    if (isForwardContainer(element)) return "forward";
+    if (type === "img" || type === "image" || type === "mface") return "image";
+    if (type === "audio" || type === "record") return "voice";
+    if (type === "video") return "video";
+    if (type === "file") return "file";
+    stack.push(...element.children ?? []);
+  }
+  return "text";
+}
+__name(detectKind, "detectKind");
+function forwardId(elements) {
+  const stack = [...elements.map(toSatoriElement)];
+  while (stack.length) {
+    const element = stack.pop();
+    if (!element) continue;
+    if (isForwardContainer(element)) {
+      const id = getString2(element.attrs?.id);
+      if (id) return id;
+    }
+    stack.push(...element.children ?? []);
+  }
+  return void 0;
+}
+__name(forwardId, "forwardId");
+var _SelfMessageRecorder = class _SelfMessageRecorder {
+  constructor(ctx, config, database, logger) {
+    this.ctx = ctx;
+    this.config = config;
+    this.database = database;
+    this.logger = logger;
+    this.wrapped = /* @__PURE__ */ new Map();
+    this.sequence = 0;
+  }
+  start() {
+    for (const bot of this.ctx.bots) this.wrapBot(bot);
+    this.ctx.on("bot-added", (bot) => this.wrapBot(bot));
+    this.ctx.on("bot-removed", (bot) => this.unwrapBot(bot));
+    this.ctx.on("send", (session) => {
+      void this.recordSendEvent(session).catch((error) => {
+        this.logger.warn("记录 send 事件失败:", error);
+      });
     });
   }
-  enqueueWrite(task) {
-    if (this.disposed) {
-      return;
+  dispose() {
+    for (const bot of [...this.wrapped.keys()]) {
+      this.unwrapBot(bot);
     }
-    this.writeQueue = this.writeQueue.then(task).catch((error) => {
-      this.logger.error("写入任务失败:", error);
-    });
   }
-  async listStoredChannels() {
-    const result = [];
-    await this.scanStoredChannels(async (entry) => {
-      result.push(entry);
+  isBlocked(platform) {
+    return (this.config.blockedPlatforms ?? []).some((item) => {
+      return item.exactMatch ? platform === item.platformName : platform.includes(item.platformName);
     });
-    return result;
   }
-  async listBotChannels(selfId) {
-    const result = [];
-    await this.scanStoredChannels(async (entry) => {
-      if (entry.selfId === selfId) {
-        result.push(entry);
+  // 包装三个发送入口，覆盖 Satori message.create 和插件直接发送
+  wrapBot(bot) {
+    if (this.wrapped.has(bot)) return;
+    const methods = {
+      createMessage: bot.createMessage,
+      sendMessage: bot.sendMessage,
+      sendPrivateMessage: bot.sendPrivateMessage
+    };
+    this.wrapped.set(bot, methods);
+    bot.createMessage = async (channelId, content, referrer, options) => {
+      const sendOptions = this.prepareOptions(options);
+      if (sendOptions.chatPatchId) {
+        return methods.createMessage.call(bot, channelId, content, referrer, sendOptions);
+      }
+      const localId = (0, import_node_crypto3.randomUUID)();
+      sendOptions.chatPatchId = localId;
+      try {
+        const messages = await methods.createMessage.call(bot, channelId, content, referrer, sendOptions);
+        const ids = Array.isArray(messages) ? messages.map((item) => getString2(getObject(item).id)).filter(Boolean) : [];
+        await this.recordFromWrapper(bot, channelId, content, ids, options, "create", localId);
+        return messages;
+      } finally {
+        delete sendOptions.chatPatchId;
       }
-    }, 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));
-        }
+    };
+    bot.sendMessage = async (channelId, content, referrer, options) => {
+      const sendOptions = this.prepareOptions(options);
+      if (sendOptions.chatPatchId) {
+        return methods.sendMessage.call(bot, channelId, content, referrer, sendOptions);
       }
-    } catch (error) {
-      if (!this.isFileMissingError(error)) {
-        this.logger.error("扫描频道文件失败:", error);
+      const localId = (0, import_node_crypto3.randomUUID)();
+      sendOptions.chatPatchId = localId;
+      try {
+        const ids = await methods.sendMessage.call(bot, channelId, content, referrer, sendOptions);
+        await this.recordFromWrapper(bot, channelId, content, ids, options, "send", localId);
+        return ids;
+      } finally {
+        delete sendOptions.chatPatchId;
       }
-    }
-  }
-  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;
+    bot.sendPrivateMessage = async (userId, content, guildId, options) => {
+      const sendOptions = this.prepareOptions(options);
+      if (sendOptions.chatPatchId) {
+        return methods.sendPrivateMessage.call(bot, userId, content, guildId, sendOptions);
       }
-    } catch (error) {
-      if (!this.isFileMissingError(error)) {
-        this.logger.error(`读取频道索引失败 [${selfId}:${entryName}]:`, error);
+      const localId = (0, import_node_crypto3.randomUUID)();
+      sendOptions.chatPatchId = localId;
+      try {
+        const ids = await methods.sendPrivateMessage.call(bot, userId, content, guildId, sendOptions);
+        await this.recordFromWrapper(bot, userId, content, ids, options, "private", localId);
+        return ids;
+      } finally {
+        delete sendOptions.chatPatchId;
       }
-    }
-    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;
+  unwrapBot(bot) {
+    const methods = this.wrapped.get(bot);
+    if (!methods) return;
+    bot.createMessage = methods.createMessage;
+    bot.sendMessage = methods.sendMessage;
+    bot.sendPrivateMessage = methods.sendPrivateMessage;
+    this.wrapped.delete(bot);
+  }
+  prepareOptions(options) {
+    return options ?? {};
+  }
+  async recordFromWrapper(bot, channelId, content, ids, options, mode, localId) {
+    if (!channelId || this.isBlocked(bot.platform ?? "")) return;
+    const source = options?.session ? "plugin" : "bot";
+    const record = this.buildRecord(
+      bot.platform ?? "",
+      bot.selfId,
+      channelId,
+      options?.session?.guildId,
+      content,
+      ids[0],
+      source,
+      mode,
+      localId
+    );
+    await this.database.upsertSelfMessage(record);
+    this.logger.logInfo("机器人消息已记录:", record.kind, record.channelId, record.messageId || record.id);
+  }
+  // 收到 send 事件时只补消息 id，避免重复记录
+  async recordSendEvent(session) {
+    if (session.type !== "send") return;
+    const platform = session.platform || "";
+    const selfId = session.selfId || "";
+    const event = getObject(session.event);
+    const eventChannel = getObject(event.channel);
+    const eventMessage = getObject(event.message);
+    const channelId = session.channelId || getString2(eventChannel.id);
+    if (this.isBlocked(platform) || !platform || !selfId || !channelId) return;
+    const messageId = session.messageId || getString2(eventMessage.id);
+    if (messageId) {
+      const updated = await this.database.updateSelfMessageByMessageId(
+        platform,
+        selfId,
+        channelId,
+        messageId,
+        { messageId }
+      );
+      if (updated) return;
+    } else {
+      return;
     }
-  }
-  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,
+    const record = this.buildRecord(
+      platform,
+      selfId,
       channelId,
-      totalMessages: 0,
-      nextChunkId: 1,
-      chunks: []
-    };
-  }
-  createChunkFileName(chunkId) {
-    return `chunk-${String(chunkId).padStart(6, "0")}.json`;
+      session.guildId,
+      session.content ?? "",
+      messageId,
+      "bot",
+      "send",
+      (0, import_node_crypto3.randomUUID)()
+    );
+    await this.database.upsertSelfMessage(record);
   }
-  async loadOrCreateChannelIndex(selfId, channelId) {
-    const entry = this.createStoredChannelEntry(selfId, channelId);
+  resolveI18nElement(attrs) {
+    const path5 = getString2(attrs.path);
+    if (!path5 || !this.ctx.i18n) return `[${path5 || "i18n"}]`;
     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 locales = this.ctx.i18n.fallback([]);
+      const text = this.ctx.i18n.render(locales, [path5], attrs || {});
+      if (text && typeof text === "string") return text;
+    } catch {
     }
-    const indexData = this.createEmptyChannelIndex(channelId);
-    await this.ensureDir(entry.channelDirPath);
-    await this.writeChannelIndex(entry.indexFilePath, indexData);
-    this.syncDirtyChannelState(entry.channelKey, indexData.totalMessages);
-    return indexData;
-  }
-  normalizeChannelIndex(channelId, indexData) {
+    const knownFallback = KOISHI_STATUS_I18N_FALLBACK[path5];
+    if (knownFallback) return knownFallback;
+    return `[${path5}]`;
+  }
+  buildRecord(platform, selfId, channelId, guildId, content, messageId, source, mode, localId) {
+    const normalizedChannelId = mode === "private" && !isPrivateChannel(channelId) ? `private:${channelId}` : channelId;
+    const channelType = mode === "private" || isPrivateChannel(normalizedChannelId) ? "user" : "group";
+    const elements = this.normalizeElements(content);
+    const contentText = typeof content === "string" ? content : import_koishi.h.toElementArray(content).join("");
+    const fingerprint = (0, import_node_crypto3.createHash)("sha256").update([
+      platform,
+      selfId,
+      normalizedChannelId,
+      JSON.stringify(elements)
+    ].join("\0")).digest("hex");
     return {
-      version: 1,
-      channelId,
-      totalMessages: indexData.totalMessages || 0,
-      nextChunkId: indexData.nextChunkId || (indexData.chunks?.length || 0) + 1,
-      chunks: Array.isArray(indexData.chunks) ? indexData.chunks : []
+      id: `self-${localId}`,
+      platform,
+      selfId,
+      channelId: normalizedChannelId,
+      guildId,
+      channelType,
+      messageId,
+      content: contentText,
+      elements: JSON.parse(JSON.stringify(elements)),
+      message: toSegments(elements, (attrs) => this.resolveI18nElement(attrs)),
+      forwardId: forwardId(elements),
+      forwardContent: toForwardNodes(elements, (attrs) => this.resolveI18nElement(attrs)),
+      sentAt: Date.now(),
+      sequence: ++this.sequence,
+      source,
+      kind: detectKind(elements),
+      fingerprint
     };
   }
-  async writeChannelIndex(indexFilePath, indexData) {
-    await this.ensureDir(import_node_path3.default.dirname(indexFilePath));
-    await this.atomicWriteTextFile(indexFilePath, JSON.stringify(indexData, null, 2));
-  }
-  async readChunkMessages(channelDirPath, fileName) {
+  normalizeElements(content) {
     try {
-      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) {
-      if (!this.isFileMissingError(error)) {
-        this.logger.error(`读取消息分块失败 [${channelDirPath}/${fileName}]:`, error);
-      }
+      const elements = typeof content === "string" ? import_koishi.h.parse(content) : import_koishi.h.toElementArray(content);
+      return JSON.parse(JSON.stringify(elements));
+    } catch {
       return [];
     }
   }
-  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);
+};
+__name(_SelfMessageRecorder, "SelfMessageRecorder");
+var SelfMessageRecorder = _SelfMessageRecorder;
+
+// src/bootstrap.ts
+function resolveEndpoint(ctx, config) {
+  const url = ctx.satori?.server?.url ?? "/satori";
+  const clean = url.startsWith("undefined") ? url.slice(9) : url;
+  if (/^https?:\/\//i.test(clean)) return clean;
+  const base = ctx.server?.selfUrl ?? ctx.server?.config?.selfUrl ?? "";
+  return `${base}${clean.startsWith("/") ? clean : `/${clean}`}`;
+}
+__name(resolveEndpoint, "resolveEndpoint");
+function registerBootstrap(ctx, config, database, logger) {
+  ctx.console.addListener("chat-patch/bootstrap", () => {
+    logger.logInfo("返回 Satori bootstrap:", {
+      endpoint: resolveEndpoint(ctx, config),
+      basePath: config.basePath
+    });
+    return {
+      endpoint: resolveEndpoint(ctx, config),
+      token: ctx.satori?.server?.config?.token ?? "",
+      basePath: config.basePath
+    };
+  }, { authority: 4 });
+  ctx.console.addListener("chat-patch/history", async (query) => {
+    const messages = await database.listMessages(
+      query.platform,
+      query.selfId,
+      query.channelId,
+      query.limit
+    );
+    return { messages };
+  }, { authority: 4 });
+  ctx.console.addListener("chat-patch/config", () => {
+    return {
+      basePath: config.basePath,
+      maxMessagesPerChannel: config.maxMessagesPerChannel,
+      historyPageSize: config.historyPageSize,
+      maxMediaFiles: config.maxMediaFiles,
+      blockedPlatforms: config.blockedPlatforms ?? [],
+      loggerinfo: config.loggerinfo
+    };
+  }, { authority: 4 });
+  ctx.console.addListener("chat-patch/contact-cache", async (query) => {
+    if (query.contacts) {
+      if (query.append) {
+        for (const contact of query.contacts) {
+          await database.appendContact(query.platform, query.selfId, query.type, contact);
         }
+        return { contacts: await database.getContacts(query.platform, query.selfId, query.type) };
       }
+      await database.setContacts(query.platform, query.selfId, query.type, query.contacts);
+      return { contacts: query.contacts };
     }
-    await this.writeChannelIndex(import_node_path3.default.join(channelDirPath, "index.json"), indexData);
-  }
-  async appendMessagesToChannel(selfId, channelId, messages) {
-    if (!messages.length) {
+    return { contacts: await database.getContacts(query.platform, query.selfId, query.type) };
+  }, { authority: 4 });
+}
+__name(registerBootstrap, "registerBootstrap");
+
+// src/web.ts
+var import_node_fs2 = require("node:fs");
+var import_node_crypto4 = require("node:crypto");
+var import_node_path3 = __toESM(require("node:path"));
+var import_node_url2 = require("node:url");
+var import_koa_send = __toESM(require("koa-send"));
+var import_file_type2 = __toESM(require("file-type"));
+function registerWeb(ctx, config, database, contactCache, logger) {
+  const webRoot = import_node_path3.default.resolve(__dirname, "..", "client", "web", "dist");
+  const webSource = import_node_path3.default.resolve(__dirname, "..", "client", "web", "src");
+  const webPublic = import_node_path3.default.resolve(__dirname, "..", "client", "web", "public");
+  const webIndex = import_node_path3.default.resolve(__dirname, "..", "client", "web", "index.html");
+  const uploadDir = import_node_path3.default.resolve(ctx.baseDir, "data", "chat-patch", "upload-media");
+  const cacheType = /* @__PURE__ */ __name((type) => type === "user" ? "friend" : type, "cacheType");
+  const getVite = /* @__PURE__ */ __name(() => {
+    return ctx.console.vite;
+  }, "getVite");
+  const viteFsUrl = /* @__PURE__ */ __name((target) => {
+    return `/vite/@fs/${import_node_path3.default.resolve(target).split(import_node_path3.default.sep).join("/")}`;
+  }, "viteFsUrl");
+  const transformWebIndex = /* @__PURE__ */ __name(async (vite, requestPath) => {
+    if (vite.config?.server) vite.config.server.preTransformRequests = false;
+    const mainFsUrl = `/@fs/${import_node_path3.default.resolve(webSource, "main.ts").split(import_node_path3.default.sep).join("/")}`;
+    const html = (await import_node_fs2.promises.readFile(webIndex, "utf8")).replace(
+      'src="/src/main.ts"',
+      `src="${mainFsUrl}"`
+    );
+    let transformed = await vite.transformIndexHtml("/chat-patch/web/index.html", html, requestPath);
+    transformed = transformed.replace(/\/vite\/bcui/g, viteFsUrl(import_node_path3.default.join(webPublic, "bcui"))).replace(/\/vite\/css/g, viteFsUrl(import_node_path3.default.join(webPublic, "css")));
+    return transformed;
+  }, "transformWebIndex");
+  const servePublicFile = /* @__PURE__ */ __name(async (koa, prefix) => {
+    const relative = (koa.params?.[0] ?? "").replace(/^\/+/, "");
+    const fullPath = import_node_path3.default.resolve(webPublic, prefix, relative);
+    if (!fullPath.startsWith(webPublic + import_node_path3.default.sep)) {
+      koa.status = 403;
+      koa.body = "";
       return;
     }
-    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);
-  }
-  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;
-  }
-  async countChannelMessages(selfId, channelId) {
-    const entry = this.createStoredChannelEntry(selfId, channelId);
-    try {
-      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) {
-      if (!this.isFileMissingError(error)) {
-        this.logger.error(`读取频道索引失败 [${entry.channelKey}]:`, error);
-      }
+    if ((0, import_node_fs2.existsSync)(fullPath) && (0, import_node_fs2.statSync)(fullPath).isFile()) {
+      await (0, import_koa_send.default)(koa, import_node_path3.default.relative(webPublic, fullPath), { root: webPublic });
+      return;
     }
-    return 0;
-  }
-  async removeChannelStorage(selfId, channelId) {
-    const entry = this.createStoredChannelEntry(selfId, channelId);
-    try {
-      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;
-        }
-      }
-      if (!chunkChanged) {
-        continue;
+    koa.status = 404;
+    koa.body = "";
+  }, "servePublicFile");
+  const registerDevPublic = /* @__PURE__ */ __name((pattern, prefix) => {
+    ctx.server.get(pattern, async (koa, next) => {
+      if (!getVite()) return next();
+      await servePublicFile(koa, prefix);
+    });
+  }, "registerDevPublic");
+  registerDevPublic("/img(.*)", "img");
+  const toExtension2 = /* @__PURE__ */ __name((value) => {
+    const ext = value.startsWith(".") ? value : `.${value}`;
+    return ext.toLowerCase();
+  }, "toExtension");
+  const normalizeGroupId3 = /* @__PURE__ */ __name((value) => {
+    const raw = value.replace(/^(?:group|room|chat|channel|guild):/i, "").trim();
+    const wrapped = raw.match(/^\[_?([\s\S]+?)_?\]$/);
+    return wrapped ? wrapped[1] : raw || value;
+  }, "normalizeGroupId");
+  const historyChannelCandidates = /* @__PURE__ */ __name((channelId) => {
+    const raw = normalizeGroupId3(channelId);
+    const candidates = [channelId];
+    if (raw && raw !== channelId) candidates.push(raw);
+    const id = raw || channelId;
+    if (!/^(?:group|room|chat|channel|guild|private):/i.test(channelId)) {
+      candidates.push(`group:${id}`, `private:${id}`);
+    }
+    if (id) {
+      candidates.push(` [_${id}_] `, `_${id}_`, `[${id}]`, `group:${id}`);
+    }
+    return [...new Set(candidates)];
+  }, "historyChannelCandidates");
+  const mimeToExt = {
+    "audio/mpeg": ".mp3",
+    "audio/mp3": ".mp3",
+    "audio/mp4": ".m4a",
+    "audio/x-m4a": ".m4a",
+    "audio/wav": ".wav",
+    "audio/x-wav": ".wav",
+    "audio/webm": ".webm",
+    "audio/ogg": ".ogg",
+    "audio/aac": ".aac",
+    "audio/flac": ".flac",
+    "image/jpeg": ".jpg",
+    "image/png": ".png",
+    "image/gif": ".gif",
+    "image/webp": ".webp",
+    "video/mp4": ".mp4",
+    "video/webm": ".webm",
+    "video/quicktime": ".mov",
+    "video/x-msvideo": ".avi",
+    "video/x-matroska": ".mkv",
+    "video/x-flv": ".flv",
+    "video/3gpp": ".3gp",
+    "video/ogg": ".ogv",
+    "video/mp2t": ".ts"
+  };
+  const MAX_UPLOAD_BYTES = 500 * 1024 * 1024;
+  ctx.server.post(`${config.basePath}/api/upload-media`, async (koa) => {
+    const requestBody = koa.request.body;
+    const body = requestBody ?? {};
+    let source = String(body.dataUrl ?? body.data ?? "");
+    let name2 = String(body.name ?? "");
+    let mime = "";
+    let buffer = null;
+    if (source) {
+      if (source.startsWith("base64://")) source = source.slice(9);
+      const comma = source.indexOf("base64,");
+      const base64 = comma >= 0 ? source.slice(comma + 7) : source;
+      const normalizedBase64 = base64.replace(/-/g, "+").replace(/_/g, "/");
+      try {
+        buffer = Buffer.from(normalizedBase64, "base64");
+      } catch {
+        koa.status = 400;
+        koa.body = { error: "invalid media data" };
+        return;
       }
-      await this.writeChunkMessages(entry.channelDirPath, chunk.fileName, messages);
-      changed = true;
-    }
-    return changed;
-  }
-  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;
+      mime = source.startsWith("data:") ? source.slice(5, source.indexOf(";")).toLowerCase() : "";
+    } else {
+      const chunks = [];
+      for await (const chunk of koa.req) {
+        chunks.push(Buffer.isBuffer(chunk) ? chunk : Buffer.from(chunk));
       }
-      matched.realId = realId;
-      matched.sending = false;
-      await this.writeChunkMessages(entry.channelDirPath, chunk.fileName, messages);
-      return matched;
-    }
-    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;
+      buffer = Buffer.concat(chunks);
+      name2 = String(koa.query.name ?? koa.get("x-file-name") ?? "");
+      try {
+        name2 = decodeURIComponent(name2);
+      } catch {
       }
+      mime = String(koa.get("content-type") ?? "").split(";")[0].trim().toLowerCase();
     }
-    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;
-  }
-  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);
+    if (!buffer || !buffer.length) {
+      koa.status = 400;
+      koa.body = { error: "missing media data" };
+      return;
     }
-    return deduplicated;
-  }
-  getCachedChannelMessages(channelKey) {
-    const cached = this.channelMessagesCache.get(channelKey);
-    if (!cached) {
-      return void 0;
+    if (buffer.length > MAX_UPLOAD_BYTES) {
+      koa.status = 413;
+      koa.body = { error: "media file too large" };
+      return;
     }
-    this.channelMessagesCache.delete(channelKey);
-    this.channelMessagesCache.set(channelKey, cached);
-    this.memoryCache.messages = this.getChannelMessagesCacheSnapshot();
-    return cached;
-  }
-  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);
+    if (!buffer.length) {
+      koa.status = 400;
+      koa.body = { error: "invalid media data" };
+      return;
     }
-    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;
-      }
-      knownIds.add(message.id);
-      merged.push(message);
+    await import_node_fs2.promises.mkdir(uploadDir, { recursive: true });
+    let detected;
+    try {
+      const result = await import_file_type2.default.fromBuffer(buffer);
+      detected = result ?? void 0;
+    } catch {
+      detected = void 0;
+    }
+    const mimeExt = mimeToExt[mime] || "";
+    const nameExt = import_node_path3.default.extname(name2).toLowerCase();
+    const ext = detected?.ext ? toExtension2(detected.ext) : mimeExt || nameExt || ".bin";
+    const filename = `${(0, import_node_crypto4.createHash)("md5").update(buffer).digest("hex")}${ext}`;
+    const filePath = import_node_path3.default.join(uploadDir, filename);
+    if (!(0, import_node_fs2.existsSync)(filePath)) {
+      await import_node_fs2.promises.writeFile(filePath, buffer);
+    }
+    koa.body = {
+      path: (0, import_node_url2.pathToFileURL)(filePath).href,
+      localPath: filePath
+    };
+  });
+  ctx.server.get(`${config.basePath}/api/media`, async (koa) => {
+    const fileName = import_node_path3.default.basename(String(koa.query.file ?? koa.query.name ?? ""));
+    if (!fileName || fileName === "." || fileName === "..") {
+      koa.status = 400;
+      koa.body = { error: "missing media file" };
+      return;
     }
-    return merged;
-  }
-  limitChannelMessages(messages) {
-    if (messages.length <= this.config.maxMessagesPerChannel) {
-      return messages;
+    const filePath = import_node_path3.default.resolve(uploadDir, fileName);
+    const root = import_node_path3.default.resolve(uploadDir);
+    if (filePath !== root && !filePath.startsWith(`${root}${import_node_path3.default.sep}`)) {
+      koa.status = 400;
+      koa.body = { error: "invalid media file" };
+      return;
     }
-    return [...messages].sort((left, right) => left.timestamp - right.timestamp).slice(-this.config.maxMessagesPerChannel);
-  }
-  async channelMessageExists(selfId, channelId, messageId) {
-    const entry = this.createStoredChannelEntry(selfId, channelId);
-    const channelKey = entry.channelKey;
-    if (this.hasRecentMessageId(channelKey, messageId)) {
-      return true;
+    if (!(0, import_node_fs2.existsSync)(filePath) || !(0, import_node_fs2.statSync)(filePath).isFile()) {
+      koa.status = 404;
+      koa.body = { error: "media file not found" };
+      return;
     }
-    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;
+    const size = (0, import_node_fs2.statSync)(filePath).size;
+    koa.set("Accept-Ranges", "bytes");
+    if (fileName.toLowerCase().endsWith(".webm")) {
+      koa.type = "audio/webm";
+    } else {
+      koa.type = fileName;
+    }
+    const range = koa.headers.range;
+    if (range) {
+      const match = /^bytes=(\d*)-(\d*)$/.exec(String(range));
+      if (!match) {
+        koa.status = 416;
+        koa.set("Content-Range", `bytes */${size}`);
+        koa.body = "";
+        return;
       }
+      let start = 0;
+      let end = size - 1;
+      if (match[1] === "" && match[2]) {
+        start = Math.max(0, size - Number(match[2]));
+      } else if (match[1]) {
+        start = Number(match[1]);
+        end = match[2] ? Number(match[2]) : end;
+      }
+      if (!Number.isFinite(start) || !Number.isFinite(end) || start < 0 || start >= size) {
+        koa.status = 416;
+        koa.set("Content-Range", `bytes */${size}`);
+        koa.body = "";
+        return;
+      }
+      if (end >= size) end = size - 1;
+      if (end < start) end = start;
+      koa.status = 206;
+      koa.set("Content-Range", `bytes ${start}-${end}/${size}`);
+      koa.set("Content-Length", String(end - start + 1));
+      koa.body = (0, import_node_fs2.createReadStream)(filePath, { start, end });
+      return;
     }
-    return false;
-  }
-  syncDirtyChannelState(channelKey, totalMessages) {
-    if (totalMessages > this.config.maxMessagesPerChannel) {
-      this.dirtyChannelKeys.add(channelKey);
+    koa.set("Content-Length", String(size));
+    koa.body = (0, import_node_fs2.createReadStream)(filePath);
+  });
+  ctx.server.get(`${config.basePath}/api/cache/all`, async (koa) => {
+    const entries = await database.getAllContacts();
+    const botMap = /* @__PURE__ */ new Map();
+    for (const entry of entries) {
+      const key = JSON.stringify([entry.platform, entry.selfId]);
+      const bot = botMap.get(key) ?? {
+        platform: entry.platform,
+        selfId: entry.selfId,
+        groups: [],
+        friends: []
+      };
+      if (entry.type === "group") bot.groups = entry.contacts;
+      if (entry.type === "friend") bot.friends = entry.contacts;
+      botMap.set(key, bot);
+    }
+    koa.body = { bots: [...botMap.values()] };
+  });
+  ctx.server.get(`${config.basePath}/api/history`, async (koa) => {
+    const platform = String(koa.query.platform ?? "");
+    const selfId = String(koa.query.selfId ?? "");
+    const channelId = String(koa.query.channelId ?? "");
+    if (!platform || !selfId || !channelId) {
+      koa.status = 400;
+      koa.body = { error: "missing history params" };
       return;
     }
-    this.dirtyChannelKeys.delete(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) {
+    const parsedLimit = Number(koa.query.limit ?? config.maxMessagesPerChannel);
+    const limit = Number.isFinite(parsedLimit) && parsedLimit > 0 ? parsedLimit : config.maxMessagesPerChannel;
+    const beforeTime = Number(koa.query.beforeTime ?? 0);
+    const queryMessages = /* @__PURE__ */ __name(async (cid) => {
+      return Number.isFinite(beforeTime) && beforeTime > 0 ? database.listMessagesBefore(platform, selfId, cid, beforeTime, limit) : database.listMessages(platform, selfId, cid, limit);
+    }, "queryMessages");
+    let messages = [];
+    for (const candidate of historyChannelCandidates(channelId)) {
+      messages = await queryMessages(candidate);
+      if (messages.length) break;
+    }
+    let selfMessages = [];
+    const querySelfMessages = /* @__PURE__ */ __name(async (cid) => {
+      return Number.isFinite(beforeTime) && beforeTime > 0 ? database.listSelfMessagesBefore(platform, selfId, cid, beforeTime, limit) : database.listSelfMessages(platform, selfId, cid, limit);
+    }, "querySelfMessages");
+    for (const candidate of historyChannelCandidates(channelId)) {
+      selfMessages = await querySelfMessages(candidate);
+      if (selfMessages.length) break;
+    }
+    messages.sort((a, b) => {
+      const timeA = Number(a?.receivedAt ?? a?.timestampMs ?? a?.timestamp ?? 0);
+      const timeB = Number(b?.receivedAt ?? b?.timestampMs ?? b?.timestamp ?? 0);
+      return timeA - timeB;
+    });
+    selfMessages.sort((a, b) => a.sentAt - b.sentAt);
+    koa.body = { messages, selfMessages };
+  });
+  ctx.server.get(`${config.basePath}/api/self-messages`, async (koa) => {
+    const platform = String(koa.query.platform ?? "");
+    const selfId = String(koa.query.selfId ?? "");
+    const channelId = String(koa.query.channelId ?? "");
+    if (!platform || !selfId || !channelId) {
+      koa.status = 400;
+      koa.body = { error: "missing self-message params" };
       return;
     }
-    const nextMessageIds = messageIds.filter((id) => id !== messageId);
-    if (nextMessageIds.length) {
-      this.pendingBotMessageIds.set(channelKey, nextMessageIds);
+    const parsedLimit = Number(koa.query.limit ?? config.historyPageSize);
+    const limit = Number.isFinite(parsedLimit) && parsedLimit > 0 ? parsedLimit : config.historyPageSize;
+    const beforeTime = Number(koa.query.beforeTime ?? 0);
+    let messages = [];
+    for (const candidate of historyChannelCandidates(channelId)) {
+      messages = Number.isFinite(beforeTime) && beforeTime > 0 ? await database.listSelfMessagesBefore(platform, selfId, candidate, beforeTime, limit) : await database.listSelfMessages(platform, selfId, candidate, limit);
+      if (messages.length) break;
+    }
+    messages.sort((a, b) => a.sentAt - b.sentAt);
+    koa.body = { messages };
+  });
+  ctx.server.post(`${config.basePath}/api/self-messages`, async (koa) => {
+    const requestBody = koa.request.body;
+    const body = requestBody ?? {};
+    const payload = {
+      id: typeof body.id === "string" ? body.id : void 0,
+      platform: String(body.platform ?? ""),
+      selfId: String(body.selfId ?? ""),
+      channelId: String(body.channelId ?? ""),
+      guildId: typeof body.guildId === "string" ? body.guildId : void 0,
+      channelType: body.channelType === "user" ? "user" : "group",
+      messageId: typeof body.messageId === "string" ? body.messageId : void 0,
+      content: typeof body.content === "string" ? body.content : void 0,
+      elements: Array.isArray(body.elements) ? body.elements : void 0,
+      message: Array.isArray(body.message) ? body.message : void 0,
+      forwardId: typeof body.forwardId === "string" ? body.forwardId : void 0,
+      forwardContent: Array.isArray(body.forwardContent) ? body.forwardContent : void 0,
+      sentAt: typeof body.sentAt === "number" && Number.isFinite(body.sentAt) ? body.sentAt : Date.now(),
+      sequence: typeof body.sequence === "number" && Number.isFinite(body.sequence) ? body.sequence : 0,
+      source: body.source === "plugin" ? "plugin" : "webui",
+      kind: typeof body.kind === "string" ? body.kind : "text"
+    };
+    if (!payload.platform || !payload.selfId || !payload.channelId) {
+      koa.status = 400;
+      koa.body = { error: "missing self-message params" };
       return;
     }
-    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) {
+    const record = {
+      id: payload.id || `web-${Date.now()}-${Math.random().toString(36).slice(2)}`,
+      platform: payload.platform,
+      selfId: payload.selfId,
+      channelId: payload.channelId,
+      guildId: payload.guildId,
+      channelType: payload.channelType,
+      messageId: payload.messageId,
+      content: payload.content,
+      elements: payload.elements,
+      message: payload.message,
+      forwardId: payload.forwardId,
+      forwardContent: payload.forwardContent,
+      sentAt: payload.sentAt ?? Date.now(),
+      sequence: payload.sequence ?? 0,
+      source: payload.source ?? "webui",
+      kind: payload.kind ?? "text"
+    };
+    await database.upsertSelfMessage(record);
+    koa.body = { ok: true, message: record };
+  });
+  ctx.server.get(`${config.basePath}/api/forward`, async (koa) => {
+    const platform = String(koa.query.platform ?? "");
+    const selfId = String(koa.query.selfId ?? "");
+    const channelId = String(koa.query.channelId ?? "");
+    const id = String(koa.query.id ?? "");
+    if (!platform || !selfId || !id) {
+      koa.status = 400;
+      koa.body = { error: "missing forward params" };
       return;
     }
-    const nextMessageIds = [...this.recentMessageIdsCache.get(channelKey) || []];
-    for (const messageId of messageIds) {
-      const existingIndex = nextMessageIds.indexOf(messageId);
-      if (existingIndex !== -1) {
-        nextMessageIds.splice(existingIndex, 1);
+    if (channelId) {
+      const cached = await database.findSelfForwardContent(platform, selfId, channelId, id);
+      if (cached) {
+        koa.body = cached;
+        return;
       }
-      nextMessageIds.push(messageId);
     }
-    const maxSize = this.getRecentMessageIdCacheLimit();
-    this.recentMessageIdsCache.set(channelKey, nextMessageIds.slice(-maxSize));
-  }
-  forgetRecentMessageIds(channelKey, messageIds) {
-    const currentMessageIds = this.recentMessageIdsCache.get(channelKey);
-    if (!currentMessageIds?.length || !messageIds.length) {
+    if (platform !== "onebot") {
+      koa.status = 501;
+      koa.body = { error: "forward api not supported" };
       return;
     }
-    const nextMessageIds = currentMessageIds.filter((messageId) => !messageIds.includes(messageId));
-    if (nextMessageIds.length) {
-      this.recentMessageIdsCache.set(channelKey, nextMessageIds);
+    const bot = ctx.bots.find((item) => {
+      return item.platform === platform && item.selfId === selfId;
+    });
+    if (!bot) {
+      koa.status = 404;
+      koa.body = { error: "bot not found" };
       return;
     }
-    this.recentMessageIdsCache.delete(channelKey);
-  }
-  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) {
+    const internal = bot.internal;
+    if (!internal?.getForwardMsg) {
+      koa.status = 501;
+      koa.body = { error: "forward api not supported" };
       return;
     }
-    const currentLocations = this.messageChunkLocationCache.get(channelKey) || /* @__PURE__ */ new Map();
-    for (const messageId of messageIds) {
-      currentLocations.set(messageId, chunkFileName);
+    try {
+      koa.body = await internal.getForwardMsg(id);
+    } catch (error) {
+      koa.status = 502;
+      koa.body = { error: "forward api failed" };
     }
-    this.messageChunkLocationCache.set(channelKey, currentLocations);
-  }
-  forgetMessageChunkLocation(channelKey, messageIds) {
-    const currentLocations = this.messageChunkLocationCache.get(channelKey);
-    if (!currentLocations || !messageIds.length) {
+  });
+  ctx.server.post(`${config.basePath}/api/send-forward`, async (koa) => {
+    const requestBody = koa.request.body;
+    const body = requestBody ?? {};
+    const platform = String(body.platform ?? "");
+    const selfId = String(body.selfId ?? "");
+    const type = String(body.type ?? "");
+    const id = String(body.id ?? "");
+    if (!platform || !selfId || !type || !id) {
+      koa.status = 400;
+      koa.body = { error: "missing send-forward params" };
       return;
     }
-    for (const messageId of messageIds) {
-      currentLocations.delete(messageId);
+    if (platform !== "onebot") {
+      koa.status = 501;
+      koa.body = { error: "forward api not supported" };
+      return;
     }
-    if (!currentLocations.size) {
-      this.messageChunkLocationCache.delete(channelKey);
+    const bot = ctx.bots.find((item) => {
+      return item.platform === platform && item.selfId === selfId;
+    });
+    if (!bot) {
+      koa.status = 404;
+      koa.body = { error: "bot not found" };
+      return;
     }
-  }
-  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"
-    );
+    const internal = bot.internal;
+    if (type === "group" && !internal?.sendGroupForwardMsg) {
+      koa.status = 501;
+      koa.body = { error: "forward api not supported" };
+      return;
+    }
+    if (type !== "group" && !internal?.sendPrivateForwardMsg) {
+      koa.status = 501;
+      koa.body = { error: "forward api not supported" };
+      return;
+    }
+    const messages = Array.isArray(body.messages) ? body.messages : [];
+    const nodes = messages.map((raw) => {
+      const item = typeof raw === "object" && raw !== null ? raw : {};
+      const nodeData = typeof item.data === "object" && item.data !== null ? item.data : item;
+      const content = Array.isArray(item.content) ? item.content : Array.isArray(nodeData.content) ? nodeData.content : [];
+      const userId = String(item.user_id ?? nodeData.user_id ?? nodeData.uin ?? "");
+      const nickname = String(item.nickname ?? nodeData.nickname ?? nodeData.name ?? "");
+      return {
+        type: "node",
+        data: {
+          user_id: userId,
+          nickname,
+          // koishi 的 OneBot adapter 发送自定义转发节点时使用 uin/name
+          uin: userId,
+          name: nickname,
+          time: String(item.time ?? nodeData.time ?? Math.floor(Date.now() / 1e3)),
+          content: content.map((segmentRaw) => {
+            const segment = typeof segmentRaw === "object" && segmentRaw !== null ? segmentRaw : {};
+            const copy = { ...segment };
+            const segmentType = String(copy.type ?? "text");
+            delete copy.type;
+            return { type: segmentType, data: copy };
+          })
+        }
+      };
+    });
     try {
-      await import_node_fs3.promises.rename(tempFilePath, filePath);
+      koa.body = type === "group" ? await internal?.sendGroupForwardMsg?.(id, nodes) : await internal?.sendPrivateForwardMsg?.(id, nodes);
     } 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;
+      koa.status = 502;
+      koa.body = { error: "send forward failed" };
     }
-  }
-  isAtomicRenameReplaceError(error) {
-    return typeof error === "object" && error !== null && "code" in error && (error.code === "EEXIST" || error.code === "EPERM");
-  }
-};
-__name(_FileManager, "FileManager");
-var FileManager = _FileManager;
-
-// src/api-handlers.ts
-var import_koishi = require("koishi");
-var import_node_url2 = require("node:url");
-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 _ApiHandlers {
-  constructor(ctx, config, fileManager, messageHandler, logger) {
-    this.ctx = ctx;
-    this.config = config;
-    this.fileManager = fileManager;
-    this.messageHandler = messageHandler;
-    this.logger = logger;
-    this.currentTempVideo = null;
-  }
-  registerApiHandlers() {
-    this.ctx.console.addListener("clear-all-indexeddb-data", async () => {
-      try {
-        this.logInfo("收到清空 IndexedDB 数据请求");
-        return { success: true, message: "可以清空 IndexedDB" };
-      } catch (error) {
-        this.logger.error("清空 IndexedDB 数据失败:", error);
-        return { success: false, error: error?.message || String(error) };
-      }
-    });
-    this.ctx.console.addListener("get-chat-data", async () => {
-      try {
-        const data = await this.fileManager.readMetadataOnly();
-        this.logInfo("获取基础聊天数据（仅元数据）");
-        return {
-          success: true,
-          data: {
-            bots: data.bots || {},
-            channels: data.channels || {},
-            pinnedBots: data.pinnedBots || [],
-            pinnedChannels: data.pinnedChannels || [],
-            // 不返回消息数据，由前端按需加载
-            messages: {}
-          }
-        };
-      } catch (error) {
-        this.logger.error("获取聊天数据失败:", error);
-        return { success: false, error: error?.message || String(error) };
-      }
-    });
-    this.ctx.console.addListener("get-history-messages", async (requestData) => {
-      try {
-        const limit = Math.max(1, requestData.limit ?? this.config.messageChunkSize);
-        const result = await this.fileManager.readChannelMessagesPage(
-          requestData.selfId,
-          requestData.channelId,
-          limit,
-          requestData.offset || 0
+  });
+  ctx.server.get(`${config.basePath}/api/cache`, async (koa) => {
+    const platform = String(koa.query.platform ?? "");
+    let selfId = String(koa.query.selfId ?? "");
+    if (!selfId) {
+      selfId = ctx.bots.find((bot) => bot.platform === platform)?.selfId ?? "";
+    }
+    const type = String(koa.query.type ?? "");
+    if (!platform || !selfId || !type) {
+      koa.status = 400;
+      koa.body = { error: "missing cache params" };
+      return;
+    }
+    const id = String(koa.query.userId ?? koa.query.groupId ?? koa.query.id ?? "");
+    if (id) {
+      if (type === "user" || type === "friend") {
+        const channelId = String(koa.query.channelId ?? "");
+        const contact = await contactCache.getUser(
+          platform,
+          selfId,
+          id,
+          String(koa.query.guildId ?? ""),
+          channelId,
+          String(koa.query.name ?? ""),
+          String(koa.query.avatar ?? "")
         );
-        this.logInfo("获取历史消息:", `${requestData.selfId}:${requestData.channelId}`, "共", result.messages.length, "条消息");
-        return {
-          success: true,
-          messages: result.messages,
-          total: result.total
-        };
-      } catch (error) {
-        this.logger.error("获取历史消息失败:", error);
-        return { success: false, error: error?.message || String(error), messages: [], total: 0 };
-      }
-    });
-    this.ctx.console.addListener("get-all-channel-message-counts", async () => {
-      try {
-        const counts = await this.fileManager.getAllChannelMessageCounts();
-        this.logInfo("获取所有频道消息数量:", {
-          频道数: Object.keys(counts).length,
-          总消息数: Object.values(counts).reduce((total, count) => total + count, 0)
-        });
-        return {
-          success: true,
-          counts
-        };
-      } catch (error) {
-        this.logger.error("获取频道消息数量失败:", error);
-        return { success: false, error: error?.message || String(error), counts: {} };
-      }
-    });
-    this.ctx.console.addListener("fetch-image", async (data) => {
-      try {
-        if (data.url.includes("/vite/@fs/")) {
-          return {
-            success: true,
-            viteUrl: data.url
-          };
-        }
-        if (this.isFileUrl(data.url)) {
-          this.logInfo("处理本地文件请求:", data.url);
-          const filePath2 = require("node:url").fileURLToPath(data.url);
-          const normalizedPath2 = filePath2.replace(/\\/g, "/");
-          return {
-            success: true,
-            viteUrl: `/vite/@fs/${normalizedPath2}`
-          };
-        }
-        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 = 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",
-              "Referer": ""
-            }
-          });
-          if (!response.ok) {
-            throw new Error(`HTTP ${response.status}: ${response.statusText}`);
-          }
-          const buffer = await response.arrayBuffer();
-          await import_node_fs4.promises.writeFile(filePath, Buffer.from(buffer));
-        }
-        const normalizedPath = filePath.replace(/\\/g, "/");
-        return {
-          success: true,
-          viteUrl: `/vite/@fs/${normalizedPath}`
-        };
-      } catch (error) {
-        return { success: false, error: this.getClientErrorMessage(error) };
-      }
-    });
-    this.ctx.console.addListener("clear-channel-history", async (data) => {
-      try {
-        this.logInfo("收到清理历史记录请求（已废弃，建议使用删除频道数据）:", data);
-        const channelKey = `${data.selfId}:${data.channelId}`;
-        const { deletedMessages } = await this.fileManager.deleteChannelData(data.selfId, data.channelId);
-        if (!deletedMessages) {
-          return { success: true, message: "频道没有历史消息" };
-        }
-        this.logInfo(`频道 ${channelKey} 历史记录已清空:`, {
-          清理消息数: deletedMessages
-        });
-        return {
-          success: true,
-          message: `成功清理 ${deletedMessages} 条历史消息`,
-          clearedCount: deletedMessages,
-          keptCount: 0
-        };
-      } catch (error) {
-        this.logger.error("清理频道历史记录失败:", error);
-        return { success: false, error: error?.message || String(error) };
-      }
-    });
-    this.ctx.console.addListener("send-message", async (data) => {
-      try {
-        this.logInfo("收到发送消息请求:", data);
-        const bot = this.ctx.bots.find((bot2) => bot2.selfId === data.selfId || bot2.user?.id === data.selfId);
-        if (!bot) {
-          this.logger.error("未找到机器人:", data.selfId, "当前可用机器人:", this.ctx.bots.map((b) => b.selfId));
-          return { success: false, error: `未找到机器人 ${data.selfId}，请检查机器人是否在线` };
-        }
-        if (bot.status !== import_koishi.Universal.Status.ONLINE) {
-          this.logger.error("机器人离线:", data.selfId, "状态:", bot.status);
-          return { success: false, error: `机器人 ${data.selfId} 当前离线` };
-        }
-        let messageContent = data.content;
-        if (data.images && data.images.length > 0) {
-          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 = tempFiles.filter((file) => file.includes(`temp_${image.tempId}`));
-            if (files.length > 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 });
-            }
-          }
-        }
-        const parsedContent = import_koishi.h.parse(messageContent);
-        this.messageHandler.setCorrectChannelId(data.selfId, data.channelId);
-        const result = await bot.sendMessage(data.channelId, parsedContent);
-        this.logInfo("消息发送成功:", result);
-        const messageId = Array.isArray(result) ? result[0] : result;
-        if (messageId) {
-          const channelKey = `${data.selfId}:${data.channelId}`;
-          const msg = await this.fileManager.markLatestBotMessageAsSent(data.selfId, data.channelId, messageId);
-          if (msg) {
-            this.ctx.console.broadcast("bot-message-updated", {
-              channelKey,
-              tempId: msg.id,
-              realId: messageId
-            });
-          }
-        }
-        return {
-          success: !!messageId,
-          messageId,
-          tempImageIds: data.images?.map((img) => img.tempId) || []
-        };
-      } catch (error) {
-        this.logger.error("发送消息失败:", error);
-        return { success: false, error: error?.message || String(error) };
-      }
-    });
-    this.ctx.console.addListener("cleanup-temp-images", async (data) => {
-      try {
-        this.logInfo("收到清理临时图片请求:", data.tempImageIds);
-        this.logInfo("临时图片将由定时任务清理，保持文件可用性");
-        return { success: true, cleanedCount: 0 };
-      } catch (error) {
-        this.logger.error("清理临时图片失败:", error);
-        return { success: false, error: error?.message || String(error) };
-      }
-    });
-    this.ctx.console.addListener("delete-bot-data", async (data) => {
-      try {
-        this.logInfo("收到删除机器人数据请求:", data);
-        const { deletedChannels, deletedMessages } = await this.fileManager.deleteBotData(data.selfId);
-        this.logInfo(`机器人 ${data.selfId} 数据删除完成:`, {
-          删除频道数: deletedChannels,
-          删除消息数: deletedMessages
-        });
-        return {
-          success: true,
-          message: `成功删除机器人数据：${deletedChannels} 个频道，${deletedMessages} 条消息`,
-          deletedChannels,
-          deletedMessages
-        };
-      } catch (error) {
-        this.logger.error("删除机器人数据失败:", error);
-        return { success: false, error: error?.message || String(error) };
-      }
-    });
-    this.ctx.console.addListener("delete-channel-data", async (data) => {
-      try {
-        this.logInfo("收到删除频道数据请求:", data);
-        const channelKey = `${data.selfId}:${data.channelId}`;
-        const { deletedMessages } = await this.fileManager.deleteChannelData(data.selfId, data.channelId);
-        this.logInfo(`频道 ${channelKey} 数据删除完成:`, {
-          删除消息数: deletedMessages
-        });
-        return {
-          success: true,
-          message: `成功删除频道数据：${deletedMessages} 条消息`,
-          deletedMessages
-        };
-      } catch (error) {
-        this.logger.error("删除频道数据失败:", error);
-        return { success: false, error: error?.message || String(error) };
-      }
-    });
-    this.ctx.console.addListener("set-pinned-bots", async (data) => {
-      try {
-        this.logInfo("收到设置置顶机器人请求:", data.pinnedBots);
-        await this.fileManager.setPinnedBots(data.pinnedBots);
-        return { success: true };
-      } catch (error) {
-        this.logger.error("设置置顶机器人失败:", error);
-        return { success: false, error: error?.message || String(error) };
-      }
-    });
-    this.ctx.console.addListener("set-pinned-channels", async (data) => {
-      try {
-        this.logInfo("收到设置置顶频道请求:", data.pinnedChannels);
-        await this.fileManager.setPinnedChannels(data.pinnedChannels);
-        return { success: true };
-      } catch (error) {
-        this.logger.error("设置置顶频道失败:", error);
-        return { success: false, error: error?.message || String(error) };
-      }
-    });
-    this.ctx.console.addListener("upload-image", async (data) => {
-      try {
-        this.logInfo("收到图片上传请求:", { filename: data.filename, mimeType: data.mimeType, isGif: data.isGif });
-        const base64Data = data.file.replace(/^data:image\/\w+;base64,/, "");
-        const buffer = Buffer.from(base64Data, "base64");
-        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 = 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,
-          tempId,
-          tempPath,
-          filename: data.filename,
-          size: buffer.length,
-          isGif: data.isGif
-        };
-      } catch (error) {
-        this.logger.error("图片上传失败:", error);
-        return { success: false, error: error?.message || String(error) };
-      }
-    });
-    this.ctx.console.addListener("delete-temp-image", async (data) => {
-      try {
-        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 = import_node_path4.default.join(tempDir, file);
-          if (await this.fileExists(filePath)) {
-            await import_node_fs4.promises.unlink(filePath);
-            this.logInfo("删除临时图片:", filePath);
-          }
-        }
-        return { success: true };
-      } catch (error) {
-        this.logger.error("删除临时图片失败:", error);
-        return { success: false, error: error?.message || String(error) };
-      }
-    });
-    this.setupTempFileCleanup();
-    this.ctx.console.addListener("get-plugin-config", async () => {
-      try {
-        return {
-          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 || [],
-            clearIndexedDBOnStart: this.config.clearIndexedDBOnStart
-          }
-        };
-      } catch (error) {
-        this.logger.error("获取插件配置失败:", error);
-        return { success: false, error: error?.message || String(error) };
+        koa.body = contact ?? null;
+        return;
       }
-    });
-    this.ctx.console.addListener("get-user-info", async (data) => {
-      try {
-        const bot = this.ctx.bots.find((b) => b.selfId === data.selfId);
-        if (!bot) return { success: false, error: "机器人不存在" };
-        if (!bot.getUser || typeof bot.getUser !== "function") {
-          return { success: false, error: "此平台不支持查看用户信息" };
-        }
-        const user = await bot.getUser(data.userId, data.guildId);
-        if (user) {
-          if (user.avatar) {
-            user.avatar = await this.messageHandler.downloadAndCacheMedia(user.avatar, "avatar");
-          }
-          const changed = await this.fileManager.updateUserProfileInBotData(data.selfId, data.userId, user.name, user.avatar);
-          if (changed) {
-            this.ctx.console.broadcast("chat-data-updated", {});
-          }
-        }
-        return { success: true, data: user };
-      } catch (error) {
-        return { success: false, error: error?.message || "获取用户信息失败" };
+      if (type === "group") {
+        const guildId = String(koa.query.guildId ?? "");
+        const channelId = String(koa.query.channelId ?? "");
+        const channelType = koa.query.channelType;
+        const contact = await contactCache.getGroup(
+          platform,
+          selfId,
+          id,
+          guildId,
+          channelId,
+          String(koa.query.name ?? ""),
+          String(koa.query.avatar ?? ""),
+          channelType
+        );
+        koa.body = contact ?? null;
+        return;
       }
-    });
-    this.ctx.console.addListener("fetch-video-temp", async (data) => {
-      try {
-        this.logInfo("收到视频临时加载请求:", data.url);
-        if (data.url.includes("/vite/@fs/")) {
-          return {
-            success: true,
-            viteUrl: data.url
-          };
-        }
-        if (this.isFileUrl(data.url)) {
-          const filePath2 = require("node:url").fileURLToPath(data.url);
-          const normalizedPath2 = filePath2.replace(/\\/g, "/");
-          return {
-            success: true,
-            viteUrl: `/vite/@fs/${normalizedPath2}`
-          };
+      if (type === "member") {
+        const groupId = String(koa.query.groupId ?? koa.query.id ?? "");
+        if (!groupId) {
+          koa.status = 400;
+          koa.body = { error: "missing groupId" };
+          return;
         }
-        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 = 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",
-              "Referer": ""
-            }
-          });
-          if (!response.ok) {
-            throw new Error(`HTTP ${response.status}: ${response.statusText}`);
-          }
-          const buffer = await response.arrayBuffer();
-          await import_node_fs4.promises.writeFile(filePath, Buffer.from(buffer));
-          this.logInfo("视频下载成功:", { size: buffer.byteLength, path: filePath });
+        const memberId = String(koa.query.userId ?? "");
+        if (memberId) {
+          koa.body = await database.getGroupMember(platform, selfId, groupId, memberId) ?? null;
+          return;
         }
-        const normalizedPath = filePath.replace(/\\/g, "/");
-        return {
-          success: true,
-          viteUrl: `/vite/@fs/${normalizedPath}`
+        koa.body = {
+          members: await database.getGroupMembers(platform, selfId, groupId)
         };
-      } catch (error) {
-        return { success: false, error: this.getClientErrorMessage(error) };
+        return;
       }
-    });
-  }
-  isFileUrl(url) {
-    try {
-      const parsedUrl = new import_node_url2.URL(url);
-      return parsedUrl.protocol === "file:";
-    } catch {
-      return false;
+      koa.status = 400;
+      koa.body = { error: "unsupported cache type" };
+      return;
     }
-  }
-  createFileUrl(filePath) {
-    try {
-      return (0, import_node_url2.pathToFileURL)(filePath).href;
-    } catch (error) {
-      this.logger.error("创建文件URL失败:", { filePath, error });
-      return `file://${filePath}`;
+    koa.body = {
+      contacts: await database.getContacts(platform, selfId, cacheType(type))
+    };
+  });
+  ctx.server.post(`${config.basePath}/api/cache`, async (koa) => {
+    const requestBody = koa.request.body;
+    const body = requestBody ?? {};
+    const platform = String(body.platform ?? "");
+    let selfId = String(body.selfId ?? "");
+    if (!selfId) {
+      selfId = ctx.bots.find((bot) => bot.platform === platform)?.selfId ?? "";
+    }
+    const type = String(body.type ?? "");
+    if (!platform || !selfId || !type) {
+      koa.status = 400;
+      koa.body = { error: "missing cache params" };
+      return;
     }
-  }
-  async handleLocalFileRequest(fileUrl) {
-    try {
-      const filePath = (0, import_node_url2.fileURLToPath)(fileUrl);
-      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 });
-      return {
-        success: true,
-        base64,
-        contentType,
-        dataUrl: `data:${contentType};base64,${base64}`
-      };
-    } catch (error) {
-      return {
-        success: false,
-        error: `读取本地文件失败: ${error.message}`
+    const normalizedType = cacheType(type);
+    if (type === "member" && body.groupId) {
+      const groupId = String(body.groupId);
+      const contacts = Array.isArray(body.contacts) ? body.contacts : [];
+      if (body.append === true) {
+        for (const contact of contacts) {
+          await database.appendGroupMember(platform, selfId, groupId, contact);
+        }
+      } else {
+        await database.setGroupMembers(platform, selfId, groupId, contacts);
+      }
+      koa.body = {
+        members: await database.getGroupMembers(platform, selfId, groupId)
       };
-    }
-  }
-  setupTempFileCleanup() {
-    this.ctx.setInterval(() => {
-      this.cleanupMediaCache();
-    }, 5 * 60 * 1e3);
-  }
-  async cleanupMediaCache() {
-    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) {
-      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;
+    if (Array.isArray(body.contacts)) {
+      const contacts = body.contacts;
+      if (body.append === true) {
+        for (const contact of contacts) {
+          await database.appendContact(platform, selfId, normalizedType, contact);
+        }
+      } else {
+        await database.setContacts(platform, selfId, normalizedType, contacts);
       }
     }
-  }
-  getClientErrorMessage(error) {
-    if (typeof error === "object" && error !== null && "message" in error && typeof error.message === "string") {
-      return error.message;
+    koa.body = {
+      contacts: await database.getContacts(platform, selfId, normalizedType)
+    };
+  });
+  const serveFile = /* @__PURE__ */ __name(async (koa, fileName) => {
+    const fullPath = import_node_path3.default.join(webRoot, fileName);
+    if ((0, import_node_fs2.existsSync)(fullPath) && (0, import_node_fs2.statSync)(fullPath).isFile()) {
+      await (0, import_koa_send.default)(koa, import_node_path3.default.relative(webRoot, fullPath), { root: webRoot });
+      return;
     }
-    return String(error);
-  }
-};
-__name(_ApiHandlers, "ApiHandlers");
-var ApiHandlers = _ApiHandlers;
-
-// 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);
+    koa.status = 200;
+    koa.body = "";
+    await (0, import_koa_send.default)(koa, "index.html", { root: webRoot });
+  }, "serveFile");
+  const serveDevWeb = /* @__PURE__ */ __name(async (koa) => {
+    const vite = getVite();
+    if (!vite) return false;
+    koa.status = 200;
+    koa.type = "html";
+    koa.body = await transformWebIndex(vite, koa.path);
+    return true;
+  }, "serveDevWeb");
+  ctx.server.get(`${config.basePath}/web(/.*)?`, async (koa) => {
+    if (await serveDevWeb(koa)) return;
+    if (!(0, import_node_fs2.existsSync)(webRoot)) {
+      koa.status = 404;
+      koa.body = "";
+      return;
     }
-  };
+    const fileName = koa.params?.[0]?.replace(/^\/+/, "") || "index.html";
+    await serveFile(koa, fileName);
+  });
+  if (!(0, import_node_fs2.existsSync)(webRoot) && process.env.NODE_ENV !== "development") {
+    logger.warn("未找到 client/web/dist，发布前请先执行 client/web 目录下的 npm run build");
+  }
 }
-__name(createPluginLogger, "createPluginLogger");
+__name(registerWeb, "registerWeb");
 
 // 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("平台名称或关键词"),
-      exactMatch: import_koishi2.Schema.boolean().default(false).description("完全匹配？如果关闭，包含关键词即屏蔽").default(true)
-    })).role("table").description("屏蔽的平台列表").default(
-      [
-        {
-          "platformName": "qq",
-          "exactMatch": true
-        },
-        {
-          "platformName": "qqguild",
-          "exactMatch": true
-        },
-        {
-          "platformName": "sandbox",
-          "exactMatch": false
-        }
-      ]
-    )
+    basePath: import_koishi2.Schema.string().default("/chat-patch").description("Web 聊天室挂载路径"),
+    maxMessagesPerChannel: import_koishi2.Schema.number().default(500).min(50).max(5e3).step(1).description("每个频道最多保存的历史消息数"),
+    historyPageSize: import_koishi2.Schema.number().default(50).min(10).max(500).step(1).description("历史消息分页大小"),
+    maxMediaFiles: import_koishi2.Schema.number().default(200).min(20).max(2e3).step(1).description("媒体缓存文件上限")
   }).description("基础设置"),
   import_koishi2.Schema.object({
-    clearIndexedDBOnStart: import_koishi2.Schema.boolean().default(true).description("启动时强制清空IndexedDB缓存（适用于紧急情况，防止浏览器卡死）"),
-    loggerinfo: import_koishi2.Schema.boolean().default(false).description("日志调试模式").experimental()
-  }).description("开发者选项")
+    blockedPlatforms: import_koishi2.Schema.array(import_koishi2.Schema.object({
+      platformName: import_koishi2.Schema.string(),
+      exactMatch: import_koishi2.Schema.boolean().default(true)
+    })).role("table").description("不记录历史的平台").default([
+      { platformName: "qq", exactMatch: true },
+      { platformName: "qqguild", exactMatch: true },
+      { platformName: "sandbox", exactMatch: false }
+    ]),
+    loggerinfo: import_koishi2.Schema.boolean().default(false).description("调试日志开关").hidden().experimental()
+  }).description("高级设置")
 ]);
 
 // src/index.ts
 var name = "chat-patch";
 var reusable = false;
-var filter = true;
+var filter = false;
 var inject = {
-  required: ["console"]
+  required: ["console", "server", "satori.server"]
 };
 var usage = `
-
 ---
 
-开启后，即可在koishi控制台操作机器人收发消息啦
-
-暂时只支持接受图文消息 / 发送文字消息
+基于 Satori 协议的 Koishi 后台聊天室。
+需要在 Koishi 中启用 server-satori，并在插件内构建 web 应用。
 
 ---
 `;
 async function apply(ctx, config) {
   const pluginLogger = createPluginLogger(ctx.logger("chat-patch"), config);
-  const fileManager = new FileManager(ctx, config, pluginLogger);
-  await fileManager.initialize();
-  const messageHandler = new MessageHandler(ctx, config, fileManager, pluginLogger);
-  const apiHandlers = new ApiHandlers(ctx, config, fileManager, messageHandler, pluginLogger);
-  const utils = new Utils(config, ctx);
-  const 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;
-    messageHandler.recordUserMessage(session, Date.now());
-  });
-  ctx.on("before-send", (session) => {
-    if (utils.isPlatformBlocked(session.platform || "unknown")) return;
-    messageHandler.recordBotMessage(session, Date.now());
-  });
-  let cleanupDelayTimer;
-  let cleanupInterval;
-  ctx.on("ready", async () => {
-    pluginLogger.logInfo("插件启动完成，开始监听消息");
-    cleanupDelayTimer = ctx.setTimeout(() => {
-      void fileManager.cleanupExcessMessagesInStorage();
-    }, 15e3);
-    cleanupInterval = ctx.setInterval(() => {
-      void fileManager.cleanupExcessMessagesInStorage();
-    }, 3e5);
-  });
-  apiHandlers.registerApiHandlers();
+  const database = new ChatDatabase(ctx, config, pluginLogger);
+  await database.initialize();
+  const contactCache = new ContactCacheService(ctx, database, pluginLogger);
+  const media = new MediaManager(ctx, config, database, pluginLogger);
+  media.start();
+  const recorder = new Recorder(ctx, config, database, media, contactCache, pluginLogger);
+  recorder.start();
+  const selfMessages = new SelfMessageRecorder(ctx, config, database, pluginLogger);
+  selfMessages.start();
+  registerBootstrap(ctx, config, database, pluginLogger);
+  registerWeb(ctx, config, database, contactCache, pluginLogger);
   ctx.console.addEntry({
-    dev: import_node_path5.default.resolve(__dirname, "../client/index.ts"),
-    prod: import_node_path5.default.resolve(__dirname, "../dist")
+    dev: import_node_path4.default.resolve(__dirname, "../client/index.ts"),
+    prod: import_node_path4.default.resolve(__dirname, "../dist")
   });
   ctx.on("dispose", () => {
-    cleanupDelayTimer?.();
-    cleanupInterval?.();
-    messageHandler.dispose();
-    void fileManager.dispose();
-    pluginLogger.logInfo("插件已卸载，所有待处理的消息已写入");
+    selfMessages.dispose();
+    media.dispose();
+    void database.dispose();
+    pluginLogger.logInfo("chat-patch 已卸载");
   });
 }
 __name(apply, "apply");