@juzi/wechaty-puppet-service 1.0.0

package/src/package-json.spec.ts

@@ -0,0 +1,10 @@
+#!/usr/bin/env -S node --no-warnings --loader ts-node/esm
+
+import { test } from 'tstest'
+
+import { packageJson } from './package-json.js'
+
+test('Make sure the packageJson is fresh in source code', async t => {
+  const keyNum = Object.keys(packageJson).length
+  t.equal(keyNum, 0, 'packageJson should be empty in source code, only updated before publish to NPM')
+})

package/src/package-json.ts

@@ -0,0 +1,101 @@
+/**
+ * This file was auto generated from scripts/generate-version.sh
+ */
+import type { PackageJson } from 'type-fest'
+export const packageJson: PackageJson = {
+  "name": "@juzi/wechaty-puppet-service",
+  "version": "1.0.0",
+  "description": "Puppet Service for Wechaty",
+  "type": "module",
+  "exports": {
+    ".": {
+      "import": "./dist/esm/src/mod.js",
+      "require": "./dist/cjs/src/mod.js"
+    }
+  },
+  "typings": "./dist/esm/src/mod.d.ts",
+  "engines": {
+    "node": ">=16",
+    "npm": ">=7"
+  },
+  "scripts": {
+    "build": "tsc && tsc -p tsconfig.cjs.json",
+    "clean": "shx rm -fr dist/*",
+    "dist": "npm-run-all clean build dist:commonjs",
+    "dist:commonjs": "jq -n \"{ type: \\\"commonjs\\\" }\" > dist/cjs/package.json",
+    "lint": "npm-run-all lint:es lint:ts lint:md",
+    "lint:md": "markdownlint README.md",
+    "lint:ts": "tsc --isolatedModules --noEmit",
+    "start": "cross-env NODE_OPTIONS=\"--no-warnings --loader=ts-node/esm\" node examples/ding-dong-bot.ts",
+    "test": "npm run lint && npm run test:unit",
+    "test:pack": "bash -x scripts/npm-pack-testing.sh",
+    "test:unit": "cross-env NODE_OPTIONS=\"--no-warnings --loader=ts-node/esm\" TAP_TIMEOUT=60 tap \"src/**/*.spec.ts\" \"tests/**/*.spec.ts\"",
+    "lint:es": "eslint --ignore-pattern fixtures/ \"src/**/*.ts\" \"tests/**/*.ts\""
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/juzibot/wechaty-puppet-service.git"
+  },
+  "keywords": [
+    "chatie",
+    "wechaty",
+    "chatbot",
+    "bot",
+    "grpc",
+    "wechat",
+    "sdk"
+  ],
+  "author": "Huan LI <zixia@zixia.net>",
+  "license": "Apache-2.0",
+  "bugs": {
+    "url": "https://github.com/juzibot/wechaty-puppet-service/issues"
+  },
+  "homepage": "https://github.com/juzibot/wechaty-puppet-service#readme",
+  "devDependencies": {
+    "@chatie/eslint-config": "^1.0.4",
+    "@chatie/semver": "^0.4.7",
+    "@chatie/tsconfig": "^4.6.3",
+    "@types/google-protobuf": "^3.15.5",
+    "@types/lru-cache": "^7.5.0",
+    "@types/semver": "^7.3.9",
+    "@types/temp": "^0.9.1",
+    "@types/uuid": "^8.3.4",
+    "@types/ws": "^8.5.3",
+    "get-port": "^6.1.2",
+    "temp": "^0.9.4",
+    "typed-emitter": "^1.5.0-from-event",
+    "utility-types": "^3.10.0",
+    "wechaty-puppet-mock": "^1.18.2",
+    "why-is-node-running": "^2.2.1"
+  },
+  "peerDependencies": {
+    "@juzi/wechaty-puppet": "1.0.0"
+  },
+  "dependencies": {
+    "clone-class": "^1.1.1",
+    "ducks": "^1.0.2",
+    "file-box": "^1.5.5",
+    "flash-store": "^1.3.4",
+    "gerror": "^1.0.16",
+    "redux-observable": "^2.0.0",
+    "rxjs": "^7.5.5",
+    "semver": "^7.3.5",
+    "stronger-typed-streams": "^0.2.0",
+    "uuid": "^8.3.2",
+    "@juzi/wechaty-grpc": "1.0.0",
+    "wechaty-redux": "^1.20.2",
+    "wechaty-token": "^1.0.6"
+  },
+  "publishConfig": {
+    "access": "public",
+    "tag": "next"
+  },
+  "files": [
+    "bin/",
+    "dist/",
+    "src/"
+  ],
+  "tap": {
+    "check-coverage": false
+  }
+} as any

package/src/pure-functions/timestamp.ts

@@ -0,0 +1,28 @@
+import { Timestamp } from '@juzi/wechaty-grpc'
+
+/**
+ * https://github.com/protocolbuffers/protobuf/blob/b6993a90605cde15ba004e0287bcb078b0f3959d/src/google/protobuf/timestamp.proto#L86-L91
+ */
+
+function timestampFromMilliseconds (milliseconds: number) {
+  const seconds = Math.floor(milliseconds / 1000)
+  const nanos   = (milliseconds % 1000) * 1000000
+
+  const timestamp = new Timestamp()
+  timestamp.setSeconds(seconds)
+  timestamp.setNanos(nanos)
+
+  return timestamp
+}
+
+function millisecondsFromTimestamp (timestamp: ReturnType<typeof timestampFromMilliseconds>) {
+  const seconds = timestamp.getSeconds()
+  const nanos   = timestamp.getNanos()
+
+  return seconds * 1000 + nanos / 1000000
+}
+
+export {
+  millisecondsFromTimestamp,
+  timestampFromMilliseconds,
+}

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

@@ -0,0 +1,383 @@
+/**
+ *   Wechaty Open Source Software - https://github.com/wechaty
+ *
+ *   @copyright 2016 Huan LI (李卓桓) <https://github.com/huan>, and
+ *                   Wechaty Contributors <https://github.com/wechaty>.
+ *
+ *   Licensed under the Apache License, Version 2.0 (the "License");
+ *   you may not use this file except in compliance with the License.
+ *   You may obtain a copy of the License at
+ *
+ *       http://www.apache.org/licenses/LICENSE-2.0
+ *
+ *   Unless required by applicable law or agreed to in writing, software
+ *   distributed under the License is distributed on an "AS IS" BASIS,
+ *   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ *   See the License for the specific language governing permissions and
+ *   limitations under the License.
+ *
+ */
+import {
+  puppet as grpcPuppet,
+  grpc,
+}                                   from '@juzi/wechaty-grpc'
+
+import * as PUPPET from '@juzi/wechaty-puppet'
+
+import { log } from '../config.js'
+import {
+  EventTypeRev,
+}                     from '../event-type-rev.js'
+
+class EventStreamManager {
+
+  protected eventStream: undefined | grpc.ServerWritableStream<grpcPuppet.EventRequest, grpcPuppet.EventResponse>
+
+  private puppetListening = false
+
+  constructor (
+    public puppet: PUPPET.impls.PuppetInterface,
+  ) {
+    log.verbose('EventStreamManager', 'constructor(%s)', puppet)
+  }
+
+  public busy (): boolean {
+    return !!this.eventStream
+  }
+
+  public start (
+    stream: grpc.ServerWritableStream<grpcPuppet.EventRequest, grpcPuppet.EventResponse>,
+  ): void {
+    log.verbose('EventStreamManager', 'start(stream)')
+
+    if (this.eventStream) {
+      throw new Error('can not set twice')
+    }
+    this.eventStream = stream
+
+    const removeAllListeners = this.connectPuppetEventToStreamingCall()
+    this.onStreamingCallEnd(removeAllListeners)
+
+    /**
+     * Huan(202108):
+     *  We emit a hearbeat at the beginning of the connect
+     *    to identicate that the connection is successeed.
+     *
+     *  Our client (wechaty-puppet-service client) will wait for the heartbeat
+     *    when it connect to the server.
+     *
+     *  If the server does not send the heartbeat,
+     *    then the client will wait for a 5 seconds timeout
+     *    for compatible the community gRPC puppet service providers like paimon.
+     */
+    const connectSuccessHeartbeatPayload = {
+      data: 'Wechaty Puppet gRPC stream connect successfully',
+    } as PUPPET.payloads.EventHeartbeat
+    this.grpcEmit(
+      grpcPuppet.EventType.EVENT_TYPE_HEARTBEAT,
+      connectSuccessHeartbeatPayload,
+    )
+
+    /**
+      * We emit the login event if current the puppet is logged in.
+      */
+    if (this.puppet.isLoggedIn) {
+      log.verbose('EventStreamManager', 'start() puppet is logged in, emit a login event for downstream')
+
+      const payload = {
+        contactId: this.puppet.currentUserId,
+      } as PUPPET.payloads.EventLogin
+
+      this.grpcEmit(grpcPuppet.EventType.EVENT_TYPE_LOGIN, payload)
+    }
+
+    if (this.puppet.readyIndicator.value()) {
+      log.verbose('EventStreamManager', 'start() puppet is ready, emit a ready event for downstream after 100ms delay')
+
+      const payload = {
+        data: 'ready',
+      } as PUPPET.payloads.EventReady
+
+      // no need to make this function async since it won't effect the start process of eventStreamManager
+      setTimeout(() => {
+        this.grpcEmit(grpcPuppet.EventType.EVENT_TYPE_READY, payload)
+      }, 100)
+    }
+  }
+
+  public stop (): void {
+    log.verbose('EventStreamManager', 'stop()')
+
+    if (!this.eventStream) {
+      throw new Error('no this.eventStream')
+    }
+
+    this.eventStream.end()
+    this.eventStream = undefined
+  }
+
+  public grpcEmit (
+    type : grpcPuppet.EventTypeMap[keyof grpcPuppet.EventTypeMap],  // https://stackoverflow.com/a/49286056/1123955
+    obj  : object,
+  ): void {
+    log.verbose('EventStreamManager', 'grpcEmit(%s[%s], %s)',
+      EventTypeRev[type],
+      type,
+      JSON.stringify(obj),
+    )
+
+    const response = new grpcPuppet.EventResponse()
+
+    response.setType(type)
+    response.setPayload(
+      JSON.stringify(obj),
+    )
+
+    if (this.eventStream) {
+      this.eventStream.write(response)
+    } else {
+      /**
+        * Huan(202108): TODO: add a queue for store a maximum number of responses before the stream get connected
+        */
+      log.warn('EventStreamManager', 'grpcEmit(%s, %s) this.eventStream is undefined.',
+        type,
+        JSON.stringify(obj),
+      )
+    }
+  }
+
+  public connectPuppetEventToStreamingCall (): () => void {
+    log.verbose('EventStreamManager', 'connectPuppetEventToStreamingCall() for %s', this.puppet)
+
+    const offCallbackList = [] as (() => void)[]
+    const offAll = () => {
+      log.verbose('EventStreamManager',
+        'connectPuppetEventToStreamingCall() offAll() %s callbacks',
+        offCallbackList.length,
+      )
+      offCallbackList.forEach(off => off())
+      this.puppetListening = false
+    }
+
+    const eventNameList: PUPPET.types.PuppetEventName[] = Object.keys(PUPPET.types.PUPPET_EVENT_DICT) as PUPPET.types.PuppetEventName[]
+    for (const eventName of eventNameList) {
+      log.verbose('EventStreamManager',
+        'connectPuppetEventToStreamingCall() this.puppet.on(%s) (listenerCount:%s) registering...',
+        eventName,
+        this.puppet.listenerCount(eventName),
+      )
+
+      switch (eventName) {
+        case 'dong': {
+          const listener = (payload: PUPPET.payloads.EventDong) => this.grpcEmit(grpcPuppet.EventType.EVENT_TYPE_DONG, payload)
+          this.puppet.on('dong', listener)
+          const off = () => this.puppet.off('dong', listener)
+          offCallbackList.push(off)
+          break
+        }
+        case 'dirty': {
+          const listener = (payload: PUPPET.payloads.EventDirty) => this.grpcEmit(grpcPuppet.EventType.EVENT_TYPE_DIRTY, payload)
+          this.puppet.on('dirty', listener)
+          const off = () => this.puppet.off('dirty', listener)
+          offCallbackList.push(off)
+          break
+        }
+        case 'error': {
+          const listener = (payload: PUPPET.payloads.EventError) => this.grpcEmit(grpcPuppet.EventType.EVENT_TYPE_ERROR, payload)
+          this.puppet.on('error', listener)
+          const off = () => this.puppet.off('error', listener)
+          offCallbackList.push(off)
+          break
+        }
+        case 'heartbeat': {
+          const listener = (payload: PUPPET.payloads.EventHeartbeat) => this.grpcEmit(grpcPuppet.EventType.EVENT_TYPE_HEARTBEAT, payload)
+          this.puppet.on('heartbeat', listener)
+          const off = () => this.puppet.off('heartbeat', listener)
+          offCallbackList.push(off)
+          break
+        }
+        case 'friendship': {
+          const listener = (payload: PUPPET.payloads.EventFriendship) => this.grpcEmit(grpcPuppet.EventType.EVENT_TYPE_FRIENDSHIP, payload)
+          this.puppet.on('friendship', listener)
+          const off = () => this.puppet.off('friendship', listener)
+          offCallbackList.push(off)
+          break
+        }
+        case 'login': {
+          const listener = (payload: PUPPET.payloads.EventLogin) => this.grpcEmit(grpcPuppet.EventType.EVENT_TYPE_LOGIN, payload)
+          this.puppet.on('login', listener)
+          const off = () => this.puppet.off('login', listener)
+          offCallbackList.push(off)
+          break
+        }
+        case 'logout': {
+          const listener = (payload: PUPPET.payloads.EventLogout) => this.grpcEmit(grpcPuppet.EventType.EVENT_TYPE_LOGOUT, payload)
+          this.puppet.on('logout', listener)
+          const off = () => this.puppet.off('logout', listener)
+          offCallbackList.push(off)
+          break
+        }
+        case 'message': {
+          const listener = (payload: PUPPET.payloads.EventMessage) => this.grpcEmit(grpcPuppet.EventType.EVENT_TYPE_MESSAGE, payload)
+          this.puppet.on('message', listener)
+          const off = () => this.puppet.off('message', listener)
+          offCallbackList.push(off)
+          break
+        }
+        case 'post': {
+          const listener = (payload: PUPPET.payloads.EventPost) => this.grpcEmit(grpcPuppet.EventType.EVENT_TYPE_POST, payload)
+          this.puppet.on('post', listener)
+          const off = () => this.puppet.off('post', listener)
+          offCallbackList.push(off)
+          break
+        }
+        case 'ready': {
+          const listener = (payload: PUPPET.payloads.EventReady) => this.grpcEmit(grpcPuppet.EventType.EVENT_TYPE_READY, payload)
+          this.puppet.on('ready', listener)
+          const off = () => this.puppet.off('ready', listener)
+          offCallbackList.push(off)
+          break
+        }
+        case 'room-invite': {
+          const listener = (payload: PUPPET.payloads.EventRoomInvite) => this.grpcEmit(grpcPuppet.EventType.EVENT_TYPE_ROOM_INVITE, payload)
+          this.puppet.on('room-invite', listener)
+          const off = () => this.puppet.off('room-invite', listener)
+          offCallbackList.push(off)
+          break
+        }
+        case 'room-join': {
+          const listener = (payload: PUPPET.payloads.EventRoomJoin) => this.grpcEmit(grpcPuppet.EventType.EVENT_TYPE_ROOM_JOIN, payload)
+          this.puppet.on('room-join', listener)
+          const off = () => this.puppet.off('room-join', listener)
+          offCallbackList.push(off)
+          break
+        }
+        case 'room-leave': {
+          const listener = (payload: PUPPET.payloads.EventRoomLeave) => this.grpcEmit(grpcPuppet.EventType.EVENT_TYPE_ROOM_LEAVE, payload)
+          this.puppet.on('room-leave', listener)
+          const off = () => this.puppet.off('room-leave', listener)
+          offCallbackList.push(off)
+          break
+        }
+        case 'room-topic': {
+          const listener = (payload: PUPPET.payloads.EventRoomTopic) => this.grpcEmit(grpcPuppet.EventType.EVENT_TYPE_ROOM_TOPIC, payload)
+          this.puppet.on('room-topic', listener)
+          const off = () => this.puppet.off('room-topic', listener)
+          offCallbackList.push(off)
+          break
+        }
+        case 'scan': {
+          const listener = (payload: PUPPET.payloads.EventScan) => this.grpcEmit(grpcPuppet.EventType.EVENT_TYPE_SCAN, payload)
+          this.puppet.on('scan', listener)
+          const off = () => this.puppet.off('scan', listener)
+          offCallbackList.push(off)
+          break
+        }
+        case 'reset':
+          // the `reset` event should be dealed internally, should not send out
+          break
+
+        default:
+          // Huan(202003): in default, the `eventName` type should be `never`, please check.
+          throw new Error('eventName ' + eventName + ' unsupported!')
+      }
+    }
+
+    this.puppetListening = true
+    return offAll
+  }
+
+  /**
+   * Detect if the streaming call was gone (GRPC disconnects)
+   *  https://github.com/grpc/grpc/issues/8117#issuecomment-362198092
+   */
+  private onStreamingCallEnd (
+    removePuppetListeners: () => void,
+  ): void {
+    log.verbose('EventStreamManager', 'onStreamingCallEnd(callback)')
+
+    if (!this.eventStream) {
+      throw new Error('no this.eventStream found')
+    }
+
+    /**
+     * Huan(202110): useful log messages
+     *
+     * ServiceCtl<PuppetServiceMixin> stop() super.stop() ... done
+     * StateSwitch <PuppetServiceMixin> inactive(true) <- (pending)
+     * EventStreamManager this.onStreamingCallEnd() this.eventStream.on(finish) fired
+     * EventStreamManager connectPuppetEventToStreamingCall() offAll() 14 callbacks
+     * EventStreamManager this.onStreamingCallEnd() this.eventStream.on(finish) eventStream is undefined
+     * EventStreamManager this.onStreamingCallEnd() this.eventStream.on(close) fired
+     * EventStreamManager this.onStreamingCallEnd() this.eventStream.on(close) eventStream is undefined
+     * EventStreamManager this.onStreamingCallEnd() this.eventStream.on(cancelled) fired with arguments: {}
+     * EventStreamManager this.onStreamingCallEnd() this.eventStream.on(cancelled) eventStream is undefined
+     * GrpcClient stop() stop client ... done
+     */
+    this.eventStream.on('cancelled', () => {
+      log.verbose('EventStreamManager', 'this.onStreamingCallEnd() this.eventStream.on(cancelled) fired with arguments: %s',
+        JSON.stringify(arguments),
+      )
+
+      if (this.puppetListening) {
+        removePuppetListeners()
+      }
+      if (this.eventStream) {
+        this.eventStream = undefined
+      } else {
+        log.warn('EventStreamManager', 'this.onStreamingCallEnd() this.eventStream.on(cancelled) eventStream is undefined')
+      }
+    })
+
+    this.eventStream.on('error', err => {
+      log.verbose('EventStreamManager', 'this.onStreamingCallEnd() this.eventStream.on(error) fired: %s', err)
+      if (this.puppetListening) {
+        removePuppetListeners()
+      }
+      if (this.eventStream) {
+        this.eventStream = undefined
+      } else {
+        log.warn('EventStreamManager', 'this.onStreamingCallEnd() this.eventStream.on(error) eventStream is undefined')
+      }
+    })
+
+    this.eventStream.on('finish', () => {
+      log.verbose('EventStreamManager', 'this.onStreamingCallEnd() this.eventStream.on(finish) fired')
+      if (this.puppetListening) {
+        removePuppetListeners()
+      }
+      if (this.eventStream) {
+        this.eventStream = undefined
+      } else {
+        log.warn('EventStreamManager', 'this.onStreamingCallEnd() this.eventStream.on(finish) eventStream is undefined')
+      }
+    })
+
+    this.eventStream.on('end', () => {
+      log.verbose('EventStreamManager', 'this.onStreamingCallEnd() this.eventStream.on(end) fired')
+      if (this.puppetListening) {
+        removePuppetListeners()
+      }
+      if (this.eventStream) {
+        this.eventStream = undefined
+      } else {
+        log.warn('EventStreamManager', 'this.onStreamingCallEnd() this.eventStream.on(end) eventStream is undefined')
+      }
+    })
+
+    this.eventStream.on('close', () => {
+      log.verbose('EventStreamManager', 'this.onStreamingCallEnd() this.eventStream.on(close) fired')
+      if (this.puppetListening) {
+        removePuppetListeners()
+      }
+      if (this.eventStream) {
+        this.eventStream = undefined
+      } else {
+        log.warn('EventStreamManager', 'this.onStreamingCallEnd() this.eventStream.on(close) eventStream is undefined')
+      }
+    })
+  }
+
+}
+
+export { EventStreamManager }

package/src/server/grpc-error.ts

@@ -0,0 +1,23 @@
+import type { grpc }  from '@juzi/wechaty-grpc'
+import { log }        from '@juzi/wechaty-puppet'
+import { GError }     from 'gerror'
+
+type GErrorCallback = (
+  gerror: Partial<grpc.StatusObject>,
+  value: null,
+) => void
+
+export function grpcError (
+  method   : string,
+  error    : any,
+  callback : GErrorCallback,
+): void {
+  const gerr = GError.from(error)
+
+  log.error('PuppetServiceImpl', `grpcError() ${method}() rejection: %s\n%s`,
+    gerr.message,
+    gerr.stack,
+  )
+
+  return callback(gerr, null)
+}

package/src/server/health-implementation.ts

@@ -0,0 +1,78 @@
+/* eslint-disable sort-keys */
+import {
+  google as grpcGoogle,
+}                         from '@juzi/wechaty-grpc'
+import {
+  log,
+  Puppet,
+}                         from '@juzi/wechaty-puppet'
+
+const HEARTBEAT_TIMEOUT_SECONDS = 60
+
+function healthImplementation (
+  puppet: Puppet,
+): grpcGoogle.IHealthServer {
+
+  let lastHeartbeatTimestamp = -1
+
+  const healthCheckResponse = () => {
+    const response = new grpcGoogle.HealthCheckResponse()
+
+    if (lastHeartbeatTimestamp < 0 || lastHeartbeatTimestamp > Date.now()) {
+      response.setStatus(grpcGoogle.HealthCheckResponse.ServingStatus.SERVICE_UNKNOWN)
+
+    } else if (Date.now() - lastHeartbeatTimestamp < HEARTBEAT_TIMEOUT_SECONDS * 1000) {
+      response.setStatus(grpcGoogle.HealthCheckResponse.ServingStatus.SERVING)
+
+    } else {
+      response.setStatus(grpcGoogle.HealthCheckResponse.ServingStatus.NOT_SERVING)
+    }
+
+    return response
+  }
+
+  puppet.on('heartbeat', () => {
+    lastHeartbeatTimestamp = Date.now()
+  })
+
+  const healthServerImpl: grpcGoogle.IHealthServer = {
+
+    check: async (call, callback) => {
+      log.verbose('HealthServiceImpl', 'check()')
+
+      const service = call.request.getService()
+      log.verbose('HealServiceImpl', 'check() service="%s"', service)
+
+      const response = healthCheckResponse()
+      callback(null, response)
+    },
+
+    watch: async (call) => {
+      log.verbose('HealthServiceImpl', 'watch()')
+
+      const firstResponse = healthCheckResponse()
+      let currentStatus   = firstResponse.getStatus()
+
+      call.write(firstResponse)
+
+      const timer = setInterval(() => {
+        const nextResponse = healthCheckResponse()
+        if (nextResponse.getStatus() !== currentStatus) {
+          currentStatus = nextResponse.getStatus()
+          call.write(nextResponse)
+        }
+      }, 5 * 1000)
+
+      const clear = () => clearInterval(timer)
+
+      call.on('end',    clear)
+      call.on('error',  clear)
+      call.on('close',  clear)
+    },
+
+  }
+
+  return healthServerImpl
+}
+
+export { healthImplementation }