hb-nb-tools 1.0.0

package/README.md

@@ -0,0 +1,34 @@
+# Homebridge NB Tools
+[![Downloads](https://img.shields.io/npm/dt/hb-nb-tools.svg)](https://www.npmjs.com/package/hb-nb-tools)
+[![Version](https://img.shields.io/npm/v/hb-nb-tools.svg)](https://www.npmjs.com/package/hb-nb-tools)
+[![JavaScript Style Guide](https://img.shields.io/badge/code_style-standard-brightgreen.svg)](https://standardjs.com)
+
+</span>
+
+## Homebridge NB Tools
+Copyright © 2020-2023 Erik Baauw. All rights reserved.
+
+This repository provides a standalone installation of the command-line tools from [Homebridge NB](https://github.com/ebaauw/homebridge-nb):
+
+Tool      | Description
+--------- | -----------
+`nb `     | Interact with Nuki bridge from command line.
+
+Each command-line tool takes a `-h` or `--help` argument to provide a brief overview of its functionality and command-line arguments.
+
+### Prerequisites
+Homebridge NB communicates with the Nuki Bridge using the local
+[Nuki Bridge HTTP API](https://developer.nuki.io/page/nuki-bridge-http-api-1-12/4).
+You need to enable this API through the Nuki app.
+
+### Installation
+```
+$ sudo npm -g i hb-nb-tools
+```
+Homebridge NB Tools uses [`sodium-plus`](https://github.com/paragonie/sodium-plus) for [encrypted tokens](https://developer.nuki.io/t/bridge-beta-fw-1-22-1-2-14-0-with-new-encrypted-bridge-http-api-token/15816).
+This optional dependency contains C++ modules, that might need to be compiled on installation.
+In case you want to install Homebridge NB Tools on a system that doesn't include the build tools needed for this, you might need to skip installation of `sodium-plus` by
+```
+$ sudo npm -g i hb-nb-tools --omit=optional
+```
+Homebrdige NB Tools reverts to hashed tokens when `sodium-plus` isn't installed.

package/cli/nb.js

@@ -0,0 +1,12 @@
+#!/usr/bin/env node
+
+// nb.js
+//
+// Command line interface to Nuki bridge HTTP API.
+// Copyright © 2018-2023 Erik Baauw. All rights reserved.
+
+'use strict'
+
+const { NbTool } = require('../index')
+
+new NbTool(require('../package.json')).main()

package/index.js

@@ -0,0 +1,38 @@
+// hb-nb-tools/index.js
+//
+// Homebridge NB Tools.
+// Copyright © 2017-2023 Erik Baauw. All rights reserved.
+
+'use strict'
+
+/** Homebridge NB Tools.
+  *
+  * @module hbNbTools
+  */
+class hbNbTools {
+  /** Colour conversions.
+    * <br>See {@link NbClient}.
+    * @type {Class}
+    * @memberof module:hbNbTools
+    */
+  static get NbClient () { return require('./lib/NbClient') }
+
+  /** Parser and validator for command-line arguments.
+    * <br>See {@link NbDiscovery}.
+    * @type {Class}
+    * @memberof module:hbNbTools
+    */
+  static get NbDiscovery () { return require('./lib/NbDiscovery') }
+
+  /** Command-line tool.
+    * <br>See {@link NbListener}.
+    * @type {Class}
+    * @memberof module:hbNbTools
+    */
+  static get NbListener () { return require('./lib/NbListener') }
+
+  // Command-line tools.
+  static get NbTool () { return require('./lib/NbTool') }
+}
+
+module.exports = hbNbTools

package/lib/NbClient.js

@@ -0,0 +1,224 @@
+// hb-nb-tools/lib/NbClient.js
+// Copyright © 2020-2023 Erik Baauw. All rights reserved.
+//
+// Homebridge NB Tools.
+
+'use strict'
+
+const crypto = require('crypto')
+const hbLibTools = require('hb-lib-tools')
+const { HttpClient, JsonFormatter, OptionParser } = hbLibTools
+let sodiumPlus
+try {
+  sodiumPlus = require('sodium-plus')
+} catch (error) {}
+const { CryptographyKey, SodiumPlus } = sodiumPlus || {}
+
+class NbClient extends HttpClient {
+  static get DeviceTypes () {
+    return {
+      SMARTLOCK: 0,
+      OPENER: 2,
+      SMARTDOOR: 3,
+      SMARTLOCK3: 4
+    }
+  }
+
+  static get LockStates () {
+    return {
+      UNCALIBRATED: 0,
+      LOCKED: 1,
+      UNLOCKING: 2,
+      UNLOCKED: 3,
+      LOCKING: 4,
+      UNLATCHED: 5,
+      UNLOCKED_LOCK_N_GO: 6,
+      UNLATCHING: 7,
+      MOTOR_BLOCKED: 254,
+      UNDEFINED: 255
+    }
+  }
+
+  static get DoorSensorStates () {
+    return {
+      DEACTIVATED: 0,
+      CLOSED: 2,
+      OPEN: 3,
+      UNKNOWN: 4,
+      CALIBRATING: 5
+    }
+  }
+
+  static get LockActions () {
+    return {
+      UNLOCK: 1,
+      LOCK: 2,
+      UNLATCH: 3,
+      LOCK_N_GO: 4,
+      LOCK_N_GO_WITH_UNLATCH: 5
+    }
+  }
+
+  static get OpenerModes () {
+    return {
+      DOOR_MODE: 2,
+      CONTINUOUS_MODE: 3
+    }
+  }
+
+  static get OpenerStates () {
+    return {
+      UNTRAINED: 0,
+      ONLINE: 1,
+      RTO_ACTIVE: 3,
+      OPEN: 5,
+      OPENING: 7,
+      BOOT_RUN: 253,
+      UNDEFINED: 255
+    }
+  }
+
+  static get OpenerActions () {
+    return {
+      ACTIVATE_RTO: 1,
+      DEACTIVATE_RTO: 2,
+      OPEN: 3,
+      ACTIVATE_CM: 4,
+      DEACTIVATE_CM: 5
+    }
+  }
+
+  static modelName (deviceType, firmware) {
+    switch (deviceType) {
+      case NbClient.DeviceTypes.SMARTLOCK:
+        if (firmware[0] === '1') {
+          return 'Smart Lock 1.0'
+        }
+        return 'Smart Lock 2.0'
+      case NbClient.DeviceTypes.OPENER:
+        return 'Opener'
+      case NbClient.DeviceTypes.SMARTDOOR:
+        return 'Smart Door'
+      case NbClient.DeviceTypes.SMARTLOCK3:
+        return 'Smart Lock 3.0'
+    }
+  }
+
+  constructor (params = {}) {
+    const _params = {
+      encryption: sodiumPlus == null ? 'hashedToken' : 'encryptedToken',
+      port: 8080,
+      timeout: 5
+    }
+    const optionParser = new OptionParser(_params)
+    optionParser
+      .hostKey('host')
+      .intKey('timeout', 1, 60)
+      .stringKey('token')
+      .enumKey('encryption')
+      .enumKeyValue('encryption', 'none')
+      .enumKeyValue('encryption', 'hashedToken')
+      .enumKeyValue('encryption', 'encryptedToken')
+      .parse(params)
+    super({
+      host: _params.hostname + ':' + _params.port,
+      json: true,
+      keepAlive: true,
+      maxSockets: 1,
+      timeout: _params.timeout
+    })
+    this._params = _params
+    this._jsonFormatter = new JsonFormatter()
+  }
+
+  get id () { return this._params.id }
+  get name () { return 'Nuki_Bridge_' + this._params.id }
+  get encryption () { return this._params.encryption }
+  get firmware () { return this._params.firmware }
+  get token () { return this._params.token }
+
+  async auth () {
+    const response = await this._get('/auth')
+    if (response.body.success) {
+      this._params.token = response.body.token
+      return response.body.token
+    }
+    throw new Error('Nuki bridge button not pressed')
+  }
+
+  async info () { return this._get('/info') }
+  async list () { return this._get('/list') }
+  async log () { return this._get('/log') }
+  async reboot () { return this._get('/reboot') }
+  async fwupdate () { return this._get('/fwupdate') }
+
+  async lockState (nukiId, deviceType) {
+    return this._get('/lockState', { nukiId, deviceType })
+  }
+
+  async lock (nukiId, deviceType) {
+    return this._get('/lock', { nukiId, deviceType })
+  }
+
+  async unlock (nukiId, deviceType) {
+    return this._get('/unlock', { nukiId, deviceType })
+  }
+
+  async lockAction (nukiId, deviceType, action) {
+    return this._get(
+      '/lockAction', { nukiId, deviceType, action }
+    )
+  }
+
+  async init () {
+    const response = await this.info()
+    this._params.id = response.body.ids.serverId.toString(16).toUpperCase()
+    this._params.firmware = response.body.versions.firmwareVersion
+  }
+
+  async callbackAdd (url) {
+    return this._get('/callback/add', { url: encodeURIComponent(url) })
+  }
+
+  async callbackList () { return this._get('/callback/list') }
+  async callbackRemove (id) { return this._get('/callback/remove', { id }) }
+
+  async _get (resource, params = {}) {
+    // Append parameters
+    let separator = '?'
+    for (const param in params) {
+      resource += separator + param + '=' + params[param]
+      separator = '&'
+    }
+    let suffix = ''
+    if (resource !== '/auth') {
+      if (this._params.encryption === 'none') {
+        suffix = separator + 'token=' + this._params.token
+      } else {
+        const date = new Date().toISOString()
+        const ts = date.slice(0, 19) + 'Z'
+        if (this._params.encryption === 'encryptedToken') {
+          if (this._sodium == null) {
+            const hash = crypto.createHash('sha256')
+            hash.update(this._params.token)
+            this._key = new CryptographyKey(hash.digest())
+            this._sodium = await SodiumPlus.auto()
+          }
+          const rnr = await this._sodium.randombytes_uniform(10000)
+          const nonce = await this._sodium.randombytes_buf(24)
+          const ctoken = await this._sodium.crypto_secretbox([ts, rnr].join(','), nonce, this._key)
+          suffix = separator + 'ctoken=' + ctoken.toString('hex') + '&nonce=' + nonce.toString('hex')
+        } else if (this._params.encryption === 'hashedToken') { // deprecated
+          const hash = crypto.createHash('sha256')
+          const rnr = Number(date[18] + date.slice(20, 23))
+          hash.update([ts, rnr, this._params.token].join(','))
+          suffix = separator + 'ts=' + ts + '&rnr=' + rnr +
+            '&hash=' + hash.digest('hex')
+        }
+      }
+    }
+    return super.get(resource, undefined, suffix)
+  }
+}
+
+module.exports = NbClient

package/lib/NbDiscovery.js

@@ -0,0 +1,57 @@
+// hb-nb-tools/lib/NbDiscovery.js
+// Copyright © 2020-2023 Erik Baauw. All rights reserved.
+//
+// Homebridge NB Tools.
+
+'use strict'
+
+const hbLibTools = require('hb-lib-tools')
+const { HttpClient, OptionParser } = hbLibTools
+
+class NbDiscovery extends HttpClient {
+  constructor (params = {}) {
+    const config = {
+      timeout: 5
+    }
+    const optionParser = new OptionParser(config)
+    optionParser.intKey('timeout', 1, 60)
+    optionParser.parse(params)
+    super({
+      https: true,
+      host: 'api.nuki.io',
+      json: true,
+      keepAlive: false,
+      name: 'nuki server',
+      path: '/discover',
+      timeout: config.timeout
+    })
+    this.config = config
+  }
+
+  async discover () {
+    const bridges = []
+    const response = await super.get('/bridges')
+    if (response == null) {
+      return bridges
+    }
+    for (const bridge of response.body.bridges) {
+      const client = new HttpClient({
+        host: bridge.ip + ':' + bridge.port,
+        path: '',
+        timeout: this.config.timeout,
+        validStatusCodes: [200, 401]
+      })
+      client
+        .on('error', (error) => { this.emit('error', error) })
+        .on('request', (request) => { this.emit('request', request) })
+        .on('response', (response) => { this.emit('response', response) })
+      try {
+        await client.get('/info')
+        bridges.push(bridge)
+      } catch (error) {}
+    }
+    return bridges
+  }
+}
+
+module.exports = NbDiscovery

package/lib/NbListener.js

@@ -0,0 +1,105 @@
+// homebridge-nb/lib/NbListener.js
+// Copyright © 2020-2023 Erik Baauw. All rights reserved.
+//
+// Homebridge NB Tools.
+
+'use strict'
+
+const events = require('events')
+const http = require('http')
+
+class NbListener extends events.EventEmitter {
+  constructor (port = 0) {
+    super()
+    this._myPort = port
+    this._clients = {}
+    this._clientsByName = {}
+    this._server = http.createServer((request, response) => {
+      let buffer = ''
+      request.on('data', (data) => {
+        buffer += data
+      })
+      request.on('end', async () => {
+        try {
+          request.body = buffer
+          if (request.method === 'GET' && request.url === '/notify') {
+            // Provide an easy way to check that listener is reachable.
+            response.writeHead(200, { 'Content-Type': 'text/html' })
+            response.write('<table>')
+            response.write(`<caption><h3>Listening to ${Object.keys(this._clients).length} clients</h3></caption>`)
+            response.write('<tr><th scope="col">Nuki Bridge</th>')
+            response.write('<th scope="col">IP Address</th>')
+            response.write('<th scope="col">Local IP Address</th>')
+            for (const name of Object.keys(this._clientsByName).sort()) {
+              const client = this._clientsByName[name]
+              response.write(`<tr><td>${name}</td><td>${client.address}</td>`)
+              response.write(`<td>${client.localAddress}</td></tr>`)
+            }
+            response.write('</table>')
+          } else if (request.method === 'POST') {
+            const array = request.url.split('/')
+            const client = this._clients[array[2]]
+            if (array[1] === 'notify' && client !== null) {
+              const obj = JSON.parse(request.body)
+              client.emit('event', obj)
+            }
+          }
+          response.end()
+        } catch (error) {
+          this.emit('error', error)
+        }
+      })
+    })
+    this._server
+      .on('error', (error) => { this.emit('error', error) })
+      .on('close', () => {
+        this.emit('close', this._callbackUrl)
+        delete this._callbackUrl
+      })
+  }
+
+  async _listen () {
+    if (this._server.listening) {
+      return
+    }
+    return new Promise((resolve, reject) => {
+      try {
+        this._server.listen(this._myPort, '0.0.0.0', () => {
+          const address = this._server.address()
+          this._myIp = address.address
+          this._myPort = address.port
+          this._callbackUrl =
+            'http://' + this._myIp + ':' + this._myPort + '/notify'
+          /** Emitted when the web server has started.
+            * @event NbListener#listening
+            * @param {string} url - The url the web server is listening on.
+            */
+          this.emit('listening', this._callbackUrl)
+          return resolve()
+        })
+      } catch (error) {
+        return reject(error)
+      }
+    })
+  }
+
+  async addClient (nbClient) {
+    this._clients[nbClient.id] = nbClient
+    this._clientsByName[nbClient.name] = nbClient
+    await this._listen()
+    const callbackUrl = 'http://' + nbClient.localAddress + ':' + this._myPort +
+      '/notify/' + nbClient.id
+    return callbackUrl
+  }
+
+  async removeClient (nbClient) {
+    this.removeAllListeners(nbClient.id)
+    delete this._clientsByName[nbClient.name]
+    delete this._clients[nbClient.id]
+    if (Object.keys(this._clients).length === 0) {
+      await this._server.close()
+    }
+  }
+}
+
+module.exports = NbListener

package/lib/NbTool.js

@@ -0,0 +1,645 @@
+// hb-nb-tools/lib/nb.js
+// Copyright © 2020-2023 Erik Baauw. All rights reserved.
+//
+// Command line interface to Nuki bridge HTTP API.
+
+'use strict'
+
+const NbClient = require('./NbClient')
+const NbDiscovery = require('./NbDiscovery')
+const NbListener = require('./NbListener')
+const hbLibTools = require('hb-lib-tools')
+const packageJson = require('../package.json')
+
+const { CommandLineParser, CommandLineTool, JsonFormatter, OptionParser } = hbLibTools
+const { b, u } = CommandLineTool
+const { UsageError } = CommandLineParser
+
+const usage = {
+  nb: `${b('nb')} [${b('-hVD')}] [${b('-H')} ${u('hostname')}[${b(':')}${u('port')}]] [${b('-T')} ${u('token')}] [${b('-E')} [${b('none')}|${b('hasedToken')}|${b('encryptedToken')}]] [${b('-t')} ${u('timeout')}] ${u('command')} [${u('argument')} ...]`,
+
+  discover: `${b('discover')} [${b('-h')}] [${b('-t')} ${u('timeout')}]`,
+
+  auth: `${b('auth')} [${b('-h')}]`,
+  info: `${b('info')} [${b('-h')}]`,
+  getlog: `${b('getlog')} [${b('-h')}]`,
+  clearlog: `${b('clearlog')} [${b('-h')}]`,
+  reboot: `${b('reboot')} [${b('-h')}]`,
+  fwupdate: `${b('fwupdate')} [${b('-h')}]`,
+  list: `${b('list')} [${b('-h')}]`,
+
+  lockState: `${b('lockState')} [${b('-h')}] ${u('nukiId')} ${u('deviceType')}`,
+  lock: `${b('lock')} [${b('-h')}] ${u('nukiId')} ${u('deviceType')}`,
+  unlock: `${b('unlock')} [${b('-h')}] ${u('nukiId')} ${u('deviceType')}`,
+  lockAction: `${b('lockAction')} [${b('-h')}] ${u('nukiId')} ${u('deviceType')} ${u('action')}`,
+
+  eventlog: `${b('eventlog')} [${b('-hns')}]`,
+  callbackList: `${b('callbackList')} [${b('-h')}]`,
+  callbackRemove: `${b('callbackRemove')} [${b('-h')}] ${u('id')}`
+}
+
+const description = {
+  nb: 'Command line interface to Nuki bridge HTTP API.',
+
+  discover: 'Discover Nuki bridges.',
+
+  auth: 'Obtain Nuki bridge token.',
+  info: 'Get Nuki bridge info.',
+  getlog: 'Get Nuki bridge log.',
+  clearlog: 'Clear Nuki bridge log.',
+  reboot: 'Reboot Nuki bridge.',
+  fwupdate: 'Trigger a firmware update of the bridge and connected devices.',
+  list: 'Get list of paired Nuki devices.',
+
+  lockState: 'Refresh state from paired Nuki device.',
+  lock: 'Lock paired Nuki device.',
+  unlock: 'Unlock paired Nuki device.',
+  lockAction: 'Send action to paired Nuki device.',
+
+  eventlog: 'Add Nuki bridge subscription and listen for events.',
+  callbackList: 'List Nuki bridge subscriptions.',
+  callbackRemove: 'Remove Nuki bridge subscription.'
+}
+
+const help = {
+  nb: `${description.nb}
+
+Usage: ${usage.nb}
+
+Parameters:
+  ${b('-h')}, ${b('--help')}
+  Print this help and exit.
+
+  ${b('-V')}, ${b('--version')}
+  Print version and exit.
+
+  ${b('-D')}, ${b('--debug')}
+  Print debug messages for communication with Nuki bridge.
+
+  ${b('-H')} ${u('hostname')}[${b(':')}${u('port')}], ${b('--host=')}${u('hostname')}[${b(':')}${u('port')}]
+  Connect to Nuki bridge at ${u('hostname')}${b(':8080')} or ${u('hostname')}${b(':')}${u('port')}.
+  You can also specify the hostname and port in the ${b('NB_HOST')} environment variable.
+
+  ${b('-T')} ${u('token')}, ${b('--token=')}${u('token')}
+  Use token ${u('token')} to connect to the Nuki bridge.
+  You can also specify the token in the ${b('NB_TOKEN')} environment variable.
+
+  ${b('-E')} [${b('none')}|${b('hasedToken')}|${b('encryptedToken')}], ${b('--encryption=')}[${b('none')}|${b('hasedToken')}|${b('encryptedToken')}]
+  Use encryption method for communication with the Nuki bridge.
+  The default is ${b('hashedToken')}.
+
+  ${b('-t')} ${u('timeout')}
+  Set timeout to ${u('timeout')} seconds instead of default ${b('5')}.
+
+Commands:
+  ${usage.discover}
+  ${description.discover}
+
+  ${usage.auth}
+  ${description.auth}
+
+  ${usage.info}
+  ${description.info}
+
+  ${usage.getlog}
+  ${description.getlog}
+
+  ${usage.clearlog}
+  ${description.clearlog}
+
+  ${usage.reboot}
+  ${description.reboot}
+
+  ${usage.fwupdate}
+  ${description.fwupdate}
+
+  ${usage.list}
+  ${description.list}
+
+  ${usage.lockState}
+  ${description.lockState}
+
+  ${usage.lock}
+  ${description.lock}
+
+  ${usage.unlock}
+  ${description.unlock}
+
+  ${usage.lockAction}
+  ${description.lockAction}
+
+  ${usage.eventlog}
+  ${description.eventlog}
+
+  ${usage.callbackList}
+  ${description.callbackList}
+
+  ${usage.callbackRemove}
+  ${description.callbackRemove}
+
+For more help, issue: ${b('nb')} ${u('command')} ${b('-h')}`,
+  discover: `${description.discover}
+
+Usage: ${usage.discover}
+
+Parameters:
+  ${b('-h')}, ${b('--help')}
+  Print this help and exit.`,
+  auth: `${description.auth}
+
+Usage: ${usage.auth}
+
+Parameters:
+  ${b('-h')}, ${b('--help')}
+  Print this help and exit.`,
+  info: `${description.info}
+
+Usage: ${usage.info}
+
+Parameters:
+  ${b('-h')}, ${b('--help')}
+  Print this help and exit.`,
+  getlog: `${description.getlog}
+
+Usage: ${usage.getlog}
+
+Parameters:
+  ${b('-h')}, ${b('--help')}
+  Print this help and exit.`,
+  clearlog: `${description.clearlog}
+
+Usage: ${usage.clearlog}
+
+Parameters:
+  ${b('-h')}, ${b('--help')}
+  Print this help and exit.`,
+  reboot: `${description.reboot}
+
+Usage: ${usage.reboot}
+
+Parameters:
+  ${b('-h')}, ${b('--help')}
+  Print this help and exit.`,
+  fwupdate: `${description.fwupdate}
+
+Usage: ${usage.fwupdate}
+
+Parameters:
+  ${b('-h')}, ${b('--help')}
+  Print this help and exit.`,
+  list: `${description.list}
+
+Usage: ${usage.list}
+
+Parameters:
+  ${b('-h')}, ${b('--help')}
+  Print this help and exit.`,
+  lockState: `${description.lockState}
+
+Usage: ${usage.lockState}
+
+Parameters:
+  ${b('-h')}, ${b('--help')}
+  Print this help and exit.
+
+  ${u('nukiId')}
+  The ID of the Nuki device (from ${b('nb list')}).
+
+  ${u('deviceType')}
+  The type of the Nuki device (from ${b('nb list')}):
+    0: Smart Lock 1.0 or 2.0
+    2: Opener
+    3: Smart Door
+    4: Smart Lock 3.0`,
+  lock: `${description.lock}
+
+Usage: ${usage.lock}
+
+Parameters:
+  ${b('-h')}, ${b('--help')}
+  Print this help and exit.
+
+  ${u('nukiId')}
+  The ID of the Nuki device (from ${b('nb list')}).
+
+  ${u('deviceType')}
+  The type of the Nuki device (from ${b('nb list')}):
+    0: Smart Lock 1.0 or 2.0
+    2: Opener
+    3: Smart Door
+    4: Smart Lock 3.0`,
+  unlock: `${description.unlock}
+
+Usage: ${usage.unlock}
+
+Parameters:
+  ${b('-h')}, ${b('--help')}
+  Print this help and exit.
+
+  ${u('nukiId')}
+  The ID of the Nuki device (from ${b('nb list')}).
+
+  ${u('deviceType')}
+  The type of the Nuki device (from ${b('nb list')}):
+    0: Smart Lock 1.0 or 2.0
+    2: Opener
+    3: Smart Door
+    4: Smart Lock 3.0`,
+  lockAction: `${description.lockAction}
+
+Usage: ${usage.lockAction}
+
+Parameters:
+  ${b('-h')}, ${b('--help')}
+  Print this help and exit.
+
+  ${u('nukiId')}
+  The ID of the Nuki device (from ${b('nb list')}).
+
+  ${u('deviceType')}
+  The type of the Nuki device (from ${b('nb list')}):
+    0: Smart Lock 1.0 or 2.0
+    2: Opener
+    3: Smart Door
+    4: Smart Lock 3.0
+
+  ${u('action')}
+  The action to send to the Nuki device:
+      Smart Lock, Smart Door   Opener
+    - ------------------------ -------------------------
+    1 unlock                   activate rto
+    2 lock                     deactivate rto
+    3 unlatch                  electric strike actuation
+    4 lock ‘n’ go              activate continuous mode
+    5 lock ‘n’ go with unlatch deactivate continuous mode`,
+  eventlog: `${description.eventlog}
+
+Usage: ${usage.eventlog}
+
+Parameters:
+  ${b('-h')}, ${b('--help')}
+  Print this help and exit.
+
+  ${b('-n')}, ${b('--noWhiteSpace')}
+  Do not include spaces nor newlines in JSON output.
+
+  ${b('-s')}, ${b('--service')}
+  Do not output timestamps (useful when running as service).`,
+  callbackList: `${description.callbackList}
+
+Usage: ${usage.callbackList}
+
+Parameters:
+  ${b('-h')}, ${b('--help')}
+  Print this help and exit.`,
+  callbackRemove: `${description.callbackRemove}
+
+Usage: ${usage.callbackRemove}
+
+Parameters:
+  ${b('-h')}, ${b('--help')}
+  Print this help and exit.
+
+  ${u('id')}
+  Remove callback with ID ${u('id')} (from ${b('nb callbackList')}).`
+}
+
+class NbTool extends CommandLineTool {
+  constructor (pkgJson) {
+    super({ mode: 'command', debug: false })
+    this.pkgJson = pkgJson
+    this.usage = usage.nb
+  }
+
+  parseArguments () {
+    const parser = new CommandLineParser(this.pkgJson)
+    const clargs = {
+      options: {
+        host: process.env.NB_HOST,
+        token: process.env.NB_TOKEN
+      }
+    }
+    parser
+      .help('h', 'help', help.nb)
+      .version('V', 'version')
+      .flag('D', 'debug', () => {
+        if (this.debugEnabled) {
+          this.setOptions({ vdebug: true })
+        } else {
+          this.setOptions({ debug: true, chalk: true })
+        }
+      })
+      .option('H', 'host', (value) => {
+        OptionParser.toHost('host', value, false, true)
+        clargs.options.host = value
+      })
+      .option('t', 'timeout', (value) => {
+        clargs.options.timeout = OptionParser.toInt('timeout', value, 1, 60, true)
+      })
+      .option('T', 'token', (value) => {
+        clargs.options.token = OptionParser.toString(
+          'token', value, true, true
+        )
+      })
+      .option('E', 'encryption', (value) => {
+        clargs.options.encryption = OptionParser.toString(
+          'encryption', value, true, true
+        )
+        if (!['none', 'hashedToken', 'encryptedToken'].includes(clargs.options.encryption)) {
+          throw new UsageError(`${value}: invalid encryption value`)
+        }
+      })
+      .parameter('command', (value) => {
+        if (usage[value] == null || typeof this[value] !== 'function') {
+          throw new UsageError(`${value}: unknown command`)
+        }
+        clargs.command = value
+      })
+      .remaining((list) => { clargs.args = list })
+      .parse()
+    return clargs
+  }
+
+  async main () {
+    try {
+      this.usage = usage.nb
+      const clargs = this.parseArguments()
+      this.jsonFormatter = new JsonFormatter({ sortKeys: true })
+      if (clargs.command !== 'discover') {
+        if (clargs.options.host == null) {
+          await this.fatal(`Missing host.  Set ${b('NB_HOST')} or specify ${b('-H')}.`)
+        }
+        if (clargs.command === 'auth') {
+          clargs.options.timeout = 60
+        }
+        const name = clargs.options.host
+        this.client = new NbClient(clargs.options)
+        this.client
+          .on('error', (error) => {
+            this.log(
+              '%s: request %d: %s %s', name, error.request.id,
+              error.request.method, error.request.resource
+            )
+            this.warn(
+              '%s: request %d: error: %s', name, error.request.id, error
+            )
+          })
+          .on('request', (request) => {
+            this.debug(
+              '%s: request %d: %s %s', name, request.id,
+              request.method, request.resource
+            )
+            this.vdebug(
+              '%s: request %d: %s %s', name, request.id,
+              request.method, request.url
+            )
+          })
+          .on('response', (response) => {
+            this.vdebug(
+              '%s: request %d: response: %j', name, response.request.id,
+              response.body
+            )
+            this.debug(
+              '%s: request %d: %d %s', name, response.request.id,
+              response.statusCode, response.statusMessage
+            )
+          })
+        if (clargs.options.token == null && clargs.command !== 'auth') {
+          let args = ''
+          if (clargs.options.host !== process.env.NB_HOST) {
+            args += ' -H ' + clargs.options.host
+          }
+          await this.fatal(
+            `Missing token.  Set ${b('NB_TOKEN')} or specify ${b('-T')}.  Run ${b('nb' + args + ' auth')} to obtain the token.`
+          )
+        }
+      }
+      this.name = 'nb ' + clargs.command
+      this.usage = `${b('nb')} ${usage[clargs.command]}`
+      this.parser = new CommandLineParser(packageJson)
+      this.parser.help('h', 'help', help[clargs.command])
+      await this[clargs.command](clargs.args)
+    } catch (error) {
+      await this.fatal(error)
+    }
+  }
+
+  async discover (...args) {
+    const options = {}
+    this.parser
+      .option('t', 'timeout', (value, key) => {
+        options.timeout = OptionParser.toInt('timeout', value, 1, 60, true)
+      })
+      .parse(...args)
+    const nbDiscovery = new NbDiscovery(options)
+    nbDiscovery
+      .on('error', (error) => {
+        this.log(
+          '%s: request %d: %s %s', error.request.name, error.request.id,
+          error.request.method, error.request.resource
+        )
+        this.warn(
+          '%s: request %d: error: %s', error.request.name, error.request.id, error
+        )
+      })
+      .on('request', (request) => {
+        this.debug(
+          '%s: request %d: %s %s', request.name, request.id,
+          request.method, request.resource
+        )
+        this.vdebug(
+          '%s: request %d: %s %s', request.name, request.id,
+          request.method, request.url
+        )
+      })
+      .on('response', (response) => {
+        this.vdebug(
+          '%s: request %d: response: %j', response.request.name, response.request.id,
+          response.body
+        )
+        this.debug(
+          '%s: request %d: %d %s', response.request.name, response.request.id,
+          response.statusCode, response.statusMessage
+        )
+      })
+    const bridges = await nbDiscovery.discover()
+    this.print(this.jsonFormatter.stringify(bridges))
+  }
+
+  async auth (...args) {
+    this.parser.parse(...args)
+    this.log('press button on Nuki bridge to obtain token')
+    const token = await this.client.auth()
+    this.print(token)
+  }
+
+  async info (...args) {
+    this.parser.parse(...args)
+    const response = await this.client.info()
+    this.print(this.jsonFormatter.stringify(response.body))
+  }
+
+  async getlog (...args) {
+    this.parser.parse(...args)
+    const response = await this.client.log()
+    this.print(this.jsonFormatter.stringify(response.body))
+  }
+
+  async clearlog (...args) {
+    this.parser.parse(...args)
+    const response = await this.client.clearlog()
+    this.print(this.jsonFormatter.stringify(response.body))
+  }
+
+  async reboot (...args) {
+    this.parser.parse(...args)
+    const response = await this.client.reboot()
+    this.print(this.jsonFormatter.stringify(response.body))
+  }
+
+  async fwupdate (...args) {
+    this.parser.parse(...args)
+    const response = await this.client.fwupdate()
+    this.print(this.jsonFormatter.stringify(response.body))
+  }
+
+  async list (...args) {
+    this.parser.parse(...args)
+    const response = await this.client.list()
+    this.print(this.jsonFormatter.stringify(response.body))
+  }
+
+  async lockState (...args) {
+    let nukiId
+    let deviceType
+    this.parser
+      .parameter('nukiId', (value) => {
+        nukiId = OptionParser.toInt('nukiId', value, 0, Infinity, true)
+      })
+      .parameter('deviceType', (value) => {
+        deviceType = OptionParser.toInt('deviceType', value, 0, 2, true)
+      })
+      .parse(...args)
+    const response = await this.client.lockState(nukiId, deviceType)
+    this.print(this.jsonFormatter.stringify(response.body))
+  }
+
+  async lock (...args) {
+    let nukiId
+    let deviceType
+    this.parser
+      .parameter('nukiId', (value) => {
+        nukiId = OptionParser.toInt('nukiId', value, 0, Infinity, true)
+      })
+      .parameter('deviceType', (value) => {
+        deviceType = OptionParser.toInt('deviceType', value, 0, 2, true)
+      })
+      .parse(...args)
+    const response = await this.client.lock(nukiId, deviceType)
+    this.print(this.jsonFormatter.stringify(response.body))
+  }
+
+  async unlock (...args) {
+    let nukiId
+    let deviceType
+    this.parser
+      .parameter('nukiId', (value) => {
+        nukiId = OptionParser.toInt('nukiId', value, 0, Infinity, true)
+      })
+      .parameter('deviceType', (value) => {
+        deviceType = OptionParser.toInt('deviceType', value, 0, 2, true)
+      })
+      .parse(...args)
+    const response = await this.client.unlock(nukiId, deviceType)
+    this.print(this.jsonFormatter.stringify(response.body))
+  }
+
+  async lockAction (...args) {
+    let nukiId
+    let deviceType
+    let action
+    this.parser
+      .parameter('nukiId', (value) => {
+        nukiId = OptionParser.toInt('nukiId', value, 0, Infinity, true)
+      })
+      .parameter('deviceType', (value) => {
+        deviceType = OptionParser.toInt('deviceType', value, 0, 2, true)
+      })
+      .parameter('action', (value) => {
+        action = OptionParser.toInt('action', value, 1, 5, true)
+      })
+      .parse(...args)
+    const response = await this.client.lockAction(nukiId, deviceType, action)
+    this.print(this.jsonFormatter.stringify(response.body))
+  }
+
+  async destroy () {
+    if (this.listener != null) {
+      const response = await this.client.callbackList()
+      for (const callback of response.body.callbacks) {
+        if (callback.url === this._callbackUrl) {
+          this.log(
+            'Removing subscription %s for %s', callback.id, callback.url
+          )
+          try {
+            await this.client.callbackRemove(callback.id)
+          } catch (error) {
+            this.error(error)
+          }
+        }
+      }
+      this.listener.removeClient(this.client)
+    }
+  }
+
+  async eventlog (...args) {
+    let noWhiteSpace = false
+    let mode = 'daemon'
+    this.parser
+      .flag('n', 'noWhiteSpace', () => { noWhiteSpace = true })
+      .flag('s', 'service', () => { mode = 'service' })
+      .parse(...args)
+    this.setOptions({ mode })
+    const jsonFormatter = new JsonFormatter({ sortKeys: true, noWhiteSpace })
+
+    this.listener = new NbListener()
+    this.listener
+      .on('error', (error) => { this.error(error) })
+      .on('listening', (url) => {
+        this.log('listening on %s', url)
+      })
+      .on('close', (url) => {
+        this.log('closed %s', url)
+      })
+    this.client.on('event', (event) => {
+      this.log('%s', jsonFormatter.stringify(event))
+    })
+
+    await this.client.init()
+    this._callbackUrl = await this.listener.addClient(this.client)
+    const response = await this.client.callbackAdd(this._callbackUrl)
+    if (!response.body.success) {
+      this.listener.removeClient(this.client)
+      this.error(response.body.message)
+    }
+  }
+
+  async callbackList (...args) {
+    this.parser.parse(...args)
+    const response = await this.client.callbackList()
+    this.print(this.jsonFormatter.stringify(response.body))
+  }
+
+  async callbackRemove (...args) {
+    let id
+    this.parser
+      .parameter('id', (value) => {
+        id = OptionParser.toInt('id', value, 0, Infinity, true)
+      })
+      .parse(...args)
+    const response = await this.client.callbackRemove(id)
+    this.print(this.jsonFormatter.stringify(response.body))
+  }
+}
+
+module.exports = NbTool

package/package.json

@@ -0,0 +1,37 @@
+{
+  "name": "hb-nb-tools",
+  "description": "Homebridge NB Command-Line Tools",
+  "author": "Erik Baauw",
+  "license": "Apache-2.0",
+  "version": "1.0.0",
+  "keywords": [
+    "nuki",
+    "smart-lock",
+    "lock",
+    "opener"
+  ],
+  "bin": {
+    "nb": "cli/nb.js"
+  },
+  "engines": {
+    "node": "^18.15.0"
+  },
+  "dependencies": {
+    "hb-lib-tools": "~1.0.6"
+  },
+  "optionalDependencies": {
+    "sodium-plus": "~0.9.0"
+  },
+  "scripts": {
+    "prepare": "standard",
+    "test": "standard && echo \"Error: no test specified\" && exit 1"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/ebaauw/hb-nb-tools.git"
+  },
+  "bugs": {
+    "url": "https://github.com/ebaauw/hb-nb-tools/issues"
+  },
+  "homepage": "https://github.com/ebaauw/hb-nb-tools#readme"
+}