@juzi/wechaty-puppet-whatsapp 1.0.0

package/src/helper/pure-function/room-raw-payload-parser.spec.ts

@@ -0,0 +1,70 @@
+/* eslint-disable sort-keys */
+
+import { test } from 'tstest'
+import { parserRoomRawPayload } from './room-raw-payload-parser.js'
+
+test('parse room info', async t => {
+  const roomPayload = {
+    id: {
+      server: 'g.us',
+      user: '120363021332004743',
+      _serialized: '120363021332004743@g.us',
+    },
+    number: null,
+    isBusiness: false,
+    isEnterprise: false,
+    labels: [],
+    name: '哈哈哈 测试',
+    statusMute: false,
+    type: 'in',
+    isMe: false,
+    isUser: false,
+    isGroup: true,
+    isWAContact: false,
+    isMyContact: false,
+    isBlocked: false,
+    avatar: 'https://pps.whatsapp.net/v/t61.24694-24/259270979_6900708863337894_342691323244398878_n.jpg?ccb=11-4&oh=ceb59735080411ee0ff36834e5ce688b&oe=6222C441',
+  }
+
+  const roomChat = {
+    groupMetadata: {
+      id: {
+        server: 'g.us',
+        user: '120363021332004743',
+        _serialized: '120363021332004743@g.us',
+      },
+      creation: 1643116497,
+      owner: { server: 'c.us', user: '8613812345678', _serialized: '8613812345678@c.us' },
+      restrict: false,
+      announce: false,
+      noFrequentlyForwarded: false,
+      ephemeralDuration: 0,
+      support: false,
+      suspended: false,
+      uniqueShortNameMap: {},
+      notAddedByContact: false,
+      participants: [{ id: { server: 'c.us', user: '8613812345678', _serialized: '8613812345678@c.us' }, isAdmin: true, isSuperAdmin: true }, { id: { server: 'c.us', user: '8613812345679', _serialized: '8613812345679@c.us' }, isAdmin: false, isSuperAdmin: false }, { id: { server: 'c.us', user: '8613812345670', _serialized: '8613812345670@c.us' }, isAdmin: false, isSuperAdmin: false }, { id: { server: 'c.us', user: '8613812345671', _serialized: '8613812345671@c.us' }, isAdmin: false, isSuperAdmin: false }],
+      pendingParticipants: [],
+    },
+    participants: [{ id: { server: 'c.us', user: '8613812345678', _serialized: '8613812345678@c.us' }, isAdmin: true, isSuperAdmin: true }, { id: { server: 'c.us', user: '8613812345679', _serialized: '8613812345679@c.us' }, isAdmin: false, isSuperAdmin: false }, { id: { server: 'c.us', user: '8613812345670', _serialized: '8613812345670@c.us' }, isAdmin: false, isSuperAdmin: false }, { id: { server: 'c.us', user: '8613812345671', _serialized: '8613812345671@c.us' }, isAdmin: false, isSuperAdmin: false }],
+    id: { server: 'g.us', user: '120363021332004743', _serialized: '120363021332004743@g.us' },
+    name: '哈哈哈 测试',
+    isGroup: true,
+    isReadOnly: false,
+    unreadCount: 0,
+    timestamp: 1645128573,
+    archived: false,
+    pinned: false,
+    isMuted: false,
+    muteExpiration: 0,
+  }
+
+  const result = parserRoomRawPayload(roomPayload as any, roomChat as any)
+  console.info(result)
+  t.ok(result.topic === '哈哈哈 测试', 'should get correct room topic')
+  t.ok(result.adminIdList[0] === '8613812345678@c.us', 'should get correct admin')
+  t.ok(result.memberIdList.length === 4, 'should get correct member count')
+  t.ok(result.avatar === 'https://pps.whatsapp.net/v/t61.24694-24/259270979_6900708863337894_342691323244398878_n.jpg?ccb=11-4&oh=ceb59735080411ee0ff36834e5ce688b&oe=6222C441', 'should get correct avatar')
+
+  t.pass('parse room info pass')
+})

package/src/helper/pure-function/room-raw-payload-parser.ts

@@ -0,0 +1,19 @@
+import type * as PUPPET from '@juzi/wechaty-puppet'
+import { WA_ERROR_TYPE } from '../../exception/error-type.js'
+import WAError from '../../exception/whatsapp-error.js'
+import type { WhatsAppContactPayload as RoomPayload, GroupChat } from '../../schema/whatsapp-type.js'
+
+export function parserRoomRawPayload (roomPayload: RoomPayload, roomChat: GroupChat): PUPPET.payloads.Room {
+  const roomId = roomPayload.id._serialized
+  if (roomChat.participants.length === 0) {
+    throw WAError(WA_ERROR_TYPE.ERR_ROOM_NOT_FOUND, `roomRawPayloadParser(${roomId}) can not get chat info for this room.`)
+  }
+  return {
+    adminIdList: roomChat.participants.filter(m => m.isAdmin || m.isSuperAdmin).map(m => m.id._serialized),
+    avatar: roomPayload.avatar,
+    id: roomId,
+    memberIdList: roomChat.participants.map(m => m.id._serialized),
+    ownerId: roomChat.owner?._serialized,
+    topic: roomPayload.name || roomPayload.pushname || '',
+  }
+}

package/src/helper/pure-function/vcard-parser.ts

@@ -0,0 +1,128 @@
+import { log } from '../../config.js'
+import { WA_ERROR_TYPE } from '../../exception/error-type.js'
+import WAError from '../../exception/whatsapp-error.js'
+
+const PRE = 'VCARD_PARSER'
+export interface IVcard {
+  /**
+   * VERSION: X.X
+   */
+  version: string;
+  /**
+   * N, name
+   */
+  N?: string[];
+  /**
+   * FN, Full name
+   */
+  FN?: string;
+  /**
+   * item1.TEL field
+   */
+  TEL?: {
+    waid: string;
+    phone: string;
+  }[];
+  [k: string]: any;
+}
+
+const VersionPattern =  /VERSION:(\d+\.\d*)$/m
+const CheckItermTelPattern = /^(item\d\.TEL|TEL;)/i
+const TelPatternForContainOnePhoneNumber = /waid=(\d*):([+ \d]*)$/m
+const TelPatternForContainMultiPhoneNumbers = /[+ \d]*$/m
+
+/*
+# Case 1: One phone number in card body from ANDROID
+BEGIN:VCARD
+VERSION:3.0
+N:;[name];;;
+FN:[name]
+item1.TEL;waid=[waid]:[phone]
+item1.X-ABLabel:‎WhatsApp | 手机 | 公费电话
+END:VCARD
+
+# Case 2: One phone number in card body from IOS
+BEGIN:VCARD
+VERSION:3.0
+N:🐉;socialbear;;;
+FN:socialbear 🐉
+TEL;type=CELL;type=VOICE;waid=8613240330438:+86 132 4033 0438
+END:VCARD
+
+# Case 3: Multi phone numbers in card body
+BEGIN:VCARD
+VERSION:3.0
+N:;[name];;;
+FN:[name]
+item1.TEL;[phone]
+item1.X-ABLabel:‎WhatsApp | 手机 | 公费电话
+END:VCARD
+
+For more detail, see: https://github.com/wechaty/puppet-whatsapp/issues/136#issuecomment-1032388884
+*/
+
+/**
+ * parse vcard body
+ * @param body vcard body string
+ */
+export function parseVcard (body: string): IVcard {
+  const lines = body.split('\n')
+  // vcard body must be at least 3 lines, 'BEGIN', 'VERSION' and 'END'
+  if (lines.length < 2) {
+    throw WAError(WA_ERROR_TYPE.ERR_MSG_CONTACT, `Invalid Vcard body: invalid length, detail: ${body}`)
+  }
+  if (lines[0] !== 'BEGIN:VCARD') {
+    throw WAError(WA_ERROR_TYPE.ERR_MSG_CONTACT, `Invalid Vcard body: begin not found, detail: ${body}`)
+  }
+
+  const versionMatch = VersionPattern.exec(lines[1]!)
+  if (!versionMatch) {
+    throw WAError(WA_ERROR_TYPE.ERR_MSG_CONTACT, `Invalid Vcard body: version field not found, detail: ${body}`)
+  }
+  const result: IVcard = {
+    TEL: [],
+    version: versionMatch[1]!,
+  }
+
+  // skip BEGIN and VERSION filed
+  for (let i = 2; i < lines.length; i++) {
+    const content = lines[i]!
+    if (content.startsWith('N:')) {
+      result.N = content.replace('N:', '').split(';').filter(v => !!v)
+    } else if (content.startsWith('FN:')) {
+      result.FN = content.replace('FN:', '')
+    } else if (CheckItermTelPattern.test(content)) {
+      if (content.includes('waid')) {
+        const match = TelPatternForContainOnePhoneNumber.exec(content)
+        if (match) {
+          result.TEL!.push({
+            phone: match[2]!,
+            waid: `${match[1]}@c.us`,
+          })
+        }
+      } else {
+        const match = TelPatternForContainMultiPhoneNumbers.exec(content)
+        log.verbose(PRE, `match: ${JSON.stringify(match)}`)
+        if (match) {
+          result.TEL!.push({
+            phone: match[0]!,
+            waid: `${extractContactIdFromPhoneNumber(match[0]!)}@c.us`,
+          })
+        }
+      }
+    } else if (content === 'END:VCARD') {
+      break
+    }
+  }
+
+  if (result.TEL!.length !== 1) {
+    log.error(PRE, `This card contains more than 1 phone number, detail: ${JSON.stringify(result.TEL)}`)
+    throw WAError(WA_ERROR_TYPE.ERR_MSG_CONTACT, `This card contains more than 1 phone number, detail: ${JSON.stringify(result.TEL)}`)
+  }
+
+  return result
+}
+
+function extractContactIdFromPhoneNumber (phone: string) {
+  return phone.replace(/\+|\s/g, '')
+}

package/src/helper/schedule/schedule-manager.spec.ts

@@ -0,0 +1,46 @@
+import ScheduleManager from './schedule-manager.js'
+import { test } from 'tstest'
+import { Job } from 'node-schedule'
+
+test('scheduleManager task add and remove test', async t => {
+  try {
+    const scheduleManager = ScheduleManager.Instance
+    t.ok(scheduleManager instanceof ScheduleManager)
+
+    const task = scheduleManager.addScheduledTask('42 * * * *', () => {
+      console.info('The answer to life, the universe, and everything!')
+    })
+    t.ok(task instanceof Job)
+
+    scheduleManager.removeScheduledTask(task)
+    // eslint-disable-next-line @typescript-eslint/no-unnecessary-condition
+    t.ok(task.nextInvocation() === null)
+    scheduleManager.clearAllTasks()
+
+    t.pass('scheduleManager add and remove test pass.')
+
+  } catch (e) {
+    t.fail(e as any)
+  }
+})
+
+test('scheduleManager task add and clear test', async t => {
+  try {
+    const scheduleManager = ScheduleManager.Instance
+    t.ok(scheduleManager instanceof ScheduleManager)
+
+    const task = scheduleManager.addScheduledTask('42 * * * *', () => {
+      console.info('The answer to life, the universe, and everything!')
+    })
+    t.ok(task instanceof Job)
+
+    scheduleManager.clearAllTasks()
+    // @ts-ignore
+    const taskCount = scheduleManager.jobPool.length
+    t.ok(taskCount === 0)
+    t.pass('scheduleManager add and clear test pass.')
+
+  } catch (e) {
+    t.fail(e as any)
+  }
+})

package/src/helper/schedule/schedule-manager.ts

@@ -0,0 +1,52 @@
+import schedule, { Job, JobCallback, RecurrenceRule, RecurrenceSpecDateRange, RecurrenceSpecObjLit } from 'node-schedule'
+import { log } from '../../config.js'
+
+const PRE = 'ScheduleManager'
+
+type ScheduleRule = RecurrenceRule | RecurrenceSpecDateRange | RecurrenceSpecObjLit | Date | string | number
+
+export default class ScheduleManager {
+
+  private static _instance?: ScheduleManager
+  private jobPool :Job[] = []
+
+  private constructor () {}
+
+  public static get Instance () {
+    if (!this._instance) {
+      this._instance = new ScheduleManager()
+    }
+    return this._instance
+  }
+
+  /**
+   * Create a schedule job.
+   *
+   * @param rule     scheduling info, ref: https://github.com/node-schedule/node-schedule#cron-style-scheduling
+   * @param callback callback to be executed on each invocation
+   */
+  public addScheduledTask (rule: ScheduleRule, callback: JobCallback): Job {
+    log.silly(PRE, 'addScheduledTask()')
+    const job = schedule.scheduleJob(rule, callback)
+    this.jobPool.push(job)
+    return job
+  }
+
+  public removeScheduledTask (job: Job): boolean {
+    log.silly(PRE, 'removeScheduledTask()')
+    const jobIndex = this.jobPool.indexOf(job)
+    if (jobIndex === -1) {
+      log.warn(PRE, 'trying to cannel a job not in jobPool')
+    } else {
+      this.jobPool.splice(jobIndex, 1)
+    }
+    return job.cancel()
+  }
+
+  public clearAllTasks () {
+    log.silly(PRE, 'clearAllTasks()')
+    this.jobPool.map(job => job.cancel())
+    this.jobPool = []
+  }
+
+}

package/src/manager-event.ts

@@ -0,0 +1,18 @@
+import type * as PUPPET from '@juzi/wechaty-puppet'
+
+export type ManagerEvents = {
+  'message': (payload: PUPPET.payloads.EventMessage) => any,
+  'room-join': (payload: PUPPET.payloads.EventRoomJoin) => any,
+  'room-leave': (payload: PUPPET.payloads.EventRoomLeave) => any,
+  'room-topic': (payload: PUPPET.payloads.EventRoomTopic) => any,
+  'room-invite': (payload: PUPPET.payloads.EventRoomInvite) => any,
+  'scan': (payload: PUPPET.payloads.EventScan) => any,
+  'login': (userId: string) => any,
+  'logout': (userId: string, message: string) =>  any,
+  'friendship': (payload: PUPPET.payloads.EventFriendship) => any,
+  'reset': (reason: string) => any,
+  'error': (error: string) => any,
+  'heartbeat': (data: string) => any,
+  'ready': () => any,
+  'dirty': (payload: PUPPET.payloads.EventDirty) => any
+};

package/src/manager.spec.ts

@@ -0,0 +1,40 @@
+#!/usr/bin/env node --no-warnings --loader ts-node/esm
+
+import { test } from 'tstest'
+import Manager from './manager.js'
+
+function genTimestamp () {
+  return Math.floor(Date.now() / 1000) - 2 * 24 * 3600 - Math.floor(Math.random() * 10000)
+}
+
+const fakeMsgListWithin3Days = Array(10).fill({ timestamp: genTimestamp() }) as any
+
+const fakeMsgListOver3Days = [
+  Array(10).fill({ timestamp: 1644823352 }),
+  ...fakeMsgListWithin3Days,
+] as any
+
+const contactId = 'fake_contact_id'
+
+class ManagerTest extends Manager {
+}
+
+test('filterFetchedMessages within 3 days', async t => {
+  const manager = new ManagerTest({})
+  await manager.initCache(contactId)
+  // @ts-ignore
+  const list = await manager.filterFetchedMessages(contactId, fakeMsgListWithin3Days)
+  t.ok(list.length === fakeMsgListWithin3Days.length)
+  await manager.releaseCache()
+  t.pass('filterFetchedMessages within 3 days pass')
+})
+
+test('filterFetchedMessages within 5 days', async t => {
+  const manager = new ManagerTest({})
+  await manager.initCache(contactId)
+  // @ts-ignore
+  const list = await manager.filterFetchedMessages(contactId, fakeMsgListOver3Days)
+  t.ok(list.length === fakeMsgListWithin3Days.length)
+  await manager.releaseCache()
+  t.pass('filterFetchedMessages within 5 days pass')
+})

package/src/manager.ts

@@ -0,0 +1,297 @@
+import { EventEmitter as EE } from 'ee-ts'
+import type { MemoryCard } from '@juzi/wechaty-puppet/dist/esm/src/config'
+import { log, MAX_HEARTBEAT_MISSED, MEMORY_SLOT } from './config.js'
+import { CacheManager } from './data/cache-manager.js'
+import { WA_ERROR_TYPE } from './exception/error-type.js'
+import WAError from './exception/whatsapp-error.js'
+import { batchProcess, getMaxTimestampForLoadHistoryMessages, isRoomId, sleep } from './helper/miscellaneous.js'
+import ScheduleManager from './helper/schedule/schedule-manager.js'
+import type { ManagerEvents } from './manager-event.js'
+import type { PuppetWhatsAppOptions } from './puppet-whatsapp.js'
+import { RequestManager, requestManagerKeys } from './request/request-manager.js'
+import { MessageAck } from './schema/whatsapp-interface.js'
+import type { GroupChat, WhatsAppContact, WhatsAppMessage } from './schema/whatsapp-type.js'
+import WhatsAppManager from './whatsapp/whatsapp-manager.js'
+
+const PRE = 'Manager'
+
+export default class Manager extends EE<ManagerEvents> {
+
+  public whatsAppManager: WhatsAppManager
+  private cacheManager?: CacheManager
+  private _requestManager?: RequestManager
+  private scheduleManager: ScheduleManager
+  private memory?: MemoryCard
+
+  private fetchingMessages: boolean = false
+  private heartbeatTimer?: NodeJS.Timer
+
+  constructor (private options: PuppetWhatsAppOptions) {
+    super()
+    this.whatsAppManager = new WhatsAppManager(this)
+    this.scheduleManager = ScheduleManager.Instance
+
+    this.whatsAppManager.on({
+      friendship: data => this.emit('friendship', data),
+      login: data => this.emit('login', data),
+      logout: (botId, data) => this.emit('logout', botId, data),
+      message: data => this.emit('message', data),
+      ready: () => this.emit('ready'),
+      'room-invite': data => this.emit('room-invite', data),
+      'room-join': data => this.emit('room-join', data),
+      'room-leave': data => this.emit('room-leave', data),
+      'room-topic': data => this.emit('room-topic', data),
+      scan: data => this.emit('scan', data),
+    })
+
+    return new Proxy(this, {
+      get: (target: Manager, prop: keyof Manager & keyof RequestManager) => {
+        return requestManagerKeys.indexOf(prop) > -1 ? (target.requestManager[prop] as Function).bind(target.requestManager) : target[prop]
+      },
+    })
+  }
+
+  getMemory (): MemoryCard {
+    if (this.memory) {
+      return this.memory
+    } else {
+      throw WAError(WA_ERROR_TYPE.ERR_INIT, 'No Memory')
+    }
+  }
+
+  /**
+   * Lifecycle
+   */
+
+  public async start (memory?: MemoryCard) {
+    if (memory) {
+      this.memory = memory
+    }
+    const session = await this.getMemory().get(MEMORY_SLOT)
+    log.verbose(PRE, 'start()')
+    const whatsAppClient = await this.whatsAppManager.genWhatsAppClient(this.options['puppeteerOptions'], session)
+    try {
+      await this.whatsAppManager.initWhatsAppEvents()
+      await this.whatsAppManager.initWhatsAppClient()
+    } catch (error) {
+      log.error(PRE, `start() error message: ${(error as Error).stack}`)
+      await sleep(2 * 1000)
+      await this.start(session)
+    }
+
+    this._requestManager = new RequestManager(whatsAppClient)
+    this.startHeartbeat()
+    return whatsAppClient
+  }
+
+  public async stop () {
+    log.verbose(PRE, 'stop()')
+    await this.whatsAppManager.stop()
+    await this.releaseCache()
+    this._requestManager = undefined
+
+    this.stopHeartbeat()
+  }
+
+  public get requestManager () {
+    if (!this._requestManager) {
+      throw WAError(WA_ERROR_TYPE.ERR_INIT, 'No request manager')
+    }
+    return this._requestManager
+  }
+
+  public getWhatsAppClient () {
+    return this.whatsAppManager.getWhatsAppClient()
+  }
+
+  /**
+   * LOGIC METHODS
+   */
+
+  /**
+   * Fetch history messages of contact or room, and then call onMessage method to emit them or not.
+   * @param {WhatsAppContact} contactOrRoom contact or room instance
+   */
+  public async processHistoryMessages (contactOrRoom: WhatsAppContact) {
+    if (this.fetchingMessages) {
+      return
+    }
+    this.fetchingMessages = true
+    const fetchedMessageList = await this.fetchMessages(contactOrRoom)
+    const filteredMessageList = await this.filterFetchedMessages(contactOrRoom.id._serialized, fetchedMessageList)
+    await this.processFetchedMessages(filteredMessageList)
+    this.fetchingMessages = false
+  }
+
+  private async fetchMessages (contactOrRoom: WhatsAppContact) {
+    if (contactOrRoom.isMe) {
+      // can not get chat for bot self
+      return []
+    }
+    const chat = await contactOrRoom.getChat()
+    const messageList = await chat.fetchMessages({})
+    return messageList
+  }
+
+  private async filterFetchedMessages (contactOrRoomId: string, messageList: WhatsAppMessage[]) {
+    const cacheManager = await this.getCacheManager()
+    const maxTimestampForLoadHistoryMessages = getMaxTimestampForLoadHistoryMessages()
+    const latestTimestampInCache = await cacheManager.getLatestMessageTimestampForChat(contactOrRoomId)
+    const minTimestamp = Math.min(latestTimestampInCache, maxTimestampForLoadHistoryMessages)
+    try {
+      const _messageList = messageList.filter(m => m.timestamp >= minTimestamp)
+      const latestMessageTimestamp = _messageList[_messageList.length - 1]?.timestamp
+      if (latestMessageTimestamp) {
+        await cacheManager.setLatestMessageTimestampForChat(contactOrRoomId, latestMessageTimestamp)
+      }
+      return _messageList
+    } catch (error) {
+      log.error(PRE, `filterFetchedMessages error: ${(error as Error).message}`)
+      return []
+    }
+  }
+
+  private async processFetchedMessages (messageList: WhatsAppMessage[]) {
+    const batchSize = 50
+    await batchProcess(batchSize, messageList, async (message: WhatsAppMessage) => {
+      if (message.ack === MessageAck.ACK_DEVICE || message.ack === MessageAck.ACK_READ) {
+        await this.processMessage(message)
+      }
+    })
+  }
+
+  public async getRoomChatById (roomId: string) {
+    if (isRoomId(roomId)) {
+      const roomChat = await this.requestManager.getChatById(roomId)
+      return roomChat as GroupChat
+    } else {
+      throw WAError(WA_ERROR_TYPE.ERR_GROUP_OR_CONTACT_ID, `The roomId: ${roomId} is not right.`)
+    }
+  }
+
+  /**
+   * Get member id list from web api
+   * @param { PuppetWhatsApp } this whatsapp client
+   * @param { string } roomId roomId
+   * @returns { string[] } member id list
+   */
+  public async syncRoomMemberList (roomId: string): Promise<string[]> {
+    const roomChat = await this.getRoomChatById(roomId)
+    // FIXME: How to deal with pendingParticipants? Maybe we should find which case could has this attribute.
+    const memberIdList = roomChat.participants.map(m => m.id._serialized)
+    const cacheManager = await this.getCacheManager()
+    await cacheManager.setRoomMemberIdList(roomId, memberIdList)
+    return memberIdList
+  }
+
+  public async syncContactOrRoomList () {
+    const whatsapp = this.getWhatsAppClient()
+    const contactList: WhatsAppContact[] = await whatsapp.getContacts()
+    const contactOrRoomList = contactList.filter(c => c.id.server !== 'broadcast' && c.id._serialized !== '0@c.us')
+    return contactOrRoomList
+  }
+
+  public async processMessage (message: WhatsAppMessage) {
+    log.silly(PRE, `processMessage(${message})`)
+    await this.whatsAppManager.getMessageEventHandler().onMessage(message)
+  }
+
+  /**
+   * Cache Section
+   */
+
+  public async initCache (userId: string) {
+    log.verbose(PRE, `initCache(${userId})`)
+    if (this.cacheManager) {
+      log.warn(PRE, 'initCache() already initialized, skip the init...')
+      return
+    }
+    await CacheManager.init(userId)
+    this.cacheManager = CacheManager.Instance
+  }
+
+  public async releaseCache () {
+    log.verbose(PRE, 'releaseCache()')
+    if (this.cacheManager) {
+      log.warn(PRE, 'releaseCache() already initialized, skip the init...')
+      return
+    }
+    await CacheManager.release()
+  }
+
+  public async getCacheManager () {
+    if (!this.cacheManager) {
+      throw WAError(WA_ERROR_TYPE.ERR_INIT, 'no cache manager')
+    }
+    return this.cacheManager
+  }
+
+  /**
+   * Schedule
+   */
+
+  public startSchedule () {
+    this.scheduleManager.addScheduledTask('0 */2 * * * *', async () => {
+      log.silly(PRE, 'startSyncMissedMessages')
+      const contactOrRoomList = await this.syncContactOrRoomList()
+      const batchSize = 100
+      await batchProcess(batchSize, contactOrRoomList, async (contactOrRoom: WhatsAppContact) => {
+        await this.processHistoryMessages(contactOrRoom)
+      })
+      log.silly(PRE, 'startSyncMissedMessages finished')
+    })
+  }
+
+  public stopSchedule () {
+    this.scheduleManager.clearAllTasks()
+  }
+
+  /**
+   * Heatbeat
+   */
+
+  private startHeartbeat () {
+    if (!this.heartbeatTimer) {
+      this.asystoleCount = 0
+      this.heartbeatTimer = setInterval(this.heartbeat.bind(this), 15 * 1000)
+    }
+  }
+
+  private stopHeartbeat () {
+    if (this.heartbeatTimer) {
+      clearInterval(this.heartbeatTimer)
+      this.heartbeatTimer = undefined
+    }
+  }
+
+  private asystoleCount = 0
+  private async heartbeat () {
+
+    /**
+     * puppteer.isConnected behaviour: (in MacOs)
+     * it will still return true if the Chromium window is closed with command + w
+     * it will not return true if the Chromium process is terminated with command + q
+     */
+
+    let alive = false
+    try {
+      alive = !!this.getWhatsAppClient().pupBrowser?.isConnected()
+    } catch (e) {
+      alive = false
+    }
+    if (alive) {
+      this.asystoleCount = 0
+      this.emit('heartbeat', 'puppeteer still connected')
+    } else {
+      this.asystoleCount += 1
+      log.warn(PRE, `asystole count: ${this.asystoleCount}`)
+      if (this.asystoleCount > MAX_HEARTBEAT_MISSED) {
+        log.error(PRE, 'max asystole reached, restarting...')
+        await this.stop()
+        await this.start()
+        this.asystoleCount = 0
+      }
+    }
+  }
+
+}

package/src/mod.ts

@@ -0,0 +1,8 @@
+import { VERSION }        from './config.js'
+import { PuppetWhatsapp } from './puppet-whatsapp.js'
+
+export {
+  VERSION,
+  PuppetWhatsapp,
+}
+export default PuppetWhatsapp

package/src/package-json.spec.ts

@@ -0,0 +1,10 @@
+#!/usr/bin/env node --no-warnings --loader ts-node/esm
+
+import { test } from 'tstest'
+
+import { packageJson } from './package-json.js'
+
+test('Make sure the packageJson is fresh in source code', async t => {
+  const keyNum = Object.keys(packageJson).length
+  t.equal(keyNum, 0, 'packageJson should be empty in source code, only updated before publish to NPM')
+})