koishi-plugin-gl-bot 0.0.7 → 0.0.9

package/lib/queQiao/mcwss.js

@@ -0,0 +1,260 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.extractAndRemoveColor = extractAndRemoveColor;
+const koishi_1 = require("koishi");
+const ws_1 = require("ws");
+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');
+class McWss {
+    constructor(ctx, cfg) {
+        this.logger = new koishi_1.Logger('Minecraft-sync-msg-Wss');
+        this.connectedClients = new Set();
+        this.conf = cfg;
+        this.ctx = ctx;
+        ctx.on('ready', async () => {
+            this.ctx.i18n.define('zh-CN', zhCN);
+            this.ctx.i18n.define('en-US', enUS);
+            this.wss = new ws_1.WebSocketServer({ host: cfg.wsHost, port: cfg.wsPort });
+            ctx.logger.info(`Websocket服务器已启动 ws://${cfg.wsHost}:${cfg.wsPort}`);
+            // 设置 WebSocket 连接处理
+            this.setupWebSocketHandlers();
+        });
+        // 设置消息处理（只需要一次）
+        this.setupMessageHandler();
+        ctx.on('dispose', async () => {
+            if (this.wss) {
+                this.wss.close();
+            }
+            this.connectedClients.clear();
+        });
+    }
+    setupWebSocketHandlers() {
+        this.wss.on('connection', (ws, req) => {
+            const 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;
+            // 验证 Token
+            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, 'Websocket客户端连接成功!', 0);
+                    }
+                });
+            }
+            // 添加到连接的客户端集合
+            this.connectedClients.add(ws);
+            // 当收到客户端消息时触发
+            ws.on('message', async (buffer) => {
+                this.ctx.logger.info(`收到来自客户端的消息: ${buffer.toString()}`);
+                const data = JSON.parse(buffer.toString());
+                const eventName = data.event_name
+                    ? (0, values_1.getListeningEvent)(data.event_name)
+                    : '';
+                if (!(0, values_1.getSubscribedEvents)(this.conf.event).includes(eventName)) {
+                    return;
+                }
+                // let sendMsg = getSubscribedEvents(this.conf.event).includes(eventName)? `[${data.server_name}](${eventTrans[eventName].name}) ${eventTrans[eventName].action? data.player?.nickname+' ':''}${(eventTrans[eventName].action? eventTrans[eventName].action+' ':'')}${data.message? data.message:''}`:''
+                // let sendMsg:any = h.unescape(sendMsg).replaceAll('&amp;','&').replaceAll(/<\/?template>/gi,'').replaceAll(/§./g,'')
+                let sendMsg = koishi_1.h
+                    .unescape(data.message ? data.message : '')
+                    .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}" />`);
+                }
+                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}:`, ''));
+                        if (sendMsg) {
+                            bot.broadcast(channels, sendMsg, 0);
+                        }
+                    });
+                }
+            });
+            ws.on('error', err => {
+                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);
+                    });
+                }
+                this.ctx.logger.error('与Websocket客户端断通信时发生错误!' + 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, '与Websocket客户端断开连接!', 0);
+                    });
+                }
+                this.ctx.logger.error('非正常与Websocket客户端断开连接!');
+            });
+        });
+    }
+    setupMessageHandler() {
+        let imgurl = '<unknown image url>';
+        this.ctx.on('message', async (session) => {
+            // this.ctx.logger.info(`收到聊天消息: ${session.content} 来自 ${session.platform}:${session.channelId}`);
+            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;
+            }
+            if (this.conf.sendToChannel.includes(`${session.platform}:${session.channelId}`) ||
+                session.platform === 'sandbox') {
+                if (session.content.startsWith(this.conf.sendprefix) &&
+                    session.content !== this.conf.sendprefix) {
+                    const 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, `@[${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}]`);
+                    if (this.connectedClients.size > 0) {
+                        const 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, 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 === ws_1.WebSocket.OPEN) {
+                                try {
+                                    client.send(JSON.stringify(msgData));
+                                    sent = true;
+                                }
+                                catch (err) {
+                                    this.ctx.logger.error(`聊天消息发送到WebSocket客户端失败: ${err}`);
+                                }
+                            }
+                        });
+                        if (!sent) {
+                            session.send('发送失败! 没有可用的WebSocket连接。');
+                        }
+                    }
+                    else {
+                        session.send('发送失败! 没有可用的WebSocket连接。');
+                    }
+                }
+            }
+        });
+    }
+    verifyHeaders(headers) {
+        const authHeader = headers['authorization'];
+        const selfNameHeader = headers['x-self-name'];
+        const clientOriginHeader = headers['x-client-origin'];
+        // 验证 Token
+        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 };
+        }
+        // 验证 x-self-name
+        if (!selfNameHeader) {
+            this.logger.error('Missing x-self-name header');
+            return { valid: false };
+        }
+        const decodedSelfName = decodeURIComponent(selfNameHeader);
+        if (decodedSelfName !== this.conf.serverName) {
+            this.logger.error('Invalid x-self-name');
+            return { valid: false };
+        }
+        // 获取 x-client-origin
+        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: '' };
+}
+(function (McWss) {
+    McWss.Config = koishi_1.Schema.intersect([
+        values_1.WsConf,
+        koishi_1.Schema.object({
+            sendToChannel: koishi_1.Schema.array(String).description('消息发送到目标群组格式{paltform}:{groupId}'),
+            sendprefix: 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('基础配置'),
+    ]);
+})(McWss || (McWss = {}));
+exports.default = McWss;

package/lib/queQiao/values.d.ts

@@ -0,0 +1,72 @@
+import { Schema } from 'koishi';
+export declare enum mcEvent {
+    AsyncPlayerChatEvent = 1,
+    PlayerCommandPreprocessEvent = 2,
+    PlayerDeathEvent = 4,
+    PlayerJoinEvent = 8,
+    PlayerQuitEvent = 16
+}
+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")[], 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")[], 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/lib/queQiao/values.js

@@ -0,0 +1,155 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.eventList = exports.RconConf = exports.WsConf = exports.mcEvent = void 0;
+exports.getSubscribedEvents = getSubscribedEvents;
+exports.getListeningEvent = getListeningEvent;
+const koishi_1 = require("koishi");
+// 放在主逻辑里面很碍眼的东西
+var mcEvent;
+(function (mcEvent) {
+    mcEvent[mcEvent["AsyncPlayerChatEvent"] = 1] = "AsyncPlayerChatEvent";
+    mcEvent[mcEvent["PlayerCommandPreprocessEvent"] = 2] = "PlayerCommandPreprocessEvent";
+    mcEvent[mcEvent["PlayerDeathEvent"] = 4] = "PlayerDeathEvent";
+    mcEvent[mcEvent["PlayerJoinEvent"] = 8] = "PlayerJoinEvent";
+    mcEvent[mcEvent["PlayerQuitEvent"] = 16] = "PlayerQuitEvent";
+})(mcEvent || (exports.mcEvent = mcEvent = {}));
+exports.WsConf = koishi_1.Schema.object({
+    wsServer: koishi_1.Schema.union(['客户端', '服务端'])
+        .default('客户端')
+        .description('Websocket端选择'),
+    wsHost: koishi_1.Schema.string()
+        .default('127.0.0.1')
+        .description('websocket服务器的地址(服务器监听地址)'),
+    wsPort: koishi_1.Schema.number()
+        .default(8080)
+        .description('websocket服务器的端口(服务器监听端口)'),
+    Token: koishi_1.Schema.string().description('websocket服务器的验证Token'),
+    serverName: koishi_1.Schema.string().description('鹊桥配置文件中对应的server_name'),
+    joinMsg: koishi_1.Schema.string()
+        .default('[客户端] 连接成功！')
+        .description('连接服务的成功时发送的消息(&颜色单词&可以设置颜色)'),
+    event: koishi_1.Schema.bitset(mcEvent).description('选择需要监听的事件'),
+    maxReconnectCount: koishi_1.Schema.number()
+        .default(20)
+        .description('[仅客户端生效]客户端最大重连次数'),
+    maxReconnectInterval: koishi_1.Schema.number()
+        .default(60000)
+        .description('[仅客户端生效]客户端单次重连时间(ms)'),
+})
+    .collapse()
+    .description('Websocket配置');
+exports.RconConf = koishi_1.Schema.object({
+    rconEnable: koishi_1.Schema.boolean().default(true).description('开启RCON功能'),
+    rconServerHost: koishi_1.Schema.string()
+        .default('127.0.0.1')
+        .description('rcon服务器地址'),
+    rconServerPort: koishi_1.Schema.number()
+        .default(25575)
+        .description('rcon服务器地址端口'),
+    rconPassword: koishi_1.Schema.string()
+        .role('secret')
+        .description('rcon服务器的密码(推荐设置)'),
+    alluser: koishi_1.Schema.boolean()
+        .default(false)
+        .description('所有用户可用(开启后下面的配置失效)'),
+    superuser: koishi_1.Schema.array(String).description('超级用户的ID，可以使用RCON所有命令'),
+    commonCmd: koishi_1.Schema.array(String)
+        .default(['list', 'spigot:tps'])
+        .description('普通用户可以使用的命令'),
+    cannotCmd: koishi_1.Schema.array(String)
+        .default(['restart', 'stop'])
+        .description('不能使用的命令'),
+})
+    .collapse()
+    .description('RCON配置');
+exports.eventList = [
+    'AsyncPlayerChatEvent',
+    'PlayerCommandPreprocessEvent',
+    'PlayerDeathEvent',
+    'PlayerJoinEvent',
+    'PlayerQuitEvent',
+];
+// export const eventTrans = {
+//     AsyncPlayerChatEvent: {
+//         name: "聊天信息",
+//         action: '说'
+//     },
+//     PlayerCommandPreprocessEvent: {
+//         name: "玩家命令执行事件",
+//         action: "发送了命令"
+//     },
+//     PlayerDeathEvent: {
+//         name: "玩家死亡事件",
+//         action: null
+//     },
+//     PlayerJoinEvent: {
+//         name: "玩家加入事件",
+//         action: "加入了服务器"
+//     },
+//     PlayerQuitEvent: {
+//         name: "玩家退出事件",
+//         action: "离开了服务器"
+//     }
+// }
+// 事件映射
+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;
+}
+// 事件映射变量
+const 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', // Spigot 与 Forge 同名
+    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',
+};
+// 监听映射
+function getListeningEvent(input) {
+    if (typeof input === 'string') {
+        input = [input];
+    }
+    const uniqueEvents = new Set();
+    for (const event of input) {
+        if (eventMap[event]) {
+            uniqueEvents.add(eventMap[event]);
+        }
+    }
+    // 如果有多个映射结果，返回第一个
+    return Array.from(uniqueEvents)[0];
+}

package/lib/utils/game.mc.d.ts

@@ -0,0 +1,4 @@
+/**
+ * 清洗数据防止QQ脏数据发送到游戏内
+ */
+export declare const clearSessionContentToMcMessage: (content: string) => string;

package/lib/utils/game.mc.js

@@ -0,0 +1,29 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.clearSessionContentToMcMessage = void 0;
+const koishi_1 = require("koishi");
+/**
+ * 清洗数据防止QQ脏数据发送到游戏内
+ */
+const clearSessionContentToMcMessage = (content) => {
+    // let imgurl = '<unknown image url>';
+    if (content.includes('<img')
+    // &&
+    // h.select(content, "img")[0]?.type === "img" &&
+    // h.select(content, "img")[0]?.attrs?.src
+    ) {
+        // imgurl = h.select(content, "img")[0].attrs.src;
+        return content.replaceAll(/<img.*\/>/gi, `[图片]`);
+    }
+    return (content
+        .replaceAll('&amp;', '&')
+        .replaceAll(/<\/?template>/gi, '')
+        .replaceAll(/<json.*\/>/gi, '<json消息>')
+        .replaceAll(/<video.*\/>/gi, '<视频消息>')
+        .replaceAll(/<audio.*\/>/gi, '<音频消息>')
+        // .replaceAll(/<img.*\/>/gi, `[[CICode,url=${imgurl}]]`)
+        .replaceAll(/<at.*\/>/gi, `@[${koishi_1.h.select(content, 'at')[0]?.attrs?.name
+        ? koishi_1.h.select(content, 'at')[0]?.attrs?.name
+        : koishi_1.h.select(content, 'at')[0]?.attrs?.id}]`));
+};
+exports.clearSessionContentToMcMessage = clearSessionContentToMcMessage;

package/lib/utils/index.d.ts

@@ -0,0 +1 @@
+export * from './game.mc';

package/lib/utils/index.js

@@ -0,0 +1,17 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./game.mc"), exports);

package/package.json

@@ -1,17 +1,20 @@
 {
   "name": "koishi-plugin-gl-bot",
   "description": "GleamSlime Koishi Rebot Plugins",
-  "version": "0.0.7",
-  "main": "src/index.ts",
+  "version": "0.0.9",
+  "main": "lib/index.js",
   "typings": "lib/index.d.ts",
   "contributors": [
     "GleamSlime <gleamslime@163.com>"
   ],
   "scripts": {
-    "build": "tsc -p ."
+    "format": "prettier --write .",
+    "lint": "eslint .",
+    "fl": "prettier --write . && eslint . --fix",
+    "build:console": "koishi-console build",
+    "build": "tsc -p tsconfig.test.json && cp -r src/queQiao/locale lib/queQiao/ || true"
   },
   "files": [
-    "src",
     "lib",
     "dist"
   ],
@@ -25,6 +28,7 @@
   ],
   "devDependencies": {
     "@koishijs/client": "^5.30.11",
+    "@types/lodash-es": "^4",
     "typescript": "^5.9.3"
   },
   "peerDependencies": {
@@ -35,5 +39,11 @@
     "description": {
       "zh": "GleamSlime Koishi 兽耳咖啡厅插件"
     }
+  },
+  "dependencies": {
+    "lodash-es": "^4.17.22",
+    "rcon-client": "^4.2.5",
+    "socket.io-client": "^4.8.2",
+    "ws": "^8.18.3"
   }
 }

package/src/index.ts

@@ -1,20 +0,0 @@
-import { Context, Schema } from "koishi";
-import { resolve } from "path";
-import {} from "@koishijs/plugin-console";
-
-export const name = "gl-bot";
-
-export interface Config {}
-
-export const Config: Schema<Config> = Schema.object({});
-
-export function apply(ctx: Context) {
-  ctx.inject(["console"], (ctx) => {
-    ctx.on("message", (session) => {
-      console.log(session.content);
-      if (session.content === "天王盖地虎") {
-        session.send("宝塔镇河妖");
-      }
-    });
-  });
-}