koishi-plugin-gl-bot 0.0.8 → 0.0.9

package/lib/mcsManager/panel.js

@@ -0,0 +1,121 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MCSManagerPanel = void 0;
+const koishi_1 = require("koishi");
+const lodash_es_1 = require("lodash-es");
+const api_1 = require("./api");
+const constants_1 = require("./constants");
+const instance_1 = require("./instance");
+const ws_1 = require("./ws");
+const logger = new koishi_1.Logger('mcsmanager-panel');
+class MCSManagerPanel {
+    constructor(ctx, config) {
+        this.ctx = ctx;
+        this.config = config;
+        this.isInitialized = false;
+        // 所有远程节点及其实例列表
+        this.remotes = [];
+        // 远程连接Map表
+        this.remoteConnectionsMap = new Map();
+        this.api = new api_1.MCSManagerAPI(ctx.http, config.mcManagerHost);
+        this.initialize();
+    }
+    async initialize() {
+        if (this.isInitialized) {
+            return;
+        }
+        this.isInitialized = true;
+        const { mcManagerUsername, mcManagerPassword } = this.config;
+        await this.api.login(mcManagerUsername, mcManagerPassword);
+        await this.api.getUserInfo();
+        await this.handleRemoteServices();
+        await this.getAvailableRemoteInstance();
+    }
+    // 获取远程服务及其实例列表
+    async handleRemoteServices() {
+        const remoteList = await this.api.getServiceRemoteList();
+        for (const remote of remoteList) {
+            const instanceList = await this.api.getServiceRemoteInstanceList(remote.uuid);
+            this.remotes.push({
+                instances: instanceList.map(item => new instance_1.MCSManagerInstance(this.ctx, this.config, this.api, this, remote, item)),
+                ...remote,
+            });
+        }
+        logger.info(`已获取到 ${this.remotes.length} 个远程节点及其实例 ${this.remotes.reduce((acc, remote) => acc + remote.instances.length, 0)} 个`);
+    }
+    // 遍历所有远程节点 选择正在运行中的实力 建立远程连接
+    getAvailableRemoteInstance() {
+        for (const remote of this.remotes) {
+            for (const instance of remote.instances) {
+                this.createMCSManagerConnection(remote, instance.cfg);
+            }
+        }
+    }
+    // 创建远程连接
+    async createMCSManagerConnection(remote, instance) {
+        if ((0, lodash_es_1.isEqual)(instance.status, constants_1.RemoteInstanceStatusEnum.RUNNING)) {
+            const uuid = instance.instanceUuid;
+            // 已存在的实例且连接中 直接返回
+            if (this.remoteConnectionsMap.has(uuid) &&
+                this.remoteConnectionsMap.get(uuid).connect.connected) {
+                return this.remoteConnectionsMap.get(uuid);
+            }
+            // 上限检测
+            if (this.remoteConnectionsMap.size >=
+                this.config.mcManagerMaxRemoteConnections) {
+                return;
+            }
+            // 试图自动获取认证信息
+            if ((0, koishi_1.isEmpty)(remote.auth)) {
+                const instanceConnectAuth = await this.api.getServiceInstanceConnectAuth(remote.uuid, instance.instanceUuid);
+                remote.auth = instanceConnectAuth;
+            }
+            if (remote.auth) {
+                const ws = new ws_1.MCSManagerWebSocketIO(this.ctx, this.config, this.api, remote, instance, remote.auth);
+                this.remoteConnectionsMap.set(uuid, ws);
+                return ws;
+            }
+            logger.error(`远程实例 ${instance.config.nickname} 缺少连接认证信息，无法建立连接`);
+        }
+    }
+    // 模糊搜索实例 通过 实例名称
+    async searchInstanceByName(instanceName) {
+        const instanceMap = new Map();
+        const keywords = instanceName.length < 10 ? instanceName.split('') : [];
+        for (const remote of this.remotes) {
+            for (const instance of remote.instances) {
+                // 连词搜索
+                if (instance.cfg.config.nickname.includes(instanceName)) {
+                    instanceMap.set(instance.cfg.instanceUuid, {
+                        remote,
+                        instance,
+                        sort: 1,
+                    });
+                }
+                // 分词搜索
+                if (keywords.length) {
+                    // 索引词权重
+                    keywords.forEach(keyword => {
+                        if (instance.cfg.config.nickname.includes(keyword)) {
+                            if (!instanceMap.has(instance.cfg.instanceUuid)) {
+                                instanceMap.set(instance.cfg.instanceUuid, {
+                                    remote,
+                                    instance,
+                                    sort: 1,
+                                });
+                            }
+                            else {
+                                // 已存在则增加权重
+                                const record = instanceMap.get(instance.cfg.instanceUuid);
+                                record.sort += 1;
+                                instanceMap.set(instance.cfg.instanceUuid, record);
+                            }
+                        }
+                    });
+                }
+            }
+        }
+        return Array.from(instanceMap.values()).sort((a, b) => b.sort - a.sort);
+    }
+}
+exports.MCSManagerPanel = MCSManagerPanel;

package/lib/mcsManager/type.d.ts

@@ -0,0 +1,115 @@
+import { RemoteInstanceStatusEnum } from './constants';
+import { MCSManagerInstance } from './instance';
+export interface MCManagerPanelResponse<T> {
+    status: number;
+    data: T;
+    time: number;
+}
+export interface UserInfo {
+    uuid: string;
+    userName: string;
+    loginTime: string;
+    registerTime: string;
+    instances: [];
+    permission: number;
+    apiKey: string;
+    isInit: boolean;
+    opennumberFA: boolean;
+    secret: string;
+    token: string;
+}
+export interface ServiceRemoteItem {
+    uuid: string;
+    ip: string;
+    port: number;
+    prefix: string;
+    available: boolean;
+    remarks: string;
+}
+export interface ServiceRemoteItemCustom extends ServiceRemoteItem {
+    instances: MCSManagerInstance[];
+    auth?: ServiceInstanceConnectAuth;
+}
+export interface ServiceRemoteInstanceItem {
+    instanceUuid: string;
+    started: number;
+    status: RemoteInstanceStatusEnum;
+    config: ServiceRemoteInstanceItemConfig;
+    info: ServiceRemoteInstanceInfo;
+}
+export interface ServiceRemoteInstanceItemConfig {
+    nickname: string;
+    startCommand: string;
+    stopCommand: string;
+    cwd: string;
+    ie: string;
+    oe: string;
+    createDatetime: number;
+    lastDatetime: number;
+    type: string;
+    tag: [];
+    endTime: number;
+    fileCode: string;
+    processType: string;
+    updateCommand: string;
+    crlf: number;
+    category: number;
+    enableRcon: false;
+    rconPassword: string;
+    rconPort: number;
+    rconIp: string;
+    actionCommandList: [];
+    terminalOption: {
+        haveColor: false;
+        pty: true;
+        ptyWindowCol: number;
+        ptyWindowRow: number;
+    };
+    eventTask: {
+        autoStart: false;
+        autoRestart: false;
+        ignore: false;
+    };
+    docker: {
+        containerName: string;
+        image: string;
+        ports: [];
+        extraVolumes: [];
+        memory: number;
+        networkMode: string;
+        networkAliases: [];
+        cpusetCpus: string;
+        cpuUsage: number;
+        maxSpace: number;
+        io: number;
+        network: number;
+        workingDir: string;
+        env: [];
+        changeWorkdir: false;
+    };
+    pingConfig: {
+        ip: string;
+        port: number;
+        type: number;
+    };
+    extraServiceConfig: {
+        openFrpTunnelId: string;
+        openFrpToken: string;
+        isOpenFrp: false;
+    };
+}
+export interface ServiceRemoteInstanceInfo {
+    mcPingOnline: true;
+    currentPlayers: number;
+    maxPlayers: number;
+    version: string;
+    fileLock: number;
+    playersChart: [];
+    openFrpStatus: false;
+    latency: number;
+}
+export interface ServiceInstanceConnectAuth {
+    password: string;
+    addr: string;
+    prefix: string;
+}

package/lib/mcsManager/type.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/lib/mcsManager/ws.d.ts

@@ -0,0 +1,24 @@
+import * as io from 'socket.io-client';
+import { Context } from 'koishi';
+import { GLBotConfigType } from '../gl';
+import { MCSManagerAPI } from './api';
+import { ServiceInstanceConnectAuth, ServiceRemoteInstanceItem, ServiceRemoteItemCustom } from './type';
+export declare class MCSManagerWebSocketIO {
+    private readonly ctx;
+    private readonly config;
+    private readonly api;
+    private remote;
+    private instance;
+    private auth;
+    connect: io.Socket;
+    isAuthenticated: boolean;
+    constructor(ctx: Context, config: GLBotConfigType, api: MCSManagerAPI, remote: ServiceRemoteItemCustom, instance: ServiceRemoteInstanceItem, auth: ServiceInstanceConnectAuth);
+    initialize(): void;
+    sendCommand(command: string): void;
+    private bindEvents;
+    private onConnect;
+    private onDisconnect;
+    private onReconnect;
+    private onConnectError;
+    authenticate(): void;
+}

package/lib/mcsManager/ws.js

@@ -0,0 +1,116 @@
+"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 __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MCSManagerWebSocketIO = void 0;
+const io = __importStar(require("socket.io-client"));
+const koishi_1 = require("koishi");
+const lodash_es_1 = require("lodash-es");
+const logger = new koishi_1.Logger('mcsmanager-ws');
+class MCSManagerWebSocketIO {
+    constructor(ctx, config, api, remote, instance, auth) {
+        this.ctx = ctx;
+        this.config = config;
+        this.api = api;
+        this.remote = remote;
+        this.instance = instance;
+        this.auth = auth;
+        // 是否已认证通过
+        this.isAuthenticated = false;
+        this.initialize();
+    }
+    initialize() {
+        if (this.connect) {
+            this.connect.close();
+        }
+        this.connect = io.connect(this.config.mcManagerWs, {
+            multiplex: false,
+            reconnectionDelayMax: 1000 * 3,
+            timeout: 1000 * 3,
+            reconnection: true,
+            reconnectionAttempts: 2000,
+        });
+        this.bindEvents();
+        logger.info(`正在连接到 MCSManager 实例服务器 [${this.remote.remarks}] - ${this.instance.config.nickname} ...`);
+    }
+    // 发送MC指令到远程实例
+    sendCommand(command) {
+        this.connect.emit('stream/input', {
+            data: { command },
+        });
+        logger.warn(`已向远程实例 ${this.instance.config.nickname} 发送指令：${command}`);
+    }
+    bindEvents() {
+        this.connect.on('connect', this.onConnect.bind(this));
+        this.connect.on('disconnect', this.onDisconnect.bind(this));
+        this.connect.on('reconnect', this.onReconnect.bind(this));
+        this.connect.on('connect_error', this.onConnectError.bind(this));
+    }
+    onConnect() {
+        this.authenticate();
+    }
+    onDisconnect(reason) {
+        logger.warn(`与 MCSManager 实例服务器的连接已断开，原因：${reason}`);
+    }
+    onReconnect(attemptNumber) {
+        logger.info(`正在重新连接到 MCSManager 实例服务器，尝试次数：${attemptNumber}`);
+    }
+    onConnectError(error) {
+        logger.error(`连接 MCSManager 实例服务器时出错：${error.message}`);
+    }
+    authenticate() {
+        this.connect.once('auth', ({ event, status }) => {
+            this.connect.once('stream/auth', pack => {
+                if ((0, lodash_es_1.isEqual)(event, 'auth') &&
+                    (0, lodash_es_1.isEqual)(status, 200) &&
+                    (0, lodash_es_1.isEqual)(pack.status, 200) &&
+                    (0, lodash_es_1.isEqual)(pack.data, true)) {
+                    logger.info(`已成功连接到 MCSManager 实例服务器 [${this.remote.remarks}] - ${this.instance.config.nickname} `);
+                    this.isAuthenticated = true;
+                    return pack;
+                }
+                logger.error(`远程实例 ${this.instance.config.nickname} 认证失败，无法建立连接`);
+            });
+            this.connect.emit('stream/auth', {
+                data: {
+                    password: this.auth.password,
+                },
+            });
+        });
+        this.connect.emit('auth', {
+            data: this.config.mcManagerKey,
+        });
+    }
+}
+exports.MCSManagerWebSocketIO = MCSManagerWebSocketIO;

package/lib/queQiao/index.d.ts

@@ -0,0 +1,108 @@
+import { Context, Schema } from 'koishi';
+import { GLBotConfigType } from '../gl';
+export declare const name = "minecraft-sync-msg";
+export interface WsMessageData {
+    api: string;
+    data: {
+        message: [
+            {
+                text: string;
+                color?: string;
+            }
+        ];
+    };
+}
+declare class MinecraftSyncMsg {
+    private ctx;
+    private config;
+    private ws;
+    private rcon;
+    private isDisposing;
+    private reconnectAttempts;
+    private reconnectIntervalId;
+    private plFork;
+    private enUS;
+    private zhCN;
+    constructor(ctx: Context, config: GLBotConfigType);
+    private initialize;
+    private setupRcon;
+    private connectToRcon;
+    private setupWebSocket;
+    private connectWebSocket;
+    private bindWebSocketEvents;
+    private handleWsOpen;
+    private handleWsMessage;
+    private handleWsClose;
+    private handleWsError;
+    private setupWatchChannel;
+    private reconnectWebSocket;
+    private clearReconnectInterval;
+    private setupMessageHandler;
+    private isValidChannel;
+    private isMessageCommand;
+    private isRconCommand;
+    private handleMessageCommand;
+    private handleRconCommand;
+    private sendRconCommand;
+    private extractAndRemoveColor;
+    private broadcastToChannels;
+    private setupDisposeHandler;
+    private dispose;
+}
+declare namespace MinecraftSyncMsg {
+    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<{
+        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.ObjectS<{
+        sendToChannel: Schema<string[], string[]>;
+        watchChannel: Schema<string[], string[]>;
+        sendprefix: Schema<string, string>;
+        cmdprefix: 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 & {
+        rconEnable: boolean;
+        rconServerHost: string;
+        rconServerPort: number;
+        rconPassword: string;
+        alluser: boolean;
+        superuser: string[];
+        commonCmd: string[];
+        cannotCmd: string[];
+    } & {
+        sendToChannel: string[];
+        watchChannel: string[];
+        sendprefix: string;
+        cmdprefix: string;
+        hideConnect: boolean;
+        locale: "zh-CN" | "en-US";
+    }>;
+    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;