wechaty-puppet-matrix 0.0.4

package/src/puppet-matrix.ts

@@ -0,0 +1,1402 @@
+import { log }              from '@juzi/wechaty-puppet'
+import * as PUPPET          from '@juzi/wechaty-puppet'
+import type { FileBoxInterface } from 'file-box'
+import { FileBox }          from 'file-box'
+import type { ContactPayload, MessagePayload } from './engine-schema.js'
+import type { FileBoxMetadataMessage } from './matrix/types.js'
+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, RoomMemberMap } from './matrix/cache-manager.js'
+import { isIMContactId, isRoomId } from './matrix/utils/is-type.js'
+import { AppMessagePayload, parseAppmsgMessagePayload } from './matrix/messages/message-appmsg.js'
+import { parseMiniProgramMessagePayload } from './matrix/messages/message-miniprogram.js'
+import { parseEmotionMessagePayload } from './matrix/messages/message-emotion.js'
+import { ImageMessagePayload, parseImageMessagePayload } from './matrix/messages/message-image.js'
+import { parseAudioMessagePayload, AudioMessagePayload } from './matrix/messages/message-audio.js'
+import { parseVideoMessagePayload, VideoMessagePayload } 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'
+
+export type PuppetEngineOptions = PUPPET.PuppetOptions & {
+  token?: string,
+  engine?: any
+}
+
+class PuppetMatrix extends PUPPET.Puppet {
+
+  private _cacheMgr?: CacheManager
+  private _client?: Client
+  private _self?: ContactPayload | undefined
+  private _qrcodeTicket: string | null | undefined
+  private _printVersion: boolean = true
+  private _heartBeatTimer?: ReturnType<typeof setTimeout>
+  private _qrcodeInterval?: ReturnType<typeof setInterval> | null
+  private _qrcodeStatuasInterval?: ReturnType<typeof setInterval> | null
+  public static override readonly  VERSION = VERSION
+
+  constructor (public override options: PuppetEngineOptions = {} as PuppetEngineOptions) {
+    super(options)
+
+    this.options.engine = Client
+
+    if (!this.options.token) {
+      const token = process.env['WECHATY_PUPPET_MATRIX_TOKEN'] || ''
+      if (token) {
+        this.options.token = token
+      }
+    }
+  }
+
+  public get client () {
+    return this._client
+  }
+
+  override async onStart (): Promise<void> {
+    log.verbose(PRE, 'onStart()')
+    await this._startClient()
+  }
+
+  /**
+   * 启动监听
+   * @private
+   */
+  private 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 } : { robotInfo: ContactPayload }) => {
+        log.info(PRE, `login success: ${robotInfo.name}`)
+        await this.onLogin(robotInfo)
+      }))
+      this._client.on('message', this.wrapAsync(async (message:MessagePayload) => {
+        await this._onPushMessage(message)
+      }))
+      this._client.on('contact', this.wrapAsync(async ({ contactInfo }:{ friendShip:PUPPET.payloads.FriendshipReceive, contactInfo: ContactPayload, type: PUPPET.types.Friendship }) => {
+        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: ContactPayload[]) => {
+        for (const contact of contactList) {
+          await this._onPushContact(contact)
+        }
+      }))
+      this._client.on('room-leave', this.wrapAsync(async ({ roomId, leaveIds }: { roomId: string, leaveIds: string[] }) => {
+        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 }: { roomId: string, inviterId: string, joinIds: string[], joinUsers: ContactPayload[] }) => {
+        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: string) => {
+        log.info(PRE, 'Logout event: %s', message)
+        await this.logout(message)
+      }))
+    }
+    addRunningPuppet(this)
+    void this.checkIsLogin()
+
+    if (this._printVersion) {
+      // only print once
+      this._printVersion = false
+      log.info(`
+      ============================================================
+       Welcome to Wechaty Matrix puppet!
+
+       - puppet-Matrix version: ${VERSION}
+      ============================================================
+    `)
+    }
+  }
+
+  private async checkIsLogin () {
+    const info = await this._client?.getSelfInfo() as ContactPayload
+    // eslint-disable-next-line @typescript-eslint/no-unnecessary-condition
+    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()
+      // eslint-disable-next-line @typescript-eslint/no-misused-promises
+      this._qrcodeInterval = setInterval(async () => {
+        await this._getQrcode()
+      }, 200000)
+    }
+  }
+
+  private getQrcodeTicket (authurl: string):string {
+    if (!authurl || !authurl.startsWith('http')) return ''
+    const url = new URL(authurl)
+    const searchParams = new URLSearchParams(url.search.slice(1))
+    return searchParams.get('ticket') || ''
+  }
+
+  private async _getQrcode () {
+    const qrcode = await this._client?.getQrcode()
+    if (qrcode) {
+      if (this._qrcodeStatuasInterval) {
+        clearInterval(this._qrcodeStatuasInterval)
+        this._qrcodeStatuasInterval = null
+      }
+      // eslint-disable-next-line @typescript-eslint/no-misused-promises
+      this._qrcodeStatuasInterval = setInterval(async () => {
+        const scanStatus = await this._client?.getQrcodeStatus() as { status: number, uuid: string, authUrl?: string }
+        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)
+    }
+  }
+
+  override async enterVerifyCode (id: string, code: string): Promise<void> {
+    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)
+  }
+
+  private async onQrCodeEvent (status: number, url: string) {
+    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 = 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()
+    }
+  }
+
+  // 登录
+  private async onLogin (user: ContactPayload):Promise<void> {
+    try {
+      // create cache manager firstly
+      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)
+    }
+  }
+
+  public async ready (): Promise<void> {
+    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)
+    }
+  }
+
+  public async onStop (): Promise<void> {
+    await this._stopClient()
+  }
+
+  private async _stopClient (): Promise<void> {
+    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()
+  }
+
+  // 登出
+  override async logout (reason?: string): Promise<void> {
+    if (!this.isLoggedIn) {
+      return
+    }
+    await this._client?.logout()
+
+    await super.logout(reason)
+    void this.checkIsLogin()
+  }
+
+  override ding (data?: string): void {
+    const eventDongPayload = {
+      data: data ? data! : 'ding-dong',
+    }
+    this.emit('dong', eventDongPayload)
+  }
+
+  /****************************************************************************
+   * contact
+   ***************************************************************************/
+
+  /**
+   *
+   * ContactSelf
+   *
+   *
+   */
+  // 设置自己的昵称 暂不支持
+  override async contactSelfName (name: string): Promise<void> {
+    return PUPPET.throwUnsupportedError(name)
+  }
+
+  // 获取自己的二维码
+  override async contactSelfQRCode (): Promise<string> {
+    return this._client?.getUserQrcode()  || ''
+  }
+
+  // 设置自己的签名 暂不支持
+  override async contactSelfSignature (signature: string): Promise<void> {
+    return PUPPET.throwUnsupportedError(signature)
+  }
+
+  // 获取用户的手机号 暂不支持
+  override async contactPhone (contactId: string, phoneList: string[]): Promise<void> {
+    return PUPPET.throwUnsupportedError(contactId, phoneList)
+  }
+
+  // 查询或设置用户备注
+  override contactAlias (contactId: string)                      : Promise<string>
+  override contactAlias (contactId: string, alias: string | null): Promise<void>
+
+  override async contactAlias (contactId : string, alias?    : string | null): Promise<string | void> {
+    const contact = await this.contactRawPayload(contactId)
+    if (alias) {
+      // contact is stranger, set alias in cache, to update after user is added
+      if (contact) {
+        if (contact.wxid.indexOf(STRANGER_SUFFIX) !== -1) {
+          await this._cacheMgr!.setContactStrangerAlias(contact.wxid, alias)
+
+          // to suppress warning: 15:31:06 WARN Contact alias(asd3) sync with server fail: set(asd3) is not equal to get()
+          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
+    }
+  }
+
+  // 获取用户头像
+  override async contactAvatar (contactId: string)                          : Promise<FileBoxInterface>
+  override async contactAvatar (contactId: string, file: FileBoxInterface)  : Promise<void>
+
+  override async contactAvatar (contactId: string, file?: FileBoxInterface) : Promise<void | FileBoxInterface> {
+    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` })
+    }
+  }
+
+  // 获取用户列表
+  override async contactList (): Promise<string[]> {
+    return this._cacheMgr!.getContactIds()
+  }
+
+  // 公司备注 暂不支持
+  override async contactCorporationRemark (contactId: string, corporationRemark: string | null) {
+    return PUPPET.throwUnsupportedError(contactId, corporationRemark)
+  }
+
+  // 其他备注 暂不支持
+  override async contactDescription (contactId: string, description: string | null) {
+    return PUPPET.throwUnsupportedError(contactId, description)
+  }
+
+  // 删除联系人
+  override async contactDelete (contactId: string): Promise<void> {
+    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)
+  }
+
+  // 添加标签 暂不支持
+  override async tagContactTagAdd (tagIds: string[], contactIds: string[]): Promise<void> {
+    return PUPPET.throwUnsupportedError(tagIds, contactIds)
+  }
+
+  // 删除用户标签 暂不支持
+  override async tagContactTagRemove (tagIds: string[], contactIds: string[]): Promise<void> {
+    return PUPPET.throwUnsupportedError(tagIds, contactIds)
+  }
+
+  // 删除标签
+  override async tagTagDelete (tagIdList: string[]) : Promise<void> {
+    return PUPPET.throwUnsupportedError(tagIdList)
+  }
+
+  // 获取用户标签
+  override async tagTagContactList (contactId?: string) : Promise<string[]> {
+    return PUPPET.throwUnsupportedError(contactId)
+  }
+
+  /****************************************************************************
+   * friendship
+   ***************************************************************************/
+  /**
+   * 通过好友请求
+   * @param friendshipId
+   */
+  override async friendshipAccept (friendshipId : string): Promise<void> {
+    const friendship: PUPPET.payloads.FriendshipReceive = (await this.friendshipRawPayload(
+      friendshipId,
+    )) as PUPPET.payloads.FriendshipReceive
+    const userName = friendship.contactId
+
+    // FIXME: workaround to make accept enterprise account work. can be done in a better way
+    if (isIMContactId(userName)) {
+      await this._refreshContact(userName)
+    }
+    await this._client?.confirmFriendship(userName, friendship.scene, friendship.ticket)
+  }
+
+  /**
+   * 主动添加好友
+   * @param contactId
+   * @param option
+   */
+  override async friendshipAdd (contactId: string, option?: PUPPET.types.FriendshipAddOptions): Promise<void> {
+    let stranger: number | undefined
+    let ticket: string
+    let addContactScene
+    const cachedContactSearch = await this._cacheMgr!.getContactSearch(contactId)
+    // 通过陌生人查找用户 手机或者qq
+    if (cachedContactSearch) {
+      stranger = cachedContactSearch.isFriend || undefined
+      ticket = cachedContactSearch.ticket || ''
+      addContactScene = cachedContactSearch.scene
+    } else {
+      // 通过wxid 查找
+      const contactPayload = await this.contactRawPayload(contactId)
+      const contactAlias = contactPayload?.remark
+      if (!contactAlias) {
+        // add contact from room,
+        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 ]) as ContactPayload | undefined
+        if (res) {
+          await this._updateContactCache(res)
+        }
+        addContactScene = '14' // 1=qq 3=微信号 6=单向添加 10和13=通讯录 14=群聊 15=手机号 17=名片 30=扫一扫
+      }
+      const res = await this.contactRawPayload(contactId)
+      if (res?.isFriend === 1) {
+        throw new Error(`contact:${contactId} is already a friend`)
+      }
+      // 通过wxid加好友
+      ticket = ''
+      addContactScene = '6' // 1=qq 3=微信号 6=单向添加 10和13=通讯录 14=群聊 15=手机号 17=名片 30=扫一扫
+    }
+    let hello: string | undefined
+    if (stranger === 1) {
+      throw new Error(`contact:${contactId} is already a friend`)
+    }
+    if (option) {
+      if (typeof option === 'string') {
+        hello = option
+      } else {
+        hello = (option as any).hello
+      }
+    }
+    await this._client?.addFriendByWxid({ content: hello, ticket,  scene: addContactScene, wxid: contactId })
+  }
+
+  /**
+   * 根据手机号查询好友
+   * @param phone
+   */
+  override async friendshipSearchPhone (phone: string): Promise<null | string> {
+    return this._friendshipSearch(phone, '15')
+  }
+
+  /**
+   * 根据qq号查询好友
+   * @param qq
+   */
+  override async friendshipSearchHandle (qq: string): Promise<null | string> {
+    return this._friendshipSearch(qq, '1')
+  }
+
+  /**
+   * 陌生人查询
+   * @param id
+   * @param scene 场景值 1=qq 3=微信号 6=单向添加 10和13=通讯录 14=群聊 15=手机号 17=名片 30=扫一扫
+   * @private
+   */
+  private async _friendshipSearch (id: string, scene?:string): Promise<null | string> {
+    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
+  }
+
+  /**
+   * 根据wxid 查询群id
+   * @param wxid
+   * @private
+   */
+  private async _findRoomIdForWxid (wxid: string): Promise<string[]> {
+    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
+  }
+
+  /****************************************************************************
+   * get message payload
+   ***************************************************************************/
+  // 名片
+  override async messageContact (messageId: string): Promise<string> {
+    log.verbose('PuppetWeChat', 'messageContact(%s)', messageId)
+    return PUPPET.throwUnsupportedError(messageId)
+  }
+
+  // 文件消息
+  override async messageFile (messageId: string): Promise<FileBoxInterface> {
+    const messagePayload: MessagePayload = await this.messageRawPayload(messageId)
+    const message: PUPPET.payloads.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}`)
+    }
+  }
+
+  /**
+   * 解析图片消息
+   * @param messageId
+   */
+  override async messageImage (messageId: string): Promise<FileBoxInterface> {
+    const messagePayload: MessagePayload = await this.messageRawPayload(messageId)
+    return this._getMessageImageFileBox(messageId, messagePayload)
+  }
+
+  /**
+   * 解析小程序
+   * @param messageId
+   */
+  override async messageMiniProgram (messageId: string): Promise<PUPPET.payloads.MiniProgram> {
+    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)
+  }
+
+  /**
+   * 解析h5链接
+   * @param messageId
+   */
+  override async messageUrl (messageId: string)  : Promise<PUPPET.payloads.UrlLink> {
+    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')
+    }
+
+    // FIXME: thumb may not in appPayload.thumburl, but in appPayload.appAttachPayload
+    const appPayload = await parseAppmsgMessagePayload(rawPayload.msg)
+    return {
+      description: appPayload.des,
+      thumbnailUrl: appPayload.thumburl,
+      title: appPayload.title,
+      url: appPayload.url,
+    }
+  }
+
+  /****************************************************************************
+   * send message
+   ***************************************************************************/
+  // 发送名片
+  override async messageSendContact (toUserId: string, contactId: string): Promise<void | string> {
+    log.verbose('PuppetWeChat', 'messageSend("%s", %s)', toUserId, contactId)
+    const contactPayload = await this.contactRawPayload(contactId)
+    const xmlObj = {
+      msg: {
+        antispamticket: '', // TODO 需要考虑怎么设置
+        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
+    }
+  }
+
+  // 发送文件
+  override async messageSendFile (conversationId: string, fileBox: FileBoxInterface): Promise<string | void> {
+    const metadata: FileBoxMetadataMessage = fileBox.metadata as FileBoxMetadataMessage
+
+    const fileType
+            = fileBox.mediaType && fileBox.mediaType !== 'application/octet-stream'
+              ? fileBox.mediaType
+              : path.extname(fileBox.name)
+
+    // @ts-ignore
+    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
+        }
+      }
+    }
+  }
+
+  // 发送小程序
+  override async messageSendMiniProgram (toUserName: string, mpPayload: PUPPET.payloads.MiniProgram): Promise<void | string> {
+    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
+    }
+  }
+
+  // 发送文字
+  override async messageSendText (conversationId: string, text: string, mentionIdList?: string[]): Promise<string | void> {
+    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
+    }
+  }
+
+  // 发送h5链接
+  override async messageSendUrl (conversationId: string, urlLinkPayload: PUPPET.payloads.UrlLink): Promise<string | void> {
+    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
+    }
+  }
+
+  /**
+   * 确认收款
+   */
+  override async messageSendPost (conversationId: string, postPayload: PUPPET.payloads.Post): Promise<void> {
+    const msgType = postPayload.sayableList[0] as PUPPET.payloads.Sayable
+    if (msgType.type !== 'Text') {
+      throw new Error(`Wrong Post!!! please check your Post payload to make sure it right ${conversationId}`)
+    }
+  }
+
+  /**
+   * 消息撤回 暂不支持
+   * @param messageId
+   */
+  override async messageRecall (messageId: string): Promise<boolean> {
+    return PUPPET.throwUnsupportedError(messageId)
+  }
+
+  /**
+   * 消息转发
+   * @param toUserName
+   * @param messageId
+   */
+  override async messageForward (toUserName: string, messageId: string): Promise<void> {
+    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}`)
+    }
+  }
+
+  /****************************************************************************
+   * room
+   ***************************************************************************/
+
+  // 拉人进群
+  override async roomAdd (roomId    : string, contactId : string): Promise<void> {
+    let type:number = 1 // 1 直接拉 2 发送邀请链接  人数超过40需要对方同意
+    if (roomId) {
+      const ret = await this.roomRawPayload(roomId)
+      if (ret && ret.memberNum && ret.memberNum > 38) {
+        type = 2
+      }
+    }
+    await this._client?.inviteToGroup(roomId, contactId, type)
+  }
+
+  // 获取群头像
+  override async roomAvatar (roomId: string): Promise<FileBoxInterface> {
+    const chatroom = await this.roomRawPayload(roomId)
+    if (chatroom && chatroom.avatar) {
+      return FileBox.fromUrl(chatroom.avatar)
+    } else {
+      // return dummy FileBox object
+      return FileBox.fromBuffer(Buffer.from(new ArrayBuffer(0)), 'room-avatar.jpg')
+    }
+  }
+
+  // 创建群聊 暂不支持
+  override async roomCreate (
+    contactIdList : string[],
+    topic         : string,
+  ): Promise<string> {
+    return PUPPET.throwUnsupportedError(contactIdList, topic)
+  }
+
+  // 删除群聊 暂不支持
+  override async roomDel (
+    roomId    : string,
+    contactId : string,
+  ): Promise<void> {
+    return PUPPET.throwUnsupportedError(roomId, contactId)
+  }
+
+  // 获取群聊列表
+  override async roomList (): Promise<string[]> {
+    return this._cacheMgr!.getRoomIds()
+  }
+
+  // 获取群二维码 暂不支持
+  override async roomQRCode (roomId: string): Promise<string> {
+    return PUPPET.throwUnsupportedError(roomId)
+  }
+
+  // 机器人退出群聊 暂不支持
+  override async roomQuit (roomId: string): Promise<void> {
+    return this._client?.roomQuit(roomId)
+  }
+
+  override async roomTopic (roomId: string)                : Promise<string>
+  override async roomTopic (roomId: string, topic: string) : Promise<void>
+
+  // 修改群名称
+  override async roomTopic (
+    roomId : string,
+    topic? : string,
+  ): Promise<void | string> {
+    await this._client?.setGroupName(roomId, topic)
+  }
+
+  override async roomAnnounce (roomId: string)                : Promise<string>
+  override async roomAnnounce (roomId: string, text: string)  : Promise<void>
+
+  // 修改群公告
+  override async roomAnnounce (roomId: string, text?: string) : Promise<void | string> {
+    if (text !== undefined) {
+      await this._client?.sendAnnouncement(roomId, text)
+    }
+    return ''
+  }
+
+  // 获取群成员列表
+  override async roomMemberList (roomId: string) : Promise<string[]> {
+    const roomMemberMap = await this._getRoomMemberList(roomId)
+    return Object.values(roomMemberMap).map((m) => m.wxid)
+  }
+
+  // 接受群邀请 暂不支持
+  override async roomInvitationAccept (roomInvitationId: string): Promise<void> {
+    return PUPPET.throwUnsupportedError(roomInvitationId)
+  }
+
+  /****************************************************************************
+   * RawPayload section
+   ***************************************************************************/
+
+  // 解析联系人信息格式化为Wechaty 格式
+  override async contactRawPayloadParser (payload: ContactPayload): Promise<PUPPET.payloads.Contact> {
+    return engineContactToWechaty(payload)
+  }
+
+  // 获取联系人信息 原格式
+  override async contactRawPayload (id: string): Promise<ContactPayload | undefined> {
+    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
+  }
+
+  /**
+   * 解析原始消息体为Wechaty支持的格式
+   * @param payload
+   */
+  override async messageRawPayloadParser (payload: MessagePayload): Promise<PUPPET.payloads.Message> {
+    return engineMessageToWechaty(this, payload)
+  }
+
+  /**
+   * 根据消息id 获取消息
+   * @param id
+   */
+  override async messageRawPayload (id: string): Promise<MessagePayload> {
+    const ret = await this._cacheMgr!.getMessage(id)
+    if (!ret) {
+      throw new Error(`can not find message in cache for messageId: ${id}`)
+    }
+
+    return ret
+  }
+
+  /**
+   * 群数据格式化为Wechaty 支持类型
+   * @param rawPayload
+   */
+  override async roomRawPayloadParser (payload: ContactPayload): Promise<PUPPET.payloads.Room> {
+    return engineRoomToWechaty(payload)
+  }
+
+  /**
+   * 查找群基础信息
+   * @param id
+   */
+  override async roomRawPayload (id: string): Promise<ContactPayload|undefined> {
+    let ret = await this._cacheMgr!.getRoom(id)
+    if (!ret) {
+      const contact = await this._refreshContact(id)
+      ret = contact
+    }
+    return ret
+  }
+
+  /**
+   * 查找群成员信息
+   * @param roomId
+   * @param contactId
+   */
+  override async roomMemberRawPayload (roomId: string, contactId: string): Promise<ContactPayload>  {
+    const roomMemberMap = await this._getRoomMemberList(roomId)
+    if (roomMemberMap[contactId]) {
+      return roomMemberMap[contactId]!
+    }
+    const newMap = await this._getRoomMemberList(roomId, true)
+
+    return newMap[contactId]!
+  }
+
+  /**
+   * 解析群成员信息
+   * @param rawPayload
+   */
+  override async roomMemberRawPayloadParser (rawPayload: ContactPayload): Promise<PUPPET.payloads.RoomMember>  {
+    return engineRoomMemberToWechaty(rawPayload)
+  }
+
+  /**
+   * 接收群邀请信息  暂不支持
+   * @param roomInvitationId
+   */
+  override async roomInvitationRawPayload (roomInvitationId: string): Promise<any> {
+    return PUPPET.throwUnsupportedError(roomInvitationId)
+  }
+
+  /**
+   * 解析群邀请信息  暂不支持
+   * @param rawPayload
+   */
+  override async roomInvitationRawPayloadParser (rawPayload: any): Promise<PUPPET.payloads.RoomInvitation> {
+    return PUPPET.throwUnsupportedError(rawPayload)
+  }
+
+  /**
+   * 好友申请信息解析
+   * @param rawPayload
+   */
+  override async friendshipRawPayloadParser (rawPayload: PUPPET.payloads.Friendship): Promise<PUPPET.payloads.Friendship> {
+    return rawPayload
+  }
+
+  /**
+   * 获取好友申请信息
+   * @param id
+   */
+  override async friendshipRawPayload (id: string): Promise<PUPPET.payloads.Friendship> {
+    const ret = await this._cacheMgr!.getFriendshipRawPayload(id)
+
+    if (!ret) {
+      throw new Error(`Can not find friendship for id: ${id}`)
+    }
+
+    return ret
+  }
+  /****************************************************************************
+   * extra methods section
+   ***************************************************************************/
+
+  async syncRoom () {
+    if (this.state.active() !== true) {
+      throw new Error('Can not sync contact before login')
+    }
+    await this._client?.getGroupList(1, 100)
+  }
+  /****************************************************************************
+   * private section
+   ***************************************************************************/
+
+  // 获取群成员列表
+  private async _getRoomMemberList (roomId: string, force?: boolean): Promise<RoomMemberMap> {
+    // FIX: https://github.com/wechaty/puppet-padlocal/issues/115
+    if (!this._cacheMgr) {
+      return {}
+    }
+
+    let ret = await this._cacheMgr!.getRoomMember(roomId)
+
+    // eslint-disable-next-line @typescript-eslint/no-unnecessary-condition
+    if (!ret || (ret && !Object.keys(ret).length) || force) {
+      const resMembers = await this._client?.getGroupMembers(roomId) || []
+
+      const roomMemberMap: RoomMemberMap = {}
+      for (const roomMember of resMembers) {
+        const hasContact = await this._cacheMgr!.hasContact(roomMember.wxid)
+        let MemberInfo: ContactPayload
+        // save chat room member as contact, to forbid massive this._client.api.getContact(id) requests while room.ready()
+        if (!hasContact) {
+          MemberInfo = chatRoomMemberToContact(roomMember)
+          await this._cacheMgr!.setContact(MemberInfo.wxid, MemberInfo)
+          roomMemberMap[roomMember.wxid] = MemberInfo
+        } else {
+          MemberInfo = await this._cacheMgr!.getContact(roomMember.wxid) as ContactPayload
+          roomMemberMap[roomMember.wxid] = MemberInfo
+        }
+      }
+      ret = roomMemberMap
+      await this._updateRoomMember(roomId, roomMemberMap)
+    }
+
+    return ret
+  }
+
+  // 更新联系人缓存
+  private async _updateContactCache (contact: ContactPayload): Promise<void> {
+    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: ContactPayload = 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)
+      }
+    }
+  }
+
+  // 更新群成员
+  private async _updateRoomMember (roomId: string, roomMemberMap?: RoomMemberMap) {
+    if (roomMemberMap) {
+      await this._cacheMgr!.setRoomMember(roomId, roomMemberMap)
+    } else {
+      await this._cacheMgr!.deleteRoomMember(roomId)
+    }
+  }
+
+  /** this.emit('login', { contactId: userId })
+   * 更新群成员信息
+   * @param roomId
+   */
+  public async _updateRoom (roomId:string) {
+    if (!roomId) {
+      log.warn(PRE, 'roomid is required for updateRoom')
+      return
+    }
+    let contact: ContactPayload | undefined = await this._client?.searchContact([ roomId ]) as ContactPayload | undefined
+
+    if (contact) {
+      const memeberMap: RoomMemberMap = 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)
+    }
+  }
+
+  // 添加好友信息到缓存
+  private async _onPushContact (contact: ContactPayload): Promise<void> {
+    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)
+      }
+    }
+  }
+
+  private async _onPushMessage (message: MessagePayload): Promise<void> {
+    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: PUPPET.payloads.RoomInvitation = event.payload
+        await this._cacheMgr!.setRoomInvitation(messageId, roomInvite)
+
+        this.emit('room-invite', {
+          roomInvitationId: messageId,
+        })
+        break
+      }
+      case EventType.RoomJoin: {
+        // const roomJoin: PUPPET.payloads.EventRoomJoin = event.payload
+        // await this._updateRoomMember(roomJoin.roomId)
+        // this.emit('room-join', roomJoin)
+        break
+      }
+      case EventType.RoomLeave: {
+        // const roomLeave: PUPPET.payloads.EventRoomLeave = event.payload
+        // this.emit('room-leave', roomLeave)
+
+        // await this._updateRoomMember(roomLeave.roomId)
+        break
+      }
+      case EventType.RoomTopic: {
+        // const roomTopic: PUPPET.payloads.EventRoomTopic = event.payload
+        // this.emit('room-topic', roomTopic)
+        break
+      }
+    }
+  }
+
+  // 刷新用户信息
+  private async _refreshContact (wxid: string, isFriend?: number): Promise<ContactPayload | undefined> {
+    const contact = await this._client?.searchContactDetail([ wxid ]) as ContactPayload | undefined
+    // may return contact with empty payload, empty username, nickname, etc.
+    if (contact && !contact.wxid) {
+      contact.wxid = wxid
+      await this._updateContactCache({ ...contact, isFriend })
+      return contact
+    } else if (contact) {
+      return contact
+    }
+    return undefined
+  }
+
+  // 开始监听心跳
+  private async _startPuppetHeart (firstTime: boolean = true) {
+    if (firstTime && this._heartBeatTimer) {
+      return
+    }
+    this.emit('heartbeat', { data: 'heartbeat@matrix' })
+    // eslint-disable-next-line @typescript-eslint/no-misused-promises
+    this._heartBeatTimer = setTimeout(async (): Promise<void> => {
+      await this._startPuppetHeart(false)
+      return undefined
+    }, 15 * 1000) // 15s
+  }
+
+  // 停止监听心跳
+  private _stopPuppetHeart () {
+    if (!this._heartBeatTimer) {
+      return
+    }
+
+    clearTimeout(this._heartBeatTimer)
+    this._heartBeatTimer = undefined
+  }
+
+  /**
+   * 解析图片
+   * @param messageId
+   * @param messagePayload
+   * @private
+   */
+  private async _getMessageImageFileBox (messageId: string, messagePayload: MessagePayload):Promise<FileBoxInterface> {
+    const imageInfo: ImageMessagePayload = 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)
+  }
+
+  private async _getMessageAudioFileBox (messageId: string, messagePayload: MessagePayload):Promise<FileBoxInterface> {
+    const audioInfo: AudioMessagePayload = 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)
+  }
+
+  private async _getMessageVideoFileBox (messageId: string, messagePayload: MessagePayload):Promise<FileBoxInterface> {
+    const videoInfo: VideoMessagePayload = 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)
+  }
+
+  /**
+   * 解析文件
+   * @param messageId
+   * @param messagePayload
+   * @private
+   */
+  private async _getMessageFileFileBox (messageId: string, messagePayload: MessagePayload):Promise<FileBoxInterface> {
+    const appPayload: AppMessagePayload = 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 })
+  }
+
+  // @ts-ignore
+  public 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