koishi-plugin-gl-bot 0.0.10 → 0.0.12

package/lib/mcsManager/schedules/mc.schedule.js

@@ -0,0 +1,15 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.default = (ctx) => {
+    ctx.model.extend('mcUser', {
+        id: { type: 'unsigned', length: 8 },
+        nickname: 'string',
+        uuid: 'string',
+        lastTime: 'timestamp',
+        level: 'integer',
+        onlineTimeJSON: 'text',
+    }, {
+        primary: 'id',
+        autoInc: true,
+    });
+};

package/lib/mcsManager/type.d.ts

@@ -1,3 +1,4 @@
+import MinecraftSyncMsg from '../queQiao';
 import { RemoteInstanceStatusEnum } from './constants';
 import { MCSManagerInstance } from './instance';
 export interface MCManagerPanelResponse<T> {
@@ -113,3 +114,106 @@ export interface ServiceInstanceConnectAuth {
     addr: string;
     prefix: string;
 }
+export interface CreateInstanceData {
+    nickname?: string;
+    startCommand?: string;
+    stopCommand?: string;
+    cwd?: string;
+    ie?: string;
+    oe?: string;
+    processType?: string;
+    createDatetime?: string;
+    lastDatetime?: string;
+    type?: string;
+    tag?: string[];
+    maxSpace?: null;
+    endTime?: string;
+    docker?: {
+        containerName?: string;
+        image?: string;
+        ports?: string[];
+        extraVolumes?: string[];
+        networkMode?: 'bridge';
+        networkAliases?: string[];
+        cpusetCpus?: string;
+        workingDir?: '/data';
+        changeWorkdir?: false;
+        env?: [];
+    };
+}
+export type TerminalOption = {
+    haveColor: boolean;
+    pty: boolean;
+    ptyWindowCol: number;
+    ptyWindowRow: number;
+};
+export type EventTaskConfig = {
+    autoStart: boolean;
+    autoRestart: boolean;
+    autoRestartMaxTimes: number;
+    ignore: boolean;
+};
+export type DockerConfig = {
+    containerName: string;
+    image: string;
+    ports: unknown[];
+    extraVolumes: unknown[];
+    networkMode: string;
+    networkAliases: string[];
+    cpusetCpus: string;
+    workingDir: string;
+    env: unknown[];
+    changeWorkdir: boolean;
+};
+export type PingConfig = {
+    ip: string;
+    type: number;
+};
+export type ExtraServiceConfig = {
+    openFrpTunnelId: string;
+    openFrpToken: string;
+};
+export type CreateInstanceConfig = {
+    nickname: string;
+    startCommand: string;
+    stopCommand: string;
+    cwd: string;
+    ie: string;
+    oe: string;
+    createDatetime: number;
+    lastDatetime: number;
+    type: string;
+    tag: string[];
+    endTime: number;
+    fileCode: string;
+    processType: string;
+    updateCommand: string;
+    runAs: string;
+    actionCommandList: unknown[];
+    crlf: number;
+    category: number;
+    enableRcon: boolean;
+    rconPassword: string;
+    rconIp: string;
+    terminalOption: TerminalOption;
+    eventTask: EventTaskConfig;
+    docker: DockerConfig;
+    pingConfig: PingConfig;
+    extraServiceConfig: ExtraServiceConfig;
+};
+export interface McUser {
+    nickname: string;
+    uuid: string;
+    address: string;
+    health: number;
+    max_health: number;
+    experience_level: number;
+    experience_progress: number;
+    total_experience: number;
+    is_op: boolean;
+    walk_speed: number;
+    x: number;
+    y: number;
+    z: number;
+    server?: Schemastery.TypeS<typeof MinecraftSyncMsg.Config>;
+}

package/lib/mcsManager/ws.js

@@ -62,7 +62,7 @@ class MCSManagerWebSocketIO {
             reconnectionAttempts: 2000,
         });
         this.bindEvents();
-        logger.info(`正在连接到 MCSManager 实例服务器 [${this.remote.remarks}] - ${this.instance.config.nickname} ...`);
+        logger.debug(`正在连接到 MCSManager 实例服务器 [${this.remote.remarks}] - ${this.instance.config.nickname} ...`);
     }
     // 发送MC指令到远程实例
     sendCommand(command) {

package/lib/napCat/api.d.ts

@@ -0,0 +1,21 @@
+import { HTTP } from 'koishi';
+export declare class NapCatApi {
+    private http;
+    private baseUrl;
+    private token;
+    get requestHeaders(): {
+        authorization: string;
+    };
+    constructor(http: HTTP, baseUrl: string, token: string);
+    /**
+     * 获取文件信息
+     * @param fileId 文件ID
+     * @returns 文件信息或false
+     */
+    getFile(fileId: string): Promise<false | {
+        file: string;
+        url: string;
+        file_size: string;
+        file_name: string;
+    }>;
+}

package/lib/napCat/api.js

@@ -0,0 +1,43 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.NapCatApi = void 0;
+class NapCatApi {
+    get requestHeaders() {
+        return {
+            authorization: this.token,
+        };
+    }
+    constructor(http, baseUrl, token) {
+        this.http = http;
+        this.baseUrl = baseUrl;
+        this.token = token;
+    }
+    /**
+     * 获取文件信息
+     * @param fileId 文件ID
+     * @returns 文件信息或false
+     */
+    async getFile(fileId) {
+        console.log(`${this.baseUrl}/get_file`, {
+            file_id: fileId,
+        });
+        try {
+            const result = await this.http(`${this.baseUrl}/get_file`, {
+                method: 'POST',
+                headers: this.requestHeaders,
+                data: {
+                    file_id: fileId,
+                },
+            });
+            console.log(result?.data);
+            if (result.status === 200 && result.data) {
+                return result.data.data;
+            }
+        }
+        catch (error) {
+            console.error('Error fetching file:', error);
+        }
+        return false;
+    }
+}
+exports.NapCatApi = NapCatApi;

package/lib/napCat/config.d.ts

@@ -0,0 +1,10 @@
+import { Schema } from 'koishi';
+export declare class NapCatConfig {
+    static Base: Schema<Schemastery.ObjectS<{
+        napCatBaseUrl: Schema<string, string>;
+        napCatToken: Schema<string, string>;
+    }>, Schemastery.ObjectT<{
+        napCatBaseUrl: Schema<string, string>;
+        napCatToken: Schema<string, string>;
+    }>>;
+}

package/lib/napCat/config.js

@@ -0,0 +1,16 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.NapCatConfig = void 0;
+const koishi_1 = require("koishi");
+class NapCatConfig {
+}
+exports.NapCatConfig = NapCatConfig;
+NapCatConfig.Base = koishi_1.Schema.object({
+    napCatBaseUrl: koishi_1.Schema.string()
+        .default('http://localhost:3000')
+        .description('地址'),
+    napCatToken: koishi_1.Schema.string()
+        .role('secret')
+        .default('admin')
+        .description('密码'),
+}).description('NapCat 基础配置');

package/lib/napCat/index.d.ts

@@ -0,0 +1,16 @@
+import { Context, Schema } from 'koishi';
+import { GLBotConfigType } from '../gl';
+import { NapCatApi } from './api';
+export declare class NapCat {
+    private readonly ctx;
+    private readonly config;
+    static Config: Schema<Schemastery.ObjectS<{
+        napCatBaseUrl: Schema<string, string>;
+        napCatToken: Schema<string, string>;
+    }>, {
+        napCatBaseUrl: string;
+        napCatToken: string;
+    } & import("cosmokit").Dict>;
+    readonly api: NapCatApi;
+    constructor(ctx: Context, config: GLBotConfigType);
+}

package/lib/napCat/index.js

@@ -0,0 +1,15 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.NapCat = void 0;
+const koishi_1 = require("koishi");
+const api_1 = require("./api");
+const config_1 = require("./config");
+class NapCat {
+    constructor(ctx, config) {
+        this.ctx = ctx;
+        this.config = config;
+        this.api = new api_1.NapCatApi(ctx.http, config.napCatBaseUrl, config.napCatToken);
+    }
+}
+exports.NapCat = NapCat;
+NapCat.Config = koishi_1.Schema.intersect([config_1.NapCatConfig.Base]);

package/lib/queQiao/index.d.ts

@@ -1,6 +1,13 @@
-import { Context, Schema } from 'koishi';
-import { GLBotConfigType } from '../gl';
+import { Context, Schema, h } from 'koishi';
+import { Rcon } from 'rcon-client';
+import { RawData, WebSocket } from 'ws';
+import { GLQueQiaoAdapter } from '../gl/queqiao.adapter';
+import McWss from './mcwss';
 export declare const name = "minecraft-sync-msg";
+interface MessageColor {
+    output: string;
+    color: string;
+}
 export interface WsMessageData {
     api: string;
     data: {
@@ -13,41 +20,44 @@ export interface WsMessageData {
     };
 }
 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;
+    ctx: Context;
+    adapter: GLQueQiaoAdapter;
+    config: Schemastery.TypeS<typeof MinecraftSyncMsg.Config>;
+    ws: WebSocket | undefined;
+    rcon: Rcon;
+    isDisposing: boolean;
+    reconnectAttempts: number;
+    reconnectIntervalId: NodeJS.Timeout | null;
+    plFork: McWss;
+    enUS: any;
+    zhCN: any;
+    get serverName(): any;
+    constructor(ctx: Context, adapter: GLQueQiaoAdapter, config: Schemastery.TypeS<typeof MinecraftSyncMsg.Config>);
+    initialize(): void;
+    setupRcon(): void;
+    connectToRcon(): Promise<void>;
+    setupWebSocket(): void;
+    connectWebSocket(): void;
+    bindWebSocketEvents(): void;
+    handleWsOpen(): void;
+    handleWsMessage(buffer: RawData): void;
+    updatePlayerOnlineTime(data: any): Promise<void>;
+    handleWsClose(): void;
+    handleWsError(err: Error): void;
+    setupWatchChannel(): void;
+    reconnectWebSocket(): Promise<void>;
+    clearReconnectInterval(): void;
+    setupMessageHandler(): void;
+    isValidChannel(session: any): boolean;
+    isMessageCommand(session: any): boolean;
+    isRconCommand(session: any): boolean;
+    handleMessageCommand(session: any): Promise<void>;
+    handleRconCommand(session: any): Promise<void>;
+    sendRconCommand(command: string): Promise<string>;
+    extractAndRemoveColor(input?: string): MessageColor;
+    broadcastToChannels(message: string | h[]): void;
+    setupDisposeHandler(): void;
+    dispose(): Promise<void>;
 }
 declare namespace MinecraftSyncMsg {
     const Config: Schema<Schemastery.ObjectS<{

package/lib/queQiao/index.js

@@ -9,6 +9,7 @@ const lodash_1 = require("lodash");
 const rcon_client_1 = require("rcon-client");
 const ws_1 = require("ws");
 const constants_1 = require("../constants");
+const online_1 = require("../mcsManager/commands/mc/online");
 const utils_1 = require("../utils");
 const mcwss_1 = __importDefault(require("./mcwss"));
 const values_1 = require("./values");
@@ -19,8 +20,12 @@ 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) {
+    get serverName() {
+        return this.config.serverName ?? '--';
+    }
+    constructor(ctx, adapter, config) {
         this.ctx = ctx;
+        this.adapter = adapter;
         this.config = config;
         this.isDisposing = false;
         this.reconnectAttempts = 0;
@@ -37,7 +42,7 @@ class MinecraftSyncMsg {
         this.ctx.i18n.define('en-US', enUS);
     }
     setupRcon() {
-        if (!this.config.rconEnable) {
+        if (!this.config.rconServerHost) {
             return;
         }
         this.rcon = new rcon_client_1.Rcon({
@@ -46,23 +51,23 @@ class MinecraftSyncMsg {
             password: this.config.rconPassword,
         });
         this.connectToRcon().catch(err => {
-            logger.error('RCON服务器连接失败:', err);
+            logger.error(`[${this.serverName}] RCON服务器连接失败:`, err);
         });
     }
     async connectToRcon() {
         try {
             await this.rcon.connect();
-            logger.info('已连接到RCON服务器');
+            logger.info(`[${this.serverName}] 已连接到RCON服务器`);
         }
         catch (err) {
-            logger.error('连接到RCON服务器时发生错误:', err);
+            logger.error(`[${this.serverName}] 连接到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);
+            // this.plFork = this.ctx.plugin(McWss, this.adapter, this.config);
+            this.plFork = new mcwss_1.default(this.ctx, this.adapter, this.config);
             return;
         }
         else {
@@ -90,10 +95,10 @@ class MinecraftSyncMsg {
         this.ws.on('error', err => this.handleWsError(err));
     }
     handleWsOpen() {
-        logger.info('成功连上websocket服务器');
-        if (!this.config.hideConnect) {
-            this.broadcastToChannels('Websocket服务器连接成功!');
-        }
+        logger.info(`[${this.serverName}] 成功连上websocket服务器`);
+        // if (!this.config.hideConnect) {
+        //   this.broadcastToChannels('Websocket服务器连接成功!');
+        // }
         if (!constants_1.IS_DEV) {
             const msgData = {
                 api: 'broadcast',
@@ -120,8 +125,11 @@ class MinecraftSyncMsg {
             logger.error('Failed to parse WebSocket message:', err);
             return;
         }
+        // 在线时间逻辑
+        this.updatePlayerOnlineTime(data);
         const eventName = data.event_name ? (0, values_1.getListeningEvent)(data.event_name) : '';
-        if (eventName === 'PlayerCommandPreprocessEvent') {
+        if (!eventName ||
+            ['PlayerCommandPreprocessEvent', 'PlayerDeathEvent'].includes(eventName)) {
             return;
         }
         // console.log(data);
@@ -144,19 +152,112 @@ class MinecraftSyncMsg {
         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]);
+        sendMsg = this.ctx.i18n.render([this.config.locale ? this.config.locale : 'zh-CN'], [`minecraft-sync-msg.action.${eventName}`], [this.config.serverName ?? 'MC', data.player?.nickname, sendMsg]);
+        /// 多服消息互通逻辑
+        // if (data.event_name && isEqual(eventName, 'AsyncPlayerChatEvent')) {
+        //   Object.entries(this.adapter.servers).forEach(
+        //     async ([serverName, server]) => {
+        //       if (!isEqual(serverName, this.config.serverName)) {
+        //         const msgData: WsMessageData = {
+        //           api: 'broadcast',
+        //           data: {
+        //             message: [
+        //               {
+        //                 text: `[${this.config.serverName}] <${data.player?.nickname}> ${clearSessionContentToMcMessage(data.message)}`,
+        //                 color:
+        //                   server.extractAndRemoveColor(server.config.joinMsg)
+        //                     .color || 'white',
+        //               },
+        //             ],
+        //           },
+        //         };
+        //         server.ws?.send(JSON.stringify(msgData));
+        //       }
+        //     },
+        //   );
+        // }
         if (data.server_name && sendMsg) {
             this.broadcastToChannels(sendMsg);
         }
     }
+    async updatePlayerOnlineTime(data) {
+        if (!online_1.MCBotGameOnline.list[this.serverName]) {
+            online_1.MCBotGameOnline.list[this.serverName] = {
+                config: this.config,
+                list: {},
+            };
+        }
+        const playerId = data.player?.uuid + '|' + this.serverName;
+        if (data.player) {
+            online_1.MCBotGameOnline.list[this.serverName].list[data.player?.nickname] =
+                data.player;
+        }
+        if (!['PlayerJoinEvent', 'PlayerQuitEvent'].includes(data.event_name)) {
+            return;
+        }
+        const user = await this.ctx.database.get('mcUser', {
+            uuid: data.player?.uuid,
+        });
+        if (user.length === 0) {
+            await this.ctx.database.create('mcUser', {
+                nickname: data.player?.nickname,
+                uuid: data.player?.uuid,
+                lastTime: new Date(),
+                level: data.player?.level || 0,
+                onlineTimeJSON: JSON.stringify({
+                    mc: {
+                        [playerId]: 0,
+                    },
+                }),
+            });
+            return;
+        }
+        if (data.event_name === 'PlayerJoinEvent') {
+            await this.ctx.database.set('mcUser', { uuid: data.player?.uuid }, {
+                nickname: data.player?.nickname,
+                level: data.player?.experience_level || 0,
+                lastTime: new Date(),
+            });
+            return;
+        }
+        // 更新在线时间 （加入游戏时会更新lastTime，退出游戏时通过lastTime算出本次在线时间，加到onlineTimeJSON中）
+        if (data.event_name === 'PlayerQuitEvent') {
+            const lastTime = new Date(user[0].lastTime).getTime();
+            const nowTime = Date.now();
+            const onlineDuration = Math.floor((nowTime - lastTime) / 1000); // 在线时长，单位秒
+            delete online_1.MCBotGameOnline.list[this.serverName].list[data.player?.nickname];
+            let onlineTimeJSON = {};
+            try {
+                onlineTimeJSON = JSON.parse(user[0].onlineTimeJSON);
+            }
+            catch (err) {
+                onlineTimeJSON = {};
+            }
+            if (!onlineTimeJSON.mc) {
+                onlineTimeJSON.mc = {};
+            }
+            if (!onlineTimeJSON.mc[playerId]) {
+                onlineTimeJSON.mc[playerId] = 0;
+            }
+            onlineTimeJSON.mc[playerId] += onlineDuration;
+            await this.ctx.database.set('mcUser', { uuid: data.player?.uuid }, {
+                nickname: data.player?.nickname,
+                lastTime: new Date(),
+                level: data.player?.experience_level || 0,
+                onlineTimeJSON: JSON.stringify(onlineTimeJSON),
+            });
+        }
+    }
     handleWsClose() {
         if (this.isDisposing) {
             return;
         }
-        if (!this.config.hideConnect) {
-            this.broadcastToChannels('与Websocket服务器断开连接!');
-        }
-        logger.error('非正常与Websocket服务器断开连接!');
+        // if (!this.config.hideConnect) {
+        //   this.broadcastToChannels(
+        //     `[${this.serverName}] 与Websocket服务器断开连接!`,
+        //   );
+        // }
+        logger.error(`[${this.serverName}] 非正常与Websocket服务器断开连接!`);
         this.ws = undefined;
         this.reconnectWebSocket();
     }
@@ -164,10 +265,12 @@ class MinecraftSyncMsg {
         if (this.isDisposing) {
             return;
         }
-        if (!this.config.hideConnect) {
-            this.broadcastToChannels('与Websocket服务器断通信时发生错误!');
-        }
-        logger.error('与Websocket服务器断通信时发生错误:', err);
+        // if (!this.config.hideConnect) {
+        //   this.broadcastToChannels(
+        //     `[${this.serverName}] 与Websocket服务器断通信时发生错误!`,
+        //   );
+        // }
+        logger.error(`[${this.serverName}] 与Websocket服务器断通信时发生错误:`, err);
     }
     setupWatchChannel() {
         this.ctx.on('message', async (session) => {
@@ -194,13 +297,13 @@ class MinecraftSyncMsg {
     async reconnectWebSocket() {
         this.clearReconnectInterval();
         this.reconnectIntervalId = setInterval(async () => {
-            if (this.reconnectAttempts >= this.config.maxReconnectCount) {
-                logger.error(`已达到最大重连次数 (${this.config.maxReconnectCount} 次)，停止重连。`);
+            if (this.reconnectAttempts >= (this.config.maxReconnectCount || 3)) {
+                logger.error(`[${this.serverName}] 已达到最大重连次数 (${this.config.maxReconnectCount} 次)，停止重连。`);
                 this.clearReconnectInterval();
                 return;
             }
             this.reconnectAttempts++;
-            logger.info(`尝试第 ${this.reconnectAttempts} 次重连...`);
+            logger.info(`[${this.serverName}] 尝试第 ${this.reconnectAttempts} 次重连...`);
             try {
                 const headers = {
                     'x-self-name': encodeURIComponent(this.config.serverName),
@@ -211,24 +314,24 @@ class MinecraftSyncMsg {
                     headers,
                 });
                 ws.on('open', () => {
-                    logger.info('WebSocket 重连成功');
+                    logger.info(`[${this.serverName}] WebSocket 重连成功`);
                     this.clearReconnectInterval();
                     this.ws = ws;
                     this.bindWebSocketEvents();
                 });
                 ws.on('error', err => {
-                    logger.error('重连时发生错误:', err);
+                    logger.error(`[${this.serverName}] 重连时发生错误:`, err);
                     ws.close();
                 });
                 ws.on('close', () => {
                     if (!this.isDisposing) {
-                        logger.info('WebSocket 再次断开，将继续尝试重连...');
+                        logger.info(`[${this.serverName}] WebSocket 再次断开，将继续尝试重连...`);
                     }
                 });
             }
             catch (err) {
-                logger.error('创建WebSocket时发生错误:', err);
-                if (this.reconnectAttempts >= this.config.maxReconnectCount) {
+                logger.error(`[${this.serverName}] 创建WebSocket时发生错误:`, err);
+                if (this.reconnectAttempts >= (this.config.maxReconnectCount || 3)) {
                     this.clearReconnectInterval();
                 }
             }
@@ -338,31 +441,33 @@ class MinecraftSyncMsg {
         session.send(response?.replaceAll(/§./g, '') || '');
     }
     async sendRconCommand(command) {
+        if (!this.rcon.authenticated) {
+            return '';
+        }
         try {
             const response = await this.rcon.send(command);
             return response;
         }
         catch (err) {
-            logger.error('发送RCON命令时发生错误:', err);
+            logger.error(`[${this.serverName}] 发送RCON命令时发生错误:`, err);
             throw err;
         }
     }
     extractAndRemoveColor(input) {
         const regex = /&(\w+)&/;
-        const match = input.match(regex);
+        const match = input?.match(regex) ?? [];
         if (match) {
             const color = match[1];
-            const output = input.replace(regex, '');
+            const output = input?.replace(regex, '');
             return { output, color };
         }
-        return { output: input, 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);
+                ?.filter(str => str.includes(`${bot.platform}`))
+                ?.map(str => str.replace(`${bot.platform}:`, '')) ?? [];
             if (process.env.NODE_ENV === 'development') {
                 logger.info((0, lodash_1.isString)(message)
                     ? message
@@ -379,9 +484,6 @@ class MinecraftSyncMsg {
         });
     }
     async dispose() {
-        if (this.plFork) {
-            await this.plFork.dispose();
-        }
         this.ctx.registry.delete(mcwss_1.default);
         if (this.ws) {
             this.ws.removeAllListeners();