mirai-js 2.8.5 → 2.8.7

package/srcold/Bot.js

@@ -1,1208 +0,0 @@
-// 引入核心功能，前缀下划线时为了与方法名区别 (视觉上的区别)
-const _releaseSession = require('./core/releaseSession');
-const _verify = require('./core/auth');
-const _bind = require('./core/verify');
-const _sendCommand = require('./core/sendCommand');
-const _sendFriendMessage = require('./core/sendFriendMessage');
-const _sendGroupMessage = require('./core/sendGroupMessage');
-const _sendTempMessage = require('./core/sendTempMessage');
-const _sendNudge = require('./core/sendNudge');
-const _getSessionConfig = require('./core/getSessionConfig');
-const _setSessionConfig = require('./core/setSessionConfig');
-const _uploadImage = require('./core/uploadImage');
-const _uploadVoice = require('./core/uploadVoice');
-const _getFriendList = require('./core/getFriendList');
-const _getGroupList = require('./core/getGroupList');
-const _getMemberList = require('./core/getMemberList');
-const _getMemberInfo = require('./core/getMemberInfo');
-const _getUserProfile = require('./core/getUserProfile');
-const _setMemberInfo = require('./core/setMemberInfo');
-const _setMemberAdmin = require('./core/setMemberAdmin');
-const _getAnnoList = require('./core/anno/getAnno');
-const _publishAnno = require('./core/anno/publishAnno');
-const _deleteAnno = require('./core/anno/deleteAnno');
-const _recall = require('./core/recall');
-const _mute = require('./core/mute');
-const _muteAll = require('./core/muteAll');
-const _unmute = require('./core/unmute');
-const _unmuteAll = require('./core/unmuteAll');
-const _removeMember = require('./core/removeMember');
-const _removeFriend = require('./core/removeFriend');
-const _quitGroup = require('./core/quitGroup');
-const _getGroupConfig = require('./core/getGroupConfig');
-const _setGroupConfig = require('./core/setGroupConfig');
-const _setEssence = require('./core/setEssence');
-const _messageFromId = require('./core/messageFromId');
-const { wsStartListening: _startListening, wsStopListening: _stopListening } = require('./polyfill/wsListener');
-
-// 其他
-const random = require('./util/random')(0, 2E16);
-const getInvalidParamsString = require('./util/getInvalidParamsString');
-const { Waiter } = require('./Waiter');
-const { FileManager } = require('./FileManager');
-const { errCodeEnum } = require('./util/errCode');
-const { isBrowserEnv } = require('./util/isBrowserEnv');
-
-const fs = isBrowserEnv() ? null : require('fs');
-const { promisify } = isBrowserEnv() ? { promisify: null } : require('util');
-
-// 扩展接口
-const { MessageChainGetable, BotConfigGetable } = require('./interface');
-
-/**
- * @field config            包含 baseUrl verifyKey qq
- * @field eventProcessorMap 事件处理器 map
- * @field wsConnection      建立连接的 WebSocket 实例
- * @field waiter            内部类单例，提供同步 io 机制
- */
-class Bot extends BotConfigGetable {
-    constructor() {
-        super();
-        this.waiter = new Waiter(this);
-        this.config = undefined;
-        this.eventProcessorMap = {};
-        this.wsConnection = undefined;
-    }
-
-    /**
-     * 实现 BotConfigGetable 接口
-     */
-    getBaseUrl() { return this.config.baseUrl; }
-    getQQ() { return this.config.qq; }
-    getVerifyKey() { return this.config.verifyKey; }
-    getSessionKey() { return this.config.sessionKey; }
-
-    /**
-     * @description 连接到 mirai-api-http，并开启一个会话，重复调用意为重建会话
-     * open 方法 1. 建立会话 2. 绑定 qq 3. 与服务端建立 WebSocket 连接
-     * @param {string} baseUrl 必选，mirai-api-http server 的地址
-     * @param {string} verifyKey 必选，mirai-api-http server 设置的 verifyKey
-     * @param {number} qq      必选，欲绑定的 qq 号，需要确保该 qq 号已在 mirai-console 登陆
-     * @param {boolean} singleMode 可选，mirai-api-http server 是否启用了 singleMode
-     * @returns {void}
-     */
-    async open({ baseUrl, qq, verifyKey, singleMode } = {}) {
-        // 若 config 存在，则认为该对象已经 open 过
-        // ，此处应该先令对象回到初始状态，然后重建会话
-        if (this.config) {
-            await this.close({ keepProcessor: true, keepConfig: true });
-        }
-
-        // 设置对象状态
-        // 若开发者重复调用 open，仅更新已提供的值
-        this.config = {
-            baseUrl: this.config?.baseUrl ?? baseUrl,
-            qq: this.config?.qq ?? qq,
-            verifyKey: this.config?.verifyKey ?? verifyKey,
-            sessionKey: this.config?.sessionKey ?? '',
-        };
-
-        // 事件处理器 map
-        // 如果重复调用 open 则保留事件处理器
-        this.eventProcessorMap = this.eventProcessorMap ?? {};
-
-        // 需要使用的参数
-        ({ baseUrl, qq, verifyKey } = this.config);
-
-        // 检查参数
-        if (!this.config.baseUrl || !this.config.qq || !this.config.verifyKey) {
-            throw new Error(`open 缺少必要的 ${getInvalidParamsString({
-                baseUrl, qq, verifyKey,
-            })} 参数`);
-        }
-
-        // 创建会话
-        const sessionKey = this.config.sessionKey = await _verify({ baseUrl, verifyKey });
-
-        // 绑定到一个 qq, 若开启了 singleMode 则需要跳过绑定
-        !singleMode && await _bind({ baseUrl, sessionKey, qq });
-
-        // 配置服务端 websocket 状态
-        // await _setSessionConfig({ baseUrl, sessionKey, enableWebsocket: true });
-
-        // 开始监听事件
-        await this.__wsListen();
-
-    }
-
-    /**
-     * @private
-     * @description 监听 ws 消息
-     */
-    async __wsListen() {
-        const { baseUrl, sessionKey, verifyKey } = this.config;
-        this.wsConnection = await _startListening({
-            baseUrl,
-            sessionKey,
-            verifyKey,
-            message: data => {
-                // 如果当前到达的事件拥有处理器，则依次调用所有该事件的处理器
-                if (data.type in this.eventProcessorMap) {
-                    data.bot = this;
-                    return Object.values(this.eventProcessorMap[data.type])
-                        .forEach(processor => processor(data));
-                }
-            },
-            error: err => {
-                const type = 'error';
-                if (type in this.eventProcessorMap) {
-                    err.bot = this;
-                    return Object.values(this.eventProcessorMap[type])
-                        .forEach(processor => processor(err));
-                }
-                try {
-                    console.log(`ws error\n${JSON.stringify(err)}`);
-                } catch (error) { } // eslint-disable-line no-empty
-            },
-            close: (obj) => {
-                const type = 'close';
-                if (type in this.eventProcessorMap) {
-                    obj.bot = this;
-                    return Object.values(this.eventProcessorMap[type])
-                        .forEach(processor => processor(obj));
-                }
-                try {
-                    console.log(`ws close\n${JSON.stringify(obj)}`);
-                } catch (error) { }// eslint-disable-line no-empty
-            },
-            unexpectedResponse: (obj) => {
-                const type = 'unexpected-response';
-                if (type in this.eventProcessorMap) {
-                    obj.bot = this;
-                    return Object.values(this.eventProcessorMap[type])
-                        .forEach(processor => processor(obj));
-                }
-                try {
-                    console.log(`ws unexpectedResponse\n${JSON.stringify(obj)}`);
-                } catch (error) { }// eslint-disable-line no-empty
-            }
-        });
-    }
-
-
-    /**
-     * @description 关闭会话
-     * @param {boolean} keepProcessor 可选，是否保留事件处理器，默认值为 false，不保留
-     * @param {boolean} keepConfig    可选，是否保留 session baseUrl qq verifyKey，默认值为 false，不保留
-     * @returns {void}
-     */
-    async close({ keepProcessor = false, keepConfig = false } = {}) {
-        // 检查对象状态
-        if (!this.config) {
-            throw new Error('close 请先调用 open，建立一个会话');
-        }
-
-        // 需要使用的参数
-        const { baseUrl, sessionKey, qq } = this.config;
-
-        //  关闭 ws 连接
-        await _stopListening(this.wsConnection);
-
-        // 释放会话
-        await _releaseSession({ baseUrl, sessionKey, qq });
-
-        // 初始化对象状态
-        if (!keepProcessor) {
-            this.eventProcessorMap = {};
-        }
-        if (!keepConfig) {
-            this.config = undefined;
-        }
-        this.wsConnection = undefined;
-    }
-
-    /**
-     * ! messageChain 将在未来被移除
-     * @description 向 qq 好友 或 qq 群发送消息，若同时提供，则优先向好友发送消息
-     * @param {boolean} temp    可选，是否是临时会话，默认为 false
-     * @param {number}  friend  二选一，好友 qq 号
-     * @param {number}  group   二选一，群号
-     * @param {number}  quote   可选，消息引用，使用发送时返回的 messageId
-     * @param {Message} message 必选，Message 实例或 MessageType 数组
-     * @returns {number} messageId
-     */
-    async sendMessage({ temp = false, friend, group, quote, message, messageChain }) {
-        // 检查对象状态
-        if (!this.config) {
-            throw new Error('sendMessage 请先调用 open，建立一个会话');
-        }
-
-        // 检查参数
-        if (!friend && !group | !message && !messageChain) {
-            throw new Error(`sendMessage 缺少必要的 ${getInvalidParamsString({
-                'friend 或 group': friend || group,
-                'message 或 messageChain': message || messageChain,
-            })} 参数`);
-        }
-
-        if (messageChain) {
-            console.log('warning: 现在 sendMessage 方法的 message 参数可以同时接收 Message 实例或 messageChain，messageChain 参数将在未来被移除');
-        }
-
-        // 需要使用的参数
-        const { baseUrl, sessionKey } = this.config;
-
-        // 处理 message，兼容存在 messageChain 参数的版本
-        messageChain = messageChain ?? message;
-
-        if (messageChain instanceof MessageChainGetable) {
-            messageChain = messageChain.getMessageChain();
-        } else if (typeof messageChain === 'string') {
-            messageChain = [{
-                type: 'Plain',
-                text: messageChain,
-            }];
-        }
-
-        // 根据 temp、friend、group 参数的情况依次调用
-        if (temp) {
-            // 临时会话的接口，好友和群是在一起的，在内部做了参数判断并抛出异常
-            // 而正常的好友和群的发送消息接口是分开的，所以在外面做了参数判断并抛出异常，格式相同
-            return await _sendTempMessage({
-                baseUrl, sessionKey, qq: friend, group, quote, messageChain
-            });
-        } else {
-            if (friend) {
-                return await _sendFriendMessage({
-                    baseUrl, sessionKey, target: friend, quote, messageChain
-                });
-            } else if (group) {
-                return await _sendGroupMessage({
-                    baseUrl, sessionKey, target: group, quote, messageChain
-                });
-            } else {
-                throw { message: 'sendGroupMessage 缺少必要的 qq 或 group 参数' };
-            }
-        }
-    }
-
-    /**
-     * @description 向好友或群成员发送戳一戳
-     * 如果提供了 group 参数则忽略 friend
-     * mirai-api-http-v1.10.1 feature
-     * @param {number} friend 二选一，好友 qq 号
-     * @param {number} group  二选一，群成员所在群 
-     * @param {number} target 必选，目标 qq 号
-     */
-    async sendNudge({ friend, group, target }) {
-        // 检查对象状态
-        if (!this.config) {
-            throw new Error('sendNudge 请先调用 open，建立一个会话');
-        }
-
-        // 检查参数
-        if (!((group || friend) && target)) {
-            throw new Error(`sendNudge 缺少必要的 ${getInvalidParamsString({
-                'group 或 friend': group || friend,
-                'target': target,
-            })} 参数`);
-        }
-
-        // 需要使用的参数
-        const { baseUrl, sessionKey } = this.config;
-
-        // 发给群成员
-        if (group) {
-            await _sendNudge({
-                baseUrl, sessionKey,
-                target,
-                subject: group,
-                kind: 'Group',
-            });
-        }
-        // 发给好友
-        else if (friend) {
-            await _sendNudge({
-                baseUrl, sessionKey,
-                target,
-                subject: friend,
-                kind: 'Friend',
-            });
-        }
-    }
-
-    /**
-     * @description 添加一个事件处理器
-     * 框架维护的 WebSocket 实例会在 ws 的事件 message 下分发 Mirai http server 的消息
-     * 回调函数 (data) => void，data 的结构取决于消息类型，详见 mirai-api-http 的文档
-     * 而对于 ws 的其他事件 error, close, unexpectedResponse，其回调函数分别为
-     * - 'error':               (err: Error) => void
-     * - 'close':               (code: number, message: string) => void
-     * - 'unexpected-response': (request: http.ClientRequest, response: http.IncomingMessage) => void
-     * @param {string | string[]}   eventType 必选，事件类型
-     * @param {function} callback  必选，回调函数
-     * @returns {number | string[]} 事件处理器的标识，用于移除该处理器
-     */
-    on(eventType, callback) {
-        // 检查对象状态
-        if (!this.config) {
-            throw new Error('on 请先调用 open，建立一个会话');
-        }
-
-        // 检查参数
-        if (!eventType || !callback) {
-            throw new Error(`on 缺少必要的 ${getInvalidParamsString({ eventType, callback })} 参数`);
-
-        }
-
-        // 适配 eventType 数组
-        if (Array.isArray(eventType)) {
-            return eventType.map(event => this.on(event, callback));
-        }
-
-        // 为没有任何事件处理器的事件生成一个空对象 (空对象 {}，而不是 null)
-        if (!(eventType in this.eventProcessorMap)) {
-            this.eventProcessorMap[eventType] = {};
-        }
-
-        // 生成一个唯一的 handle，作为当前 
-        // processor 的标识，用于移除该处理器
-        let handle = random();
-        while (handle in this.eventProcessorMap[eventType]) {
-            handle = random();
-        }
-
-        // processor
-        // 每个事件对应多个 processor，这些 processor 和 
-        // handle 分别作为 value 和 key 包含在一个大对象中
-        let processor = callback;
-
-        // 添加事件处理器
-        this.eventProcessorMap[eventType][handle] = processor;
-        return handle;
-    }
-
-    /**
-     * @description 添加一个一次性事件处理器，回调一次后自动移除
-     * @param {string | string[]}   eventType 必选，事件类型
-     * @param {function} callback  必选，回调函数
-     * @param {boolean}  strict    可选，是否严格检测调用，由于消息可能会被中间件拦截
-     *                             当为 true 时，只有开发者的处理器结束后才会移除该处理器
-     *                             当为 false 时，即使消息被拦截，也会移除该处理器
-     * @returns {void}
-     */
-    one(eventType, callback, strict = false) {
-        // 检查对象状态
-        if (!this.config) {
-            throw new Error('one 请先调用 open，建立一个会话');
-        }
-
-        // 检查参数
-        if (!eventType || !callback) {
-            throw new Error(`one 缺少必要的 ${getInvalidParamsString({ eventType, callback })} 参数`);
-
-        }
-
-        // 适配 eventType 数组
-        if (Array.isArray(eventType)) {
-            eventType.map(event => this.one(event, callback));
-            return;
-        }
-
-        // 为没有任何事件处理器的事件生成一个空对象 (空对象 {}，而不是 null)
-        if (!(eventType in this.eventProcessorMap)) {
-            this.eventProcessorMap[eventType] = {};
-        }
-
-        // 生成一个唯一的 handle，作为当前 
-        // processor 的标识，用于移除该处理器
-        let handle = random();
-        while (handle in this.eventProcessorMap[eventType]) {
-            handle = random();
-        }
-
-        // processor
-        // 每个事件对应多个 processor，这些 processor 和 h
-        // andle 分别作为 value 和 key 包含在一个大对象中
-        const processor = async (data) => {
-            if (strict) {
-                // 严格检测回调
-                // 当开发者的处理器结束后才移除该处理器，这里等待异步回调
-                await callback(data);
-                if (handle in this.eventProcessorMap[eventType]) {
-                    delete this.eventProcessorMap[eventType][handle];
-                }
-            } else {
-                // 不严格检测，直接移除处理器
-                // 从 field eventProcessorMap 中移除 handle 指定的事件处理器
-                if (handle in this.eventProcessorMap[eventType]) {
-                    delete this.eventProcessorMap[eventType][handle];
-                }
-
-                // 调用开发者提供的回调
-                callback(data);
-            }
-        };
-
-        // 添加事件处理器
-        this.eventProcessorMap[eventType][handle] = processor;
-    }
-
-    /**
-     * @description 移除一个事件处理器
-     * @param {string}                 eventType 必选，事件类型
-     * @param {number | number[]} handle    
-     * 可选，事件处理器标识(或数组)，由 on 方法返回，未提供时将移除该事件下的所有处理器
-     * @returns {void}
-     */
-    off(eventType, handle) {
-        // 检查对象状态
-        if (!this.config) {
-            throw new Error('off 请先调用 open，建立一个会话');
-        }
-
-        // 检查参数
-        if (!eventType) {
-            throw new Error('off 缺少必要的 eventType 参数');
-        }
-
-
-        if (handle) {
-            // 从 field eventProcessorMap 中移除 handle 指定的事件处理器
-            if (handle.forEach) {
-                // 可迭代
-                handle.forEach(hd => {
-                    if (hd in this.eventProcessorMap[eventType]) {
-                        delete this.eventProcessorMap[eventType][hd];
-                    }
-                });
-            } else {
-                // 不可迭代，认为是单个标识
-                if (handle in this.eventProcessorMap[eventType]) {
-                    delete this.eventProcessorMap[eventType][handle];
-                }
-            }
-        } else {
-            // 未提供 handle，移除所有
-            if (eventType in this.eventProcessorMap) {
-                delete this.eventProcessorMap[eventType];
-            }
-        }
-
-    }
-
-    /**
-     * @description 移除所有事件处理器
-     * @param {string | string[]} eventType 可选，事件类型(或数组)
-     * @returns {void}
-     */
-    offAll(eventType) {
-        // 检查对象状态
-        if (!this.config) {
-            throw new Error('offAll 请先调用 open，建立一个会话');
-        }
-
-        if (eventType) {
-            // 提供了特定的 eventType 参数
-            if (eventType.forEach) {
-                // 可迭代
-                eventType.forEach(evtType => {
-                    if (evtType in this.eventProcessorMap) {
-                        delete this.eventProcessorMap[evtType];
-                    }
-                });
-            } else {
-                // 不可迭代
-                if (eventType in this.eventProcessorMap) {
-                    delete this.eventProcessorMap[eventType];
-                }
-            }
-        } else {
-            // 未提供参数，全部移除
-            this.eventProcessorMap = {};
-        }
-    }
-
-    /**
-     * @description 获取 config
-     * @returns {Object} 结构 { cacheSize, enableWebsocket }
-     */
-    async getSessionConfig() {
-        // 检查对象状态
-        if (!this.config) {
-            throw new Error('getConfig 请先调用 open，建立一个会话');
-        }
-
-        const { baseUrl, sessionKey } = this.config;
-        return await _getSessionConfig({ baseUrl, sessionKey });
-    }
-
-    /**
-     * @description 设置 config
-     * @param   {number}  cacheSize       可选，插件缓存大小
-     * @param   {boolean} enableWebsocket 可选，websocket 状态
-     * @returns {void}
-     */
-    async setSessionConfig({ cacheSize, enableWebsocket }) {
-        // 检查对象状态
-        if (!this.config) {
-            throw new Error('setConfig 请先调用 open，建立一个会话');
-        }
-
-        const { baseUrl, sessionKey } = this.config;
-        await _setSessionConfig({ baseUrl, sessionKey, cacheSize, enableWebsocket });
-    }
-
-    /**
-     * @description 撤回由 messageId 确定的消息
-     * @param {number} messageId 欲撤回消息的 messageId
-     * @returns {void}
-     */
-    async recall({ messageId }) {
-        // 检查对象状态
-        if (!this.config) {
-            throw new Error('recall 请先调用 open，建立一个会话');
-        }
-
-        // 检查参数
-        if (!messageId) {
-            throw new Error('recall 缺少必要的 messageId 参数');
-        }
-
-        const { baseUrl, sessionKey } = this.config;
-        // 撤回消息
-        await _recall({ baseUrl, sessionKey, target: messageId });
-    }
-
-    /**
-     * FIXME: type 指定为 'friend' 或 'temp' 时发送的图片显示红色感叹号，无法加载，group 则正常
-     * @description 上传图片至服务器，返回指定 type 的 imageId，url，及 path
-     * @param {string} type     可选，"friend" 或 "group" 或 "temp"，默认为 "group"
-     * @param {Buffer} img      二选一，图片二进制数据
-     * @param {string} filename 二选一，图片文件路径
-     * @returns {Object} 结构 { imageId, url, path } 
-     */
-    async uploadImage({ type = 'group', img, filename }) {
-        if (isBrowserEnv()) { throw new Error('uploadImage 在浏览器环境下不可用'); }
-        // 检查对象状态
-        if (!this.config) {
-            throw new Error('uploadImage 请先调用 open，建立一个会话');
-        }
-
-        // 检查参数
-        if (isBrowserEnv() && filename) {
-            throw new Error('uploadImage 浏览器端不支持 filename 参数');
-        }
-        if (!img && !filename) {
-            throw new Error('uploadImage 缺少必要的 img 或 filename 参数');
-        }
-
-        // 若传入 filename 则统一转换为 Buffer
-        if (filename) {
-            // 优先使用 img 的原值
-            img = img ?? await promisify(fs.readFile)(filename);
-        }
-
-        const { baseUrl, sessionKey } = this.config;
-        return await _uploadImage({ baseUrl, sessionKey, type, img });
-    }
-
-    /**
-     * FIXME: 目前该功能返回的 voiceId 无法正常使用，无法
-     * 发送给好友，提示 message is empty，发到群里则是 1s 的无声语音
-     * @description 上传语音至服务器，返回 voiceId, url 及 path
-     * @param {string} type     TODO: 目前仅支持 "group"，请忽略该参数
-     * @param {Buffer} voice    二选一，语音二进制数据
-     * @param {string} filename 二选一，语音文件路径
-     * @returns {Object} 结构 { voiceId, url, path } 
-     */
-    async uploadVoice({ type = 'group', voice, filename }) {
-        if (isBrowserEnv()) { throw new Error('uploadVoice 在浏览器环境下不可用'); }
-        // 检查对象状态
-        if (!this.config) {
-            throw new Error('uploadVoice 请先调用 open，建立一个会话');
-        }
-
-        // 检查参数
-        if (isBrowserEnv() && filename) {
-            throw new Error('uploadVoice 浏览器端不支持 filename 参数');
-        }
-        if (!voice && !filename) {
-            throw new Error('uploadVoice 缺少必要的 voice 或 filename 参数');
-        }
-
-        // 若传入 filename 则统一转换为 Buffer
-        if (filename) {
-            // 优先使用 img 的原值
-            voice = voice ?? await promisify(fs.readFile)(filename);
-        }
-
-        const { baseUrl, sessionKey } = this.config;
-        return await _uploadVoice({ baseUrl, sessionKey, type, voice });
-    }
-
-    /**
-     * @description 获取好友列表
-     * @returns {Object[]} 结构 array[...{ id, name, remark }]
-     */
-    async getFriendList() {
-        // 检查对象状态
-        if (!this.config) {
-            throw new Error('getFriendList 请先调用 open，建立一个会话');
-        }
-
-        const { baseUrl, sessionKey } = this.config;
-
-        // 获取列表
-        const friendList = await _getFriendList({ baseUrl, sessionKey });
-
-        // 这里希望所有列表应该具有相同的属性名
-        friendList.map((value) => {
-            value.name = value.nickname;
-            delete value.nickname;
-        });
-        return friendList;
-    }
-
-    /**
-     * @description 获取群列表
-     * @returns {Object[]} 结构 array[...{ id, name, permission }]
-     */
-    async getGroupList() {
-        // 检查对象状态
-        if (!this.config) {
-            throw new Error('getGroupList 请先调用 open，建立一个会话');
-        }
-
-        const { baseUrl, sessionKey } = this.config;
-        return await _getGroupList({ baseUrl, sessionKey });
-    }
-
-    /**
-     * @description 获取指定群的成员列表
-     * @param {number} group 必选，欲获取成员列表的群号
-     * @returns {Object[]} 结构 array[...{ id, name, permission }]
-     */
-    async getMemberList({ group }) {
-        // 检查对象状态
-        if (!this.config) {
-            throw new Error('getMemberList 请先调用 open，建立一个会话');
-        }
-
-        // 检查参数
-        if (!group) {
-            throw new Error('getMemberList 缺少必要的 group 参数');
-        }
-
-        // 获取列表
-        const { baseUrl, sessionKey } = this.config;
-        const memberList = await _getMemberList({ baseUrl, sessionKey, target: group });
-
-        // 这里希望所有列表应该具有相同的属性名
-        memberList.map((value) => {
-            value.name = value.memberName;
-            delete value.group;
-            delete value.memberName;
-        });
-        return memberList;
-    }
-
-    /**
-     * @description 获取群成员信息
-     * @param {number} group 必选，群成员所在群号
-     * @param {number} qq    必选，群成员的 qq 号
-     * @returns {Object}
-     */
-    async getMemberInfo({ group, qq }) {
-        // 检查对象状态
-        if (!this.config) {
-            throw new Error('getMemberInfo 请先调用 open，建立一个会话');
-        }
-
-        // 检查参数
-        if (!group || !qq) {
-            throw new Error(`getMemberInfo 缺少必要的 ${getInvalidParamsString({
-                group, qq
-            })} 参数`);
-        }
-
-        // 获取列表
-        const { baseUrl, sessionKey } = this.config;
-        const memberInfo = await _getMemberInfo({
-            baseUrl, sessionKey, target: group, memberId: qq
-        });
-
-        // 将 specialTitle 改为 title，在 setMemberInfo 也保持一致
-        memberInfo.title = memberInfo.specialTitle;
-        delete memberInfo.specialTitle;
-
-        return memberInfo;
-    }
-
-    /**
-     * @description 获取群成员信息
-     * @param {number} qq    必选，用户的 qq 号
-     * @returns {Object} 结构 { nickname, email, age, level, sign, sex }
-     */
-    async getUserProfile({ qq }) {
-        // 检查对象状态
-        if (!this.config) {
-            throw new Error('getUserProfile 请先调用 open，建立一个会话');
-        }
-
-        // 检查参数
-        if (!qq) {
-            throw new Error('getUserProfile 缺少必要的 qq 参数');
-        }
-
-        const { baseUrl, sessionKey } = this.config;
-        return await _getUserProfile({ baseUrl, sessionKey, target: qq });
-    }
-
-    /**
-     * @description 设置群成员信息
-     * @param {number} group 必选，群成员所在群号
-     * @param {number} qq    必选，群成员的 qq 号
-     * @param {string} name  可选，要设置的群名片
-     * @param {string} title 可选，要设置的群头衔
-     * @param {boolean} permission 可选，要设置的权限，
-     * 使用枚举值：Bot.Permission.Admin, Bot.Permission.Member
-     * @returns {void}
-     */
-    async setMemberInfo({ group, qq, name, title, permission }) {
-        // 检查对象状态
-        if (!this.config) {
-            throw new Error('setMemberInfo 请先调用 open，建立一个会话');
-        }
-
-        // 检查参数
-        if (!group || !qq) {
-            throw new Error(`setMemberInfo 缺少必要的 ${getInvalidParamsString({
-                group, qq
-            })} 参数`);
-        }
-        if (permission != undefined
-            && permission != Bot.groupPermission.ADMINISTRATOR
-            && permission != Bot.groupPermission.MEMBER) {
-            throw new Error('setMemberInfo admin 参数只能是 Bot.groupPermission.ADMINISTRATOR 或 Bot.groupPermission.Member');
-        }
-
-        // setMemberInfo
-        const { baseUrl, sessionKey } = this.config;
-        if (name != undefined || title != undefined) {
-            await _setMemberInfo({
-                baseUrl, sessionKey, target: group, memberId: qq,
-                name, specialTitle: title,
-            });
-        }
-
-        // setPermission
-        if (permission != undefined) {
-            await _setMemberAdmin({
-                baseUrl, sessionKey, target: group, memberId: qq,
-                assign: permission == Bot.groupPermission.ADMINISTRATOR ? true : false,
-            });
-        }
-    }
-
-    /**
-     * @description 获取群公告列表迭代器
-     * @param {number} group 必选，群号
-     * @returns 迭代器
-     */
-    async *getAnnoIter({ group }) {
-        // 检查对象状态
-        if (!this.config) {
-            throw new Error('getAnno 请先调用 open，建立一个会话');
-        }
-
-        // 检查参数
-        if (!group) {
-            throw new Error('getAnno 缺少必要的 group 参数');
-        }
-
-        // 获取列表
-        const { baseUrl, sessionKey } = this.config;
-        let offset = 0;
-        let annoList = await _getAnnoList({ baseUrl, sessionKey, id: group, offset, size: 10 });
-        while (annoList.length > 0) {
-            for (const anno of annoList) {
-                yield anno;
-            }
-
-            // 获取下一页
-            offset += 10;
-            annoList = await _getAnnoList({ baseUrl, sessionKey, id: group, offset, size: 10 });
-        }
-
-        return;
-    }
-
-    /**
-     * @description 发布群公告
-     * @param {number} group 必选，群号
-     * @param {string} content 必选，公告内容
-     * @returns {void}
-     */
-    async publishAnno({ group, content, pinned }) {
-        // 检查对象状态
-        if (!this.config) {
-            throw new Error('publishAllo 请先调用 open，建立一个会话');
-        }
-
-        // 检查参数
-        if (!group || !content) {
-            throw new Error(`publishAllo 缺少必要的 ${getInvalidParamsString({
-                group, content
-            })} 参数`);
-        }
-
-        // 发布公告
-        const { baseUrl, sessionKey } = this.config;
-        await _publishAnno({ baseUrl, sessionKey, target: group, content, pinned });
-    }
-
-    /**
-     * @description 删除群公告
-     * @param {number} group 必选，群号
-     * @param {string} fid 必选，公告 id
-     * @reaturns {void}
-     */
-    async deleteAnno({ group, fid }) {
-        // 检查对象状态
-        if (!this.config) {
-            throw new Error('deleteAnno 请先调用 open，建立一个会话');
-        }
-
-        // 检查参数
-        if (!group || !fid) {
-            throw new Error(`deleteAnno 缺少必要的 ${getInvalidParamsString({
-                group, fid
-            })} 参数`);
-        }
-
-        // 发布公告
-        const { baseUrl, sessionKey } = this.config;
-        await _deleteAnno({ baseUrl, sessionKey, id: group, fid });
-    }
-
-    /**
-     * @description 禁言群成员
-     * @param {number} group 必选，欲禁言成员所在群号
-     * @param {number} qq    必选，欲禁言成员 qq 号
-     * @param {number} time  必选，禁言时长，单位: s (秒)
-     * @returns {void}
-     */
-    async mute({ group, qq, time }) {
-        // 检查对象状态
-        if (!this.config) {
-            throw new Error('mute 请先调用 open，建立一个会话');
-        }
-
-        // 检查参数
-        if (!group || !qq || !time) {
-            throw new Error(`mute 缺少必要的 ${getInvalidParamsString({ group, qq, time })} 参数`);
-        }
-
-        const { baseUrl, sessionKey } = this.config;
-        // 禁言
-        await _mute({ baseUrl, sessionKey, target: group, memberId: qq, time });
-    }
-
-    /**
-     * @description 全员禁言
-     * @param {number} group 必选，欲全员禁言的群号
-     * @returns {void}
-     */
-    async muteAll({ group }) {
-        // 检查对象状态
-        if (!this.config) {
-            throw new Error('muteAll 请先调用 open，建立一个会话');
-        }
-
-        // 检查参数
-        if (!group) {
-            throw new Error('muteAll 缺少必要的 group 参数');
-        }
-
-        const { baseUrl, sessionKey } = this.config;
-        // 禁言
-        await _muteAll({ baseUrl, sessionKey, target: group });
-    }
-
-    /**
-     * @description 解除禁言
-     * @param {number} group 必选，欲解除禁言的成员所在群号
-     * @param {number} qq    必选，欲解除禁言的成员 qq 号
-     * @returns {void}
-     */
-    async unmute({ group, qq }) {
-        // 检查对象状态
-        if (!this.config) {
-            throw new Error('unmute 请先调用 open，建立一个会话');
-        }
-
-        // 检查参数
-        if (!group || !qq) {
-            throw new Error(`unmute 缺少必要的 ${getInvalidParamsString({ group, qq })} 参数`);
-        }
-
-        const { baseUrl, sessionKey } = this.config;
-        // 禁言
-        await _unmute({ baseUrl, sessionKey, target: group, memberId: qq });
-    }
-
-    /**
-     * @description 解除全员禁言
-     * @param {number} group 必选，欲解除全员禁言的群号
-     * @returns {void}
-     */
-    async unmuteAll({ group }) {
-        // 检查对象状态
-        if (!this.config) {
-            throw new Error('unmute 请先调用 open，建立一个会话');
-        }
-
-        // 检查参数
-        if (!group) {
-            throw new Error('unmute 缺少必要的 group 参数');
-        }
-
-        const { baseUrl, sessionKey } = this.config;
-        // 禁言
-        await _unmuteAll({ baseUrl, sessionKey, target: group });
-    }
-
-    /**
-     * @description 移除群成员
-     * @param {number} group   必选，欲移除的成员所在群号
-     * @param {number} qq      必选，欲移除的成员 qq 号
-     * @param {string} message 可选，默认为空串 ""，信息
-     * @returns {void}
-     */
-    async removeMember({ group, qq, message = '' }) {
-        // 检查对象状态
-        if (!this.config) {
-            throw new Error('removeMember 请先调用 open，建立一个会话');
-        }
-
-        // 检查参数
-        if (!group || !qq) {
-            throw new Error(`removeMember 缺少必要的 ${getInvalidParamsString({ group, qq })} 参数`);
-        }
-
-        const { baseUrl, sessionKey } = this.config;
-        // 禁言
-        await _removeMember({ baseUrl, sessionKey, target: group, memberId: qq, msg: message });
-    }
-
-    /**
-     * @description 删除好友
-     * @param {*} qq 欲删除的好友 qq 号
-     * @returns {void}
-     */
-    async removeFriend({ qq }) {
-        // 检查对象状态
-        if (!this.config) {
-            throw new Error('removeFriend 请先调用 open，建立一个会话');
-        }
-
-        // 检查参数
-        if (!qq) {
-            throw new Error('removeFriend 缺少必要的 qq 参数');
-        }
-
-        const { baseUrl, sessionKey } = this.config;
-
-        // 删除好友
-        await _removeFriend({ baseUrl, sessionKey, target: qq });
-    }
-
-    /**
-     * @description 移除群成员
-     * @param {number} group   必选，欲移除的成员所在群号
-     * @returns {void}
-     */
-    async quitGroup({ group }) {
-        // 检查对象状态 
-        if (!this.config) {
-            throw new Error('quitGroup 请先调用 open，建立一个会话');
-        }
-
-        // 检查参数
-        if (!group) {
-            throw new Error('quitGroup 缺少必要的 group 参数');
-        }
-
-        const { baseUrl, sessionKey } = this.config;
-        // 禁言
-        await _quitGroup({ baseUrl, sessionKey, target: group });
-    }
-
-    /**
-     * @description 获取群配置
-     * @param {number} group 必选，群号
-     * @returns {Object}
-     */
-    async getGroupConfig({ group }) {
-        // 检查对象状态
-        if (!this.config) {
-            throw new Error('getGroupConfig 请先调用 open，建立一个会话');
-        }
-
-        // 检查参数
-        if (!group) {
-            throw new Error('getGroupConfig 缺少必要的 group 参数');
-        }
-
-        const { baseUrl, sessionKey } = this.config;
-        return await _getGroupConfig({ baseUrl, sessionKey, target: group });
-    }
-
-    /**
-     * @description 设置群配置
-     * @param {number}  group             必选，群号
-     * @param {string}  name	          可选，群名
-     * @param {string}  announcement	  可选，群公告
-     * @param {boolean} confessTalk	      可选，是否开启坦白说
-     * @param {boolean} allowMemberInvite 可选，是否允许群员邀请
-     * @param {boolean} autoApprove	      可选，是否开启自动审批入群
-     * @param {boolean} anonymousChat     可选，是否允许匿名聊天
-     * @returns {void}
-     */
-    async setGroupConfig({
-        group,
-        name, announcement, confessTalk, allowMemberInvite, autoApprove, anonymousChat,
-    }) {
-        // 检查对象状态
-        if (!this.config) {
-            throw new Error('setGroupConfig 请先调用 open，建立一个会话');
-        }
-
-        // 检查参数
-        if (!group) {
-            throw new Error('setGroupConfig 缺少必要的 group 参数');
-        }
-
-
-        const { baseUrl, sessionKey } = this.config;
-        await _setGroupConfig({
-            baseUrl, sessionKey, target: group,
-            name, announcement,
-            confessTalk,
-            allowMemberInvite,
-            autoApprove,
-            anonymousChat,
-        });
-    }
-
-    /**
-     * @description 文件管理器的工厂方法
-     * @param {number} group 群号 
-     * @returns {FileManager} 文件管理器实例
-     */
-    fileManager({ group }) {
-        return new FileManager({ bot: this, group });
-    }
-
-    /**
-     * @description 设置群精华消息
-     * @param {number} messageId 必选，消息 id
-     * @returns {void}
-     */
-    async setEssence({ messageId }) {
-        // 检查对象状态
-        if (!this.config) {
-            throw new Error('setEssence 请先调用 open，建立一个会话');
-        }
-
-        // 检查参数
-        if (!messageId) {
-            throw new Error('setEssence 缺少必要的 messageId 参数');
-        }
-
-        const { baseUrl, sessionKey } = this.config;
-        await _setEssence({ baseUrl, sessionKey, target: messageId });
-    }
-
-    /**
-     * @description 向 mirai-console 发送指令
-     * @param {string[]}   command 必选，指令和参数
-     * @returns {Object} 结构 { message }，注意查看 message 的内容，已知的问题：
-     * 'Login failed: Mirai 无法完成滑块验证. 使用协议 ANDROID_PHONE 强制要求滑块验证, 
-     * 请更换协议后重试. 另请参阅: https://github.com/project-mirai/mirai-login-solver-selenium'
-     */
-    async sendCommand({ command }) {
-        // 检查对象状态
-        if (!this.config) {
-            throw new Error('setEssence 请先调用 open，建立一个会话');
-        }
-
-        // 检查参数
-        if (!command) {
-            throw new Error(`sendCommand 缺少必要的 ${getInvalidParamsString({ command })} 参数`);
-        }
-
-        const { Message } = require('./Message');
-        const { baseUrl, sessionKey } = this.config;
-        return await _sendCommand({
-            baseUrl, sessionKey,
-            command: command
-                .map((v) => v?.toString() ?? '')
-                .reduce((acc, cur) => acc.addText(cur), new Message)
-                .messageChain
-        });
-    }
-
-    /**
-     * @description 通过 messageId 获取消息
-     * @param {number} target    可选, 目标 qq 号/群号, mah v2.6.0+ 新增该参数
-     * @param {number} messageId 必选, 消息 id
-     * @returns {Object} 结构 { type, messageChain, sender }
-     */
-    async getMessageById({ messageId, target }) {
-        // 检查对象状态
-        if (!this.config) {
-            throw new Error('getMessageById 请先调用 open，建立一个会话');
-        }
-
-        // 检查参数
-        if (!messageId) {
-            throw new Error('getMessageById 缺少必要的 messageId 参数');
-        }
-
-        const { baseUrl, sessionKey } = this.config;
-        return await _messageFromId({ baseUrl, sessionKey, target, messageId });
-    }
-
-    /**
-     * @description 检测该账号是否已经在 mirai-console 登录
-     * @param {string} baseUrl 必选，mirai-api-http server 的地址
-     * @param {string} verifyKey 必选，mirai-api-http server 设置的 verifyKey
-     * @param {number} qq      必选，qq 号
-     * @returns 
-     */
-    static async isBotLoggedIn({ baseUrl, verifyKey, qq }) {
-        // 检查参数
-        if (!baseUrl || !verifyKey || !qq) {
-            throw new Error(`isBotLoggedIn 缺少必要的 ${getInvalidParamsString({ baseUrl, verifyKey, qq })} 参数`);
-        }
-
-        const sessionKey = await _verify({ baseUrl, verifyKey });
-        const { code } = await _bind({ baseUrl, sessionKey, qq, throwable: false });
-
-        if (code == errCodeEnum.BOT_NOT_FOUND) {
-            return false;
-        } else {
-            _releaseSession({ baseUrl, sessionKey, qq });
-            return true;
-        }
-    }
-
-}
-
-
-// 静态属性: 群成员的权限
-Bot.groupPermission = {
-    get OWNER() {
-        return 'OWNER';
-    },
-    get ADMINISTRATOR() {
-        return 'ADMINISTRATOR';
-    },
-    get MEMBER() {
-        return 'MEMBER';
-    },
-};
-
-module.exports = { Bot };