koishi-plugin-chat-patch 0.8.2

package/lib/index.js

@@ -0,0 +1,594 @@
+var __defProp = Object.defineProperty;
+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 usage = `
+---
+
+开启后，即可在koishi控制台操作机器人收发消息啦
+
+暂时只支持接受图文消息 / 发送文字消息
+
+---
+`;
+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);
+    }
+  }
+  __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;
+  }
+  __name(isPlatformBlocked, "isPlatformBlocked");
+  function ensureDataDir() {
+    const dir = path.dirname(dataFilePath);
+    if (!fs.existsSync(dir)) {
+      fs.mkdirSync(dir, { recursive: true });
+    }
+  }
+  __name(ensureDataDir, "ensureDataDir");
+  function readChatDataFromFile() {
+    try {
+      if (fs.existsSync(dataFilePath)) {
+        const jsonData = fs.readFileSync(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);
+    }
+    return {
+      bots: {},
+      channels: {},
+      messages: {},
+      pinnedBots: [],
+      // 默认空数组
+      pinnedChannels: []
+      // 默认空数组
+    };
+  }
+  __name(readChatDataFromFile, "readChatDataFromFile");
+  function writeChatDataToFile(data) {
+    try {
+      ensureDataDir();
+      data.lastSaveTime = Date.now();
+      const jsonData = JSON.stringify(data, null, 2);
+      fs.writeFileSync(dataFilePath, jsonData, "utf8");
+    } catch (error) {
+      logger.error("写入聊天数据失败:", error);
+    }
+  }
+  __name(writeChatDataToFile, "writeChatDataToFile");
+  function cleanExcessMessages(data) {
+    let cleanedCount2 = 0;
+    const cleanedMessages = {};
+    for (const [channelKey, messages] of Object.entries(data.messages)) {
+      if (messages.length > config.maxMessagesPerChannel) {
+        const sortedMessages = [...messages].sort((a, b) => a.timestamp - b.timestamp);
+        const keptMessages = sortedMessages.slice(-config.maxMessagesPerChannel);
+        cleanedCount2 += messages.length - keptMessages.length;
+        cleanedMessages[channelKey] = keptMessages;
+        logInfo(`频道 ${channelKey} 清理了 ${messages.length - keptMessages.length} 条旧消息，保留最新 ${keptMessages.length} 条`);
+      } else {
+        cleanedMessages[channelKey] = messages;
+      }
+    }
+    if (cleanedCount2 > 0) {
+      logInfo("总共清理超量消息:", cleanedCount2, "条");
+    }
+    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] = [];
+    }
+    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} 条旧消息`);
+    }
+    writeChatDataToFile(data);
+    logInfo("添加消息到文件:", channelKey, "当前消息数:", data.messages[channelKey].length);
+  }
+  __name(addMessageToFile, "addMessageToFile");
+  function updateBotInfoToFile(session) {
+    const data = readChatDataFromFile();
+    const botInfo = {
+      selfId: session.selfId,
+      platform: session.platform || "unknown",
+      username: session.bot.user?.name || `Bot-${session.selfId}`,
+      avatar: session.bot.user?.avatar,
+      status: "online"
+    };
+    data.bots[session.selfId] = botInfo;
+    writeChatDataToFile(data);
+    logInfo("更新机器人信息到文件:", botInfo.username);
+  }
+  __name(updateBotInfoToFile, "updateBotInfoToFile");
+  async function updateChannelInfoToFile(session) {
+    const data = readChatDataFromFile();
+    let guildName = session.channelId;
+    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);
+      guildName = session.channelId;
+    }
+    if (!data.channels[session.selfId]) {
+      data.channels[session.selfId] = {};
+    }
+    const channelInfo = {
+      id: session.channelId,
+      name: session.guildId ? `${guildName} (${session.channelId})` : `私信 ${session.channelId}`,
+      type: session.type || 0,
+      guildId: session.guildId,
+      guildName
+    };
+    data.channels[session.selfId][session.channelId] = channelInfo;
+    writeChatDataToFile(data);
+    logInfo("更新频道信息到文件:", channelInfo.name);
+    return guildName;
+  }
+  __name(updateChannelInfoToFile, "updateChannelInfoToFile");
+  async function broadcastMessageEvent(session) {
+    try {
+      updateBotInfoToFile(session);
+      const guildName = await updateChannelInfoToFile(session);
+      const timestamp = Date.now();
+      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()
+        };
+      }
+      const messageInfo = {
+        id: session.messageId || `msg-${timestamp}`,
+        content: session.content || "",
+        userId: session.userId || "unknown",
+        username: session.username || session.userId || "unknown",
+        avatar: session.author?.avatar,
+        timestamp,
+        channelId: session.channelId,
+        selfId: session.selfId,
+        elements: session.elements,
+        type: "user",
+        guildId: session.guildId,
+        guildName,
+        platform: session.platform || "unknown",
+        quote: quoteInfo
+      };
+      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,
+        timestamp,
+        guildId: session.guildId,
+        guildName,
+        channelType: session.type || 0,
+        elements: session.elements,
+        quote: quoteInfo,
+        bot: {
+          avatar: session.bot.user?.avatar,
+          name: session.bot.user?.name
+        }
+      };
+      ctx.console.broadcast("chat-message-event", messageEvent);
+    } catch (error) {
+      logger.error("广播消息事件失败:", error);
+    }
+  }
+  __name(broadcastMessageEvent, "broadcastMessageEvent");
+}
+__name(apply, "apply");
+export {
+  Config,
+  apply,
+  filter,
+  inject,
+  name,
+  reusable,
+  usage
+};

package/package.json

@@ -0,0 +1,40 @@
+{
+  "name": "koishi-plugin-chat-patch",
+  "description": "[<ruby>chat-patch<rp>（</rp><rt>点我预览效果</rt><rp>）</rp></ruby>](https://i0.hdslb.com/bfs/openplatform/71074dfc9e5256fc3333d8bd8478bec1af874046.png) 视奸小插件((bushi( (低性能警告)。手机端适配。灵感来自 chat 插件。",
+  "version": "0.8.2",
+  "type": "module",
+  "main": "lib/index.js",
+  "files": [
+    "client",
+    "dist",
+    "lib",
+    "src"
+  ],
+  "license": "MIT",
+  "homepage": "https://github.com/shangxueink/koishi-shangxue-apps/",
+  "bugs": {
+    "url": "https://github.com/shangxueink/koishi-shangxue-apps/issues"
+  },
+  "keywords": [
+    "koishi",
+    "plugin",
+    "chat",
+    "聊天室",
+    "console"
+  ],
+  "cordis": {
+    "service": {
+      "required": [
+        "console"
+      ]
+    }
+  },
+  "peerDependencies": {
+    "@koishijs/plugin-console": "^5.11.0",
+    "koishi": "^4.16.0"
+  },
+  "devDependencies": {
+    "@koishijs/client": "^5.11.0",
+    "koishi": "^4.16.0"
+  }
+}

package/readme.md

@@ -0,0 +1,25 @@
+# koishi-plugin-chat-patch
+
+[![npm](https://img.shields.io/npm/v/koishi-plugin-chat-patch?style=flat-square)](https://www.npmjs.com/package/koishi-plugin-chat-patch)   [![npm downloads](https://img.shields.io/npm/dm/koishi-plugin-chat-patch)](https://www.npmjs.com/package/koishi-plugin-chat-patch)  
+
+Koishi 控制台聊天插件，允许用户直接在控制台中管理机器人、频道和消息。
+
+支持消息的收发、图片缓存、频道置顶等。
+
+## ✨ 功能特性
+
+- **聊天界面**：在 Koishi 控制台内直接查看机器人的聊天记录。
+- **消息收发**：支持接收文本、图片等多种类型的消息。
+- **图片缓存**：通过 IndexedDB 缓存图片，优化加载速度并减少网络请求。
+- **手机端优化**：针对手机端进行适配，提供滑动返回等手势操作，并可配置聊天容器高度以防止输入框被遮挡。
+- **平台屏蔽**：可配置屏蔽特定平台的消息，避免不必要的干扰。
+
+## 🛠️ 开发与贡献
+
+欢迎 PR ~
+
+PR 方式请参考 -> https://github.com/shangxueink/koishi-shangxue-apps/tree/main?tab=readme-ov-file#%E5%A6%82%E4%BD%95%E5%9C%A8%E9%A1%B9%E7%9B%AE%E6%A8%A1%E6%9D%BF%E4%B8%AD%E5%BC%80%E5%8F%91%E6%AD%A4%E4%BB%93%E5%BA%93
+
+## 许可证
+
+本项目采用 [MIT 许可证](LICENSE) 开源。