@hubot-friends/hubot-slack 0.0.0-development

package/docs/_pages/about.md

@@ -0,0 +1,16 @@
+---
+layout: page
+title: About
+permalink: /about
+order: 9999
+---
+# {{ site.product_name }}
+
+{{ site.description }}
+
+{{ site.product_name }} is proudly maintained with :sparkling_heart: by the Slack Developer Tools team
+
+  * [License](https://github.com/{{ site.github_username }}/{{ site.repo_name }}/blob/master/LICENSE)
+  * [Code of Conduct](https://slackhq.github.io/code-of-conduct)
+  * [Contributing](https://github.com/{{ site.github_username }}/{{ site.repo_name }}/blob/master/.github/contributing.md)
+  * [Contributor License Agreement](https://cla-assistant.io/slackapi/hubot-slack)

package/docs/_pages/advanced_usage.md

@@ -0,0 +1,102 @@
+---
+layout: page
+title: Advanced Usage
+permalink: /advanced_usage
+order: 5
+headings:
+    - title: Customizing rtm.start options
+    - title: Customizing the RTM Client
+    - title: Activate logging for debugging
+    - title: Accessing more API methods and distribution
+    - title: Running Hubot behind an HTTP Proxy
+    - title: Customizing for shared channels
+---
+
+## Customizing rtm.start options
+
+Under the hood, each Hubot using this adapter is connected to Slack using the [RTM API](https://api.slack.com/rtm). A
+connection to the RTM API is initiated using [`rtm.start`](https://api.slack.com/methods/rtm.start).
+By default, the adapter calls this method with only the required `token` parameter. If you have more specialized needs,
+such as opting into MPIM data, you can add additional parameters to that Web API call by setting an environment
+variable. The variable is called `HUBOT_SLACK_RTM_START_OPTS`, and its value should be a JSON-encoded string with
+the additional parameters as key-value pairs. Here is an example of running hubot with that environment variable set:
+
+```
+$ HUBOT_SLACK_TOKEN=xoxb-xxxxx HUBOT_SLACK_RTM_START_OPTS='{ "mpim_aware": true }' ./bin/hubot --adapter slack
+```
+
+## Customizing the RTM Client
+
+The RTM connection is handled by the `RTMClient` class from our handy
+**Slack Developer Kit for Node.js version 3**. By default, the adapter instantiates the client with the required
+`token` parameter, but more options are available. You can customize the options for the `RTMClient` instance by setting
+an environment variable. The variable is called `HUBOT_SLACK_RTM_CLIENT_OPTS`, and its value should be a JSON-encoded
+string with the additional parameters as key-value pairs. Note that not every option can only be set to JSON-encodable
+values; you won't be able to create an instance of `SlackDataStore` and pass it in via a JSON string but you can set the
+option to `false` to opt out of using a Data Store (not recommended). Here is an example of running hubot with a custom
+retry configuration:
+
+```
+$ HUBOT_SLACK_TOKEN=xoxb-xxxxx HUBOT_SLACK_RTM_CLIENT_OPTS='{ "retryConfig": { "retries": 20 } }' ./bin/hubot --adapter slack
+```
+
+## Activate logging for debugging
+
+Hubot has a flag for setting a log level, called `HUBOT_LOG_LEVEL`. This adapter peforms all of its logging through
+Hubot, so setting it to its most detailed level, `debug`, can give you much more detailed information about activity
+at runtime. Here is an example of running hubot with its log level set to `debug`:
+
+```
+$ HUBOT_SLACK_TOKEN=xoxb-xxxxx HUBOT_LOG_LEVEL=debug ./bin/hubot --adapter slack
+```
+
+The underlying **Slack Developer Kit for Node.js** can also be supplied with a log level to get _even more_ information
+at runtime. Here is an example of combining both of these options:
+
+```
+$ HUBOT_SLACK_TOKEN=xoxb-xxxxx HUBOT_LOG_LEVEL=debug HUBOT_SLACK_RTM_CLIENT_OPTS='{ "logLevel": "debug" }' ./bin/hubot --adapter slack
+```
+
+## Accessing more API methods and distribution
+
+You might find your Hubot unable to access a Web API method. For some methods, you can resolve this by transitioning
+from an App Bot to a Custom Bot (these methods are [listed here](https://api.slack.com/bot-users#bot_methods)). If the
+method isn't available to a Custom Bot, you'll have to use an App Bot and also manage a new token.
+
+You will also need to manage a new token if you're considering distributing your Hubot powered app in the App Directory.
+
+Start by finding the new scope that your app will require. Required scopes are specified on the documentation for each
+[Web API method](https://api.slack.com/methods). Add this scope to your app on the "OAuth and Permissions" page of your
+app configuration. Once you save the changes, you need to install the app on your development workspace once again.
+
+After installing the app and authorizing the new scope, you'll notice a new **OAuth Access Token** (begins with `xoxp`).
+This is the new token that you'll need to manage. We recommend putting the new token in another environment variable,
+and using it to initialize a new `WebClient` object, as described in
+[Using the Slack Web API]({{ site.baseurl }}{% link _pages/basic_usage.md %}#{{ "Using the Slack Web API" | slugify }}). For
+example, if you put the new token in an environment variable called `SLACK_OAUTH_TOKEN`, you'd simply change the
+initialization of the `WebClient` object to the following:
+
+```javascript
+  const web = new WebClient(process.env.SLACK_OAUTH_TOKEN)
+```
+
+## Running Hubot behind an HTTP Proxy
+
+You might find the need to run Hubot inside a firewall, where the internet is only accessible via a specific proxy.
+Have no fear, environment variable configuration is here. Just add the `https_proxy` environment variable to your
+startup (we'll just do this on the command line for this example) with the address and authentication information of
+your proxy.
+
+```
+$ https_proxy="http://user:pass@localhost:8888" HUBOT_SLACK_TOKEN=xoxb-xxxxx ./bin/hubot --adapter slack
+```
+
+## Customizing for shared channels
+
+Generally, it's not supposed to invite Hubot to external shared channels. That said, the situation may arise regardless of intention.
+
+If your workspace admins would like to surely turn off Hubot's reactions to other workspace users, set `INSTALLED_TEAM_ONLY` env variable as `true`. With this option, this adapter reacts to only the messages generated by its own installed workspace users while it skips all from other workspaces.
+
+```
+$ HUBOT_SLACK_TOKEN=xoxb-xxxxx INSTALLED_TEAM_ONLY=true ./bin/hubot --adapter slack
+```

package/docs/_pages/auth.md

@@ -0,0 +1,44 @@
+---
+layout: page
+title: Tokens & Authentication
+permalink: /auth
+order: 2
+hidden: true
+headings:
+    - title: Handling tokens and other sensitive data
+---
+
+## Handling tokens and other sensitive data
+
+Slack tokens are the keys to your—or your customers'—teams. Keep them secret. Keep them safe. One way to do that is
+to never explicitly hardcode them.
+
+Try to avoid this when possible:
+
+```js
+var token = 'xoxp-abc-1232';
+```
+
+If you commit this code to GitHub, the world gains access to this token's team. Rather, we recommend you pass tokens as
+environment variables, or persist them in a database that is accessed at runtime. You can add a token to the
+environment by starting your app as:
+
+```bash
+SLACK_API_TOKEN=xoxp-abc-123 node index.js
+```
+
+You can then get the token in your code simply:
+
+```js
+var token = process.env.SLACK_API_TOKEN || '';
+```
+
+This will ensure that your app has a Slack token before it proceeds. If it doesn't, it will set a default empty string
+for the token, which will cause calls to the Web API to fail (which is what we want).
+
+You can use the same technique for other kinds of sensitive data that ne'er-do-wells could use in nefarious ways, including
+
+  * Incoming webhook URLs
+  * Slash command verification tokens
+  * Bot verification tokens
+  * App client ids and client secrets

package/docs/_pages/basic_usage.md

@@ -0,0 +1,302 @@
+---
+layout: page
+title: Basic Usage
+permalink: /basic_usage
+order: 4
+headings:
+    - title: Listening for a message
+    - title: Messages directed to your Hubot
+    - title: Sending a response
+    - title: User and conversation mentions
+    - title: Using the Slack Web API
+    - title: Working with threads
+    - title: Message reactions
+    - title: Presence changes
+    - title: Send a message to a different channel
+    - title: Text formatting and raw messages
+---
+
+Most Hubots are designed to react to user input – a user makes a request, and Hubot responds, often after going out
+into the world to trigger some action (building your code, deploying to production, and so on). Many of the tasks
+you'd like to accomplish are already well documented in the [official Hubot documentation](https://hubot.github.com/docs/).
+Nevertheless, we'll cover the basics, as well as some interesting Slack-specific use cases.
+
+--------
+
+## Listening for a message
+
+You can listen for messages in any channel that your Hubot has been invited into very simply, by using `robot.hear` with
+a RegExp to match against. Any message that matches the RegExp will trigger the function.
+
+```javascript
+module.exports = robot => // Any message that contains "badger" will trigger the following function
+robot.hear(
+  /badger/i,
+  res => // res.message is a SlackTextMessage instance that represents the incoming message Hubot just heard
+  robot.logger.debug(`Received message ${res.message.text}`)
+);
+```
+
+Hubot will only hear messages in converastions where it is a member. A human must invite Hubot into conversations
+(shortcut: `/invite @username`).
+
+--------
+
+## Messages directed to your Hubot
+
+If you want to specifically listen for messages that mention your Hubot, use the `robot.respond` method. You can also
+be more specific using a RegExp (or don't be more specific, `/.*/` will match all messages).
+
+```javascript
+module.exports = robot => // Any message that contains "badger" and is directed at Hubot (in a DM or starting with its name)
+// will trigger the following function
+robot.respond(
+  /badger/i,
+  res => robot.logger.debug(`Received message ${res.message.text}`)
+);
+```
+
+--------
+
+## Sending a response
+
+Responding to a message is straightforward, regardless of whether the message was sent to your Hubot specifically or to
+anyone in general.
+
+```javascript
+module.exports = robot => robot.hear(/badger/i, res => // Hubot sends a response to the same channel it heard the incoming message
+res.send("Yes, more badgers please!"));
+```
+
+--------
+
+## User and conversation mentions
+
+When your Hubot hears a message, it might contain mentions of other users, channels, or groups. The `text` property is
+pretty and human-readable. But this isn't great for scripting because
+[usernames are deprecated](https://api.slack.com/changelog/2017-09-the-one-about-usernames), and display names and
+conversation names can change. What you really want is an ID; it's stable to store and gives your Hubot an easy way to
+write mentions that have the user's preferred display name.
+
+Each incoming message has a `mentions` array that contains the ID and any other information known about the user or
+conversation that was mentioned.
+
+```javascript
+mmodule.exports = function(robot) {
+  // A map of user IDs to scores
+  const thank_scores = {};
+
+  return robot.hear(/thanks/i, function(res) {
+    // filter mentions to just user mentions
+    const user_mentions = (Array.from(res.message.mentions).filter((mention) => mention.type === "user"));
+
+    // when there are user mentions...
+    if (user_mentions.length > 0) {
+      let response_text = "";
+
+      // process each mention
+      for (let { id } of Array.from(user_mentions)) {
+        // increment the thank score
+        thank_scores[id] = (thank_scores[id] != null) ? (thank_scores[id] + 1) : 1;
+        // show the total score in the message with a properly formatted mention (uses display name)
+        response_text += `<@${id}> has been thanked ${thank_scores[id]} times!\n`;
+      }
+
+      // send the response
+      return res.send(response_text);
+    }
+  });
+};
+```
+
+--------
+
+## Using the Slack Web API
+
+You can access the [Slack Web API](https://api.slack.com/web_api) from your Hubot. Start by installing the
+[Slack Developer Kit for Node.js](https://slackapi.github.io/node-slack-sdk/) package into your Hubot project:
+
+```
+npm install --save @slack/client
+```
+
+Next, modify your script to instatiate a `WebClient` object using the same token your Hubot used to connect.
+
+```javascript
+// Import the Slack Developer Kit
+const {WebClient} = require("@slack/client");
+
+module.exports = function(robot) {
+  let web;
+  return web = new WebClient(robot.adapter.options.token);
+};
+```
+
+Finally, anytime you'd like to call a Web API method, call it like a method on `web`.
+
+```javascript
+// Import the Slack Developer Kit
+const {WebClient} = require("@slack/client");
+
+module.exports = function(robot) {
+  const web = new WebClient(robot.adapter.options.token);
+
+  return robot.hear(/test/i, res => web.api.test()
+    .then(() => res.send("Your connection to the Slack API is working!"))
+    .catch(error => res.send("Your connection to the Slack API failed :(")));
+};
+```
+
+You only have access to the Web API methods that your bot token is authorized to use. Depending on
+[how you installed Hubot]({{ site.baseurl }}{% link index.md %}#{{ "Getting a Slack token" | slugify }}), the
+exact list of methods is either those checked for Custom Bots or App Bots in the
+[bot methods table](https://api.slack.com/bot-users#bot_methods). If you have an App Bot and need to access a method
+only available to a Custom Bot, now might be the right time to switch. If you need access to a method that isn't listed
+in the table at all, see
+[Accessing more API methods and distribution]({{ site.baseurl }}{% link _pages/advanced_usage.md %}#{{ "Accessing more API methods and distribution" | slugify }}).
+
+--------
+
+## Working with threads
+
+Slack has the concept of [threaded messages](https://api.slack.com/docs/message-threading), which Hubot wasn't
+directly designed to support. However, with a little bit of knowledge about the underlying messages, you can create
+new threads and send messages into a thread using Hubot.
+
+
+```javascript
+module.exports = robot => robot.hear(/badger/i, function(res) {
+  if (res.message.thread_ts != null) {
+    // The incoming message was inside a thread, responding normally will continue the thread
+    return res.send("Did someone say BADGER?");
+  } else {
+    // The incoming message was not inside a thread, so lets respond by creating a new thread
+    res.message.thread_ts = res.message.rawMessage.ts;
+    return res.send("Slight digression, we need to talk about these BADGERS");
+  }
+});
+```
+
+If you want to use the `reply_broadcast` feature of threads, you'll have to
+[use the Web API directly](#{{"Using the Slack Web API" | slugify}}) for the `chat.postMessage` method.
+
+--------
+
+## Message reactions
+
+Of course, Slack is more than just text messages. Users can send
+[emoji reactions](https://get.slack.help/hc/en-us/articles/206870317-Emoji-reactions) to messages as well. Your Hubot
+can both listen for these from other users, and send reactions of its own. Here is a recipe to listen for
+emoji reactions and add the same reaction back to the same message.
+
+```javascript
+const {WebClient} = require("@slack/client");
+
+module.exports = function(robot) {
+  const web = new WebClient(robot.adapter.options.token);
+
+  return robot.hearReaction(function(res) {
+
+    // res.message is a ReactionMessage instance that represents the reaction Hubot just heard
+    if ((res.message.type === "added") && (res.message.item.type === "message")) {
+
+      // res.messsage.reaction is the emoji alias for the reaction Hubot just heard
+      return web.reactions.add({
+        name: res.message.reaction,
+        channel: res.message.item.channel,
+        timestamp: res.message.item.ts
+      });
+    }
+  });
+};
+```
+
+When using `robot.hearReaction` as shown above, the `res.message` value is of type `ReactionMessage`. In addition to the normal
+message properties, this type has a few really helpful properties you might want to use in your script:
+
+*  `type`: This is either `"added"` or `"removed"`, depending on whether, you guessed it, the reaction was added or
+   removed.
+*  `reaction`: The name of the emoji reaction. For example, when adding a 👍 reaction, this value is
+   `"thumbsup"`.
+*  `item`: This is either the message, the file, or the comment where this reaction took place.
+*  `item_user`: The user who created the item. This value can be `undefined` if the item was created by a custom
+   integration (not a Slack App).
+*  `event_ts`: The timestamp of when this reaction message took place.
+
+--------
+
+## Presence changes (deprecated)
+
+Each time a user changes from away to active, or vice-versa, Hubot can listen that event.
+
+```javascript
+module.exports = robot => robot.presenceChange(function(res) {
+
+  // res.message is a PresenceMessage instance that represents the presence change Hubot just heard
+  const names = (Array.from(res.message.users).map((user) => user.name)).join(", ");
+
+  const message = res.message.presence === "away" ? `Bye bye ${names}` : `Glad you are back ${names}`;
+  return robot.logger.debug(message);
+});
+```
+
+--------
+
+## Send a message to a different channel
+
+Responding right back to an incoming message is great, but sometimes you want send a message to a different channel.
+Hubot calls channels "rooms" and this adapter identifies rooms by channel ID, **not by channel name**. If your Hubot
+wants to send a message into another channel, it first needs to find that channel ID. You might get a channel ID from
+a previous message or you might use the Web API to translate a channel name to a channel ID. In the following example,
+we use the Web API to translate to default named channel to an ID and then store it in a variable. There's a listener
+set up that can update that variable based on an incoming message. Then a new listener is used to send data into
+the current channel in the variable, no matter where the incoming message is received.
+
+```javascript
+const {WebClient} = require("@slack/client");
+
+module.exports = function(robot) {
+  const web = new WebClient(robot.adapter.options.token);
+
+  // When the script starts up, there is no notification room
+  let notification_room = undefined;
+
+  // Immediately, a request is made to the Slack Web API to translate a default channel name into an ID
+  const default_channel_name = "general";
+  web.channels.list()
+    .then(function(api_response) {
+      // List is searched for the channel with the right name, and the notification_room is updated
+      const room = api_response.channels.find(channel => channel.name === default_channel_name);
+      if (room != null) { return notification_room = room.id; }}).catch(error => robot.logger.error(error.message));
+
+  // Any message that says "send updates here" will change the notification room
+  robot.hear(/send updates here/i, res => notification_room = res.message.rawMessage.channel.id);
+
+  // Any message that says "my update" will cause Hubot to echo that message to the notification room
+  return robot.hear(/my update/i, function(res) {
+    if (notification_room != null) {
+      return robot.messageRoom(notification_room, `An update from: <@${res.message.user.id}>: '${res.message.text}'`);
+    }
+  });
+};
+```
+
+--------
+
+## Text formatting and raw messages
+
+When your Hubot receives a message, the adapter does its best to make the `text` easy to work with by formatting links
+and mentions. This formatting sometimes removes meaningful information from the text. If you want to access the
+unaltered text in the incoming message, you can use the `rawText` property. Similarly, if you need to access any other
+property of the incoming Slack message, use the `rawMessage` property.
+
+```javascript
+module.exports = robot => // listen to all incoming messages
+robot.hear(/.*/, function(res) {
+  // find URLs in the rawText
+  const urls = res.message.rawText.match(/https?:\/\/[^\|>\s]+/gi);
+
+  // log each link found
+  if (urls) { return robot.logger.debug((Array.from(urls).map((url) => `link shared: ${url}`)).join("\n")); }
+});
+```

package/docs/_pages/changelog.html

@@ -0,0 +1,17 @@
+---
+layout: page
+title: Changelog
+permalink: /changelog
+order: 8
+---
+
+    {% for post in site.posts %}
+        <h2 id="{{ post.date | date: "%b-%-d-%Y" }}">{{ post.title }}</h2>
+        <p>{{ post.date | date: "%b %-d, %Y" }}</p>
+        <p>
+            {{ post.content }}
+        </p>
+
+    {% endfor %}
+
+<p class="rss-subscribe">subscribe <a href="{{ "/feed.xml" | prepend: site.baseurl }}">via RSS</a></p>

package/docs/_pages/upgrading.md

@@ -0,0 +1,49 @@
+---
+layout: page
+title: Upgrading from a Previous Version
+permalink: /upgrading
+order: 10
+headings:
+    - title: Upgrading from version 2 or earlier
+    - title: Upgrading from version 3 or earlier
+---
+
+## Upgrading from version 3 or earlier
+
+Version 4 of the {{ site.product_name }} adapter uses a more recent version of the Slack Developer Kit for Node.js. As a
+result, there are some syntax changes within Hubot:
+
+1. Before version 4, `msg.message.room` would return the name of the room(e.g. `general`). `msg.message.room` now
+returns a room identifier (e.g. `C03NM270D`). If you need to translate the room id to a room name, you can look it up as
+shown in
+[Send a message to a different channel]({{ site.baseurl }}{% link _pages/basic_usage.md %}#{{ "Send a message to a different channel" | slugify }}).
+
+2. Version 3 of {{ site.product_name }} supported attachments by emitting a `slack.attachment` event. In version 4, you
+use `msg.send`, passing an object with an `attachments` array:
+
+    ```javascript
+      robot.respond(/send attachments/i, msg => msg.send({
+        attachments: [
+          {
+            text: '*error*: something bad happened',
+            fallback: 'error: something bad happened',
+            color: 'danger',
+            mrkdwn_in: ['text']
+          }
+        ]
+      }));
+    ```
+
+## Upgrading from version 2 or earlier
+
+Version 3 of the {{ site.product_name }} requires different server support from previous versions. If you have an
+existing "hubot" integration set up you'll need to upgrade it:
+
+- Go to https://my.slack.com/services/new/hubot and create a new hubot integration
+- Run `npm install hubot-slack --save` to update your code.
+- Test your bot locally using: `HUBOT_SLACK_TOKEN=xoxb-1234-5678-91011-00e4dd ./bin/hubot --adapter slack`
+- Update your production startup scripts to pass the new `HUBOT_SLACK_TOKEN`. You can remove the other `HUBOT_SLACK_*`
+  environment variables if you want.
+- Deploy your new hubot to production.
+- Once you're happy it works, disable the old hubot integration from https://my.slack.com/services
+

package/docs/_posts/2016-07-15-v4.0.0.md

@@ -0,0 +1,14 @@
+---
+layout: changelog
+---
+  * Now uses the latest version of `node-slack-sdk` (v3.4.1 as of this writing), inheriting all the improvements therein.
+  * Better (and automatically enabled) reconnect logic. As in, it actually reconnects automatically at all.
+  * Now you can upload files!
+  * Significantly improved handling of messages with attachments, which is to say, we can deliver them.
+  * Message formatting of links, usernames and channel names is now working far better than it ever did, which is damning with faint praise, but hey.
+  * Long messages are now left for Slack to handle, bless their hearts.
+  * Slack usernames with `.` and `-` are now treated with the respect and dignity due to all usernames.
+  * Messages from bots are no longer filtered out, which is both cool and potentially terrifying, but we should never have silenced the robots in the first place.
+  * Remember how if you tried to hack on this adapter and used `npm link` to plug that into a live bot? And how that didn't work? Yeah? Well now it does. Stupid `instanceof`.
+  * Total refactoring of the functionality, exposing a slightly different interface. So watch out for that.
+  * You can now access the underlying Slack client directly, for when you really need low-level functionality therein.

package/docs/_posts/2016-07-19-v4.0.1.md

@@ -0,0 +1,5 @@
+---
+layout: changelog
+---
+  * Usernames with `-` and `.` no longer borked
+  * You could craft a bot that would crash Hubot by simply having it send a message. Wow! That got fixed.

package/docs/_posts/2016-08-03-v4.0.2.md

@@ -0,0 +1,4 @@
+---
+layout: changelog
+---
+  * v4 shipped with this amazing feature whereby we would silently destroy any non-string fields in a message object before sending it out. Y'all loved that feature so much, we just had to build on it. Now we silently destroy you entire message object before sending it out. J/K, that was actually a bug, and we fixed it.

package/docs/_posts/2016-09-12-v4.0.3.md

@@ -0,0 +1,8 @@
+---
+layout: changelog
+---
+  * So, you know how Hubot would crash when you tried to set the topic in a private channel? Yeah, me too. Fixed. (#350)
+  * As it happens, we were taking on some of the message formatting work that the Slack servers can do on our behalf. Fixed. (#236, #356)
+  * `robot.messageRoom` now accepts room names, not just IDs. Because sometimes all you have is a name. (#346)
+  * Treely ruly ignore all self-generated messages, for realz this time.
+  * Send all messages with `as_user=true` by default now.

package/docs/_posts/2016-09-12-v4.0.4.md

@@ -0,0 +1,4 @@
+---
+layout: changelog
+---
+  * Oh, so it turns out that the solution to using Slack's message formatting was incorrectly conceived. Fixed.

package/docs/_posts/2016-09-14-v4.0.5.md

@@ -0,0 +1,4 @@
+---
+layout: changelog
+---
+  * Sometimes you could send a message to an @username or a #channelname, but most of the time you couldn't. We have found the problem, and politely asked it to leave.

package/docs/_posts/2016-09-21-v4.1.0.md

@@ -0,0 +1,4 @@
+---
+layout: changelog
+---
+  * Somewhere out there, someone has been pining to handle message reactions. If that someone is you, this release lets you do that. Preprare to receive new `ReactionMessage` messages when reactions are added or removed from messages! To the rest of you: Carry on.

package/docs/_posts/2016-10-12-v4.2.0.md

@@ -0,0 +1,4 @@
+---
+layout: changelog
+---
+  * And now we have an even easier way of watching for message reactions

package/docs/_posts/2016-10-12-v4.2.1.md

@@ -0,0 +1,4 @@
+---
+layout: changelog
+---
+  * Emergency bugfix because typos.

package/docs/_posts/2016-11-05-v4.2.2.md

@@ -0,0 +1,8 @@
+---
+layout: changelog
+---
+  * Fixed a surprisingly wide range of bugs whereby we incorrectly formatted incoming messages that tagged
+  channels or users. Now if someone says "@foobar", your bot will here "@foobar", just as you'd expect.
+  * So, it turns out you can't have both an event handler in a base class called `topic` and a setter method
+  in a derived class called `topic`. Who knew? Stupid dynamically typed languages.
+  * v4.2.1 was retconned by the recently updated documentation. The retcon has been retconned.

package/docs/_posts/2017-01-05-v4.3.0.md

@@ -0,0 +1,5 @@
+---
+layout: changelog
+---
+  *  loads slack users into `robot.brain`. (#381) thanks @NKMR6194!
+  *  fixes various typos and inaccuracies in the docs (#383, #378, #376).

package/docs/_posts/2017-01-09-v4.3.1.md

@@ -0,0 +1,5 @@
+---
+layout: changelog
+---
+  *  fixes a bug where hubot's using a token without permission to read a user's email would
+     cause a crash (#388). thanks @aoberoi.

package/docs/_posts/2017-02-15-v4.3.2.md

@@ -0,0 +1,5 @@
+---
+layout: changelog
+---
+  *  fixes a bug where `user_change` events would cause hubot to crash (#391). thanks @aoberoi,
+  @DonEmil, and @pearswj.

package/docs/_posts/2017-02-17-v4.3.3.md

@@ -0,0 +1,4 @@
+---
+layout: changelog
+---
+  *  Adds support for message threads. Thanks @ndaversa!

package/docs/_posts/2017-03-29-v4.3.4.md

@@ -0,0 +1,5 @@
+---
+layout: changelog
+---
+  *  Fixes issue when events arrive from user's who are outside the team/workspace you are connected
+     to (#404).

package/docs/_posts/2017-08-24-v4.4.0.md

@@ -0,0 +1,7 @@
+---
+layout: changelog
+---
+  * Restore ability to inspect `rawText` and `rawMessage` on SlackMessage objects (#413) - thanks @mistydemeo
+  * Relieve extraneous `users.list` Web API method calls from occurring due to hubot brain (#419) - thanks @chapmanc
+  * Add ability to set RTMClient options and `rtm.start` options via env vars (#431, #421) - thanks @aoberoi
+  * Documentation fix (#426) - thanks @TonioOoOo