@juzi/wechaty-puppet-service 1.0.113 → 1.0.115

package/src/pure-functions/timestamp.spec.ts

@@ -0,0 +1,56 @@
+#!/usr/bin/env -S node --no-warnings --loader ts-node/esm
+
+import { test } from 'tstest'
+
+import {
+  millisecondsFromTimestamp,
+  millisecondsFromTimestampObject,
+  timestampFromMilliseconds,
+}                             from './timestamp.js'
+
+/**
+ * 1. ms -> Timestamp -> ms round-trips for millisecond-aligned values.
+ */
+test('timestampFromMilliseconds <-> millisecondsFromTimestamp round-trip', async t => {
+  const cases = [
+    0,
+    1_000,
+    1_700_000_000_000,
+    1_700_000_000_123,
+  ]
+
+  for (const ms of cases) {
+    const roundTripped = millisecondsFromTimestamp(timestampFromMilliseconds(ms))
+    t.equal(roundTripped, ms, `round-trip identity for ${ms}ms`)
+  }
+})
+
+/**
+ * 2. The plain-object variant agrees with the instance variant for the same
+ *    Timestamp (this is the `toObject()` shape used by callRawPayloadParser).
+ */
+test('millisecondsFromTimestampObject matches millisecondsFromTimestamp', async t => {
+  const cases = [
+    0,
+    1_000,
+    1_700_000_000_123,
+  ]
+
+  for (const ms of cases) {
+    const timestamp = timestampFromMilliseconds(ms)
+    const fromInstance = millisecondsFromTimestamp(timestamp)
+    const fromObject   = millisecondsFromTimestampObject(timestamp.toObject())
+    t.equal(fromObject, fromInstance, `instance and object conversion agree for ${ms}ms`)
+  }
+})
+
+/**
+ * 3. Sub-millisecond nanos are rounded to the nearest millisecond.
+ */
+test('millisecondsFromTimestampObject rounds nanos to nearest millisecond', async t => {
+  t.equal(millisecondsFromTimestampObject({ seconds: 1, nanos: 0 }),         1000, 'no nanos')
+  t.equal(millisecondsFromTimestampObject({ seconds: 1, nanos: 499_999 }),   1000, '0.499ms rounds down')
+  t.equal(millisecondsFromTimestampObject({ seconds: 1, nanos: 500_000 }),   1001, '0.5ms rounds up')
+  t.equal(millisecondsFromTimestampObject({ seconds: 1, nanos: 999_999 }),   1001, '0.999ms rounds up')
+  t.equal(millisecondsFromTimestampObject({ seconds: 0, nanos: 123_000_000 }), 123, '123ms from nanos')
+})

package/src/pure-functions/timestamp.ts

@@ -22,7 +22,26 @@ function millisecondsFromTimestamp (timestamp: ReturnType<typeof timestampFromMi
   return seconds * 1000 + nanos / 1000000
 }
 
+/**
+ * Plain `{ seconds, nanos }` shape produced by a protobuf `Message.toObject()`
+ * for a `google.protobuf.Timestamp` field.
+ */
+type TimestampObject = {
+  seconds: number,
+  nanos: number,
+}
+
+/**
+ * Same conversion as `millisecondsFromTimestamp`, but for the plain
+ * `{ seconds, nanos }` shape produced by `Message.toObject()` rather than a
+ * Timestamp class instance. Nanos are rounded to the nearest millisecond.
+ */
+function millisecondsFromTimestampObject (timestamp: TimestampObject): number {
+  return timestamp.seconds * 1000 + Math.round(timestamp.nanos / 1000000)
+}
+
 export {
   millisecondsFromTimestamp,
+  millisecondsFromTimestampObject,
   timestampFromMilliseconds,
 }

package/src/server/event-stream-manager.ts

@@ -322,6 +322,13 @@ class EventStreamManager {
           this.offCallbackList.push(off)
           break
         }
+        case 'call': {
+          const listener = (payload: PUPPET.payloads.EventCall) => this.grpcEmit(grpcPuppet.EventType.EVENT_TYPE_CALL, payload)
+          this.puppet.on('call', listener)
+          const off = () => this.puppet.off('call', listener)
+          this.offCallbackList.push(off)
+          break
+        }
         case 'reset':
           // the `reset` event should be dealed internally, should not send out
           break

package/src/server/puppet-implementation.ts

@@ -44,8 +44,39 @@ import { log } from '../config.js'
 import { grpcError }          from './grpc-error.js'
 import { EventStreamManager } from './event-stream-manager.js'
 import { OptionalBooleanUnwrapper, OptionalBooleanWrapper, callRecordPayloadToPb, channelPayloadToPb, chatHistoryPayloadToPb, postPbToPayload, urlLinkPayloadToPb, channelCardPayloadToPb } from '../utils/pb-payload-helper.js'
+import { grpcCallTypeToPuppetMedia, puppetCallMediaTypeToGrpc } from '../utils/call-media-mapping.js'
 import { TextContentType } from '@juzi/wechaty-puppet/types'
 
+type MessageBatchSendResponse = Awaited<ReturnType<PUPPET.impls.PuppetInterface['messageBatchSendText']>>
+
+type GrpcBatchResult = {
+  setConversationId(value: string): void,
+  setError(value: string): void,
+  setId(value: string): void,
+}
+
+type GrpcBatchResponse<Result extends GrpcBatchResult> = {
+  setResultsList(value: Result[]): void,
+}
+
+const setGrpcBatchResults = <Result extends GrpcBatchResult> (
+  response      : GrpcBatchResponse<Result>,
+  ResultClass   : new () => Result,
+  payload       : MessageBatchSendResponse,
+): void => {
+  response.setResultsList(payload.results.map(result => {
+    const pbResult = new ResultClass()
+    pbResult.setConversationId(result.conversationId)
+    if (result.id) {
+      pbResult.setId(result.id)
+    }
+    if (result.error) {
+      pbResult.setError(result.error)
+    }
+    return pbResult
+  }))
+}
+
 function puppetImplementation (
   puppet      : PUPPET.impls.PuppetInterface,
   FileBoxUuid : typeof FileBox,
@@ -1251,6 +1282,180 @@ function puppetImplementation (
       }
     },
 
+    messageBatchSendText: async (call, callback) => {
+      log.verbose('PuppetServiceImpl', 'messageBatchSendText()')
+
+      try {
+        const results = await puppet.messageBatchSendText(
+          call.request.getConversationIdsList(),
+          call.request.getText(),
+          call.request.getBatchTaskId(),
+        )
+        const response = new grpcPuppet.MessageBatchSendTextResponse()
+        setGrpcBatchResults(response, grpcPuppet.MessageBatchSendTextResponse.Result, results)
+        return callback(null, response)
+      } catch (e) {
+        return grpcError('messageBatchSendText', e, callback)
+      }
+    },
+
+    messageBatchSendFile: async (call, callback) => {
+      log.verbose('PuppetServiceImpl', 'messageBatchSendFile()')
+
+      try {
+        const results = await puppet.messageBatchSendFile(
+          call.request.getConversationIdsList(),
+          FileBoxUuid.fromJSON(call.request.getFileBox()),
+          call.request.getBatchTaskId(),
+        )
+        const response = new grpcPuppet.MessageBatchSendFileResponse()
+        setGrpcBatchResults(response, grpcPuppet.MessageBatchSendFileResponse.Result, results)
+        return callback(null, response)
+      } catch (e) {
+        return grpcError('messageBatchSendFile', e, callback)
+      }
+    },
+
+    messageBatchForward: async (call, callback) => {
+      log.verbose('PuppetServiceImpl', 'messageBatchForward()')
+
+      try {
+        const messageIds = call.request.getMessageIdsList()
+        const results = await puppet.messageBatchForward(
+          call.request.getConversationIdsList(),
+          messageIds.length > 0 ? messageIds : call.request.getMessageId(),
+          call.request.getBatchTaskId(),
+        )
+        const response = new grpcPuppet.MessageBatchForwardResponse()
+        setGrpcBatchResults(response, grpcPuppet.MessageBatchForwardResponse.Result, results)
+        return callback(null, response)
+      } catch (e) {
+        return grpcError('messageBatchForward', e, callback)
+      }
+    },
+
+    messageBatchSendContact: async (call, callback) => {
+      log.verbose('PuppetServiceImpl', 'messageBatchSendContact()')
+
+      try {
+        const results = await puppet.messageBatchSendContact(
+          call.request.getConversationIdsList(),
+          call.request.getContactId(),
+          call.request.getBatchTaskId(),
+        )
+        const response = new grpcPuppet.MessageBatchSendContactResponse()
+        setGrpcBatchResults(response, grpcPuppet.MessageBatchSendContactResponse.Result, results)
+        return callback(null, response)
+      } catch (e) {
+        return grpcError('messageBatchSendContact', e, callback)
+      }
+    },
+
+    messageBatchSendUrl: async (call, callback) => {
+      log.verbose('PuppetServiceImpl', 'messageBatchSendUrl()')
+
+      try {
+        const payload = call.request.getUrlLink()?.toObject()
+        if (!payload) {
+          throw new Error('no url link payload found')
+        }
+        const results = await puppet.messageBatchSendUrl(
+          call.request.getConversationIdsList(),
+          payload,
+          call.request.getBatchTaskId(),
+        )
+        const response = new grpcPuppet.MessageBatchSendUrlResponse()
+        setGrpcBatchResults(response, grpcPuppet.MessageBatchSendUrlResponse.Result, results)
+        return callback(null, response)
+      } catch (e) {
+        return grpcError('messageBatchSendUrl', e, callback)
+      }
+    },
+
+    messageBatchSendMiniProgram: async (call, callback) => {
+      log.verbose('PuppetServiceImpl', 'messageBatchSendMiniProgram()')
+
+      try {
+        const payload = call.request.getMiniProgram()?.toObject()
+        if (!payload) {
+          throw new Error('no mini program payload found')
+        }
+        const results = await puppet.messageBatchSendMiniProgram(
+          call.request.getConversationIdsList(),
+          payload,
+          call.request.getBatchTaskId(),
+        )
+        const response = new grpcPuppet.MessageBatchSendMiniProgramResponse()
+        setGrpcBatchResults(response, grpcPuppet.MessageBatchSendMiniProgramResponse.Result, results)
+        return callback(null, response)
+      } catch (e) {
+        return grpcError('messageBatchSendMiniProgram', e, callback)
+      }
+    },
+
+    messageBatchSendLocation: async (call, callback) => {
+      log.verbose('PuppetServiceImpl', 'messageBatchSendLocation()')
+
+      try {
+        const payload = call.request.getLocation()?.toObject()
+        if (!payload) {
+          throw new Error('no location payload found')
+        }
+        const results = await puppet.messageBatchSendLocation(
+          call.request.getConversationIdsList(),
+          payload,
+          call.request.getBatchTaskId(),
+        )
+        const response = new grpcPuppet.MessageBatchSendLocationResponse()
+        setGrpcBatchResults(response, grpcPuppet.MessageBatchSendLocationResponse.Result, results)
+        return callback(null, response)
+      } catch (e) {
+        return grpcError('messageBatchSendLocation', e, callback)
+      }
+    },
+
+    messageBatchSendChannel: async (call, callback) => {
+      log.verbose('PuppetServiceImpl', 'messageBatchSendChannel()')
+
+      try {
+        const payload = call.request.getChannel()?.toObject()
+        if (!payload) {
+          throw new Error('no channel payload found')
+        }
+        const results = await puppet.messageBatchSendChannel(
+          call.request.getConversationIdsList(),
+          payload,
+          call.request.getBatchTaskId(),
+        )
+        const response = new grpcPuppet.MessageBatchSendChannelResponse()
+        setGrpcBatchResults(response, grpcPuppet.MessageBatchSendChannelResponse.Result, results)
+        return callback(null, response)
+      } catch (e) {
+        return grpcError('messageBatchSendChannel', e, callback)
+      }
+    },
+
+    messageBatchSendChannelCard: async (call, callback) => {
+      log.verbose('PuppetServiceImpl', 'messageBatchSendChannelCard()')
+
+      try {
+        const payload = call.request.getChannelCard()?.toObject()
+        if (!payload) {
+          throw new Error('no channel card payload found')
+        }
+        const results = await puppet.messageBatchSendChannelCard(
+          call.request.getConversationIdsList(),
+          payload,
+          call.request.getBatchTaskId(),
+        )
+        const response = new grpcPuppet.MessageBatchSendChannelCardResponse()
+        setGrpcBatchResults(response, grpcPuppet.MessageBatchSendChannelCardResponse.Result, results)
+        return callback(null, response)
+      } catch (e) {
+        return grpcError('messageBatchSendChannelCard', e, callback)
+      }
+    },
+
     messageSendUrl: async (call, callback) => {
       log.verbose('PuppetServiceImpl', 'messageSendUrl()')
 
@@ -1494,9 +1699,11 @@ function puppetImplementation (
         const inviteOnly = call.request.getInviteOnly()
         const quoteIds = call.request.getQuoteIdsList()
 
-        const target = contactIds.length > 0 ? contactIds : contactId
-
-        await puppet.roomAdd(roomId, target, inviteOnly, quoteIds)
+        if (contactIds.length > 1) {
+          await puppet.roomAddV2(roomId, contactIds, inviteOnly, quoteIds)
+        } else {
+          await puppet.roomAdd(roomId, contactId || contactIds[0] || '', inviteOnly, quoteIds)
+        }
 
         return callback(null, new grpcPuppet.RoomAddResponse())
 
@@ -2752,6 +2959,180 @@ function puppetImplementation (
 
     },
 
+    callInvite: async (call, callback) => {
+      log.verbose('PuppetServiceImpl', 'callInvite()')
+
+      try {
+        const contactIds = call.request.getContactIdsList()
+        if (contactIds.length === 0) {
+          throw new Error('callInvite: contact_ids is required')
+        }
+        const media = grpcCallTypeToPuppetMedia(call.request.getMedia())
+        if (media === undefined) {
+          throw new Error('callInvite: media is required (got CALL_TYPE_UNKNOWN on the wire)')
+        }
+
+        const callId = await puppet.callInvite(contactIds, media)
+        if (!callId) {
+          throw new Error('callInvite: puppet returned empty callId')
+        }
+
+        const response = new grpcPuppet.CallInviteResponse()
+        response.setCallId(callId)
+
+        return callback(null, response)
+      } catch (e) {
+        return grpcError('callInvite', e, callback)
+      }
+    },
+
+    callAdd: async (call, callback) => {
+      log.verbose('PuppetServiceImpl', 'callAdd()')
+
+      try {
+        const callId = call.request.getCallId()
+        if (!callId) {
+          throw new Error('callAdd: call_id is required')
+        }
+        const contactIds = call.request.getContactIdsList()
+        if (contactIds.length === 0) {
+          throw new Error('callAdd: contact_ids is required')
+        }
+
+        await puppet.callAdd(callId, contactIds)
+
+        return callback(null, new grpcPuppet.CallAddResponse())
+      } catch (e) {
+        return grpcError('callAdd', e, callback)
+      }
+    },
+
+    callAccept: async (call, callback) => {
+      log.verbose('PuppetServiceImpl', 'callAccept()')
+
+      try {
+        const callId = call.request.getCallId()
+        if (!callId) {
+          throw new Error('callAccept: call_id is required')
+        }
+
+        await puppet.callAccept(callId)
+
+        return callback(null, new grpcPuppet.CallAcceptResponse())
+      } catch (e) {
+        return grpcError('callAccept', e, callback)
+      }
+    },
+
+    callReject: async (call, callback) => {
+      log.verbose('PuppetServiceImpl', 'callReject()')
+
+      try {
+        const callId = call.request.getCallId()
+        if (!callId) {
+          throw new Error('callReject: call_id is required')
+        }
+        const reason = call.request.getReason() || undefined
+
+        await puppet.callReject(callId, reason)
+
+        return callback(null, new grpcPuppet.CallRejectResponse())
+      } catch (e) {
+        return grpcError('callReject', e, callback)
+      }
+    },
+
+    callCancel: async (call, callback) => {
+      log.verbose('PuppetServiceImpl', 'callCancel()')
+
+      try {
+        const callId = call.request.getCallId()
+        if (!callId) {
+          throw new Error('callCancel: call_id is required')
+        }
+
+        await puppet.callCancel(callId)
+
+        return callback(null, new grpcPuppet.CallCancelResponse())
+      } catch (e) {
+        return grpcError('callCancel', e, callback)
+      }
+    },
+
+    callHangup: async (call, callback) => {
+      log.verbose('PuppetServiceImpl', 'callHangup()')
+
+      try {
+        const callId = call.request.getCallId()
+        if (!callId) {
+          throw new Error('callHangup: call_id is required')
+        }
+        const reason = call.request.getReason() || undefined
+
+        await puppet.callHangup(callId, reason)
+
+        return callback(null, new grpcPuppet.CallHangupResponse())
+      } catch (e) {
+        return grpcError('callHangup', e, callback)
+      }
+    },
+
+    callMediaEndpoint: async (call, callback) => {
+      log.verbose('PuppetServiceImpl', 'callMediaEndpoint()')
+
+      try {
+        const callId = call.request.getCallId()
+        if (!callId) {
+          throw new Error('callMediaEndpoint: call_id is required')
+        }
+
+        const payload = await puppet.callMediaEndpoint(callId)
+
+        const response = new grpcPuppet.CallMediaEndpointResponse()
+        response.setUrl(payload.url)
+        response.setToken(payload.token)
+        if (payload.expiresAt !== undefined) {
+          response.setExpiresAt(timestampFromMilliseconds(payload.expiresAt))
+        }
+        if (payload.protocol) {
+          response.setProtocol(payload.protocol)
+        }
+
+        return callback(null, response)
+      } catch (e) {
+        return grpcError('callMediaEndpoint', e, callback)
+      }
+    },
+
+    callPayload: async (call, callback) => {
+      log.verbose('PuppetServiceImpl', 'callPayload()')
+
+      try {
+        const callId = call.request.getId()
+        if (!callId) {
+          throw new Error('callPayload: id is required')
+        }
+
+        const payload = await puppet.callPayload(callId)
+
+        const response = new grpcPuppet.CallPayloadResponse()
+        response.setId(payload.id)
+        if (payload.starter) {
+          response.setStarter(payload.starter)
+        }
+        response.setParticipantsList(payload.participants)
+        response.setMedia(puppetCallMediaTypeToGrpc(payload.media))
+        response.setStartTime(timestampFromMilliseconds(payload.startTime))
+        if (payload.endTime !== undefined) {
+          response.setEndTime(timestampFromMilliseconds(payload.endTime))
+        }
+
+        return callback(null, response)
+      } catch (e) {
+        return grpcError('callPayload', e, callback)
+      }
+    },
+
     upload: async (call, callback) => {
       log.verbose('PuppetServiceImpl', 'upload()')
 

package/src/utils/call-media-mapping.spec.ts

@@ -0,0 +1,53 @@
+#!/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 {
+  puppetCallMediaTypeToGrpc,
+  grpcCallTypeToPuppetMedia,
+} from './call-media-mapping.js'
+
+/**
+ * 1. CallMediaType Audio and Video round-trip: PUPPET -> gRPC -> PUPPET === original.
+ */
+test('CallMediaType: Audio and Video survive a round-trip through gRPC', async t => {
+  const mediaCases = [
+    PUPPET.types.CallMediaType.Audio,
+    PUPPET.types.CallMediaType.Video,
+  ] as const
+
+  for (const media of mediaCases) {
+    const grpcValue    = puppetCallMediaTypeToGrpc(media)
+    const roundTripped = grpcCallTypeToPuppetMedia(grpcValue)
+    t.equal(roundTripped, media, `round-trip should be identity for CallMediaType.${media}`)
+  }
+})
+
+/**
+ * 2. Each direction maps to the expected concrete enum member.
+ */
+test('puppetCallMediaTypeToGrpc: Audio -> VOICE, Video -> VIDEO', async t => {
+  t.equal(puppetCallMediaTypeToGrpc(PUPPET.types.CallMediaType.Audio), grpcPuppet.CallType.CALL_TYPE_VOICE, 'Audio maps to CALL_TYPE_VOICE')
+  t.equal(puppetCallMediaTypeToGrpc(PUPPET.types.CallMediaType.Video), grpcPuppet.CallType.CALL_TYPE_VIDEO, 'Video maps to CALL_TYPE_VIDEO')
+})
+
+/**
+ * 3. CALL_TYPE_UNKNOWN (wire zero value) maps to undefined so callers can reject it explicitly.
+ */
+test('grpcCallTypeToPuppetMedia: CALL_TYPE_UNKNOWN returns undefined', async t => {
+  const result = grpcCallTypeToPuppetMedia(grpcPuppet.CallType.CALL_TYPE_UNKNOWN)
+  t.equal(result, undefined, 'CALL_TYPE_UNKNOWN should map to undefined')
+})
+
+/**
+ * 4. Unknown numeric values not in the proto enum throw rather than silently returning garbage.
+ */
+test('grpcCallTypeToPuppetMedia: unknown value 999 throws', async t => {
+  t.throws(
+    () => grpcCallTypeToPuppetMedia(999),
+    'should throw for unknown CallType value 999',
+  )
+})

package/src/utils/call-media-mapping.ts

@@ -0,0 +1,35 @@
+import * as PUPPET              from '@juzi/wechaty-puppet'
+import { puppet as grpcPuppet } from '@juzi/wechaty-grpc'
+
+type GrpcCallType = grpcPuppet.CallTypeMap[keyof grpcPuppet.CallTypeMap]
+
+/**
+ * PUPPET CallMediaType (string enum) -> gRPC CallType (number enum).
+ * The `never` check in default guarantees exhaustiveness at compile time,
+ * while the throw still guards against untyped callers at runtime.
+ * media is required per upstream contract: every call invite must carry a media type.
+ */
+export function puppetCallMediaTypeToGrpc (media: PUPPET.types.CallMediaType): GrpcCallType {
+  switch (media) {
+    case PUPPET.types.CallMediaType.Audio: return grpcPuppet.CallType.CALL_TYPE_VOICE
+    case PUPPET.types.CallMediaType.Video: return grpcPuppet.CallType.CALL_TYPE_VIDEO
+    default: {
+      const exhaustive: never = media
+      throw new Error(`puppetCallMediaTypeToGrpc: unknown CallMediaType "${String(exhaustive)}"`)
+    }
+  }
+}
+
+/**
+ * gRPC CallType (number enum) -> PUPPET CallMediaType (string enum).
+ * CALL_TYPE_UNKNOWN (wire zero value) maps to undefined so callers can reject it explicitly.
+ */
+export function grpcCallTypeToPuppetMedia (grpcType: number): PUPPET.types.CallMediaType | undefined {
+  switch (grpcType) {
+    case grpcPuppet.CallType.CALL_TYPE_UNKNOWN: return undefined
+    case grpcPuppet.CallType.CALL_TYPE_VOICE:   return PUPPET.types.CallMediaType.Audio
+    case grpcPuppet.CallType.CALL_TYPE_VIDEO:   return PUPPET.types.CallMediaType.Video
+    default:
+      throw new Error(`grpcCallTypeToPuppetMedia: unknown gRPC CallType value ${grpcType}`)
+  }
+}