wechaty-puppet-matrix 0.0.4

package/dist/esm/src/matrix/service/request.js

@@ -0,0 +1,1286 @@
+import axios from 'axios';
+import { log } from '@juzi/wechaty-puppet';
+import { EventEmitter } from 'events';
+import WebSocket from 'ws';
+import * as PUPPET from '@juzi/wechaty-puppet';
+import { format, getUnixTime } from 'date-fns';
+import { xmlToJson } from '../utils/xml-to-json.js';
+import { isRoomId } from '../utils/is-type.js';
+const PRE = '[PuppetMatrix]';
+export var NotifyTypeEnum;
+(function (NotifyTypeEnum) {
+    NotifyTypeEnum[NotifyTypeEnum["Ready"] = 1001] = "Ready";
+    NotifyTypeEnum[NotifyTypeEnum["LoginQRCodeChange"] = 1002] = "LoginQRCodeChange";
+    NotifyTypeEnum[NotifyTypeEnum["UserLogin"] = 1003] = "UserLogin";
+    NotifyTypeEnum[NotifyTypeEnum["UserLogout"] = 1004] = "UserLogout";
+    NotifyTypeEnum[NotifyTypeEnum["InitFinish"] = 1005] = "InitFinish";
+    NotifyTypeEnum[NotifyTypeEnum["HeartBeatError"] = 1006] = "HeartBeatError";
+    NotifyTypeEnum[NotifyTypeEnum["SessionTimeout"] = 1007] = "SessionTimeout";
+    NotifyTypeEnum[NotifyTypeEnum["LoginFailed"] = 1008] = "LoginFailed";
+    NotifyTypeEnum[NotifyTypeEnum["ContactSyncFinish"] = 1009] = "ContactSyncFinish";
+    NotifyTypeEnum[NotifyTypeEnum["NewMsg"] = 1010] = "NewMsg";
+    NotifyTypeEnum[NotifyTypeEnum["ContactInfoChange"] = 1039] = "ContactInfoChange";
+    NotifyTypeEnum[NotifyTypeEnum["FriendAdd"] = 1040] = "FriendAdd";
+    NotifyTypeEnum[NotifyTypeEnum["FriendDel"] = 1041] = "FriendDel";
+    NotifyTypeEnum[NotifyTypeEnum["RoomAdd"] = 1042] = "RoomAdd";
+    NotifyTypeEnum[NotifyTypeEnum["RoomQuit"] = 1043] = "RoomQuit";
+    NotifyTypeEnum[NotifyTypeEnum["RoomDelMe"] = 1044] = "RoomDelMe";
+    NotifyTypeEnum[NotifyTypeEnum["RoomDisband"] = 1045] = "RoomDisband";
+    NotifyTypeEnum[NotifyTypeEnum["RoomMemberAdd"] = 1046] = "RoomMemberAdd";
+    NotifyTypeEnum[NotifyTypeEnum["RoomMemberUpdate"] = 1047] = "RoomMemberUpdate";
+    NotifyTypeEnum[NotifyTypeEnum["RoomMemberDel"] = 1048] = "RoomMemberDel";
+})(NotifyTypeEnum || (NotifyTypeEnum = {}));
+var ContactGender;
+(function (ContactGender) {
+    ContactGender[ContactGender["Unknown"] = 0] = "Unknown";
+    ContactGender[ContactGender["Male"] = 1] = "Male";
+    ContactGender[ContactGender["Female"] = 2] = "Female";
+})(ContactGender || (ContactGender = {}));
+var Status;
+(function (Status) {
+    Status["normal"] = "normal";
+    Status["offline"] = "offline";
+    Status["pending"] = "pending";
+    Status["fail"] = "fail";
+})(Status || (Status = {}));
+export var WechatMessageType;
+(function (WechatMessageType) {
+    WechatMessageType[WechatMessageType["Text"] = 1] = "Text";
+    WechatMessageType[WechatMessageType["Image"] = 3] = "Image";
+    WechatMessageType[WechatMessageType["Voice"] = 34] = "Voice";
+    WechatMessageType[WechatMessageType["VerifyMsg"] = 37] = "VerifyMsg";
+    WechatMessageType[WechatMessageType["PossibleFriendMsg"] = 40] = "PossibleFriendMsg";
+    WechatMessageType[WechatMessageType["ShareCard"] = 42] = "ShareCard";
+    WechatMessageType[WechatMessageType["Video"] = 43] = "Video";
+    WechatMessageType[WechatMessageType["Emoticon"] = 47] = "Emoticon";
+    WechatMessageType[WechatMessageType["Location"] = 48] = "Location";
+    WechatMessageType[WechatMessageType["App"] = 49] = "App";
+    WechatMessageType[WechatMessageType["VoipMsg"] = 50] = "VoipMsg";
+    WechatMessageType[WechatMessageType["StatusNotify"] = 51] = "StatusNotify";
+    WechatMessageType[WechatMessageType["VoipNotify"] = 52] = "VoipNotify";
+    WechatMessageType[WechatMessageType["VoipInvite"] = 53] = "VoipInvite";
+    WechatMessageType[WechatMessageType["MicroVideo"] = 62] = "MicroVideo";
+    WechatMessageType[WechatMessageType["VerifyMsgEnterprise"] = 65] = "VerifyMsgEnterprise";
+    WechatMessageType[WechatMessageType["Transfer"] = 2000] = "Transfer";
+    WechatMessageType[WechatMessageType["RedEnvelope"] = 2001] = "RedEnvelope";
+    WechatMessageType[WechatMessageType["MiniProgram"] = 2002] = "MiniProgram";
+    WechatMessageType[WechatMessageType["GroupInvite"] = 2003] = "GroupInvite";
+    WechatMessageType[WechatMessageType["File"] = 2004] = "File";
+    WechatMessageType[WechatMessageType["SysNotice"] = 9999] = "SysNotice";
+    WechatMessageType[WechatMessageType["Sys"] = 10000] = "Sys";
+    WechatMessageType[WechatMessageType["SysTemplate"] = 10002] = "SysTemplate";
+})(WechatMessageType || (WechatMessageType = {}));
+export var FriendshipType;
+(function (FriendshipType) {
+    FriendshipType[FriendshipType["Unknown"] = 0] = "Unknown";
+    FriendshipType[FriendshipType["Confirm"] = 1] = "Confirm";
+    FriendshipType[FriendshipType["Receive"] = 2] = "Receive";
+    FriendshipType[FriendshipType["Verify"] = 3] = "Verify";
+    FriendshipType[FriendshipType["Delete"] = 4] = "Delete";
+    FriendshipType[FriendshipType["Removed"] = 5] = "Removed";
+})(FriendshipType || (FriendshipType = {}));
+async function getAtWxidList(source) {
+    if (source) {
+        const json = await xmlToJson(source);
+        return (json?.msgsource?.atuserlist?.split(',').filter((item) => item)
+            || []);
+    }
+    return [];
+}
+class Client extends EventEmitter {
+    options;
+    socket;
+    server;
+    tokenInfo;
+    hasEmitLogout;
+    emit(event, ...args) {
+        return super.emit(event, ...args);
+    }
+    static async create(options) {
+        const client = new Client(options);
+        await client.initServer();
+        return client;
+    }
+    constructor(options = {}) {
+        super();
+        this.options = options;
+        this.tokenInfo = null;
+        this.socket = null;
+        this.hasEmitLogout = false;
+    }
+    async getTokenInfo() {
+        try {
+            const res = await axios.get(`https://api-bot.aibotk.com/openapi/v1/token/info?secret=5be06b6f8d42a7&token=${this.options.token}`);
+            if (res.data.code === 0) {
+                this.tokenInfo = res.data.data;
+                return true;
+            }
+            else {
+                log.error('Token auth failed, reason: %s', res.data.message);
+                return false;
+            }
+        }
+        catch (e) {
+            log.error('error info: %s', e);
+            return false;
+        }
+    }
+    async initServer() {
+        await this.getTokenInfo();
+        if (!this.socket) {
+            const ws = new WebSocket(`${this.tokenInfo.endpoint}?guid=${this.tokenInfo.guid}`, { perMessageDeflate: true, maxPayload: 100 * 1024 * 1024 });
+            ws.on('message', (data) => {
+                log.silly(PRE, 'initWebSocket() ws.on(message): %s', data);
+                try {
+                    const payload = JSON.parse(data);
+                    log.info(JSON.stringify(payload));
+                    void this.eventParse(payload);
+                }
+                catch (e) {
+                    log.warn(PRE, 'initWebSocket() ws.on(message) exception: %s', e);
+                    this.emit('error', e.message);
+                }
+            });
+            ws.on('message', () => {
+            });
+            ws.on('error', (e) => {
+                if (e.message.indexOf('ECONNREFUSED') !== -1) {
+                }
+                else {
+                    log.verbose(PRE, 'initWebSocket() ws.on(error) %s', e);
+                    this.emit('error', e);
+                }
+            });
+            ws.on('close', (code, reason) => {
+                log.warn(PRE, 'initWebSocket() ws.on(close) code: %s, reason: %s', code, reason);
+            });
+            await new Promise((resolve, reject) => {
+                ws.once('open', () => {
+                    log.silly(PRE, 'initWebSocket() Promise() ws.on(open)');
+                    return resolve({});
+                });
+                ws.once('error', (e) => {
+                    log.silly(PRE, 'initWebSocket() Promise() ws.on(error) %s', e);
+                    return reject(e);
+                });
+                ws.once('close', (e) => {
+                    log.silly(PRE, 'initWebSocket() Promise() ws.on(close)');
+                    return reject(e);
+                });
+            });
+            this.socket = ws;
+            return;
+        }
+        if (this.socket) {
+            throw new Error('socket had already been opened!');
+        }
+    }
+    async eventParse(eventData) {
+        const notifyType = eventData.notify_type;
+        const data = eventData.data;
+        let robotInfo, msg, contactInfo, atWxidList;
+        switch (notifyType) {
+            case NotifyTypeEnum.LoginQRCodeChange:
+                if (data.authUrl) {
+                    this.emit('verify-code', {
+                        ticket: this.getQrcodeTicket(data.authUrl),
+                        status: PUPPET.types.ScanStatus.Scanned,
+                    });
+                }
+                else {
+                    void this.onQrCodeEvent(data.status, `http://weixin.qq.com/x/${data.uuid}`);
+                }
+                break;
+            case NotifyTypeEnum.UserLogin:
+                robotInfo = {
+                    wxNum: data?.alias,
+                    wxid: data?.username || '',
+                    name: data?.nickname || '',
+                    sex: data?.sex,
+                    alias: '',
+                    province: data?.province || '',
+                    city: data?.city || '',
+                    country: data?.country || '',
+                    avatar: data?.big_headimg_url || data?.small_headimg_url || '',
+                    description: '',
+                    labelIdlist: '',
+                };
+                this.emit('login', {
+                    errorCode: 0,
+                    errorMessage: 'success',
+                    wxid: robotInfo.wxid,
+                    robotInfo,
+                });
+                break;
+            case NotifyTypeEnum.NewMsg:
+                if (data.is_chatroom_msg) {
+                    atWxidList = await getAtWxidList(data.source);
+                }
+                msg = {
+                    msg: data.content,
+                    text: data.content,
+                    id: data.msg_id,
+                    atWxidList,
+                    fromWxid: data.from_username,
+                    msgType: data.msg_type,
+                    timeStamp: data.create_time,
+                    talkerId: !data.is_chatroom_msg
+                        ? data.from_username
+                        : data.chatroom_sender,
+                    listenerId: data.to_username,
+                };
+                this.emit('message', msg);
+                break;
+            case NotifyTypeEnum.FriendAdd:
+                contactInfo = {
+                    wxNum: data?.alias,
+                    wxid: data?.username || '',
+                    name: data?.nickname || '',
+                    sex: data?.sex,
+                    alias: '',
+                    province: data?.province || '',
+                    city: data?.city || '',
+                    country: data?.country || '',
+                    avatar: data?.big_headimg_url || data?.small_headimg_url || '',
+                    description: '',
+                    labelIdlist: data?.labelid_list,
+                };
+                this.emit('contact', { type: FriendshipType.Confirm, contactInfo });
+                break;
+            case NotifyTypeEnum.ContactInfoChange:
+                contactInfo = {
+                    wxNum: data?.alias,
+                    wxid: data?.username || '',
+                    name: data?.nickname || '',
+                    sex: data?.sex,
+                    alias: '',
+                    province: data?.province || '',
+                    city: data?.city || '',
+                    country: data?.country || '',
+                    avatar: data?.big_headimg_url || data?.small_headimg_url || '',
+                    description: '',
+                    labelIdlist: data?.labelid_list,
+                };
+                this.emit('update-contacts', [contactInfo]);
+                break;
+            case NotifyTypeEnum.UserLogout:
+                this.emit('logout', data.errmsg);
+                break;
+            case NotifyTypeEnum.RoomMemberAdd:
+                this.emit('room-join', {
+                    roomId: data.room_username,
+                    inviterId: data.member_list[0]?.invite_username,
+                    joinIds: data.member_list.map((item) => item.username),
+                    joinUsers: data.member_list.map((data) => ({
+                        wxNum: data?.alias,
+                        wxid: data?.username || '',
+                        name: data?.nickname || '',
+                        sex: data?.sex,
+                        alias: '',
+                        province: data?.province || '',
+                        city: data?.city || '',
+                        country: data?.country || '',
+                        avatar: data?.big_headimg_url || data?.small_headimg_url || '',
+                        description: '',
+                        labelIdlist: data?.labelid_list,
+                    })),
+                });
+                break;
+            case NotifyTypeEnum.RoomMemberDel:
+                this.emit('room-leave', {
+                    roomId: data.room_username,
+                    leaveIds: data.member_list.map((item) => item.username),
+                });
+                break;
+            default:
+                log.info('other data', JSON.stringify(data));
+        }
+    }
+    getQrcodeTicket(authurl) {
+        if (!authurl || !authurl.startsWith('http'))
+            return '';
+        const url = new URL(authurl);
+        const searchParams = new URLSearchParams(url.search.slice(1));
+        return searchParams.get('ticket') || '';
+    }
+    async onQrCodeEvent(status, url) {
+        const ScanStatusName = {
+            [PUPPET.types.ScanStatus.Unknown]: 'Unknown',
+            [PUPPET.types.ScanStatus.Cancel]: 'Cancel',
+            [PUPPET.types.ScanStatus.Waiting]: 'Waiting',
+            [PUPPET.types.ScanStatus.Scanned]: 'Scanned',
+            [PUPPET.types.ScanStatus.Confirmed]: 'Confirmed',
+            [PUPPET.types.ScanStatus.Timeout]: 'Timeout',
+        };
+        let scanStatus = PUPPET.types.ScanStatus.Unknown;
+        let qrUrl = '';
+        switch (status) {
+            case 0:
+                scanStatus = PUPPET.types.ScanStatus.Waiting;
+                qrUrl = url;
+                break;
+            case 1:
+                scanStatus = PUPPET.types.ScanStatus.Scanned;
+                break;
+            case 2:
+                scanStatus = PUPPET.types.ScanStatus.Confirmed;
+                break;
+            case 3:
+                scanStatus = PUPPET.types.ScanStatus.Cancel;
+                break;
+            case 4:
+                scanStatus = PUPPET.types.ScanStatus.Timeout;
+                break;
+        }
+        log.silly(PRE, `scan event, status: ${ScanStatusName[scanStatus]}${url ? ', with qrcode: ' + url : ''}`);
+        this.emit('scan', {
+            qrcode: qrUrl,
+            status: scanStatus,
+        });
+    }
+    setEmitLogout(val) {
+        this.hasEmitLogout = val;
+        if (val) {
+            let time = setTimeout(() => {
+                this.hasEmitLogout = false;
+                clearTimeout(time);
+                time = null;
+            }, 10000);
+        }
+    }
+    async postData(data) {
+        const config = {
+            data: {
+                guid: this.tokenInfo.guid,
+                ...data.data,
+            },
+            headers: {
+                'Content-Type': 'application/json',
+            },
+            method: 'POST',
+            url: this.tokenInfo.httpServer + data.path,
+            timeout: 600000,
+        };
+        const res = await axios(config);
+        if (res.data?.errcode === -102) {
+            log.warn('request error: %s', res.data?.errmsg);
+            if (!this.hasEmitLogout) {
+                this.setEmitLogout(true);
+                this.emit('logout', res.data?.errmsg);
+            }
+            return {};
+        }
+        return res.data;
+    }
+    async getStats() {
+        const res = await this.postData({
+            path: '/client/get_client_status',
+            data: {},
+        });
+        const { errcode, data } = res;
+        if (!errcode) {
+            return {
+                status: data.status === 1
+                    ? Status.pending
+                    : data.status === 2
+                        ? Status.normal
+                        : Status.offline,
+            };
+        }
+        else {
+            return { status: Status.fail };
+        }
+    }
+    async getQrcode() {
+        try {
+            const res = await this.postData({
+                path: '/login/get_login_qrcode',
+                data: {},
+            });
+            if (res?.qrcode) {
+                return {
+                    base64: `data:image/jpeg;base64,${res?.qrcode?.buffer}`,
+                    qrcodeUrl: `http://weixin.qq.com/x/${res?.uuid}`,
+                    uuid: res?.uuid,
+                    expiredTime: res?.expiredTime,
+                };
+            }
+            log.info(PRE, 'getQrcode error:', res?.errmsg);
+            return null;
+        }
+        catch (e) {
+            log.error(PRE, 'getQrcode(): %s', e);
+            return null;
+        }
+    }
+    async getQrcodeStatus() {
+        try {
+            const res = await this.postData({
+                path: '/login/check_login_qrcode',
+                data: {},
+            });
+            if (res?.uuid) {
+                return res;
+            }
+            log.info(PRE, 'getQrcodeStatus error:', res?.errmsg);
+            return {
+                status: 4,
+            };
+        }
+        catch (e) {
+            log.error(PRE, 'getQrcodeStatus(): %s', e);
+            return {
+                status: 4,
+            };
+        }
+    }
+    async verifyLoginUrl(ticket, pin) {
+        try {
+            const res = await this.postData({
+                path: '/login/verify_login_url',
+                data: {
+                    ticket,
+                    pin,
+                },
+            });
+            log.info(PRE, 'verifyLoginUrl', res);
+        }
+        catch (e) {
+            log.error(PRE, 'verifyLoginUrl(): %s', e);
+        }
+    }
+    async pushLoginNotify() {
+        await this.postData({
+            path: '/login/push_login_url',
+            data: {},
+        });
+    }
+    async getSelfInfo() {
+        try {
+            const res = await this.postData({ path: '/user/get_profile', data: {} });
+            if (res.errcode === -102) {
+                log.info(PRE, 'offline login:', res?.errmsg);
+                return false;
+            }
+            else if (res.userInfo) {
+                const contact = res?.userInfo;
+                const contactMore = res?.userInfoExt;
+                return {
+                    wxNum: contact.alias,
+                    wxid: contact?.userName?.string || '',
+                    name: contact?.nickName?.string || '',
+                    sex: contact?.sex,
+                    alias: contact?.remark?.string || '',
+                    province: contact?.province || '',
+                    city: contact?.city || '',
+                    country: contact?.country || '',
+                    avatar: contactMore?.bigHeadImgUrl || contactMore?.smallHeadImgUrl || '',
+                    description: contact?.description,
+                    labelIdlist: contact?.labelIdlist,
+                };
+            }
+            log.info(PRE, 'get self info error:(%s)', res?.errmsg);
+            return false;
+        }
+        catch (e) {
+            log.error(PRE, 'getSelfInfo(): %s', e);
+            return false;
+        }
+    }
+    async getUserQrcode() {
+        try {
+            const res = await this.postData({
+                path: '/user/get_qrcode',
+                data: {},
+            });
+            return res.qrcodeUrl;
+        }
+        catch (e) {
+            log.error(PRE, 'getUserQrcode(): %s', e);
+            return '';
+        }
+    }
+    async logout() {
+        try {
+            await this.postData({
+                path: '/user/logout',
+                data: {},
+            });
+        }
+        catch (e) {
+            log.error(PRE, 'logout(): %s', e);
+        }
+    }
+    async searchContact(contactIds) {
+        if (!contactIds.length)
+            return;
+        try {
+            const res = await this.postData({
+                path: '/contact/batch_get_contact_brief_info',
+                data: {
+                    username_list: contactIds,
+                },
+            });
+            if (res.contactList?.length === 1) {
+                const contactInfo = res.contactList?.length
+                    ? res.contactList[0]
+                    : undefined;
+                if (contactInfo) {
+                    const contact = contactInfo.contact;
+                    return {
+                        wxNum: contact.alias,
+                        wxid: contact?.userName?.string || '',
+                        name: contact?.nickName?.string || '',
+                        sex: contact?.sex,
+                        alias: contact?.remark?.string || '',
+                        province: contact?.province || '',
+                        city: contact?.city || '',
+                        country: contact?.country || '',
+                        avatar: contact?.bigHeadImgUrl || contact?.smallHeadImgUrl || '',
+                        description: contact?.description,
+                        labelIdlist: contact?.labelIdlist,
+                    };
+                }
+                return undefined;
+            }
+            else {
+                const contacts = res.contactList?.map((contactInfo) => {
+                    const contact = contactInfo.contact;
+                    return {
+                        wxNum: contact.alias,
+                        wxid: contact?.userName?.string || '',
+                        name: contact?.nickName?.string || '',
+                        sex: contact?.sex,
+                        alias: contact?.remark?.string || '',
+                        province: contact?.province || '',
+                        city: contact?.city || '',
+                        country: contact?.country || '',
+                        avatar: contact?.bigHeadImgUrl || contact?.smallHeadImgUrl || '',
+                        description: contact?.description,
+                        labelIdlist: contact?.labelIdlist,
+                    };
+                }) || [];
+                return contacts;
+            }
+        }
+        catch (e) {
+            log.error(PRE, 'searchContact(%s): %s', contactIds, e);
+            return undefined;
+        }
+    }
+    async searchContactDetail(contactIds, roomId) {
+        if (!contactIds.length && !roomId)
+            return undefined;
+        try {
+            const data = {};
+            if (contactIds.length) {
+                data['username_list'] = contactIds;
+            }
+            if (roomId) {
+                data['room_username'] = roomId;
+            }
+            const res = await this.postData({
+                path: '/contact/get_contact',
+                data,
+            });
+            if (res.contactList?.length === 1) {
+                const contactInfo = res.contactList.length
+                    ? res.contactList[0]
+                    : undefined;
+                if (contactInfo) {
+                    const contact = contactInfo.contact || {};
+                    return {
+                        wxNum: contact?.alias,
+                        wxid: contact?.userName?.string,
+                        name: contact?.nickName?.string || '',
+                        sex: contact?.sex || 0,
+                        alias: contact?.remark?.string || '',
+                        province: contact?.province || '',
+                        city: contact?.city || '',
+                        country: contact?.country || '',
+                        avatar: contact?.bigHeadImgUrl || contact?.smallHeadImgUrl || '',
+                        description: contact?.description,
+                        labelIdlist: contact?.labelIdlist,
+                        scene: contact?.addContactScene,
+                        sign: contact?.signature,
+                        snsBgImg: contact?.snsUserInfo?.snsBgimgId,
+                    };
+                }
+                return undefined;
+            }
+            else {
+                return res.contactList?.map((contactInfo) => {
+                    const contact = contactInfo.contact || {};
+                    return {
+                        wxNum: contact?.alias,
+                        wxid: contact?.userName?.string,
+                        name: contact?.nickName?.string || '',
+                        sex: contact?.sex || 0,
+                        alias: contact?.remark?.string || '',
+                        province: contact?.province || '',
+                        city: contact?.city || '',
+                        country: contact?.country || '',
+                        avatar: contact?.bigHeadImgUrl || contact?.smallHeadImgUrl || '',
+                        description: contact?.description,
+                        labelIdlist: contact?.labelIdlist,
+                        scene: contact?.addContactScene,
+                        sign: contact?.signature,
+                        snsBgImg: contact?.snsUserInfo?.snsBgimgId,
+                    };
+                });
+            }
+        }
+        catch (e) {
+            log.error(PRE, 'searchContactDetail(%s， %s): %s', contactIds, roomId, e);
+            return undefined;
+        }
+    }
+    async syncContact() {
+        try {
+            const res = await this.postData({
+                path: '/contact/init_contact',
+                data: {
+                    contact_seq: 0,
+                    room_seq: 0,
+                },
+            });
+            const contactUsernameList = res.contactUsernameList || [];
+            const contactsInfo = (await this.searchContact(contactUsernameList));
+            this.emit('update-contacts', contactsInfo || []);
+        }
+        catch (e) {
+            log.error(PRE, 'syncContact(): %s', e);
+        }
+    }
+    async getContactList(page = 1, pageSize = 100) {
+        try {
+            const res = await this.postData({
+                path: '/contact/get_friends',
+                data: {
+                    page_num: page,
+                    page_size: pageSize,
+                },
+            });
+            const totalPage = res.total_page || 1;
+            const contactList = res.contact_list
+                .filter((item) => item.username)
+                .map((contact) => {
+                return {
+                    isFriend: true,
+                    wxNum: contact?.alias,
+                    wxid: contact?.username,
+                    name: contact?.nickname || '',
+                    sex: contact?.sex,
+                    alias: contact?.remark || '',
+                    province: contact?.province || '',
+                    city: contact?.city || '',
+                    country: contact?.country || '',
+                    avatar: contact?.big_headimg_url || contact?.small_headimg_url || '',
+                    labelIdlist: contact?.labelIdlist,
+                };
+            });
+            this.emit('update-contacts', contactList);
+            if (page < totalPage) {
+                await this.getContactList(page + 1, pageSize);
+            }
+        }
+        catch (e) {
+            log.error(PRE, 'getContactList(): %s', e);
+        }
+    }
+    async getGroupList(page = 1, pageSize = 100) {
+        try {
+            const res = await this.postData({
+                path: '/room/get_chatrooms',
+                data: {
+                    page_num: page,
+                    page_size: pageSize,
+                },
+            });
+            const totalPage = res.total_page || 1;
+            const groupList = res.room_list
+                .filter((item) => item.username)
+                .map((item) => {
+                return {
+                    wxid: item.username,
+                    announcement: item?.announcement,
+                    ownerId: item?.creator,
+                    name: item?.nickname,
+                    avatar: item?.headimg_url,
+                    memberNum: item?.total_member,
+                    chatroommemberList: [],
+                };
+            });
+            if (groupList.length > 0) {
+                this.emit('update-contacts', groupList);
+            }
+            if (parseInt(page.toString()) < parseInt(totalPage.toString())) {
+                await this.getGroupList(parseInt(page.toString()) + 1, pageSize);
+            }
+        }
+        catch (e) {
+            log.error(PRE, 'getGroupList(): %s', e);
+        }
+    }
+    async getGroupMembersDetail(roomId) {
+        try {
+            const res = await this.postData({
+                path: '/room/get_chatroom_member_detail',
+                data: {
+                    room_username: roomId,
+                    version: 0,
+                },
+            });
+            const memeberIdList = res?.allMemberUserNameList.map((item) => item.string) || [];
+            const allMemberCount = res.allMemberCount;
+            const ownerId = res.chatRoomOwner;
+            const adminIdList = res?.adminUserNameList.map((item) => item.string) || [];
+            const memberList = res?.newChatroomData?.chatRoomMember
+                .filter((item) => item.username)
+                .map((item) => ({
+                wxid: item.username,
+                groupNick: item?.nickname,
+                avatarMinUrl: item?.smallHeadImgUrl,
+                avatarMaxUrl: item?.bigHeadImgUrl,
+                avatar: item?.bigHeadImgUrl || item?.smallHeadImgUrl,
+                inviterUserName: item?.inviterUserName,
+            }));
+            return {
+                memeberIdList,
+                allMemberCount,
+                ownerId,
+                adminIdList,
+                memberList,
+            };
+        }
+        catch (e) {
+            log.error(PRE, 'getGroupMembers(%s): %s', roomId, e);
+            return [];
+        }
+    }
+    async getGroupMembers(roomId, page = 1, pageSize = 100) {
+        try {
+            const res = await this.postData({
+                path: '/room/get_chatroom_members',
+                data: {
+                    room_username: roomId,
+                    page_num: page,
+                    page_size: pageSize,
+                },
+            });
+            const totalPage = res.total_page || 1;
+            const memberList = res.room_list
+                .filter((item) => item.username)
+                .map((item) => ({
+                wxid: item.username,
+                groupNick: item?.nickname,
+                avatarMinUrl: item?.small_headimg_url,
+                avatarMaxUrl: item?.big_headimg_url,
+                avatar: item?.big_headimg_url || item?.small_headimg_url,
+                inviterUserName: item?.invite_username,
+                country: item?.country,
+                province: item?.province,
+                city: item?.city,
+                displayName: item?.display_name,
+                sex: item?.sex,
+                wxNum: item?.alias,
+                alias: item?.remark,
+            }));
+            if (page < totalPage) {
+                const nextPageContacts = await this.getGroupMembers(roomId, page + 1, pageSize);
+                return memberList.concat(nextPageContacts);
+            }
+            else {
+                return memberList;
+            }
+        }
+        catch (e) {
+            log.error(PRE, 'getGroupMembers(%s): %s', roomId, e);
+            return [];
+        }
+    }
+    async getOfficeList(page = 1, pageSize = 100) {
+        try {
+            const res = await this.postData({
+                path: '/contact/get_publics',
+                data: {
+                    page_num: page,
+                    page_size: pageSize,
+                },
+            });
+            const totalPage = res.total_page || 1;
+            const officeList = res.contact_list
+                .filter((item) => item.username)
+                .map((contact) => {
+                return {
+                    wxNum: contact?.alias,
+                    wxid: contact?.username,
+                    name: contact?.nickname || '',
+                    sex: contact?.sex,
+                    alias: contact?.remark || '',
+                    province: contact?.province || '',
+                    city: contact?.city || '',
+                    country: contact?.country || '',
+                    avatar: contact?.big_headimg_url || contact?.small_headimg_url || '',
+                    labelIdlist: contact?.labelIdlist,
+                };
+            });
+            this.emit('update-contacts', officeList);
+            if (page < totalPage) {
+                await this.getOfficeList(page + 1, pageSize);
+            }
+        }
+        catch (e) {
+            log.error(PRE, 'getOfficeList(): %s', e);
+        }
+    }
+    async sendText(contactId, msg, selfId) {
+        try {
+            const res = await this.postData({
+                path: '/msg/send_text',
+                data: {
+                    to_username: contactId,
+                    content: msg,
+                },
+            });
+            return {
+                id: res?.list?.[0].newMsgId || '',
+                timeStamp: res?.list?.[0].createTime || '',
+                msgType: res?.list?.[0].type || '',
+                talkerId: selfId || '',
+                text: msg,
+                msg,
+                fromWxid: isRoomId(contactId) ? contactId : '',
+                listenerId: contactId,
+            };
+        }
+        catch (e) {
+            log.error(PRE, 'sendText(%s, %s, %s): %s', contactId, msg, e);
+        }
+    }
+    async sendAtText(contactId, msg, atList, selfId) {
+        try {
+            const res = await this.postData({
+                path: '/msg/send_room_at',
+                data: {
+                    to_username: contactId,
+                    content: msg,
+                    at_list: atList,
+                },
+            });
+            return {
+                id: res?.list?.[0].newMsgId || '',
+                timeStamp: res?.list?.[0].createTime || '',
+                msgType: res?.list?.[0].type || '',
+                talkerId: selfId || '',
+                text: msg,
+                msg,
+                fromWxid: isRoomId(contactId) ? contactId : '',
+                listenerId: contactId,
+            };
+        }
+        catch (e) {
+            log.error(PRE, 'sendText(%s, %s, %s): %s', contactId, msg, atList, e);
+        }
+    }
+    async uploadFile(url, type) {
+        return await this.postData({
+            path: '/cloud/cdn_upload',
+            data: {
+                file_type: type,
+                url,
+            },
+        });
+    }
+    async downloadImage(imageInfo) {
+        const params = {
+            file_type: 2,
+            file_id: imageInfo.file_id,
+            aes_key: imageInfo.aes_key,
+            file_size: imageInfo.file_size,
+            file_name: `/微信图片_${format(new Date(), 'yyyyMMddHHmmss')}.png`,
+        };
+        const res = await this.postData({
+            path: '/cloud/cdn_download',
+            data: params,
+        });
+        return encodeURI(res.url) || '';
+    }
+    async downloadFile(imageInfo) {
+        const params = {
+            file_type: 5,
+            file_id: imageInfo.file_id.replace('@cdn_', ''),
+            aes_key: imageInfo.aes_key,
+            file_size: imageInfo.file_size,
+            file_name: '/' + imageInfo.file_name,
+        };
+        const res = await this.postData({
+            path: '/cloud/cdn_download',
+            data: params,
+        });
+        return encodeURI(res.url) || '';
+    }
+    async downloadAudio(msgId, voiceInfo, roomId) {
+        const params = {
+            msg_id: msgId,
+            length: voiceInfo.length,
+            room_username: roomId,
+            file_name: '/voice.mp3',
+            to_mp3: true,
+        };
+        const res = await this.postData({
+            path: '/cloud/download_voice',
+            data: params,
+        });
+        return encodeURI(res.url) || '';
+    }
+    async downloadVideo(videoInfo) {
+        const params = {
+            file_type: 4,
+            file_id: videoInfo.file_id,
+            aes_key: videoInfo.aes_key,
+            file_size: videoInfo.file_size,
+            file_name: `/微信视频_${format(new Date(), 'yyyyMMddHHmmss')}.mp4`,
+        };
+        const res = await this.postData({
+            path: '/cloud/cdn_download',
+            data: params,
+        });
+        return encodeURI(res.url) || '';
+    }
+    async sendUrlImg(contactId, url, selfId) {
+        try {
+            const fileInfo = await this.uploadFile(url, 2);
+            const res = await this.postData({
+                path: '/msg/send_image',
+                data: {
+                    to_username: contactId,
+                    file_id: fileInfo.file_id,
+                    aes_key: fileInfo.aes_key,
+                    file_size: fileInfo.file_size,
+                    big_file_size: 0,
+                    thumb_file_size: fileInfo.thumb_file_size,
+                    file_md5: fileInfo.md5,
+                    thumb_width: fileInfo.thumb_width,
+                    thumb_height: fileInfo.thumb_height,
+                    file_crc: fileInfo.file_crc,
+                },
+            });
+            return {
+                id: res?.newMsgId || '',
+                timeStamp: res?.createTime || '',
+                msgType: WechatMessageType.Image,
+                talkerId: selfId || '',
+                text: url,
+                msg: url,
+                fromWxid: isRoomId(contactId) ? contactId : '',
+                listenerId: contactId,
+            };
+        }
+        catch (e) {
+            log.error(PRE, 'sendUrlImg(%s, %s): %s', contactId, url, e);
+        }
+    }
+    async sendVideo(contactId, url, selfId) {
+        try {
+            const fileInfo = await this.uploadFile(url, 4);
+            const res = await this.postData({
+                path: '/msg/send_video',
+                data: {
+                    to_username: contactId,
+                    file_id: fileInfo.file_id,
+                    aes_key: fileInfo.aes_key,
+                    file_size: fileInfo.file_size,
+                    thumb_file_size: fileInfo.thumb_file_size,
+                    file_md5: fileInfo.md5,
+                    thumb_file_md5: fileInfo.thumb_file_md5,
+                    video_duration: fileInfo.video_duration,
+                    file_crc: fileInfo.file_crc,
+                    mp4_identify: fileInfo.mp4_identify,
+                },
+            });
+            return {
+                id: res?.newMsgId || '',
+                timeStamp: res?.createTime || getUnixTime(new Date()),
+                msgType: WechatMessageType.Image,
+                talkerId: selfId || '',
+                text: url,
+                msg: url,
+                fromWxid: isRoomId(contactId) ? contactId : '',
+                listenerId: contactId,
+            };
+        }
+        catch (error) {
+            log.error(PRE, 'sendVideo(%s, %s): %s', contactId, url, error);
+        }
+    }
+    async sendCloudFile(contactId, url, selfId) {
+        try {
+            const fileInfo = await this.uploadFile(url, 5);
+            const res = await this.postData({
+                path: '/msg/send_file',
+                data: {
+                    to_username: contactId,
+                    file_id: fileInfo.file_id,
+                    aes_key: fileInfo.aes_key,
+                    file_size: fileInfo.file_size,
+                    file_md5: fileInfo.md5,
+                    file_name: fileInfo.name,
+                    file_key: fileInfo.file_key,
+                },
+            });
+            return {
+                id: res?.newMsgId || '',
+                timeStamp: res?.createTime || '',
+                msgType: WechatMessageType.App,
+                talkerId: selfId || '',
+                text: url,
+                msg: url,
+                fromWxid: isRoomId(contactId) ? contactId : '',
+                listenerId: contactId,
+            };
+        }
+        catch (error) {
+            log.error(PRE, 'sendCloudFile(%s, %s): %s', contactId, url, error);
+        }
+    }
+    async sendShareCard({ contactId, title, content, jumpUrl, imageUrl, }, selfId) {
+        try {
+            const res = await this.postData({
+                path: '/msg/send_link_card',
+                data: {
+                    to_username: contactId,
+                    title,
+                    desc: content,
+                    url: jumpUrl,
+                    image_url: imageUrl,
+                },
+            });
+            return {
+                id: res?.newMsgId || '',
+                timeStamp: res?.createTime || '',
+                msgType: WechatMessageType.Text,
+                talkerId: selfId || '',
+                text: jumpUrl,
+                msg: jumpUrl,
+                fromWxid: isRoomId(contactId) ? contactId : '',
+                listenerId: contactId,
+            };
+        }
+        catch (e) {
+            log.error('error info', e);
+        }
+    }
+    async sendMiniProgram({ appid, contactId, title, content, pagePath, username, thumbUrl, iconUrl, }, selfId) {
+        try {
+            const fileInfo = await this.uploadFile(thumbUrl, 2);
+            const res = await this.postData({
+                path: '/msg/send_mini_app',
+                data: {
+                    to_username: contactId,
+                    appid,
+                    username: username && username.endsWith('@app')
+                        ? username
+                        : username + '@app',
+                    title: content,
+                    appname: title,
+                    page_path: pagePath,
+                    appicon: iconUrl,
+                    file_id: fileInfo.file_id,
+                    aes_key: fileInfo.aes_key,
+                    file_size: fileInfo.file_size,
+                    file_md5: fileInfo.md5,
+                },
+            });
+            return {
+                id: res?.newMsgId || '',
+                timeStamp: res?.createTime || '',
+                msgType: WechatMessageType.MiniProgram,
+                talkerId: selfId || '',
+                text: appid + '_' + username,
+                msg: appid + '_' + username,
+                fromWxid: isRoomId(contactId) ? contactId : '',
+                listenerId: contactId,
+            };
+        }
+        catch (error) {
+            log.error(PRE, 'sendMiniProgram(%s, %s): %s', contactId, username, error);
+        }
+    }
+    async sendXml(contactId, xml, selfId) {
+        try {
+            const res = await this.postData({
+                path: '/msg/send_app_msg',
+                data: {
+                    to_username: contactId,
+                    app_type: 0,
+                    appid: '',
+                    xml,
+                },
+            });
+            return {
+                id: res?.newMsgId || '',
+                timeStamp: res?.createTime || '',
+                msgType: WechatMessageType.App,
+                talkerId: selfId || '',
+                text: xml,
+                msg: xml,
+                fromWxid: isRoomId(contactId) ? contactId : '',
+                listenerId: contactId,
+            };
+        }
+        catch (error) {
+            log.error(PRE, 'sendXml(%s, %s): %s', contactId, xml, error);
+        }
+    }
+    async confirmFriendship(contactId, scene, ticket) {
+        const res = await this.postData({
+            path: '/contact/verify_friend',
+            data: {
+                username: contactId,
+                scene: (scene && scene.toString()) || 6,
+                ticket,
+                opcode: 3,
+            },
+        });
+        return res;
+    }
+    async addFriendByWxid({ scene, wxid, content, ticket, }) {
+        await this.postData({
+            path: '/contact/add_friend',
+            data: {
+                scene,
+                username: wxid,
+                verify_content: content,
+                ticket,
+            },
+        });
+    }
+    async searchStranger(content) {
+        const contact = await this.postData({
+            path: '/contact/search_contact',
+            data: {
+                username: content,
+                from_scene: 0,
+                search_scene: 0,
+            },
+        });
+        return {
+            wxNum: contact?.alias || '',
+            wxid: contact?.userName?.string,
+            isFriend: contact?.userName?.string.includes('@stranger')
+                && contact?.userName?.string.includes('v3_')
+                ? 0
+                : 1,
+            name: contact?.nickName?.string || '',
+            sex: contact?.sex,
+            alias: contact?.remark?.string || '',
+            province: contact?.province || '',
+            city: contact?.city || '',
+            country: contact?.country || '',
+            avatar: contact?.bigHeadImgUrl || contact?.smallHeadImgUrl || '',
+            description: contact?.description,
+            labelIdlist: contact?.labelIdlist,
+            scene: contact?.addContactScene,
+            sign: contact?.signature,
+            snsBgImg: contact?.snsUserInfo?.snsBgimgId,
+            ticket: contact?.antispamTicket,
+        };
+    }
+    async inviteToGroup(groupId, contactId, type = 1) {
+        if (type === 1) {
+            await this.postData({
+                path: '/room/add_chatroom_member',
+                data: {
+                    room_username: groupId,
+                    username_list: [contactId],
+                },
+            });
+        }
+        else {
+            await this.postData({
+                path: '/room/invite_chatroom_member',
+                data: {
+                    room_username: groupId,
+                    username_list: [contactId],
+                },
+            });
+        }
+    }
+    async removeContact(contactId) {
+        await this.postData({
+            path: '/contact/del_friend',
+            data: {
+                username: contactId,
+            },
+        });
+    }
+    async setContactAlias(contactId, remark) {
+        await this.postData({
+            path: '/contact/modify_remark',
+            data: {
+                username: contactId,
+                remark,
+            },
+        });
+    }
+    async setGroupName(groupId, name) {
+        await this.postData({
+            path: '/room/modify_chatroom_name',
+            data: {
+                room_username: groupId,
+                name,
+            },
+        });
+    }
+    async roomQuit(roomId) {
+        await this.postData({
+            path: '/room/quit_chatroom',
+            data: {
+                room_username: roomId,
+            },
+        });
+    }
+    async sendContactCard(contactId, xml, selfId) {
+        try {
+            const res = await this.postData({
+                path: '/msg/send_share_card_raw',
+                data: {
+                    to_username: contactId,
+                    xml,
+                },
+            });
+            return {
+                id: res?.newMsgId || '',
+                timeStamp: res?.createTime || '',
+                msgType: WechatMessageType.App,
+                talkerId: selfId || '',
+                text: xml,
+                msg: xml,
+                fromWxid: isRoomId(contactId) ? contactId : '',
+                listenerId: contactId,
+            };
+        }
+        catch (error) {
+            log.error(PRE, 'sendContactCard(%s, %s): %s', contactId, xml, error);
+        }
+    }
+    async sendAnnouncement(roomId, content) {
+        try {
+            const res = await this.postData({
+                path: '/room/set_chatroom_announcement',
+                data: {
+                    room_username: roomId,
+                    announcement: content,
+                },
+            });
+            if (res.baseResponse.ret) {
+                log.error('sendAnnouncement error: %s', JSON.stringify(res.baseResponse));
+            }
+        }
+        catch (error) {
+            log.error(PRE, 'sendAnnouncement(%s, %s): %s', roomId, content, error);
+        }
+    }
+}
+export default Client;