@juzi/wechaty-puppet-service 1.0.128 → 1.0.130

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@juzi/wechaty-puppet-service",
-  "version": "1.0.128",
+  "version": "1.0.130",
   "description": "Puppet Service for Wechaty",
   "type": "module",
   "exports": {
@@ -51,7 +51,7 @@
     "@chatie/eslint-config": "^1.0.4",
     "@chatie/semver": "^0.4.7",
     "@chatie/tsconfig": "^4.6.3",
-    "@juzi/wechaty-puppet": "^1.0.155",
+    "@juzi/wechaty-puppet": "^1.0.157",
     "@juzi/wechaty-puppet-mock": "^1.0.1",
     "@swc/core": "1.3.39",
     "@types/google-protobuf": "^3.15.5",
@@ -71,10 +71,10 @@
     "why-is-node-running": "^2.2.1"
   },
   "peerDependencies": {
-    "@juzi/wechaty-puppet": "^1.0.155"
+    "@juzi/wechaty-puppet": "^1.0.157"
   },
   "dependencies": {
-    "@juzi/wechaty-grpc": "^1.0.107",
+    "@juzi/wechaty-grpc": "^1.0.109",
     "clone-class": "^1.1.1",
     "ducks": "^1.0.2",
     "file-box": "^1.5.5",

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

@@ -154,6 +154,153 @@ test('callInviteWithMedia rejects when the server returns an empty call_id', asy
   )
 })
 
+let orgBroadcastTestId = 0
+
+function createOrgBroadcastPuppet (
+  payloadResponse?: grpcPuppet.OrgBroadcastPayloadResponse,
+): { puppet: PuppetService, executeRequestList: grpcPuppet.OrgBroadcastExecuteRequest[] } {
+  const puppet = new PuppetService({
+    token: `org-broadcast-test-${orgBroadcastTestId++}`,
+  })
+
+  const executeRequestList: grpcPuppet.OrgBroadcastExecuteRequest[] = []
+
+  ;(puppet as any)._grpcManager = {
+    client: {
+      orgBroadcastExecute: (
+        request  : grpcPuppet.OrgBroadcastExecuteRequest,
+        callback : (error: null | Error, response: grpcPuppet.OrgBroadcastExecuteResponse) => void,
+      ) => {
+        executeRequestList.push(request)
+        callback(null, new grpcPuppet.OrgBroadcastExecuteResponse())
+      },
+      orgBroadcastPayload: (
+        request  : grpcPuppet.OrgBroadcastPayloadRequest,
+        callback : (error: null | Error, response?: grpcPuppet.OrgBroadcastPayloadResponse) => void,
+      ) => {
+        void request
+        callback(null, payloadResponse)
+      },
+    },
+  }
+
+  return { puppet, executeRequestList }
+}
+
+test('orgBroadcastPayload maps every response field onto OrgBroadcastPayload', async t => {
+  const roomTarget = new grpcPuppet.OrgBroadcastTarget()
+  roomTarget.setRoomId('R:room-1')
+  roomTarget.setStatus(grpcPuppet.OrgBroadcastTargetStatus.ORG_BROADCAST_TARGET_STATUS_UNCONFIRMED)
+
+  const sentRoomTarget = new grpcPuppet.OrgBroadcastTarget()
+  sentRoomTarget.setRoomId('R:room-2')
+  sentRoomTarget.setStatus(grpcPuppet.OrgBroadcastTargetStatus.ORG_BROADCAST_TARGET_STATUS_SENT)
+
+  const response = new grpcPuppet.OrgBroadcastPayloadResponse()
+  response.setId('4728994241730369413')
+  response.setSendType(2)
+  response.setConversationType(1)
+  response.setCreatorId('creator-1')
+  response.setExecTime(1758600000000)
+  response.setStatus(3)
+  response.setCanCancel(true)
+  response.setAllowSelect(true)
+  response.setSent(false)
+  response.setTotalCount(7)
+  response.setSentCount(5)
+  response.setContentListJson('[{"contentType":2}]')
+  response.setTargetsList([ roomTarget, sentRoomTarget ])
+
+  const { puppet } = createOrgBroadcastPuppet(response)
+  const payload = await puppet.orgBroadcastPayload('4728994241730369413')
+
+  t.same(payload, {
+    id               : '4728994241730369413',
+    sendType         : 2,
+    conversationType : 1,
+    creatorId        : 'creator-1',
+    execTime         : 1758600000000,
+    status           : 3,
+    canCancel        : true,
+    allowSelect      : true,
+    sent             : false,
+    totalCount       : 7,
+    sentCount        : 5,
+    contentListJson  : '[{"contentType":2}]',
+    targets          : [
+      { contactId: undefined, roomId: 'R:room-1', status: 4 },
+      { contactId: undefined, roomId: 'R:room-2', status: 1 },
+    ],
+  }, 'maps every field and drops the empty contact_id of room targets')
+})
+
+test('orgBroadcastPayload maps empty creator_id and contact targets', async t => {
+  const contactTarget = new grpcPuppet.OrgBroadcastTarget()
+  contactTarget.setContactId('contact-1')
+
+  const response = new grpcPuppet.OrgBroadcastPayloadResponse()
+  response.setId('org-broadcast-2')
+  response.setTargetsList([ contactTarget ])
+
+  const { puppet } = createOrgBroadcastPuppet(response)
+  const payload = await puppet.orgBroadcastPayload('org-broadcast-2')
+
+  t.equal(payload.creatorId, undefined, 'maps an empty creator_id to undefined')
+  t.same(payload.targets, [ { contactId: 'contact-1', roomId: undefined, status: 0 } ], 'drops the empty room_id of contact targets')
+})
+
+test('orgBroadcastExecute sends all targets as an empty target_ids when targetIds is omitted', async t => {
+  const { puppet, executeRequestList } = createOrgBroadcastPuppet()
+
+  await puppet.orgBroadcastExecute('org-broadcast-1')
+
+  t.equal(executeRequestList.length, 1, 'sends exactly one request')
+  t.equal(executeRequestList[0]!.getId(), 'org-broadcast-1', 'maps orgBroadcastId onto id')
+  t.same(executeRequestList[0]!.getTargetIdsList(), [], 'leaves target_ids empty')
+})
+
+test('orgBroadcastExecute forwards the selected targets', async t => {
+  const { puppet, executeRequestList } = createOrgBroadcastPuppet()
+
+  await puppet.orgBroadcastExecute('org-broadcast-1', [ 'contact-1', 'contact-2' ])
+
+  t.same(executeRequestList[0]!.getTargetIdsList(), [ 'contact-1', 'contact-2' ], 'maps targetIds onto target_ids')
+})
+
+test('orgBroadcastExecute rejects an explicit empty targetIds instead of sending to all targets', async t => {
+  const { puppet, executeRequestList } = createOrgBroadcastPuppet()
+
+  await t.rejects(
+    puppet.orgBroadcastExecute('org-broadcast-1', []),
+    /targetIds is empty/,
+    'does not turn an empty selection into sending to all targets',
+  )
+  t.equal(executeRequestList.length, 0, 'never reaches the server')
+})
+
+test('org broadcast grpc events are emitted as puppet events', async t => {
+  const { puppet } = createOrgBroadcastPuppet()
+
+  const createdSpy = sinon.spy()
+  const sentSpy    = sinon.spy()
+  puppet.on('org-broadcast-created', createdSpy)
+  puppet.on('org-broadcast-sent', sentSpy)
+
+  const createdEvent = new grpcPuppet.EventResponse()
+  createdEvent.setType(grpcPuppet.EventType.EVENT_TYPE_ORG_BROADCAST_CREATED)
+  createdEvent.setPayload(JSON.stringify({ orgBroadcastId: 'org-broadcast-1', messageId: 'message-1' }))
+
+  const sentEvent = new grpcPuppet.EventResponse()
+  sentEvent.setType(grpcPuppet.EventType.EVENT_TYPE_ORG_BROADCAST_SENT)
+  sentEvent.setPayload(JSON.stringify({ orgBroadcastId: 'org-broadcast-1' }))
+
+  await (puppet as any).onGrpcStreamEvent(createdEvent)
+  await (puppet as any).onGrpcStreamEvent(sentEvent)
+
+  t.same(createdSpy.args[0], [ { orgBroadcastId: 'org-broadcast-1', messageId: 'message-1' } ], 'emits org-broadcast-created')
+  t.same(sentSpy.args[0], [ { orgBroadcastId: 'org-broadcast-1' } ], 'emits org-broadcast-sent')
+})
+
 test('version()', async t => {
   const puppet = new PuppetService({
     token: 'test',

package/src/client/puppet-service.ts

@@ -429,9 +429,18 @@ 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_SAME_NET_VERIFY:
+        this.emit('same-net-verify', JSON.parse(payload) as PUPPET.payloads.EventSameNetVerify)
+        break
       case grpcPuppet.EventType.EVENT_TYPE_CALL:
         this.emit('call', JSON.parse(payload) as PUPPET.payloads.EventCall)
         break
+      case grpcPuppet.EventType.EVENT_TYPE_ORG_BROADCAST_CREATED:
+        this.emit('org-broadcast-created', JSON.parse(payload) as PUPPET.payloads.EventOrgBroadcastCreated)
+        break
+      case grpcPuppet.EventType.EVENT_TYPE_ORG_BROADCAST_SENT:
+        this.emit('org-broadcast-sent', JSON.parse(payload) as PUPPET.payloads.EventOrgBroadcastSent)
+        break
 
       default:
         // Huan(202003): in default, the `type` type should be `never`, please check.
@@ -3725,6 +3734,54 @@ class PuppetService extends PUPPET.Puppet {
     return result
   }
 
+  override async orgBroadcastPayload (orgBroadcastId: string): Promise<PUPPET.payloads.OrgBroadcast> {
+    this.log.verbose('PuppetService', 'orgBroadcastPayload(%s)', orgBroadcastId)
+
+    const request = new grpcPuppet.OrgBroadcastPayloadRequest()
+    request.setId(orgBroadcastId)
+
+    const response = await util.promisify(
+      this.grpcManager.client.orgBroadcastPayload.bind(this.grpcManager.client),
+    )(request)
+
+    return {
+      id               : response.getId(),
+      sendType         : response.getSendType(),
+      conversationType : response.getConversationType() as PUPPET.types.OrgBroadcastConversationType,
+      creatorId        : response.getCreatorId() || undefined,
+      execTime         : response.getExecTime(),
+      status           : response.getStatus(),
+      canCancel        : response.getCanCancel(),
+      allowSelect      : response.getAllowSelect(),
+      sent             : response.getSent(),
+      totalCount       : response.getTotalCount(),
+      sentCount        : response.getSentCount(),
+      contentListJson  : response.getContentListJson(),
+      targets          : response.getTargetsList().map(targetPb => ({
+        contactId : targetPb.getContactId() || undefined,
+        roomId    : targetPb.getRoomId() || undefined,
+        status    : targetPb.getStatus() as number as PUPPET.types.OrgBroadcastTargetStatus,
+      })),
+    }
+  }
+
+  override async orgBroadcastExecute (orgBroadcastId: string, targetIds?: string[]): Promise<void> {
+    this.log.verbose('PuppetService', 'orgBroadcastExecute(%s, %s)', orgBroadcastId, targetIds?.length)
+
+    // on the wire an empty target_ids means all targets, so an explicit empty list must not pass through
+    if (targetIds && targetIds.length === 0) {
+      throw new Error('targetIds is empty, omit it to send to all targets of the org broadcast')
+    }
+
+    const request = new grpcPuppet.OrgBroadcastExecuteRequest()
+    request.setId(orgBroadcastId)
+    request.setTargetIdsList(targetIds ?? [])
+
+    await util.promisify(
+      this.grpcManager.client.orgBroadcastExecute.bind(this.grpcManager.client),
+    )(request)
+  }
+
   healthCheckInterval?: NodeJS.Timeout
   startHealthCheck () {
     this.healthCheckInterval = setInterval(() => {

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.128",
+  "version": "1.0.130",
   "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.155",
+    "@juzi/wechaty-puppet": "^1.0.157",
     "@juzi/wechaty-puppet-mock": "^1.0.1",
     "@swc/core": "1.3.39",
     "@types/google-protobuf": "^3.15.5",
@@ -75,10 +75,10 @@ export const packageJson: PackageJson = {
     "why-is-node-running": "^2.2.1"
   },
   "peerDependencies": {
-    "@juzi/wechaty-puppet": "^1.0.155"
+    "@juzi/wechaty-puppet": "^1.0.157"
   },
   "dependencies": {
-    "@juzi/wechaty-grpc": "^1.0.107",
+    "@juzi/wechaty-grpc": "^1.0.109",
     "clone-class": "^1.1.1",
     "ducks": "^1.0.2",
     "file-box": "^1.5.5",

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

@@ -0,0 +1,30 @@
+#!/usr/bin/env -S node --no-warnings --loader ts-node/esm
+
+import {
+  sinon,
+  test,
+}  from 'tstest'
+
+import { puppet as grpcPuppet } from '@juzi/wechaty-grpc'
+import { PuppetMock } from '@juzi/wechaty-puppet-mock'
+
+import { EventStreamManager } from './event-stream-manager.js'
+
+test('org broadcast puppet events are forwarded as their own grpc event types', async t => {
+  const puppet  = new PuppetMock() as any
+  const manager = new EventStreamManager(puppet)
+
+  const write = sinon.spy()
+  ;(manager as any).eventStream = { write }
+  manager.connectPuppetEventToStreamingCall()
+
+  puppet.emit('org-broadcast-created', { orgBroadcastId: 'org-broadcast-1', messageId: 'message-1' })
+  puppet.emit('org-broadcast-sent', { orgBroadcastId: 'org-broadcast-1' })
+
+  const [ created, sent ] = write.args.map(args => args[0] as grpcPuppet.EventResponse)
+
+  t.equal(created?.getType(), grpcPuppet.EventType.EVENT_TYPE_ORG_BROADCAST_CREATED, 'forwards org-broadcast-created as EVENT_TYPE_ORG_BROADCAST_CREATED')
+  t.same(JSON.parse(created!.getPayload()), { orgBroadcastId: 'org-broadcast-1', messageId: 'message-1' }, 'keeps the created payload')
+  t.equal(sent?.getType(), grpcPuppet.EventType.EVENT_TYPE_ORG_BROADCAST_SENT, 'forwards org-broadcast-sent as EVENT_TYPE_ORG_BROADCAST_SENT')
+  t.same(JSON.parse(sent!.getPayload()), { orgBroadcastId: 'org-broadcast-1' }, 'keeps the sent payload')
+})

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

@@ -322,6 +322,13 @@ class EventStreamManager {
           this.offCallbackList.push(off)
           break
         }
+        case 'same-net-verify': {
+          const listener = (payload: PUPPET.payloads.EventSameNetVerify) => this.grpcEmit(grpcPuppet.EventType.EVENT_TYPE_SAME_NET_VERIFY, payload)
+          this.puppet.on('same-net-verify', listener)
+          const off = () => this.puppet.off('same-net-verify', listener)
+          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)
@@ -329,6 +336,20 @@ class EventStreamManager {
           this.offCallbackList.push(off)
           break
         }
+        case 'org-broadcast-created': {
+          const listener = (payload: PUPPET.payloads.EventOrgBroadcastCreated) => this.grpcEmit(grpcPuppet.EventType.EVENT_TYPE_ORG_BROADCAST_CREATED, payload)
+          this.puppet.on('org-broadcast-created', listener)
+          const off = () => this.puppet.off('org-broadcast-created', listener)
+          this.offCallbackList.push(off)
+          break
+        }
+        case 'org-broadcast-sent': {
+          const listener = (payload: PUPPET.payloads.EventOrgBroadcastSent) => this.grpcEmit(grpcPuppet.EventType.EVENT_TYPE_ORG_BROADCAST_SENT, payload)
+          this.puppet.on('org-broadcast-sent', listener)
+          const off = () => this.puppet.off('org-broadcast-sent', 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.spec.ts

@@ -119,3 +119,130 @@ test('callInviteWithMedia rejects an empty callId returned by the puppet', async
 
   t.match(error?.message, /empty callId/, 'does not pass an unusable empty callId back on the wire')
 })
+
+function invokeOrgBroadcast<Req, Res> (
+  puppet  : any,
+  method  : 'orgBroadcastPayload' | 'orgBroadcastExecute',
+  request : Req,
+): Promise<{ error: null | Error, response: null | Res }> {
+  const impl = puppetImplementation(puppet, FileBox)
+
+  return new Promise(resolve => {
+    void (impl[method] as any)(
+      { request } as any,
+      ((error: any, response: any) => resolve({ error, response })) as any,
+    )
+  })
+}
+
+test('orgBroadcastPayload serializes every payload field onto the response', async t => {
+  const puppet = new PuppetMock() as any
+  const stub   = sinon.stub().resolves({
+    id               : 'org-broadcast-1',
+    sendType         : 2,
+    conversationType : 1,
+    creatorId        : 'creator-1',
+    execTime         : 1758600000000,
+    status           : 3,
+    canCancel        : true,
+    allowSelect      : true,
+    sent             : false,
+    totalCount       : 7,
+    sentCount        : 5,
+    contentListJson  : '[{"contentType":2}]',
+    targets          : [ { roomId: 'R:1', status: 4 }, { roomId: 'R:2', status: 1 } ],
+  })
+  puppet.orgBroadcastPayload = stub
+
+  const request = new grpcPuppet.OrgBroadcastPayloadRequest()
+  request.setId('org-broadcast-1')
+
+  const { error, response } = await invokeOrgBroadcast<grpcPuppet.OrgBroadcastPayloadRequest, grpcPuppet.OrgBroadcastPayloadResponse>(puppet, 'orgBroadcastPayload', request)
+
+  t.equal(error, null, 'returns without error')
+  t.same(stub.args[0], [ 'org-broadcast-1' ], 'passes the id to the puppet')
+  t.same(response?.toObject(), {
+    id              : 'org-broadcast-1',
+    sendType        : 2,
+    conversationType: 1,
+    creatorId       : 'creator-1',
+    execTime        : 1758600000000,
+    status          : 3,
+    canCancel       : true,
+    allowSelect     : true,
+    sent            : false,
+    totalCount      : 7,
+    sentCount       : 5,
+    contentListJson : '[{"contentType":2}]',
+    targetsList     : [
+      { contactId: '', roomId: 'R:1', status: 4 },
+      { contactId: '', roomId: 'R:2', status: 1 },
+    ],
+  }, 'serializes every field')
+})
+
+test('orgBroadcastPayload serializes a missing creatorId and contact targets as empty strings', async t => {
+  const puppet = new PuppetMock() as any
+  puppet.orgBroadcastPayload = sinon.stub().resolves({
+    id               : 'org-broadcast-2',
+    sendType         : 0,
+    conversationType : 0,
+    execTime         : 0,
+    status           : 0,
+    canCancel        : false,
+    allowSelect      : false,
+    sent             : false,
+    totalCount       : 1,
+    sentCount        : 0,
+    contentListJson  : '[]',
+    targets          : [ { contactId: 'contact-1', status: 0 } ],
+  })
+
+  const request = new grpcPuppet.OrgBroadcastPayloadRequest()
+  request.setId('org-broadcast-2')
+
+  const { response } = await invokeOrgBroadcast<grpcPuppet.OrgBroadcastPayloadRequest, grpcPuppet.OrgBroadcastPayloadResponse>(puppet, 'orgBroadcastPayload', request)
+
+  t.equal(response?.getCreatorId(), '', 'serializes a missing creatorId as empty')
+  t.same(response?.getTargetsList()[0]?.toObject(), { contactId: 'contact-1', roomId: '', status: 0 }, 'leaves room_id empty for a contact target')
+})
+
+test('orgBroadcastExecute turns an empty target_ids into sending to all targets', async t => {
+  const puppet = new PuppetMock() as any
+  const stub   = sinon.stub().resolves()
+  puppet.orgBroadcastExecute = stub
+
+  const request = new grpcPuppet.OrgBroadcastExecuteRequest()
+  request.setId('org-broadcast-1')
+
+  const { error } = await invokeOrgBroadcast(puppet, 'orgBroadcastExecute', request)
+
+  t.equal(error, null, 'returns without error')
+  t.same(stub.args[0], [ 'org-broadcast-1', undefined ], 'omits targetIds')
+})
+
+test('orgBroadcastExecute forwards the selected target_ids', async t => {
+  const puppet = new PuppetMock() as any
+  const stub   = sinon.stub().resolves()
+  puppet.orgBroadcastExecute = stub
+
+  const request = new grpcPuppet.OrgBroadcastExecuteRequest()
+  request.setId('org-broadcast-1')
+  request.setTargetIdsList([ 'contact-1' ])
+
+  await invokeOrgBroadcast(puppet, 'orgBroadcastExecute', request)
+
+  t.same(stub.args[0], [ 'org-broadcast-1', [ 'contact-1' ] ], 'passes targetIds through')
+})
+
+test('orgBroadcastExecute reports a puppet failure as a grpc error', async t => {
+  const puppet = new PuppetMock() as any
+  puppet.orgBroadcastExecute = sinon.stub().rejects(new Error('broadcast not found'))
+
+  const request = new grpcPuppet.OrgBroadcastExecuteRequest()
+  request.setId('org-broadcast-missing')
+
+  const { error } = await invokeOrgBroadcast(puppet, 'orgBroadcastExecute', request)
+
+  t.match(error?.message, /broadcast not found/, 'surfaces the puppet error')
+})

package/src/server/puppet-implementation.ts

@@ -3017,6 +3017,56 @@ function puppetImplementation (
       }
     },
 
+    orgBroadcastPayload: async (call, callback) => {
+      log.verbose('PuppetServiceImpl', 'orgBroadcastPayload()')
+
+      try {
+        const orgBroadcastId = call.request.getId()
+        const payload = await puppet.orgBroadcastPayload(orgBroadcastId)
+
+        const response = new grpcPuppet.OrgBroadcastPayloadResponse()
+        response.setId(payload.id)
+        response.setSendType(payload.sendType)
+        response.setConversationType(payload.conversationType)
+        response.setCreatorId(payload.creatorId ?? '')
+        response.setExecTime(payload.execTime)
+        response.setStatus(payload.status)
+        response.setCanCancel(payload.canCancel)
+        response.setAllowSelect(payload.allowSelect)
+        response.setSent(payload.sent)
+        response.setTotalCount(payload.totalCount)
+        response.setSentCount(payload.sentCount)
+        response.setContentListJson(payload.contentListJson)
+        response.setTargetsList(payload.targets.map(target => {
+          const targetPb = new grpcPuppet.OrgBroadcastTarget()
+          targetPb.setContactId(target.contactId ?? '')
+          targetPb.setRoomId(target.roomId ?? '')
+          targetPb.setStatus(target.status as number as grpcPuppet.OrgBroadcastTargetStatusMap[keyof grpcPuppet.OrgBroadcastTargetStatusMap])
+          return targetPb
+        }))
+
+        return callback(null, response)
+      } catch (e) {
+        return grpcError('orgBroadcastPayload', e, callback)
+      }
+    },
+
+    orgBroadcastExecute: async (call, callback) => {
+      log.verbose('PuppetServiceImpl', 'orgBroadcastExecute()')
+
+      try {
+        const orgBroadcastId = call.request.getId()
+        const targetIds = call.request.getTargetIdsList()
+
+        // an empty target_ids on the wire means all targets of the org broadcast
+        await puppet.orgBroadcastExecute(orgBroadcastId, targetIds.length ? targetIds : undefined)
+
+        return callback(null, new grpcPuppet.OrgBroadcastExecuteResponse())
+      } catch (e) {
+        return grpcError('orgBroadcastExecute', e, callback)
+      }
+    },
+
     download: async (call) => {
       log.verbose('PuppetServiceImpl', 'download()')