wechaty-puppet-matrix 0.0.4

package/dist/esm/src/puppet-matrix.js

@@ -0,0 +1,1007 @@
+import { log } from '@juzi/wechaty-puppet';
+import * as PUPPET from '@juzi/wechaty-puppet';
+import { FileBox } from 'file-box';
+import Client from './matrix/service/request.js';
+import { getUnixTime } from 'date-fns';
+import { delay } from './matrix/utils/index.js';
+import path from 'path';
+import { CacheManager } from './matrix/cache-manager.js';
+import { isIMContactId, isRoomId } from './matrix/utils/is-type.js';
+import { parseAppmsgMessagePayload } from './matrix/messages/message-appmsg.js';
+import { parseMiniProgramMessagePayload } from './matrix/messages/message-miniprogram.js';
+import { parseEmotionMessagePayload } from './matrix/messages/message-emotion.js';
+import { parseImageMessagePayload } from './matrix/messages/message-image.js';
+import { parseAudioMessagePayload } from './matrix/messages/message-audio.js';
+import { parseVideoMessagePayload } from './matrix/messages/message-video.js';
+import { CachedPromiseFunc } from './matrix/utils/cached-promise.js';
+import { engineMessageToWechaty } from './matrix/schema-mapper/message.js';
+import { engineContactToWechaty } from './matrix/schema-mapper/contact.js';
+import { chatRoomMemberToContact, engineRoomMemberToWechaty, engineRoomToWechaty, } from './matrix/schema-mapper/room.js';
+import { parseEvent, EventType } from './matrix/events/mod.js';
+import { addRunningPuppet, removeRunningPuppet } from './cleanup.js';
+import { packageJson } from './package-json.js';
+import { JsonToXml } from './matrix/utils/xml-to-json.js';
+const VERSION = packageJson.version || '0.0.0';
+const PRE = '[PuppetMatrix]';
+const SEARCH_CONTACT_PREFIX = '$search$-';
+const STRANGER_SUFFIX = '@stranger';
+class PuppetMatrix extends PUPPET.Puppet {
+    options;
+    _cacheMgr;
+    _client;
+    _self;
+    _qrcodeTicket;
+    _printVersion = true;
+    _heartBeatTimer;
+    _qrcodeInterval;
+    _qrcodeStatuasInterval;
+    static VERSION = VERSION;
+    constructor(options = {}) {
+        super(options);
+        this.options = options;
+        this.options.engine = Client;
+        if (!this.options.token) {
+            const token = process.env['WECHATY_PUPPET_MATRIX_TOKEN'] || '';
+            if (token) {
+                this.options.token = token;
+            }
+        }
+    }
+    get client() {
+        return this._client;
+    }
+    async onStart() {
+        log.verbose(PRE, 'onStart()');
+        await this._startClient();
+    }
+    async _startClient() {
+        if (!this._client) {
+            this._client = await this.options.engine.create(this.options);
+        }
+        await this._startPuppetHeart(true);
+        if (this._client) {
+            this._client.on('login', this.wrapAsync(async ({ robotInfo }) => {
+                log.info(PRE, `login success: ${robotInfo.name}`);
+                await this.onLogin(robotInfo);
+            }));
+            this._client.on('message', this.wrapAsync(async (message) => {
+                await this._onPushMessage(message);
+            }));
+            this._client.on('contact', this.wrapAsync(async ({ contactInfo }) => {
+                await this._cacheMgr.setContact(contactInfo.wxid, contactInfo);
+                await this._cacheMgr?.setFriendshipRawPayload(contactInfo.wxid, {
+                    id: contactInfo.wxid,
+                    contactId: contactInfo.wxid,
+                    timestamp: getUnixTime(Date.now()),
+                    type: PUPPET.types.Friendship.Confirm,
+                });
+                this.emit('friendship', {
+                    friendshipId: contactInfo.wxid,
+                    type: PUPPET.types.Friendship.Confirm,
+                });
+            }));
+            this._client.on('update-contacts', this.wrapAsync(async (contactList) => {
+                for (const contact of contactList) {
+                    await this._onPushContact(contact);
+                }
+            }));
+            this._client.on('room-leave', this.wrapAsync(async ({ roomId, leaveIds }) => {
+                const payload = {
+                    roomId,
+                    removeeIdList: leaveIds,
+                    removerId: this._self?.wxid,
+                    timestamp: getUnixTime(Date.now()),
+                };
+                for (const leaveId of leaveIds) {
+                    await this._cacheMgr?.deleteSingleRoomMember(roomId, leaveId);
+                    const roomInfo = await this._cacheMgr?.getRoom(roomId);
+                    if (roomInfo && roomInfo.chatroommemberList) {
+                        roomInfo.chatroommemberList = roomInfo.chatroommemberList.filter(member => member !== leaveId);
+                        await this._cacheMgr?.setRoom(roomId, roomInfo);
+                    }
+                }
+                this.emit('room-leave', payload);
+            }));
+            this._client.on('room-join', this.wrapAsync(async ({ roomId, inviterId, joinIds, joinUsers }) => {
+                const payload = {
+                    inviteeIdList: joinIds,
+                    inviterId,
+                    roomId,
+                    timestamp: getUnixTime(Date.now()),
+                };
+                for (const joinUser of joinUsers) {
+                    await this._cacheMgr?.updateSingleRoomMember(roomId, joinUser);
+                    const roomInfo = await this._cacheMgr?.getRoom(roomId);
+                    if (roomInfo && roomInfo.chatroommemberList) {
+                        roomInfo.chatroommemberList.push(joinUser.wxid);
+                        await this._cacheMgr?.setRoom(roomId, roomInfo);
+                    }
+                }
+                log.info(PRE, 'room-join-----: %s', JSON.stringify(payload));
+                this.emit('room-join', payload);
+            }));
+            this._client.on('logout', this.wrapAsync(async (message) => {
+                log.info(PRE, 'Logout event: %s', message);
+                await this.logout(message);
+            }));
+        }
+        addRunningPuppet(this);
+        void this.checkIsLogin();
+        if (this._printVersion) {
+            this._printVersion = false;
+            log.info(`
+      ============================================================
+       Welcome to Wechaty Matrix puppet!
+
+       - puppet-Matrix version: ${VERSION}
+      ============================================================
+    `);
+        }
+    }
+    async checkIsLogin() {
+        const info = await this._client?.getSelfInfo();
+        if (info) {
+            log.info(PRE, `login success: ${info.name}`);
+            await this.onLogin(info);
+        }
+        else {
+            if (this._qrcodeInterval) {
+                clearInterval(this._qrcodeInterval);
+                this._qrcodeInterval = null;
+            }
+            await this._getQrcode();
+            this._qrcodeInterval = setInterval(async () => {
+                await this._getQrcode();
+            }, 200000);
+        }
+    }
+    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 _getQrcode() {
+        const qrcode = await this._client?.getQrcode();
+        if (qrcode) {
+            if (this._qrcodeStatuasInterval) {
+                clearInterval(this._qrcodeStatuasInterval);
+                this._qrcodeStatuasInterval = null;
+            }
+            this._qrcodeStatuasInterval = setInterval(async () => {
+                const scanStatus = await this._client?.getQrcodeStatus();
+                if (scanStatus.uuid === qrcode.uuid) {
+                    if (scanStatus.authUrl) {
+                        this._qrcodeTicket = this.getQrcodeTicket(scanStatus.authUrl);
+                        this.emit('verify-code', scanStatus.uuid, '', 1, 1);
+                    }
+                    await this.onQrCodeEvent(scanStatus.status, qrcode.qrcodeUrl);
+                }
+            }, 8000);
+        }
+    }
+    async enterVerifyCode(id, code) {
+        log.verbose(PRE, 'enterVerifyCode(%s, %s)', id, code);
+        if (this._qrcodeTicket) {
+            await this._client?.verifyLoginUrl(this._qrcodeTicket, code);
+            return;
+        }
+        log.error(PRE, 'enterVerifyCode(%s, %s) error, no qrcodeTicket', id, code);
+    }
+    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;
+        switch (status) {
+            case 0:
+                scanStatus = PUPPET.types.ScanStatus.Waiting;
+                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: url,
+            status: scanStatus,
+        });
+        if (status === 4 || status === 3) {
+            await this.checkIsLogin();
+        }
+    }
+    async onLogin(user) {
+        try {
+            if (!this._client) {
+                this._client = await this.options.engine.create(this.options);
+            }
+            if (!this._cacheMgr) {
+                this._cacheMgr = new CacheManager(user.wxid);
+                await this._cacheMgr.init();
+                await this._cacheMgr.setContact(user.wxid, user);
+            }
+            if (this._qrcodeInterval) {
+                clearInterval(this._qrcodeInterval);
+                this._qrcodeInterval = null;
+            }
+            if (this._qrcodeStatuasInterval) {
+                clearInterval(this._qrcodeStatuasInterval);
+                this._qrcodeStatuasInterval = null;
+            }
+            this._self = user;
+            await super.login(user.wxid);
+            void this._client?.pushLoginNotify();
+            await this.ready();
+        }
+        catch (e) {
+            log.error('error login', e);
+        }
+    }
+    async ready() {
+        try {
+            await this._client?.getContactList(1, 100);
+            await delay(2000);
+            await this._client?.getGroupList(1, 100);
+            await delay(2000);
+            await this._client?.getOfficeList(1, 100);
+            log.silly(PRE, 'on ready');
+            setTimeout(() => {
+                this.emit('ready', {
+                    data: 'ready',
+                });
+            }, 10000);
+        }
+        catch (e) {
+            log.error('ready error', e);
+        }
+    }
+    async onStop() {
+        await this._stopClient();
+    }
+    async _stopClient() {
+        this.__currentUserId = undefined;
+        this.__currentUserId = undefined;
+        if (this._cacheMgr) {
+            log.info(PRE, 'colse cache');
+            await this._cacheMgr.close();
+            this._cacheMgr = undefined;
+        }
+        removeRunningPuppet(this);
+        this._stopPuppetHeart();
+    }
+    async logout(reason) {
+        if (!this.isLoggedIn) {
+            return;
+        }
+        await this._client?.logout();
+        await super.logout(reason);
+        void this.checkIsLogin();
+    }
+    ding(data) {
+        const eventDongPayload = {
+            data: data ? data : 'ding-dong',
+        };
+        this.emit('dong', eventDongPayload);
+    }
+    async contactSelfName(name) {
+        return PUPPET.throwUnsupportedError(name);
+    }
+    async contactSelfQRCode() {
+        return this._client?.getUserQrcode() || '';
+    }
+    async contactSelfSignature(signature) {
+        return PUPPET.throwUnsupportedError(signature);
+    }
+    async contactPhone(contactId, phoneList) {
+        return PUPPET.throwUnsupportedError(contactId, phoneList);
+    }
+    async contactAlias(contactId, alias) {
+        const contact = await this.contactRawPayload(contactId);
+        if (alias) {
+            if (contact) {
+                if (contact.wxid.indexOf(STRANGER_SUFFIX) !== -1) {
+                    await this._cacheMgr.setContactStrangerAlias(contact.wxid, alias);
+                    if (contactId.startsWith(SEARCH_CONTACT_PREFIX)) {
+                        const searchContact = await this._cacheMgr?.getContactSearch(contactId);
+                        if (searchContact) {
+                            searchContact.remark = alias;
+                            await this._cacheMgr.setContactSearch(contactId, searchContact);
+                        }
+                    }
+                }
+                else {
+                    await this._client?.setContactAlias(contactId, alias);
+                    contact.remark = alias;
+                    await this._updateContactCache(contact);
+                }
+            }
+        }
+        else {
+            return contact && contact.remark;
+        }
+    }
+    async contactAvatar(contactId, file) {
+        if (file) {
+            return PUPPET.throwUnsupportedError('set avatar is not unsupported');
+        }
+        const contact = await this.contactRawPayload(contactId);
+        if (contact && contact.avatar) {
+            return FileBox.fromUrl(contact.avatar, { name: `avatar-${contactId}.jpg` });
+        }
+    }
+    async contactList() {
+        return this._cacheMgr.getContactIds();
+    }
+    async contactCorporationRemark(contactId, corporationRemark) {
+        return PUPPET.throwUnsupportedError(contactId, corporationRemark);
+    }
+    async contactDescription(contactId, description) {
+        return PUPPET.throwUnsupportedError(contactId, description);
+    }
+    async contactDelete(contactId) {
+        const contact = await this._refreshContact(contactId);
+        if (contact && contact.isFriend === 2) {
+            log.warn(`can not delete contact which is not a friend:: ${contactId}`);
+            return;
+        }
+        await this._client?.removeContact(contactId);
+        await this._refreshContact(contactId, 2);
+    }
+    async tagContactTagAdd(tagIds, contactIds) {
+        return PUPPET.throwUnsupportedError(tagIds, contactIds);
+    }
+    async tagContactTagRemove(tagIds, contactIds) {
+        return PUPPET.throwUnsupportedError(tagIds, contactIds);
+    }
+    async tagTagDelete(tagIdList) {
+        return PUPPET.throwUnsupportedError(tagIdList);
+    }
+    async tagTagContactList(contactId) {
+        return PUPPET.throwUnsupportedError(contactId);
+    }
+    async friendshipAccept(friendshipId) {
+        const friendship = (await this.friendshipRawPayload(friendshipId));
+        const userName = friendship.contactId;
+        if (isIMContactId(userName)) {
+            await this._refreshContact(userName);
+        }
+        await this._client?.confirmFriendship(userName, friendship.scene, friendship.ticket);
+    }
+    async friendshipAdd(contactId, option) {
+        let stranger;
+        let ticket;
+        let addContactScene;
+        const cachedContactSearch = await this._cacheMgr.getContactSearch(contactId);
+        if (cachedContactSearch) {
+            stranger = cachedContactSearch.isFriend || undefined;
+            ticket = cachedContactSearch.ticket || '';
+            addContactScene = cachedContactSearch.scene;
+        }
+        else {
+            const contactPayload = await this.contactRawPayload(contactId);
+            const contactAlias = contactPayload?.remark;
+            if (!contactAlias) {
+                const roomIds = await this._findRoomIdForWxid(contactId);
+                if (!roomIds.length) {
+                    throw new Error(`Can not find room for contact while adding friendship: ${contactId}`);
+                }
+                const res = await this._client?.searchContact([contactId]);
+                if (res) {
+                    await this._updateContactCache(res);
+                }
+                addContactScene = '14';
+            }
+            const res = await this.contactRawPayload(contactId);
+            if (res?.isFriend === 1) {
+                throw new Error(`contact:${contactId} is already a friend`);
+            }
+            ticket = '';
+            addContactScene = '6';
+        }
+        let hello;
+        if (stranger === 1) {
+            throw new Error(`contact:${contactId} is already a friend`);
+        }
+        if (option) {
+            if (typeof option === 'string') {
+                hello = option;
+            }
+            else {
+                hello = option.hello;
+            }
+        }
+        await this._client?.addFriendByWxid({ content: hello, ticket, scene: addContactScene, wxid: contactId });
+    }
+    async friendshipSearchPhone(phone) {
+        return this._friendshipSearch(phone, '15');
+    }
+    async friendshipSearchHandle(qq) {
+        return this._friendshipSearch(qq, '1');
+    }
+    async _friendshipSearch(id, scene) {
+        const cachedContactSearch = await this._cacheMgr.getContactSearch(id);
+        if (cachedContactSearch) {
+            return id;
+        }
+        const res = await this._client?.searchStranger(id);
+        const searchId = `${SEARCH_CONTACT_PREFIX}${id}`;
+        if (res) {
+            await this._cacheMgr.setContactSearch(searchId, { ...res, scene });
+        }
+        return searchId;
+    }
+    async _findRoomIdForWxid(wxid) {
+        const ret = [];
+        const roomIds = (await this._cacheMgr?.getRoomIds()) || [];
+        for (const roomId of roomIds) {
+            const roomMember = await this._cacheMgr?.getRoomMember(roomId);
+            if (!roomMember) {
+                continue;
+            }
+            const roomMemberIds = Object.keys(roomMember);
+            if (roomMemberIds.indexOf(wxid) !== -1) {
+                ret.push(roomId);
+            }
+        }
+        return ret;
+    }
+    async messageContact(messageId) {
+        log.verbose('PuppetWeChat', 'messageContact(%s)', messageId);
+        return PUPPET.throwUnsupportedError(messageId);
+    }
+    async messageFile(messageId) {
+        const messagePayload = await this.messageRawPayload(messageId);
+        const message = await this.messageRawPayloadParser(messagePayload);
+        switch (message.type) {
+            case PUPPET.types.Message.Image:
+                return this._getMessageImageFileBox(messageId, messagePayload);
+            case PUPPET.types.Message.Audio:
+                return this._getMessageAudioFileBox(messageId, messagePayload);
+            case PUPPET.types.Message.Video: {
+                return this._getMessageVideoFileBox(messageId, messagePayload);
+            }
+            case PUPPET.types.Message.Attachment:
+                return this._getMessageFileFileBox(messageId, messagePayload);
+            case PUPPET.types.Message.Emoticon: {
+                const emotionPayload = await parseEmotionMessagePayload(messagePayload);
+                const emoticonBox = FileBox.fromUrl(emotionPayload.cdnurl, { name: `message-${messageId}-emoticon.jpg` });
+                emoticonBox.metadata = {
+                    payload: emotionPayload,
+                    type: 'emoticon',
+                };
+                return emoticonBox;
+            }
+            case PUPPET.types.Message.MiniProgram:
+                return PUPPET.throwUnsupportedError(messageId);
+            case PUPPET.types.Message.Url:
+                return PUPPET.throwUnsupportedError(messageId);
+            default:
+                throw new Error(`Can not get file for message: ${messageId}`);
+        }
+    }
+    async messageImage(messageId) {
+        const messagePayload = await this.messageRawPayload(messageId);
+        return this._getMessageImageFileBox(messageId, messagePayload);
+    }
+    async messageMiniProgram(messageId) {
+        const messagePayload = await this.messageRawPayload(messageId);
+        const message = await this.messageRawPayloadParser(messagePayload);
+        if (message.type !== PUPPET.types.Message.MiniProgram) {
+            throw new Error('message is not mini program, can not get MiniProgramPayload');
+        }
+        return parseMiniProgramMessagePayload(messagePayload);
+    }
+    async messageUrl(messageId) {
+        const rawPayload = await this.messageRawPayload(messageId);
+        const payload = await this.messageRawPayloadParser(rawPayload);
+        if (payload.type !== PUPPET.types.Message.Url) {
+            throw new Error('Can not get url from non url payload');
+        }
+        const appPayload = await parseAppmsgMessagePayload(rawPayload.msg);
+        return {
+            description: appPayload.des,
+            thumbnailUrl: appPayload.thumburl,
+            title: appPayload.title,
+            url: appPayload.url,
+        };
+    }
+    async messageSendContact(toUserId, contactId) {
+        log.verbose('PuppetWeChat', 'messageSend("%s", %s)', toUserId, contactId);
+        const contactPayload = await this.contactRawPayload(contactId);
+        const xmlObj = {
+            msg: {
+                antispamticket: '',
+                bigheadimgurl: contactPayload?.avatar,
+                brandFlags: '0',
+                certflag: '0',
+                city: contactPayload?.city,
+                fullpy: contactPayload?.name,
+                imagestatus: '3',
+                nickname: contactPayload?.name,
+                province: contactPayload?.province,
+                regionCode: 'CN_Shanghai',
+                scene: '17',
+                sex: contactPayload?.sex,
+                smallheadimgurl: contactPayload?.avatar,
+                username: contactPayload?.ticket,
+            },
+        };
+        const xml = JsonToXml(xmlObj);
+        const res = await this._client?.sendContactCard(toUserId, xml, this._self?.wxid);
+        if (res) {
+            await this._cacheMgr?.setMessage(res.id, res);
+            return res.id;
+        }
+    }
+    async messageSendFile(conversationId, fileBox) {
+        const metadata = fileBox.metadata;
+        const fileType = fileBox.mediaType && fileBox.mediaType !== 'application/octet-stream'
+            ? fileBox.mediaType
+            : path.extname(fileBox.name);
+        const fileUrl = fileBox.remoteUrl || '';
+        if (metadata.type === 'emoticon') {
+            PUPPET.throwUnsupportedError(conversationId, fileBox);
+        }
+        else if (fileBox.mediaType.startsWith('image/')) {
+            if (fileUrl) {
+                const msgInfo = await this._client?.sendUrlImg(conversationId, fileUrl, this._self?.wxid);
+                if (msgInfo) {
+                    await this._cacheMgr?.setMessage(msgInfo.id, msgInfo);
+                    return msgInfo.id;
+                }
+            }
+        }
+        else if (fileBox.mediaType === 'audio/silk') {
+            PUPPET.throwUnsupportedError(conversationId, fileBox);
+        }
+        else if (fileType.includes('video/mp4') || fileType.includes('.mp4')) {
+            const msgInfo = await this._client?.sendVideo(conversationId, fileUrl, this._self?.wxid);
+            if (msgInfo) {
+                await this._cacheMgr?.setMessage(msgInfo.id, msgInfo);
+                return msgInfo.id;
+            }
+        }
+        else {
+            if (fileUrl) {
+                const msgInfo = await this._client?.sendCloudFile(conversationId, fileUrl, this._self?.wxid);
+                if (msgInfo) {
+                    await this._cacheMgr?.setMessage(msgInfo.id, msgInfo);
+                    return msgInfo.id;
+                }
+            }
+        }
+    }
+    async messageSendMiniProgram(toUserName, mpPayload) {
+        const miniProgram = {
+            appid: mpPayload.appid,
+            contactId: toUserName,
+            content: mpPayload.description,
+            username: mpPayload.username,
+            pagePath: mpPayload.pagePath,
+            thumbUrl: mpPayload.thumbUrl,
+            iconUrl: mpPayload.iconUrl,
+            title: mpPayload.title,
+        };
+        if (!mpPayload.thumbUrl) {
+            log.warn(PRE, 'no thumb image found while sending mimi program');
+        }
+        const res = await this._client?.sendMiniProgram(miniProgram, this._self?.wxid);
+        if (res) {
+            await this._cacheMgr?.setMessage(res.id, res);
+            return res.id;
+        }
+    }
+    async messageSendText(conversationId, text, mentionIdList) {
+        if (mentionIdList && mentionIdList.length) {
+            const msgInfo = await this._client?.sendAtText(conversationId, text, mentionIdList, this._self?.wxid);
+            if (msgInfo) {
+                await this._cacheMgr?.setMessage(msgInfo.id, msgInfo);
+                return msgInfo.id;
+            }
+        }
+        const msgInfo = await this._client?.sendText(conversationId, text, this._self?.wxid);
+        if (msgInfo) {
+            await this._cacheMgr?.setMessage(msgInfo.id, msgInfo);
+            return msgInfo.id;
+        }
+    }
+    async messageSendUrl(conversationId, urlLinkPayload) {
+        const urlCard = {
+            contactId: conversationId,
+            content: urlLinkPayload.description,
+            jumpUrl: urlLinkPayload.url,
+            imageUrl: urlLinkPayload.thumbnailUrl,
+            title: urlLinkPayload.title,
+        };
+        if (!urlLinkPayload.thumbnailUrl) {
+            log.warn(PRE, 'no thumb image found while sending mimi program');
+        }
+        const msgInfo = await this._client?.sendShareCard(urlCard, this._self?.wxid);
+        if (msgInfo) {
+            await this._cacheMgr?.setMessage(msgInfo.id, msgInfo);
+            return msgInfo.id;
+        }
+    }
+    async messageSendPost(conversationId, postPayload) {
+        const msgType = postPayload.sayableList[0];
+        if (msgType.type !== 'Text') {
+            throw new Error(`Wrong Post!!! please check your Post payload to make sure it right ${conversationId}`);
+        }
+    }
+    async messageRecall(messageId) {
+        return PUPPET.throwUnsupportedError(messageId);
+    }
+    async messageForward(toUserName, messageId) {
+        const messagePayload = await this.messageRawPayload(messageId);
+        const message = await this.messageRawPayloadParser(messagePayload);
+        switch (message.type) {
+            case PUPPET.types.Message.Text:
+                await this.messageSendText(toUserName, message.text);
+                break;
+            case PUPPET.types.Message.Image: {
+                const imageFileBox = await this.messageImage(messageId);
+                await this.messageSendFile(toUserName, imageFileBox);
+                break;
+            }
+            case PUPPET.types.Message.Audio: {
+                const audioFileBox = await this.messageFile(messageId);
+                await this.messageSendFile(toUserName, audioFileBox);
+                break;
+            }
+            case PUPPET.types.Message.Video: {
+                const videoFileBox = await this.messageFile(messageId);
+                await this.messageSendFile(toUserName, videoFileBox);
+                break;
+            }
+            default:
+                throw new Error(`Message forwarding is unsupported for messageId:${messageId}, type:${message.type}`);
+        }
+    }
+    async roomAdd(roomId, contactId) {
+        let type = 1;
+        if (roomId) {
+            const ret = await this.roomRawPayload(roomId);
+            if (ret && ret.memberNum && ret.memberNum > 38) {
+                type = 2;
+            }
+        }
+        await this._client?.inviteToGroup(roomId, contactId, type);
+    }
+    async roomAvatar(roomId) {
+        const chatroom = await this.roomRawPayload(roomId);
+        if (chatroom && chatroom.avatar) {
+            return FileBox.fromUrl(chatroom.avatar);
+        }
+        else {
+            return FileBox.fromBuffer(Buffer.from(new ArrayBuffer(0)), 'room-avatar.jpg');
+        }
+    }
+    async roomCreate(contactIdList, topic) {
+        return PUPPET.throwUnsupportedError(contactIdList, topic);
+    }
+    async roomDel(roomId, contactId) {
+        return PUPPET.throwUnsupportedError(roomId, contactId);
+    }
+    async roomList() {
+        return this._cacheMgr.getRoomIds();
+    }
+    async roomQRCode(roomId) {
+        return PUPPET.throwUnsupportedError(roomId);
+    }
+    async roomQuit(roomId) {
+        return this._client?.roomQuit(roomId);
+    }
+    async roomTopic(roomId, topic) {
+        await this._client?.setGroupName(roomId, topic);
+    }
+    async roomAnnounce(roomId, text) {
+        if (text !== undefined) {
+            await this._client?.sendAnnouncement(roomId, text);
+        }
+        return '';
+    }
+    async roomMemberList(roomId) {
+        const roomMemberMap = await this._getRoomMemberList(roomId);
+        return Object.values(roomMemberMap).map((m) => m.wxid);
+    }
+    async roomInvitationAccept(roomInvitationId) {
+        return PUPPET.throwUnsupportedError(roomInvitationId);
+    }
+    async contactRawPayloadParser(payload) {
+        return engineContactToWechaty(payload);
+    }
+    async contactRawPayload(id) {
+        log.silly(PRE, 'contactRawPayload(%s) @ %s', id, this);
+        if (id.startsWith(SEARCH_CONTACT_PREFIX)) {
+            const searchContact = await this._cacheMgr?.getContactSearch(id);
+            return searchContact;
+        }
+        let ret = await this._cacheMgr.getContact(id);
+        if (!ret) {
+            ret = await CachedPromiseFunc(`contactRawPayload-${id}`, async () => {
+                const contact = await this._refreshContact(id);
+                return contact;
+            });
+            return ret;
+        }
+        return ret;
+    }
+    async messageRawPayloadParser(payload) {
+        return engineMessageToWechaty(this, payload);
+    }
+    async messageRawPayload(id) {
+        const ret = await this._cacheMgr.getMessage(id);
+        if (!ret) {
+            throw new Error(`can not find message in cache for messageId: ${id}`);
+        }
+        return ret;
+    }
+    async roomRawPayloadParser(payload) {
+        return engineRoomToWechaty(payload);
+    }
+    async roomRawPayload(id) {
+        let ret = await this._cacheMgr.getRoom(id);
+        if (!ret) {
+            const contact = await this._refreshContact(id);
+            ret = contact;
+        }
+        return ret;
+    }
+    async roomMemberRawPayload(roomId, contactId) {
+        const roomMemberMap = await this._getRoomMemberList(roomId);
+        if (roomMemberMap[contactId]) {
+            return roomMemberMap[contactId];
+        }
+        const newMap = await this._getRoomMemberList(roomId, true);
+        return newMap[contactId];
+    }
+    async roomMemberRawPayloadParser(rawPayload) {
+        return engineRoomMemberToWechaty(rawPayload);
+    }
+    async roomInvitationRawPayload(roomInvitationId) {
+        return PUPPET.throwUnsupportedError(roomInvitationId);
+    }
+    async roomInvitationRawPayloadParser(rawPayload) {
+        return PUPPET.throwUnsupportedError(rawPayload);
+    }
+    async friendshipRawPayloadParser(rawPayload) {
+        return rawPayload;
+    }
+    async friendshipRawPayload(id) {
+        const ret = await this._cacheMgr.getFriendshipRawPayload(id);
+        if (!ret) {
+            throw new Error(`Can not find friendship for id: ${id}`);
+        }
+        return ret;
+    }
+    async syncRoom() {
+        if (this.state.active() !== true) {
+            throw new Error('Can not sync contact before login');
+        }
+        await this._client?.getGroupList(1, 100);
+    }
+    async _getRoomMemberList(roomId, force) {
+        if (!this._cacheMgr) {
+            return {};
+        }
+        let ret = await this._cacheMgr.getRoomMember(roomId);
+        if (!ret || (ret && !Object.keys(ret).length) || force) {
+            const resMembers = await this._client?.getGroupMembers(roomId) || [];
+            const roomMemberMap = {};
+            for (const roomMember of resMembers) {
+                const hasContact = await this._cacheMgr.hasContact(roomMember.wxid);
+                let MemberInfo;
+                if (!hasContact) {
+                    MemberInfo = chatRoomMemberToContact(roomMember);
+                    await this._cacheMgr.setContact(MemberInfo.wxid, MemberInfo);
+                    roomMemberMap[roomMember.wxid] = MemberInfo;
+                }
+                else {
+                    MemberInfo = await this._cacheMgr.getContact(roomMember.wxid);
+                    roomMemberMap[roomMember.wxid] = MemberInfo;
+                }
+            }
+            ret = roomMemberMap;
+            await this._updateRoomMember(roomId, roomMemberMap);
+        }
+        return ret;
+    }
+    async _updateContactCache(contact) {
+        if (!contact.wxid) {
+            log.warn(PRE, `wxid is required for contact: ${JSON.stringify(contact)}`);
+            return;
+        }
+        if (isRoomId(contact.wxid)) {
+            const oldRoomPayload = await this._cacheMgr.getRoom(contact.wxid);
+            const roomId = contact.wxid;
+            let finalPayload = contact;
+            if (oldRoomPayload) {
+                finalPayload = Object.assign(oldRoomPayload, contact);
+            }
+            await this._cacheMgr.setRoom(roomId, finalPayload);
+            if (!finalPayload.chatroommemberList || finalPayload.chatroommemberList.length === 0) {
+                const map = await this._getRoomMemberList(roomId);
+                await this._cacheMgr.setRoom(roomId, Object.assign(finalPayload, { chatroommemberList: Object.keys(map) }));
+            }
+        }
+        else {
+            const oldContactPaylod = await this._cacheMgr.getContact(contact.wxid);
+            if (oldContactPaylod) {
+                await this._cacheMgr.setContact(contact.wxid, Object.assign(oldContactPaylod, contact));
+            }
+            else {
+                await this._cacheMgr.setContact(contact.wxid, contact);
+            }
+        }
+    }
+    async _updateRoomMember(roomId, roomMemberMap) {
+        if (roomMemberMap) {
+            await this._cacheMgr.setRoomMember(roomId, roomMemberMap);
+        }
+        else {
+            await this._cacheMgr.deleteRoomMember(roomId);
+        }
+    }
+    async _updateRoom(roomId) {
+        if (!roomId) {
+            log.warn(PRE, 'roomid is required for updateRoom');
+            return;
+        }
+        let contact = await this._client?.searchContact([roomId]);
+        if (contact) {
+            const memeberMap = await this._getRoomMemberList(contact.wxid, true);
+            const chatroommemberList = Object.values(memeberMap).map(item => item.wxid);
+            contact = { ...contact, memberNum: Object.keys(memeberMap).length, chatroommemberList };
+            await this._onPushContact(contact);
+        }
+    }
+    async _onPushContact(contact) {
+        log.silly(PRE, `on push contact: ${JSON.stringify(contact)}`);
+        await this._updateContactCache(contact);
+        if (contact.wxid) {
+            const aliasToSet = await this._cacheMgr.getContactStrangerAlias(contact.wxid);
+            if (aliasToSet) {
+                await this.contactAlias(contact.wxid, aliasToSet);
+                await this._cacheMgr.deleteContactStrangerAlias(contact.wxid);
+            }
+        }
+    }
+    async _onPushMessage(message) {
+        const messageId = message.id;
+        log.silly(PRE, `on push original message: ${JSON.stringify(message)}`);
+        if (await this._cacheMgr.hasMessage(messageId)) {
+            return;
+        }
+        await this._cacheMgr.setMessage(message.id, message);
+        const event = await parseEvent(this, message);
+        log.info('event-------', JSON.stringify(event));
+        switch (event.type) {
+            case EventType.Message:
+                this.emit('message', {
+                    messageId,
+                });
+                break;
+            case EventType.Friendship: {
+                await this._cacheMgr?.setFriendshipRawPayload(event.payload.contactId, event.payload);
+                this.emit('friendship', {
+                    friendshipId: event.payload.contactId,
+                    type: event.payload.type,
+                });
+                break;
+            }
+            case EventType.RoomInvite: {
+                const roomInvite = event.payload;
+                await this._cacheMgr.setRoomInvitation(messageId, roomInvite);
+                this.emit('room-invite', {
+                    roomInvitationId: messageId,
+                });
+                break;
+            }
+            case EventType.RoomJoin: {
+                break;
+            }
+            case EventType.RoomLeave: {
+                break;
+            }
+            case EventType.RoomTopic: {
+                break;
+            }
+        }
+    }
+    async _refreshContact(wxid, isFriend) {
+        const contact = await this._client?.searchContactDetail([wxid]);
+        if (contact && !contact.wxid) {
+            contact.wxid = wxid;
+            await this._updateContactCache({ ...contact, isFriend });
+            return contact;
+        }
+        else if (contact) {
+            return contact;
+        }
+        return undefined;
+    }
+    async _startPuppetHeart(firstTime = true) {
+        if (firstTime && this._heartBeatTimer) {
+            return;
+        }
+        this.emit('heartbeat', { data: 'heartbeat@matrix' });
+        this._heartBeatTimer = setTimeout(async () => {
+            await this._startPuppetHeart(false);
+            return undefined;
+        }, 15 * 1000);
+    }
+    _stopPuppetHeart() {
+        if (!this._heartBeatTimer) {
+            return;
+        }
+        clearTimeout(this._heartBeatTimer);
+        this._heartBeatTimer = undefined;
+    }
+    async _getMessageImageFileBox(messageId, messagePayload) {
+        const imageInfo = await parseImageMessagePayload(messagePayload);
+        if (!imageInfo.file_id) {
+            log.error(`Can not get file for message: ${messageId}`);
+        }
+        const url = await this._client?.downloadImage(imageInfo);
+        return FileBox.fromUrl(url);
+    }
+    async _getMessageAudioFileBox(messageId, messagePayload) {
+        const audioInfo = await parseAudioMessagePayload(messagePayload);
+        if (!audioInfo.length) {
+            log.error(`Can not get file for message: ${messageId}`);
+        }
+        const url = await this._client?.downloadAudio(messageId, audioInfo);
+        return FileBox.fromUrl(url);
+    }
+    async _getMessageVideoFileBox(messageId, messagePayload) {
+        const videoInfo = await parseVideoMessagePayload(messagePayload);
+        if (!videoInfo.file_id) {
+            log.error(`Can not get file for message: ${messageId}`);
+        }
+        const url = await this._client?.downloadVideo(videoInfo);
+        log.info(PRE, '_getMessageVideoFileBox(): %s', url);
+        return FileBox.fromUrl(url);
+    }
+    async _getMessageFileFileBox(messageId, messagePayload) {
+        const appPayload = await parseAppmsgMessagePayload(messagePayload.msg);
+        if (!appPayload.appattach?.attachid) {
+            log.error(`Can not get file for message: ${messageId}`);
+        }
+        const appattach = appPayload.appattach;
+        const params = {
+            aes_key: appattach?.aeskey || '',
+            file_id: appattach?.attachid || '',
+            file_name: appPayload.title,
+            file_size: appattach?.totallen || '',
+        };
+        const url = await this._client?.downloadFile(params);
+        if (!url) {
+            log.error(`Can not get file url: ${JSON.stringify(params)}`);
+        }
+        return FileBox.fromUrl(url, { name: appPayload.title });
+    }
+    async syncContact() {
+        if (!this.currentUserId) {
+            throw new Error('Can not sync contact before login');
+        }
+        log.info('syncContact');
+        await this._client.syncContact();
+    }
+}
+export { PuppetMatrix, VERSION };
+export default PuppetMatrix;