koishi-plugin-chat-patch 0.8.2 → 1.0.6

package/lib/index.js

@@ -1,480 +1,247 @@
+var __create = Object.create;
 var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
 var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
-
-// src/index.ts
-import { Schema } from "koishi";
-import path from "node:path";
-import fs from "node:fs";
-var name = "chat-patch";
-var reusable = false;
-var filter = false;
-var inject = {
-  required: ["console"]
+var __export = (target, all) => {
+  for (var name2 in all)
+    __defProp(target, name2, { get: all[name2], enumerable: true });
 };
-var usage = `
----
-
-开启后，即可在koishi控制台操作机器人收发消息啦
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
 
-暂时只支持接受图文消息 / 发送文字消息
+// src/index.ts
+var src_exports = {};
+__export(src_exports, {
+  Config: () => Config,
+  apply: () => apply,
+  filter: () => filter,
+  inject: () => inject,
+  name: () => name,
+  reusable: () => reusable,
+  usage: () => usage
+});
+module.exports = __toCommonJS(src_exports);
+var import_node_path2 = __toESM(require("node:path"));
 
----
-`;
-var Config = Schema.intersect([
-  Schema.object({
-    maxMessagesPerChannel: Schema.number().default(500).description("每个群组最大保存消息数量").min(50).max(5e3),
-    keepMessagesOnClear: Schema.number().default(0).description("手动清理历史记录时保留的消息数量").min(0).max(1e3),
-    blockedPlatforms: Schema.array(Schema.object({
-      platformName: Schema.string().description("平台名称或关键词"),
-      exactMatch: Schema.boolean().default(false).description("完全匹配？如果关闭，包含关键词即屏蔽").default(true)
-    })).role("table").description("屏蔽的平台列表").default([
-      {
-        "platformName": "qq",
-        "exactMatch": true
-      },
-      {
-        "platformName": "qqguild",
-        "exactMatch": true
-      },
-      {
-        "platformName": "sandbox",
-        "exactMatch": false
-      }
-    ])
-  }).description("基础设置"),
-  Schema.object({
-    chatContainerHeight: Schema.number().default(80).description("手机端使用的视口高度（防止文本输入框被挡住）").min(50).max(100),
-    loggerinfo: Schema.boolean().default(false).description("日志调试模式").experimental()
-  }).description("进阶设置")
-]);
-async function apply(ctx, config) {
-  const logger = ctx.logger("chat-patch");
-  const dataFilePath = path.resolve(ctx.baseDir, "data", "chat-patch", "chat-data.json");
-  const initialData = readChatDataFromFile();
-  const cleanedData = cleanExcessMessages(initialData);
-  const originalCount = Object.values(initialData.messages).reduce((total, msgs) => total + msgs.length, 0);
-  const cleanedCount = Object.values(cleanedData.messages).reduce((total, msgs) => total + msgs.length, 0);
-  if (originalCount !== cleanedCount) {
-    writeChatDataToFile(cleanedData);
-  }
-  logInfo("插件加载完成，数据统计:", {
-    机器人数量: Object.keys(cleanedData.bots).length,
-    频道数量: Object.keys(cleanedData.channels).reduce((total, botId) => total + Object.keys(cleanedData.channels[botId] || {}).length, 0),
-    消息频道数: Object.keys(cleanedData.messages).length,
-    总消息数: Object.values(cleanedData.messages).reduce((total, msgs) => total + msgs.length, 0)
-  });
-  ctx.on("message", async (session) => {
-    if (isPlatformBlocked(session.platform || "unknown")) {
-      logInfo(`忽略来自被屏蔽平台的消息: ${session.platform}`);
-      return;
-    }
-    await broadcastMessageEvent(session);
-  });
-  ctx.on("ready", async () => {
-    logInfo("插件启动完成，开始监听消息");
-    setInterval(() => {
-      const data = readChatDataFromFile();
-      const cleanedData2 = cleanExcessMessages(data);
-      const originalCount2 = Object.values(data.messages).reduce((total, msgs) => total + msgs.length, 0);
-      const cleanedCount2 = Object.values(cleanedData2.messages).reduce((total, msgs) => total + msgs.length, 0);
-      if (originalCount2 !== cleanedCount2) {
-        writeChatDataToFile(cleanedData2);
-        logInfo("定期清理完成，清理了", originalCount2 - cleanedCount2, "条超量消息");
-      }
-    }, 3e5);
-  });
-  ctx.console.addListener("get-chat-data", async () => {
-    try {
-      const data = readChatDataFromFile();
-      const cleanedData2 = cleanExcessMessages(data);
-      logInfo("获取聊天数据:", {
-        机器人数量: Object.keys(cleanedData2.bots).length,
-        频道数量: Object.keys(cleanedData2.channels).reduce((total, botId) => total + Object.keys(cleanedData2.channels[botId] || {}).length, 0),
-        消息频道数: Object.keys(cleanedData2.messages).length,
-        总消息数: Object.values(cleanedData2.messages).reduce((total, msgs) => total + msgs.length, 0)
-      });
-      return {
-        success: true,
-        data: {
-          ...cleanedData2,
-          pinnedBots: cleanedData2.pinnedBots,
-          // 包含置顶机器人
-          pinnedChannels: cleanedData2.pinnedChannels
-          // 包含置顶频道
-        }
-      };
-    } catch (error) {
-      logger.error("获取聊天数据失败:", error);
-      return { success: false, error: error?.message || String(error) };
-    }
-  });
-  ctx.console.addListener("get-history-messages", async (requestData) => {
-    try {
-      const data = readChatDataFromFile();
-      const channelKey = `${requestData.selfId}-${requestData.channelId}`;
-      const messages = data.messages[channelKey] || [];
-      const sortedMessages = messages.sort((a, b) => a.timestamp - b.timestamp);
-      logInfo("获取历史消息:", channelKey, "共", sortedMessages.length, "条消息");
-      return {
-        success: true,
-        messages: sortedMessages
-      };
-    } catch (error) {
-      logger.error("获取历史消息失败:", error);
-      return { success: false, error: error?.message || String(error), messages: [] };
-    }
-  });
-  ctx.console.addListener("get-all-channel-message-counts", async () => {
-    try {
-      const data = readChatDataFromFile();
-      const counts = {};
-      for (const [channelKey, messages] of Object.entries(data.messages)) {
-        counts[channelKey] = messages.length;
-      }
-      logInfo("获取所有频道消息数量:", {
-        频道数: Object.keys(counts).length,
-        总消息数: Object.values(counts).reduce((total, count) => total + count, 0)
-      });
-      return {
-        success: true,
-        counts
-      };
-    } catch (error) {
-      logger.error("获取频道消息数量失败:", error);
-      return { success: false, error: error?.message || String(error), counts: {} };
-    }
-  });
-  ctx.console.addListener("fetch-image", async (data) => {
-    try {
-      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();
-      const base64 = Buffer.from(buffer).toString("base64");
-      const contentType = response.headers.get("content-type") || "image/jpeg";
-      return {
-        success: true,
-        base64,
-        contentType,
-        dataUrl: `data:${contentType};base64,${base64}`
-      };
-    } catch (error) {
-      return { success: false, error: error?.message || String(error) };
-    }
-  });
-  ctx.console.addListener("clear-channel-history", async (data) => {
-    try {
-      logInfo("收到清理历史记录请求:", data);
-      const chatData = readChatDataFromFile();
-      const channelKey = `${data.selfId}-${data.channelId}`;
-      if (!chatData.messages[channelKey]) {
-        return { success: true, message: "频道没有历史消息" };
-      }
-      const messages = chatData.messages[channelKey];
-      const originalCount2 = messages.length;
-      const keepCount = data.keepCount || config.keepMessagesOnClear;
-      if (keepCount > 0 && originalCount2 <= keepCount) {
-        return { success: true, message: `消息数量(${originalCount2})未超过保留数量(${keepCount})，无需清理` };
-      }
-      const sortedMessages = [...messages].sort((a, b) => a.timestamp - b.timestamp);
-      const keptMessages = keepCount > 0 ? sortedMessages.slice(-keepCount) : [];
-      const clearedCount = originalCount2 - keptMessages.length;
-      chatData.messages[channelKey] = keptMessages;
-      writeChatDataToFile(chatData);
-      logInfo(`频道 ${channelKey} 历史记录清理完成:`, {
-        原始消息数: originalCount2,
-        保留消息数: keptMessages.length,
-        清理消息数: clearedCount
-      });
-      return {
-        success: true,
-        message: `成功清理 ${clearedCount} 条历史消息，保留最新 ${keptMessages.length} 条`,
-        clearedCount,
-        keptCount: keptMessages.length
-      };
-    } catch (error) {
-      logger.error("清理频道历史记录失败:", error);
-      return { success: false, error: error?.message || String(error) };
-    }
-  });
-  ctx.console.addListener("send-message", async (data) => {
-    try {
-      logInfo("收到发送消息请求:", data);
-      const bot = ctx.bots.find((bot2) => bot2.selfId === data.selfId);
-      if (!bot) {
-        logger.error("未找到机器人:", data.selfId);
-        return { success: false, error: "未找到指定的机器人" };
-      }
-      const result = await bot.sendMessage(data.channelId, data.content);
-      logInfo("消息发送成功:", result);
-      const timestamp = Date.now();
-      const chatData = readChatDataFromFile();
-      const botInfo = {
-        selfId: bot.selfId,
-        platform: bot.platform || "unknown",
-        username: bot.user?.name || `Bot-${data.selfId}`,
-        avatar: bot.user?.avatar,
-        status: "online"
-      };
-      chatData.bots[bot.selfId] = botInfo;
-      writeChatDataToFile(chatData);
-      const botMessageInfo = {
-        id: Array.isArray(result) ? result[0] : result || `bot-msg-${timestamp}`,
-        content: data.content,
-        userId: bot.selfId,
-        username: bot.user?.name || `Bot-${data.selfId}`,
-        avatar: bot.user?.avatar,
-        timestamp,
-        channelId: data.channelId,
-        selfId: data.selfId,
-        type: "bot",
-        platform: bot.platform || "unknown"
-      };
-      addMessageToFile(botMessageInfo);
-      const sentMessageEvent = {
-        type: "bot-message-sent",
-        selfId: data.selfId,
-        channelId: data.channelId,
-        messageId: Array.isArray(result) ? result[0] : result,
-        content: data.content,
-        timestamp,
-        botUsername: bot.user?.name || `Bot-${data.selfId}`,
-        botAvatar: bot.user?.avatar
-      };
-      ctx.console.broadcast("bot-message-sent-event", sentMessageEvent);
-      return { success: true, messageId: Array.isArray(result) ? result[0] : result };
-    } catch (error) {
-      logger.error("发送消息失败:", error);
-      return { success: false, error: error?.message || String(error) };
-    }
-  });
-  ctx.console.addListener("delete-bot-data", async (data) => {
-    try {
-      logInfo("收到删除机器人数据请求:", data);
-      const chatData = readChatDataFromFile();
-      let deletedChannels = 0;
-      let deletedMessages = 0;
-      if (chatData.channels[data.selfId]) {
-        deletedChannels = Object.keys(chatData.channels[data.selfId]).length;
-        delete chatData.channels[data.selfId];
-      }
-      const channelsToDelete = Object.keys(chatData.messages).filter((key) => key.startsWith(`${data.selfId}-`));
-      for (const channelKey of channelsToDelete) {
-        deletedMessages += chatData.messages[channelKey].length;
-        delete chatData.messages[channelKey];
-      }
-      delete chatData.bots[data.selfId];
-      writeChatDataToFile(chatData);
-      logInfo(`机器人 ${data.selfId} 数据删除完成:`, {
-        删除频道数: deletedChannels,
-        删除消息数: deletedMessages
-      });
-      return {
-        success: true,
-        message: `成功删除机器人数据：${deletedChannels} 个频道，${deletedMessages} 条消息`,
-        deletedChannels,
-        deletedMessages
-      };
-    } catch (error) {
-      logger.error("删除机器人数据失败:", error);
-      return { success: false, error: error?.message || String(error) };
-    }
-  });
-  ctx.console.addListener("delete-channel-data", async (data) => {
-    try {
-      logInfo("收到删除频道数据请求:", data);
-      const chatData = readChatDataFromFile();
-      const channelKey = `${data.selfId}-${data.channelId}`;
-      let deletedMessages = 0;
-      if (chatData.messages[channelKey]) {
-        deletedMessages = chatData.messages[channelKey].length;
-        delete chatData.messages[channelKey];
-      }
-      if (chatData.channels[data.selfId] && chatData.channels[data.selfId][data.channelId]) {
-        delete chatData.channels[data.selfId][data.channelId];
-      }
-      writeChatDataToFile(chatData);
-      logInfo(`频道 ${channelKey} 数据删除完成:`, {
-        删除消息数: deletedMessages
-      });
-      return {
-        success: true,
-        message: `成功删除频道数据：${deletedMessages} 条消息`,
-        deletedMessages
-      };
-    } catch (error) {
-      logger.error("删除频道数据失败:", error);
-      return { success: false, error: error?.message || String(error) };
-    }
-  });
-  ctx.console.addListener("set-pinned-bots", async (data) => {
-    try {
-      logInfo("收到设置置顶机器人请求:", data.pinnedBots);
-      const chatData = readChatDataFromFile();
-      chatData.pinnedBots = data.pinnedBots;
-      writeChatDataToFile(chatData);
-      return { success: true };
-    } catch (error) {
-      logger.error("设置置顶机器人失败:", error);
-      return { success: false, error: error?.message || String(error) };
-    }
-  });
-  ctx.console.addListener("set-pinned-channels", async (data) => {
-    try {
-      logInfo("收到设置置顶频道请求:", data.pinnedChannels);
-      const chatData = readChatDataFromFile();
-      chatData.pinnedChannels = data.pinnedChannels;
-      writeChatDataToFile(chatData);
-      return { success: true };
-    } catch (error) {
-      logger.error("设置置顶频道失败:", error);
-      return { success: false, error: error?.message || String(error) };
-    }
-  });
-  ctx.console.addListener("get-plugin-config", async () => {
-    try {
-      return {
-        success: true,
-        config: {
-          maxMessagesPerChannel: config.maxMessagesPerChannel,
-          keepMessagesOnClear: config.keepMessagesOnClear,
-          loggerinfo: config.loggerinfo,
-          blockedPlatforms: config.blockedPlatforms || [],
-          chatContainerHeight: config.chatContainerHeight
-        }
-      };
-    } catch (error) {
-      logger.error("获取插件配置失败:", error);
-      return { success: false, error: error?.message || String(error) };
-    }
-  });
-  ctx.console.addEntry({
-    dev: path.resolve(__dirname, "../client/index.ts"),
-    prod: path.resolve(__dirname, "../dist")
-  });
-  function logInfo(...args) {
-    if (config.loggerinfo) {
-      logger.info(...args);
-    }
+// src/file-manager.ts
+var import_node_path = __toESM(require("node:path"));
+var import_node_fs = __toESM(require("node:fs"));
+var FileManager = class {
+  constructor(ctx, config) {
+    this.ctx = ctx;
+    this.config = config;
+    this.dataFilePath = import_node_path.default.resolve(ctx.baseDir, "data", "chat-patch", "chat-data.json");
+    this.logger = ctx.logger("chat-patch");
   }
-  __name(logInfo, "logInfo");
-  function isPlatformBlocked(platform) {
-    if (!config.blockedPlatforms || config.blockedPlatforms.length === 0) {
-      return false;
-    }
-    for (const blockedPlatform of config.blockedPlatforms) {
-      if (blockedPlatform.exactMatch) {
-        if (platform === blockedPlatform.platformName) {
-          logInfo(`平台 ${platform} 被屏蔽 (完全匹配: ${blockedPlatform.platformName})`);
-          return true;
-        }
-      } else {
-        if (platform.includes(blockedPlatform.platformName)) {
-          logInfo(`平台 ${platform} 被屏蔽 (包含匹配: ${blockedPlatform.platformName})`);
-          return true;
-        }
-      }
-    }
-    return false;
+  static {
+    __name(this, "FileManager");
   }
-  __name(isPlatformBlocked, "isPlatformBlocked");
-  function ensureDataDir() {
-    const dir = path.dirname(dataFilePath);
-    if (!fs.existsSync(dir)) {
-      fs.mkdirSync(dir, { recursive: true });
+  dataFilePath;
+  fileOperationLock = Promise.resolve();
+  logger;
+  // 确保目录存在
+  ensureDataDir() {
+    const dir = import_node_path.default.dirname(this.dataFilePath);
+    if (!import_node_fs.default.existsSync(dir)) {
+      import_node_fs.default.mkdirSync(dir, { recursive: true });
     }
   }
-  __name(ensureDataDir, "ensureDataDir");
-  function readChatDataFromFile() {
+  // 从JSON文件读取数据
+  readChatDataFromFile() {
     try {
-      if (fs.existsSync(dataFilePath)) {
-        const jsonData = fs.readFileSync(dataFilePath, "utf8");
+      if (import_node_fs.default.existsSync(this.dataFilePath)) {
+        const jsonData = import_node_fs.default.readFileSync(this.dataFilePath, "utf8");
         const data = JSON.parse(jsonData);
         return {
           bots: data.bots || {},
           channels: data.channels || {},
           messages: data.messages || {},
           pinnedBots: data.pinnedBots || [],
-          // 读取置顶机器人
           pinnedChannels: data.pinnedChannels || [],
-          // 读取置顶频道
           lastSaveTime: data.lastSaveTime
         };
       }
     } catch (error) {
-      logger.error("读取聊天数据失败:", error);
+      this.logger.error("读取聊天数据失败:", error);
     }
     return {
       bots: {},
       channels: {},
       messages: {},
       pinnedBots: [],
-      // 默认空数组
       pinnedChannels: []
-      // 默认空数组
     };
   }
-  __name(readChatDataFromFile, "readChatDataFromFile");
-  function writeChatDataToFile(data) {
+  // 写入数据到JSON文件
+  writeChatDataToFile(data) {
     try {
-      ensureDataDir();
+      this.ensureDataDir();
       data.lastSaveTime = Date.now();
       const jsonData = JSON.stringify(data, null, 2);
-      fs.writeFileSync(dataFilePath, jsonData, "utf8");
+      import_node_fs.default.writeFileSync(this.dataFilePath, jsonData, "utf8");
     } catch (error) {
-      logger.error("写入聊天数据失败:", error);
+      this.logger.error("写入聊天数据失败:", error);
     }
   }
-  __name(writeChatDataToFile, "writeChatDataToFile");
-  function cleanExcessMessages(data) {
-    let cleanedCount2 = 0;
+  // 清理超量消息
+  cleanExcessMessages(data) {
+    let cleanedCount = 0;
     const cleanedMessages = {};
     for (const [channelKey, messages] of Object.entries(data.messages)) {
-      if (messages.length > config.maxMessagesPerChannel) {
+      if (messages.length > this.config.maxMessagesPerChannel) {
         const sortedMessages = [...messages].sort((a, b) => a.timestamp - b.timestamp);
-        const keptMessages = sortedMessages.slice(-config.maxMessagesPerChannel);
-        cleanedCount2 += messages.length - keptMessages.length;
+        const keptMessages = sortedMessages.slice(-this.config.maxMessagesPerChannel);
+        cleanedCount += messages.length - keptMessages.length;
         cleanedMessages[channelKey] = keptMessages;
-        logInfo(`频道 ${channelKey} 清理了 ${messages.length - keptMessages.length} 条旧消息，保留最新 ${keptMessages.length} 条`);
+        this.logInfo(`频道 ${channelKey} 清理了 ${messages.length - keptMessages.length} 条旧消息，保留最新 ${keptMessages.length} 条`);
       } else {
         cleanedMessages[channelKey] = messages;
       }
     }
-    if (cleanedCount2 > 0) {
-      logInfo("总共清理超量消息:", cleanedCount2, "条");
+    if (cleanedCount > 0) {
+      this.logInfo("总共清理超量消息:", cleanedCount, "条");
     }
     return {
       ...data,
       messages: cleanedMessages
     };
   }
-  __name(cleanExcessMessages, "cleanExcessMessages");
-  function addMessageToFile(messageInfo) {
-    const data = readChatDataFromFile();
-    const channelKey = `${messageInfo.selfId}-${messageInfo.channelId}`;
-    if (!data.messages[channelKey]) {
-      data.messages[channelKey] = [];
+  // 添加消息到JSON文件（使用锁机制防止并发冲突）
+  async addMessageToFile(messageInfo) {
+    this.fileOperationLock = this.fileOperationLock.then(async () => {
+      const data = this.readChatDataFromFile();
+      const channelKey = `${messageInfo.selfId}:${messageInfo.channelId}`;
+      if (!data.messages[channelKey]) {
+        data.messages[channelKey] = [];
+      }
+      const existingMessage = data.messages[channelKey].find((m) => m.id === messageInfo.id);
+      if (existingMessage) {
+        this.logInfo("消息已存在，跳过保存:", {
+          channelKey,
+          messageId: messageInfo.id,
+          existingType: existingMessage.type,
+          existingContent: existingMessage.content,
+          newType: messageInfo.type,
+          newContent: messageInfo.content
+        });
+        return;
+      }
+      if (!messageInfo.timestamp) {
+        messageInfo.timestamp = Date.now();
+      }
+      const beforeCount = data.messages[channelKey].length;
+      data.messages[channelKey].push(messageInfo);
+      const afterCount = data.messages[channelKey].length;
+      if (data.messages[channelKey].length > this.config.maxMessagesPerChannel) {
+        data.messages[channelKey].sort((a, b) => a.timestamp - b.timestamp);
+        const removedCount = data.messages[channelKey].length - this.config.maxMessagesPerChannel;
+        data.messages[channelKey] = data.messages[channelKey].slice(-this.config.maxMessagesPerChannel);
+        this.logInfo(`频道 ${channelKey} 达到消息上限，清理了 ${removedCount} 条旧消息`);
+      }
+      this.writeChatDataToFile(data);
+      const isCommandMessage = messageInfo.content?.startsWith("++") || messageInfo.content?.startsWith(".");
+      this.logInfo("添加消息到文件:", {
+        channelKey,
+        messageId: messageInfo.id,
+        content: messageInfo.content,
+        type: messageInfo.type,
+        userId: messageInfo.userId,
+        username: messageInfo.username,
+        timestamp: messageInfo.timestamp,
+        isCommandMessage,
+        消息数变化: `${beforeCount} -> ${afterCount} -> ${data.messages[channelKey].length}`
+      });
+    }).catch((error) => {
+      this.logger.error("保存消息时发生错误:", error);
+    });
+    await this.fileOperationLock;
+  }
+  logInfo(...args) {
+    if (this.config.loggerinfo) {
+      this.logger.info(...args);
     }
-    messageInfo.timestamp = Date.now();
-    data.messages[channelKey].push(messageInfo);
-    if (data.messages[channelKey].length > config.maxMessagesPerChannel) {
-      data.messages[channelKey].sort((a, b) => a.timestamp - b.timestamp);
-      const removedCount = data.messages[channelKey].length - config.maxMessagesPerChannel;
-      data.messages[channelKey] = data.messages[channelKey].slice(-config.maxMessagesPerChannel);
-      logInfo(`频道 ${channelKey} 达到消息上限，清理了 ${removedCount} 条旧消息`);
+  }
+};
+
+// src/utils.ts
+var Utils = class {
+  constructor(config) {
+    this.config = config;
+  }
+  static {
+    __name(this, "Utils");
+  }
+  // 检查平台是否被屏蔽
+  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;
+        }
+      }
     }
-    writeChatDataToFile(data);
-    logInfo("添加消息到文件:", channelKey, "当前消息数:", data.messages[channelKey].length);
+    return false;
   }
-  __name(addMessageToFile, "addMessageToFile");
-  function updateBotInfoToFile(session) {
-    const data = readChatDataFromFile();
+  // 递归提取所有文本内容的函数
+  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);
+      }
+    }
+    return text;
+  }
+};
+
+// src/message-handler.ts
+var MessageHandler = class {
+  constructor(ctx, config, fileManager) {
+    this.ctx = ctx;
+    this.config = config;
+    this.fileManager = fileManager;
+    this.logger = ctx.logger("chat-patch");
+    this.utils = new Utils(config);
+  }
+  static {
+    __name(this, "MessageHandler");
+  }
+  logger;
+  utils;
+  // 更新机器人信息到JSON文件
+  async updateBotInfoToFile(session) {
+    const data = this.fileManager.readChatDataFromFile();
     const botInfo = {
       selfId: session.selfId,
       platform: session.platform || "unknown",
@@ -483,20 +250,20 @@ async function apply(ctx, config) {
       status: "online"
     };
     data.bots[session.selfId] = botInfo;
-    writeChatDataToFile(data);
-    logInfo("更新机器人信息到文件:", botInfo.username);
+    this.fileManager.writeChatDataToFile(data);
+    this.logInfo("更新机器人信息到文件:", botInfo.username);
   }
-  __name(updateBotInfoToFile, "updateBotInfoToFile");
-  async function updateChannelInfoToFile(session) {
-    const data = readChatDataFromFile();
+  // 更新频道信息到JSON文件
+  async updateChannelInfoToFile(session) {
     let guildName = session.channelId;
+    const data = this.fileManager.readChatDataFromFile();
     try {
       if (session.guildId && session.bot.getGuild && typeof session.bot.getGuild === "function") {
         const guild = await session.bot.getGuild(session.guildId);
         guildName = guild?.name || session.channelId;
       }
     } catch (guildError) {
-      logInfo("获取群组信息失败，使用频道ID作为备用:", guildError);
+      this.logInfo("获取群组信息失败，使用频道ID作为备用:", guildError);
       guildName = session.channelId;
     }
     if (!data.channels[session.selfId]) {
@@ -510,15 +277,14 @@ async function apply(ctx, config) {
       guildName
     };
     data.channels[session.selfId][session.channelId] = channelInfo;
-    writeChatDataToFile(data);
-    logInfo("更新频道信息到文件:", channelInfo.name);
+    this.fileManager.writeChatDataToFile(data);
+    this.logInfo("更新频道信息到文件:", channelInfo.name);
     return guildName;
   }
-  __name(updateChannelInfoToFile, "updateChannelInfoToFile");
-  async function broadcastMessageEvent(session) {
+  async broadcastMessageEvent(session) {
     try {
-      updateBotInfoToFile(session);
-      const guildName = await updateChannelInfoToFile(session);
+      await this.updateBotInfoToFile(session);
+      const guildName = await this.updateChannelInfoToFile(session);
       const timestamp = Date.now();
       let quoteInfo = void 0;
       if (session.quote) {
@@ -537,53 +303,690 @@ async function apply(ctx, config) {
           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.messageId || `msg-${timestamp}`,
-        content: session.content || "",
-        userId: session.userId || "unknown",
-        username: session.username || session.userId || "unknown",
-        avatar: session.author?.avatar,
+        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: session.elements,
+        elements,
         type: "user",
         guildId: session.guildId,
         guildName,
         platform: session.platform || "unknown",
         quote: quoteInfo
       };
-      addMessageToFile(messageInfo);
+      await this.fileManager.addMessageToFile(messageInfo);
       const messageEvent = {
         type: "message",
         selfId: session.selfId,
         platform: session.platform || "unknown",
         channelId: session.channelId,
-        messageId: session.messageId,
-        content: session.content,
-        userId: session.userId || "unknown",
-        username: session.username || session.userId || "unknown",
-        avatar: session.author?.avatar,
+        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,
         guildId: session.guildId,
         guildName,
         channelType: session.type || 0,
-        elements: session.elements,
+        elements,
         quote: quoteInfo,
         bot: {
           avatar: session.bot.user?.avatar,
           name: session.bot.user?.name
         }
       };
-      ctx.console.broadcast("chat-message-event", messageEvent);
+      this.ctx.console.broadcast("chat-message-event", messageEvent);
+    } catch (error) {
+      this.logger.error("广播消息事件失败:", error);
+    }
+  }
+  // 处理机器人发送的消息
+  async broadcastBotMessageEvent(session) {
+    try {
+      await this.updateBotInfoToFile(session);
+      const guildName = await this.updateChannelInfoToFile(session);
+      const timestamp = Date.now();
+      let content = "";
+      if (session.event?.message?.elements) {
+        content = this.utils.extractTextContent(session.event.message.elements).trim();
+      }
+      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: session.event?.channel?.id || session.channelId,
+        selfId: session.selfId,
+        elements: session.event?.message?.elements,
+        type: "bot",
+        guildId: session.event?.guild?.id || session.guildId,
+        guildName,
+        platform: session.platform || "unknown"
+      };
+      await this.fileManager.addMessageToFile(messageInfo);
+      const messageEvent = {
+        type: "bot-message",
+        selfId: session.selfId,
+        platform: session.platform || "unknown",
+        channelId: session.event?.channel?.id || session.channelId,
+        messageId: `bot-msg-${timestamp}`,
+        content,
+        userId: session.selfId,
+        username: session.bot.user?.name || `Bot-${session.selfId}`,
+        avatar: session.bot.user?.avatar,
+        timestamp,
+        guildId: session.event?.guild?.id || session.guildId,
+        guildName,
+        channelType: session.event?.channel?.type || session.type || 0,
+        elements: session.event?.message?.elements,
+        bot: {
+          avatar: session.bot.user?.avatar,
+          name: session.bot.user?.name
+        }
+      };
+      const imageElements = session.event?.message?.elements?.filter(
+        (element) => element.type === "img" || element.type === "image" || element.type === "mface"
+      ) || [];
+      this.logInfo("机器人发送消息 (before-send):", {
+        selfId: session.selfId,
+        channelId: messageEvent.channelId,
+        content,
+        platform: session.platform,
+        imageCount: imageElements.length,
+        imageUrls: imageElements.map((el) => el.attrs?.src || el.attrs?.url || el.attrs?.file)
+      });
+      this.ctx.console.broadcast("chat-bot-message-event", messageEvent);
     } catch (error) {
-      logger.error("广播消息事件失败:", error);
+      this.logger.error("广播机器人消息事件失败:", error);
+    }
+  }
+  logInfo(...args) {
+    if (this.config.loggerinfo) {
+      this.logger.info(...args);
+    }
+  }
+};
+
+// src/api-handlers.ts
+var import_koishi = require("koishi");
+var import_node_url = require("node:url");
+var ApiHandlers = class {
+  constructor(ctx, config, fileManager) {
+    this.ctx = ctx;
+    this.config = config;
+    this.fileManager = fileManager;
+    this.logger = ctx.logger("chat-patch");
+  }
+  static {
+    __name(this, "ApiHandlers");
+  }
+  logger;
+  registerApiHandlers() {
+    this.ctx.console.addListener("get-chat-data", async () => {
+      try {
+        const data = this.fileManager.readChatDataFromFile();
+        const cleanedData = this.fileManager.cleanExcessMessages(data);
+        this.logInfo("获取聊天数据:", {
+          机器人数量: Object.keys(cleanedData.bots).length,
+          频道数量: Object.keys(cleanedData.channels).reduce((total, botId) => total + Object.keys(cleanedData.channels[botId] || {}).length, 0),
+          消息频道数: Object.keys(cleanedData.messages).length,
+          总消息数: Object.values(cleanedData.messages).reduce((total, msgs) => total + msgs.length, 0)
+        });
+        return {
+          success: true,
+          data: {
+            ...cleanedData,
+            pinnedBots: cleanedData.pinnedBots,
+            pinnedChannels: cleanedData.pinnedChannels
+          }
+        };
+      } 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 data = this.fileManager.readChatDataFromFile();
+        const channelKey = `${requestData.selfId}:${requestData.channelId}`;
+        const messages = data.messages[channelKey] || [];
+        const sortedMessages = messages.sort((a, b) => a.timestamp - b.timestamp);
+        this.logInfo("获取历史消息:", channelKey, "共", sortedMessages.length, "条消息");
+        return {
+          success: true,
+          messages: sortedMessages
+        };
+      } catch (error) {
+        this.logger.error("获取历史消息失败:", error);
+        return { success: false, error: error?.message || String(error), messages: [] };
+      }
+    });
+    this.ctx.console.addListener("get-all-channel-message-counts", async () => {
+      try {
+        const data = this.fileManager.readChatDataFromFile();
+        const counts = {};
+        for (const [channelKey, messages] of Object.entries(data.messages)) {
+          counts[channelKey] = messages.length;
+        }
+        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 (this.isFileUrl(data.url)) {
+          this.logInfo("处理本地文件请求:", data.url);
+          return await this.handleLocalFileRequest(data.url);
+        }
+        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();
+        const base64 = Buffer.from(buffer).toString("base64");
+        const contentType = response.headers.get("content-type") || "image/jpeg";
+        return {
+          success: true,
+          base64,
+          contentType,
+          dataUrl: `data:${contentType};base64,${base64}`
+        };
+      } catch (error) {
+        return { success: false, error: error?.message || String(error) };
+      }
+    });
+    this.ctx.console.addListener("clear-channel-history", async (data) => {
+      try {
+        this.logInfo("收到清理历史记录请求:", data);
+        const chatData = this.fileManager.readChatDataFromFile();
+        const channelKey = `${data.selfId}:${data.channelId}`;
+        if (!chatData.messages[channelKey]) {
+          return { success: true, message: "频道没有历史消息" };
+        }
+        const messages = chatData.messages[channelKey];
+        const originalCount = messages.length;
+        const keepCount = data.keepCount || this.config.keepMessagesOnClear;
+        if (keepCount > 0 && originalCount <= keepCount) {
+          return { success: true, message: `消息数量(${originalCount})未超过保留数量(${keepCount})，无需清理` };
+        }
+        const sortedMessages = [...messages].sort((a, b) => a.timestamp - b.timestamp);
+        const keptMessages = keepCount > 0 ? sortedMessages.slice(-keepCount) : [];
+        const clearedCount = originalCount - keptMessages.length;
+        chatData.messages[channelKey] = keptMessages;
+        this.fileManager.writeChatDataToFile(chatData);
+        this.logInfo(`频道 ${channelKey} 历史记录清理完成:`, {
+          原始消息数: originalCount,
+          保留消息数: keptMessages.length,
+          清理消息数: clearedCount
+        });
+        return {
+          success: true,
+          message: `成功清理 ${clearedCount} 条历史消息，保留最新 ${keptMessages.length} 条`,
+          clearedCount,
+          keptCount: keptMessages.length
+        };
+      } 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);
+        if (!bot) {
+          this.logger.error("未找到机器人:", data.selfId);
+          return { success: false, error: "未找到指定的机器人" };
+        }
+        let messageContent = data.content;
+        if (data.images && data.images.length > 0) {
+          const tempDir = this.ctx.baseDir + "/data/chat-patch/temp";
+          for (const image of data.images) {
+            const files = require("fs").readdirSync(tempDir).filter(
+              (file) => file.includes(`temp_${image.tempId}`)
+            );
+            if (files.length > 0) {
+              const imagePath = `${tempDir}/${files[0]}`;
+              const fileUrl = this.createFileUrl(imagePath);
+              messageContent += import_koishi.h.image(fileUrl).toString();
+              this.logInfo("添加图片到消息:", { imagePath, fileUrl });
+            }
+          }
+        }
+        const result = await bot.sendMessage(data.channelId, messageContent);
+        this.logInfo("消息发送成功:", result);
+        return {
+          success: true,
+          messageId: Array.isArray(result) ? result[0] : result,
+          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 chatData = this.fileManager.readChatDataFromFile();
+        let deletedChannels = 0;
+        let deletedMessages = 0;
+        if (chatData.channels[data.selfId]) {
+          deletedChannels = Object.keys(chatData.channels[data.selfId]).length;
+          delete chatData.channels[data.selfId];
+        }
+        const channelsToDelete = Object.keys(chatData.messages).filter((key) => key.startsWith(`${data.selfId}:`));
+        for (const channelKey of channelsToDelete) {
+          deletedMessages += chatData.messages[channelKey].length;
+          delete chatData.messages[channelKey];
+        }
+        delete chatData.bots[data.selfId];
+        this.fileManager.writeChatDataToFile(chatData);
+        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 chatData = this.fileManager.readChatDataFromFile();
+        const channelKey = `${data.selfId}:${data.channelId}`;
+        let deletedMessages = 0;
+        if (chatData.messages[channelKey]) {
+          deletedMessages = chatData.messages[channelKey].length;
+          delete chatData.messages[channelKey];
+        }
+        if (chatData.channels[data.selfId] && chatData.channels[data.selfId][data.channelId]) {
+          delete chatData.channels[data.selfId][data.channelId];
+        }
+        this.fileManager.writeChatDataToFile(chatData);
+        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);
+        const chatData = this.fileManager.readChatDataFromFile();
+        chatData.pinnedBots = data.pinnedBots;
+        this.fileManager.writeChatDataToFile(chatData);
+        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);
+        const chatData = this.fileManager.readChatDataFromFile();
+        chatData.pinnedChannels = data.pinnedChannels;
+        this.fileManager.writeChatDataToFile(chatData);
+        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 });
+        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() || "jpg";
+        const tempFilename = `temp_${tempId}.${extension}`;
+        const tempDir = this.ctx.baseDir + "/data/chat-patch/temp";
+        if (!require("fs").existsSync(tempDir)) {
+          require("fs").mkdirSync(tempDir, { recursive: true });
+        }
+        const tempPath = `${tempDir}/${tempFilename}`;
+        require("fs").writeFileSync(tempPath, buffer);
+        this.logInfo("图片上传成功:", { tempPath, size: buffer.length });
+        return {
+          success: true,
+          tempId,
+          tempPath,
+          filename: data.filename,
+          size: buffer.length
+        };
+      } 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 = this.ctx.baseDir + "/data/chat-patch/temp";
+        const files = require("fs").readdirSync(tempDir).filter(
+          (file) => file.includes(`temp_${data.tempId}`)
+        );
+        for (const file of files) {
+          const filePath = `${tempDir}/${file}`;
+          if (require("fs").existsSync(filePath)) {
+            require("fs").unlinkSync(filePath);
+            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,
+            keepMessagesOnClear: this.config.keepMessagesOnClear,
+            keepTempImages: this.config.keepTempImages,
+            loggerinfo: this.config.loggerinfo,
+            blockedPlatforms: this.config.blockedPlatforms || [],
+            chatContainerHeight: this.config.chatContainerHeight
+          }
+        };
+      } catch (error) {
+        this.logger.error("获取插件配置失败:", error);
+        return { success: false, error: error?.message || String(error) };
+      }
+    });
+    this.ctx.console.addListener("debug-get-raw-data", async () => {
+      try {
+        const data = this.fileManager.readChatDataFromFile();
+        return {
+          success: true,
+          data
+        };
+      } catch (error) {
+        this.logger.error("获取原始数据失败:", error);
+        return { success: false, error: error?.message || String(error) };
+      }
+    });
+  }
+  // 检查是否为文件 URL
+  isFileUrl(url) {
+    try {
+      const parsedUrl = new import_node_url.URL(url);
+      return parsedUrl.protocol === "file:";
+    } catch {
+      return false;
     }
   }
-  __name(broadcastMessageEvent, "broadcastMessageEvent");
+  // 创建文件 URL
+  createFileUrl(filePath) {
+    try {
+      return (0, import_node_url.pathToFileURL)(filePath).href;
+    } catch (error) {
+      this.logger.error("创建文件URL失败:", { filePath, error });
+      return `file://${filePath}`;
+    }
+  }
+  // 处理本地文件请求
+  async handleLocalFileRequest(fileUrl) {
+    try {
+      const fileresponse = await this.ctx.http.file(fileUrl);
+      const fileresponsebase64 = Buffer.from(fileresponse.data).toString("base64");
+      let contentType = fileresponse.type;
+      this.logInfo("成功读取本地文件:", { fileUrl, contentType });
+      return {
+        success: true,
+        base64: fileresponsebase64,
+        contentType,
+        dataUrl: `data:${contentType};base64,${fileresponsebase64}`
+      };
+    } catch (error) {
+      this.logger.error("读取本地文件失败:", { fileUrl, error: error.message });
+      return {
+        success: false,
+        error: `读取本地文件失败: ${error.message}`
+      };
+    }
+  }
+  // 设置定时清理临时文件
+  setupTempFileCleanup() {
+    setInterval(() => {
+      this.cleanupTempImagesByCount();
+    }, 5 * 60 * 1e3);
+  }
+  // 基于数量清理临时图片（保留最新的N张）
+  async cleanupTempImagesByCount() {
+    try {
+      const tempDir = this.ctx.baseDir + "/data/chat-patch/temp";
+      if (!require("fs").existsSync(tempDir)) {
+        return;
+      }
+      const now = Date.now();
+      const protectionTime = 30 * 1e3;
+      const files = require("fs").readdirSync(tempDir).filter((file) => file.startsWith("temp_")).map((file) => {
+        const filePath = `${tempDir}/${file}`;
+        try {
+          const stats = require("fs").statSync(filePath);
+          const fileAge = now - stats.mtime.getTime();
+          return {
+            name: file,
+            path: filePath,
+            mtime: stats.mtime.getTime(),
+            age: fileAge,
+            protected: fileAge < protectionTime
+            // 是否在保护期内
+          };
+        } catch (error) {
+          return null;
+        }
+      }).filter((file) => file !== null).sort((a, b) => b.mtime - a.mtime);
+      const keepCount = this.config.keepTempImages;
+      let cleanedCount = 0;
+      let protectedCount = 0;
+      const protectedFiles = files.filter((file) => file.protected);
+      const deletableFiles = files.filter((file) => !file.protected);
+      protectedCount = protectedFiles.length;
+      if (deletableFiles.length > keepCount) {
+        const filesToDelete = deletableFiles.slice(keepCount);
+        for (const file of filesToDelete) {
+          try {
+            if (require("fs").existsSync(file.path)) {
+              require("fs").unlinkSync(file.path);
+              cleanedCount++;
+              this.logInfo("清理多余临时图片:", file.path);
+            }
+          } catch (fileError) {
+            this.logger.warn("删除临时文件失败:", { file: file.name, error: fileError });
+          }
+        }
+      }
+      if (cleanedCount > 0 || protectedCount > 0) {
+        this.logInfo(`基于数量清理完成，保留最新 ${keepCount} 张图片，清理了 ${cleanedCount} 张多余图片，保护了 ${protectedCount} 张新上传图片`);
+      }
+    } catch (error) {
+      this.logger.warn("基于数量清理临时文件失败:", error);
+    }
+  }
+  logInfo(...args) {
+    if (this.config.loggerinfo) {
+      this.logger.info(...args);
+    }
+  }
+};
+
+// src/config.ts
+var import_koishi2 = require("koishi");
+var Config = import_koishi2.Schema.intersect([
+  import_koishi2.Schema.object({
+    maxMessagesPerChannel: import_koishi2.Schema.number().default(1e3).description("每个群组最大保存消息数量").min(50).max(5e3),
+    keepMessagesOnClear: import_koishi2.Schema.number().default(50).description("手动清理历史记录时保留的消息数量").min(0).max(1e3),
+    keepTempImages: import_koishi2.Schema.number().default(50).description("发送消息保留的临时图片数量（最新的N张）").min(10).max(200),
+    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
+        }
+      ]
+    )
+  }).description("基础设置"),
+  import_koishi2.Schema.object({
+    chatContainerHeight: import_koishi2.Schema.number().default(80).description("手机端使用的视口高度（防止文本输入框被挡住）").min(50).max(100),
+    loggerinfo: import_koishi2.Schema.boolean().default(false).description("日志调试模式").experimental()
+  }).description("进阶设置")
+]);
+
+// src/index.ts
+var name = "chat-patch";
+var reusable = false;
+var filter = false;
+var inject = {
+  required: ["console"]
+};
+var usage = `
+
+---
+
+开启后，即可在koishi控制台操作机器人收发消息啦
+
+暂时只支持接受图文消息 / 发送文字消息
+
+---
+`;
+async function apply(ctx, config) {
+  const logger = ctx.logger("chat-patch");
+  const fileManager = new FileManager(ctx, config);
+  const messageHandler = new MessageHandler(ctx, config, fileManager);
+  const apiHandlers = new ApiHandlers(ctx, config, fileManager);
+  const utils = new Utils(config);
+  const initialData = fileManager.readChatDataFromFile();
+  const cleanedData = fileManager.cleanExcessMessages(initialData);
+  const originalCount = Object.values(initialData.messages).reduce((total, msgs) => total + msgs.length, 0);
+  const cleanedCount = Object.values(cleanedData.messages).reduce((total, msgs) => total + msgs.length, 0);
+  if (originalCount !== cleanedCount) {
+    fileManager.writeChatDataToFile(cleanedData);
+  }
+  function logInfo(...args) {
+    if (config.loggerinfo) {
+      logger.info(...args);
+    }
+  }
+  __name(logInfo, "logInfo");
+  logInfo("插件加载完成，数据统计:", {
+    机器人数量: Object.keys(cleanedData.bots).length,
+    频道数量: Object.keys(cleanedData.channels).reduce((total, botId) => total + Object.keys(cleanedData.channels[botId] || {}).length, 0),
+    消息频道数: Object.keys(cleanedData.messages).length,
+    总消息数: Object.values(cleanedData.messages).reduce((total, msgs) => total + msgs.length, 0)
+  });
+  ctx.on("message", async (session) => {
+    if (utils.isPlatformBlocked(session.platform || "unknown")) {
+      logInfo(`忽略来自被屏蔽平台的消息: ${session.platform}`);
+      return;
+    }
+    await messageHandler.broadcastMessageEvent(session);
+  });
+  ctx.on("before-send", async (session) => {
+    if (utils.isPlatformBlocked(session.platform || "unknown")) {
+      logInfo(`忽略来自被屏蔽平台的机器人消息: ${session.platform}`);
+      return;
+    }
+    await messageHandler.broadcastBotMessageEvent(session);
+  });
+  ctx.on("ready", async () => {
+    logInfo("插件启动完成，开始监听消息");
+    setInterval(() => {
+      const data = fileManager.readChatDataFromFile();
+      const cleanedData2 = fileManager.cleanExcessMessages(data);
+      const originalCount2 = Object.values(data.messages).reduce((total, msgs) => total + msgs.length, 0);
+      const cleanedCount2 = Object.values(cleanedData2.messages).reduce((total, msgs) => total + msgs.length, 0);
+      if (originalCount2 !== cleanedCount2) {
+        fileManager.writeChatDataToFile(cleanedData2);
+        logInfo("定期清理完成，清理了", originalCount2 - cleanedCount2, "条超量消息");
+      }
+    }, 3e5);
+  });
+  apiHandlers.registerApiHandlers();
+  ctx.console.addEntry({
+    dev: import_node_path2.default.resolve(__dirname, "../client/index.ts"),
+    prod: import_node_path2.default.resolve(__dirname, "../dist")
+  });
 }
 __name(apply, "apply");
-export {
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
   Config,
   apply,
   filter,
@@ -591,4 +994,4 @@ export {
   name,
   reusable,
   usage
-};
+});