@juzi/wechaty-puppet-whatsapp 1.0.0

package/src/whatsapp/event-handler/message-event-handler.ts

@@ -0,0 +1,230 @@
+import type * as PUPPET from '@juzi/wechaty-puppet'
+import {
+  MessageMediaTypeList,
+  log,
+} from '../../config.js'
+import {
+  MessageTypes as WhatsAppMessageType,
+  MessageAck,
+} from '../../schema/whatsapp-interface.js'
+import WhatsAppBase from '../whatsapp-base.js'
+
+import type {
+  WhatsAppMessage,
+  WhatsAppMessagePayload,
+} from '../../schema/whatsapp-type.js'
+import {
+  isContactId,
+  isInviteLink,
+  getInviteCode,
+} from '../../helper/miscellaneous.js'
+import { RequestPool } from '../../request/request-pool.js'
+
+const PRE = 'MessageEventHandler'
+
+export default class MessageEventHandler extends WhatsAppBase {
+
+  public async onMessage (message: WhatsAppMessage | WhatsAppMessagePayload) {
+    log.info(PRE, `onMessage(${JSON.stringify(message)})`)
+    // @ts-ignore
+    if (
+      message.type === 'multi_vcard'
+      || (message.type === 'e2e_notification'
+      && message.body === ''
+      && !message.author)
+    ) {
+      // skip room join notification and multi_vcard message
+      return
+    }
+    const messageId = message.id.id
+    const cacheManager = await this.manager.getCacheManager()
+    const messageInCache = await cacheManager.getMessageRawPayload(messageId)
+    if (messageInCache) {
+      return
+    }
+    await cacheManager.setMessageRawPayload(messageId, message)
+
+    const contactId = message.from
+    if (contactId && isContactId(contactId)) {
+      const contactIds = await cacheManager.getContactIdList()
+      const notFriend = !contactIds.find(c => c === contactId)
+      if (notFriend) {
+        this.emit('friendship', { friendshipId: messageId })
+      }
+    }
+
+    const needEmitMessage = await this.convertInviteLinkMessageToEvent(message)
+    if (needEmitMessage) {
+      this.emit('message', { messageId })
+    }
+  }
+
+  /**
+   * This event only for the message which sent by bot (web / phone)
+   * @param {WhatsAppMessage} message message detail info
+   * @returns
+   */
+  public async onMessageAck (message: WhatsAppMessage) {
+    log.silly(PRE, `onMessageAck(${JSON.stringify(message)})`)
+
+    /**
+     * if message ack equal MessageAck.ACK_DEVICE, we could regard it as has already send success.
+     *
+     * FIXME: if the ack is not consecutive, and without MessageAck.ACK_DEVICE, then we could not receive this message.
+     *
+     * After add sync missed message schedule, if the ack of message has not reach MessageAck.ACK_DEVICE,
+     * the schedule will emit these messages with wrong ack (ack = MessageAck.ACK_PENDING or MessageAck.ACK_SERVER),
+     * and will make some mistakes (can not get the media of message).
+     */
+    if (message.id.fromMe) {
+      if (MessageMediaTypeList.includes(message.type)) {
+        if (message.hasMedia && message.ack === MessageAck.ACK_SERVER) {
+          await this.processMessageFromBot(message)
+        }
+        if (message.ack === MessageAck.ACK_DEVICE || message.ack === MessageAck.ACK_READ) {
+          await this.processMessageFromBot(message)
+        }
+      } else {
+        await this.processMessageFromBot(message)
+      }
+    }
+  }
+
+  /**
+   * This event only for the message which sent by bot (web / phone) and to the bot self
+   * @param {WhatsAppMessage} message message detail info
+   * @returns
+   */
+  public async onMessageCreate (message: WhatsAppMessage) {
+    log.silly(PRE, `onMessageCreate(${JSON.stringify(message)})`)
+    if (message.id.fromMe) {
+      const messageId = message.id.id
+      const cacheManager = await this.manager.getCacheManager()
+      await cacheManager.setMessageRawPayload(messageId, message)
+      const requestPool = RequestPool.Instance
+      requestPool.resolveRequest(messageId)
+      this.emit('message', { messageId })
+    }
+  }
+
+  public async processMessageFromBot (message: WhatsAppMessage) {
+    const messageId = message.id.id
+    const cacheManager = await this.manager.getCacheManager()
+    const messageInCache = await cacheManager.getMessageRawPayload(messageId)
+    await cacheManager.setMessageRawPayload(messageId, message) // set message with different message ack
+    /**
+     * - Non-Media Message
+     *   emit only when no cache
+     *
+     * - Media Message
+     *   emit message when no cache or ack of message in cache equal 1
+     */
+    if (!messageInCache || (MessageMediaTypeList.includes(message.type) && messageInCache.ack === MessageAck.ACK_SERVER)) {
+      const requestPool = RequestPool.Instance
+      requestPool.resolveRequest(messageId)
+      this.emit('message', { messageId })
+    }
+  }
+
+  public async convertInviteLinkMessageToEvent (message: WhatsAppMessage | WhatsAppMessagePayload): Promise<boolean> {
+    const cacheManager = await this.manager.getCacheManager()
+    if (message.type === WhatsAppMessageType.GROUP_INVITE) {
+      const inviteCode = message.inviteV4?.inviteCode
+      if (inviteCode) {
+        const roomInvitationPayload: PUPPET.payloads.EventRoomInvite = {
+          roomInvitationId: inviteCode,
+        }
+        await cacheManager.setRoomInvitationRawPayload(inviteCode, { inviteCode })
+        this.emit('room-invite', roomInvitationPayload)
+      } else {
+        log.warn(PRE, `convertInviteLinkMessageToEvent can not get invite code: ${JSON.stringify(message)}`)
+      }
+      return false
+    }
+
+    // eslint-disable-next-line @typescript-eslint/no-unnecessary-condition
+    if (message.type === WhatsAppMessageType.TEXT && message.links && message.links.length === 1 && isInviteLink(message.links[0]!.link)) {
+      const inviteCode = getInviteCode(message.links[0]!.link)
+      if (inviteCode) {
+        const roomInvitationPayload: PUPPET.payloads.EventRoomInvite = {
+          roomInvitationId: inviteCode,
+        }
+        await cacheManager.setRoomInvitationRawPayload(inviteCode, { inviteCode })
+        this.emit('room-invite', roomInvitationPayload)
+        return false
+      }
+    }
+    return true
+  }
+
+  public async onIncomingCall (...args: any[]) { // it is a any[] argument
+    log.silly(PRE, `onIncomingCall(${JSON.stringify(args)})`)
+  }
+
+  public async onMediaUploaded (message: WhatsAppMessage) {
+    log.silly(PRE, `onMediaUploaded(${JSON.stringify(message)})`)
+    await this.createOrUpdateImageMessage(message)
+    if (!message.hasMedia) {
+      log.warn(PRE, `onMediaUploaded failed, message id: ${message.id.id}, type: ${message.type}, detail info: ${JSON.stringify(message)}`)
+    }
+  }
+
+  public async createOrUpdateImageMessage (message: WhatsAppMessage) {
+    if (message.type === WhatsAppMessageType.IMAGE) {
+      const messageId = message.id.id
+      const cacheManager = await this.manager.getCacheManager()
+      const messageInCache = await cacheManager.getMessageRawPayload(messageId)
+      if (messageInCache) {
+        message.body = messageInCache.body || message.body
+        await cacheManager.setMessageRawPayload(messageId, message)
+        return
+      }
+      await cacheManager.setMessageRawPayload(messageId, message)
+    }
+  }
+
+  /**
+   * Someone delete message in all devices. Due to they have the same message id so we generate a fake id as flash-store key.
+   * see: https://github.com/pedroslopez/whatsapp-web.js/issues/1178
+   * @param message revoke message
+   * @param revokedMsg original message, sometimes it will be null
+   */
+  public async onMessageRevokeEveryone (message: WhatsAppMessage, revokedMsg?: WhatsAppMessage | null | undefined) {
+    log.silly(PRE, `onMessageRevokeEveryone(newMsg: ${JSON.stringify(message)}, originalMsg: ${JSON.stringify(revokedMsg)})`)
+    const cacheManager = await this.manager.getCacheManager()
+    const messageId = message.id.id
+    if (revokedMsg) {
+      const originalMessageId = revokedMsg.id.id
+      const recalledMessageId = this.generateFakeRecallMessageId(originalMessageId)
+      message.body = recalledMessageId
+      await cacheManager.setMessageRawPayload(recalledMessageId, revokedMsg)
+    }
+    await cacheManager.setMessageRawPayload(messageId, message)
+    this.emit('message', { messageId })
+  }
+
+  /**
+   * Only delete message in bot phone will trigger this event. But the message type is chat, not revoked any more.
+   */
+  public async onMessageRevokeMe (message: WhatsAppMessage) {
+    log.silly(PRE, `onMessageRevokeMe(${JSON.stringify(message)})`)
+    /*
+    if (message.ack === MessageAck.ACK_PENDING) {
+      // when the bot logout, it will receive onMessageRevokeMe event, but it's ack is MessageAck.ACK_PENDING, so let's ignore this event.
+      return
+    }
+    const cacheManager = await this.manager.getCacheManager()
+    const messageId = message.id.id
+    message.type = WhatsAppMessageType.REVOKED
+    message.body = messageId
+    const recalledMessageId = this.generateFakeRecallMessageId(messageId)
+    await cacheManager.setMessageRawPayload(recalledMessageId, message)
+    this.emit('message', { messageId: recalledMessageId })
+    */
+  }
+
+  public generateFakeRecallMessageId (messageId: string) {
+    return `${messageId}_revoked`
+  }
+
+}

package/src/whatsapp/whatsapp-base.ts

@@ -0,0 +1,78 @@
+import { EventEmitter as EE } from 'ee-ts'
+import { MEMORY_SLOT } from '../config.js'
+import { WA_ERROR_TYPE } from '../exception/error-type.js'
+import WAError from '../exception/whatsapp-error.js'
+import type { ManagerEvents } from '../manager-event.js'
+import type Manager from '../manager.js'
+import type { WhatsAppClientType } from '../schema/whatsapp-type.js'
+
+export default class WhatsAppBase extends EE<ManagerEvents> {
+
+  private static _botId?: string
+  private static _whatsAppClient?: WhatsAppClientType
+  protected pendingLogoutEmitTimer?: NodeJS.Timer
+
+  public get botId () {
+    return WhatsAppBase._botId
+  }
+
+  public set botId (value: string | undefined) {
+    WhatsAppBase._botId = value
+  }
+
+  public get whatsAppClient () {
+    return WhatsAppBase._whatsAppClient
+  }
+
+  public set whatsAppClient (value: WhatsAppClientType | undefined) {
+    WhatsAppBase._whatsAppClient = value
+  }
+
+  constructor (protected manager: Manager) {
+    super()
+  }
+
+  protected baseStop () {
+    this.botId = undefined
+    this.whatsAppClient = undefined
+    this.clearPendingLogoutEmitTimer()
+  }
+
+  public getBotId () {
+    if (!this.botId) {
+      throw WAError(WA_ERROR_TYPE.ERR_INIT, 'This bot is not login')
+    }
+    return this.botId
+  }
+
+  public clearPendingLogoutEmitTimer () {
+    if (this.pendingLogoutEmitTimer) {
+      clearTimeout(this.pendingLogoutEmitTimer)
+      this.pendingLogoutEmitTimer = undefined
+    }
+  }
+
+  public getWhatsAppClient () {
+    if (!this.whatsAppClient) {
+      throw WAError(WA_ERROR_TYPE.ERR_INIT, 'Not init whatsapp')
+    }
+    return this.whatsAppClient
+  }
+
+  /**
+   * MemoryCard Session Section
+   */
+
+  public async setSession (session: string) {
+    const memoryCard = this.manager.getMemory()
+    await memoryCard.set(MEMORY_SLOT, session)
+    await memoryCard.save()
+  }
+
+  public async clearSession () {
+    const memoryCard = this.manager.getMemory()
+    await memoryCard.delete(MEMORY_SLOT)
+    await memoryCard.save()
+  }
+
+}

package/src/whatsapp/whatsapp-manager.ts

@@ -0,0 +1,160 @@
+import type {
+  LaunchOptions,
+  BrowserConnectOptions,
+  BrowserLaunchArgumentOptions,
+} from 'puppeteer'
+
+import type {
+  WhatsAppClientType,
+  ClientOptions,
+} from '../schema/whatsapp-type.js'
+import {
+  Client as WhatsApp, LocalAuth,
+} from '../schema/whatsapp-interface.js'
+import WhatsAppBase from './whatsapp-base.js'
+import type Manager from '../manager.js'
+import { log, STRINGS, LANGUAGE } from '../config.js'
+import { fromEvent, map, merge, distinctUntilKeyChanged } from 'rxjs'
+import LoginEventHandler from './event-handler/login-event-handler.js'
+import MessageEventHandler from './event-handler/message-event-handler.js'
+import GroupEventHandler from './event-handler/group-event-handler.js'
+
+const PRE = 'WhatsAppManager'
+
+export default class WhatsAppManager extends WhatsAppBase {
+
+  private botEventHandler: LoginEventHandler
+  private messageEventHandler: MessageEventHandler
+  private groupEventHandler: GroupEventHandler
+
+  constructor (manager: Manager) {
+    super(manager)
+    this.botEventHandler = new LoginEventHandler(manager)
+    this.messageEventHandler = new MessageEventHandler(manager)
+    this.groupEventHandler = new GroupEventHandler(manager)
+
+    this.botEventHandler.on({
+      login: data => this.emit('login', data),
+      logout: (botId, data) => this.emit('logout', botId, data),
+      ready: () => this.emit('ready'),
+      scan: data => this.emit('scan', data),
+    })
+
+    this.messageEventHandler.on({
+      friendship: data => this.emit('friendship', data),
+      message: data => this.emit('message', data),
+      'room-invite': data => this.emit('room-invite', data),
+    })
+
+    this.groupEventHandler.on({
+      'room-join': data => this.emit('room-join', data),
+      'room-leave': data => this.emit('room-leave', data),
+      'room-topic': data => this.emit('room-topic', data),
+    })
+  }
+
+  public async stop () {
+    await this.getWhatsAppClient().stop()
+    this.baseStop()
+    this.botEventHandler.clearQrcodeOrLoginCheckTimer()
+  }
+
+  public async genWhatsAppClient (
+    options: ClientOptions = {},
+    session: string = 'default-client',
+  ): Promise<WhatsAppClientType> {
+    log.verbose(PRE, 'initWhatsAppClient()')
+    const { puppeteer = {}, ...restOptions } = options
+    const { args, ...restPuppeteerOptions } = puppeteer
+    const puppeteerOptions: LaunchOptions & BrowserLaunchArgumentOptions & BrowserConnectOptions = {
+      /**
+       * No usable sandbox!
+       *  https://github.com/pedroslopez/whatsapp-web.js/issues/344#issuecomment-691570764
+       */
+      args: [
+        '--no-sandbox',
+        '--disable-setuid-sandbox',
+        ...(puppeteer.args || []),
+      ],
+      headless: true,
+      ...restPuppeteerOptions,
+    }
+
+    this.whatsAppClient = new WhatsApp({
+      authStrategy: new LocalAuth({ clientId: session }),
+      puppeteer: puppeteerOptions,
+      // can no longer customize refresh interval
+      // refresh time gap is set to 15 seconds
+      restartOnAuthFail: true,
+      ...restOptions,
+    })
+    await this.setSession(session)
+    return this.whatsAppClient
+  }
+
+  public async initWhatsAppClient (): Promise<void> {
+    const whatsAppClient = this.getWhatsAppClient()
+    whatsAppClient
+      .initialize()
+      .then(() => log.verbose(PRE, 'start() whatsapp.initialize() done.'))
+      .catch(async e => {
+        log.error(PRE, 'start() whatsapp.initialize() rejection: %s', e)
+      })
+  }
+
+  public async initWhatsAppEvents (): Promise<void> {
+    log.verbose(PRE, 'initWhatsAppEvents()')
+    const whatsAppClient = this.getWhatsAppClient()
+    whatsAppClient.on('qr', this.botEventHandler.onQRCode.bind(this.botEventHandler))
+    whatsAppClient.on('authenticated', this.botEventHandler.onAuthenticated.bind(this.botEventHandler))
+    /**
+     * There is only one situation that will cause this event, invalid session causing timeout
+     * https://github.com/pedroslopez/whatsapp-web.js/blob/d86c39de3ca5699a50db98ee93e264ab8c4f25a3/src/Client.js#L116-L129
+     */
+    whatsAppClient.on('auth_failure', this.botEventHandler.onAuthFailure.bind(this.botEventHandler))
+    whatsAppClient.on('ready', this.botEventHandler.onWhatsAppReady.bind(this.botEventHandler))
+    whatsAppClient.on('change_state', this.botEventHandler.onChangeState.bind(this.botEventHandler))
+    whatsAppClient.on('change_battery', this.botEventHandler.onChangeBattery.bind(this.botEventHandler))
+
+    whatsAppClient.on('message', this.messageEventHandler.onMessage.bind(this.messageEventHandler))
+    whatsAppClient.on('message_ack', this.messageEventHandler.onMessageAck.bind(this.messageEventHandler))
+    whatsAppClient.on('message_create', this.messageEventHandler.onMessageCreate.bind(this.messageEventHandler))
+    whatsAppClient.on('message_revoke_everyone', this.messageEventHandler.onMessageRevokeEveryone.bind(this.messageEventHandler))
+    whatsAppClient.on('message_revoke_me', this.messageEventHandler.onMessageRevokeMe.bind(this.messageEventHandler))
+    whatsAppClient.on('media_uploaded', this.messageEventHandler.onMediaUploaded.bind(this.messageEventHandler))
+    whatsAppClient.on('incoming_call', this.messageEventHandler.onIncomingCall.bind(this.messageEventHandler))
+
+    whatsAppClient.on('group_join', this.groupEventHandler.onRoomJoin.bind(this.messageEventHandler))
+    whatsAppClient.on('group_leave', this.groupEventHandler.onRoomLeave.bind(this.messageEventHandler))
+    whatsAppClient.on('group_update', this.groupEventHandler.onRoomUpdate.bind(this.messageEventHandler))
+
+    const events = [
+      'authenticated',
+      'ready',
+      'disconnected',
+    ]
+    const eventStreams = events.map((event) => fromEvent(whatsAppClient, event).pipe(map((value: any) => ({ event, value }))))
+    const allEvents$ = merge(...eventStreams)
+    allEvents$.pipe(distinctUntilKeyChanged('event')).subscribe(({ event, value }: { event: string, value: any }) => {
+      log.info(PRE, `initWhatsAppEvents: ${JSON.stringify(event)}, value: ${JSON.stringify(value)}`)
+      if (event === 'disconnected') {
+        switch (value) {
+          case 'NAVIGATION':
+            void this.botEventHandler.onLogout(STRINGS[LANGUAGE].LOGOUT_REASON.DEFAULT)
+            break
+          case 'CONFLICT':
+            void this.botEventHandler.onLogout(STRINGS[LANGUAGE].LOGOUT_REASON.LOGIN_CONFLICT)
+            break
+          default:
+            void this.botEventHandler.onLogout(STRINGS[LANGUAGE].LOGOUT_REASON.DEFAULT)
+            break
+        }
+      }
+    })
+  }
+
+  public getMessageEventHandler () {
+    return this.messageEventHandler
+  }
+
+}