@arr0wing/koishi-plugin-minecraft-sync-msg 3.0.2

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2023 Twiyin0
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/lib/index.d.ts

@@ -0,0 +1,50 @@
+import { Context, Schema } from 'koishi';
+import { wsConf, rconConf } from './values';
+export declare const name = "minecraft-sync-msg";
+declare class MinecraftSyncMsg {
+    private ctx;
+    private config;
+    private ws;
+    private rcon;
+    private isDisposing;
+    private reconnectAttempts;
+    private reconnectIntervalId;
+    private pl_fork;
+    private enUS;
+    private zhCN;
+    constructor(ctx: Context, config: MinecraftSyncMsg.Config);
+    private initialize;
+    private setupRcon;
+    private connectToRcon;
+    private setupWebSocket;
+    private connectWebSocket;
+    private bindWebSocketEvents;
+    private handleWsOpen;
+    private handleWsMessage;
+    private handleWsClose;
+    private handleWsError;
+    private reconnectWebSocket;
+    private clearReconnectInterval;
+    private setupMessageHandler;
+    private isValidChannel;
+    private isMessageCommand;
+    private isRconCommand;
+    private handleMessageCommand;
+    private handleRconCommand;
+    private sendRconCommand;
+    private extractAndRemoveColor;
+    private broadcastToChannels;
+    private setupDisposeHandler;
+}
+declare namespace MinecraftSyncMsg {
+    interface Config extends wsConf, rconConf {
+        sendToChannel: string[];
+        sendprefix: string;
+        cmdprefix: string;
+        hideConnect: boolean;
+        locale: string;
+    }
+    const Config: Schema<Config>;
+    const usage = "\n  \u63D2\u4EF6\u4F7F\u7528\u8BE6\u60C5\u8BF7\u770B [v2.x](https://blog.iin0.cn/views/myblog/mc/wskoishitomc.html)  \n  *** \u6CE8\u610F ***  \n  * \u547D\u4EE4\u53D1\u9001\u524D\u7F00(\u4E0D\u80FD\u4E3A\u7A7A)\u548C\u6D88\u606F\u53D1\u9001\u524D\u7F00(\u53EF\u4EE5\u4E3A\u7A7A)\u4E0D\u80FD\u76F8\u540C\n  * forge\u7AEF\u4E0D\u652F\u6301PlayerCommandPreprocessEvent\u4E8B\u4EF6\n  * * \u539F\u7248\u7AEF\u4EC5\u652F\u6301\u804A\u5929\u3001\u52A0\u5165\u3001\u79BB\u5F00\u4E8B\u4EF6\n  * sendToChannel\u7684\u683C\u5F0F\u4E3A{platform}:{groupId},\u5982\uFF1A`discord:123456`\n  * v2.1.0-beta\u53EF\u4EE5\u901A\u8FC7`\u672C\u5730\u5316`\u81EA\u5B9A\u4E49\u5BF9\u5E94\u4E8B\u4EF6\u53D1\u9001\u683C\u5F0F\n    - action\u8282\u70B9\u7684{0}\u662F\u73A9\u5BB6\u540D\u79F0{1}\u662F\u6D88\u606F\n    - message\u8282\u70B9\u4E2D\u7684{0}\u662F\u5E73\u53F0{1}\u662F\u7528\u6237\u540D\n  ";
+}
+export default MinecraftSyncMsg;

package/lib/index.js

@@ -0,0 +1,639 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
+var __export = (target, all) => {
+  for (var name2 in all)
+    __defProp(target, name2, { get: all[name2], enumerable: true });
+};
+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 __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/index.tsx
+var src_exports = {};
+__export(src_exports, {
+  default: () => src_default,
+  name: () => name
+});
+module.exports = __toCommonJS(src_exports);
+var import_koishi3 = require("koishi");
+var import_ws2 = require("ws");
+var import_rcon_client = require("rcon-client");
+
+// src/values.tsx
+var import_koishi = require("koishi");
+var mcEvent = /* @__PURE__ */ ((mcEvent2) => {
+  mcEvent2[mcEvent2["AsyncPlayerChatEvent"] = 1] = "AsyncPlayerChatEvent";
+  mcEvent2[mcEvent2["PlayerCommandPreprocessEvent"] = 2] = "PlayerCommandPreprocessEvent";
+  mcEvent2[mcEvent2["PlayerDeathEvent"] = 4] = "PlayerDeathEvent";
+  mcEvent2[mcEvent2["PlayerJoinEvent"] = 8] = "PlayerJoinEvent";
+  mcEvent2[mcEvent2["PlayerQuitEvent"] = 16] = "PlayerQuitEvent";
+  mcEvent2[mcEvent2["PlayerAchievementEvent"] = 32] = "PlayerAchievementEvent";
+  return mcEvent2;
+})(mcEvent || {});
+var wsConf = import_koishi.Schema.object({
+  wsServer: import_koishi.Schema.union(["客户端", "服务端"]).default("客户端").description("Websocket端选择"),
+  wsHost: import_koishi.Schema.string().default("127.0.0.1").description("websocket服务器的地址(服务器监听地址)"),
+  wsPort: import_koishi.Schema.number().default(8080).description("websocket服务器的端口(服务器监听端口)"),
+  Token: import_koishi.Schema.string().description("websocket服务器的验证Token"),
+  serverName: import_koishi.Schema.string().description("鹊桥配置文件中对应的server_name"),
+  joinMsg: import_koishi.Schema.string().default("[客户端] 连接成功！").description("连接服务的成功时发送的消息(&颜色单词&可以设置颜色)"),
+  event: import_koishi.Schema.bitset(mcEvent).description("选择需要监听的事件"),
+  maxReconnectCount: import_koishi.Schema.number().default(20).description("[仅客户端生效]客户端最大重连次数"),
+  maxReconnectInterval: import_koishi.Schema.number().default(6e4).description("[仅客户端生效]客户端单次重连时间(ms)")
+}).collapse().description("Websocket配置");
+var rconConf = import_koishi.Schema.object({
+  rconEnable: import_koishi.Schema.boolean().default(true).description("开启RCON功能"),
+  rconServerHost: import_koishi.Schema.string().default("127.0.0.1").description("rcon服务器地址"),
+  rconServerPort: import_koishi.Schema.number().default(25575).description("rcon服务器地址端口"),
+  rconPassword: import_koishi.Schema.string().role("secret").description("rcon服务器的密码(推荐设置)"),
+  alluser: import_koishi.Schema.boolean().default(false).description("所有用户可用(开启后下面的配置失效)"),
+  superuser: import_koishi.Schema.array(String).description("超级用户的ID，可以使用RCON所有命令"),
+  commonCmd: import_koishi.Schema.array(String).default(["list", "spigot:tps"]).description("普通用户可以使用的命令"),
+  cannotCmd: import_koishi.Schema.array(String).default(["restart", "stop"]).description("不能使用的命令")
+}).collapse().description("RCON配置");
+function getSubscribedEvents(binaryInput) {
+  const subscribedEvents = [];
+  const eventValues = Object.values(mcEvent).filter((value) => typeof value === "number");
+  const eventNames = Object.keys(mcEvent).filter((key) => isNaN(Number(key)));
+  for (let i = 0; i < eventValues.length; i++) {
+    if ((binaryInput & eventValues[i]) !== 0) {
+      subscribedEvents.push(eventNames[i]);
+    }
+  }
+  return subscribedEvents;
+}
+__name(getSubscribedEvents, "getSubscribedEvents");
+var eventMap = {
+  AsyncPlayerChatEvent: "AsyncPlayerChatEvent",
+  ServerMessageEvent: "AsyncPlayerChatEvent",
+  ServerChatEvent: "AsyncPlayerChatEvent",
+  NeoServerChatEvent: "AsyncPlayerChatEvent",
+  MinecraftPlayerChatEvent: "AsyncPlayerChatEvent",
+  BaseChatEvent: "AsyncPlayerChatEvent",
+  PlayerChatEvent: "AsyncPlayerChatEvent",
+  PlayerCommandPreprocessEvent: "PlayerCommandPreprocessEvent",
+  ServerCommandMessageEvent: "PlayerCommandPreprocessEvent",
+  CommandEvent: "PlayerCommandPreprocessEvent",
+  NeoCommandEvent: "PlayerCommandPreprocessEvent",
+  BasePlayerCommandEvent: "PlayerCommandPreprocessEvent",
+  PlayerCommandEvent: "PlayerCommandPreprocessEvent",
+  PlayerDeathEvent: "PlayerDeathEvent",
+  NeoPlayerDeathEvent: "PlayerDeathEvent",
+  ServerLivingEntityAfterDeathEvent: "PlayerDeathEvent",
+  BaseDeathEvent: "PlayerDeathEvent",
+  PlayerJoinEvent: "PlayerJoinEvent",
+  ServerPlayConnectionJoinEvent: "PlayerJoinEvent",
+  PlayerLoggedInEvent: "PlayerJoinEvent",
+  NeoPlayerLoggedInEvent: "PlayerJoinEvent",
+  MinecraftPlayerJoinEvent: "PlayerJoinEvent",
+  BaseJoinEvent: "PlayerJoinEvent",
+  PlayerQuitEvent: "PlayerQuitEvent",
+  ServerPlayConnectionDisconnectEvent: "PlayerQuitEvent",
+  PlayerLoggedOutEvent: "PlayerQuitEvent",
+  NeoPlayerLoggedOutEvent: "PlayerQuitEvent",
+  MinecraftPlayerQuitEvent: "PlayerQuitEvent",
+  BaseQuitEvent: "PlayerQuitEvent",
+  VelocityDisconnectEvent: "PlayerQuitEvent",
+  VelocityCommandExecuteEvent: "PlayerCommandPreprocessEvent",
+  VelocityLoginEvent: "PlayerJoinEvent",
+  VelocityPlayerChatEvent: "AsyncPlayerChatEvent",
+  PlayerAchievementEvent: "PlayerAchievementEvent"
+};
+function getListeningEvent(input) {
+  if (typeof input === "string") {
+    input = [input];
+  }
+  const uniqueEvents = /* @__PURE__ */ new Set();
+  for (const event of input) {
+    if (eventMap[event]) {
+      uniqueEvents.add(eventMap[event]);
+    }
+  }
+  return Array.from(uniqueEvents)[0];
+}
+__name(getListeningEvent, "getListeningEvent");
+
+// src/mcwss.tsx
+var import_koishi2 = require("koishi");
+var import_ws = require("ws");
+
+// src/locale/zh-CN.yml
+var zh_CN_default = { "minecraft-sync-msg": { connection: { connectedToWS: "Websocket服务器连接成功", disconnectedFromWS: "与Websocket服务器断开连接!", connectionErrorWS: "与Websocket服务器通信错误" }, action: { PlayerJoinEvent: "[加入]{0} 加入了服务器！", PlayerCommandPreprocessEvent: "[指令]{0} 执行了指令: {1}", PlayerDeathEvent: "[死亡]{0} 与山长眠！", AsyncPlayerChatEvent: "[聊天]{0} 说：{1}", PlayerQuitEvent: "[离开]{0} 离开了服务器！", PlayerAchievementEvent: "[成就]{0} 获得了成就：{1}" }, message: { MCReceivePrefix: "[{0}]({2}){1}: " } } };
+
+// src/locale/en-US.yml
+var en_US_default = { "minecraft-sync-msg": { connection: { connectedToWS: "Websocket connection up!", disconnectedFromWS: "Websocket connection down!", connectionErrorWS: "Websocket connection error!" }, action: { PlayerJoinEvent: "[join] Player {0} joined the game", PlayerCommandPreprocessEvent: "[command] Player {0} executed command: {1}", PlayerDeathEvent: "[death] Player {0} meet the god", AsyncPlayerChatEvent: "[chat] Player {0} said: {1}", PlayerQuitEvent: "[quit] Player {0} left the game", PlayerAchievementEvent: "[achievement]{0} has achieved: {1}" }, message: { MCReceivePrefix: "[{0}]({2}){1}: " } } };
+
+// src/mcwss.tsx
+var mcWss = class {
+  static {
+    __name(this, "mcWss");
+  }
+  conf;
+  logger = new import_koishi2.Logger("Minecraft-sync-msg-Wss");
+  wss;
+  ctx;
+  connectedClients = /* @__PURE__ */ new Set();
+  constructor(ctx, cfg) {
+    this.conf = cfg;
+    this.ctx = ctx;
+    ctx.on("ready", async () => {
+      this.ctx.i18n.define("zh-CN", zh_CN_default);
+      this.ctx.i18n.define("en-US", en_US_default);
+      this.wss = new import_ws.WebSocketServer({ host: cfg.wsHost, port: cfg.wsPort });
+      ctx.logger.info(`Websocket服务器已启动 ws://${cfg.wsHost}:${cfg.wsPort}`);
+      this.setupWebSocketHandlers();
+    });
+    this.setupMessageHandler();
+    ctx.on("dispose", async () => {
+      if (this.wss) {
+        this.wss.close();
+      }
+      this.connectedClients.clear();
+    });
+  }
+  setupWebSocketHandlers() {
+    this.wss.on("connection", (ws, req) => {
+      let msgData = {
+        "api": "broadcast",
+        data: {
+          "message": [
+            {
+              text: extractAndRemoveColor(this.conf.joinMsg).output,
+              color: extractAndRemoveColor(this.conf.joinMsg).color ? extractAndRemoveColor(this.conf.joinMsg).color : "gold"
+            }
+          ]
+        }
+      };
+      ws.send(JSON.stringify(msgData));
+      this.ctx.logger.success("客户端连接成功!");
+      const headers = req.headers;
+      if (!this.verifyHeaders(headers).valid) {
+        this.ctx.logger.error("请求头验证失败!");
+        if (!this.conf.hideConnect) this.ctx.bots.forEach(async (bot) => {
+          const channels = this.conf.sendToChannel.filter((str) => str.includes(`${bot.platform}`)).map((str) => str.replace(`${bot.platform}:`, ""));
+          bot.broadcast(channels, "Websocket请求头验证失败!", 0);
+        });
+        ws.close(1008, "Invalid header!");
+        return;
+      }
+      if (!this.conf.hideConnect) this.ctx.bots.forEach(async (bot) => {
+        const channels = this.conf.sendToChannel.filter((str) => str.includes(`${bot.platform}`)).map((str) => str.replace(`${bot.platform}:`, ""));
+        if (!this.conf.hideConnect) bot.broadcast(channels, this.ctx.i18n.render([this.conf.locale ? this.conf.locale : "zh-CN"], [`minecraft-sync-msg.connection.connectedToWS`], {}), 0);
+      });
+      this.connectedClients.add(ws);
+      ws.on("message", async (buffer) => {
+        this.ctx.logger.info(`收到来自客户端的消息: ${buffer.toString()}`);
+        const data = JSON.parse(buffer.toString());
+        let eventName = data.event_name ? getListeningEvent(data.event_name) : "";
+        if (!getSubscribedEvents(this.conf.event).includes(eventName)) return;
+        let sendMsg = import_koishi2.h.unescape(data.message ? data.message : data.command ? data.command : "").replaceAll("&amp;", "&").replaceAll(/<\/?template>/gi, "").replaceAll(/§./g, "");
+        sendMsg = sendMsg.replaceAll(/<json.*\/>/gi, "<json消息>");
+        const imageMatch = sendMsg.match(/(https?|file):\/\/.*\.(jpg|jpeg|webp|ico|gif|jfif|bmp|png)/gi);
+        const sendImage = imageMatch?.[0];
+        if (sendImage) {
+          sendMsg = sendMsg.replace(sendImage, `<img src="${sendImage}" />`);
+        }
+        if (eventName === "PlayerAchievementEvent" && data.player) {
+          sendMsg = this.ctx.i18n.render([this.conf.locale ? this.conf.locale : "zh-CN"], [`minecraft-sync-msg.action.${eventName}`], [data.player?.nickname, data.achievement.text]);
+        } else
+          sendMsg = this.ctx.i18n.render([this.conf.locale ? this.conf.locale : "zh-CN"], [`minecraft-sync-msg.action.${eventName}`], [data.player?.nickname, sendMsg]);
+        if (data.server_name)
+          this.ctx.bots.forEach(async (bot) => {
+            const channels = this.conf.sendToChannel.filter((str) => str.includes(`${bot.platform}`)).map((str) => str.replace(`${bot.platform}:`, ""));
+            sendMsg ? bot.broadcast(channels, sendMsg, 0) : "";
+          });
+      });
+      ws.on("error", (err) => {
+        ws?.close();
+        if (!this.conf.hideConnect) this.ctx.bots.forEach(async (bot) => {
+          const channels = this.conf.sendToChannel.filter((str) => str.includes(`${bot.platform}`)).map((str) => str.replace(`${bot.platform}:`, ""));
+          bot.broadcast(channels, this.ctx.i18n.render([this.conf.locale ? this.conf.locale : "zh-CN"], [`minecraft-sync-msg.connection.connectionErrorWS`], {}), 0);
+        });
+        this.ctx.logger.error(this.ctx.i18n.render([this.conf.locale ? this.conf.locale : "zh-CN"], [`minecraft-sync-msg.connection.connectionErrorWS`], {}), err);
+      });
+      ws.on("close", () => {
+        this.connectedClients.delete(ws);
+        if (!this.conf.hideConnect) this.ctx.bots.forEach(async (bot) => {
+          const channels = this.conf.sendToChannel.filter((str) => str.includes(`${bot.platform}`)).map((str) => str.replace(`${bot.platform}:`, ""));
+          bot.broadcast(channels, this.ctx.i18n.render([this.conf.locale ? this.conf.locale : "zh-CN"], [`minecraft-sync-msg.connection.disconnectedFromWS`], {}), 0);
+        });
+        this.ctx.logger.error(this.ctx.i18n.render([this.conf.locale ? this.conf.locale : "zh-CN"], [`minecraft-sync-msg.connection.disconnectedFromWS`], {}));
+      });
+    });
+  }
+  setupMessageHandler() {
+    let imgurl = "<unknown image url>";
+    this.ctx.on("message", async (session) => {
+      if (session.content.includes("<img") && import_koishi2.h.select(session.content, "img")[0]?.type === "img" && import_koishi2.h.select(session.content, "img")[0]?.attrs?.src) {
+        imgurl = import_koishi2.h.select(session.content, "img")[0].attrs.src;
+      }
+      if (this.conf.sendToChannel.includes(`${session.platform}:${session.channelId}`) || session.platform === "sandbox") {
+        if (session.content.startsWith(this.conf.sendprefix) && session.content !== this.conf.sendprefix) {
+          let msg = session.content.replaceAll("&amp;", "&").replaceAll(/<\/?template>/gi, "").replace(this.conf.sendprefix, "").replaceAll(/<json.*\/>/gi, "<json消息>").replaceAll(/<video.*\/>/gi, "<视频消息>").replaceAll(/<audio.*\/>/gi, "<音频消息>").replaceAll(/<img.*\/>/gi, `[[CICode,url=${imgurl}]]`).replaceAll(/<at.*\/>/gi, `@[${import_koishi2.h.select(session.content, "at")[0]?.attrs?.name ? import_koishi2.h.select(session.content, "at")[0]?.attrs?.name : import_koishi2.h.select(session.content, "at")[0]?.attrs?.id}]`);
+          const data = await session.bot.internal.getGroupMemberInfo(session.guildId, session.userId);
+          if (this.connectedClients.size > 0) {
+            let msgData = {
+              "api": "broadcast",
+              data: {
+                "message": [
+                  {
+                    // text: `(${session.platform})[${session.event.user.name}] ` + extractAndRemoveColor(msg).output,
+                    text: this.ctx.i18n.render([this.conf.locale ? this.conf.locale : "zh-CN"], ["minecraft-sync-msg.message.MCReceivePrefix"], [session.platform, data.card || data.nickname, session.userId]).map((element) => element.attrs?.content).join("") + extractAndRemoveColor(msg).output,
+                    color: extractAndRemoveColor(msg).color ? extractAndRemoveColor(msg).color : "white"
+                  }
+                ]
+              }
+            };
+            let sent = false;
+            this.connectedClients.forEach((client) => {
+              if (client.readyState === import_ws.WebSocket.OPEN) {
+                try {
+                  client.send(JSON.stringify(msgData));
+                  sent = true;
+                } catch (err) {
+                  this.ctx.logger.error(`聊天消息发送到WebSocket客户端失败: ${err}`);
+                }
+              }
+            });
+            if (!sent) {
+              session.send(this.ctx.i18n.render([this.conf.locale ? this.conf.locale : "zh-CN"], [`minecraft-sync-msg.connection.connectionErrorWS`], {}));
+            }
+          } else {
+            session.send(this.ctx.i18n.render([this.conf.locale ? this.conf.locale : "zh-CN"], [`minecraft-sync-msg.connection.connectionErrorWS`], {}));
+          }
+        }
+      }
+    });
+  }
+  verifyHeaders(headers) {
+    const authHeader = headers["authorization"];
+    const selfNameHeader = headers["x-self-name"];
+    const clientOriginHeader = headers["x-client-origin"];
+    if (!authHeader) {
+      this.logger.error("Missing authorization header");
+      return { valid: false };
+    }
+    const token = authHeader.split(" ")[1];
+    if (token !== this.conf.Token) {
+      this.logger.error("Token is invalid!");
+      return { valid: false };
+    }
+    if (!selfNameHeader) {
+      this.logger.error("Missing x-self-name header");
+      return { valid: false };
+    }
+    if (selfNameHeader !== this.conf.serverName) {
+      this.logger.error("Invalid x-self-name");
+      return { valid: false };
+    }
+    const clientOrigin = clientOriginHeader;
+    return { valid: true, clientOrigin };
+  }
+};
+function extractAndRemoveColor(input) {
+  const regex = /&(\w+)&/;
+  const match = input.match(regex);
+  if (match) {
+    const color = match[1];
+    const output = input.replace(regex, "");
+    return { output, color };
+  }
+  return { output: input, color: "" };
+}
+__name(extractAndRemoveColor, "extractAndRemoveColor");
+((mcWss2) => {
+  mcWss2.Config = import_koishi2.Schema.intersect([
+    wsConf,
+    import_koishi2.Schema.object({
+      sendToChannel: import_koishi2.Schema.array(String).description("消息发送到目标群组格式{paltform}:{groupId}"),
+      sendprefix: import_koishi2.Schema.string().default(".#").description("消息发送前缀（不可与命令发送前缀相同）"),
+      hideConnect: import_koishi2.Schema.boolean().default(true).description("关闭连接成功/失败提示"),
+      locale: import_koishi2.Schema.union(["zh-CN", "en-US"]).default("zh-CN").description("本地化语言选择,zh_CN为中文,en-US为英文")
+    }).description("基础配置")
+  ]);
+})(mcWss || (mcWss = {}));
+var mcwss_default = mcWss;
+
+// src/index.tsx
+var name = "minecraft-sync-msg";
+var logger = new import_koishi3.Logger("minecraft-sync-msg");
+var MinecraftSyncMsg = class _MinecraftSyncMsg {
+  constructor(ctx, config) {
+    this.ctx = ctx;
+    this.config = config;
+    this.initialize();
+  }
+  static {
+    __name(this, "MinecraftSyncMsg");
+  }
+  ws;
+  rcon;
+  isDisposing = false;
+  reconnectAttempts = 0;
+  reconnectIntervalId = null;
+  pl_fork;
+  enUS;
+  zhCN;
+  initialize() {
+    this.setupRcon();
+    this.setupWebSocket();
+    this.setupMessageHandler();
+    this.setupDisposeHandler();
+    this.ctx.i18n.define("zh-CN", zh_CN_default);
+    this.ctx.i18n.define("en-US", en_US_default);
+  }
+  setupRcon() {
+    if (!this.config.rconEnable) return;
+    this.rcon = new import_rcon_client.Rcon({
+      host: this.config.rconServerHost,
+      port: this.config.rconServerPort,
+      password: this.config.rconPassword
+    });
+    this.connectToRcon().catch((err) => {
+      logger.error("RCON服务器连接失败:", err);
+    });
+  }
+  async connectToRcon() {
+    try {
+      await this.rcon.connect();
+      logger.info("已连接到RCON服务器");
+    } catch (err) {
+      logger.error("连接到RCON服务器时发生错误:", err);
+      throw err;
+    }
+  }
+  setupWebSocket() {
+    if (this.config.wsServer === "服务端") {
+      this.pl_fork = this.ctx.plugin(mcwss_default, this.config);
+      return;
+    } else
+      this.connectWebSocket();
+  }
+  connectWebSocket() {
+    const headers = {
+      "x-self-name": this.config.serverName,
+      "Authorization": `Bearer ${this.config.Token}`,
+      "x-client-origin": "NOTkoishi"
+    };
+    this.ws = new import_ws2.WebSocket(`ws://${this.config.wsHost}:${this.config.wsPort}/minecraft/ws`, {
+      headers
+    });
+    this.bindWebSocketEvents();
+  }
+  bindWebSocketEvents() {
+    if (!this.ws) return;
+    this.ws.on("open", () => this.handleWsOpen());
+    this.ws.on("message", (buffer) => this.handleWsMessage(buffer));
+    this.ws.on("close", () => this.handleWsClose());
+    this.ws.on("error", (err) => this.handleWsError(err));
+  }
+  handleWsOpen() {
+    logger.info(this.ctx.i18n.render([this.config.locale ? this.config.locale : "zh-CN"], [`minecraft-sync-msg.connection.connectedToWS`], {}));
+    if (!this.config.hideConnect) {
+      this.broadcastToChannels(this.ctx.i18n.render([this.config.locale ? this.config.locale : "zh-CN"], [`minecraft-sync-msg.connection.connectedToWS`], {}));
+    }
+    const msgData = {
+      "api": "broadcast",
+      "data": {
+        "message": [
+          {
+            "text": this.extractAndRemoveColor(this.config.joinMsg).output,
+            "color": this.extractAndRemoveColor(this.config.joinMsg).color || "gold"
+          }
+        ]
+      }
+    };
+    this.ws?.send(JSON.stringify(msgData));
+  }
+  handleWsMessage(buffer) {
+    const dataStr = buffer.toString();
+    let data;
+    try {
+      data = JSON.parse(dataStr);
+    } catch (err) {
+      logger.error("Failed to parse WebSocket message:", err);
+      return;
+    }
+    const eventName = data.event_name ? getListeningEvent(data.event_name) : "";
+    if (!getSubscribedEvents(this.config.event).includes(eventName)) return;
+    let sendMsg = import_koishi3.h.unescape(data.message ? data.message : data.command ? data.command : "").replaceAll("&amp;", "&").replaceAll(/<\/?template>/gi, "").replaceAll(/§./g, "");
+    sendMsg = sendMsg.replaceAll(/<json.*\/>/gi, "<json消息>");
+    const imageMatch = sendMsg.match(/(https?|file):\/\/.*\.(jpg|jpeg|webp|ico|gif|jfif|bmp|png)/gi);
+    const sendImage = imageMatch?.[0];
+    if (sendImage) {
+      sendMsg = sendMsg.replace(sendImage, `<img src="${sendImage}" />`);
+    }
+    if (eventName === "PlayerAchievementEvent" && data.player) {
+      sendMsg = this.ctx.i18n.render([this.config.locale ? this.config.locale : "zh-CN"], [`minecraft-sync-msg.action.${eventName}`], [data.player?.nickname, data.achievement.text]);
+    } else
+      sendMsg = this.ctx.i18n.render([this.config.locale ? this.config.locale : "zh-CN"], [`minecraft-sync-msg.action.${eventName}`], [data.player?.nickname, sendMsg]);
+    if (data.server_name && sendMsg) {
+      this.broadcastToChannels(import_koishi3.h.parse(sendMsg));
+    }
+  }
+  handleWsClose() {
+    if (this.isDisposing) return;
+    if (!this.config.hideConnect) {
+      this.broadcastToChannels(this.ctx.i18n.render([this.config.locale ? this.config.locale : "zh-CN"], [`minecraft-sync-msg.connection.disconnectedFromWS`], {}));
+    }
+    logger.error(this.ctx.i18n.render([this.config.locale ? this.config.locale : "zh-CN"], [`minecraft-sync-msg.connection.disconnectedFromWS`], {}));
+    this.ws = void 0;
+    this.reconnectWebSocket();
+  }
+  handleWsError(err) {
+    if (this.isDisposing) return;
+    if (!this.config.hideConnect) {
+      this.broadcastToChannels(this.ctx.i18n.render([this.config.locale ? this.config.locale : "zh-CN"], [`minecraft-sync-msg.connection.connectionErrorWS`], {}));
+    }
+    logger.error(this.ctx.i18n.render([this.config.locale ? this.config.locale : "zh-CN"], [`minecraft-sync-msg.connection.connectionErrorWS`], {}), err);
+  }
+  async reconnectWebSocket() {
+    this.clearReconnectInterval();
+    this.reconnectIntervalId = setInterval(async () => {
+      if (this.reconnectAttempts >= this.config.maxReconnectCount) {
+        logger.error(`已达到最大重连次数 (${this.config.maxReconnectCount} 次)，停止重连。`);
+        this.clearReconnectInterval();
+        return;
+      }
+      this.reconnectAttempts++;
+      logger.info(`尝试第 ${this.reconnectAttempts} 次重连...`);
+      try {
+        const headers = {
+          "x-self-name": this.config.serverName,
+          "Authorization": `Bearer ${this.config.Token}`,
+          "x-client-origin": "koishi"
+        };
+        const ws = new import_ws2.WebSocket(`ws://${this.config.wsHost}:${this.config.wsPort}/minecraft/ws`, {
+          headers
+        });
+        ws.on("open", () => {
+          logger.info("WebSocket 重连成功");
+          this.clearReconnectInterval();
+          this.ws = ws;
+          this.bindWebSocketEvents();
+        });
+        ws.on("error", (err) => {
+          logger.error("重连时发生错误:", err);
+          ws?.close();
+        });
+        ws.on("close", () => {
+          if (!this.isDisposing) {
+            logger.info("WebSocket 再次断开，将继续尝试重连...");
+          }
+        });
+      } catch (err) {
+        logger.error("创建WebSocket时发生错误:", err);
+        if (this.reconnectAttempts >= this.config.maxReconnectCount) {
+          this.clearReconnectInterval();
+        }
+      }
+    }, this.config.maxReconnectInterval);
+  }
+  clearReconnectInterval() {
+    if (this.reconnectIntervalId) {
+      clearInterval(this.reconnectIntervalId);
+      this.reconnectIntervalId = null;
+    }
+    this.reconnectAttempts = 0;
+  }
+  setupMessageHandler() {
+    this.ctx.on("message", async (session) => {
+      if (!this.isValidChannel(session)) return;
+      if (this.isMessageCommand(session)) {
+        await this.handleMessageCommand(session);
+      }
+      if (this.isRconCommand(session)) {
+        await this.handleRconCommand(session);
+      }
+    });
+  }
+  isValidChannel(session) {
+    return this.config.sendToChannel.includes(`${session.platform}:${session.channelId}`) || session.platform === "sandbox";
+  }
+  isMessageCommand(session) {
+    return session.content.startsWith(this.config.sendprefix) && session.content !== this.config.sendprefix;
+  }
+  isRconCommand(session) {
+    return this.config.rconEnable && this.config.cmdprefix && session.content.startsWith(this.config.cmdprefix) && session.content !== this.config.cmdprefix;
+  }
+  async handleMessageCommand(session) {
+    let imgurl = "<unknown image url>";
+    if (session.content.includes("<img") && import_koishi3.h.select(session.content, "img")[0]?.type === "img" && import_koishi3.h.select(session.content, "img")[0]?.attrs?.src) {
+      imgurl = import_koishi3.h.select(session.content, "img")[0].attrs.src;
+    }
+    let msg = session.content.replaceAll("&amp;", "&").replaceAll(/<\/?template>/gi, "").replace(this.config.sendprefix, "").replaceAll(/<json.*\/>/gi, "<json消息>").replaceAll(/<video.*\/>/gi, "<视频消息>").replaceAll(/<audio.*\/>/gi, "<音频消息>").replaceAll(/<img.*\/>/gi, `[[CICode,url=${imgurl}]]`).replaceAll(/<at.*\/>/gi, `@[${import_koishi3.h.select(session.content, "at")[0]?.attrs?.name ? import_koishi3.h.select(session.content, "at")[0]?.attrs?.name : import_koishi3.h.select(session.content, "at")[0]?.attrs?.id}]`);
+    try {
+      const { output, color } = this.extractAndRemoveColor(msg);
+      const username = await session.bot.internal.getGroupMemberInfo(session.guildId, session.userId);
+      const msgData = {
+        "api": "broadcast",
+        "data": {
+          "message": [
+            {
+              "text": this.ctx.i18n.render([this.config.locale ? this.config.locale : "zh-CN"], ["minecraft-sync-msg.message.MCReceivePrefix"], [session.platform, username.card || username.nickname, session.userId]).map((element) => element.attrs.content).join("") + output,
+              "color": color || "white"
+            }
+          ]
+        }
+      };
+      this.ws?.send(JSON.stringify(msgData));
+    } catch (err) {
+      logger.error("[minecraft-sync-msg] 消息发送到WebSocket服务端失败", err);
+    }
+  }
+  async handleRconCommand(session) {
+    const cmd = session.content.replaceAll("&amp;", "§").replaceAll("&", "§").replaceAll(this.config.cmdprefix, "");
+    let response;
+    if (this.config.alluser) {
+      response = await this.sendRconCommand(cmd);
+    } else {
+      if (this.config.superuser.includes(session.userId)) {
+        response = cmd.includes(this.config.cannotCmd) ? "危险命令，禁止使用" : await this.sendRconCommand(cmd);
+        response = response || "该命令无反馈";
+      } else if (cmd.includes(this.config.commonCmd)) {
+        response = this.config.cannotCmd.includes(cmd) ? "危险命令，禁止使用" : await this.sendRconCommand(cmd);
+        response = response || "该命令无反馈";
+      } else {
+        response = "无权使用该命令";
+      }
+    }
+    session.send(response?.replaceAll(/§./g, "") || "");
+  }
+  async sendRconCommand(command) {
+    try {
+      const response = await this.rcon.send(command);
+      return response;
+    } catch (err) {
+      logger.error("发送RCON命令时发生错误:", err);
+      throw err;
+    }
+  }
+  extractAndRemoveColor(input) {
+    const regex = /&(\w+)&/;
+    const match = input.match(regex);
+    if (match) {
+      const color = match[1];
+      const output = input.replace(regex, "");
+      return { output, color };
+    }
+    return { output: input, color: "" };
+  }
+  broadcastToChannels(message) {
+    this.ctx.bots.forEach((bot) => {
+      const channels = this.config.sendToChannel.filter((str) => str.includes(`${bot.platform}`)).map((str) => str.replace(`${bot.platform}:`, ""));
+      bot.broadcast(channels, message, 0);
+    });
+  }
+  setupDisposeHandler() {
+    this.ctx.on("dispose", async () => {
+      this.ctx.registry.delete(mcwss_default);
+      this.ctx.registry.delete(_MinecraftSyncMsg);
+      await new Promise(() => {
+        this.ws?.close();
+        this.ws?.removeAllListeners();
+        this.ws ? this.clearReconnectInterval() : void 0;
+      });
+      this.ws = null;
+      this.isDisposing = true;
+    });
+    this.isDisposing = false;
+  }
+};
+((MinecraftSyncMsg2) => {
+  MinecraftSyncMsg2.Config = import_koishi3.Schema.intersect([
+    wsConf,
+    rconConf,
+    import_koishi3.Schema.object({
+      sendToChannel: import_koishi3.Schema.array(String).description("消息发送到目标群组格式{platform}:{groupId}"),
+      sendprefix: import_koishi3.Schema.string().default(".#").description("消息发送前缀（不可与命令发送前缀相同,可以为空）"),
+      cmdprefix: import_koishi3.Schema.string().default("./").description("命令发送前缀（不可与消息发送前缀相同）"),
+      hideConnect: import_koishi3.Schema.boolean().default(true).description("关闭连接成功/失败提示"),
+      locale: import_koishi3.Schema.union(["zh-CN", "en-US"]).default("zh-CN").description("本地化语言选择,zh_CN为中文,en-US为英文")
+    }).description("基础配置")
+  ]);
+  MinecraftSyncMsg2.usage = `
+  插件使用详情请看 [v2.x](https://blog.iin0.cn/views/myblog/mc/wskoishitomc.html)  
+  *** 注意 ***  
+  * 命令发送前缀(不能为空)和消息发送前缀(可以为空)不能相同
+  * forge端不支持PlayerCommandPreprocessEvent事件
+  * * 原版端仅支持聊天、加入、离开事件
+  * sendToChannel的格式为{platform}:{groupId},如：\`discord:123456\`
+  * v2.1.0-beta可以通过\`本地化\`自定义对应事件发送格式
+    - action节点的{0}是玩家名称{1}是消息
+    - message节点中的{0}是平台{1}是用户名
+  `;
+})(MinecraftSyncMsg || (MinecraftSyncMsg = {}));
+var src_default = MinecraftSyncMsg;
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  name
+});

package/lib/mcwss.d.ts

@@ -0,0 +1,31 @@
+import { Context, Schema } from 'koishi';
+import { IncomingMessage } from 'http';
+import { wsConf } from './values';
+declare class mcWss {
+    private conf;
+    private logger;
+    private wss;
+    private ctx;
+    private connectedClients;
+    constructor(ctx: Context, cfg: mcWss.Config);
+    private setupWebSocketHandlers;
+    private setupMessageHandler;
+    verifyHeaders(headers: IncomingMessage['headers']): {
+        valid: boolean;
+        clientOrigin?: string;
+    };
+}
+export declare function extractAndRemoveColor(input: string): {
+    output: string;
+    color: string;
+};
+declare namespace mcWss {
+    interface Config extends wsConf {
+        sendToChannel: string[];
+        sendprefix: string;
+        hideConnect: boolean;
+        locale: string | any;
+    }
+    const Config: Schema<Config>;
+}
+export default mcWss;

package/lib/values.d.ts

@@ -0,0 +1,73 @@
+import { Schema } from 'koishi';
+export declare enum mcEvent {
+    AsyncPlayerChatEvent = 1,
+    PlayerCommandPreprocessEvent = 2,
+    PlayerDeathEvent = 4,
+    PlayerJoinEvent = 8,
+    PlayerQuitEvent = 16,
+    PlayerAchievementEvent = 32
+}
+export interface wsConf {
+    wsServer: boolean | string;
+    wsHost: string;
+    wsPort: number;
+    Token: string;
+    serverName: string;
+    joinMsg: string;
+    event: mcEvent;
+    maxReconnectCount: number;
+    maxReconnectInterval: number;
+}
+export declare const wsConf: Schema<Schemastery.ObjectS<{
+    wsServer: Schema<"客户端" | "服务端", "客户端" | "服务端">;
+    wsHost: Schema<string, string>;
+    wsPort: Schema<number, number>;
+    Token: Schema<string, string>;
+    serverName: Schema<string, string>;
+    joinMsg: Schema<string, string>;
+    event: Schema<number | readonly ("AsyncPlayerChatEvent" | "PlayerCommandPreprocessEvent" | "PlayerDeathEvent" | "PlayerJoinEvent" | "PlayerQuitEvent" | "PlayerAchievementEvent")[], number>;
+    maxReconnectCount: Schema<number, number>;
+    maxReconnectInterval: Schema<number, number>;
+}>, Schemastery.ObjectT<{
+    wsServer: Schema<"客户端" | "服务端", "客户端" | "服务端">;
+    wsHost: Schema<string, string>;
+    wsPort: Schema<number, number>;
+    Token: Schema<string, string>;
+    serverName: Schema<string, string>;
+    joinMsg: Schema<string, string>;
+    event: Schema<number | readonly ("AsyncPlayerChatEvent" | "PlayerCommandPreprocessEvent" | "PlayerDeathEvent" | "PlayerJoinEvent" | "PlayerQuitEvent" | "PlayerAchievementEvent")[], number>;
+    maxReconnectCount: Schema<number, number>;
+    maxReconnectInterval: Schema<number, number>;
+}>>;
+export interface rconConf {
+    rconEnable: boolean;
+    rconServerHost: string;
+    rconServerPort: number;
+    rconPassword: string;
+    alluser: boolean;
+    superuser: string[];
+    commonCmd: string[];
+    cannotCmd: string[];
+}
+export declare const rconConf: Schema<Schemastery.ObjectS<{
+    rconEnable: Schema<boolean, boolean>;
+    rconServerHost: Schema<string, string>;
+    rconServerPort: Schema<number, number>;
+    rconPassword: Schema<string, string>;
+    alluser: Schema<boolean, boolean>;
+    superuser: Schema<string[], string[]>;
+    commonCmd: Schema<string[], string[]>;
+    cannotCmd: Schema<string[], string[]>;
+}>, Schemastery.ObjectT<{
+    rconEnable: Schema<boolean, boolean>;
+    rconServerHost: Schema<string, string>;
+    rconServerPort: Schema<number, number>;
+    rconPassword: Schema<string, string>;
+    alluser: Schema<boolean, boolean>;
+    superuser: Schema<string[], string[]>;
+    commonCmd: Schema<string[], string[]>;
+    cannotCmd: Schema<string[], string[]>;
+}>>;
+export declare const eventList: string[];
+export declare function getSubscribedEvents(binaryInput: number): string[];
+export declare function getListeningEvent(input: string | string[]): string;

package/package.json

@@ -0,0 +1,42 @@
+{
+  "name": "@arr0wing/koishi-plugin-minecraft-sync-msg",
+  "description": "搭配鹊桥v0.3.x的mc消息互联插件 (更新前请停止插件)",
+  "version": "3.0.2",
+  "main": "lib/index.js",
+  "typings": "lib/index.d.ts",
+  "homepage": "https://blog.iin0.cn/views/myblog/mc/koishiandmc.html",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/Twiyin0/koishi-plugin-minecraft-sync-msg.git"
+  },
+  "contributors": [
+    "Twiyin0 <twiyin0@outlook.com>"
+  ],
+  "koishi": {
+    "browser": true,
+    "description": {
+      "en": "A simple websocket communication for MC message interconnection (please stop the plugin before updating)",
+      "zh": "使用鹊桥插件/MOD桥接的Websocket消息互联插件(更新前请停止插件)"
+    }
+  },
+  "files": [
+    "lib",
+    "dist"
+  ],
+  "license": "MIT",
+  "keywords": [
+    "chatbot",
+    "koishi",
+    "plugin",
+    "minecraft",
+    "mc互联",
+    "mc"
+  ],
+  "peerDependencies": {
+    "koishi": "^4.14.0"
+  },
+  "dependencies": {
+    "rcon-client": "^4.2.5",
+    "ws": "^8.18.2"
+  }
+}

package/readme.md

@@ -0,0 +1,194 @@
+# koishi-plugin-minecraft-sync-msg
+
+[![npm](https://img.shields.io/npm/v/koishi-plugin-minecraft-sync-msg?style=flat-square)](https://www.npmjs.com/package/koishi-plugin-minecraft-sync-msg)
+
+`v2.x` mc插件已更换为 [鹊桥](https://github.com/17TheWord/QueQiao) 同时支持插件服与MOD服
+`v1.x` mc插件已停止维护，但可以继续使用 [chatSocketServer-spigot](https://github.com/Twiyin0/chatSocketServer-spigot) 仅支持插件服(1.13~1.21)
+使用详情查看  
+* [音铃的博客(v2.x)](https://blog.iin0.cn/views/myblog/mc/wskoishitomc.html)
+* [音铃的博客(v1.x)](https://blog.iin0.cn/views/myblog/mc/koishiandmc.html)
+
+**注意**  
+rcon并非完全跟控制台一样所有命令都会有反馈
+
+# CHANGELOG
+## v3.0.2
+### 新增
+* 新增连接消息相关本地化（不包含logger）
+`connectedToWS`连上WS发送的消息（兼容WSserver）  
+`disconnectedFromWS`断开WS发送的消息（兼容WSserver）  
+`connectionErrorWS`WS连接出错发送的消息（兼容WSserver）  
+* 对于WSserver的用户而言消息发送未完全本地化，因为WSclient和WSserver的处理方式不兼容同一套本地化，后续会想办法分开
+
+## v3.0.1
+### 修改
+* 修改了本地化节点`minecraft-sync-msg.message.MCReceivePrefix`,{0}为聊天平台，{1}为平台用户名，{2}为用户id（为了区分相同用户名）
+
+## v3.0.0
+### 注意
+**此版本后需要配合鹊桥v0.3.x才能正常使用**
+### 新增
+* 新增成就上报，但是没有做本地化 **该事件暂不建议在koishi端订阅**
+* 新增执行命令返回，但是这个所有命令都会返回，需要在鹊桥端优化 **该事件暂不建议在koishi端订阅**
+### 修复
+* 修复了插件重载或重启后整个koishi重启的问题
+
+## v3.0.0-beta.2
+### 注意
+**此版本后需要配合鹊桥v0.3.x才能正常使用**
+### 修复
+* 修复了mc消息无法发送到群聊的问题
+* 优化了重启无限重连的问题
+
+## v3.0.0-beta.1
+### 注意
+**此版本后需要配合鹊桥v0.3.x才能正常使用**
+### 修复
+* 修复RCON命令发送逻辑，感谢大佬[GoFightNow](https://github.com/GoFightNow)
+
+## v2.1.0-beta.2
+### 注意
+**此版本后需要配合鹊桥v0.3.x才能正常使用**
+### 修复
+* 修复消息发送api，感谢大佬[@ajchen02](https://github.com/ajchen02)
+* 优化插件重启后重复链接的bug
+
+## v2.1.0-beta.1
+### 修复
+* 修复图片发消息至Minecraft时会有报错
+* 修复订阅事件不生效的BUG
+
+## v2.1.0-beta
+### 新增
+* 新增了本地化，现在可以对事件发送消息进行自定义了
+* 新增插件提示，有些需要注意的地方强调了一下
+
+### 修改
+* 修改了mc发送到平台时的限制（之前限制了语音和视频）
+
+## v2.0.8
+### 优化
+* 简化at元素
+* 修复RCON禁止的指令不生效
+
+## v2.0.7
+### 优化
+* 简化一些消息元素
+* 作为服务端使用时支持[chatImage](https://github.com/kitUIN/ChatImage) MOD
+
+## v2.0.6
+### 修复
+* 修复了作为服务端时koishi消息无响应的问题
+* 修复服务端部分类型消息无处理的问题
+
+## v2.0.5
+### 修复
+* 修复了作为服务端时koishi插件钩子报错的问题
+
+## v2.0.4
+### 修复
+* 修复了一下重连导致多个客户端连接的问题
+* 重构了我的垢使代码
+
+## v2.0.4-beta
+### 修复
+* 修复了一下重连导致多个客户端连接的问题
+
+## v2.0.3
+### 更新
+感谢[@17TheWord](https://github.com/17TheWord)大佬的支持
+* 映射了NeoForge的事件，感谢[@17TheWord](https://github.com/17TheWord)大佬的PR
+
+## v2.0.2
+### 修复
+* 修复重连无法接收消息的问题（log可能会跳多次重连，但这些都不重要，mc的消息只会发送一条）
+### 新增
+对使用[chatImage](https://github.com/kitUIN/ChatImage) MOD的用户进行了一些玩法优化
+
+## v2.0.1
+### 修复
+* 修复v端无法使用的问题
+* 修复无法重连，或者重连任继续重连的问题
+
+## v2.0.0
+经本人测试该插件整体趋向稳定，可以作为正式版发布，非常感谢koishi开发群各位大佬的支持以及各位用户的反馈
+### 更新
+* 已支持koishi作为ws服务端给鹊桥连接
+* 加入了原版端的聊天、加入以及离开的事件的映射
+### 修复
+* 修复了ws作为客户端无法重连的问题
+
+## v2.0.0-beta.5
+### 修复
+* 删除debug的命令，防止误操作
+
+## v2.0.0-beta.4
+### 修复
+* 修复事件无法正常订阅的问题
+
+## v2.0.0-beta.3
+### 修复
+* 修复开启插件会报错`TypeError: input is not iterable`的问题
+
+## v2.0.0-beta.2
+### 更新
+* 由于fabric与forge的监听事件与spigot不同，因此对其进行了映射，不过需要注意的是`forge`不支持`PlayerCommandPreprocessEvent`事件，即使订阅了该事件也无法监听
+
+## v2.0.0-beta.1
+教程更新为[v2.0](https://twiyin0.github.io/blogs/myblog/mc/wskoishitomc.html)
+### 更新
+* 更新了使用的协议，使用Websocket协议连接mc服务器
+* mc服务端插件更换为[鹊桥](https://github.com/17TheWord/QueQiao)支持插件服与MOD服
+### 优化
+* 优化了配置项的排列
+
+## v1.1.0
+### 新增
+* 新增配置项，可以配置是否使用socket发送消息（关闭此项可以仅用RCON）
+### 修复
+* 修复插件重载配置后进行多次连接的问题（每次重载都能重新连接socket啦）
+
+## v1.0.2
+### 新增
+* 为了适配mc插件端新增token配置项，用于验证身份，如果你的插件版本还没更新，这个配置项可以留空
+
+## v1.0.0
+### 修改
+* 开放消息发送前缀与命令发送前缀修改配置项
+* 转为正式版(ver 1.0.0， 出bug的概率小)
+
+## v0.3.0
+### 修复
+* 修复机器人只能广播一次消息的问题，非常感谢开发群的各位大佬
+### 修改
+* 将RCON密码配置项改为不看见格式
+
+## v0.2.1
+### 修复
+* 加入配置项`toGBK`可以选择是否将消息转为GBK格式
+* 目前支持`GBK`与`UTF8`两种格式接收mc服务器的聊天消息
+
+## v0.2.0
+### 更新
+* 加入新的配置项`chatOnly`开启则只接收聊天消息
+* (如果你的chatSocketServer版本为v1.0.1)群友发送tps/TPS/服务器信息/server_info触发mc插件对应响应
+### 修复
+* 修改了`无响应`为`无反馈`,实际上是有相应的，只是没有反馈
+* 聊天前缀、命令前缀只能在对应频道（群聊）或者koishi沙盒触发
+### 一点小建议
+* 由于RCON不像控制这么灵活，因此rcon发送的命令简易在前面加上插件名（父级）
+示例:  
+/tps ==> /spigot:tps  
+/status ==> /cmi:cmi status
+
+## v0.1.2
+### 修复
+* 修复超管不启用的小问题
+
+## v0.1.1
+### 修改
+* 将replace改成replaceAll替换全局
+
+## v0.1.0
+### 发布
+插件发布啦！