hubot 8.0.3 → 9.0.0

package/bin/hubot.js

@@ -153,5 +153,5 @@ function loadExternalScripts () {
 
   robot.adapter.once('connected', loadScripts)
 
-  robot.run()
+  await robot.run()
 })()

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "hubot",
-  "version": "8.0.3",
+  "version": "9.0.0",
   "author": "hubot",
   "keywords": [
     "github",
@@ -15,28 +15,21 @@
     "url": "https://github.com/hubotio/hubot.git"
   },
   "dependencies": {
-    "async": "^3.2.4",
     "cline": "^0.8.2",
     "coffeescript": "^2.7.0",
     "connect-multiparty": "^2.2.0",
     "express": "^4.18.2",
     "express-basic-auth": "^1.2.1",
     "optparse": "^1.0.5",
-    "pino": "^8.11.0",
-    "standard": "^17.1.0"
+    "pino": "^8.11.0"
   },
   "devDependencies": {
-    "chai": "^4.3.7",
-    "is-circular": "^1.0.2",
-    "mocha": "^10.2.0",
-    "mockery": "^2.1.0",
     "semantic-release": "^21.0.1",
-    "sinon": "^15.0.4",
-    "sinon-chai": "^3.7.0"
+    "standard": "^17.1.0"
   },
   "engines": {
-    "node": "> 4.0.0",
-    "npm": "> 2.0.0"
+    "node": ">= 18",
+    "npm": ">= 9"
   },
   "main": "./index",
   "bin": {
@@ -45,7 +38,7 @@
   "scripts": {
     "start": "bin/hubot",
     "pretest": "standard",
-    "test": "mocha --exit",
+    "test": "node --test test/*_test.js",
     "test:smoke": "node src/**/*.js",
     "test:e2e": "bin/e2e-test.sh"
   },

package/src/adapter.js

@@ -16,8 +16,8 @@ class Adapter extends EventEmitter {
   // envelope - A Object with message, room and user details.
   // strings  - One or more Strings for each message to send.
   //
-  // Returns nothing.
-  send (envelope/* , ...strings */) {}
+  // Returns results from adapter.
+  async send (envelope, ...strings) {}
 
   // Public: Raw method for sending emote data back to the chat source.
   // Defaults as an alias for send
@@ -25,10 +25,9 @@ class Adapter extends EventEmitter {
   // envelope - A Object with message, room and user details.
   // strings  - One or more Strings for each message to send.
   //
-  // Returns nothing.
-  emote (envelope/* , ...strings */) {
-    const strings = [].slice.call(arguments, 1)
-    return this.send.apply(this, [envelope].concat(strings))
+  // Returns results from adapter.
+  async emote (envelope, ...strings) {
+    return this.send(envelope, ...strings)
   }
 
   // Public: Raw method for building a reply and sending it back to the chat
@@ -37,63 +36,68 @@ class Adapter extends EventEmitter {
   // envelope - A Object with message, room and user details.
   // strings  - One or more Strings for each reply to send.
   //
-  // Returns nothing.
-  reply (envelope/* , ...strings */) {}
+  // Returns results from adapter.
+  async reply (envelope, ...strings) {}
 
   // Public: Raw method for setting a topic on the chat source. Extend this.
   //
   // envelope - A Object with message, room and user details.
   // strings  - One more more Strings to set as the topic.
   //
-  // Returns nothing.
-  topic (envelope/* , ...strings */) {}
+  // Returns results from adapter.
+  async topic (envelope, ...strings) {}
 
   // Public: Raw method for playing a sound in the chat source. Extend this.
   //
   // envelope - A Object with message, room and user details.
   // strings  - One or more strings for each play message to send.
   //
-  // Returns nothing
-  play (envelope/* , ...strings */) {}
+  // Returns results from adapter.
+  async play (envelope, ...strings) {}
 
   // Public: Raw method for invoking the bot to run. Extend this.
   //
-  // Returns nothing.
-  run () {}
+  // Returns whatever the extended adapter returns.
+  async run () {}
 
   // Public: Raw method for shutting the bot down. Extend this.
   //
   // Returns nothing.
-  close () {}
+  close () {
+    this.removeAllListeners()
+  }
 
   // Public: Dispatch a received message to the robot.
   //
   // Returns nothing.
-  receive (message) {
-    this.robot.receive(message)
+  async receive (message) {
+    await this.robot.receive(message)
   }
 
   // Public: Get an Array of User objects stored in the brain.
   //
   // Returns an Array of User objects.
+  // @deprecated Use @robot.brain
   users () {
-    this.robot.logger.warning('@users() is going to be deprecated in 3.0.0 use @robot.brain.users()')
+    this.robot.logger.warning('@users() is going to be deprecated in 11.0.0 use @robot.brain.users()')
     return this.robot.brain.users()
   }
 
   // Public: Get a User object given a unique identifier.
   //
   // Returns a User instance of the specified user.
+  // @deprecated Use @robot.brain
   userForId (id, options) {
-    this.robot.logger.warning('@userForId() is going to be deprecated in 3.0.0 use @robot.brain.userForId()')
+    this.robot.logger.warning('@userForId() is going to be deprecated in 11.0.0 use @robot.brain.userForId()')
     return this.robot.brain.userForId(id, options)
   }
 
   // Public: Get a User object given a name.
   //
   // Returns a User instance for the user with the specified name.
+  // @deprecated Use @robot.brain
   userForName (name) {
-    this.robot.logger.warning('@userForName() is going to be deprecated in 3.0.0 use @robot.brain.userForName()')
+    this.robot.logger.warning('@userForName() is going to be deprecated in 11.0.0 use @robot.brain.userForName()')
     return this.robot.brain.userForName(name)
   }
 
@@ -102,8 +106,9 @@ class Adapter extends EventEmitter {
   // nicknames, etc.
   //
   // Returns an Array of User instances matching the fuzzy name.
+  // @deprecated Use @robot.brain
   usersForRawFuzzyName (fuzzyName) {
-    this.robot.logger.warning('@userForRawFuzzyName() is going to be deprecated in 3.0.0 use @robot.brain.userForRawFuzzyName()')
+    this.robot.logger.warning('@userForRawFuzzyName() is going to be deprecated in 11.0.0 use @robot.brain.userForRawFuzzyName()')
     return this.robot.brain.usersForRawFuzzyName(fuzzyName)
   }
 
@@ -112,8 +117,9 @@ class Adapter extends EventEmitter {
   // fuzzyName is a raw fuzzy match (see usersForRawFuzzyName).
   //
   // Returns an Array of User instances matching the fuzzy name.
+  // @deprecated Use @robot.brain
   usersForFuzzyName (fuzzyName) {
-    this.robot.logger.warning('@userForFuzzyName() is going to be deprecated in 3.0.0 use @robot.brain.userForFuzzyName()')
+    this.robot.logger.warning('@userForFuzzyName() is going to be deprecated in 11.0.0 use @robot.brain.userForFuzzyName()')
     return this.robot.brain.usersForFuzzyName(fuzzyName)
   }
 
@@ -123,8 +129,9 @@ class Adapter extends EventEmitter {
   // send the request.
   //
   // Returns a ScopedClient instance.
+  // @deprecated Use node.js fetch.
   http (url) {
-    this.robot.logger.warning('@http() is going to be deprecated in 3.0.0 use @robot.http()')
+    this.robot.logger.warning('@http() is going to be deprecated in 11.0.0 use @robot.http()')
     return this.robot.http(url)
   }
 }

package/src/adapters/campfire.js

@@ -82,7 +82,7 @@ class Campfire extends Adapter {
     })
   }
 
-  run () {
+  async run () {
     const self = this
 
     const options = {

package/src/adapters/shell.js

@@ -17,49 +17,52 @@ const historyPath = '.hubot_history'
 const bold = str => `\x1b[1m${str}\x1b[22m`
 
 class Shell extends Adapter {
+  #rl = null
   constructor (robot) {
     super(robot)
     this.name = 'Shell'
   }
 
-  send (envelope/* , ...strings */) {
-    const strings = [].slice.call(arguments, 1)
-
+  async send (envelope, ...strings) {
     Array.from(strings).forEach(str => console.log(bold(str)))
   }
 
-  emote (envelope/* , ...strings */) {
-    const strings = [].slice.call(arguments, 1)
+  async emote (envelope, ...strings) {
     Array.from(strings).map(str => this.send(envelope, `* ${str}`))
   }
 
-  reply (envelope/* , ...strings */) {
-    const strings = [].slice.call(arguments, 1).map((s) => `${envelope.user.name}: ${s}`)
-
-    this.send.apply(this, [envelope].concat(strings))
+  async reply (envelope, ...strings) {
+    strings = strings.map((s) => `${envelope.user.name}: ${s}`)
+    this.send(envelope, ...strings)
   }
 
-  run () {
+  async run () {
     this.buildCli()
-    loadHistory((error, history) => {
-      if (error) {
-        console.log(error.message)
-      }
+    try {
+      const { readlineInterface, history } = await this.#loadHistory()
       this.cli.history(history)
-      this.cli.interact(`${this.robot.name}> `)
-      return this.emit('connected', this)
-    })
+      this.cli.interact(`${this.robot.name ?? this.robot.alias}> `)
+      this.#rl = readlineInterface
+      this.emit('connected', this)
+    } catch (error) {
+      console.log(error)
+    }
   }
 
-  shutdown () {
-    this.robot.shutdown()
-    return process.exit(0)
+  close () {
+    super.close()
+    // Getting an error message on GitHubt Actions: error: 'this[#rl].close is not a function'
+    if (this.#rl?.close) {
+      this.#rl.close()
+    }
+    this.cli.removeAllListeners()
+    this.cli.close()
   }
 
   buildCli () {
     this.cli = cline()
 
-    this.cli.command('*', input => {
+    this.cli.command('*', async input => {
       let userId = process.env.HUBOT_SHELL_USER_ID || '1'
       if (userId.match(/A\d+z/)) {
         userId = parseInt(userId)
@@ -67,7 +70,7 @@ class Shell extends Adapter {
 
       const userName = process.env.HUBOT_SHELL_USER_NAME || 'Shell'
       const user = this.robot.brain.userForId(userId, { name: userName, room: 'Shell' })
-      this.receive(new TextMessage(user, input, 'messageId'))
+      await this.receive(new TextMessage(user, input, 'messageId'))
     })
 
     this.cli.command('history', () => {
@@ -90,7 +93,7 @@ class Shell extends Adapter {
       history = this.cli.history()
 
       if (history.length <= historySize) {
-        return this.shutdown()
+        return
       }
 
       const startIndex = history.length - historySize
@@ -100,11 +103,35 @@ class Shell extends Adapter {
       }
 
       const outstream = fs.createWriteStream(historyPath, fileOpts)
-      outstream.on('end', this.shutdown.bind(this))
       for (i = 0, len = history.length; i < len; i++) {
         item = history[i]
         outstream.write(item + '\n')
       }
+      outstream.end()
+    })
+  }
+
+  async #loadHistory () {
+    if (!fs.existsSync(historyPath)) {
+      return new Error('No history available')
+    }
+    const instream = fs.createReadStream(historyPath)
+    const outstream = new Stream()
+    outstream.readable = true
+    outstream.writable = true
+    const history = []
+    const readlineInterface = readline.createInterface({ input: instream, output: outstream, terminal: false })
+    return new Promise((resolve, reject) => {
+      readlineInterface.on('line', line => {
+        line = line.trim()
+        if (line.length > 0) {
+          history.push(line)
+        }
+      })
+      readlineInterface.on('close', () => {
+        resolve({ readlineInterface, history })
+      })
+      readlineInterface.on('error', reject)
     })
   }
 }
@@ -112,29 +139,3 @@ class Shell extends Adapter {
 // Prevent output buffer "swallowing" every other character on OSX / Node version > 16.19.0.
 process.stdout._handle.setBlocking(false)
 exports.use = robot => new Shell(robot)
-
-// load history from .hubot_history.
-//
-// callback - A Function that is called with the loaded history items (or an empty array if there is no history)
-function loadHistory (callback) {
-  if (!fs.existsSync(historyPath)) {
-    return callback(new Error('No history available'))
-  }
-
-  const instream = fs.createReadStream(historyPath)
-  const outstream = new Stream()
-  outstream.readable = true
-  outstream.writable = true
-
-  const items = []
-
-  readline.createInterface({ input: instream, output: outstream, terminal: false })
-    .on('line', function (line) {
-      line = line.trim()
-      if (line.length > 0) {
-        items.push(line)
-      }
-    })
-    .on('close', () => callback(null, items))
-    .on('error', callback)
-}

package/src/brain.js

@@ -109,6 +109,7 @@ class Brain extends EventEmitter {
     clearInterval(this.saveInterval)
     this.save()
     this.emit('close')
+    this.removeAllListeners()
   }
 
   // Public: Enable or disable the automatic saving

package/src/datastore.js

@@ -13,52 +13,49 @@ class DataStore {
   // write has completed.
   //
   // Value can be any JSON-serializable type.
-  set (key, value) {
-    return this._set(key, value, 'global')
+  async set (key, value) {
+    return await this._set(key, value, 'global')
   }
 
   // Public: Assuming `key` represents an object in the database,
   // sets its `objectKey` to `value`. If `key` isn't already
   // present, it's instantiated as an empty object.
-  setObject (key, objectKey, value) {
-    return this.get(key).then((object) => {
-      const target = object || {}
-      target[objectKey] = value
-      return this.set(key, target)
-    })
+  async setObject (key, objectKey, value) {
+    const object = await this.get(key)
+    const target = object || {}
+    target[objectKey] = value
+    return await this.set(key, target)
   }
 
   // Public: Adds the supplied value(s) to the end of the existing
   // array in the database marked by `key`. If `key` isn't already
   // present, it's instantiated as an empty array.
-  setArray (key, value) {
-    return this.get(key).then((object) => {
-      const target = object || []
-      // Extend the array if the value is also an array, otherwise
-      // push the single value on the end.
-      if (Array.isArray(value)) {
-        return this.set(key, target.push.apply(target, value))
-      } else {
-        return this.set(key, target.concat(value))
-      }
-    })
+  async setArray (key, value) {
+    const object = await this.get(key)
+    const target = object ?? []
+    // Extend the array if the value is also an array, otherwise
+    // push the single value on the end.
+    if (Array.isArray(value)) {
+      return await this.set(key, target.concat(value))
+    } else {
+      return await this.set(key, target.concat([value]))
+    }
   }
 
   // Public: Get value by key if in the database or return `undefined`
   // if not found. Returns a promise which resolves to the
   // requested value.
-  get (key) {
-    return this._get(key, 'global')
+  async get (key) {
+    return await this._get(key, 'global')
   }
 
   // Public: Digs inside the object at `key` for a key named
   // `objectKey`. If `key` isn't already present, or if it doesn't
   // contain an `objectKey`, returns `undefined`.
-  getObject (key, objectKey) {
-    return this.get(key).then((object) => {
-      const target = object || {}
-      return target[objectKey]
-    })
+  async getObject (key, objectKey) {
+    const object = await this.get(key)
+    const target = object || {}
+    return target[objectKey]
   }
 
   // Private: Implements the underlying `set` logic for the datastore.
@@ -70,7 +67,7 @@ class DataStore {
   // This returns a resolved promise when the `set` operation is
   // successful, and a rejected promise if the operation fails.
   _set (key, value, table) {
-    return Promise.reject(new DataStoreUnavailable('Setter called on the abstract class.'))
+    throw new DataStoreUnavailable('Setter called on the abstract class.')
   }
 
   // Private: Implements the underlying `get` logic for the datastore.
@@ -82,7 +79,7 @@ class DataStore {
   // This returns a resolved promise containing the fetched value on
   // success, and a rejected promise if the operation fails.
   _get (key, table) {
-    return Promise.reject(new DataStoreUnavailable('Getter called on the abstract class.'))
+    throw new DataStoreUnavailable('Getter called on the abstract class.')
   }
 }
 

package/src/datastores/memory.js

@@ -1,6 +1,6 @@
 'use strict'
 
-const DataStore = require('../datastore').DataStore
+const DataStore = require('../datastore.js').DataStore
 
 class InMemoryDataStore extends DataStore {
   constructor (robot) {
@@ -11,11 +11,11 @@ class InMemoryDataStore extends DataStore {
     }
   }
 
-  _get (key, table) {
+  async _get (key, table) {
     return Promise.resolve(this.data[table][key])
   }
 
-  _set (key, value, table) {
+  async _set (key, value, table) {
     return Promise.resolve(this.data[table][key] = value)
   }
 }

package/src/listener.js

@@ -20,19 +20,19 @@ class Listener {
   constructor (robot, matcher, options, callback) {
     this.robot = robot
     this.matcher = matcher
-    this.options = options
+    this.options = options ?? {}
     this.callback = callback
 
     if (this.matcher == null) {
       throw new Error('Missing a matcher for Listener')
     }
 
-    if (this.callback == null) {
+    if (!this.callback) {
       this.callback = this.options
       this.options = {}
     }
 
-    if (this.options.id == null) {
+    if (!this.options?.id) {
       this.options.id = null
     }
 
@@ -49,60 +49,40 @@ class Listener {
   //
   // message - A Message instance.
   // middleware - Optional Middleware object to execute before the Listener callback
-  // callback - Optional Function called with a boolean of whether the matcher matched
   //
-  // Returns a boolean of whether the matcher matched.
-  // Returns before executing callback
-  call (message, middleware, didMatchCallback) {
-    // middleware argument is optional
-    if (didMatchCallback == null && typeof middleware === 'function') {
-      didMatchCallback = middleware
-      middleware = undefined
+  // Returns the result of the callback.
+  async call (message, middleware) {
+    if (middleware && typeof middleware === 'function') {
+      const fn = middleware
+      middleware = new Middleware(this.robot)
+      middleware.register(fn)
     }
 
-    // ensure we have a Middleware object
-    if (middleware == null) {
+    if (!middleware) {
       middleware = new Middleware(this.robot)
     }
 
     const match = this.matcher(message)
-    if (match) {
-      if (this.regex) {
-        this.robot.logger.debug(`Message '${message}' matched regex /${inspect(this.regex)}/; listener.options = ${inspect(this.options)}`)
-      }
-
-      // special middleware-like function that always executes the Listener's
-      // callback and calls done (never calls 'next')
-      const executeListener = (context, done) => {
-        this.robot.logger.debug(`Executing listener callback for Message '${message}'`)
-        try {
-          this.callback(context.response)
-        } catch (err) {
-          this.robot.emit('error', err, context.response)
-        }
-        done()
-      }
+    if (!match) return null
+    if (this.regex) {
+      this.robot.logger.debug(`Message '${message}' matched regex /${inspect(this.regex)}/; listener.options = ${inspect(this.options)}`)
+    }
 
-      // When everything is finished (down the middleware stack and back up),
-      // pass control back to the robot
-      const allDone = function allDone () {
-        // Yes, we tried to execute the listener callback (middleware may
-        // have intercepted before actually executing though)
-        if (didMatchCallback != null) {
-          process.nextTick(() => didMatchCallback(true))
-        }
-      }
+    const response = new this.robot.Response(this.robot, message, match)
 
-      const response = new this.robot.Response(this.robot, message, match)
-      middleware.execute({ listener: this, response }, executeListener, allDone)
-      return true
-    } else {
-      if (didMatchCallback != null) {
-        // No, we didn't try to execute the listener callback
-        process.nextTick(() => didMatchCallback(false))
-      }
-      return false
+    try {
+      const shouldContinue = await middleware.execute({ listener: this, response })
+      if (shouldContinue === false) return null
+    } catch (e) {
+      this.robot.logger.error(`Error executing middleware for listener: ${e.stack}`)
+    }
+    try {
+      return await this.callback(response)
+    } catch (e) {
+      this.robot.logger.error(`Error executing listener callback: ${e.stack}`)
+      this.robot.emit('error', e, response)
     }
+    return null
   }
 }
 

package/src/message.js

@@ -7,7 +7,7 @@ class Message {
   constructor (user, done) {
     this.user = user
     this.done = done || false
-    this.room = this.user.room
+    this.room = this.user?.room
   }
 
   // Indicates that no other Listener should be called on this object

package/src/middleware.js

@@ -1,7 +1,5 @@
 'use strict'
 
-const async = require('async')
-
 class Middleware {
   constructor (robot) {
     this.robot = robot
@@ -16,68 +14,29 @@ class Middleware {
   // context - context object that is passed through the middleware stack.
   //     When handling errors, this is assumed to have a `response` property.
   //
-  // next(context, done) - Called when all middleware is complete (assuming
-  //     all continued by calling respective 'next' functions)
-  //
-  // done() - Initial (final) completion callback. May be wrapped by
-  //     executed middleware.
-  //
-  // Returns nothing
-  // Returns before executing any middleware
-  execute (context, next, done) {
-    const self = this
-
-    if (done == null) {
-      done = function () {}
-    }
-
-    // Execute a single piece of middleware and update the completion callback
-    // (each piece of middleware can wrap the 'done' callback with additional
-    // logic).
-    function executeSingleMiddleware (doneFunc, middlewareFunc, cb) {
-      // Match the async.reduce interface
-      function nextFunc (newDoneFunc) {
-        cb(null, newDoneFunc || doneFunc)
-      }
-
-      // Catch errors in synchronous middleware
+  // Returns bool, true | false, whether or not to continue execution
+  async execute (context) {
+    let shouldContinue = true
+    for await (const middleware of this.stack) {
       try {
-        middlewareFunc(context, nextFunc, doneFunc)
-      } catch (err) {
-        // Maintaining the existing error interface (Response object)
-        self.robot.emit('error', err, context.response)
-        // Forcibly fail the middleware and stop executing deeper
-        doneFunc()
+        shouldContinue = await middleware(context)
+        if (shouldContinue === false) break
+      } catch (e) {
+        this.robot.emit('error', e, context.response)
+        break
       }
     }
-
-    // Executed when the middleware stack is finished
-    function allDone (_, finalDoneFunc) {
-      next(context, finalDoneFunc)
-    }
-
-    // Execute each piece of middleware, collecting the latest 'done' callback
-    // at each step.
-    process.nextTick(async.reduce.bind(null, this.stack, done, executeSingleMiddleware, allDone))
+    return shouldContinue
   }
 
   // Public: Registers new middleware
   //
-  // middleware - A generic pipeline component function that can either
-  //              continue the pipeline or interrupt it. The function is called
-  //              with (robot, context, next, done). If execution should
-  //              continue (next middleware, final callback), the middleware
-  //              should call the 'next' function with 'done' as an optional
-  //              argument.
-  //              If not, the middleware should call the 'done' function with
-  //              no arguments. Middleware may wrap the 'done' function in
-  //              order to execute logic after the final callback has been
-  //              executed.
+  // middleware - Middleware function to execute prior to the listener callback. Return false to prevent execution of the listener callback.
   //
   // Returns nothing.
   register (middleware) {
-    if (middleware.length !== 3) {
-      throw new Error(`Incorrect number of arguments for middleware callback (expected 3, got ${middleware.length})`)
+    if (middleware.length !== 1) {
+      throw new Error(`Incorrect number of arguments for middleware callback (expected 1, got ${middleware.length})`)
     }
     this.stack.push(middleware)
   }

package/src/response.js

@@ -14,8 +14,7 @@ class Response {
     this.match = match
     this.envelope = {
       room: this.message.room,
-      user: this.message.user,
-      message: this.message
+      user: this.message.user
     }
   }
 
@@ -24,10 +23,9 @@ class Response {
   // strings - One or more strings to be posted. The order of these strings
   //           should be kept intact.
   //
-  // Returns nothing.
-  send (/* ...strings */) {
-    const strings = [].slice.call(arguments)
-    this.runWithMiddleware.apply(this, ['send', { plaintext: true }].concat(strings))
+  // Returns result from middleware.
+  async send (...strings) {
+    return await this.#runWithMiddleware('send', { plaintext: true }, ...strings)
   }
 
   // Public: Posts an emote back to the chat source
@@ -35,10 +33,9 @@ class Response {
   // strings - One or more strings to be posted. The order of these strings
   //           should be kept intact.
   //
-  // Returns nothing.
-  emote (/* ...strings */) {
-    const strings = [].slice.call(arguments)
-    this.runWithMiddleware.apply(this, ['emote', { plaintext: true }].concat(strings))
+  // Returns result from middleware.
+  async emote (...strings) {
+    return await this.#runWithMiddleware('emote', { plaintext: true }, ...strings)
   }
 
   // Public: Posts a message mentioning the current user.
@@ -46,10 +43,9 @@ class Response {
   // strings - One or more strings to be posted. The order of these strings
   //           should be kept intact.
   //
-  // Returns nothing.
-  reply (/* ...strings */) {
-    const strings = [].slice.call(arguments)
-    this.runWithMiddleware.apply(this, ['reply', { plaintext: true }].concat(strings))
+  // Returns result from middleware.
+  async reply (...strings) {
+    return await this.#runWithMiddleware('reply', { plaintext: true }, ...strings)
   }
 
   // Public: Posts a topic changing message
@@ -57,10 +53,9 @@ class Response {
   // strings - One or more strings to set as the topic of the
   //           room the bot is in.
   //
-  // Returns nothing.
-  topic (/* ...strings */) {
-    const strings = [].slice.call(arguments)
-    this.runWithMiddleware.apply(this, ['topic', { plaintext: true }].concat(strings))
+  // Returns result from middleware.
+  async topic (...strings) {
+    return await this.#runWithMiddleware('topic', { plaintext: true }, ...strings)
   }
 
   // Public: Play a sound in the chat source
@@ -68,10 +63,9 @@ class Response {
   // strings - One or more strings to be posted as sounds to play. The order of
   //           these strings should be kept intact.
   //
-  // Returns nothing
-  play (/* ...strings */) {
-    const strings = [].slice.call(arguments)
-    this.runWithMiddleware.apply(this, ['play'].concat(strings))
+  // Returns result from middleware.
+  async play (...strings) {
+    return await this.#runWithMiddleware('play', {}, ...strings)
   }
 
   // Public: Posts a message in an unlogged room
@@ -79,27 +73,17 @@ class Response {
   // strings - One or more strings to be posted. The order of these strings
   //           should be kept intact.
   //
-  // Returns nothing
-  locked (/* ...strings */) {
-    const strings = [].slice.call(arguments)
-    this.runWithMiddleware.apply(this, ['locked', { plaintext: true }].concat(strings))
+  // Returns result from middleware.
+  async locked (...strings) {
+    await this.#runWithMiddleware('locked', { plaintext: true }, ...strings)
   }
 
-  // Private: Call with a method for the given strings using response
+  // Call with a method for the given strings using response
   // middleware.
-  runWithMiddleware (methodName, opts/* , ...strings */) {
-    const self = this
-    const strings = [].slice.call(arguments, 2)
-    const copy = strings.slice(0)
-    let callback
-
-    if (typeof copy[copy.length - 1] === 'function') {
-      callback = copy.pop()
-    }
-
+  async #runWithMiddleware (methodName, opts, ...strings) {
     const context = {
       response: this,
-      strings: copy,
+      strings,
       method: methodName
     }
 
@@ -107,17 +91,9 @@ class Response {
       context.plaintext = true
     }
 
-    function responseMiddlewareDone () {}
-    function runAdapterSend (_, done) {
-      const result = context.strings
-      if (callback != null) {
-        result.push(callback)
-      }
-      self.robot.adapter[methodName].apply(self.robot.adapter, [self.envelope].concat(result))
-      done()
-    }
-
-    return this.robot.middleware.response.execute(context, runAdapterSend, responseMiddlewareDone)
+    const shouldContinue = await this.robot.middleware.response.execute(context)
+    if (shouldContinue === false) return
+    return await this.robot.adapter[methodName](this.envelope, ...context.strings)
   }
 
   // Public: Picks a random item from the given items.

package/src/robot.js

@@ -4,7 +4,6 @@ const fs = require('fs')
 const path = require('path')
 const pathToFileURL = require('url').pathToFileURL
 
-const async = require('async')
 const pino = require('pino')
 const HttpClient = require('./httpclient')
 
@@ -51,11 +50,6 @@ class Robot {
       name,
       level: process.env.HUBOT_LOG_LEVEL || 'info'
     })
-    Reflect.defineProperty(this.logger, 'warning', {
-      value: this.logger.warn,
-      enumerable: true,
-      configurable: true
-    })
 
     this.pingIntervalId = null
     this.globalHttpOptions = {}
@@ -73,10 +67,6 @@ class Robot {
     this.on('error', (err, res) => {
       return this.invokeErrorHandlers(err, res)
     })
-    this.onUncaughtException = err => {
-      return this.emit('error', err)
-    }
-    process.on('uncaughtException', this.onUncaughtException)
   }
 
   // Public: Adds a custom Listener with the provided matcher, options, and
@@ -233,9 +223,8 @@ class Robot {
       options = {}
     }
 
-    this.listen(isCatchAllMessage, options, function listenCallback (msg) {
-      msg.message = msg.message.message
-      callback(msg)
+    this.listen(isCatchAllMessage, options, async msg => {
+      await callback(msg.message)
     })
   }
 
@@ -244,11 +233,8 @@ class Robot {
   //
   // middleware - A function that determines whether or not a given matching
   //              Listener should be executed. The function is called with
-  //              (context, next, done). If execution should
-  //              continue (next middleware, Listener callback), the middleware
-  //              should call the 'next' function with 'done' as an argument.
-  //              If not, the middleware should call the 'done' function with
-  //              no arguments.
+  //              (context). If execution should, the middleware should return
+  //              true. If not, the middleware should return false.
   //
   // Returns nothing.
   listenerMiddleware (middleware) {
@@ -260,9 +246,8 @@ class Robot {
   //
   // middleware - A function that examines an outgoing message and can modify
   //              it or prevent its sending. The function is called with
-  //              (context, next, done). If execution should continue,
-  //              the middleware should call next(done). If execution should
-  //              stop, the middleware should call done(). To modify the
+  //              (context). If execution should continue, return true
+  //              otherwise return false to stop. To modify the
   //              outgoing message, set context.string to a new message.
   //
   // Returns nothing.
@@ -273,11 +258,10 @@ class Robot {
   // Public: Registers new middleware for execution before matching
   //
   // middleware - A function that determines whether or not listeners should be
-  //              checked. The function is called with (context, next, done). If
-  //              ext, next, done). If execution should continue to the next
-  //              middleware or matching phase, it should call the 'next'
-  //              function with 'done' as an argument. If not, the middleware
-  //              should call the 'done' function with no arguments.
+  //              checked. The function is called with (context). If execution
+  //              should continue to the next
+  //              middleware or matching phase, it should return true or nothing
+  //              otherwise return false to stop.
   //
   // Returns nothing.
   receiveMiddleware (middleware) {
@@ -290,14 +274,12 @@ class Robot {
   // message - A Message instance. Listeners can flag this message as 'done' to
   //           prevent further execution.
   //
-  // cb - Optional callback that is called when message processing is complete
-  //
-  // Returns nothing.
-  // Returns before executing callback
-  receive (message, cb) {
-    // When everything is finished (down the middleware stack and back up),
-    // pass control back to the robot
-    this.middleware.receive.execute({ response: new Response(this, message) }, this.processListeners.bind(this), cb)
+  // Returns array of results from listeners.
+  async receive (message) {
+    const context = { response: new Response(this, message) }
+    const shouldContinue = await this.middleware.receive.execute(context)
+    if (shouldContinue === false) return null
+    return await this.processListeners(context)
   }
 
   // Private: Passes the given message to any interested Listeners.
@@ -305,45 +287,40 @@ class Robot {
   // message - A Message instance. Listeners can flag this message as 'done' to
   //           prevent further execution.
   //
-  // done - Optional callback that is called when message processing is complete
-  //
-  // Returns nothing.
-  // Returns before executing callback
-  processListeners (context, done) {
+  // Returns array of results from listeners.
+  async processListeners (context) {
     // Try executing all registered Listeners in order of registration
     // and return after message is done being processed
+    const results = []
     let anyListenersExecuted = false
-
-    async.detectSeries(this.listeners, (listener, done) => {
+    for await (const listener of this.listeners) {
       try {
-        listener.call(context.response.message, this.middleware.listener, function (listenerExecuted) {
-          anyListenersExecuted = anyListenersExecuted || listenerExecuted
-          // Defer to the event loop at least after every listener so the
-          // stack doesn't get too big
-          process.nextTick(() =>
-            // Stop processing when message.done == true
-            done(null, context.response.message.done)
-          )
-        })
+        const match = listener.matcher(context.response.message)
+        if (!match) {
+          continue
+        }
+        const result = await listener.call(context.response.message, this.middleware.listener)
+        results.push(result)
+        anyListenersExecuted = true
       } catch (err) {
-        this.emit('error', err, new this.Response(this, context.response.message, []))
-        // Continue to next listener when there is an error
-        done(null, false)
+        this.emit('error', err, context)
       }
-    },
-    // Ignore the result ( == the listener that set message.done = true)
-    _ => {
-      // If no registered Listener matched the message
-
-      if (!(context.response.message instanceof Message.CatchAllMessage) && !anyListenersExecuted) {
-        this.logger.debug('No listeners executed; falling back to catch-all')
-        this.receive(new Message.CatchAllMessage(context.response.message), done)
-      } else {
-        if (done != null) {
-          process.nextTick(done)
-        }
+      if (context.response.message.done) {
+        break
       }
-    })
+    }
+
+    if (!isCatchAllMessage(context.response.message) && !anyListenersExecuted) {
+      this.logger.debug('No listeners executed; falling back to catch-all')
+      try {
+        const result = await this.receive(new Message.CatchAllMessage(context.response.message))
+        results.push(result)
+      } catch (err) {
+        this.emit('error', err, context)
+      }
+    }
+
+    return results
   }
 
   async loadmjs (filePath) {
@@ -389,7 +366,7 @@ class Robot {
       this.parseHelp(full)
     } catch (error) {
       this.logger.error(`Unable to load ${full}: ${error.stack}`)
-      process.exit(1)
+      throw error
     }
   }
 
@@ -424,7 +401,7 @@ class Robot {
       Object.keys(packages).forEach(key => require(key)(this, packages[key]))
     } catch (error) {
       this.logger.error(`Error loading scripts from npm package - ${error.stack}`)
-      process.exit(1)
+      throw error
     }
   }
 
@@ -472,9 +449,8 @@ class Robot {
       this.server = app.listen(port, address)
       this.router = app
     } catch (error) {
-      const err = error
-      this.logger.error(`Error trying to start HTTP server: ${err}\n${err.stack}`)
-      process.exit(1)
+      this.logger.error(`Error trying to start HTTP server: ${error}\n${error.stack}`)
+      throw error
     }
 
     let herokuUrl = process.env.HEROKU_URL
@@ -533,9 +509,9 @@ class Robot {
           }
         }
       }
-    } catch (err) {
-      this.logger.error(`Cannot load adapter ${adapterPath ?? '[no path set]'} ${this.adapterName} - ${err}`)
-      process.exit(1)
+    } catch (error) {
+      this.logger.error(`Cannot load adapter ${adapterPath ?? '[no path set]'} ${this.adapterName} - ${error}`)
+      throw error
     }
   }
 
@@ -616,10 +592,8 @@ class Robot {
   // strings  - One or more Strings for each message to send.
   //
   // Returns whatever the extending adapter returns.
-  send (envelope/* , ...strings */) {
-    const strings = [].slice.call(arguments, 1)
-
-    return this.adapter.send.apply(this.adapter, [envelope].concat(strings))
+  async send (envelope, ...strings) {
+    return await this.adapter.send(envelope, ...strings)
   }
 
   // Public: A helper reply function which delegates to the adapter's reply
@@ -629,10 +603,8 @@ class Robot {
   // strings  - One or more Strings for each message to send.
   //
   // Returns whatever the extending adapter returns.
-  reply (envelope/* , ...strings */) {
-    const strings = [].slice.call(arguments, 1)
-
-    return this.adapter.reply.apply(this.adapter, [envelope].concat(strings))
+  async reply (envelope, ...strings) {
+    return await this.adapter.reply(envelope, ...strings)
   }
 
   // Public: A helper send function to message a room that the robot is in.
@@ -641,11 +613,9 @@ class Robot {
   // strings - One or more Strings for each message to send.
   //
   // Returns whatever the extending adapter returns.
-  messageRoom (room/* , ...strings */) {
-    const strings = [].slice.call(arguments, 1)
+  async messageRoom (room, ...strings) {
     const envelope = { room }
-
-    return this.adapter.send.apply(this.adapter, [envelope].concat(strings))
+    return await this.adapter.send(envelope, ...strings)
   }
 
   // Public: A wrapper around the EventEmitter API to make usage
@@ -656,10 +626,8 @@ class Robot {
   //            when event happens.
   //
   // Returns nothing.
-  on (event/* , ...args */) {
-    const args = [].slice.call(arguments, 1)
-
-    this.events.on.apply(this.events, [event].concat(args))
+  on (event, ...args) {
+    this.events.on(event, ...args)
   }
 
   // Public: A wrapper around the EventEmitter API to make usage
@@ -669,19 +637,17 @@ class Robot {
   // args...  - Arguments emitted by the event
   //
   // Returns nothing.
-  emit (event/* , ...args */) {
-    const args = [].slice.call(arguments, 1)
-
-    this.events.emit.apply(this.events, [event].concat(args))
+  emit (event, ...args) {
+    this.events.emit(event, ...args)
   }
 
   // Public: Kick off the event loop for the adapter
   //
-  // Returns nothing.
-  run () {
+  // Returns whatever the adapter returns.
+  async run () {
     this.emit('running')
 
-    this.adapter.run()
+    return await this.adapter.run()
   }
 
   // Public: Gracefully shutdown the robot process
@@ -691,13 +657,12 @@ class Robot {
     if (this.pingIntervalId != null) {
       clearInterval(this.pingIntervalId)
     }
-    process.removeListener('uncaughtException', this.onUncaughtException)
-    this.adapter.close()
+    this.adapter?.close()
     if (this.server) {
       this.server.close()
     }
-
     this.brain.close()
+    this.events.removeAllListeners()
   }
 
   // Public: The version of Hubot from npm