@juzi/wechaty 1.0.0

package/src/cli/gateway.ts

@@ -0,0 +1,190 @@
+/* eslint-disable sort-keys */
+import {
+  command,
+  option,
+  optional,
+  string,
+  number,
+}                 from 'cmd-ts'
+
+import {
+  log,
+}                 from 'wechaty-puppet'
+import { WechatyToken } from 'wechaty-token'
+import getPort from 'get-port'
+
+import {
+  VERSION,
+}                           from '../config.js'
+import {
+  IoClient,
+  IoClientOptions,
+}                           from '../io-client.js'
+import { WechatyBuilder }   from '../wechaty-builder.js'
+import {
+  isPuppetModuleName,
+  OFFICIAL_PUPPET_DEPENDENCIES,
+  OFFICIAL_PUPPET_DEFAULT,
+}                           from '../puppet-config.js'
+
+async function onError (
+  this : IoClient,
+  e    : Error,
+) {
+  log.error('Gateway', 'Error: %s', e)
+  await this.quit()
+  process.exit(-1)
+}
+
+const gateway = command({
+  name: 'gateway',
+  description: 'Publish your DIY token as a Wechaty Puppet Service. (you can generate a token by running `wechaty token generate`)',
+  args: {
+    token: option({
+      description: 'Specify a TOKEN for your DIY Wechaty Puppet Service (WPS). It is the standard token service for TypeScript and Polyglot Wechaty (like Python, Rust, Go, etc.). If it not specified, it will be generated automatically.',
+      long: 'token',
+      short: 't',
+      type: optional(string),
+    }),
+    port: option({
+      description: 'Specify a Port for your DIY Wechaty Puppet Service (WPS). If it not specified, it will select a free port automatically. This port MUST be public accessiable via the internet.',
+      long: 'port',
+      short: 'p',
+      type: optional(number),
+    }),
+    puppet: option({
+      description: 'Specify a Wechaty Puppet Provider (WPP). If it not specified, it will use the environment variable `WECHATY_PUPPET`.',
+      long: 'puppet',
+      short: 'P',
+      type: optional(string),
+    }),
+    puppetToken: option({
+      description: 'Specify the WEchaty Puppet Provider TOKEN. If it not specified, it will use the environment variable `WECHATY_PUPPET_XXX_TOKEN` (`XXX` is your WPP name).',
+      long: 'puppet-token',
+      short: 'T',
+      type: optional(string),
+    }),
+  },
+  handler: async args => {
+    log.info('Gateway', 'Wechaty version %s', VERSION)
+
+    let {
+      token,
+      port,
+      puppet,
+      puppetToken,
+    } = args
+
+    /**
+     * Token
+     */
+    if (!token) {
+      log.info('Gateway', 'no `--token` specified, generating random Wechaty Puppet Service TOKEN ...')
+      token = WechatyToken.generate('insecure')
+    }
+    log.info('Gateway', 'Wechaty Puppet Service TOKEN: %s', token)
+
+    /**
+     * Puppet Service Server Port
+     */
+    if (!port) {
+      log.info('Gateway', 'no `--port` specified, selecting random free Wechaty Puppet Service Server Port ...')
+      port = await getPort({
+        port: 8788,
+      })
+
+    }
+    log.info('Gateway', 'Wechaty Puppet Service Server Port: %d', port)
+
+    /**
+     * Puppet Provider
+     */
+    if (!puppet) {
+      log.info('Gateway', 'no `--puppet` specified, reading from environment variable `WECHATY_PUPPET` for Wechaty Puppet Provider ...')
+      puppet = process.env['WECHATY_PUPPET']
+      if (!puppet) {
+        log.info('Gateway', `environment variable "WECHATY_PUPPET" is not available. Using system default puppet "${OFFICIAL_PUPPET_DEFAULT}"`)
+        puppet = OFFICIAL_PUPPET_DEFAULT
+      }
+    }
+    if (!isPuppetModuleName(puppet)) {
+      console.error(`The puppet name "${puppet}" is not a valid puppet name.`)
+      console.error(`Valid puppet names are: ${Object.keys(OFFICIAL_PUPPET_DEPENDENCIES).join(', ')}`)
+      return 1
+    }
+    log.info('Gateway', 'Wechaty Puppet Provider: %s', puppet)
+
+    /**
+     * Puppet Token
+     */
+    if (!puppetToken) {
+      log.info('Gateway', 'no `--puppet-token` specified, reading from environment variable `WECHATY_PUPPET_TOKEN` for your Wechaty Puppet Provider ...')
+      puppetToken = process.env['WECHATY_PUPPET_TOKEN']
+      if (!puppetToken) {
+        log.info('Gateway', 'WECHATY_PUPPET_TOKEN environment variable not available. Token disabled.')
+      }
+    }
+    log.info('Gateway', 'Wechaty Puppet Provider Token: %s', puppetToken ? `"${puppetToken}"` : 'disabled')
+
+    const wechaty = WechatyBuilder.build({
+      name: 'Gateway',
+      puppet,
+      puppetOptions: {
+        token: puppetToken,
+      },
+    })
+
+    const options: IoClientOptions = {
+      port,
+      token,
+      wechaty,
+    }
+
+    const client = new IoClient(options)
+
+    client.start()
+      .catch(onError.bind(client))
+
+    const wechatyToken = new WechatyToken(token)
+    let address
+    while (true) {
+      log.info('Gateway', 'Registering Wechaty Puppet Token Gateway Service Discovery ...')
+      await new Promise(resolve => setTimeout(resolve, 1000))
+      address = await wechatyToken.discover()
+      if (address) {
+        log.info('Gateway', 'Registering Wechaty Puppet Token Gateway Service Discovery ... success')
+        break
+      }
+      log.info('Gateway', 'Registering Wechaty Puppet Token Gateway Service Discovery ... timeout')
+    }
+
+    console.info(`
+
+    Your have successfully ran Wechaty Token Gateway with the below settings:
+      1. token: ${token}
+      2. port: ${port}
+      3. puppet: ${puppet}
+      4. puppetToken: ${puppetToken || ''}
+
+    The Wechaty Puppet Token Gateway Service Address is ${address.host}:${address.port}, please make sure it can be public accessed via the internet.
+
+    You can save the below command to restore the token gateway in future:
+
+    $ wechaty gateway --token ${token} --port ${port} --puppet ${puppet} --puppet-token ${puppetToken || ''}
+
+    You can set the below environment variables for your Wechaty program to use the DIY token provided by this gateway:
+    __________________________________________________________________________
+    $ export WECHATY_PUPPET=wechaty-puppet-service
+    $ export WECHATY_PUPPET_SERVICE_TOKEN=${token}
+    $ npm start
+
+    Please file an issue if you found any bug or have feature request at https://github.com/wechaty/wechaty/issues
+    Join the Wechaty Community Gitter Channel at https://gitter.im/wechaty/wechaty if you have any questions.
+
+    `)
+
+    return 0
+  },
+})
+
+export { gateway }

package/src/cli/mod.ts

@@ -0,0 +1,5 @@
+export { friday }     from './friday.js'
+export { gateway }    from './gateway.js'
+export { provider }   from './provider.js'
+export { service }    from './service.js'
+export { token }      from './token.js'

package/src/cli/provider.ts

@@ -0,0 +1,20 @@
+/* eslint-disable sort-keys */
+import {
+  command,
+}                 from 'cmd-ts'
+
+async function handler (_args: any) {
+  console.info('this command can help you manage Wechaty Puppet Provider (WPP).')
+  console.info('Not implemented yet, please stay tuned and contribute is welcome!')
+  console.info('GitHub repo(source code): https://github.com/wechaty/wechaty/blob/main/src/cli/puppet-provider.ts')
+}
+
+const provider = command({
+  name: 'provider',
+  description: 'Manage Wechaty Puppet Provider (WPP)',
+  args: {
+  },
+  handler,
+})
+
+export { provider }

package/src/cli/service.ts

@@ -0,0 +1,20 @@
+/* eslint-disable sort-keys */
+import {
+  command,
+}                 from 'cmd-ts'
+
+async function handler (_args: any) {
+  console.info('this command can help you manage Wechaty Puppet Servivce (WPS).')
+  console.info('Not implemented yet, please stay tuned and contribute is welcome!')
+  console.info('GitHub repo(source code): https://github.com/wechaty/wechaty/blob/main/src/cli/puppet-service.ts')
+}
+
+const service = command({
+  name: 'service',
+  description: 'Manage Wechaty Puppet Service (WPS)',
+  args: {
+  },
+  handler,
+})
+
+export { service }

package/src/cli/token.ts

@@ -0,0 +1,19 @@
+/* eslint-disable sort-keys */
+import {
+  subcommands,
+}                 from 'cmd-ts'
+
+import { cmds } from 'wechaty-token'
+
+import {
+  VERSION,
+}                           from '../config.js'
+
+const token = subcommands({
+  name: 'Token',
+  description: 'Generate & Discover TOKEN for Wechaty',
+  version: VERSION,
+  cmds,
+})
+
+export { token }

package/src/config.spec.ts

@@ -0,0 +1,97 @@
+#!/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 { config } from './config.js'
+// import { Puppet } from './puppet'
+
+test('important variables', async t => {
+  // t.ok('puppet'   in config, 'should exist `puppet` in Config')
+  t.ok('apihost'  in config, 'should exist `apihost` in Config')
+  t.ok('token'    in config, 'should exist `token` in Config')
+
+  // t.ok(config.default.DEFAULT_PUPPET      , 'should export DEFAULT_PUPPET')
+  // t.ok(config.default.DEFAULT_PROFILE     , 'should export DEFAULT_PROFILE')
+  t.ok(config.default.DEFAULT_PROTOCOL, 'should export DEFAULT_PROTOCOL')
+  t.ok(config.default.DEFAULT_APIHOST,  'should export DEFAULT_APIHOST')
+})
+
+test('validApiHost()', async t => {
+  const OK_APIHOSTS = [
+    'api.chatie.io',
+    'chatie.io:8080',
+  ]
+  const ERR_APIHOSTS = [
+    'https://api.chatie.io',
+    'chatie.io/',
+  ]
+  OK_APIHOSTS.forEach(apihost => {
+    t.doesNotThrow(() => {
+      config.validApiHost(apihost)
+    })
+  }, 'should not row for right apihost')
+  ERR_APIHOSTS.forEach(apihost => {
+    t.throws(() => {
+      config.validApiHost(apihost)
+    })
+  }, 'should throw for error apihost')
+
+})
+
+// test('puppetInstance()', async t => {
+//   // BUG Compitable with Win32 CI
+//   // global instance infected across unit tests... :(
+//   const bak = config.puppetInstance()
+
+//   config.puppetInstance(null)
+//   t.throws(() => {
+//     config.puppetInstance()
+//   }, Error, 'should throw when not initialized')
+//   config.puppetInstance(bak)
+
+//   const EXPECTED: Puppet = {userId: 'test'} as any
+//   const mockPuppet = EXPECTED
+
+//   config.puppetInstance(mockPuppet)
+//   const instance = config.puppetInstance()
+//   t.same(instance, EXPECTED, 'should equal with initialized data')
+
+//   config.puppetInstance(null)
+//   t.throws(() => {
+//     config.puppetInstance()
+//   }, Error, 'should throw after set to null')
+
+//   config.puppetInstance(bak)
+// })
+
+test('systemPuppetName ()', async t => {
+  const WECHATY_PUPPET_ORIG = process.env['WECHATY_PUPPET']
+
+  delete process.env['WECHATY_PUPPET']
+  t.equal(config.systemPuppetName(), 'wechaty-puppet-wechat4u', 'should get wechaty-puppet-wechat4u as default puppet name')
+
+  process.env['WECHATY_PUPPET'] = 'wechaty-puppet-mock'
+  t.equal(config.systemPuppetName(), 'wechaty-puppet-mock', 'should get puppet name from process.env')
+
+  // restore the original value
+  process.env['WECHATY_PUPPET'] = WECHATY_PUPPET_ORIG
+})

package/src/config.ts

@@ -0,0 +1,165 @@
+/**
+ *   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.
+ *
+ */
+/// <reference path="./io-peer/json-rpc-peer.d.ts" />
+
+import {
+  log,
+}                   from 'wechaty-puppet'
+import { FileBox } from 'file-box'
+import type {
+  FileBoxInterface,
+}                   from 'file-box'
+import type {
+  PackageJson,
+}                   from 'type-fest'
+
+import {
+  OfficialPuppetNpmName,
+  OFFICIAL_PUPPET_DEFAULT,
+}                      from './puppet-config.js'
+import {
+  packageJson,
+  GIT_COMMIT_HASH,
+}                       from './package-json.js'
+
+type PackageJsonWechaty = PackageJson & {
+  wechaty: {
+    DEFAULT_PORT: number
+    DEFAULT_PROTOCOL: string
+    DEFAULT_APIHOST: string
+  }
+}
+
+const VERSION = packageJson.version || '0.0.0'
+
+/**
+ * to handle unhandled exceptions
+ */
+if (log.level() === 'verbose' || log.level() === 'silly') {
+  log.info('Config', 'registering process.on("unhandledRejection") for development/debug')
+
+  /**
+   * Refer to https://nodejs.org/api/process.html#process_event_unhandledrejection
+   * the reason is in type: Error | any
+   */
+  process.on('unhandledRejection', (reason: Error | any, promise) => {
+    log.error('Config', '###########################')
+    log.error('Config', 'Wechaty unhandledRejection: %s %s', reason.stack || reason, promise)
+    log.error('Config', '###########################')
+    promise.catch(err => {
+      log.error('Config', 'process.on(unhandledRejection) promise.catch(%s)', err.message)
+      console.error('Config', err) // I don't know if log.error has similar full trace print support like console.error
+    })
+  })
+
+  process.on('uncaughtException', function (error) {
+    const origin = arguments[1] // to compatible with node 12 or below version typings
+
+    log.error('Config', '###########################')
+    log.error('Config', 'Wechaty uncaughtException: %s %s', error.stack, origin)
+    log.error('Config', '###########################')
+  })
+}
+
+export interface DefaultSetting {
+  DEFAULT_PORT     : number,
+  DEFAULT_APIHOST  : string,
+  DEFAULT_PROTOCOL : string,
+}
+
+const DEFAULT_SETTING = packageJson['wechaty'] as DefaultSetting
+
+export class Config {
+
+  default = DEFAULT_SETTING
+
+  apihost = process.env['WECHATY_APIHOST'] || DEFAULT_SETTING['DEFAULT_APIHOST']
+
+  serviceIp = process.env['WECHATY_PUPPET_SERVICE_IP'] || ''
+
+  systemPuppetName (): OfficialPuppetNpmName {
+    return (
+      process.env['WECHATY_PUPPET'] || OFFICIAL_PUPPET_DEFAULT
+    ).toLowerCase() as OfficialPuppetNpmName
+  }
+
+  name = process.env['WECHATY_NAME']
+
+  // DO NOT set DEFAULT, because sometimes user do not want to connect to io cloud service
+  token   = process.env['WECHATY_TOKEN']
+
+  debug   = !!(process.env['WECHATY_DEBUG'])
+
+  httpPort = process.env['PORT']
+    || process.env['WECHATY_PORT']
+    || DEFAULT_SETTING['DEFAULT_PORT']
+
+  docker = !!(process.env['WECHATY_DOCKER'])
+
+  constructor () {
+    log.verbose('Config', 'constructor()')
+    this.validApiHost(this.apihost)
+  }
+
+  validApiHost (apihost: string): boolean {
+    if (/^[a-zA-Z0-9.\-_]+:?[0-9]*$/.test(apihost)) {
+      return true
+    }
+    throw new Error('validApiHost() fail for ' + apihost)
+  }
+
+}
+
+export const CHATIE_OFFICIAL_ACCOUNT_ID = 'gh_051c89260e5d'
+
+export function qrCodeForChatie (): FileBoxInterface {
+  const CHATIE_OFFICIAL_ACCOUNT_QRCODE = 'http://weixin.qq.com/r/qymXj7DEO_1ErfTs93y5'
+  return FileBox.fromQRCode(CHATIE_OFFICIAL_ACCOUNT_QRCODE)
+}
+
+// http://jkorpela.fi/chars/spaces.html
+// String.fromCharCode(8197)
+export const FOUR_PER_EM_SPACE = String.fromCharCode(0x2005)
+// mobile: \u2005, PC、mac: \u0020
+export const AT_SEPARATOR_REGEX = /[\u2005\u0020]/
+
+export function qrcodeValueToImageUrl (qrcodeValue: string): string {
+  return [
+    'https://wechaty.js.org/qrcode/',
+    encodeURIComponent(qrcodeValue),
+  ].join('')
+}
+
+export function isProduction (): boolean {
+  return process.env['NODE_ENV'] === 'production'
+      || process.env['NODE_ENV'] === 'prod'
+}
+
+const config = new Config()
+
+export type {
+  PackageJsonWechaty,
+}
+export {
+  log,
+  config,
+  GIT_COMMIT_HASH,
+  VERSION,
+}

package/src/doctor.ts

@@ -0,0 +1,92 @@
+/**
+ *   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 {
+  createServer,
+  Socket,
+}                   from 'net'
+import { spawnSync as spawn } from 'child_process'
+
+import {
+  log,
+}                   from 'wechaty-puppet'
+
+export class Doctor {
+
+  constructor () {
+    log.verbose('Doctor', 'constructor()')
+  }
+
+  public chromedriverVersion (): string {
+    let version: string
+    try {
+      const cmd = spawn('chromedriver', ['--version'])
+      version = String(cmd.error) || cmd.stdout.toString() || cmd.stderr.toString()
+    } catch (e) {
+      version = (e as Error).message
+    }
+    return version
+  }
+
+  /**
+   * https://gist.github.com/tedmiston/5935757
+   */
+  public testTcp (): Promise<boolean> {
+    log.verbose('Doctor', 'testTcp()')
+
+    return new Promise<boolean>((resolve, reject) => {
+      /**
+       * Server
+       */
+      const server = createServer(socket => socket.pipe(socket))
+      /**
+       * Promise Reject
+       */
+      server.on('error', reject)
+      server.on('close', () => log.silly('Doctor', 'testTcp() server closed'))
+
+      server.listen(8788, 'localhost', () => {
+        /**
+         * Client
+         */
+        const client = new Socket()
+        client.connect(8788, 'localhost', () => {
+          log.silly('Doctor', 'testTcp() client connected')
+          client.write('ding')
+        })
+
+        client.on('data', () => {
+          /**
+           * Promise Resolve
+           */
+          resolve(true)
+
+          client.destroy() // kill client after server's response
+        })
+        /**
+         * Promise Reject
+         */
+        client.on('error', reject)
+
+        client.on('close', () => server.close())
+      })
+    })
+  }
+
+}

package/src/helper-functions/open-graph.ts

@@ -0,0 +1,34 @@
+/**
+ *   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 og from 'open-graph'
+
+export async function openGraph (url: string): Promise<og.Data> {
+  return new Promise((resolve, reject) => {
+    og(url, (err, meta) => {
+      if (err) {
+        reject(err)
+      } else if (!meta) {
+        reject(new Error('meta is undefined'))
+      } else {
+        resolve(meta)
+      }
+    })
+  })
+}

package/src/helper-functions/stringify-filter.ts

@@ -0,0 +1,13 @@
+// https://stackoverflow.com/a/38251445/1123955
+
+function stringifyFilter (_key: string, value: any) {
+  if (value instanceof RegExp) {
+    return value.toString()
+  }
+
+  return value
+}
+
+export {
+  stringifyFilter,
+}