koishi-plugin-gl-bot 0.0.7 → 0.0.9

package/dist/index.js

@@ -1 +1 @@
-import{resolveComponent as r,createBlock as a,openBlock as s,withCtx as _,createTextVNode as p}from"vue";const l=(t,e)=>{const o=t.__vccOpts||t;for(const[n,c]of e)o[n]=c;return o},u={};function f(t,e){const o=r("k-layout");return s(),a(o,null,{default:_(()=>[...e[0]||(e[0]=[p("扩展内容",-1)])]),_:1})}const m=l(u,[["render",f]]),x=t=>{t.page({name:"扩展页面",path:"/custom-page",component:m})};export{x as default};
+import{resolveComponent as r,createBlock as a,openBlock as s,withCtx as _,createTextVNode as p}from"vue";const d=(t,e)=>{const o=t.__vccOpts||t;for(const[n,c]of e)o[n]=c;return o},f={};function l(t,e){const o=r("k-card");return s(),a(o,null,{default:_(()=>[...e[0]||(e[0]=[p("扩展内容22",-1)])]),_:1})}const m=d(f,[["render",l]]),x=t=>{t.page({name:"扩展页面",path:"/custom-page",component:m})};export{x as default};

package/lib/constants/index.d.ts

@@ -0,0 +1 @@
+export declare const IS_DEV: boolean;

package/lib/constants/index.js

@@ -0,0 +1,4 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.IS_DEV = void 0;
+exports.IS_DEV = process.env.NODE_ENV === 'development';

package/lib/gl/index.d.ts

@@ -0,0 +1,83 @@
+import { Context, Schema } from 'koishi';
+export declare class GLBot {
+    private ctx;
+    private config;
+    static 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">;
+    }> | Schemastery.ObjectS<{
+        mcManagerUsername: Schema<string, string>;
+        mcManagerPassword: Schema<string, string>;
+        mcManagerKey: Schema<string, string>;
+        mcManagerHost: Schema<string, string>;
+        mcManagerWs: Schema<string, string>;
+        mcManagerMaxConnectWs: Schema<number, number>;
+    }>, {
+        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";
+    } & {
+        mcManagerUsername: string;
+        mcManagerPassword: string;
+        mcManagerKey: string;
+        mcManagerHost: string;
+        mcManagerWs: string;
+        mcManagerMaxConnectWs: number;
+    }>;
+    private mcSyncMsg;
+    private mcsManager;
+    constructor(ctx: Context, config: GLBotConfigType);
+    private initialize;
+    private globalCommand;
+}
+export declare class GLBotBase {
+    private ctx;
+    private config;
+    constructor(ctx: Context, config: GLBotConfigType);
+}
+export type GLBotConfigType = Schemastery.TypeS<typeof GLBot.Config>;

package/lib/gl/index.js

@@ -0,0 +1,51 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.GLBotBase = exports.GLBot = void 0;
+const koishi_1 = require("koishi");
+const constants_1 = require("../constants");
+const mcsManager_1 = require("../mcsManager");
+const queQiao_1 = __importDefault(require("../queQiao"));
+const logger = new koishi_1.Logger('gl-bot');
+class GLBot {
+    constructor(ctx, config) {
+        this.ctx = ctx;
+        this.config = config;
+        this.mcSyncMsg = new queQiao_1.default(ctx, config);
+        this.mcsManager = new mcsManager_1.MCManager(ctx, config);
+        this.initialize();
+    }
+    initialize() {
+        this.globalCommand();
+    }
+    globalCommand() {
+        this.ctx.on('message', session => {
+            if (constants_1.IS_DEV) {
+                // console.log(JSON.stringify(session, null, 2));
+            }
+            switch (session.content) {
+                case '环境变量':
+                    session.send(`当前环境变量：${Object.entries(process.env)
+                        .map(([k, v]) => `${k}: ${v}`)
+                        .join('\n')}`);
+                    break;
+                default:
+                    break;
+            }
+            if (~session.content.indexOf('群群')) {
+                session.send(`群群似杂鱼！大杂鱼喵`);
+            }
+        });
+    }
+}
+exports.GLBot = GLBot;
+GLBot.Config = koishi_1.Schema.intersect([queQiao_1.default.Config, mcsManager_1.MCManager.Config]);
+class GLBotBase {
+    constructor(ctx, config) {
+        this.ctx = ctx;
+        this.config = config;
+    }
+}
+exports.GLBotBase = GLBotBase;

package/lib/index.d.ts

@@ -1,6 +1,3 @@
-import { Context, Schema } from "koishi";
+import { GLBot } from './gl';
 export declare const name = "gl-bot";
-export interface Config {
-}
-export declare const Config: Schema<Config>;
-export declare function apply(ctx: Context): void;
+export default GLBot;

package/lib/index.js

@@ -0,0 +1,6 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.name = void 0;
+const gl_1 = require("./gl");
+exports.name = 'gl-bot';
+exports.default = gl_1.GLBot;

package/lib/mcsManager/api.d.ts

@@ -0,0 +1,25 @@
+import { HTTP } from 'koishi';
+import { ServiceInstanceConnectAuth, ServiceRemoteInstanceItem, ServiceRemoteItem, UserInfo } from './type';
+export declare class MCSManagerAPI {
+    private http;
+    private baseUrl;
+    private authCookie?;
+    userInfo: UserInfo;
+    get requestHeaders(): {
+        cookie: string;
+        'x-requested-with': string;
+    };
+    constructor(http: HTTP, baseUrl: string, authCookie?: string);
+    login(username: string, password: string): Promise<boolean>;
+    getUserInfo(): Promise<UserInfo>;
+    getServiceRemoteList(): Promise<ServiceRemoteItem[]>;
+    getServiceRemoteInstanceList(daemonId: string, options?: {
+        status?: string;
+        tag: string[];
+        instance_name?: string;
+        page?: number;
+        page_size?: number;
+    }): Promise<ServiceRemoteInstanceItem[]>;
+    getServiceInstanceConnectAuth(remoteUUID: string, instanceId: string): Promise<ServiceInstanceConnectAuth | null>;
+    restartRemoteInstance(daemonId: string, instanceId: string): Promise<HTTP.Response<any>>;
+}

package/lib/mcsManager/api.js

@@ -0,0 +1,96 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MCSManagerAPI = void 0;
+class MCSManagerAPI {
+    get requestHeaders() {
+        return {
+            cookie: this.authCookie,
+            'x-requested-with': 'XMLHttpRequest',
+        };
+    }
+    constructor(http, baseUrl, authCookie) {
+        this.http = http;
+        this.baseUrl = baseUrl;
+        this.authCookie = authCookie;
+    }
+    async login(username, password) {
+        const result = await this.http(`${this.baseUrl}/auth/login`, {
+            method: 'POST',
+            data: {
+                username,
+                password,
+            },
+        });
+        if (result.status === 200 && result.headers.get('set-cookie')) {
+            const cookieString = result.headers.get('set-cookie');
+            this.authCookie = extractCookiesWithRegex(cookieString);
+            return true;
+        }
+        return false;
+    }
+    async getUserInfo() {
+        const result = await this.http(`${this.baseUrl}/auth/`, {
+            headers: this.requestHeaders,
+        });
+        if (result.status === 200) {
+            this.userInfo = result.data.data;
+            return this.userInfo;
+        }
+        return null;
+    }
+    async getServiceRemoteList() {
+        return ((await this.http(`${this.baseUrl}/service/remote_services_list`, {
+            headers: this.requestHeaders,
+            params: {
+                token: this.userInfo.token,
+            },
+        })).data.data ?? []);
+    }
+    async getServiceRemoteInstanceList(daemonId, options) {
+        return ((await this.http(`${this.baseUrl}/service/remote_service_instances`, {
+            headers: this.requestHeaders,
+            params: {
+                daemonId,
+                page: options?.page || 1,
+                page_size: options?.page_size || 999,
+                status: options?.status || '',
+                instance_name: options?.instance_name || '',
+                tag: JSON.stringify(options?.tag || []),
+                token: this.userInfo.token,
+            },
+        })).data?.data?.data ?? []);
+    }
+    async getServiceInstanceConnectAuth(remoteUUID, instanceId) {
+        return ((await this.http(`${this.baseUrl}/protected_instance/stream_channel`, {
+            method: 'POST',
+            headers: this.requestHeaders,
+            params: {
+                remote_uuid: remoteUUID,
+                uuid: instanceId,
+                token: this.userInfo.token,
+            },
+        })).data.data ?? null);
+    }
+    async restartRemoteInstance(daemonId, instanceId) {
+        console.log({
+            daemonId,
+            uuid: instanceId,
+            token: this.userInfo.token,
+        });
+        return this.http(`${this.baseUrl}/protected_instance/restart`, {
+            headers: this.requestHeaders,
+            params: {
+                daemonId,
+                uuid: instanceId,
+                token: this.userInfo.token,
+            },
+        });
+    }
+}
+exports.MCSManagerAPI = MCSManagerAPI;
+function extractCookiesWithRegex(cookieStr) {
+    return cookieStr
+        .match(/(\S+=\S+;)/g)
+        .filter(v => v !== 'path=/;')
+        .join(' ');
+}

package/lib/mcsManager/bot.d.ts

@@ -0,0 +1,14 @@
+import { Context } from 'koishi';
+import { GLBotConfigType } from '../gl';
+import { MCBotResetCommand } from './commands/reset';
+import { MCSManagerPanel } from './panel';
+export declare class MCSManagerBot {
+    readonly ctx: Context;
+    readonly config: GLBotConfigType;
+    readonly panel: MCSManagerPanel;
+    constructor(ctx: Context, config: GLBotConfigType, panel: MCSManagerPanel);
+    help(): string[];
+    commands(): (typeof MCBotResetCommand)[];
+    initialize(): Promise<void>;
+    private registerCommands;
+}

package/lib/mcsManager/bot.js

@@ -0,0 +1,42 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MCSManagerBot = void 0;
+const reset_1 = require("./commands/reset");
+class MCSManagerBot {
+    constructor(ctx, config, panel) {
+        this.ctx = ctx;
+        this.config = config;
+        this.panel = panel;
+        this.initialize();
+    }
+    help() {
+        return [
+            '服务器 管理指令：',
+            '/服务器 列表',
+            '/服务器 开启 <模糊名>',
+            '/服务器 关闭 <模糊名>',
+            '/服务器 重启 <模糊名>',
+            '/服务器 备份 <模糊名>',
+        ];
+    }
+    commands() {
+        return [reset_1.MCBotResetCommand];
+    }
+    async initialize() {
+        this.ctx.on('ready', async () => {
+            this.registerCommands();
+        });
+    }
+    registerCommands() {
+        for (const Command of this.commands()) {
+            new Command(this);
+        }
+        // this.ctx
+        //   .command('/服务器 <action> [...name]')
+        //   .option('debug', '-d')
+        //   .action(({ options }, action, ...name) => {
+        //     return `收到指令：${action} ${name.join(' ')}，调试模式：${options.debug}`;
+        //   });
+    }
+}
+exports.MCSManagerBot = MCSManagerBot;

package/lib/mcsManager/commands/base.d.ts

@@ -0,0 +1,2 @@
+export declare class MCBotCommandBase {
+}

package/lib/mcsManager/commands/base.js

@@ -0,0 +1,6 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MCBotCommandBase = void 0;
+class MCBotCommandBase {
+}
+exports.MCBotCommandBase = MCBotCommandBase;

package/lib/mcsManager/commands/index.d.ts

@@ -0,0 +1,7 @@
+import { Context } from 'koishi';
+import { GLBotConfigType } from '../../gl';
+export declare class MCBotCommandBase {
+    readonly ctx: Context;
+    readonly config: GLBotConfigType;
+    constructor(ctx: Context, config: GLBotConfigType);
+}

package/lib/mcsManager/commands/index.js

@@ -0,0 +1,13 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MCBotCommandBase = void 0;
+const koishi_1 = require("koishi");
+const logger = new koishi_1.Logger('mcsmanager-command');
+class MCBotCommandBase {
+    constructor(ctx, config) {
+        this.ctx = ctx;
+        this.config = config;
+        // logger.info('注册 MCSManager 服务器管理指令...');
+    }
+}
+exports.MCBotCommandBase = MCBotCommandBase;

package/lib/mcsManager/commands/reset.d.ts

@@ -0,0 +1,12 @@
+import { Context, Session } from 'koishi';
+import { MCSManagerBot } from '../bot';
+/**
+ * 服务器重启指令
+ *
+ * @example 服务器 重启 神话
+ */
+export declare class MCBotResetCommand {
+    private readonly bot;
+    constructor(bot: MCSManagerBot);
+    handle(session: Session<never, never, Context>, name: string): Promise<string>;
+}

package/lib/mcsManager/commands/reset.js

@@ -0,0 +1,45 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MCBotResetCommand = void 0;
+const constants_1 = require("../constants");
+// const logger = new Logger('mcsmanager-reset');
+const tempSelections = new Map();
+/**
+ * 服务器重启指令
+ *
+ * @example 服务器 重启 神话
+ */
+class MCBotResetCommand {
+    constructor(bot) {
+        this.bot = bot;
+        bot.ctx
+            .command('服务器 重启 <name...>')
+            .action(async ({ session }, _action, ...name) => {
+            return await this.handle(session, name.join(' '));
+        });
+    }
+    async handle(session, name) {
+        let selectIndex = -1;
+        const userId = Number(session.event.user.id);
+        // 溯源前搜索项
+        if (tempSelections.has(userId) && !isNaN(Number(name))) {
+            selectIndex = Number(name) - 1;
+            name = tempSelections.get(userId);
+        }
+        tempSelections.delete(userId);
+        const nameInstances = await this.bot.panel.searchInstanceByName(name);
+        if (nameInstances.length === 0) {
+            return `未找到名称包含 "${name}" 的服务器实例`;
+        }
+        if (nameInstances.length > 1 && selectIndex === -1) {
+            tempSelections.set(userId, name);
+            return `请输入序号以选择:\n\n${nameInstances
+                .map((item, index) => `${index + 1}. [${constants_1.RemoteInstanceStatusName[item.instance.cfg.status]}] ${item.instance.cfg.config.nickname}`)
+                .join('\n')}\n ==== 例如发送： (服务器 重启 1) ====`;
+        }
+        const targetInstance = selectIndex !== -1 ? nameInstances[selectIndex] : nameInstances[0];
+        targetInstance.instance.restartInstance();
+        return `已向服务器实例 "${targetInstance.instance.cfg.config.nickname}" 发送重启操作`;
+    }
+}
+exports.MCBotResetCommand = MCBotResetCommand;

package/lib/mcsManager/config.d.ts

@@ -0,0 +1,18 @@
+import { Schema } from 'koishi';
+export declare class MCManagerConfig {
+    static Base: Schema<Schemastery.ObjectS<{
+        mcManagerUsername: Schema<string, string>;
+        mcManagerPassword: Schema<string, string>;
+        mcManagerKey: Schema<string, string>;
+        mcManagerHost: Schema<string, string>;
+        mcManagerWs: Schema<string, string>;
+        mcManagerMaxConnectWs: Schema<number, number>;
+    }>, Schemastery.ObjectT<{
+        mcManagerUsername: Schema<string, string>;
+        mcManagerPassword: Schema<string, string>;
+        mcManagerKey: Schema<string, string>;
+        mcManagerHost: Schema<string, string>;
+        mcManagerWs: Schema<string, string>;
+        mcManagerMaxConnectWs: Schema<number, number>;
+    }>>;
+}

package/lib/mcsManager/config.js

@@ -0,0 +1,24 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MCManagerConfig = void 0;
+const koishi_1 = require("koishi");
+class MCManagerConfig {
+}
+exports.MCManagerConfig = MCManagerConfig;
+MCManagerConfig.Base = koishi_1.Schema.object({
+    mcManagerUsername: koishi_1.Schema.string().default('admin').description('用户名'),
+    mcManagerPassword: koishi_1.Schema.string()
+        .role('secret')
+        .default('admin')
+        .description('密码'),
+    mcManagerKey: koishi_1.Schema.string().role('secret').description('KEY'),
+    mcManagerHost: koishi_1.Schema.string()
+        .default('http://localhost:23333/api')
+        .description('地址'),
+    mcManagerWs: koishi_1.Schema.string()
+        .default('ws://localhost:24444')
+        .description('WebSocket 地址'),
+    mcManagerMaxConnectWs: koishi_1.Schema.number()
+        .default(20)
+        .description('最大连接实例数'),
+}).description('MCSMANAGER 基础配置');

package/lib/mcsManager/constants.d.ts

@@ -0,0 +1,8 @@
+export declare enum RemoteInstanceStatusEnum {
+    STOPPED = 0,
+    RUNNING = 3
+}
+export declare const RemoteInstanceStatusName: {
+    0: string;
+    3: string;
+};

package/lib/mcsManager/constants.js

@@ -0,0 +1,12 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RemoteInstanceStatusName = exports.RemoteInstanceStatusEnum = void 0;
+var RemoteInstanceStatusEnum;
+(function (RemoteInstanceStatusEnum) {
+    RemoteInstanceStatusEnum[RemoteInstanceStatusEnum["STOPPED"] = 0] = "STOPPED";
+    RemoteInstanceStatusEnum[RemoteInstanceStatusEnum["RUNNING"] = 3] = "RUNNING";
+})(RemoteInstanceStatusEnum || (exports.RemoteInstanceStatusEnum = RemoteInstanceStatusEnum = {}));
+exports.RemoteInstanceStatusName = {
+    [RemoteInstanceStatusEnum.STOPPED]: '已停止',
+    [RemoteInstanceStatusEnum.RUNNING]: '运行中',
+};

package/lib/mcsManager/index.d.ts

@@ -0,0 +1,26 @@
+import { Context, Schema } from 'koishi';
+import { GLBotConfigType } from '../gl';
+export declare class MCManager {
+    private readonly ctx;
+    private readonly config;
+    static Config: Schema<Schemastery.ObjectS<{
+        mcManagerUsername: Schema<string, string>;
+        mcManagerPassword: Schema<string, string>;
+        mcManagerKey: Schema<string, string>;
+        mcManagerHost: Schema<string, string>;
+        mcManagerWs: Schema<string, string>;
+        mcManagerMaxConnectWs: Schema<number, number>;
+    }>, {
+        mcManagerUsername: string;
+        mcManagerPassword: string;
+        mcManagerKey: string;
+        mcManagerHost: string;
+        mcManagerWs: string;
+        mcManagerMaxConnectWs: number;
+    } & import("cosmokit").Dict>;
+    private panel;
+    private bot;
+    constructor(ctx: Context, config: GLBotConfigType);
+    initialize(): Promise<void>;
+}
+export type MCManagerConfigType = typeof MCManager.Config;

package/lib/mcsManager/index.js

@@ -0,0 +1,21 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MCManager = void 0;
+const koishi_1 = require("koishi");
+const bot_1 = require("./bot");
+const config_1 = require("./config");
+const panel_1 = require("./panel");
+class MCManager {
+    constructor(ctx, config) {
+        this.ctx = ctx;
+        this.config = config;
+        this.panel = new panel_1.MCSManagerPanel(ctx, config);
+        this.bot = new bot_1.MCSManagerBot(ctx, config, this.panel);
+        ctx.on('ready', this.initialize.bind(this));
+    }
+    async initialize() {
+        await this.panel.initialize();
+    }
+}
+exports.MCManager = MCManager;
+MCManager.Config = koishi_1.Schema.intersect([config_1.MCManagerConfig.Base]);

package/lib/mcsManager/instance.d.ts

@@ -0,0 +1,16 @@
+import { Context } from 'koishi';
+import { GLBotConfigType } from '../gl';
+import { MCSManagerAPI } from './api';
+import { MCSManagerPanel } from './panel';
+import { ServiceRemoteInstanceItem, ServiceRemoteItem } from './type';
+export declare class MCSManagerInstance {
+    private readonly ctx;
+    private readonly config;
+    private readonly api;
+    private readonly panel;
+    remote: ServiceRemoteItem;
+    cfg: ServiceRemoteInstanceItem;
+    isAuthenticated: boolean;
+    constructor(ctx: Context, config: GLBotConfigType, api: MCSManagerAPI, panel: MCSManagerPanel, remote: ServiceRemoteItem, cfg: ServiceRemoteInstanceItem);
+    restartInstance(): void;
+}

package/lib/mcsManager/instance.js

@@ -0,0 +1,18 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MCSManagerInstance = void 0;
+class MCSManagerInstance {
+    constructor(ctx, config, api, panel, remote, cfg) {
+        this.ctx = ctx;
+        this.config = config;
+        this.api = api;
+        this.panel = panel;
+        this.remote = remote;
+        this.cfg = cfg;
+        this.isAuthenticated = false;
+    }
+    restartInstance() {
+        this.api.restartRemoteInstance(this.remote.uuid, this.cfg.instanceUuid);
+    }
+}
+exports.MCSManagerInstance = MCSManagerInstance;

package/lib/mcsManager/panel.d.ts

@@ -0,0 +1,24 @@
+import { Context } from 'koishi';
+import { GLBotConfigType } from '../gl';
+import { MCSManagerAPI } from './api';
+import { MCSManagerInstance } from './instance';
+import { ServiceRemoteInstanceItem, ServiceRemoteItemCustom } from './type';
+import { MCSManagerWebSocketIO } from './ws';
+export declare class MCSManagerPanel {
+    readonly ctx: Context;
+    readonly config: GLBotConfigType;
+    private isInitialized;
+    api: MCSManagerAPI;
+    remotes: ServiceRemoteItemCustom[];
+    remoteConnectionsMap: Map<string, MCSManagerWebSocketIO>;
+    constructor(ctx: Context, config: GLBotConfigType);
+    initialize(): Promise<void>;
+    handleRemoteServices(): Promise<void>;
+    getAvailableRemoteInstance(): void;
+    createMCSManagerConnection(remote: ServiceRemoteItemCustom, instance: ServiceRemoteInstanceItem): Promise<MCSManagerWebSocketIO>;
+    searchInstanceByName(instanceName: string): Promise<{
+        remote: ServiceRemoteItemCustom;
+        instance: MCSManagerInstance;
+        sort: number;
+    }[]>;
+}