koishi-plugin-gl-bot 0.0.8 → 0.0.10

package/lib/queQiao/index.js

@@ -0,0 +1,437 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.name = void 0;
+const koishi_1 = require("koishi");
+const lodash_1 = require("lodash");
+const rcon_client_1 = require("rcon-client");
+const ws_1 = require("ws");
+const constants_1 = require("../constants");
+const utils_1 = require("../utils");
+const mcwss_1 = __importDefault(require("./mcwss"));
+const values_1 = require("./values");
+// import zhCN from "./locale/zh-CN.json";
+// import enUS from "./locale/en-US.json";
+const zhCN = require('./locale/zh-CN.json');
+const enUS = require('./locale/en-US.json');
+exports.name = 'minecraft-sync-msg';
+const logger = new koishi_1.Logger('minecraft-sync-msg');
+class MinecraftSyncMsg {
+    constructor(ctx, config) {
+        this.ctx = ctx;
+        this.config = config;
+        this.isDisposing = false;
+        this.reconnectAttempts = 0;
+        this.reconnectIntervalId = null;
+        this.initialize();
+    }
+    initialize() {
+        this.setupRcon();
+        this.setupWebSocket();
+        this.setupWatchChannel();
+        this.setupMessageHandler();
+        this.setupDisposeHandler();
+        this.ctx.i18n.define('zh-CN', zhCN);
+        this.ctx.i18n.define('en-US', enUS);
+    }
+    setupRcon() {
+        if (!this.config.rconEnable) {
+            return;
+        }
+        this.rcon = new rcon_client_1.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.plFork = this.ctx.plugin(mcwss_1.default, this.config);
+            // this.plFork = new McWss(this.ctx, this.config);
+            return;
+        }
+        else {
+            this.connectWebSocket();
+        }
+    }
+    connectWebSocket() {
+        const headers = {
+            'x-self-name': encodeURIComponent(this.config.serverName),
+            Authorization: `Bearer ${this.config.Token}`,
+            'x-client-origin': 'NOTkoishi',
+        };
+        this.ws = new ws_1.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('成功连上websocket服务器');
+        if (!this.config.hideConnect) {
+            this.broadcastToChannels('Websocket服务器连接成功!');
+        }
+        if (!constants_1.IS_DEV) {
+            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) {
+        // Convert RawData to string
+        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 ? (0, values_1.getListeningEvent)(data.event_name) : '';
+        if (eventName === 'PlayerCommandPreprocessEvent') {
+            return;
+        }
+        // console.log(data);
+        // if (!getSubscribedEvents(this.config.event).includes(eventName)) return;
+        // let sendMsg = `[${data.server_name}](${eventTrans[eventName].name}) ${
+        //   eventTrans[eventName].action ? data.player?.nickname + ' ' : ''
+        // }${
+        //   eventTrans[eventName].action ? eventTrans[eventName].action + ' ' : ''
+        // }${
+        //   data.message ? data.message : ''
+        // }`
+        let sendMsg = koishi_1.h
+            .unescape(data.message ? data.message : '')
+            .replaceAll('&', '&')
+            .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}" />`);
+        }
+        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(sendMsg);
+        }
+    }
+    handleWsClose() {
+        if (this.isDisposing) {
+            return;
+        }
+        if (!this.config.hideConnect) {
+            this.broadcastToChannels('与Websocket服务器断开连接!');
+        }
+        logger.error('非正常与Websocket服务器断开连接!');
+        this.ws = undefined;
+        this.reconnectWebSocket();
+    }
+    handleWsError(err) {
+        if (this.isDisposing) {
+            return;
+        }
+        if (!this.config.hideConnect) {
+            this.broadcastToChannels('与Websocket服务器断通信时发生错误!');
+        }
+        logger.error('与Websocket服务器断通信时发生错误:', err);
+    }
+    setupWatchChannel() {
+        this.ctx.on('message', async (session) => {
+            this.config.watchChannel.forEach(channel => {
+                const [platform, channelId] = channel.split(':');
+                if (platform === session.platform && channelId === session.channelId) {
+                    const msgData = {
+                        api: 'broadcast',
+                        data: {
+                            message: [
+                                {
+                                    text: `[${session.event._data.group_name}] <${session.username}> ${(0, utils_1.clearSessionContentToMcMessage)(session.content)}`,
+                                    color: this.extractAndRemoveColor(this.config.joinMsg).color ||
+                                        'white',
+                                },
+                            ],
+                        },
+                    };
+                    this.ws?.send(JSON.stringify(msgData));
+                }
+            });
+        });
+    }
+    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': encodeURIComponent(this.config.serverName),
+                    Authorization: `Bearer ${this.config.Token}`,
+                    'x-client-origin': 'koishi',
+                };
+                const ws = new ws_1.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') &&
+            koishi_1.h.select(session.content, 'img')[0]?.type === 'img' &&
+            koishi_1.h.select(session.content, 'img')[0]?.attrs?.src) {
+            imgurl = koishi_1.h.select(session.content, 'img')[0].attrs.src;
+        }
+        const 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, `@[${koishi_1.h.select(session.content, 'at')[0]?.attrs?.name
+            ? koishi_1.h.select(session.content, 'at')[0]?.attrs?.name
+            : koishi_1.h.select(session.content, 'at')[0]?.attrs?.id}]`);
+        try {
+            const { output, color } = this.extractAndRemoveColor(msg);
+            const msgData = {
+                api: 'broadcast',
+                data: {
+                    message: [
+                        {
+                            // text: `(${session.platform})[${session.event.user.name}] ` + output,
+                            text: this.ctx.i18n
+                                .render([this.config.locale ? this.config.locale : 'zh-CN'], ['minecraft-sync-msg.message.MCReceivePrefix'], [session.platform, session.userId])
+                                .map(element => element.attrs.content)
+                                .join('') + output,
+                            color: color || 'white',
+                        },
+                    ],
+                },
+            };
+            this.ws?.send(JSON.stringify(msgData));
+            this.ctx.logger.info(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}:`, ''));
+            console.log(this.config.sendToChannel);
+            if (process.env.NODE_ENV === 'development') {
+                logger.info((0, lodash_1.isString)(message)
+                    ? message
+                    : message.map(el => el.attrs.content).join(''));
+            }
+            bot.broadcast(channels, message, 0);
+        });
+    }
+    setupDisposeHandler() {
+        this.ctx.on('dispose', async () => {
+            this.isDisposing = true;
+            await this.dispose();
+            this.isDisposing = false;
+        });
+    }
+    async dispose() {
+        if (this.plFork) {
+            await this.plFork.dispose();
+        }
+        this.ctx.registry.delete(mcwss_1.default);
+        if (this.ws) {
+            this.ws.removeAllListeners();
+            if (this.ws.readyState === ws_1.WebSocket.OPEN) {
+                this.ws.close();
+            }
+            this.ws = undefined;
+        }
+        this.clearReconnectInterval();
+    }
+}
+(function (MinecraftSyncMsg) {
+    // export interface Config extends WsConf, RconConf {
+    //   sendToChannel: string[];
+    //   sendprefix: string;
+    //   cmdprefix: string;
+    //   hideConnect: boolean;
+    //   locale: string;
+    //   watchChannel: string[];
+    // }
+    MinecraftSyncMsg.Config = koishi_1.Schema.intersect([
+        values_1.WsConf,
+        values_1.RconConf,
+        koishi_1.Schema.object({
+            sendToChannel: koishi_1.Schema.array(String).description('消息发送到目标群组格式{platform}:{groupId}'),
+            watchChannel: koishi_1.Schema.array(String).description('消息观察频道目标群组格式{platform}:{groupId}'),
+            sendprefix: koishi_1.Schema.string()
+                .default('.#')
+                .description('消息发送前缀（不可与命令发送前缀相同,可以为空）'),
+            cmdprefix: koishi_1.Schema.string()
+                .default('./')
+                .description('命令发送前缀（不可与消息发送前缀相同）'),
+            hideConnect: koishi_1.Schema.boolean()
+                .default(true)
+                .description('关闭连接成功/失败提示'),
+            locale: koishi_1.Schema.union(['zh-CN', 'en-US'])
+                .default('zh-CN')
+                .description('本地化语言选择,zh_CN为中文,en-US为英文'),
+        }).description('基础配置'),
+    ]);
+    MinecraftSyncMsg.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 = {}));
+exports.default = MinecraftSyncMsg;

package/lib/queQiao/locale/en-US.json

@@ -0,0 +1 @@
+{"minecraft-sync-msg":{"action":{"PlayerJoinEvent":"[join] Player {0} joined the game","PlayerCommandPreprocessEvent":"[command] Player {0} executed command","PlayerDeathEvent":"[death] Player {0} meet the god","AsyncPlayerChatEvent":"[chat] Player {0} said: {1}","PlayerQuitEvent":"[quit] Player {0} left the game"},"message":{"MCReceivePrefix":"({0})[{1}]"}}}

package/lib/queQiao/locale/en-US.yml

@@ -0,0 +1,9 @@
+minecraft-sync-msg:
+  action:
+    PlayerJoinEvent: '[join] Player {0} joined the game'
+    PlayerCommandPreprocessEvent: '[command] Player {0} executed command'
+    PlayerDeathEvent: '[death] Player {0} meet the god'
+    AsyncPlayerChatEvent: '[chat] Player {0} said: {1}'
+    PlayerQuitEvent: '[quit] Player {0} left the game'
+  message:
+    MCReceivePrefix: '({0})[{1}]'

package/lib/queQiao/locale/zh-CN.json

@@ -0,0 +1 @@
+{"minecraft-sync-msg":{"action":{"PlayerJoinEvent":"[加入]{0} 加入了服务器！","PlayerCommandPreprocessEvent":"[指令]{0} 执行了指令","PlayerDeathEvent":"[死亡]{0} 与山长眠！","AsyncPlayerChatEvent":"[聊天]{0} 说：{1}","PlayerQuitEvent":"[离开]{0} 离开了服务器！"},"message":{"MCReceivePrefix":"({0})[{1}]"}}}

package/lib/queQiao/locale/zh-CN.yml

@@ -0,0 +1,9 @@
+minecraft-sync-msg:
+  action:
+    PlayerJoinEvent: '[加入]{0} 加入了服务器！'
+    PlayerCommandPreprocessEvent: '[指令]{0} 执行了指令'
+    PlayerDeathEvent: '[死亡]{0} 与山长眠！'
+    AsyncPlayerChatEvent: '[聊天]{0} 说：{1}'
+    PlayerQuitEvent: '[离开]{0} 离开了服务器！'
+  message:
+    MCReceivePrefix: '({0})[{1}]'

package/lib/queQiao/mcwss.d.ts

@@ -0,0 +1,61 @@
+import { IncomingMessage } from 'http';
+import { Context, Schema } from 'koishi';
+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<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")[], number>;
+        maxReconnectCount: Schema<number, number>;
+        maxReconnectInterval: Schema<number, number>;
+    }> | Schemastery.ObjectS<{
+        sendToChannel: Schema<string[], string[]>;
+        sendprefix: Schema<string, string>;
+        hideConnect: Schema<boolean, boolean>;
+        locale: Schema<"zh-CN" | "en-US", "zh-CN" | "en-US">;
+    }>, {
+        wsServer: "客户端" | "服务端";
+        wsHost: string;
+        wsPort: number;
+        Token: string;
+        serverName: string;
+        joinMsg: string;
+        event: number;
+        maxReconnectCount: number;
+        maxReconnectInterval: number;
+    } & import("cosmokit").Dict & {
+        sendToChannel: string[];
+        sendprefix: string;
+        hideConnect: boolean;
+        locale: "zh-CN" | "en-US";
+    }>;
+}
+export default McWss;