@juzi/wechaty-puppet-service 1.0.113 → 1.0.115

package/src/client/call-raw-payload-parser.spec.ts

@@ -0,0 +1,131 @@
+#!/usr/bin/env -S node --no-warnings --loader ts-node/esm
+
+import { test }            from 'tstest'
+import * as PUPPET         from '@juzi/wechaty-puppet'
+import { puppet as grpcPuppet } from '@juzi/wechaty-grpc'
+
+import { PuppetService }   from './puppet-service.js'
+import { timestampFromMilliseconds } from '../pure-functions/timestamp.js'
+
+/**
+ * The parser only reads `rawPayload.*` and a module-level `log` — it never
+ * touches `this`. Invoke it via `prototype.call({}, raw)` to avoid building a
+ * full PuppetService instance for unit-level tests.
+ */
+const callParser = async (raw: grpcPuppet.CallPayloadResponse.AsObject) =>
+  PuppetService.prototype.callRawPayloadParser.call({} as PuppetService, raw)
+
+/**
+ * 1. Full payload with starter, participants, media=VOICE, startTime, endTime
+ *    parses every field, mapping VOICE -> CallMediaType.Audio.
+ */
+test('callRawPayloadParser parses a complete payload', async t => {
+  const startMs = 1_700_000_000_000
+  const endMs   = 1_700_000_030_000
+
+  const pb = new grpcPuppet.CallPayloadResponse()
+  pb.setId('call-1')
+  pb.setStarter('alice')
+  pb.setParticipantsList([ 'alice', 'bob' ])
+  pb.setMedia(grpcPuppet.CallType.CALL_TYPE_VOICE)
+  pb.setStartTime(timestampFromMilliseconds(startMs))
+  pb.setEndTime(timestampFromMilliseconds(endMs))
+
+  const payload = await callParser(pb.toObject())
+
+  t.equal(payload.id, 'call-1', 'id propagated')
+  t.equal(payload.starter, 'alice', 'starter propagated')
+  t.same(payload.participants, [ 'alice', 'bob' ], 'participants propagated')
+  t.equal(payload.media, PUPPET.types.CallMediaType.Audio, 'VOICE maps to Audio')
+  t.equal(payload.startTime, startMs, 'startTime parsed')
+  t.equal(payload.endTime, endMs, 'endTime parsed')
+})
+
+/**
+ * 2. Empty starter string -> parser omits `starter` from the resulting payload.
+ *    (Mirrors the server, which only `setStarter` when the value is truthy.)
+ */
+test('callRawPayloadParser omits starter when starter is an empty string', async t => {
+  const pb = new grpcPuppet.CallPayloadResponse()
+  pb.setId('call-2')
+  pb.setParticipantsList([ 'alice' ])
+  pb.setMedia(grpcPuppet.CallType.CALL_TYPE_VIDEO)
+  pb.setStartTime(timestampFromMilliseconds(1_700_000_000_000))
+  // no setStarter -> default proto3 string '' on the wire
+
+  const payload = await callParser(pb.toObject())
+
+  t.equal(payload.starter, undefined, 'starter is undefined when empty on the wire')
+  t.equal(payload.media, PUPPET.types.CallMediaType.Video, 'VIDEO maps to Video')
+})
+
+/**
+ * 3. endTime not set (no setEndTime) -> payload.endTime === undefined.
+ */
+test('callRawPayloadParser leaves endTime undefined when endTime is not set', async t => {
+  const pb = new grpcPuppet.CallPayloadResponse()
+  pb.setId('call-3')
+  pb.setStarter('alice')
+  pb.setParticipantsList([ 'alice', 'bob' ])
+  pb.setMedia(grpcPuppet.CallType.CALL_TYPE_VOICE)
+  pb.setStartTime(timestampFromMilliseconds(1_700_000_000_000))
+  // no setEndTime
+
+  const payload = await callParser(pb.toObject())
+
+  t.equal(payload.endTime, undefined, 'endTime is undefined when not set on the wire')
+})
+
+/**
+ * 4. media = CALL_TYPE_UNKNOWN -> throw, error mentions "media".
+ */
+test('callRawPayloadParser throws when media is CALL_TYPE_UNKNOWN', async t => {
+  const pb = new grpcPuppet.CallPayloadResponse()
+  pb.setId('call-4')
+  pb.setParticipantsList([ 'alice' ])
+  pb.setMedia(grpcPuppet.CallType.CALL_TYPE_UNKNOWN)
+  pb.setStartTime(timestampFromMilliseconds(1_700_000_000_000))
+
+  await t.rejects(
+    callParser(pb.toObject()),
+    /media/,
+    'rejects with a message that mentions media',
+  )
+})
+
+/**
+ * 5. startTime not set -> throw, error mentions "startTime".
+ */
+test('callRawPayloadParser throws when startTime is not set', async t => {
+  const pb = new grpcPuppet.CallPayloadResponse()
+  pb.setId('call-5')
+  pb.setParticipantsList([ 'alice' ])
+  pb.setMedia(grpcPuppet.CallType.CALL_TYPE_VOICE)
+  // no setStartTime
+
+  await t.rejects(
+    callParser(pb.toObject()),
+    /startTime/,
+    'rejects with a message that mentions startTime',
+  )
+})
+
+/**
+ * 6. endTime explicitly set to epoch 0 -> payload.endTime === 0.
+ *    proto3 `setEndTime(timestamp(0))` is a legal "ended at epoch-0" value
+ *    (extreme short session / test stub) and must not be swallowed by a
+ *    truthy guard. Presence is what matters, not the numeric value.
+ */
+test('callRawPayloadParser preserves endTime when it is set to epoch zero', async t => {
+  const pb = new grpcPuppet.CallPayloadResponse()
+  pb.setId('call-6')
+  pb.setStarter('alice')
+  pb.setParticipantsList([ 'alice', 'bob' ])
+  pb.setMedia(grpcPuppet.CallType.CALL_TYPE_VOICE)
+  pb.setStartTime(timestampFromMilliseconds(1_700_000_000_000))
+  pb.setEndTime(timestampFromMilliseconds(0))
+
+  const payload = await callParser(pb.toObject())
+
+  t.equal(payload.endTime, 0, 'endTime is 0 when explicitly set to epoch zero on the wire')
+})

package/src/client/payload-store.ts

@@ -164,8 +164,8 @@ class PayloadStore {
      * Huan(202108): `fs.rm` was introduced from Node.js v14.14
      *  https://nodejs.org/api/fs.html#fs_fspromises_rm_path_options
      */
-    await fs.promises.rmdir(this.storeDir, {
-      // force: true,
+    await fs.promises.rm(this.storeDir, {
+      force: true,
       recursive: true,
     })
   }

package/src/client/puppet-service.spec.ts

@@ -1,6 +1,8 @@
 #!/usr/bin/env -S node --no-warnings --loader ts-node/esm
 
-import { test }  from 'tstest'
+import {
+  test,
+}  from 'tstest'
 import getPort from 'get-port'
 
 import { PuppetMock } from '@juzi/wechaty-puppet-mock'

package/src/client/puppet-service.ts

@@ -31,7 +31,10 @@ import {
 
 // import type { Subscription }  from 'rxjs'
 
-import { millisecondsFromTimestamp }  from '../pure-functions/timestamp.js'
+import {
+  millisecondsFromTimestamp,
+  millisecondsFromTimestampObject,
+}                                     from '../pure-functions/timestamp.js'
 
 import {
   uuidifyFileBoxGrpc,
@@ -50,7 +53,8 @@ import { packageJson }  from '../package-json.js'
 
 import { GrpcManager }  from './grpc-manager.js'
 import { PayloadStore } from './payload-store.js'
-import { OptionalBooleanUnwrapper, OptionalBooleanWrapper, callRecordPbToPayload, channelPayloadToPb, channelPbToPayload, chatHistoryPbToPayload, contactPbToPayload, postPayloadToPb, roomMemberPbToPayload, urlLinkPbToPayload, channelCardPayloadToPb, channelCardPbToPayload } from '../utils/pb-payload-helper.js'
+import { OptionalBooleanUnwrapper, OptionalBooleanWrapper, callRecordPbToPayload, channelPayloadToPb, channelPbToPayload, chatHistoryPbToPayload, contactPbToPayload, postPayloadToPb, roomMemberPbToPayload, urlLinkPbToPayload, channelCardPayloadToPb, channelCardPbToPayload, miniProgramPayloadToPb, urlLinkPayloadToPb, locationPayloadToPb } from '../utils/pb-payload-helper.js'
+import { puppetCallMediaTypeToGrpc, grpcCallTypeToPuppetMedia } from '../utils/call-media-mapping.js'
 import type { MessageBroadcastTargets } from '@juzi/wechaty-puppet/dist/esm/src/schemas/message.js'
 import { timeoutPromise } from 'gerror'
 import { BooleanIndicator } from 'state-switch'
@@ -72,6 +76,34 @@ export type PuppetServiceOptions = PUPPET.PuppetOptions & {
 const ResetLoginTimeout = 30 * 1000
 const ResetReadyTimeout = 20 * 1000 // normally ready comes 15 seconds after login
 
+type MessageBatchSendResponse = Awaited<ReturnType<PUPPET.impls.PuppetInterface['messageBatchSendText']>>
+
+type GrpcUnaryMethod<Request, Response> = {
+  (request: Request, callback: (error: Error | null, response: Response) => void): unknown,
+}
+
+type GrpcBatchResult = {
+  getConversationId(): string,
+  getError(): string,
+  getId(): string,
+}
+
+type GrpcBatchResponse<Result extends GrpcBatchResult> = {
+  getResultsList(): Result[],
+}
+
+function grpcBatchResultsToPayload<Result extends GrpcBatchResult> (
+  response: GrpcBatchResponse<Result>,
+): MessageBatchSendResponse {
+  return {
+    results: response.getResultsList().map(result => ({
+      conversationId : result.getConversationId(),
+      error          : result.getError() || undefined,
+      id             : result.getId() || undefined,
+    })),
+  }
+}
+
 class PuppetService extends PUPPET.Puppet {
 
   static override readonly VERSION = VERSION
@@ -125,6 +157,17 @@ class PuppetService extends PUPPET.Puppet {
     return JSON.stringify(normalizedFileBox)
   }
 
+  private async grpcUnary<Request, Response> (
+    method  : GrpcUnaryMethod<Request, Response>,
+    request : Request,
+  ): Promise<Response> {
+    const promisified = util.promisify(
+      method.bind(this.grpcManager.client),
+    ) as (request: Request) => Promise<Response>
+
+    return promisified(request)
+  }
+
   override name () {
     return packageJson.name || 'wechaty-puppet-service'
   }
@@ -384,6 +427,9 @@ class PuppetService extends PUPPET.Puppet {
       case grpcPuppet.EventType.EVENT_TYPE_VERIFY_SLIDE:
         this.emit('verify-slide', JSON.parse(payload) as PUPPET.payloads.EventVerifySlide)
         break
+      case grpcPuppet.EventType.EVENT_TYPE_CALL:
+        this.emit('call', JSON.parse(payload) as PUPPET.payloads.EventCall)
+        break
 
       default:
         // Huan(202003): in default, the `type` type should be `never`, please check.
@@ -461,7 +507,7 @@ class PuppetService extends PUPPET.Puppet {
   ): Promise<void> {
     log.verbose('PuppetService', 'fastDirty(%s<%s>, %s)', PUPPET.types.Dirty[payloadType], payloadType, payloadId)
 
-    const dirtyMap = {
+    const dirtyMap: Partial<Record<PUPPET.types.Dirty, (id: string) => Promise<unknown>>> = {
       [PUPPET.types.Dirty.Contact]:      async (id: string) => this._payloadStore.contact?.delete(id),
       [PUPPET.types.Dirty.Friendship]:   async (_: string) => {},
       [PUPPET.types.Dirty.Message]:      async (_: string) => {},
@@ -474,7 +520,7 @@ class PuppetService extends PUPPET.Puppet {
     }
 
     try {
-      await dirtyMap[payloadType](payloadId)
+      await dirtyMap[payloadType]?.(payloadId)
     } catch (error) {
       this.emit('error', error)
     }
@@ -1114,6 +1160,189 @@ class PuppetService extends PUPPET.Puppet {
     return payload
   }
 
+  override async callInvite (
+    contactIds: string[],
+    media: PUPPET.types.CallMediaType,
+  ): Promise<string> {
+    log.verbose('PuppetService', 'callInvite(%s, %s)', contactIds, media)
+
+    const request = new grpcPuppet.CallInviteRequest()
+    request.setContactIdsList(contactIds)
+    request.setMedia(puppetCallMediaTypeToGrpc(media))
+
+    const response = await util.promisify(
+      this.grpcManager.client.callInvite
+        .bind(this.grpcManager.client),
+    )(request)
+
+    const callId = response.getCallId()
+    if (!callId) {
+      throw new Error('callInvite: puppet server returned empty call_id')
+    }
+
+    return callId
+  }
+
+  override async callAdd (
+    callId: string,
+    contactIds: string[],
+  ): Promise<void> {
+    log.verbose('PuppetService', 'callAdd(%s, %s)', callId, contactIds)
+
+    const request = new grpcPuppet.CallAddRequest()
+    request.setCallId(callId)
+    request.setContactIdsList(contactIds)
+
+    await this.grpcUnary(
+      this.grpcManager.client.callAdd,
+      request,
+    )
+  }
+
+  override async callAccept (
+    callId: string,
+  ): Promise<void> {
+    log.verbose('PuppetService', 'callAccept(%s)', callId)
+
+    const request = new grpcPuppet.CallAcceptRequest()
+    request.setCallId(callId)
+
+    await this.grpcUnary(
+      this.grpcManager.client.callAccept,
+      request,
+    )
+  }
+
+  override async callReject (
+    callId: string,
+    reason?: string,
+  ): Promise<void> {
+    log.verbose('PuppetService', 'callReject(%s, %s)', callId, reason)
+
+    const request = new grpcPuppet.CallRejectRequest()
+    request.setCallId(callId)
+    if (reason !== undefined && reason !== '') {
+      request.setReason(reason)
+    }
+
+    await this.grpcUnary(
+      this.grpcManager.client.callReject,
+      request,
+    )
+  }
+
+  override async callCancel (
+    callId: string,
+  ): Promise<void> {
+    log.verbose('PuppetService', 'callCancel(%s)', callId)
+
+    const request = new grpcPuppet.CallCancelRequest()
+    request.setCallId(callId)
+
+    await this.grpcUnary(
+      this.grpcManager.client.callCancel,
+      request,
+    )
+  }
+
+  override async callHangup (
+    callId: string,
+    reason?: string,
+  ): Promise<void> {
+    log.verbose('PuppetService', 'callHangup(%s, %s)', callId, reason)
+
+    const request = new grpcPuppet.CallHangupRequest()
+    request.setCallId(callId)
+    if (reason !== undefined && reason !== '') {
+      request.setReason(reason)
+    }
+
+    await this.grpcUnary(
+      this.grpcManager.client.callHangup,
+      request,
+    )
+  }
+
+  override async callMediaEndpoint (
+    callId: string,
+  ): Promise<PUPPET.payloads.CallMediaEndpoint> {
+    log.verbose('PuppetService', 'callMediaEndpoint(%s)', callId)
+
+    const request = new grpcPuppet.CallMediaEndpointRequest()
+    request.setCallId(callId)
+
+    const response = await util.promisify(
+      this.grpcManager.client.callMediaEndpoint
+        .bind(this.grpcManager.client),
+    )(request)
+
+    const url   = response.getUrl()
+    const token = response.getToken()
+    if (!url || !token) {
+      throw new Error('callMediaEndpoint: puppet server returned empty url or token')
+    }
+
+    const payload: PUPPET.payloads.CallMediaEndpoint = {
+      url,
+      token,
+    }
+
+    if (response.hasExpiresAt()) {
+      payload.expiresAt = millisecondsFromTimestamp(response.getExpiresAt()!)
+    }
+
+    const protocol = response.getProtocol()
+    if (protocol) {
+      payload.protocol = protocol
+    }
+
+    return payload
+  }
+
+  override async callRawPayload (callId: string): Promise<grpcPuppet.CallPayloadResponse.AsObject> {
+    log.verbose('PuppetService', 'callRawPayload(%s)', callId)
+
+    const request = new grpcPuppet.CallPayloadRequest()
+    request.setId(callId)
+
+    const response = await util.promisify(
+      this.grpcManager.client.callPayload
+        .bind(this.grpcManager.client),
+    )(request)
+
+    return response.toObject()
+  }
+
+  override async callRawPayloadParser (rawPayload: grpcPuppet.CallPayloadResponse.AsObject): Promise<PUPPET.payloads.Call> {
+    log.verbose('PuppetService', 'callRawPayloadParser({id:%s})', rawPayload.id)
+
+    const media = grpcCallTypeToPuppetMedia(rawPayload.media)
+    if (media === undefined) {
+      throw new Error('callRawPayloadParser: media is required (got CALL_TYPE_UNKNOWN on the wire)')
+    }
+
+    if (rawPayload.startTime === undefined) {
+      throw new Error('callRawPayloadParser: startTime is required')
+    }
+
+    const payload: PUPPET.payloads.Call = {
+      id           : rawPayload.id,
+      participants : rawPayload.participantsList,
+      media,
+      startTime    : millisecondsFromTimestampObject(rawPayload.startTime),
+    }
+
+    if (rawPayload.starter) {
+      payload.starter = rawPayload.starter
+    }
+
+    if (rawPayload.endTime !== undefined) {
+      payload.endTime = millisecondsFromTimestampObject(rawPayload.endTime)
+    }
+
+    return payload
+  }
+
   override async messageChatHistory (
     messageId: string,
   ): Promise<PUPPET.payloads.ChatHistory[]> {
@@ -1487,6 +1716,211 @@ class PuppetService extends PUPPET.Puppet {
     }
   }
 
+  override async messageBatchSendText (
+    conversationIds : string[],
+    text            : string,
+    batchTaskId?    : string,
+  ): Promise<MessageBatchSendResponse> {
+    log.verbose('PuppetService', 'messageBatchSendText(%s)', conversationIds.join(','))
+
+    const request = new grpcPuppet.MessageBatchSendTextRequest()
+    request.setConversationIdsList(conversationIds)
+    request.setText(text)
+    if (batchTaskId) {
+      request.setBatchTaskId(batchTaskId)
+    }
+
+    const response = await this.grpcUnary<grpcPuppet.MessageBatchSendTextRequest, grpcPuppet.MessageBatchSendTextResponse>(
+      this.grpcManager.client.messageBatchSendText,
+      request,
+    )
+
+    return grpcBatchResultsToPayload(response)
+  }
+
+  override async messageBatchSendFile (
+    conversationIds : string[],
+    fileBox         : FileBoxInterface,
+    batchTaskId?    : string,
+  ): Promise<MessageBatchSendResponse> {
+    log.verbose('PuppetService', 'messageBatchSendFile(%s)', conversationIds.join(','))
+
+    const request = new grpcPuppet.MessageBatchSendFileRequest()
+    request.setConversationIdsList(conversationIds)
+    request.setFileBox(await this.serializeFileBox(fileBox))
+    if (batchTaskId) {
+      request.setBatchTaskId(batchTaskId)
+    }
+
+    const response = await this.grpcUnary<grpcPuppet.MessageBatchSendFileRequest, grpcPuppet.MessageBatchSendFileResponse>(
+      this.grpcManager.client.messageBatchSendFile,
+      request,
+    )
+
+    return grpcBatchResultsToPayload(response)
+  }
+
+  override async messageBatchForward (
+    conversationIds : string[],
+    messageIds      : string | string[],
+    batchTaskId?    : string,
+  ): Promise<MessageBatchSendResponse> {
+    log.verbose('PuppetService', 'messageBatchForward(%s, %s)', conversationIds.join(','), messageIds)
+
+    const request = new grpcPuppet.MessageBatchForwardRequest()
+    request.setConversationIdsList(conversationIds)
+    if (Array.isArray(messageIds)) {
+      request.setMessageIdsList(messageIds)
+      if (messageIds.length === 1) {
+        request.setMessageId(messageIds[0] as string)
+      }
+    } else {
+      request.setMessageId(messageIds)
+    }
+    if (batchTaskId) {
+      request.setBatchTaskId(batchTaskId)
+    }
+
+    const response = await this.grpcUnary<grpcPuppet.MessageBatchForwardRequest, grpcPuppet.MessageBatchForwardResponse>(
+      this.grpcManager.client.messageBatchForward,
+      request,
+    )
+
+    return grpcBatchResultsToPayload(response)
+  }
+
+  override async messageBatchSendContact (
+    conversationIds : string[],
+    contactId       : string,
+    batchTaskId?    : string,
+  ): Promise<MessageBatchSendResponse> {
+    log.verbose('PuppetService', 'messageBatchSendContact(%s, %s)', conversationIds.join(','), contactId)
+
+    const request = new grpcPuppet.MessageBatchSendContactRequest()
+    request.setConversationIdsList(conversationIds)
+    request.setContactId(contactId)
+    if (batchTaskId) {
+      request.setBatchTaskId(batchTaskId)
+    }
+
+    const response = await this.grpcUnary<grpcPuppet.MessageBatchSendContactRequest, grpcPuppet.MessageBatchSendContactResponse>(
+      this.grpcManager.client.messageBatchSendContact,
+      request,
+    )
+
+    return grpcBatchResultsToPayload(response)
+  }
+
+  override async messageBatchSendUrl (
+    conversationIds : string[],
+    urlLinkPayload  : PUPPET.payloads.UrlLink,
+    batchTaskId?    : string,
+  ): Promise<MessageBatchSendResponse> {
+    log.verbose('PuppetService', 'messageBatchSendUrl(%s)', conversationIds.join(','))
+
+    const request = new grpcPuppet.MessageBatchSendUrlRequest()
+    request.setConversationIdsList(conversationIds)
+    request.setUrlLink(urlLinkPayloadToPb(grpcPuppet, urlLinkPayload))
+    if (batchTaskId) {
+      request.setBatchTaskId(batchTaskId)
+    }
+
+    const response = await this.grpcUnary<grpcPuppet.MessageBatchSendUrlRequest, grpcPuppet.MessageBatchSendUrlResponse>(
+      this.grpcManager.client.messageBatchSendUrl,
+      request,
+    )
+
+    return grpcBatchResultsToPayload(response)
+  }
+
+  override async messageBatchSendMiniProgram (
+    conversationIds     : string[],
+    miniProgramPayload  : PUPPET.payloads.MiniProgram,
+    batchTaskId?        : string,
+  ): Promise<MessageBatchSendResponse> {
+    log.verbose('PuppetService', 'messageBatchSendMiniProgram(%s)', conversationIds.join(','))
+
+    const request = new grpcPuppet.MessageBatchSendMiniProgramRequest()
+    request.setConversationIdsList(conversationIds)
+    request.setMiniProgram(miniProgramPayloadToPb(grpcPuppet, miniProgramPayload))
+    if (batchTaskId) {
+      request.setBatchTaskId(batchTaskId)
+    }
+
+    const response = await this.grpcUnary<grpcPuppet.MessageBatchSendMiniProgramRequest, grpcPuppet.MessageBatchSendMiniProgramResponse>(
+      this.grpcManager.client.messageBatchSendMiniProgram,
+      request,
+    )
+
+    return grpcBatchResultsToPayload(response)
+  }
+
+  override async messageBatchSendLocation (
+    conversationIds  : string[],
+    locationPayload  : PUPPET.payloads.Location,
+    batchTaskId?     : string,
+  ): Promise<MessageBatchSendResponse> {
+    log.verbose('PuppetService', 'messageBatchSendLocation(%s)', conversationIds.join(','))
+
+    const request = new grpcPuppet.MessageBatchSendLocationRequest()
+    request.setConversationIdsList(conversationIds)
+    request.setLocation(locationPayloadToPb(grpcPuppet, locationPayload))
+    if (batchTaskId) {
+      request.setBatchTaskId(batchTaskId)
+    }
+
+    const response = await this.grpcUnary<grpcPuppet.MessageBatchSendLocationRequest, grpcPuppet.MessageBatchSendLocationResponse>(
+      this.grpcManager.client.messageBatchSendLocation,
+      request,
+    )
+
+    return grpcBatchResultsToPayload(response)
+  }
+
+  override async messageBatchSendChannel (
+    conversationIds : string[],
+    channelPayload  : PUPPET.payloads.Channel,
+    batchTaskId?    : string,
+  ): Promise<MessageBatchSendResponse> {
+    log.verbose('PuppetService', 'messageBatchSendChannel(%s)', conversationIds.join(','))
+
+    const request = new grpcPuppet.MessageBatchSendChannelRequest()
+    request.setConversationIdsList(conversationIds)
+    request.setChannel(channelPayloadToPb(grpcPuppet, channelPayload))
+    if (batchTaskId) {
+      request.setBatchTaskId(batchTaskId)
+    }
+
+    const response = await this.grpcUnary<grpcPuppet.MessageBatchSendChannelRequest, grpcPuppet.MessageBatchSendChannelResponse>(
+      this.grpcManager.client.messageBatchSendChannel,
+      request,
+    )
+
+    return grpcBatchResultsToPayload(response)
+  }
+
+  override async messageBatchSendChannelCard (
+    conversationIds     : string[],
+    channelCardPayload  : PUPPET.payloads.ChannelCard,
+    batchTaskId?        : string,
+  ): Promise<MessageBatchSendResponse> {
+    log.verbose('PuppetService', 'messageBatchSendChannelCard(%s)', conversationIds.join(','))
+
+    const request = new grpcPuppet.MessageBatchSendChannelCardRequest()
+    request.setConversationIdsList(conversationIds)
+    request.setChannelCard(channelCardPayloadToPb(grpcPuppet, channelCardPayload))
+    if (batchTaskId) {
+      request.setBatchTaskId(batchTaskId)
+    }
+
+    const response = await this.grpcUnary<grpcPuppet.MessageBatchSendChannelCardRequest, grpcPuppet.MessageBatchSendChannelCardResponse>(
+      this.grpcManager.client.messageBatchSendChannelCard,
+      request,
+    )
+
+    return grpcBatchResultsToPayload(response)
+  }
+
   override async messageSendFile (
     conversationId : string,
     fileBox        : FileBoxInterface,

package/src/package-json.ts

@@ -4,7 +4,7 @@
 import type { PackageJson } from 'type-fest'
 export const packageJson: PackageJson = {
   "name": "@juzi/wechaty-puppet-service",
-  "version": "1.0.113",
+  "version": "1.0.115",
   "description": "Puppet Service for Wechaty",
   "type": "module",
   "exports": {
@@ -55,7 +55,7 @@ export const packageJson: PackageJson = {
     "@chatie/eslint-config": "^1.0.4",
     "@chatie/semver": "^0.4.7",
     "@chatie/tsconfig": "^4.6.3",
-    "@juzi/wechaty-puppet": "^1.0.125",
+    "@juzi/wechaty-puppet": "^1.0.138",
     "@juzi/wechaty-puppet-mock": "^1.0.1",
     "@swc/core": "1.3.39",
     "@types/google-protobuf": "^3.15.5",
@@ -74,10 +74,10 @@ export const packageJson: PackageJson = {
     "why-is-node-running": "^2.2.1"
   },
   "peerDependencies": {
-    "@juzi/wechaty-puppet": "^1.0.84"
+    "@juzi/wechaty-puppet": "^1.0.138"
   },
   "dependencies": {
-    "@juzi/wechaty-grpc": "^1.0.100",
+    "@juzi/wechaty-grpc": "^1.0.102",
     "clone-class": "^1.1.1",
     "ducks": "^1.0.2",
     "file-box": "^1.5.5",