@juzi/wechaty-puppet-whatsapp 1.0.0

package/src/package-json.ts

@@ -0,0 +1,93 @@
+/**
+ * This file was auto generated from scripts/generate-version.sh
+ */
+import type { PackageJson } from 'type-fest'
+export const packageJson: PackageJson = {
+  "name": "@juzi/wechaty-puppet-whatsapp",
+  "version": "1.0.0",
+  "description": "Wechaty Puppet for WhatsApp",
+  "type": "module",
+  "exports": {
+    ".": {
+      "import": "./dist/esm/src/mod.js",
+      "require": "./dist/cjs/src/mod.js"
+    }
+  },
+  "typings": "./dist/esm/src/mod.d.ts",
+  "engines": {
+    "node": ">=16",
+    "npm": ">=7"
+  },
+  "scripts": {
+    "clean": "shx rm -fr dist/*",
+    "dist": "npm-run-all clean build fixup",
+    "build": "tsc && tsc -p tsconfig.cjs.json",
+    "fixup": "shx echo '{\"type\": \"commonjs\"}' > dist/cjs/package.json",
+    "start": "cross-env NODE_OPTIONS='--no-warnings --loader=ts-node/esm' node examples/ding-dong-bot.ts",
+    "lint": "npm-run-all lint:es lint:ts lint:md",
+    "lint:md": "markdownlint README.md",
+    "lint:ts": "tsc --isolatedModules --noEmit",
+    "lint:es": "eslint \"src/**/*.ts\" \"tests/**/*.spec.ts\" --ignore-pattern tests/fixtures/",
+    "test": "npm-run-all lint test:unit",
+    "test:pack": "bash -x scripts/npm-pack-testing.sh",
+    "test:unit": "tap --node-arg=--loader=ts-node/esm --node-arg=--no-warnings 'src/**/*.spec.ts' 'tests/**/*.spec.ts'"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/juzibot/puppet-whatsapp.git"
+  },
+  "keywords": [
+    "chatie",
+    "wechaty",
+    "chatbot",
+    "bot",
+    "wechat",
+    "sdk",
+    "puppet",
+    "mock"
+  ],
+  "author": "Huan LI <zixia@zixia.net>",
+  "license": "Apache-2.0",
+  "bugs": {
+    "url": "https://github.com/juzibot/puppet-whatsapp/issues"
+  },
+  "homepage": "https://github.com/juzibot/puppet-whatsapp#readme",
+  "devDependencies": {
+    "@chatie/eslint-config": "^1.0.4",
+    "@chatie/semver": "^0.4.7",
+    "@chatie/tsconfig": "^4.6.3",
+    "@types/cuid": "^2.0.1",
+    "@types/fs-extra": "^9.0.13",
+    "@types/mime": "^2.0.3",
+    "@types/node-schedule": "^1.3.2",
+    "@types/qrcode-terminal": "^0.12.0",
+    "qrcode-terminal": "^0.12.0",
+    "tstest": "^1.2.8"
+  },
+  "peerDependencies": {
+    "@juzi/wechaty-puppet": "1.0.0"
+  },
+  "dependencies": {
+    "@juzi/whatsapp-web.js": "^1.16.10",
+    "ee-ts": "^1.0.2",
+    "flash-store": "^1.0.6",
+    "fs-extra": "^10.0.1",
+    "gerror": "^1.0.16",
+    "mime": "^3.0.0",
+    "node-schedule": "^2.1.0",
+    "rxjs": "^7.5.5",
+    "type-fest": "^2.12.2"
+  },
+  "files": [
+    "bin/",
+    "dist/",
+    "src/"
+  ],
+  "tap": {
+    "check-coverage": false
+  },
+  "publishConfig": {
+    "access": "public",
+    "tag": "next"
+  }
+} as any

package/src/puppet-mixin/contact-self.ts

@@ -0,0 +1,20 @@
+import * as PUPPET from '@juzi/wechaty-puppet'
+import { log } from '../config.js'
+import type PuppetWhatsApp from '../puppet-whatsapp.js'
+
+const PRE = 'MIXIN_CONTACT_SELF'
+
+export async function contactSelfQRCode (this: PuppetWhatsApp): Promise<string> {
+  log.verbose(PRE, 'contactSelfQRCode()')
+  return PUPPET.throwUnsupportedError()
+}
+
+export async function contactSelfName (this: PuppetWhatsApp, name: string): Promise<void> {
+  log.verbose(PRE, 'contactSelfName(%s)', name)
+  await this.manager.setNickname(name)
+}
+
+export async function contactSelfSignature (this: PuppetWhatsApp, signature: string): Promise<void> {
+  log.verbose(PRE, 'contactSelfSignature(%s)', signature)
+  await this.manager.setStatusMessage(signature)
+}

package/src/puppet-mixin/contact.ts

@@ -0,0 +1,107 @@
+/* eslint-disable no-redeclare */
+import * as PUPPET from '@juzi/wechaty-puppet'
+
+import {
+  FileBox,
+  log,
+} from '../config.js'
+import { WA_ERROR_TYPE } from '../exception/error-type.js'
+import WAError from '../exception/whatsapp-error.js'
+import type PuppetWhatsApp from '../puppet-whatsapp.js'
+import type { WhatsAppContactPayload } from '../schema/whatsapp-type.js'
+import { isContactId } from '../helper/miscellaneous.js'
+
+import { parserContactRawPayload } from '../helper/pure-function/contact-raw-payload-parser.js'
+
+const PRE = 'MIXIN_CONTACT'
+
+export async function contactAlias(this: PuppetWhatsApp, contactId: string): Promise<string>;
+export async function contactAlias(this: PuppetWhatsApp, contactId: string, alias: string | null): Promise<void>;
+export async function contactAlias (this: PuppetWhatsApp, contactId: string, alias?: string | null): Promise<void | string> {
+  log.verbose(PRE, 'contactAlias(%s, %s)', contactId, alias)
+  return PUPPET.throwUnsupportedError()
+}
+
+export async function contactPhone(this: PuppetWhatsApp, contactId: string): Promise<string[]>
+export async function contactPhone(this: PuppetWhatsApp, contactId: string, phoneList: string[]): Promise<void>
+
+export async function contactPhone (this: PuppetWhatsApp, contactId: string, phoneList?: string[]): Promise<string[] | void> {
+  log.verbose(PRE, 'contactPhone(%s, %s)', contactId, phoneList)
+  if (typeof phoneList === 'undefined') {
+    const cacheManager = await this.manager.getCacheManager()
+    const contact = await cacheManager.getContactOrRoomRawPayload(contactId)
+    if (contact) {
+      return [contact!.number]
+    } else {
+      return []
+    }
+  }
+}
+
+export async function contactCorporationRemark (this: PuppetWhatsApp, contactId: string, corporationRemark: string) {
+  log.verbose(PRE, 'contactCorporationRemark(%s, %s)', contactId, corporationRemark)
+  return PUPPET.throwUnsupportedError()
+}
+
+export async function contactDescription (this: PuppetWhatsApp, contactId: string, description: string) {
+  log.verbose(PRE, 'contactDescription(%s, %s)', contactId, description)
+  return PUPPET.throwUnsupportedError()
+}
+
+export async function contactList (this: PuppetWhatsApp): Promise<string[]> {
+  log.verbose(PRE, 'contactList()')
+  const cacheManager = await this.manager.getCacheManager()
+  const contactIdList = await cacheManager.getContactIdList()
+  return contactIdList
+}
+
+export async function contactAvatar(this: PuppetWhatsApp, contactId: string): Promise<FileBox>
+export async function contactAvatar(this: PuppetWhatsApp, contactId: string, file: FileBox): Promise<void>
+
+export async function contactAvatar (this: PuppetWhatsApp, contactId: string, file?: FileBox): Promise<void | FileBox> {
+  log.verbose(PRE, 'contactAvatar(%s)', contactId)
+
+  if (file) {
+    return PUPPET.throwUnsupportedError()
+  }
+  let avatar: string = ''
+  const con = await this.manager.getContactById(contactId)
+  try {
+    avatar = await con.getProfilePicUrl()
+  } catch (err) {
+    log.error(PRE, 'contactAvatar(%s) error:%s', contactId, (err as Error).message)
+  }
+  if (avatar) {
+    return FileBox.fromUrl(avatar)
+  }
+}
+
+export async function contactRawPayload (this: PuppetWhatsApp, id: string): Promise<WhatsAppContactPayload> {
+  log.verbose(PRE, 'contactRawPayload(%s)', id)
+  if (!isContactId(id)) {
+    throw WAError(WA_ERROR_TYPE.ERR_CONTACT_NOT_FOUND, `please check contact id: ${id} again.`)
+  }
+  const cacheManager = await this.manager.getCacheManager()
+  const contact = await cacheManager.getContactOrRoomRawPayload(id)
+  if (contact) {
+    return contact
+  } else {
+    const rawContact = await this.manager.getContactById(id)
+    const avatar = await rawContact.getProfilePicUrl() || ''
+    const contact = Object.assign(rawContact, { avatar })
+    await cacheManager.setContactOrRoomRawPayload(id, contact)
+    return contact
+  }
+}
+
+export async function contactRawPayloadParser (this: PuppetWhatsApp, contactPayload: WhatsAppContactPayload): Promise<PUPPET.payloads.Contact> {
+  try {
+    const userName = this.manager.getWhatsAppClient().info.pushname
+    const result = parserContactRawPayload(contactPayload, userName)
+    log.verbose(PRE, 'contactRawPayloadParser whatsAppPayload(%s) result(%s)', JSON.stringify(contactPayload), JSON.stringify(result))
+    return result
+  } catch (error) {
+    log.error(PRE, `contactRawPayloadParser(${contactPayload.id._serialized}) failed, error message: ${(error as Error).message}`)
+    throw WAError(WA_ERROR_TYPE.ERR_CONTACT_NOT_FOUND, `contactRawPayloadParser(${contactPayload.id._serialized}) failed, error message: ${(error as Error).message}`)
+  }
+}

package/src/puppet-mixin/conversation.ts

@@ -0,0 +1,12 @@
+import * as PUPPET from '@juzi/wechaty-puppet'
+import { log } from '../config.js'
+
+const PRE = 'MIXIN_CONVERSATION'
+
+export async function conversationReadMark (
+  conversationId: string,
+  hasRead?: boolean,
+): Promise<void | boolean> {
+  log.verbose(PRE, 'conversationReadMark(%s, %s)', conversationId, hasRead)
+  return PUPPET.throwUnsupportedError()
+}

package/src/puppet-mixin/friendship.ts

@@ -0,0 +1,88 @@
+import * as PUPPET from '@juzi/wechaty-puppet'
+import { LANGUAGE, log, STRINGS } from '../config.js'
+import { WA_ERROR_TYPE } from '../exception/error-type.js'
+import WAError from '../exception/whatsapp-error.js'
+import type PuppetWhatsApp from '../puppet-whatsapp.js'
+import type { WhatsAppMessagePayload } from '../schema/whatsapp-type.js'
+
+const PRE = 'MIXIN_FRIENDSHIP'
+
+export type FriendshipRawPayload = WhatsAppMessagePayload
+
+export async function friendshipRawPayload (this: PuppetWhatsApp, id: string): Promise<FriendshipRawPayload> {
+  const cache = await this.manager.getCacheManager()
+  const message = await cache.getMessageRawPayload(id)
+  if (!message) {
+    throw WAError(WA_ERROR_TYPE.ERR_MSG_NOT_FOUND, 'Message not found', `messageId: ${id}`)
+  }
+  return message
+}
+
+export async function friendshipRawPayloadParser (rawPayload: FriendshipRawPayload): Promise<PUPPET.payloads.Friendship> {
+  return {
+    contactId: rawPayload.from,
+    hello: rawPayload.body,
+    id: rawPayload.id.id,
+    timestamp: rawPayload.timestamp,
+    type: PUPPET.types.Friendship.Confirm,
+  }
+}
+
+export async function friendshipSearchPhone (
+  this: PuppetWhatsApp,
+  phone: string,
+): Promise<null | string> {
+  log.verbose(PRE, 'friendshipSearchPhone(%s)', phone)
+  const contactId = `${phone}@c.us`
+  const isUser = await this.manager.isWhatsappUser(contactId)
+  if (!isUser) {
+    throw WAError(WA_ERROR_TYPE.ERR_CONTACT_NOT_FOUND, 'Not a registered user on WhatsApp.', `contactId: ${contactId}`)
+  }
+  return contactId
+}
+
+export async function friendshipSearchWeixin (
+  weixin: string,
+): Promise<null | string> {
+  log.verbose(PRE, 'friendshipSearchWeixin(%s)', weixin)
+  return PUPPET.throwUnsupportedError()
+}
+
+export async function friendshipSearchHandle (
+  handle: string,
+): Promise<null | string> {
+  log.verbose(PRE, 'friendshipSearchHandle(%s)', handle)
+  return PUPPET.throwUnsupportedError()
+}
+
+export async function friendshipAdd (
+  this: PuppetWhatsApp,
+  contactId: string,
+  option?: PUPPET.types.FriendshipAddOptions,
+): Promise<void> {
+  let hello: string = ''
+  if (typeof (option) === 'object') {
+    hello = option.hello || ''
+  } else {
+    hello = option || ''
+  }
+  if (hello.length === 0) {
+    hello = STRINGS[LANGUAGE].DEFAULT_HELLO_MESSAGE
+  }
+  log.verbose(PRE, 'friendshipAdd(%s, %s)', contactId, JSON.stringify(option))
+  const isUser = await this.manager.isWhatsappUser(contactId)
+  if (!isUser) {
+    throw WAError(WA_ERROR_TYPE.ERR_CONTACT_NOT_FOUND, 'Not a registered user on WhatsApp.', `contactId: ${contactId}`)
+  }
+
+  await this.contactRawPayload(contactId)
+
+  await this.messageSendText(contactId, hello)
+}
+
+export async function friendshipAccept (
+  friendshipId: string,
+): Promise<void> {
+  log.verbose(PRE, 'friendshipAccept(%s)', friendshipId)
+  return PUPPET.throwUnsupportedError()
+}

package/src/puppet-mixin/message.ts

@@ -0,0 +1,311 @@
+import * as PUPPET from '@juzi/wechaty-puppet'
+import * as path  from 'path'
+import mime from 'mime'
+import type PuppetWhatsApp from '../puppet-whatsapp.js'
+import type {
+  MessageContent,
+  WhatsAppMessagePayload,
+  MessageSendOptions,
+} from '../schema/whatsapp-type.js'
+import {
+  MessageMedia,
+  MessageTypes as WhatsAppMessageType,
+} from '../schema/whatsapp-interface.js'
+import { WA_ERROR_TYPE } from '../exception/error-type.js'
+import WAError from '../exception/whatsapp-error.js'
+import {
+  DEFAULT_TIMEOUT,
+  FileBox,
+  log,
+} from '../config.js'
+import { convertMessagePayloadToClass } from '../helper/pure-function/convert-function.js'
+import { parserMessageRawPayload } from '../helper/pure-function/message-raw-payload-parser.js'
+import { parseVcard } from '../helper/pure-function/vcard-parser.js'
+import { RequestPool } from '../request/request-pool.js'
+
+const PRE = 'MIXIN_MESSAGE'
+
+/**
+  * Get contact message
+  * @param messageId message Id
+  * @returns contact name
+  */
+export async function messageContact (this: PuppetWhatsApp, messageId: string): Promise<string> {
+  log.verbose(PRE, 'messageContact(%s)', messageId)
+  const cacheManager = await this.manager.getCacheManager()
+  const msg = await cacheManager.getMessageRawPayload(messageId)
+  if (!msg) {
+    log.error(PRE, 'Message %s not found', messageId)
+    throw WAError(WA_ERROR_TYPE.ERR_MSG_NOT_FOUND, `Message ${messageId} not found`)
+  }
+  if (msg.type !== WhatsAppMessageType.CONTACT_CARD) {
+    log.error(PRE, 'Message %s is not contact type', messageId)
+    throw WAError(WA_ERROR_TYPE.ERR_MSG_NOT_MATCH, `Message ${messageId} is not contact type`)
+  }
+  if (!msg.vCards[0]) {
+    throw WAError(WA_ERROR_TYPE.ERR_MSG_NOT_MATCH, `Message ${messageId} has no vCards info, detail: ${JSON.stringify(msg)}`)
+  }
+  try {
+    const vcard = parseVcard(msg.vCards[0])
+    return vcard.TEL![0]!.waid
+  } catch (error) {
+    throw WAError(WA_ERROR_TYPE.ERR_MSG_CONTACT, `Can not parse contact card from message: ${messageId}, error: ${(error as Error).message}`)
+  }
+}
+
+/**
+* Recall message
+* @param messageId message id
+* @returns { Promise<boolean> }
+*/
+export async function messageRecall (this: PuppetWhatsApp, messageId: string): Promise<boolean> {
+  log.verbose(PRE, 'messageRecall(%s)', messageId)
+  const cacheManager = await this.manager.getCacheManager()
+  const msg = await cacheManager.getMessageRawPayload(messageId)
+  if (!msg) {
+    log.error(PRE, 'Message %s not found', messageId)
+    throw WAError(WA_ERROR_TYPE.ERR_MSG_NOT_FOUND, `Message ${messageId} not found`)
+  }
+  const msgObj = convertMessagePayloadToClass(this.manager.getWhatsAppClient(), msg)
+  try {
+    await msgObj.delete(true)
+    return true
+  } catch (err) {
+    log.error(PRE, `Can not recall this message: ${messageId}, error: ${(err as Error).message}`)
+    return false
+  }
+}
+
+/**
+* Get moment detail image or video from message
+* @param messageId message id
+* @param imageType image size to get (may not apply to WhatsApp)
+* @returns the image or video
+*/
+export async function messagePost (this: PuppetWhatsApp, messageId: string, imageType: PUPPET.types.Image) {
+  log.verbose(PRE, 'messagePost(%s, %s)', messageId, PUPPET.types.Image[imageType])
+  const cacheManager = await this.manager.getCacheManager()
+  const msg = await cacheManager.getMessageRawPayload(messageId)
+  if (!msg) {
+    log.error(PRE, 'Message %s not found', messageId)
+    throw WAError(WA_ERROR_TYPE.ERR_MSG_NOT_FOUND, `Message ${messageId} Not Found`)
+  }
+
+  if (!msg.hasMedia) {
+    log.error(PRE, 'Message %s does not contain any media', messageId)
+    throw WAError(WA_ERROR_TYPE.ERR_MSG_NOT_MATCH, `Message ${messageId} does not contain any media`)
+  }
+
+  if (msg.type === WhatsAppMessageType.IMAGE) {
+    return this.messageImage(messageId, imageType)
+  } else if (msg.type === WhatsAppMessageType.VIDEO) {
+    return this.messageFile(messageId)
+  } else {
+    throw WAError(WA_ERROR_TYPE.ERR_MSG_NOT_MATCH, `Post message ${messageId} with wrong message type: ${msg.type}`)
+  }
+
+}
+
+/**
+* Get image from message
+* @param messageId message id
+* @param imageType image size to get (may not apply to WhatsApp)
+* @returns the image
+*/
+export async function messageImage (this: PuppetWhatsApp, messageId: string, imageType: PUPPET.types.Image): Promise<FileBox> {
+  log.verbose(PRE, 'messageImage(%s, %s)', messageId, PUPPET.types.Image[imageType])
+  const cacheManager = await this.manager.getCacheManager()
+  const msg = await cacheManager.getMessageRawPayload(messageId)
+  if (!msg) {
+    log.error(PRE, 'Message %s not found', messageId)
+    throw WAError(WA_ERROR_TYPE.ERR_MSG_NOT_FOUND, `Message ${messageId} Not Found`)
+  }
+  if (msg.type !== WhatsAppMessageType.IMAGE || (!msg.hasMedia && !msg.body)) {
+    log.error(PRE, 'Message %s does not contain any media', messageId)
+    throw WAError(WA_ERROR_TYPE.ERR_MSG_NOT_MATCH, `Message ${messageId} does not contain any media`)
+  }
+  try {
+    switch (imageType) {
+      case PUPPET.types.Image.HD:
+      case PUPPET.types.Image.Artwork:
+        if (msg.hasMedia) {
+          return downloadMedia.call(this, msg)
+        } else {
+          return FileBox.fromBase64(msg.body, 'thumbnail.jpg')
+        }
+      case PUPPET.types.Image.Thumbnail:
+      default:
+        if (msg.body) {
+          return FileBox.fromBase64(msg.body, 'thumbnail.jpg')
+        } else {
+          return downloadMedia.call(this, msg)
+        }
+    }
+  } catch (error) {
+    throw WAError(WA_ERROR_TYPE.ERR_MSG_IMAGE, `Message ${messageId} does not contain any media`)
+  }
+}
+
+/**
+* Get the file attached to the message
+* @param messageId message id
+* @returns the file that attached to the message
+*/
+export async function messageFile (this: PuppetWhatsApp, messageId: string): Promise<FileBox> {
+  log.verbose(PRE, 'messageFile(%s)', messageId)
+  const cacheManager = await this.manager.getCacheManager()
+  const msg = await cacheManager.getMessageRawPayload(messageId)
+  if (!msg) {
+    log.error(PRE, 'Message %s not found', messageId)
+    throw WAError(WA_ERROR_TYPE.ERR_MSG_NOT_FOUND, `Message ${messageId} Not Found`)
+  }
+  if (!msg.hasMedia) {
+    log.error(PRE, 'Message %s does not contain any media', messageId)
+    throw WAError(WA_ERROR_TYPE.ERR_MSG_NOT_MATCH, `Message ${messageId} does not contain any media`)
+  }
+  try {
+    return downloadMedia.call(this, msg)
+  } catch (error) {
+    throw WAError(WA_ERROR_TYPE.ERR_MSG_FILE, `Message ${messageId} does not contain any media`)
+  }
+}
+
+async function downloadMedia (this: PuppetWhatsApp, msg: WhatsAppMessagePayload) {
+  const msgObj = convertMessagePayloadToClass(this.manager.getWhatsAppClient(), msg)
+  const media = await msgObj.downloadMedia()
+  const filenameExtension = mime.getExtension(media.mimetype)
+  const fileBox = FileBox.fromBase64(media.data, media.filename ?? `unknown_name.${filenameExtension}`)
+  fileBox.mimeType = media.mimetype
+  return fileBox
+}
+
+/**
+* Get url in the message
+* @param messageId message id
+* @returns url in the message
+*/
+export async function messageUrl (this: PuppetWhatsApp, messageId: string): Promise<PUPPET.payloads.UrlLink> {
+  log.verbose(PRE, 'messageUrl(%s)', messageId)
+  const cacheManager = await this.manager.getCacheManager()
+  const msg = await cacheManager.getMessageRawPayload(messageId)
+  if (!msg) {
+    log.error(PRE, 'Message %s not found', messageId)
+    throw WAError(WA_ERROR_TYPE.ERR_MSG_NOT_FOUND, `Message ${messageId} Not Found`)
+  }
+  if (msg.links.length === 0) {
+    log.error(PRE, 'Message %s is does not contain links', messageId)
+    throw WAError(WA_ERROR_TYPE.ERR_MSG_NOT_MATCH, `Message ${messageId} does not contain any link message.`)
+  }
+  try {
+    return {
+      description: msg.description || 'NO_DESCRIPTION',
+      title: msg.title || 'NO_TITLE',
+      url: msg.links[0]?.link || msg.body,
+    }
+  } catch (error) {
+    throw WAError(WA_ERROR_TYPE.ERR_MSG_URL_LINK, `Get link message: ${messageId} failed, error: ${(error as Error).message}`)
+  }
+}
+
+/**
+* Not supported for WhatsApp
+* @param messageId message id
+*/
+export async function messageMiniProgram (this: PuppetWhatsApp, messageId: string): Promise<PUPPET.payloads.MiniProgram> {
+  log.verbose(PRE, 'messageMiniProgram(%s)', messageId)
+  return PUPPET.throwUnsupportedError()
+}
+
+export async function messageSend (this: PuppetWhatsApp, conversationId: string, content: MessageContent, options?: MessageSendOptions, timeout = DEFAULT_TIMEOUT.MESSAGE_SEND): Promise<string> {
+  log.verbose(PRE, 'messageSend(%s, %s)', conversationId, typeof content)
+
+  const msg = await this.manager.sendMessage(conversationId, content, options)
+  const messageId = msg.id.id
+  const requestPool = RequestPool.Instance
+  await requestPool.pushRequest(messageId, timeout)
+  return messageId
+}
+
+export async function messageSendText (this: PuppetWhatsApp, conversationId: string, text: string, mentions?: string[]): Promise<void | string> {
+  log.verbose(PRE, 'messageSendText(%s, %s)', conversationId, text)
+  if (mentions) {
+    const contacts = await Promise.all(mentions.map((v) => (
+      this.manager.getContactById(v)
+    )))
+    return messageSend.call(this, conversationId, text, { mentions: contacts }, DEFAULT_TIMEOUT.MESSAGE_SEND_TEXT)
+  } else {
+    return messageSend.call(this, conversationId, text, {}, DEFAULT_TIMEOUT.MESSAGE_SEND_TEXT)
+  }
+}
+
+export async function messageSendFile (this: PuppetWhatsApp, conversationId: string, file: FileBox, options?: MessageSendOptions): Promise<void | string> {
+  log.verbose(PRE, 'messageSendFile(%s, %s)', conversationId, file.name)
+  await file.ready()
+  const type = (file.mediaType && file.mediaType !== 'application/octet-stream')
+    ? file.mediaType.replace(/;.*$/, '')
+    : path.extname(file.name)
+  log.silly(PRE, `message type: ${type}, filename: ${file.name}`)
+  const fileBoxJsonObject: any = file.toJSON() // FIXME: need import FileBoxJsonObject from file-box
+  const remoteUrl = fileBoxJsonObject.remoteUrl
+  let msgContent
+  if (remoteUrl) {
+    msgContent = await MessageMedia.fromUrl(remoteUrl, { filename: file.name })
+  } else {
+    const fileData = await file.toBase64()
+    msgContent = new MessageMedia(file.mediaType!, fileData, file.name)
+  }
+  return messageSend.call(this, conversationId, msgContent, options, DEFAULT_TIMEOUT.MESSAGE_SEND_FILE)
+}
+
+export async function messageSendContact (this: PuppetWhatsApp, conversationId: string, contactId: string, options?: MessageSendOptions): Promise<void> {
+  log.verbose(PRE, 'messageSendContact(%s, %s)', conversationId, contactId)
+
+  const contact = await this.manager.getContactById(contactId)
+  await messageSend.call(this, conversationId, contact, options, DEFAULT_TIMEOUT.MESSAGE_SEND_TEXT)
+}
+
+export async function messageSendUrl (
+  this: PuppetWhatsApp,
+  conversationId: string,
+  urlLinkPayload: PUPPET.payloads.UrlLink,
+): Promise<string> {
+  log.verbose(PRE, 'messageSendUrl(%s, %s)', conversationId, JSON.stringify(urlLinkPayload))
+  return messageSend.call(this, conversationId, urlLinkPayload.url, {}, DEFAULT_TIMEOUT.MESSAGE_SEND_TEXT)
+}
+
+export async function messageSendMiniProgram (this: PuppetWhatsApp, conversationId: string, miniProgramPayload: PUPPET.payloads.MiniProgram): Promise<void> {
+  log.verbose(PRE, 'messageSendMiniProgram(%s, %s)', conversationId, JSON.stringify(miniProgramPayload))
+  return PUPPET.throwUnsupportedError()
+}
+
+export async function messageForward (this: PuppetWhatsApp, conversationId: string, messageId: string): Promise<void> {
+  log.verbose(PRE, 'messageForward(%s, %s)', conversationId, messageId)
+  const cacheManager = await this.manager.getCacheManager()
+  const msg = await cacheManager.getMessageRawPayload(messageId)
+  if (!msg) {
+    log.error(PRE, 'Message %s not found', messageId)
+    throw WAError(WA_ERROR_TYPE.ERR_MSG_NOT_FOUND, `Message ${messageId} not found`)
+  }
+  const msgObj = convertMessagePayloadToClass(this.manager.getWhatsAppClient(), msg)
+  try {
+    await msgObj.forward(conversationId)
+  } catch (error) {
+    throw WAError(WA_ERROR_TYPE.ERR_MSG_FORWARD, `Forward message: ${messageId} failed, error: ${(error as Error).message}`)
+  }
+}
+
+export async function messageRawPayload (this: PuppetWhatsApp, id: string): Promise<WhatsAppMessagePayload> {
+  log.verbose(PRE, 'messageRawPayload(%s)', id)
+  const cacheManager = await this.manager.getCacheManager()
+  const msg = await cacheManager.getMessageRawPayload(id)
+  if (!msg) {
+    throw WAError(WA_ERROR_TYPE.ERR_MSG_NOT_FOUND, `Can not find this message: ${id}`)
+  }
+  return msg
+}
+
+export async function messageRawPayloadParser (this: PuppetWhatsApp, whatsAppPayload: WhatsAppMessagePayload): Promise<PUPPET.payloads.Message> {
+  const result = parserMessageRawPayload(whatsAppPayload)
+  log.verbose(PRE, 'messageRawPayloadParser whatsAppPayload(%s) result(%s)', JSON.stringify(whatsAppPayload), JSON.stringify(result))
+  return result
+}