diff --git a/.eslintrc.cjs b/.eslintrc.cjs
index 7308c5b..c9435d5 100644
--- a/.eslintrc.cjs
+++ b/.eslintrc.cjs
@@ -2,7 +2,12 @@
 const rules = {
   semi: ["error", "always"],
   quotes: ["error", "double"],
-  'space-before-function-paren': ["error", "never"],
+  "space-before-function-paren": ["error", {
+    "anonymous": "never",
+    "named": "never",
+    "asyncArrow": "always"
+  }],
+  'array-bracket-spacing': ["error", "never"]
 }
 
 module.exports = {
diff --git a/package.json b/package.json
index 70cb63e..6efd546 100644
--- a/package.json
+++ b/package.json
@@ -1,6 +1,6 @@
 {
   "name": "wechaty-puppet-padlocal",
-  "version": "1.20.1",
+  "version": "1.20.2",
   "description": "Puppet PadLocal for Wechaty",
   "type": "module",
   "exports": {
diff --git a/src/cleanup.ts b/src/cleanup.ts
index e212fc2..48222a5 100644
--- a/src/cleanup.ts
+++ b/src/cleanup.ts
@@ -13,7 +13,7 @@ nodeCleanup((exitCode, signal) => {
   const puppets = RunningPuppets.slice();
 
   Promise.all(
-    puppets.map(async(puppet) => {
+    puppets.map(async (puppet) => {
       await puppet.stop();
     }),
   ).finally(() => {
diff --git a/src/padlocal/events/event-friendship.ts b/src/padlocal/events/event-friendship.ts
index 56bfb11..fa727f0 100644
--- a/src/padlocal/events/event-friendship.ts
+++ b/src/padlocal/events/event-friendship.ts
@@ -47,7 +47,7 @@ const isNeedVerify = (message: PadLocal.Message.AsObject): boolean => {
   });
 };
 
-const isReceive = async(message: PadLocal.Message.AsObject): Promise<ReceiveXmlSchema | null> => {
+const isReceive = async (message: PadLocal.Message.AsObject): Promise<ReceiveXmlSchema | null> => {
   if (message.type !== WechatMessageType.VerifyMsg && message.type !== WechatMessageType.VerifyMsgEnterprise) {
     return null;
   }
@@ -67,7 +67,7 @@ const isReceive = async(message: PadLocal.Message.AsObject): Promise<ReceiveXmlS
   return null;
 };
 
-export default async(_puppet: PUPPET.Puppet, message: PadLocal.Message.AsObject): Promise<EventPayload> => {
+export default async (_puppet: PUPPET.Puppet, message: PadLocal.Message.AsObject): Promise<EventPayload> => {
   if (isConfirm(message)) {
     return {
       contactId: message.fromusername,
diff --git a/src/padlocal/events/event-message.ts b/src/padlocal/events/event-message.ts
index d7782f5..55fa072 100644
--- a/src/padlocal/events/event-message.ts
+++ b/src/padlocal/events/event-message.ts
@@ -2,6 +2,6 @@ import type * as PUPPET from "wechaty-puppet";
 import type PadLocal from "padlocal-client-ts/dist/proto/padlocal_pb.js";
 import type { EventPayload } from "./event.js";
 
-export default async(_puppet: PUPPET.Puppet, message: PadLocal.Message.AsObject): Promise<EventPayload> => {
+export default async (_puppet: PUPPET.Puppet, message: PadLocal.Message.AsObject): Promise<EventPayload> => {
   return message;
 };
diff --git a/src/padlocal/events/event-room-invite.ts b/src/padlocal/events/event-room-invite.ts
index c6552ba..05b2c3b 100644
--- a/src/padlocal/events/event-room-invite.ts
+++ b/src/padlocal/events/event-room-invite.ts
@@ -8,7 +8,7 @@ const ROOM_OTHER_INVITE_TITLE_EN = [/Group Chat Invitation/];
 const ROOM_OTHER_INVITE_LIST_ZH = [/^"(.+)"邀请你加入群聊(.*)，进入可查看详情。/];
 const ROOM_OTHER_INVITE_LIST_EN = [/"(.+)" invited you to join the group chat "(.+)"\. Enter to view details\./];
 
-export default async(_puppet: PUPPET.Puppet, message: PadLocal.Message.AsObject): Promise<EventPayload> => {
+export default async (_puppet: PUPPET.Puppet, message: PadLocal.Message.AsObject): Promise<EventPayload> => {
   let appMsgPayload: AppMessagePayload;
   try {
     appMsgPayload = await parseAppmsgMessagePayload(message.content);
diff --git a/src/padlocal/events/event-room-join.ts b/src/padlocal/events/event-room-join.ts
index 2ff0b4b..71f13d3 100644
--- a/src/padlocal/events/event-room-join.ts
+++ b/src/padlocal/events/event-room-join.ts
@@ -35,7 +35,7 @@ const OTHER_JOIN_VIA_OTHER_QRCODE_REGEX_LIST = [
   /^"(.+)" joined the group chat via the QR Code shared by "(.+)"/,
 ];
 
-export default async(puppet: PUPPET.Puppet, message: PadLocal.Message.AsObject): Promise<EventPayload> => {
+export default async (puppet: PUPPET.Puppet, message: PadLocal.Message.AsObject): Promise<EventPayload> => {
   const roomId = message.fromusername;
   if (!isRoomId(roomId)) {
     return null;
@@ -57,7 +57,7 @@ export default async(puppet: PUPPET.Puppet, message: PadLocal.Message.AsObject):
   const youInviteOther = createSysmsgTemplateRunner<PUPPET.payloads.EventRoomJoin>(
     sysmsgTemplatePayload,
     [...YOU_INVITE_OTHER_REGEX_LIST, ...OTHER_JOIN_VIA_YOUR_QRCODE_REGEX_LIST],
-    async(templateLinkList) => {
+    async (templateLinkList) => {
       // the first item MUST be others profile link
       const inviteeList = templateLinkList[0]!.payload as SysmsgTemplateLinkProfile;
       // filter other empty userName, in case the user is not your friend
@@ -77,7 +77,7 @@ export default async(puppet: PUPPET.Puppet, message: PadLocal.Message.AsObject):
   const otherInviteYou = createSysmsgTemplateRunner<PUPPET.payloads.EventRoomJoin>(
     sysmsgTemplatePayload,
     OTHER_INVITE_YOU_REGEX_LIST,
-    async(templateLinkList) => {
+    async (templateLinkList) => {
       // the first must invitor
       const inviter = templateLinkList[0]!.payload as SysmsgTemplateLinkProfile;
 
@@ -97,7 +97,7 @@ export default async(puppet: PUPPET.Puppet, message: PadLocal.Message.AsObject):
   const otherInviteOther = createSysmsgTemplateRunner<PUPPET.payloads.EventRoomJoin>(
     sysmsgTemplatePayload,
     [...OTHER_INVITE_YOU_AND_OTHER_REGEX_LIST, ...OTHER_INVITE_OTHER_REGEX_LIST],
-    async(templateLinkList, matchedRegexIndex) => {
+    async (templateLinkList, matchedRegexIndex) => {
       // the first item is invitor
       const inviter = templateLinkList[0]!.payload as SysmsgTemplateLinkProfile;
 
@@ -126,7 +126,7 @@ export default async(puppet: PUPPET.Puppet, message: PadLocal.Message.AsObject):
   const otherJoinViaQrCode = createSysmsgTemplateRunner<PUPPET.payloads.EventRoomJoin>(
     sysmsgTemplatePayload,
     OTHER_JOIN_VIA_OTHER_QRCODE_REGEX_LIST,
-    async(templateLinkList) => {
+    async (templateLinkList) => {
       // the first item is invitee
       const inviteeList = templateLinkList[0]!.payload as SysmsgTemplateLinkProfile;
       // filter other empty userName, in case the user is not your friend
diff --git a/src/padlocal/events/event-room-leave.ts b/src/padlocal/events/event-room-leave.ts
index 78fd6a4..087a1a1 100644
--- a/src/padlocal/events/event-room-leave.ts
+++ b/src/padlocal/events/event-room-leave.ts
@@ -49,7 +49,7 @@ export function isRoomLeaveDebouncing(roomId: string, removeeId: string): boolea
   return roomLeaveDebounceMap.get(key) !== undefined;
 }
 
-export default async(puppet: PUPPET.Puppet, message: PadLocal.Message.AsObject): Promise<EventPayload> => {
+export default async (puppet: PUPPET.Puppet, message: PadLocal.Message.AsObject): Promise<EventPayload> => {
   const roomId = message.fromusername;
   if (!isRoomId(roomId)) {
     return null;
@@ -60,7 +60,7 @@ export default async(puppet: PUPPET.Puppet, message: PadLocal.Message.AsObject):
    * /^(你)将"(.+)"移出了群聊/,
    *  我移除别人是 10002: https://gist.github.com/padlocal/5676b96ad0ca918fdd53849417eff422
    */
-  const youRemoveOther = async() => {
+  const youRemoveOther = async () => {
     const sysmsgTemplatePayload = await parseSysmsgSysmsgTemplateMessagePayload(message);
     if (!sysmsgTemplatePayload) {
       return null;
@@ -69,7 +69,7 @@ export default async(puppet: PUPPET.Puppet, message: PadLocal.Message.AsObject):
     return await parseSysmsgTemplate<PUPPET.payloads.EventRoomLeave>(
       sysmsgTemplatePayload,
       YOU_REMOVE_OTHER_REGEX_LIST,
-      async(templateLinkList) => {
+      async (templateLinkList) => {
         // the first item MUST be removed profile link
         const removeeList = templateLinkList[0]!.payload as SysmsgTemplateLinkProfile;
         // filter other empty userName, in case the user is not your friend
@@ -88,7 +88,7 @@ export default async(puppet: PUPPET.Puppet, message: PadLocal.Message.AsObject):
    * /^(你)被"([^"]+?)"移出群聊/,
    * // 我被别人移除是 10000：https://gist.github.com/padlocal/60be89334d4d743937f07023da20291e
    */
-  const otherRemoveYou = async() => {
+  const otherRemoveYou = async () => {
     if (message.type !== WechatMessageType.Sys) {
       return null;
     }
diff --git a/src/padlocal/events/event-room-topic.ts b/src/padlocal/events/event-room-topic.ts
index ad0126b..9a0a1d6 100644
--- a/src/padlocal/events/event-room-topic.ts
+++ b/src/padlocal/events/event-room-topic.ts
@@ -17,9 +17,9 @@ const YOU_CHANGE_TOPIC_REGEX_LIST = [
   /^(You) changed the group name to "(.+)"$/,
 ];
 
-type TopicChange = {changerId: string, newTopic: string};
+type TopicChange = { changerId: string, newTopic: string };
 
-export default async(puppet: PUPPET.Puppet, message: PadLocal.Message.AsObject): Promise<EventPayload> => {
+export default async (puppet: PUPPET.Puppet, message: PadLocal.Message.AsObject): Promise<EventPayload> => {
   const roomId = message.fromusername;
   if (!isRoomId(roomId)) {
     return null;
@@ -28,12 +28,12 @@ export default async(puppet: PUPPET.Puppet, message: PadLocal.Message.AsObject):
   /**
    * 1. Message payload "you change the room topic" is plain text with type 10000 : https://gist.github.com/padlocal/0c7bb4f5d51e7e94a0efa108bebb4645
    */
-  const youChangeTopic = async() => {
+  const youChangeTopic = async () => {
     if (message.type !== WechatMessageType.Sys) {
       return null;
     }
 
-    return parseTextWithRegexList(message.content, YOU_CHANGE_TOPIC_REGEX_LIST, async(_, match) => {
+    return parseTextWithRegexList(message.content, YOU_CHANGE_TOPIC_REGEX_LIST, async (_, match) => {
       const newTopic = match[2];
 
       return {
@@ -46,7 +46,7 @@ export default async(puppet: PUPPET.Puppet, message: PadLocal.Message.AsObject):
   /**
    * 2. Message payload "others change room topic" is xml text with type 10002: https://gist.github.com/padlocal/3480ada677839c8c11578d47e820e893
    */
-  const otherChangeTopic = async() => {
+  const otherChangeTopic = async () => {
     const sysmsgTemplatePayload = await parseSysmsgSysmsgTemplateMessagePayload(message);
     if (!sysmsgTemplatePayload) {
       return null;
@@ -55,7 +55,7 @@ export default async(puppet: PUPPET.Puppet, message: PadLocal.Message.AsObject):
     return parseSysmsgTemplate<TopicChange>(
       sysmsgTemplatePayload,
       OTHER_CHANGE_TOPIC_REGEX_LIST,
-      async(templateLinkList) => {
+      async (templateLinkList) => {
         // the first item MUST be changers profile link
         const changerList = templateLinkList[0]!.payload as SysmsgTemplateLinkProfile;
         const changerId = changerList[0]!.userName;
diff --git a/src/padlocal/messages/sysmsg/message-revokemsg.ts b/src/padlocal/messages/sysmsg/message-revokemsg.ts
index 6cb5e60..de079ba 100644
--- a/src/padlocal/messages/sysmsg/message-revokemsg.ts
+++ b/src/padlocal/messages/sysmsg/message-revokemsg.ts
@@ -32,8 +32,8 @@ const OTHER_REVOKE_REGEX_LIST = [
 export async function parseRevokeMsgMessagePayload(revokeMsgXmlSchema: RevokeMsgXmlSchema): Promise<RevokeMsgMessagePayload> {
   let nickName: string | undefined;
 
-  const youRevoke = async() => parseTextWithRegexList<RevokeMsgType>(revokeMsgXmlSchema.replacemsg, YOU_REVOKE_REGEX_LIST, async() => "You");
-  const otherRevoke = async() => parseTextWithRegexList<RevokeMsgType>(revokeMsgXmlSchema.replacemsg, OTHER_REVOKE_REGEX_LIST, async(_, match) => {
+  const youRevoke = async () => parseTextWithRegexList<RevokeMsgType>(revokeMsgXmlSchema.replacemsg, YOU_REVOKE_REGEX_LIST, async () => "You");
+  const otherRevoke = async () => parseTextWithRegexList<RevokeMsgType>(revokeMsgXmlSchema.replacemsg, OTHER_REVOKE_REGEX_LIST, async (_, match) => {
     nickName = match[1];
     return "Other";
   });
@@ -49,7 +49,7 @@ export async function parseRevokeMsgMessagePayload(revokeMsgXmlSchema: RevokeMsg
   };
 }
 
-export async function getRevokeOriginalMessage(puppet: PUPPET.Puppet, revokemsgPayload:RevokeMsgMessagePayload): Promise<PUPPET.payloads.Message | null> {
+export async function getRevokeOriginalMessage(puppet: PUPPET.Puppet, revokemsgPayload: RevokeMsgMessagePayload): Promise<PUPPET.payloads.Message | null> {
   const messageIdList = await puppet.messageSearch({ id: revokemsgPayload.originalMessageId });
   if (messageIdList.length) {
     return puppet.messagePayload(messageIdList[0]!);
@@ -58,7 +58,7 @@ export async function getRevokeOriginalMessage(puppet: PUPPET.Puppet, revokemsgP
   return null;
 }
 
-export async function getRevokeOperatorIdForRoomMessage(puppet: PUPPET.Puppet, revokemsgPayload:RevokeMsgMessagePayload) : Promise<string | null> {
+export async function getRevokeOperatorIdForRoomMessage(puppet: PUPPET.Puppet, revokemsgPayload: RevokeMsgMessagePayload): Promise<string | null> {
   if (isRoomId(revokemsgPayload.session) || isIMRoomId(revokemsgPayload.session)) {
     const contactIdList = await puppet.roomMemberSearch(revokemsgPayload.session, revokemsgPayload.operatorNickName!);
     if (contactIdList.length) {
diff --git a/src/padlocal/messages/sysmsg/message-sysmsgtemplate.ts b/src/padlocal/messages/sysmsg/message-sysmsgtemplate.ts
index c94bf83..b707fbc 100644
--- a/src/padlocal/messages/sysmsg/message-sysmsgtemplate.ts
+++ b/src/padlocal/messages/sysmsg/message-sysmsgtemplate.ts
@@ -78,7 +78,7 @@ function toList(list: any): any[] {
 export async function parseSysmsgTemplateMessagePayload(sysmsgTemplateXml: SysmsgTemplateXmlSchema): Promise<SysmsgTemplateMessagePayload> {
   const linkList = toList(sysmsgTemplateXml.content_template.link_list.link);
 
-  const allLinkList = linkList.map((link): SysmsgTemplateLink  => {
+  const allLinkList = linkList.map((link): SysmsgTemplateLink => {
     const type = link.$.type as SysmsgTemplateLinkType;
     let payload: SysmsgTemplateLinkPayload | undefined;
 
@@ -122,12 +122,12 @@ export async function parseSysmsgTemplateMessagePayload(sysmsgTemplateXml: Sysms
 
 export type SysmsgTemplateHandler<T> = (templateLinkList: SysmsgTemplateLink[], matchedRegexIndex: number) => Promise<T>;
 
-export async function parseSysmsgTemplate<T>(sysmsgTemplatePayload: SysmsgTemplateMessagePayload, regexList: RegExp[], handler: SysmsgTemplateHandler<T>) : Promise<T | null> {
-  return parseTextWithRegexList(sysmsgTemplatePayload.template, regexList, async(matchedRegexIndex) => {
+export async function parseSysmsgTemplate<T>(sysmsgTemplatePayload: SysmsgTemplateMessagePayload, regexList: RegExp[], handler: SysmsgTemplateHandler<T>): Promise<T | null> {
+  return parseTextWithRegexList(sysmsgTemplatePayload.template, regexList, async (matchedRegexIndex) => {
     return handler(sysmsgTemplatePayload.templateLinkList, matchedRegexIndex);
   });
 }
 
 export function createSysmsgTemplateRunner<T>(sysmsgTemplatePayload: SysmsgTemplateMessagePayload, regexList: RegExp[], handler: SysmsgTemplateHandler<T>): Runner<T> {
-  return async() => parseSysmsgTemplate<T>(sysmsgTemplatePayload, regexList, handler);
+  return async () => parseSysmsgTemplate<T>(sysmsgTemplatePayload, regexList, handler);
 }
diff --git a/src/padlocal/schema-mapper/message/message-parser-appmsg.ts b/src/padlocal/schema-mapper/message/message-parser-appmsg.ts
index 4b357e3..a050af8 100644
--- a/src/padlocal/schema-mapper/message/message-parser-appmsg.ts
+++ b/src/padlocal/schema-mapper/message/message-parser-appmsg.ts
@@ -4,7 +4,7 @@ import { log } from "wechaty-puppet";
 import { LOGPRE, MessageParser, MessageParserContext } from "./message-parser.js";
 import { AppMessageType, parseAppmsgMessagePayload } from "../../messages/message-appmsg.js";
 
-export const appMsgParser: MessageParser = async(padLocalMessage: PadLocal.Message.AsObject, ret: PUPPET.payloads.Message, context: MessageParserContext) => {
+export const appMsgParser: MessageParser = async (padLocalMessage: PadLocal.Message.AsObject, ret: PUPPET.payloads.Message, context: MessageParserContext) => {
   if (ret.type !== PUPPET.types.Message.Attachment) {
     return ret;
   }
diff --git a/src/padlocal/schema-mapper/message/message-parser-refermsg.ts b/src/padlocal/schema-mapper/message/message-parser-refermsg.ts
index 05913ab..b536c85 100644
--- a/src/padlocal/schema-mapper/message/message-parser-refermsg.ts
+++ b/src/padlocal/schema-mapper/message/message-parser-refermsg.ts
@@ -4,7 +4,7 @@ import { AppMessageType, parseAppmsgMessagePayload, ReferMsgPayload } from "../.
 import { WechatMessageType } from "../../types.js";
 import type { MessageParser, MessageParserContext } from "./message-parser.js";
 
-export const referMsgParser: MessageParser = async(_padLocalMessage: PadLocal.Message.AsObject, ret: PUPPET.payloads.Message, context: MessageParserContext) => {
+export const referMsgParser: MessageParser = async (_padLocalMessage: PadLocal.Message.AsObject, ret: PUPPET.payloads.Message, context: MessageParserContext) => {
   if (!context.appMessagePayload || context.appMessagePayload.type !== AppMessageType.ReferMsg) {
     return ret;
   }
diff --git a/src/padlocal/schema-mapper/message/message-parser-room.ts b/src/padlocal/schema-mapper/message/message-parser-room.ts
index 137f21e..d2e45f7 100644
--- a/src/padlocal/schema-mapper/message/message-parser-room.ts
+++ b/src/padlocal/schema-mapper/message/message-parser-room.ts
@@ -53,7 +53,7 @@ async function roomMessageSentBySelf(padLocalMessage: PadLocal.Message.AsObject,
  * @param ret
  * @param context
  */
-export const roomParser: MessageParser = async(padLocalMessage: PadLocal.Message.AsObject, ret: PUPPET.payloads.Message, context: MessageParserContext) => {
+export const roomParser: MessageParser = async (padLocalMessage: PadLocal.Message.AsObject, ret: PUPPET.payloads.Message, context: MessageParserContext) => {
   await roomMessageSentByOthers(padLocalMessage, ret);
   await roomMessageSentBySelf(padLocalMessage, ret);
 
diff --git a/src/padlocal/schema-mapper/message/message-parser-single-chat.ts b/src/padlocal/schema-mapper/message/message-parser-single-chat.ts
index 01b102d..65ed771 100644
--- a/src/padlocal/schema-mapper/message/message-parser-single-chat.ts
+++ b/src/padlocal/schema-mapper/message/message-parser-single-chat.ts
@@ -2,7 +2,7 @@ import type * as PUPPET from "wechaty-puppet";
 import type PadLocal from "padlocal-client-ts/dist/proto/padlocal_pb.js";
 import type { MessageParser, MessageParserContext } from "./message-parser";
 
-export const singleChatParser: MessageParser = async(padLocalMessage: PadLocal.Message.AsObject, ret: PUPPET.payloads.Message, context: MessageParserContext) => {
+export const singleChatParser: MessageParser = async (padLocalMessage: PadLocal.Message.AsObject, ret: PUPPET.payloads.Message, context: MessageParserContext) => {
   if (!context.isRoomMessage) {
     ret.talkerId = padLocalMessage.fromusername;
     ret.listenerId = padLocalMessage.tousername;
diff --git a/src/padlocal/schema-mapper/message/message-parser-sysmsg.ts b/src/padlocal/schema-mapper/message/message-parser-sysmsg.ts
index 881fa42..391e672 100644
--- a/src/padlocal/schema-mapper/message/message-parser-sysmsg.ts
+++ b/src/padlocal/schema-mapper/message/message-parser-sysmsg.ts
@@ -12,7 +12,7 @@ import type { RevokeMsgMessagePayload } from "../../messages/sysmsg/message-revo
  * @param ret
  * @param context
  */
-export const sysmsgParser: MessageParser = async(padLocalMessage: PadLocal.Message.AsObject, ret: PUPPET.payloads.Message, context: MessageParserContext) => {
+export const sysmsgParser: MessageParser = async (padLocalMessage: PadLocal.Message.AsObject, ret: PUPPET.payloads.Message, context: MessageParserContext) => {
   const sysmsgPayload = await parseSysmsgMessagePayload(padLocalMessage);
   if (!sysmsgPayload) {
     return ret;
diff --git a/src/padlocal/schema-mapper/message/message-parser-type.ts b/src/padlocal/schema-mapper/message/message-parser-type.ts
index 2e50df5..eefe1e9 100644
--- a/src/padlocal/schema-mapper/message/message-parser-type.ts
+++ b/src/padlocal/schema-mapper/message/message-parser-type.ts
@@ -22,7 +22,7 @@ const TypeMappings: { [key: number]: PUPPET.types.Message; } = {
   [WechatMessageType.SysNotice]: PUPPET.types.Message.Unknown,
 };
 
-export const typeParser: MessageParser = async(padLocalMessage: PadLocal.Message.AsObject, ret: PUPPET.payloads.Message, _context: MessageParserContext) => {
+export const typeParser: MessageParser = async (padLocalMessage: PadLocal.Message.AsObject, ret: PUPPET.payloads.Message, _context: MessageParserContext) => {
   const wechatMessageType = padLocalMessage.type as WechatMessageType;
   let type: PUPPET.types.Message | undefined = TypeMappings[wechatMessageType];
 
diff --git a/src/puppet-padlocal.ts b/src/puppet-padlocal.ts
index 6fc5409..2e98d5f 100644
--- a/src/puppet-padlocal.ts
+++ b/src/puppet-padlocal.ts
@@ -121,7 +121,7 @@ class PuppetPadlocal extends PUPPET.Puppet {
       [PUPPET.types.ScanStatus.Timeout]: "Timeout",
     };
 
-    const onQrCodeEvent = async(qrCodeEvent: PadLocal.QRCodeEvent) => {
+    const onQrCodeEvent = (qrCodeEvent: PadLocal.QRCodeEvent) => {
       let scanStatus: PUPPET.types.ScanStatus = PUPPET.types.ScanStatus.Unknown;
       let qrCodeImageURL: string | undefined;
       switch (qrCodeEvent.getStatus()) {
@@ -169,9 +169,9 @@ class PuppetPadlocal extends PUPPET.Puppet {
         log.info(PRE, `start login with type: ${LoginTypeName[loginType]}`);
       },
 
-      onLoginSuccess: async(_) => {
+      onLoginSuccess: (_) => {
         this.wrapAsync(
-          this._onPushSerialExecutor.execute(async() => {
+          this._onPushSerialExecutor.execute(async () => {
             const userName = this._client!.selfContact!.getUsername();
             log.silly(PRE, `login success: ${userName}`);
 
@@ -187,10 +187,10 @@ class PuppetPadlocal extends PUPPET.Puppet {
       onQrCodeEvent,
 
       // Will sync message and contact after login success, since last time login.
-      onSync: async(syncEvent: PadLocal.SyncEvent) => {
+      onSync: (syncEvent: PadLocal.SyncEvent) => {
 
         this.wrapAsync(
-          this._onPushSerialExecutor.execute(async() => {
+          this._onPushSerialExecutor.execute(async () => {
             log.silly(PRE, `login sync event: ${JSON.stringify(syncEvent.toObject())}`);
 
             for (const contact of syncEvent.getContactList()) {
@@ -206,7 +206,7 @@ class PuppetPadlocal extends PUPPET.Puppet {
     })
       .then(() => {
         this.wrapAsync(
-          this._onPushSerialExecutor.execute(async() => {
+          this._onPushSerialExecutor.execute(async () => {
             log.silly(PRE, "on ready");
 
             this.emit("ready", {
@@ -217,7 +217,7 @@ class PuppetPadlocal extends PUPPET.Puppet {
 
         return null;
       })
-      .catch(async(error) => {
+      .catch(async (error) => {
         log.error(`start client failed: ${error.stack}`);
         await this._stopClient(true);
       });
@@ -1062,7 +1062,8 @@ class PuppetPadlocal extends PUPPET.Puppet {
       }
       case PUPPET.types.Message.Attachment:
       case PUPPET.types.Message.MiniProgram:
-      case PUPPET.types.Message.Url: {
+      case PUPPET.types.Message.Url:
+      case PUPPET.types.Message.ChatHistory: {
         const response: PadLocal.ForwardMessageResponse = await this._client!.api.forwardMessage(
           genIdempotentId(),
           toUserName,
@@ -1196,7 +1197,7 @@ class PuppetPadlocal extends PUPPET.Puppet {
     let ret = await this._cacheMgr!.getContact(id);
 
     if (!ret) {
-      ret = await CachedPromiseFunc(`contactRawPayload-${id}`, async() => {
+      ret = await CachedPromiseFunc(`contactRawPayload-${id}`, async () => {
         const contact = await this._refreshContact(id);
         return contact.toObject();
       });
@@ -1288,7 +1289,7 @@ class PuppetPadlocal extends PUPPET.Puppet {
     await this.client!.api.syncContact({
       onSync: (contactList: PadLocal.Contact[]) => {
         this.wrapAsync(
-          this._onPushSerialExecutor.execute(async() => {
+          this._onPushSerialExecutor.execute(async () => {
             for (const contact of contactList) {
               await this._onPushContact(contact);
             }
@@ -1525,7 +1526,7 @@ class PuppetPadlocal extends PUPPET.Puppet {
     this._client = await PadLocalClient.create(this.options.token!, true);
 
     this._client.on("kickout", this.wrapAsync(
-      async(_detail: KickOutEvent) => {
+      async (_detail: KickOutEvent) => {
         if (this.currentUserId) {
           this.emit("logout", { contactId: this.currentUserId, data: _detail.errorMessage });
         }
@@ -1534,8 +1535,8 @@ class PuppetPadlocal extends PUPPET.Puppet {
       }),
     );
     this._client.on("message", this.wrapAsync(
-      async(messageList: PadLocal.Message[]) => {
-        await this._onPushSerialExecutor.execute(async() => {
+      async (messageList: PadLocal.Message[]) => {
+        await this._onPushSerialExecutor.execute(async () => {
           for (const message of messageList) {
             // handle message one by one
             await this._onPushMessage(message);
@@ -1545,8 +1546,8 @@ class PuppetPadlocal extends PUPPET.Puppet {
     ));
 
     this._client.on("contact", this.wrapAsync(
-      async(contactList: PadLocal.Contact[]) => {
-        await this._onPushSerialExecutor.execute(async() => {
+      async (contactList: PadLocal.Contact[]) => {
+        await this._onPushSerialExecutor.execute(async () => {
           for (const contact of contactList) {
             await this._onPushContact(contact);
           }
diff --git a/tests/wechaty-api.test.ts b/tests/wechaty-api.test.ts
index 04e8c74..5378d7a 100644
--- a/tests/wechaty-api.test.ts
+++ b/tests/wechaty-api.test.ts
@@ -8,16 +8,16 @@ import type PuppetPadlocal from "../src/puppet-padlocal.js";
 
 let bot: Wechaty;
 
-beforeAll(async() => {
+beforeAll(async () => {
   bot = await prepareSingedOnBot();
 });
 
-afterAll(async() => {
+afterAll(async () => {
   await bot.stop();
 });
 
 describe("contact", () => {
-  test("set self name", async() => {
+  test("set self name", async () => {
     const self = bot.currentUser;
 
     const oldName = self.name();
@@ -32,7 +32,7 @@ describe("contact", () => {
     console.info(`new name: ${newName}`);
   });
 
-  test("self qr code", async() => {
+  test("self qr code", async () => {
     const self = bot.currentUser;
     const qrStr = await self.qrcode();
     expect(qrStr.length).toBeGreaterThan(0);
@@ -40,13 +40,13 @@ describe("contact", () => {
     console.info(`qr: ${qrStr}`);
   });
 
-  test("set self signature", async() => {
+  test("set self signature", async () => {
     const toSignature: string = config.get("test.contact.changeSignature");
     const self = bot.currentUser;
     await self.signature(toSignature);
   });
 
-  test("set other contact alias", async() => {
+  test("set other contact alias", async () => {
     const userName: string = config.get("test.contact.alias.userName");
     const toAlias: string = config.get("test.contact.alias.aliasName");
 
@@ -62,7 +62,7 @@ describe("contact", () => {
     console.info(`new alias: ${newAlias}`);
   });
 
-  test("contact avatar", async() => {
+  test("contact avatar", async () => {
     const selfContact = bot.currentUser;
     const selfAvatarFileBox = await selfContact.avatar();
     expect(selfAvatarFileBox).toBeTruthy();
@@ -73,12 +73,12 @@ describe("contact", () => {
     expect(otherAvatar).toBeTruthy();
   });
 
-  test("contact list", async() => {
+  test("contact list", async () => {
     const contactList = await bot.Contact.findAll();
     expect(contactList.length).toBeGreaterThan(0);
   });
 
-  test("delete contact", async() => {
+  test("delete contact", async () => {
     const deleteUserName: string = config.get("test.contact.deleteUserName");
 
     const puppet: PuppetPadlocal = bot.puppet as PuppetPadlocal;
@@ -93,24 +93,24 @@ describe("tag", () => {
   const userName: string = config.get("test.tag.targetUserName");
   const tagName: string = config.get("test.tag.addDeleteTagName");
 
-  test("add user tag", async() => {
+  test("add user tag", async () => {
     const tag = await bot.Tag.get(tagName);
     const contact = await bot.Contact.find({ id: userName });
     await tag.add(contact!);
   });
 
-  test("delete user tag", async() => {
+  test("delete user tag", async () => {
     const tag = await bot.Tag.get(tagName);
     const contact = await bot.Contact.find({ id: userName });
     await tag.remove(contact!);
   });
 
-  test("delete tag", async() => {
+  test("delete tag", async () => {
     const tag = await bot.Tag.get(tagName);
     await bot.Tag.delete(tag);
   });
 
-  test("get contact tag list", async() => {
+  test("get contact tag list", async () => {
     const contact = await bot.Contact.find({ id: userName });
     const tags = await contact!.tags();
     console.info(tags);
@@ -120,14 +120,14 @@ describe("tag", () => {
 describe("friendship", () => {
   const hello: string = config.get("test.friendship.add.hello");
 
-  test("accept", async() => {
+  test("accept", async () => {
     const friendshipId: string = config.get("test.friendship.acceptId");
     const friendship = await bot.Friendship.load(friendshipId);
     await friendship.ready();
     await friendship.accept();
   });
 
-  test("add", async() => {
+  test("add", async () => {
     const userName: string = config.get("test.friendship.add.userName");
     const contact = await bot.Contact.find({ id: userName });
     expect(contact).toBeTruthy();
@@ -135,7 +135,7 @@ describe("friendship", () => {
     await bot.Friendship.add(contact!, hello);
   });
 
-  test("search phone ", async() => {
+  test("search phone ", async () => {
     const searchPhone: string = config.get("test.friendship.search.phone");
     const contact = await bot.Friendship.search({ phone: searchPhone });
     expect(contact).toBeTruthy();
@@ -143,7 +143,7 @@ describe("friendship", () => {
     await bot.Friendship.add(contact!, hello);
   });
 
-  test("search weixin ", async() => {
+  test("search weixin ", async () => {
     const searchWeixin: string = config.get("test.friendship.search.weixin");
     const contact = await bot.Friendship.search({ weixin: searchWeixin });
     expect(contact).toBeTruthy();
@@ -155,7 +155,7 @@ describe("friendship", () => {
 const toChatRoomId: string = config.get("test.message.send.chatroomId");
 const toUserName: string = config.get("test.message.send.toUserName");
 
-const expectSendMessage = async(message: Message, expectedMessageType: PUPPET.types.Message) => {
+const expectSendMessage = async (message: Message, expectedMessageType: PUPPET.types.Message) => {
   const selfContact = bot.currentUser;
   expect(message).toBeTruthy();
   expect(message.talker()!.id).toEqual(selfContact.id);
@@ -164,7 +164,7 @@ const expectSendMessage = async(message: Message, expectedMessageType: PUPPET.ty
   expect(message.date()).toBeTruthy();
 };
 
-const sendToContact = async(payload: any, expectedMessageType: PUPPET.types.Message, toUser?: string): Promise<Message> => {
+const sendToContact = async (payload: any, expectedMessageType: PUPPET.types.Message, toUser?: string): Promise<Message> => {
   const to = toUser || toUserName;
   const toContact = await bot.Contact.find({ id: to });
   const message = (await toContact!.say(payload)) as Message;
@@ -174,7 +174,7 @@ const sendToContact = async(payload: any, expectedMessageType: PUPPET.types.Mess
   return message;
 };
 
-const sendToRoom = async(
+const sendToRoom = async (
   payload: any,
   expectedMessageType: PUPPET.types.Message,
   toRoomId?: string,
@@ -190,14 +190,14 @@ const sendToRoom = async(
 };
 
 describe("message", () => {
-  const sendMessage = async(payload: any, expectedMessageType: PUPPET.types.Message): Promise<Message[]> => {
+  const sendMessage = async (payload: any, expectedMessageType: PUPPET.types.Message): Promise<Message[]> => {
     const message1 = await sendToContact(payload, expectedMessageType);
     const message2 = await sendToRoom(payload, expectedMessageType);
 
     return [message1, message2];
   };
 
-  const recallMessages = async(messageList: Message[]) => {
+  const recallMessages = async (messageList: Message[]) => {
     await new Promise((resolve) => setTimeout(resolve, 1000));
     await messageList[0]!.recall();
 
@@ -205,12 +205,12 @@ describe("message", () => {
     await messageList[1]!.recall();
   };
 
-  test("send text message", async() => {
+  test("send text message", async () => {
     const text = `hello padlocal: ${Date.now()}`;
     await sendMessage(text, PUPPET.types.Message.Text);
   });
 
-  test("send text message with at user list", async() => {
+  test("send text message with at user list", async () => {
     const atUserList: string[] = config.get("test.message.send.chatroomAtUserList");
 
     const text = `hello padlocal: ${Date.now()}`;
@@ -223,46 +223,46 @@ describe("message", () => {
     await sendToRoom(text, PUPPET.types.Message.Text, undefined, ...contactList);
   });
 
-  test("recall text message", async() => {
+  test("recall text message", async () => {
     const messageList = await sendMessage(`hi: ${Date.now()}`, PUPPET.types.Message.Text);
     await recallMessages(messageList);
   });
 
-  const sendContactCardMessage = async(): Promise<Message[]> => {
+  const sendContactCardMessage = async (): Promise<Message[]> => {
     const contactCardId: string = config.get("test.message.send.contactCardId");
     const contact = (await bot.Contact.find({ id: contactCardId }))!;
 
     return sendMessage(contact, PUPPET.types.Message.Text);
   };
 
-  test("send contact card message", async() => {
+  test("send contact card message", async () => {
     await sendContactCardMessage();
   });
 
-  test("recall contact card message", async() => {
+  test("recall contact card message", async () => {
     const messageList = await sendContactCardMessage();
 
     await recallMessages(messageList);
   });
 
-  const sendImageMessage = async(): Promise<Message[]> => {
+  const sendImageMessage = async (): Promise<Message[]> => {
     const imageFilePath: string = config.get("test.message.send.imageFilePath");
     const fileBox = FileBox.fromFile(imageFilePath);
 
     return sendMessage(fileBox, PUPPET.types.Message.Text);
   };
 
-  test("send image message", async() => {
+  test("send image message", async () => {
     await sendImageMessage();
   });
 
-  test("recall image message", async() => {
+  test("recall image message", async () => {
     const messageList = await sendImageMessage();
 
     await recallMessages(messageList);
   });
 
-  const sendVoiceMessage = async(): Promise<Message[]> => {
+  const sendVoiceMessage = async (): Promise<Message[]> => {
     const voiceFilePath: string = config.get("test.message.send.voiceFilePath");
     const voiceLength: number = config.get("test.message.send.voiceLength");
 
@@ -275,50 +275,50 @@ describe("message", () => {
     return sendMessage(fileBox, PUPPET.types.Message.Text);
   };
 
-  test("send voice message", async() => {
+  test("send voice message", async () => {
     await sendVoiceMessage();
   }, 20000);
 
-  test("recall voice message", async() => {
+  test("recall voice message", async () => {
     const messageList = await sendVoiceMessage();
 
     await recallMessages(messageList);
   }, 20000);
 
-  const sendVideoMessage = async(): Promise<Message[]> => {
+  const sendVideoMessage = async (): Promise<Message[]> => {
     const videoFilePath: string = config.get("test.message.send.videoFilePath");
     const fileBox = FileBox.fromFile(videoFilePath);
 
     return sendMessage(fileBox, PUPPET.types.Message.Text);
   };
 
-  test("send video message", async() => {
+  test("send video message", async () => {
     await sendVideoMessage();
   }, 20000);
 
-  test("recall video message", async() => {
+  test("recall video message", async () => {
     const messageList = await sendVideoMessage();
 
     await recallMessages(messageList);
   }, 20000);
 
-  const sendFileMessage = async(): Promise<Message[]> => {
+  const sendFileMessage = async (): Promise<Message[]> => {
     const fileFilePath: string = config.get("test.message.send.fileFilePath");
     const fileBox = FileBox.fromFile(fileFilePath);
 
     return sendMessage(fileBox, PUPPET.types.Message.Text);
   };
 
-  test("send file message", async() => {
+  test("send file message", async () => {
     await sendFileMessage();
   }, 300000);
 
-  test("recall file message", async() => {
+  test("recall file message", async () => {
     const messageList = await sendFileMessage();
     await recallMessages(messageList);
   }, 20000);
 
-  const sendLinkMessage = async(): Promise<Message[]> => {
+  const sendLinkMessage = async (): Promise<Message[]> => {
     const title: string = config.get("test.message.send.link.title");
     const description: string = config.get("test.message.send.link.description");
     const url: string = config.get("test.message.send.link.url");
@@ -334,22 +334,22 @@ describe("message", () => {
     return sendMessage(urlLink, PUPPET.types.Message.Url);
   };
 
-  test("send link message", async() => {
+  test("send link message", async () => {
     await sendLinkMessage();
   });
 
-  test("recall link message", async() => {
+  test("recall link message", async () => {
     const messageList = await sendLinkMessage();
     await recallMessages(messageList);
   }, 10000);
 
-  const sendMiniProgramMessageThumbCdn = async(): Promise<Message[]> => {
+  const sendMiniProgramMessageThumbCdn = async (): Promise<Message[]> => {
     const miniProgramPayload: PUPPET.payloads.MiniProgram = config.get("test.message.send.miniProgram");
     const miniProgram = new impls.MiniProgramImpl(miniProgramPayload);
     return sendMessage(miniProgram, PUPPET.types.Message.MiniProgram);
   };
 
-  const sendMiniProgramMessageThumbHttp = async(): Promise<Message[]> => {
+  const sendMiniProgramMessageThumbHttp = async (): Promise<Message[]> => {
     const miniProgramPayload: PUPPET.payloads.MiniProgram = Object.assign({}, config.get("test.message.send.miniProgram"));
 
     miniProgramPayload.thumbUrl = config.get("test.message.send.miniProgramThumbURLHttp");
@@ -361,19 +361,19 @@ describe("message", () => {
 
   test(
     "send miniprogram message",
-    async() => {
+    async () => {
       await sendMiniProgramMessageThumbCdn();
       await sendMiniProgramMessageThumbHttp();
     },
     30 * 1000,
   );
 
-  test("recall miniprogram message", async() => {
+  test("recall miniprogram message", async () => {
     const messageList = await sendMiniProgramMessageThumbCdn();
     await recallMessages(messageList);
   });
 
-  const sendEmojiMessage = async(): Promise<Message[]> => {
+  const sendEmojiMessage = async (): Promise<Message[]> => {
     const emotionPayload: EmojiMessagePayload = config.get("test.message.send.emoji");
     const emoticonBox = FileBox.fromUrl(emotionPayload.cdnurl, "message-test-emotion.jpg", {
       ...emotionPayload,
@@ -384,11 +384,11 @@ describe("message", () => {
     return sendMessage(emoticonBox, PUPPET.types.Message.Emoticon);
   };
 
-  test("send emoticon message", async() => {
+  test("send emoticon message", async () => {
     await sendEmojiMessage();
   });
 
-  test("recall emoticon message", async() => {
+  test("recall emoticon message", async () => {
     const messageList = await sendEmojiMessage();
     await recallMessages(messageList);
   });
@@ -397,7 +397,7 @@ describe("message", () => {
 describe("room", () => {
   const chatroomId: string = config.get("test.room.chatroomId");
 
-  test("create room", async() => {
+  test("create room", async () => {
     const memberList: string[] = config.get("test.room.create.memberUserNameList");
     const roomName: string = config.get("test.room.create.roomName");
 
@@ -423,7 +423,7 @@ describe("room", () => {
     await sendToRoom("hello", PUPPET.types.Message.Text, newRoom.id);
   });
 
-  test("room member list", async() => {
+  test("room member list", async () => {
     const room = (await bot.Room.find({ id: chatroomId }))!;
 
     const memberList = await room.memberAll();
@@ -434,7 +434,7 @@ describe("room", () => {
     expect(memberList.length).toBeGreaterThan(0);
   });
 
-  test("room delete member", async() => {
+  test("room delete member", async () => {
     const memberUserName: string = config.get("test.room.delete.memberUserName");
 
     const room = (await bot.Room.find({ id: chatroomId }))!;
@@ -450,7 +450,7 @@ describe("room", () => {
     expect(newMemberList.length).toEqual(oldMemberList.length - 1);
   });
 
-  test("room add member", async() => {
+  test("room add member", async () => {
     const room = (await bot.Room.find({ id: chatroomId }))!;
 
     const userName: string = config.get("test.room.add.memberUserName");
@@ -466,19 +466,19 @@ describe("room", () => {
     expect(newMemberList.length).toEqual(oldMemberList.length + 1);
   });
 
-  test("room avatar", async() => {
+  test("room avatar", async () => {
     const room = await bot.Room.find({ id: chatroomId });
 
     const avatarFileBox = await room!.avatar();
     expect(avatarFileBox).toBeTruthy();
   });
 
-  test("get room list", async() => {
+  test("get room list", async () => {
     const allRooms = await bot.Room.findAll();
     expect(allRooms.length).toBeGreaterThan(0);
   });
 
-  test("room qr", async() => {
+  test("room qr", async () => {
     const room = (await bot.Room.find({ id: chatroomId }))!;
     const qrString = await room.qrCode();
 
@@ -487,7 +487,7 @@ describe("room", () => {
     expect(qrString).toBeTruthy();
   });
 
-  test("room topic", async() => {
+  test("room topic", async () => {
     const room = (await bot.Room.find({ id: chatroomId }))!;
 
     const toName: string = config.get("test.room.topic.changeName");
@@ -499,7 +499,7 @@ describe("room", () => {
     expect(newTopic).toEqual(toName);
   });
 
-  test("room announce", async() => {
+  test("room announce", async () => {
     const room = (await bot.Room.find({ id: chatroomId }))!;
 
     const newAnnouncement: string = config.get("test.room.announce.newAnnouncement");
@@ -509,14 +509,14 @@ describe("room", () => {
     expect(announcement).toEqual(newAnnouncement);
   });
 
-  test("room quit", async() => {
+  test("room quit", async () => {
     const roomId: string = config.get("test.room.quit.id");
 
     const room = (await bot.Room.find({ id: roomId }))!;
     await room.quit();
   });
 
-  test("accept room invitation", async() => {
+  test("accept room invitation", async () => {
     const roomInvitationId: string = config.get("test.room.invitation.id");
     const roomInvitation = bot.RoomInvitation.load(roomInvitationId);
     await roomInvitation.accept();
diff --git a/tests/wechaty-login.test.ts b/tests/wechaty-login.test.ts
index 22568ad..27f3480 100644
--- a/tests/wechaty-login.test.ts
+++ b/tests/wechaty-login.test.ts
@@ -1,6 +1,6 @@
 import { prepareSingedOnBot } from "./wechaty-common.js";
 
-test("login", async() => {
+test("login", async () => {
   const bot = await prepareSingedOnBot();
 
   expect(bot.isLoggedIn).toBeTruthy();
@@ -14,7 +14,7 @@ test("login", async() => {
 
 test(
   "logout",
-  async() => {
+  async () => {
     const bot = await prepareSingedOnBot();
 
     expect(bot.isLoggedIn).toBeTruthy();
diff --git a/tests/wechaty-push.test.ts b/tests/wechaty-push.test.ts
index b6743c2..ac6cdb1 100644
--- a/tests/wechaty-push.test.ts
+++ b/tests/wechaty-push.test.ts
@@ -8,12 +8,12 @@ const LOGPRE = "TestBot";
 
 test(
   "push",
-  async() => {
+  async () => {
     const forwardFrom = config.get("test.push.forwardFrom");
     const forwardTo: string = config.get("test.push.forwardTo");
     const recallUserId: string = config.get("test.push.recallUserId");
 
-    const getMessagePayload = async(message: Message) => {
+    const getMessagePayload = async (message: Message) => {
       switch (message.type()) {
         case PUPPET.types.Message.Text:
           if (message.talker().id === recallUserId && message.text()!.indexOf("recall") !== -1) {
@@ -126,7 +126,7 @@ test(
       }
     };
 
-    const forwardMessage = async(bot: Wechaty, message: Message): Promise<void> => {
+    const forwardMessage = async (bot: Wechaty, message: Message): Promise<void> => {
       if (message.type() === PUPPET.types.Message.Unknown) {
         return;
       }
@@ -145,8 +145,8 @@ test(
       }
     };
 
-    await prepareSingedOnBot(async(bot) => {
-      bot.on("message", async(message: Message) => {
+    await prepareSingedOnBot(async (bot) => {
+      bot.on("message", async (message: Message) => {
         log.info(LOGPRE, `on message: ${message.toString()}`);
 
         if (message.talker().id === forwardFrom && message.listener()?.id === forwardFrom) {
@@ -156,7 +156,7 @@ test(
         await getMessagePayload(message);
       });
 
-      bot.on("friendship", async(friendship: Friendship) => {
+      bot.on("friendship", async (friendship: Friendship) => {
         log.info(LOGPRE, `on friendship: ${friendship.toJSON()}`);
 
         if (friendship.type() === PUPPET.types.Friendship.Receive) {
@@ -172,36 +172,34 @@ test(
         }
       });
 
-      bot.on("room-invite", async(roomInvite: RoomInvitation) => {
+      bot.on("room-invite", async (roomInvite: RoomInvitation) => {
         log.info(LOGPRE, `on room invite: ${await roomInvite.toJSON()}`);
 
         await roomInvite.accept();
       });
 
-      bot.on("room-join", async(room: Room, inviteeList: Contact[], inviter: Contact, date) => {
+      bot.on("room-join", async (room: Room, inviteeList: Contact[], inviter: Contact, date) => {
         log.info(
           LOGPRE,
-          `on room join: ${room.toString()}, inviteeList: ${inviteeList.map((i) => i.id)}, inviter: ${
-            inviter.id
+          `on room join: ${room.toString()}, inviteeList: ${inviteeList.map((i) => i.id)}, inviter: ${inviter.id
           }, ${date}`,
         );
       });
 
-      bot.on("room-leave", async(room: Room, leaverList: Contact[], remover?: Contact, date?: Date) => {
+      bot.on("room-leave", async (room: Room, leaverList: Contact[], remover?: Contact, date?: Date) => {
         log.info(
           LOGPRE,
-          `on room leave: ${room.toString()}, leaverList: ${leaverList.map((l) => l.id)}, remover: ${
-            remover?.id
+          `on room leave: ${room.toString()}, leaverList: ${leaverList.map((l) => l.id)}, remover: ${remover?.id
           } ${date}`,
         );
       });
 
-      bot.on("room-topic", async(room: Room, newTopic: string, oldTopic: string, changer: Contact, date?: Date) => {
+      bot.on("room-topic", async (room: Room, newTopic: string, oldTopic: string, changer: Contact, date?: Date) => {
         log.info(LOGPRE, `on room topic: ${room.toString()}, ${newTopic}, ${oldTopic}, ${changer.toString()}, ${date}`);
       });
     });
 
-    return new Promise(() => {});
+    return new Promise(() => { });
   },
   Math.pow(2, 30),
 );