@juzi/wechaty 1.0.0

package/src/io-client.ts

@@ -0,0 +1,276 @@
+/**
+ *   Wechaty Chatbot SDK - https://github.com/wechaty/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 { StateSwitch } from 'state-switch'
+import {
+  PuppetServer,
+  PuppetServerOptions,
+}                       from 'wechaty-puppet-service'
+
+import type { MessageInterface }  from './user-modules/mod.js'
+import type { WechatyInterface }  from './wechaty/mod.js'
+
+import {
+  log,
+}                       from './config.js'
+import { Io }           from './io.js'
+
+export interface IoClientOptions {
+  token   : string,
+  wechaty : WechatyInterface,
+  port?: number
+}
+
+const DEFAULT_IO_CLIENT_OPTIONS: Partial<IoClientOptions> = {
+  port: 8788,
+}
+
+export class IoClient {
+
+  /**
+   * Huan(20161026): keep io `null-able` or not?
+   * Huan(202002): make it optional.
+   */
+  private io?: Io
+  private puppetServer?: PuppetServer
+
+  private state: StateSwitch
+
+  protected options: Required<IoClientOptions>
+
+  constructor (
+    options: IoClientOptions,
+  ) {
+    log.verbose('IoClient', 'constructor({%s})',
+      Object.keys(options)
+        .map(key => {
+          return `${key}:${(options as any)[key]}`
+        })
+        .reduce((acc, cur) => `${acc}, ${cur}`),
+    )
+
+    const normalizedOptions = {
+      ...DEFAULT_IO_CLIENT_OPTIONS,
+      ...options,
+    } as Required<IoClientOptions>
+
+    this.options = normalizedOptions
+
+    this.state = new StateSwitch('IoClient', { log })
+  }
+
+  private async startPuppetServer () {
+    log.verbose('IoClient', 'startPuppetServer()')
+
+    if (this.puppetServer) {
+      throw new Error('puppet server exists')
+    }
+
+    const options: PuppetServerOptions = {
+      endpoint : '0.0.0.0:' + this.options.port,
+      /**
+       * Huan(202110): FIXME: remove the any
+       *  by updating the puppet-service server code
+       *  to use PuppetInterface
+       */
+      puppet   : this.options.wechaty.puppet as any,
+      token    : this.options.token,
+    }
+    this.puppetServer = new PuppetServer(options)
+    await this.puppetServer.start()
+  }
+
+  private async stopPuppetServer () {
+    log.verbose('IoClient', 'stopPuppetServer()')
+
+    if (!this.puppetServer) {
+      log.error('IoClient', 'stopPuppetServer() this.puppetServer is `undefined`')
+      return
+    }
+
+    await this.puppetServer.stop()
+    this.puppetServer = undefined
+  }
+
+  public async start (): Promise<void> {
+    log.verbose('IoClient', 'start()')
+
+    if (this.state.active()) {
+      log.warn('IoClient', 'start() with a on state, wait and return')
+      await this.state.stable('active')
+      return
+    }
+
+    this.state.active('pending')
+
+    try {
+      await this.hookWechaty(this.options.wechaty)
+
+      await this.startIo()
+
+      await this.options.wechaty.start()
+
+      await this.startPuppetServer()
+
+      this.state.active(true)
+
+    } catch (e) {
+      log.error('IoClient', 'start() exception: %s', (e as Error).message)
+      this.state.inactive(true)
+      throw e
+    }
+  }
+
+  private async hookWechaty (wechaty: WechatyInterface): Promise<void> {
+    log.verbose('IoClient', 'hookWechaty()')
+
+    if (this.state.inactive()) {
+      const e = new Error('state.off() is true, skipped')
+      log.warn('IoClient', 'initWechaty() %s', e.message)
+      throw e
+    }
+
+    wechaty
+      .on('login',    user => log.info('IoClient', `${user.name()} logged in`))
+      .on('logout',   user => log.info('IoClient', `${user.name()} logged out`))
+      .on('message',  msg => this.onMessage(msg))
+      .on('scan',     (url, code) => {
+        log.info('IoClient', [
+          `[${code}] ${url}`,
+          `Online QR Code Image: https://wechaty.js.org/qrcode/${encodeURIComponent(url)}`,
+        ].join('\n'))
+      })
+  }
+
+  private async startIo (): Promise<void> {
+    log.verbose('IoClient', 'startIo() with token %s', this.options.token)
+
+    if (this.state.inactive()) {
+      const e = new Error('startIo() state.off() is true, skipped')
+      log.warn('IoClient', e.message)
+      throw e
+    }
+
+    if (this.io) {
+      throw new Error('io exists')
+    }
+
+    this.io = new Io({
+      servicePort : this.options.port,
+      token      : this.options.token,
+      wechaty    : this.options.wechaty,
+    })
+
+    try {
+      await this.io.start()
+    } catch (e) {
+      log.verbose('IoClient', 'startIo() init fail: %s', (e as Error).message)
+      throw e
+    }
+  }
+
+  private async stopIo () {
+    log.verbose('IoClient', 'stopIo()')
+
+    if (!this.io) {
+      log.warn('IoClient', 'stopIo() io does not exist')
+      return
+    }
+
+    await this.io.stop()
+    this.io = undefined
+  }
+
+  private async onMessage (msg: MessageInterface) {
+    log.verbose('IoClient', 'onMessage(%s)', msg)
+
+    // const from = m.from()
+    // const to = m.to()
+    // const content = m.toString()
+    // const room = m.room()
+
+    // log.info('Bot', '%s<%s>:%s'
+    //               , (room ? '['+room.topic()+']' : '')
+    //               , from.name()
+    //               , m.toStringDigest()
+    //         )
+
+    // if (/^wechaty|chatie|botie/i.test(m.text()) && !m.self()) {
+    //   await m.say('https://www.chatie.io')
+    //     .then(_ => log.info('Bot', 'REPLIED to magic word "chatie"'))
+    // }
+  }
+
+  public async stop (): Promise<void> {
+    log.verbose('IoClient', 'stop()')
+
+    this.state.inactive('pending')
+
+    await this.stopIo()
+    await this.stopPuppetServer()
+    await this.options.wechaty.stop()
+
+    this.state.inactive(true)
+
+    // XXX 20161026
+    // this.io = null
+  }
+
+  public async restart (): Promise<void> {
+    log.verbose('IoClient', 'restart()')
+
+    try {
+      await this.stop()
+      await this.start()
+    } catch (e) {
+      log.error('IoClient', 'restart() exception %s', (e as Error).message)
+      throw e
+    }
+  }
+
+  public async quit (): Promise<void> {
+    log.verbose('IoClient', 'quit()')
+
+    if (this.state.inactive() === 'pending') {
+      log.warn('IoClient', 'quit() with state.off() = `pending`, skipped')
+      throw new Error('quit() with state.off() = `pending`')
+    }
+
+    this.state.inactive('pending')
+
+    try {
+      // if (this.options.wechaty) {
+      await this.options.wechaty.stop()
+      // this.wechaty = null
+      // } else { log.warn('IoClient', 'quit() no this.wechaty') }
+
+      if (this.io) {
+        await this.io.stop()
+        // this.io = null
+      } else { log.warn('IoClient', 'quit() no this.io') }
+
+    } catch (e) {
+      log.error('IoClient', 'exception: %s', (e as Error).message)
+      throw e
+    } finally {
+      this.state.inactive(true)
+    }
+  }
+
+}

package/src/io-peer/io-peer.spec.ts

@@ -0,0 +1,64 @@
+#!/usr/bin/env -S node --no-warnings --loader ts-node/esm
+/**
+ *   Wechaty Chatbot SDK - https://github.com/wechaty/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 { test }  from 'tstest'
+
+import jsonRpcPeer from 'json-rpc-peer'
+
+import {
+  getPeer,
+}                   from './io-peer.js'
+
+test('getPeer()', async t => {
+  const EXPECTED_PORT = 8788
+  const server = getPeer({
+    serviceGrpcPort: EXPECTED_PORT,
+  })
+  const client = new jsonRpcPeer.Peer()
+  /**
+   * FIXME: Huan(202108): remove `any` to fix the typing
+   */
+  server.pipe(client as any).pipe(server)
+
+  /**
+   * Huan(202101) Need to be fixed by new IO Bus system.
+   *  See: https://github.com/wechaty/wechaty-puppet-service/issues/118
+   */
+  const port = await client.request('getHostieGrpcPort')
+  t.equal(port, EXPECTED_PORT, 'should get the right port')
+})
+
+test('exec()', async t => {
+  const EXPECTED_PORT = 8788
+  const server = getPeer({
+    serviceGrpcPort: EXPECTED_PORT,
+  })
+
+  /**
+   * Huan(202101) Need to be fixed by new IO Bus system.
+   *  See: https://github.com/wechaty/wechaty-puppet-service/issues/118
+   */
+  const request = jsonRpcPeer.format.request(42, 'getHostieGrpcPort')
+  const response = await server.exec(request) as string
+  // console.info('response: ', response)
+
+  const obj = jsonRpcPeer.parse(response) as jsonRpcPeer.JsonRpcPayloadResponse
+  t.equal(obj.result, EXPECTED_PORT, 'should get the right port from payload')
+})

package/src/io-peer/io-peer.ts

@@ -0,0 +1,79 @@
+/// <reference path="json-rpc-peer.d.ts"/>
+import jsonRpcPeer from 'json-rpc-peer'
+
+// // https://stackoverflow.com/a/50375286/1123955
+// type UnionToIntersection<U> =
+//   (U extends any ? (k: U)=>void : never) extends ((k: infer I)=>void) ? I : never
+
+// type UnknownJsonRpcPayload = Partial<UnionToIntersection<JsonRpcPayload>>
+
+const isJsonRpcRequest      = (payload: jsonRpcPeer.JsonRpcPayload): payload is jsonRpcPeer.JsonRpcPayloadRequest      => ('method' in payload)
+const isJsonRpcNotification = (payload: jsonRpcPeer.JsonRpcPayload): payload is jsonRpcPeer.JsonRpcPayloadNotification => isJsonRpcRequest(payload) && (!('id' in payload))
+const isJsonRpcResponse     = (payload: jsonRpcPeer.JsonRpcPayload): payload is jsonRpcPeer.JsonRpcPayloadResponse     => ('result' in payload)
+const isJsonRpcError        = (payload: jsonRpcPeer.JsonRpcPayload): payload is jsonRpcPeer.JsonRpcPayloadError        => ('error' in payload)
+
+interface IoPeerOptions {
+  serviceGrpcPort: number,
+}
+
+const getPeer = (options: IoPeerOptions) => {
+  const getServiceGrpcPort = () => options.serviceGrpcPort
+
+  const serviceImpl = {
+    /**
+     * Huan(202101) Need to be fixed by new IO Bus system.
+     *  See: https://github.com/wechaty/wechaty-puppet-service/issues/118
+     */
+    getHostieGrpcPort: getServiceGrpcPort,
+  }
+
+  const onMessage = async (message: jsonRpcPeer.JsonRpcPayload): Promise<any> => {
+    if (isJsonRpcRequest(message)) {
+      const {
+        // id,
+        method,
+        // params,
+      } = message
+
+      if (!(method in serviceImpl)) {
+        console.error('serviceImpl does not contain method: ' + method)
+        return
+      }
+
+      const serviceMethodName = method as keyof typeof serviceImpl
+      switch (serviceMethodName) {
+        /**
+         * Huan(202101) Need to be fixed by new IO Bus system.
+         *  See: https://github.com/wechaty/wechaty-puppet-service/issues/118
+         */
+        case 'getHostieGrpcPort':
+          return serviceImpl[serviceMethodName]()
+
+        default:
+          throw new jsonRpcPeer.MethodNotFound(serviceMethodName)
+      }
+    } else if (isJsonRpcResponse(message)) {
+      // NOOP: we are server
+    } else if (isJsonRpcNotification(message)) {
+      // NOOP: we are server
+    } else if (isJsonRpcError(message)) {
+      // NOOP: we are server
+    } else {
+      throw new Error('unknown json-rpc message: ' + JSON.stringify(message))
+    }
+    console.info(JSON.stringify(message))
+  }
+
+  const ioPeer = new jsonRpcPeer.Peer(onMessage)
+
+  return ioPeer
+}
+
+export {
+  getPeer,
+
+  isJsonRpcError,
+  isJsonRpcNotification,
+  isJsonRpcRequest,
+  isJsonRpcResponse,
+}

package/src/io-peer/json-rpc-peer.d.ts

@@ -0,0 +1,68 @@
+/**
+ * Add typescript definitions #60
+ *  https://github.com/JsCommunity/json-rpc-peer/pull/60
+ */
+declare module 'json-rpc-peer' {
+
+  /// <reference types='json-rpc-protocol' />
+  /// <reference types='node' />
+  import { Writable }     from 'stream'
+  import { EventEmitter } from 'events'
+  import {
+    JsonRpcPayload,
+    JsonRpcParamsSchema,
+  }                       from 'json-rpc-protocol'
+
+  // export as namespace JsonRpcPeer
+
+  export * from 'json-rpc-protocol'
+
+  export class Peer extends EventEmitter implements Writable {
+
+    constructor(onmessage?: (message: JsonRpcPayload, data: any) => Promise<any>)
+
+    public exec(
+      message: string | object,
+      data?: any
+    ): Promise<undefined | string | JsonRpcPayload | JsonRpcPayload[]>
+
+    /**
+     * Fails all pending requests.
+     */
+    public failPendingRequests(reason?: string)
+
+    /**
+     * This function should be called to send a request to the other end.
+     */
+    public request(method: string, params?: JsonRpcParamsSchema): Promise<any>
+
+    /**
+     * This function should be called to send a notification to the other end.
+     */
+    public notify(method: string, params?: JsonRpcParamsSchema)
+
+    public push(chunk: any, encoding?: string)
+
+    public pipe<T extends Writable>(writable: T): T
+
+    // NodeJS.WritableStream
+
+    writable: boolean
+    write(
+      buffer: Uint8Array | string,
+      cb?: (err?: Error | null) => void
+    ): boolean
+
+    write(
+      str: string,
+      encoding?: string,
+      cb?: (err?: Error | null) => void
+    ): boolean
+
+    end(cb?: () => void): void
+    end(data: string | Uint8Array, cb?: () => void): void
+    end(str: string, encoding?: string, cb?: () => void): void
+
+  }
+
+}

package/src/io.spec.ts

@@ -0,0 +1,44 @@
+#!/usr/bin/env -S node --no-warnings --loader ts-node/esm
+/**
+ *   Wechaty Chatbot SDK - https://github.com/wechaty/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 { test }  from 'tstest'
+import { WechatyBuilder } from './wechaty-builder.js'
+
+import { Io }       from './io.js'
+
+test('Io restart without problem', async t => {
+  const io = new Io({
+    // token must not contain any white spaces
+    servicePort : 8788,
+    token       : 'mock_00000000-0000-0000-0000-000000000000',
+    wechaty     : WechatyBuilder.build(),
+  })
+
+  try {
+    for (let i = 0; i < 2; i++) {
+      await io.start()
+      await io.stop()
+      t.pass('start/stop-ed at #' + i)
+    }
+    t.pass('start/restart successed.')
+  } catch (e) {
+    t.fail(e as any)
+  }
+})