wechaty-puppet-matrix 0.0.4

package/src/matrix/cache-manager.ts

@@ -0,0 +1,359 @@
+import fs from 'fs-extra'
+import os from 'os'
+import path from 'path'
+import LRU from 'lru-cache'
+
+import type * as PUPPET from '@juzi/wechaty-puppet'
+import { log } from '@juzi/wechaty-puppet'
+import { FlashStore } from 'flash-store'
+import type { MessagePayload, ContactPayload, MessageRevokeInfo, Label } from '../engine-schema.js'
+
+const PRE = '[CacheManager]'
+
+export type RoomMemberMap = { [contactId: string]: ContactPayload };
+
+export class CacheManager {
+
+  private readonly _userName: string
+
+  private _messageCache?: LRU<string, MessagePayload> // because message count may be massive, so we just keep them in memory with LRU and with limited capacity
+  private _messageRevokeCache?: LRU<string, MessageRevokeInfo>
+  private _contactCache?: FlashStore<string, ContactPayload>
+  private _contactSearchCache?: LRU<string, ContactPayload>
+  private _contactStrangerAliasCache?: FlashStore<string, string> // set alias before add contact
+  private _roomCache?: FlashStore<string, ContactPayload>
+  private _roomMemberCache?: FlashStore<string, RoomMemberMap>
+  private _roomInvitationCache?: FlashStore<string, PUPPET.payloads.RoomInvitation>
+  private _friendshipCache?: FlashStore<string, PUPPET.payloads.FriendshipReceive | PUPPET.payloads.FriendshipConfirm>
+
+  private _labelList?: Label[]
+
+  constructor (userName: string) {
+    this._userName = userName
+  }
+
+  async init (): Promise<void> {
+    if (this._messageCache) {
+      throw new Error('already initialized')
+    }
+
+    const baseDir = path.join(
+      os.homedir(),
+      path.sep,
+      '.wechaty',
+      'puppet-engine-cache',
+      path.sep,
+      this._userName,
+      path.sep,
+    )
+
+    const baseDirExist = await fs.pathExists(baseDir)
+    if (!baseDirExist) {
+      await fs.mkdirp(baseDir)
+    }
+
+    this._messageCache = new LRU<string, MessagePayload>({
+      dispose (key: string, val: any) {
+        log.silly(PRE, 'constructor() lruOptions.dispose(%s, %s)', key, JSON.stringify(val))
+      },
+      max: 1000,
+      maxAge: 1000 * 60 * 60,
+    })
+
+    this._messageRevokeCache = new LRU<string, MessageRevokeInfo>({
+      dispose (key: string, val: any) {
+        log.silly(PRE, 'constructor() lruOptions.dispose(%s, %s)', key, JSON.stringify(val))
+      },
+      max: 1000,
+      maxAge: 1000 * 60 * 60,
+    })
+
+    this._contactCache = new FlashStore(path.join(baseDir, 'contact-raw-payload'))
+    this._contactSearchCache = new LRU<string, ContactPayload>({
+      dispose (key: string, val: any) {
+        log.silly(PRE, 'constructor() lruOptions.dispose(%s, %s)', key, JSON.stringify(val))
+      },
+      max: 1000,
+      maxAge: 1000 * 60 * 60,
+    })
+    this._contactStrangerAliasCache = new FlashStore(path.join(baseDir, 'contact-stranger-alias'))
+    this._roomCache = new FlashStore(path.join(baseDir, 'room-raw-payload'))
+    this._roomMemberCache = new FlashStore(path.join(baseDir, 'room-member-raw-payload'))
+    this._roomInvitationCache = new FlashStore(path.join(baseDir, 'room-invitation-raw-payload'))
+    this._friendshipCache = new FlashStore(path.join(baseDir, 'friendship-raw-payload'))
+
+    const contactTotal = await this._contactCache.size
+
+    log.silly(PRE, `initCache() inited ${contactTotal} Contacts,  cachedir="${baseDir}"`)
+  }
+
+  async close () {
+    log.silly(PRE, 'close()')
+
+    if (
+      this._contactCache
+      && this._contactStrangerAliasCache
+      && this._roomMemberCache
+      && this._roomCache
+      && this._friendshipCache
+      && this._roomInvitationCache
+      && this._messageCache
+    ) {
+      log.silly(PRE, 'close() closing caches ...')
+
+      await Promise.all([
+        this._contactCache.close(),
+        this._contactStrangerAliasCache.close(),
+        this._roomMemberCache.close(),
+        this._roomCache.close(),
+        this._friendshipCache.close(),
+        this._roomInvitationCache.close(),
+      ])
+
+      this._contactCache = undefined
+      this._contactStrangerAliasCache = undefined
+      this._roomMemberCache = undefined
+      this._roomCache = undefined
+      this._friendshipCache = undefined
+      this._roomInvitationCache = undefined
+      this._messageCache = undefined
+
+      log.silly(PRE, 'close() cache closed.')
+    } else {
+      log.silly(PRE, 'close() cache not exist.')
+    }
+  }
+
+  /**
+   * -------------------------------
+   * Message Section
+   * --------------------------------
+   */
+  public async getMessage (messageId: string): Promise<MessagePayload | undefined> {
+    if (!messageId) return
+    return this._messageCache!.get(messageId)
+  }
+
+  public async setMessage (messageId: string, payload: MessagePayload): Promise<void> {
+    if (!messageId) return
+    await this._messageCache!.set(messageId, payload)
+  }
+
+  public async hasMessage (messageId: string): Promise<boolean> {
+    if (!messageId) return false
+    return this._messageCache!.has(messageId)
+  }
+
+  public async getMessageRevokeInfo (messageId: string): Promise<MessageRevokeInfo | undefined> {
+    if (!messageId) return
+    return this._messageRevokeCache!.get(messageId)
+  }
+
+  public async setMessageRevokeInfo (messageId: string, messageSendResult: MessageRevokeInfo): Promise<void> {
+    await this._messageRevokeCache!.set(messageId, messageSendResult)
+  }
+
+  /**
+   * -------------------------------
+   * Contact Section
+   * --------------------------------
+   */
+  public async getContact (contactId: string): Promise<ContactPayload | undefined> {
+    if (!contactId) return
+    return this._contactCache!.get(contactId)
+  }
+
+  public async setContact (contactId: string, payload: ContactPayload): Promise<void> {
+    if (!contactId) return
+    await this._contactCache!.set(contactId, payload)
+  }
+
+  public async deleteContact (contactId: string): Promise<void> {
+    if (!contactId) return
+    await this._contactCache!.delete(contactId)
+  }
+
+  public async getContactIds (): Promise<string[]> {
+    const result: string[] = []
+    for await (const key of this._contactCache!.keys()) {
+      result.push(key)
+    }
+
+    return result
+  }
+
+  public async getAllContacts (): Promise<ContactPayload[]> {
+    const result: ContactPayload[] = []
+    for await (const value of this._contactCache!.values()) {
+      result.push(value)
+    }
+    return result
+  }
+
+  public async hasContact (contactId: string): Promise<boolean> {
+    if (!contactId) return false
+    return this._contactCache!.has(contactId)
+  }
+
+  public async getContactCount (): Promise<number> {
+    return this._contactCache!.size
+  }
+
+  /**
+   * contact search
+   */
+
+  public async getContactSearch (id: string): Promise<ContactPayload | undefined> {
+    if (!id) return
+    return this._contactSearchCache!.get(id)
+  }
+
+  public async setContactSearch (id: string, payload: ContactPayload): Promise<void> {
+    if (!id) return
+    this._contactSearchCache!.set(id, payload)
+  }
+
+  public async hasContactSearch (id: string): Promise<boolean> {
+    if (!id) return false
+    return this._contactSearchCache!.has(id)
+  }
+
+  public async getContactStrangerAlias (encryptedUserName: string): Promise<string | undefined> {
+    return this._contactStrangerAliasCache!.get(encryptedUserName)
+  }
+
+  public async setContactStrangerAlias (encryptedUserName: string, alias: string): Promise<void> {
+    await this._contactStrangerAliasCache!.set(encryptedUserName, alias)
+  }
+
+  public async deleteContactStrangerAlias (encryptedUserName: string): Promise<void> {
+    await this._contactStrangerAliasCache!.delete(encryptedUserName)
+  }
+
+  /**
+   * -------------------------------
+   * Room Section
+   * --------------------------------
+   */
+  public async getRoom (roomId: string): Promise<ContactPayload | undefined> {
+    if (!roomId) return
+    return this._roomCache!.get(roomId)
+  }
+
+  public async setRoom (roomId: string, payload: ContactPayload): Promise<void> {
+    if (!roomId) return
+    await this._roomCache!.set(roomId, payload)
+  }
+
+  public async deleteRoom (roomId: string): Promise<void> {
+    if (!roomId) return
+    await this._roomCache!.delete(roomId)
+  }
+
+  public async getRoomIds (): Promise<string[]> {
+    const result: string[] = []
+    for await (const key of this._roomCache!.keys()) {
+      result.push(key)
+    }
+    return result
+  }
+
+  public async getRoomCount (): Promise<number> {
+    return this._roomCache!.size
+  }
+
+  public async hasRoom (roomId: string): Promise<boolean> {
+    if (!roomId) return false
+    return this._roomCache!.has(roomId)
+  }
+
+  /**
+   * -------------------------------
+   * Room Member Section
+   * --------------------------------
+   */
+  public async getRoomMember (roomId: string): Promise<RoomMemberMap | undefined> {
+    if (!roomId) return
+    return this._roomMemberCache!.get(roomId)
+  }
+
+  public async setRoomMember (roomId: string, payload: RoomMemberMap): Promise<void> {
+    if (!roomId) return
+    await this._roomMemberCache!.set(roomId, payload)
+
+    const roomInfo = await this.getRoom(roomId)
+    if (roomInfo && roomInfo.chatroommemberList) {
+      roomInfo.chatroommemberList = Object.keys(payload)
+      await this.setRoom(roomId, roomInfo)
+    }
+  }
+
+  public async deleteRoomMember (roomId: string): Promise<void> {
+    if (!roomId) return
+    await this._roomMemberCache!.delete(roomId)
+  }
+
+  public async updateSingleRoomMember (roomId: string, payload: ContactPayload): Promise<void> {
+    if (!roomId) return
+    const roomMemberMap = await this.getRoomMember(roomId)
+    if (roomMemberMap) {
+      roomMemberMap[payload.wxid] = payload
+      await this.setRoomMember(roomId, roomMemberMap)
+    } else {
+      await this.setRoomMember(roomId, { [payload.wxid]: payload })
+    }
+  }
+
+  public async deleteSingleRoomMember (roomId: string, contactId: string): Promise<void> {
+    if (!roomId || !contactId) return
+    const roomMemberMap = await this.getRoomMember(roomId)
+    if (roomMemberMap) {
+      delete roomMemberMap[contactId]
+      await this.setRoomMember(roomId, roomMemberMap)
+    }
+  }
+
+  /**
+   * -------------------------------
+   * Room Invitation Section
+   * -------------------------------
+   */
+  public async getRoomInvitation (messageId: string): Promise<PUPPET.payloads.RoomInvitation | undefined> {
+    if (!messageId) return
+    return this._roomInvitationCache!.get(messageId)
+  }
+
+  public async setRoomInvitation (messageId: string, payload: PUPPET.payloads.RoomInvitation): Promise<void> {
+    if (!messageId) return
+    await this._roomInvitationCache!.set(messageId, payload)
+  }
+
+  public async deleteRoomInvitation (messageId: string): Promise<void> {
+    if (!messageId) return
+    await this._roomInvitationCache!.delete(messageId)
+  }
+
+  /**
+   * -------------------------------
+   * Friendship Cache Section
+   * --------------------------------
+   */
+  public async getFriendshipRawPayload (id: string): Promise<PUPPET.payloads.FriendshipReceive | PUPPET.payloads.FriendshipConfirm|undefined> {
+    if (!id) return
+    return this._friendshipCache!.get(id)
+  }
+
+  public async setFriendshipRawPayload (id: string, payload: PUPPET.payloads.FriendshipReceive | PUPPET.payloads.FriendshipConfirm) {
+    if (!id) return
+    await this._friendshipCache!.set(id, payload)
+  }
+
+  public getLabelList (): Label[] | undefined {
+    return this._labelList
+  }
+
+  public setLabelList (labelList: Label[]): void {
+    this._labelList = labelList
+  }
+
+}

package/src/matrix/events/event-friendship.ts

@@ -0,0 +1,116 @@
+import type { MessagePayload } from '../../engine-schema.js'
+import * as PUPPET from '@juzi/wechaty-puppet'
+import type { EventPayload } from './event.js'
+import { WechatMessageType } from '../types.js'
+import { xmlToJson } from '../utils/xml-to-json.js'
+import { isContactId, isIMContactId } from '../utils/is-type.js'
+
+const FRIENDSHIP_CONFIRM_REGEX_LIST = [
+  /^You have added (.+) as your WeChat contact. Start chatting!$/,
+  /^你已添加了(.+)，现在可以开始聊天了。$/,
+  /I've accepted your friend request. Now let's chat!$/,
+  /^(.+) just added you to his\/her contacts list. Send a message to him\/her now!$/,
+  /^(.+)刚刚把你添加到通讯录，现在可以开始聊天了。$/,
+  /^我通过了你的朋友验证请求，现在我们可以开始聊天了$/,
+]
+
+const FRIENDSHIP_VERIFY_REGEX_LIST = [
+  /^(.+) has enabled Friend Confirmation/,
+  /^(.+)开启了朋友验证，你还不是他（她）朋友。请先发送朋友验证请求，对方验证通过后，才能聊天。/,
+]
+
+// 已经添加好友
+const isConfirm = (message: MessagePayload): boolean => {
+  return FRIENDSHIP_CONFIRM_REGEX_LIST.some((regexp) => {
+    return !!message.text.match(regexp)
+  })
+}
+// 需要添加好友
+const isNeedVerify = (message: MessagePayload): boolean => {
+  return FRIENDSHIP_VERIFY_REGEX_LIST.some((regexp) => {
+    return !!message.text.match(regexp)
+  })
+}
+
+interface ReceiveXmlSchema {
+  msg: {
+    $: {
+      fromusername: string
+      encryptusername: string
+      content: string
+      scene: string
+      ticket: string
+      sourcenickname?: string
+      sourceusername?: string
+      sharecardnickname?: string
+      sharecardusername?: string
+    }
+  }
+}
+
+const isReceive = async (
+  message: MessagePayload,
+): Promise<ReceiveXmlSchema | null> => {
+  if (
+    message.msgType !== WechatMessageType.VerifyMsg
+    && message.msgType !== WechatMessageType.VerifyMsgEnterprise
+  ) {
+    return null
+  }
+
+  try {
+    const verifyXml: ReceiveXmlSchema = await xmlToJson(message.text)
+    const contactId = verifyXml.msg.$.fromusername
+    if (isContactId(contactId) && verifyXml.msg.$.encryptusername) {
+      return verifyXml
+    } else if (isIMContactId(contactId)) {
+      return verifyXml
+    }
+  } catch (e) {
+    // not receive event
+  }
+
+  return null
+}
+
+export default async (_puppet: PUPPET.Puppet, message: MessagePayload): Promise<EventPayload> => {
+  if (isConfirm(message)) {
+    return {
+      contactId: message.talkerId,
+      id: message.id,
+      timestamp: message.timeStamp,
+      type: PUPPET.types.Friendship.Confirm,
+    } as PUPPET.payloads.FriendshipConfirm
+  } else if (isNeedVerify(message)) {
+    return {
+      contactId: message.talkerId,
+      id: message.id,
+      timestamp: message.timeStamp,
+      type: PUPPET.types.Friendship.Verify,
+    } as PUPPET.payloads.FriendshipVerify
+  } else {
+    const verifyXml = await isReceive(message)
+    if (verifyXml) {
+      const payload = verifyXml.msg.$
+
+      return {
+        contactId: payload.fromusername,
+        hello: payload.content,
+        id: message.id,
+        scene: parseInt(payload.scene, 10),
+        stranger: payload.encryptusername,
+        // 这里的ticket并非wechaty原始意义上的ticket
+        // 因为接口不同,所以这里存放的是原始xml
+        ticket: payload.ticket,
+        timestamp: message.timeStamp,
+        type: PUPPET.types.Friendship.Receive,
+        sourceNickName: payload.sourcenickname,
+        sourceContactId: payload.sourceusername,
+        shareCardNickName: payload.sharecardnickname,
+        shareCardContactId: payload.sharecardusername,
+      } as  PUPPET.payloads.FriendshipReceive
+    }
+
+    return null
+  }
+}

package/src/matrix/events/event-message.ts

@@ -0,0 +1,7 @@
+import type * as PUPPET from '@juzi/wechaty-puppet'
+import type { MessagePayload } from '../../engine-schema.js'
+import type { EventPayload } from './event.js'
+
+export default async (_puppet: PUPPET.Puppet, message: MessagePayload): Promise<EventPayload> => {
+  return message
+}

package/src/matrix/events/event-room-invite.ts

@@ -0,0 +1,64 @@
+import { parseAppmsgMessagePayload, AppMessagePayload, AppMessageType } from '../messages/message-appmsg.js'
+import { isRoomId } from '../utils/is-type.js'
+import type * as PUPPET from '@juzi/wechaty-puppet'
+import type { MessagePayload } from '../../engine-schema.js'
+import type { EventPayload } from './event.js'
+
+const ROOM_OTHER_INVITE_TITLE_ZH = [ /邀请你加入群聊/ ]
+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: MessagePayload): Promise<EventPayload> => {
+  let appMsgPayload: AppMessagePayload
+  try {
+    appMsgPayload = await parseAppmsgMessagePayload(message.msg)
+  } catch (e) {
+    return null
+  }
+
+  if (appMsgPayload.type !== AppMessageType.Url) {
+    return null
+  }
+
+  if (!appMsgPayload.title || !appMsgPayload.des) {
+    return null
+  }
+
+  let matchesForOtherInviteTitleEn = null as null | string[]
+  let matchesForOtherInviteTitleZh = null as null | string[]
+  let matchesForOtherInviteEn = null as null | string[]
+  let matchesForOtherInviteZh = null as null | string[]
+
+  ROOM_OTHER_INVITE_TITLE_EN.some((regex) => !!(matchesForOtherInviteTitleEn = appMsgPayload.title.match(regex)))
+  ROOM_OTHER_INVITE_TITLE_ZH.some((regex) => !!(matchesForOtherInviteTitleZh = appMsgPayload.title.match(regex)))
+  ROOM_OTHER_INVITE_LIST_EN.some((regex) => !!(matchesForOtherInviteEn = appMsgPayload.des!.match(regex)))
+  ROOM_OTHER_INVITE_LIST_ZH.some((regex) => !!(matchesForOtherInviteZh = appMsgPayload.des!.match(regex)))
+
+  const titleMatch = matchesForOtherInviteTitleEn || matchesForOtherInviteTitleZh
+  const matchInviteEvent = matchesForOtherInviteEn || matchesForOtherInviteZh
+  const matches = !!titleMatch && !!matchInviteEvent
+
+  if (!matches) {
+    return null
+  }
+  let receiverId = ''
+  // 如果不是群，则接收人是机器人 是群的话，接收人为群
+  if (!isRoomId(message.talkerId)) {
+    receiverId = _puppet.currentUserId
+  } else {
+    receiverId = message.talkerId
+  }
+
+  return {
+    avatar: appMsgPayload.thumburl,
+    id: message.id,
+    invitation: appMsgPayload.url,
+    inviterId: message.talkerId,
+    memberCount: 0,
+    memberIdList: [],
+    receiverId,
+    timestamp: message.timeStamp,
+    topic: matchInviteEvent![2],
+  } as PUPPET.payloads.RoomInvitation
+}