Adding upstream version 1:115.7.0.upstream/1%115.7.0upstream

Signed-off-by: Daniel Baumann <daniel.baumann@progress-linux.org>

40 files changed, 9711 insertions, 0 deletions

diff --git a/comm/chat/protocols/irc/components.conf b/comm/chat/protocols/irc/components.conf
new file mode 100644
index 0000000000..08a9674884
--- /dev/null
+++ b/comm/chat/protocols/irc/components.conf
@@ -0,0 +1,15 @@
+# -*- Mode: python; indent-tabs-mode: nil; tab-width: 40 -*-
+# vim: set filetype=python:
+# This Source Code Form is subject to the terms of the Mozilla Public
+# License, v. 2.0. If a copy of the MPL was not distributed with this
+# file, You can obtain one at http://mozilla.org/MPL/2.0/.
+
+Classes = [
+  {
+    'cid': '{607b2c0b-9504-483f-ad62-41de09238aec}',
+    'contract_ids': ['@mozilla.org/chat/irc;1'],
+    'esModule': 'resource:///modules/irc.sys.mjs',
+    'constructor': 'ircProtocol',
+    'categories': {'im-protocol-plugin': 'prpl-irc'},
+  },
+]
diff --git a/comm/chat/protocols/irc/icons/prpl-irc-32.png b/comm/chat/protocols/irc/icons/prpl-irc-32.png
new file mode 100644
index 0000000000..003103914c
--- /dev/null
+++ b/comm/chat/protocols/irc/icons/prpl-irc-32.png
diff --git a/comm/chat/protocols/irc/icons/prpl-irc-48.png b/comm/chat/protocols/irc/icons/prpl-irc-48.png
new file mode 100644
index 0000000000..606425fabb
--- /dev/null
+++ b/comm/chat/protocols/irc/icons/prpl-irc-48.png
diff --git a/comm/chat/protocols/irc/icons/prpl-irc.png b/comm/chat/protocols/irc/icons/prpl-irc.png
new file mode 100644
index 0000000000..19d578deda
--- /dev/null
+++ b/comm/chat/protocols/irc/icons/prpl-irc.png
diff --git a/comm/chat/protocols/irc/irc.sys.mjs b/comm/chat/protocols/irc/irc.sys.mjs
new file mode 100644
index 0000000000..087dbf28d8
--- /dev/null
+++ b/comm/chat/protocols/irc/irc.sys.mjs
@@ -0,0 +1,122 @@
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
+
+import { XPCOMUtils } from "resource://gre/modules/XPCOMUtils.sys.mjs";
+import { l10nHelper } from "resource:///modules/imXPCOMUtils.sys.mjs";
+import { GenericProtocolPrototype } from "resource:///modules/jsProtoHelper.sys.mjs";
+
+const lazy = {};
+
+XPCOMUtils.defineLazyGetter(lazy, "_", () =>
+  l10nHelper("chrome://chat/locale/irc.properties")
+);
+ChromeUtils.defineESModuleGetters(lazy, {
+  ircAccount: "resource:///modules/ircAccount.sys.mjs",
+});
+
+export function ircProtocol() {
+  // ircCommands.jsm exports one variable: commands. Import this directly into
+  // the protocol object.
+  this.commands = ChromeUtils.importESModule(
+    "resource:///modules/ircCommands.sys.mjs"
+  ).commands;
+  this.registerCommands();
+}
+
+ircProtocol.prototype = {
+  __proto__: GenericProtocolPrototype,
+  get name() {
+    return "IRC";
+  },
+  get normalizedName() {
+    return "irc";
+  },
+  get iconBaseURI() {
+    return "chrome://prpl-irc/skin/";
+  },
+  get usernameEmptyText() {
+    return lazy._("irc.usernameHint");
+  },
+
+  usernameSplits: [
+    {
+      get label() {
+        return lazy._("options.server");
+      },
+      separator: "@",
+      defaultValue: "irc.libera.chat",
+    },
+  ],
+
+  splitUsername(aName) {
+    let splitter = aName.lastIndexOf("@");
+    if (splitter === -1) {
+      return [];
+    }
+    return [aName.slice(0, splitter), aName.slice(splitter + 1)];
+  },
+
+  options: {
+    port: {
+      get label() {
+        return lazy._("options.port");
+      },
+      default: 6697,
+    },
+    ssl: {
+      get label() {
+        return lazy._("options.ssl");
+      },
+      default: true,
+    },
+    // TODO We should attempt to auto-detect encoding instead.
+    encoding: {
+      get label() {
+        return lazy._("options.encoding");
+      },
+      default: "UTF-8",
+    },
+    quitmsg: {
+      get label() {
+        return lazy._("options.quitMessage");
+      },
+      get default() {
+        return Services.prefs.getCharPref("chat.irc.defaultQuitMessage");
+      },
+    },
+    partmsg: {
+      get label() {
+        return lazy._("options.partMessage");
+      },
+      default: "",
+    },
+    showServerTab: {
+      get label() {
+        return lazy._("options.showServerTab");
+      },
+      default: false,
+    },
+    alternateNicks: {
+      get label() {
+        return lazy._("options.alternateNicks");
+      },
+      default: "",
+    },
+  },
+
+  get chatHasTopic() {
+    return true;
+  },
+  get slashCommandsNative() {
+    return true;
+  },
+  //  Passwords in IRC are optional, and are needed for certain functionality.
+  get passwordOptional() {
+    return true;
+  },
+
+  getAccount(aImAccount) {
+    return new lazy.ircAccount(this, aImAccount);
+  },
+};
diff --git a/comm/chat/protocols/irc/ircAccount.sys.mjs b/comm/chat/protocols/irc/ircAccount.sys.mjs
new file mode 100644
index 0000000000..6a127e16cb
--- /dev/null
+++ b/comm/chat/protocols/irc/ircAccount.sys.mjs
@@ -0,0 +1,2296 @@
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
+
+import { XPCOMUtils } from "resource://gre/modules/XPCOMUtils.sys.mjs";
+import {
+  ClassInfo,
+  executeSoon,
+  l10nHelper,
+  nsSimpleEnumerator,
+} from "resource:///modules/imXPCOMUtils.sys.mjs";
+import { clearTimeout, setTimeout } from "resource://gre/modules/Timer.sys.mjs";
+import { IMServices } from "resource:///modules/IMServices.sys.mjs";
+import {
+  ctcpFormatToHTML,
+  kListRefreshInterval,
+} from "resource:///modules/ircUtils.sys.mjs";
+import {
+  GenericAccountPrototype,
+  GenericAccountBuddyPrototype,
+  GenericConvIMPrototype,
+  GenericConvChatPrototype,
+  GenericConvChatBuddyPrototype,
+  GenericConversationPrototype,
+  TooltipInfo,
+} from "resource:///modules/jsProtoHelper.sys.mjs";
+import { NormalizedMap } from "resource:///modules/NormalizedMap.sys.mjs";
+import { Socket } from "resource:///modules/socket.sys.mjs";
+
+const lazy = {};
+
+ChromeUtils.defineESModuleGetters(lazy, {
+  DownloadUtils: "resource://gre/modules/DownloadUtils.sys.mjs",
+  PluralForm: "resource://gre/modules/PluralForm.sys.mjs",
+  ircHandlers: "resource:///modules/ircHandlers.sys.mjs",
+});
+
+XPCOMUtils.defineLazyGetter(lazy, "_conv", () =>
+  l10nHelper("chrome://chat/locale/conversations.properties")
+);
+XPCOMUtils.defineLazyGetter(lazy, "_", () =>
+  l10nHelper("chrome://chat/locale/irc.properties")
+);
+
+/*
+ * Parses a raw IRC message into an object (see section 2.3 of RFC 2812). This
+ * returns an object with the following fields:
+ *   rawMessage The initial message string received without any processing.
+ *   command    A string that is the command or response code.
+ *   params     An array of strings for the parameters. The last parameter is
+ *              stripped of its : prefix.
+ *   origin     The user's nickname or the server who sent the message. Can be
+ *              a host (e.g. irc.mozilla.org) or an IPv4 address (e.g. 1.2.3.4)
+ *              or an IPv6 address (e.g. 3ffe:1900:4545:3:200:f8ff:fe21:67cf).
+ *   user       The user's username, note that this can be undefined.
+ *   host       The user's hostname, note that this can be undefined.
+ *   source     A "nicely" formatted combination of user & host, which is
+ *              <user>@<host> or <user> if host is undefined.
+ *   tags       A Map with tags stored as key-value-pair. The value is a decoded
+ *              string or undefined if the tag has no value.
+ *
+ * There are cases (e.g. localhost) where it cannot be easily determined if a
+ * message is from a server or from a user, thus the usage of a generic "origin"
+ * instead of "nickname" or "servername".
+ *
+ * Inputs:
+ *  aData       The raw string to parse, it should already have the \r\n
+ *              stripped from the end.
+ *  aOrigin     The default origin to use for unprefixed messages.
+ */
+export function ircMessage(aData, aOrigin) {
+  let message = { rawMessage: aData };
+  let temp;
+
+  // Splits the raw string into five parts. The third part, the command, is
+  // required. A raw string looks like:
+  //   ["@" <tags> " "] [":" <prefix> " "] <command> [" " <parameter>]* [":" <last parameter>]
+  //     <tags>: /[^ ]+/
+  //     <prefix>: :(<server name> | <nickname> [["!" <user>] "@" <host>])
+  //     <command>: /[^ ]+/
+  //     <parameter>: /[^ ]+/
+  //     <last parameter>: /.+/
+  // See http://joshualuckers.nl/2010/01/10/regular-expression-to-match-raw-irc-messages/
+  // Note that this expression is slightly more aggressive in matching than RFC
+  // 2812 would allow. It allows for empty parameters (besides the last
+  // parameter, which can always be empty), by allowing multiple spaces.
+  // (This is for compatibility with Unreal's 432 response, which returns an
+  // empty first parameter.) It also allows a trailing space after the
+  // <parameter>s when no <last parameter> is present (also occurs with Unreal).
+  if (
+    !(temp = aData.match(
+      /^(?:@([^ ]+) )?(?::([^ ]+) )?([^ ]+)((?: +[^: ][^ ]*)*)? *(?::([\s\S]*))?$/
+    ))
+  ) {
+    throw new Error("Couldn't parse message: \"" + aData + '"');
+  }
+
+  message.command = temp[3];
+  // Space separated parameters. Since we expect a space as the first thing
+  // here, we want to ignore the first value (which is empty).
+  message.params = temp[4] ? temp[4].split(" ").slice(1) : [];
+  // Last parameter can contain spaces or be an empty string.
+  if (temp[5] !== undefined) {
+    message.params.push(temp[5]);
+  }
+
+  // Handle the prefix part of the message per RFC 2812 Section 2.3.
+
+  // If no prefix is given, assume the current server is the origin.
+  if (!temp[2]) {
+    temp[2] = aOrigin;
+  }
+
+  // Split the prefix into separate nickname, username and hostname fields as:
+  //   :(servername|(nickname[[!user]@host]))
+  [message.origin, message.user, message.host] = temp[2].split(/[!@]/);
+
+  // Store the tags in a Map, see IRCv3.2 Message Tags.
+  message.tags = new Map();
+
+  if (temp[1]) {
+    let tags = temp[1].split(";");
+    tags.forEach(tag => {
+      let [key, value] = tag.split("=");
+
+      if (value) {
+        // Unescape tag values according to this mapping:
+        // \\ = \
+        // \n = LF
+        // \r = CR
+        // \s = SPACE
+        // \: = ;
+        // everything else stays identical.
+        value = value.replace(/\\(.)/g, (str, type) => {
+          if (type == "\\") {
+            return "\\";
+          } else if (type == "n") {
+            return "\n";
+          } else if (type == "r") {
+            return "\r";
+          } else if (type == "s") {
+            return " ";
+          } else if (type == ":") {
+            return ";";
+          }
+          // Ignore the backslash, not specified by the spec, but as it says
+          // backslashes must be escaped this case should not occur in a valid
+          // tag value.
+          return type;
+        });
+      }
+      // The tag key can typically have the form of example.com/aaa for vendor
+      // defined tags. The spec wants any unicode characters in URLs to be
+      // in punycode (xn--). These are not unescaped to their unicode value.
+      message.tags.set(key, value);
+    });
+  }
+
+  // It is occasionally useful to have a "source" which is a combination of
+  // user@host.
+  if (message.user) {
+    message.source = message.user + "@" + message.host;
+  } else if (message.host) {
+    message.source = message.host;
+  } else {
+    message.source = "";
+  }
+
+  return message;
+}
+
+// This handles a mode change string for both channels and participants. A mode
+// change string is of the form:
+//   aAddNewMode is true if modes are being added, false otherwise.
+//   aNewModes is an array of mode characters.
+function _setMode(aAddNewMode, aNewModes) {
+  // Check each mode being added/removed.
+  for (let newMode of aNewModes) {
+    let hasMode = this._modes.has(newMode);
+    // If the mode is in the list of modes and we want to remove it.
+    if (hasMode && !aAddNewMode) {
+      this._modes.delete(newMode);
+    } else if (!hasMode && aAddNewMode) {
+      // If the mode is not in the list of modes and we want to add it.
+      this._modes.add(newMode);
+    }
+  }
+}
+
+function TagMessage(aMessage, aTagName) {
+  this.message = aMessage;
+  this.tagName = aTagName;
+  this.tagValue = aMessage.tags.get(aTagName);
+}
+
+// Properties / methods shared by both ircChannel and ircConversation.
+export var GenericIRCConversation = {
+  _observedNicks: [],
+  // This is set to true after a message is sent to notify the 401
+  // ERR_NOSUCHNICK handler to write an error message to the conversation.
+  _pendingMessage: false,
+  _waitingForNick: false,
+
+  normalizeNick(aNick) {
+    return this._account.normalizeNick(aNick);
+  },
+
+  // This will calculate the maximum number of bytes that are left for a message
+  // typed by the user by calculate the amount of bytes that would be used by
+  // the IRC messaging.
+  getMaxMessageLength() {
+    // Build the shortest possible message that could be sent to other users.
+    let baseMessage =
+      ":" +
+      this._account._nickname +
+      this._account.prefix +
+      " " +
+      this._account.buildMessage("PRIVMSG", this.name) +
+      " :\r\n";
+    return (
+      this._account.maxMessageLength - this._account.countBytes(baseMessage)
+    );
+  },
+  /**
+   * @param {string} aWho - Message author's username.
+   * @param {string} aMessage - Message text.
+   * @param {object} aObject - Other properties to set on the imMessage.
+   */
+  handleTags(aWho, aMessage, aObject) {
+    let messageProps = aObject;
+    if ("tags" in aObject && lazy.ircHandlers.hasTagHandlers) {
+      // Merge extra info for the handler into the props.
+      messageProps = Object.assign(
+        {
+          who: aWho,
+          message: aMessage,
+          get originalMessage() {
+            return aMessage;
+          },
+        },
+        messageProps
+      );
+      for (let tag of aObject.tags.keys()) {
+        // Unhandled tags may be common, since a tag does not have to be handled
+        // with a tag handler, it may also be handled by a message command handler.
+        lazy.ircHandlers.handleTag(
+          this._account,
+          new TagMessage(messageProps, tag)
+        );
+      }
+
+      // Remove helper prop for tag handlers. We don't want to remove the other
+      // ones, since they might have been changed and will override aWho and
+      // aMessage in the imMessage constructor.
+      delete messageProps.originalMessage;
+    }
+    // Remove the IRC tags, as those were passed in just for this step.
+    delete messageProps.tags;
+    return messageProps;
+  },
+  // Apply CTCP formatting before displaying.
+  prepareForDisplaying(aMsg) {
+    aMsg.displayMessage = ctcpFormatToHTML(aMsg.displayMessage);
+    GenericConversationPrototype.prepareForDisplaying.apply(this, arguments);
+  },
+  prepareForSending(aOutgoingMessage) {
+    // Split the message by line breaks and send each one individually.
+    let messages = aOutgoingMessage.message.split(/[\r\n]+/);
+
+    let maxLength = this.getMaxMessageLength();
+
+    // Attempt to smartly split a string into multiple lines (based on the
+    // maximum number of characters the message can contain).
+    for (let i = 0; i < messages.length; ++i) {
+      let message = messages[i];
+      let length = this._account.countBytes(message);
+      // The message is short enough.
+      if (length <= maxLength) {
+        continue;
+      }
+
+      // Find the location of a space before the maximum length.
+      let index = message.lastIndexOf(" ", maxLength);
+
+      // Remove the current message and insert the two new ones. If no space was
+      // found, cut the first message to the maximum length and start the second
+      // message one character after that. If a space was found, exclude it.
+      messages.splice(
+        i,
+        1,
+        message.substr(0, index == -1 ? maxLength : index),
+        message.substr(index + 1 || maxLength)
+      );
+    }
+
+    return messages;
+  },
+  dispatchMessage(message, action = false, isNotice = false) {
+    if (!message.length) {
+      return;
+    }
+
+    if (action) {
+      if (!this._account.sendCTCPMessage(this.name, false, "ACTION", message)) {
+        this.writeMessage(
+          this._account._currentServerName,
+          lazy._("error.sendMessageFailed"),
+          {
+            error: true,
+            system: true,
+          }
+        );
+        return;
+      }
+    } else if (
+      !this._account.sendMessage(isNotice ? "NOTICE" : "PRIVMSG", [
+        this.name,
+        message,
+      ])
+    ) {
+      this.writeMessage(
+        this._account._currentServerName,
+        lazy._("error.sendMessageFailed"),
+        {
+          error: true,
+          system: true,
+        }
+      );
+      return;
+    }
+
+    // By default the server doesn't send the message back, but this can be
+    // enabled with the echo-message capability. If this is not enabled, just
+    // assume the message was received and immediately show it.
+    if (!this._account._activeCAPs.has("echo-message")) {
+      this.writeMessage(
+        this._account.imAccount.alias ||
+          this._account.imAccount.statusInfo.displayName ||
+          this._account._nickname,
+        message,
+        {
+          outgoing: true,
+          notification: isNotice,
+          action,
+        }
+      );
+    }
+
+    this._pendingMessage = true;
+  },
+  // IRC doesn't support typing notifications, but it does have a maximum
+  // message length.
+  sendTyping(aString) {
+    let longestLineLength = Math.max.apply(
+      null,
+      aString.split("\n").map(this._account.countBytes, this._account)
+    );
+    return this.getMaxMessageLength() - longestLineLength;
+  },
+
+  requestCurrentWhois(aNick) {
+    if (!this._observedNicks.length) {
+      Services.obs.addObserver(this, "user-info-received");
+    }
+    this._observedNicks.push(this.normalizeNick(aNick));
+    this._account.requestCurrentWhois(aNick);
+  },
+
+  observe(aSubject, aTopic, aData) {
+    if (aTopic != "user-info-received") {
+      return;
+    }
+
+    let nick = this.normalizeNick(aData);
+    let nickIndex = this._observedNicks.indexOf(nick);
+    if (nickIndex == -1) {
+      return;
+    }
+
+    // Remove the nick from the list of nicks that are being waited to received.
+    this._observedNicks.splice(nickIndex, 1);
+
+    // If this is the last nick, remove the observer.
+    if (!this._observedNicks.length) {
+      Services.obs.removeObserver(this, "user-info-received");
+    }
+
+    // If we are waiting for the conversation name, set it.
+    let account = this._account;
+    if (this._waitingForNick && nick == this.normalizedName) {
+      if (account.whoisInformation.has(nick)) {
+        this.updateNick(account.whoisInformation.get(nick).nick);
+      }
+      delete this._waitingForNick;
+      return;
+    }
+
+    // Otherwise, print the requested whois information.
+    let type = { system: true, noLog: true };
+    // RFC 2812 errors 401 and 406 result in there being no entry for the nick.
+    if (!account.whoisInformation.has(nick)) {
+      this.writeMessage(null, lazy._("message.unknownNick", nick), type);
+      return;
+    }
+    // If the nick is offline, tell the user. In that case, it's WHOWAS info.
+    let msgType = "message.whois";
+    if ("offline" in account.whoisInformation.get(nick)) {
+      msgType = "message.whowas";
+    }
+    let msg = lazy._(msgType, account.whoisInformation.get(nick).nick);
+
+    // Iterate over each field.
+    for (let elt of aSubject.QueryInterface(Ci.nsISimpleEnumerator)) {
+      switch (elt.type) {
+        case Ci.prplITooltipInfo.pair:
+        case Ci.prplITooltipInfo.sectionHeader:
+          msg += "\n" + lazy._("message.whoisEntry", elt.label, elt.value);
+          break;
+        case Ci.prplITooltipInfo.sectionBreak:
+          break;
+        case Ci.prplITooltipInfo.status:
+          if (elt.label != Ci.imIStatusInfo.STATUS_AWAY) {
+            break;
+          }
+          // The away message has no tooltipInfo.pair entry.
+          msg +=
+            "\n" +
+            lazy._("message.whoisEntry", lazy._("tooltip.away"), elt.value);
+          break;
+      }
+    }
+    this.writeMessage(null, msg, type);
+  },
+
+  unInitIRCConversation() {
+    this._account.removeConversation(this.name);
+    if (this._observedNicks.length) {
+      Services.obs.removeObserver(this, "user-info-received");
+    }
+  },
+};
+
+export function ircChannel(aAccount, aName, aNick) {
+  this._init(aAccount, aName, aNick);
+  this._participants = new NormalizedMap(this.normalizeNick.bind(this));
+  this._modes = new Set();
+  this._observedNicks = [];
+  this.banMasks = [];
+}
+
+ircChannel.prototype = {
+  __proto__: GenericConvChatPrototype,
+  _modes: null,
+  _receivedInitialMode: false,
+  // For IRC you're not in a channel until the JOIN command is received, open
+  // all channels (initially) as left.
+  _left: true,
+  // True while we are rejoining a channel previously parted by the user.
+  _rejoined: false,
+  banMasks: [],
+
+  // Section 3.2.2 of RFC 2812.
+  part(aMessage) {
+    let params = [this.name];
+
+    // If a valid message was given, use it as the part message.
+    // Otherwise, fall back to the default part message, if it exists.
+    let msg = aMessage || this._account.getString("partmsg");
+    if (msg) {
+      params.push(msg);
+    }
+
+    this._account.sendMessage("PART", params);
+
+    // Remove reconnection information.
+    delete this.chatRoomFields;
+  },
+
+  close() {
+    // Part the room if we're connected.
+    if (this._account.connected && !this.left) {
+      this.part();
+    }
+    GenericConvChatPrototype.close.call(this);
+  },
+
+  unInit() {
+    this.unInitIRCConversation();
+    GenericConvChatPrototype.unInit.call(this);
+  },
+
+  // Use the normalized nick in order to properly notify the observers.
+  getNormalizedChatBuddyName(aNick) {
+    return this.normalizeNick(aNick);
+  },
+
+  getParticipant(aNick, aNotifyObservers) {
+    if (this._participants.has(aNick)) {
+      return this._participants.get(aNick);
+    }
+
+    let participant = new ircParticipant(aNick, this);
+    this._participants.set(aNick, participant);
+
+    // Add the participant to the whois table if it is not already there.
+    this._account.setWhois(participant._name);
+
+    if (aNotifyObservers) {
+      this.notifyObservers(
+        new nsSimpleEnumerator([participant]),
+        "chat-buddy-add"
+      );
+    }
+    return participant;
+  },
+
+  /*
+   * Add/remove modes from this channel.
+   *
+   * aNewMode is the new mode string, it MUST begin with + or -.
+   * aModeParams is a list of ordered string parameters for the mode string.
+   * aSetter is the nick of the person (or service) that set the mode.
+   */
+  setMode(aNewMode, aModeParams, aSetter) {
+    // Save this for a comparison after the new modes have been set.
+    let previousTopicSettable = this.topicSettable;
+
+    const hostMaskExp = /^.+!.+@.+$/;
+    function getNextParam() {
+      // If there's no next parameter, throw a warning.
+      if (!aModeParams.length) {
+        this.WARN("Mode parameter expected!");
+        return undefined;
+      }
+      return aModeParams.pop();
+    }
+    function peekNextParam() {
+      // Non-destructively gets the next param.
+      if (!aModeParams.length) {
+        return undefined;
+      }
+      return aModeParams.slice(-1)[0];
+    }
+
+    // Are modes being added or removed?
+    if (aNewMode[0] != "+" && aNewMode[0] != "-") {
+      this.WARN("Invalid mode string: " + aNewMode);
+      return;
+    }
+    let addNewMode = aNewMode[0] == "+";
+
+    // Check each mode being added and update the user.
+    let channelModes = [];
+    let userModes = new NormalizedMap(this.normalizeNick.bind(this));
+    let msg;
+
+    for (let i = aNewMode.length - 1; i > 0; --i) {
+      // Since some modes are conflicted between different server
+      // implementations, check if a participant with that name exists. If this
+      // is true, then update the mode of the ConvChatBuddy.
+      if (
+        this._account.memberStatuses.includes(aNewMode[i]) &&
+        aModeParams.length &&
+        this._participants.has(peekNextParam())
+      ) {
+        // Store the new modes for this nick (so each participant's mode is only
+        // updated once).
+        let nick = getNextParam();
+        if (!userModes.has(nick)) {
+          userModes.set(nick, []);
+        }
+        userModes.get(nick).push(aNewMode[i]);
+
+        // Don't use this mode as a channel mode.
+        continue;
+      } else if (aNewMode[i] == "k") {
+        // Channel key.
+        let newFields = this.name;
+        if (addNewMode) {
+          let key = getNextParam();
+          // A new channel key was set, display a message if this key is not
+          // already known.
+          if (
+            this.chatRoomFields &&
+            this.chatRoomFields.getValue("password") == key
+          ) {
+            continue;
+          }
+          msg = lazy._("message.channelKeyAdded", aSetter, key);
+          newFields += " " + key;
+        } else {
+          msg = lazy._("message.channelKeyRemoved", aSetter);
+        }
+
+        this.writeMessage(aSetter, msg, { system: true });
+        // Store the new fields for reconnect.
+        this.chatRoomFields =
+          this._account.getChatRoomDefaultFieldValues(newFields);
+      } else if (aNewMode[i] == "b") {
+        // A banmask was added or removed.
+        let banMask = getNextParam();
+        let msgKey = "message.banMask";
+        if (addNewMode) {
+          this.banMasks.push(banMask);
+          msgKey += "Added";
+        } else {
+          this.banMasks = this.banMasks.filter(aBanMask => banMask != aBanMask);
+          msgKey += "Removed";
+        }
+        this.writeMessage(aSetter, lazy._(msgKey, banMask, aSetter), {
+          system: true,
+        });
+      } else if (["e", "I", "l"].includes(aNewMode[i])) {
+        // TODO The following have parameters that must be accounted for.
+        getNextParam();
+      } else if (
+        aNewMode[i] == "R" &&
+        aModeParams.length &&
+        peekNextParam().match(hostMaskExp)
+      ) {
+        // REOP_LIST takes a mask as a parameter, since R is a conflicted mode,
+        // try to match the parameter. Implemented by IRCNet.
+        // TODO The parameter must be acounted for.
+        getNextParam();
+      }
+      // TODO From RFC 2811: a, i, m, n, q, p, s, r, t, l, e, I.
+
+      // Keep track of the channel modes in the order they were received.
+      channelModes.unshift(aNewMode[i]);
+    }
+
+    if (aModeParams.length) {
+      this.WARN("Unused mode parameters: " + aModeParams.join(", "));
+    }
+
+    // Update the mode of each participant.
+    for (let [nick, mode] of userModes.entries()) {
+      this.getParticipant(nick).setMode(addNewMode, mode, aSetter);
+    }
+
+    // If the topic can now be set (and it couldn't previously) or vice versa,
+    // notify the UI. Note that this status can change by either a channel mode
+    // or a user mode changing.
+    if (this.topicSettable != previousTopicSettable) {
+      this.notifyObservers(this, "chat-update-topic");
+    }
+
+    // If no channel modes were being set, don't display a message for it.
+    if (!channelModes.length) {
+      return;
+    }
+
+    // Store the channel modes.
+    _setMode.call(this, addNewMode, channelModes);
+
+    // Notify the UI of changes.
+    msg = lazy._(
+      "message.channelmode",
+      aNewMode[0] + channelModes.join(""),
+      aSetter
+    );
+    this.writeMessage(aSetter, msg, { system: true });
+
+    this._receivedInitialMode = true;
+  },
+
+  setModesFromRestriction(aRestriction) {
+    // First remove all types from the list of modes.
+    for (let key in this._account.channelRestrictionToModeMap) {
+      let mode = this._account.channelRestrictionToModeMap[key];
+      this._modes.delete(mode);
+    }
+
+    // Add the new mode onto the list.
+    if (aRestriction in this._account.channelRestrictionToModeMap) {
+      let mode = this._account.channelRestrictionToModeMap[aRestriction];
+      if (mode) {
+        this._modes.add(mode);
+      }
+    }
+  },
+
+  get topic() {
+    return this._topic;
+  }, // can't add a setter without redefining the getter
+  set topic(aTopic) {
+    // Note that the UI isn't updated here because the server will echo back the
+    // TOPIC to us and we'll set it on receive.
+    this._account.sendMessage("TOPIC", [this.name, aTopic]);
+  },
+  get topicSettable() {
+    // Don't use getParticipant since we don't want to lazily create it!
+    let participant = this._participants.get(this.nick);
+
+    // We must be in the room to set the topic.
+    if (!participant) {
+      return false;
+    }
+
+    // If the channel mode is +t, hops and ops can set the topic; otherwise
+    // everyone can.
+    return !this._modes.has("t") || participant.admin || participant.moderator;
+  },
+  writeMessage(aWho, aMsg, aObject) {
+    const messageProps = this.handleTags(aWho, aMsg, aObject);
+    GenericConvChatPrototype.writeMessage.call(this, aWho, aMsg, messageProps);
+  },
+};
+Object.assign(ircChannel.prototype, GenericIRCConversation);
+
+function ircParticipant(aName, aConv) {
+  this._name = aName;
+  this._conv = aConv;
+  this._account = aConv._account;
+  this._modes = new Set();
+
+  // Handle multi-prefix modes.
+  let i;
+  for (
+    i = 0;
+    i < this._name.length && this._name[i] in this._account.userPrefixToModeMap;
+    ++i
+  ) {
+    let mode = this._account.userPrefixToModeMap[this._name[i]];
+    if (mode) {
+      this._modes.add(mode);
+    }
+  }
+  this._name = this._name.slice(i);
+}
+ircParticipant.prototype = {
+  __proto__: GenericConvChatBuddyPrototype,
+
+  setMode(aAddNewMode, aNewModes, aSetter) {
+    _setMode.call(this, aAddNewMode, aNewModes);
+
+    // Notify the UI of changes.
+    let msg = lazy._(
+      "message.usermode",
+      (aAddNewMode ? "+" : "-") + aNewModes.join(""),
+      this.name,
+      aSetter
+    );
+    this._conv.writeMessage(aSetter, msg, { system: true });
+    this._conv.notifyObservers(this, "chat-buddy-update");
+  },
+
+  get voiced() {
+    return this._modes.has("v");
+  },
+  get moderator() {
+    return this._modes.has("h");
+  },
+  get admin() {
+    return this._modes.has("o");
+  },
+  get founder() {
+    return this._modes.has("O") || this._modes.has("q");
+  },
+  get typing() {
+    return false;
+  },
+};
+
+export function ircConversation(aAccount, aName) {
+  let nick = aAccount.normalize(aName);
+  if (aAccount.whoisInformation.has(nick)) {
+    aName = aAccount.whoisInformation.get(nick).nick;
+  }
+
+  this._init(aAccount, aName);
+  this._observedNicks = [];
+
+  // Fetch correctly capitalized name.
+  // Always request the info as it may be out of date.
+  this._waitingForNick = true;
+  this.requestCurrentWhois(aName);
+}
+
+ircConversation.prototype = {
+  __proto__: GenericConvIMPrototype,
+  get buddy() {
+    return this._account.buddies.get(this.name);
+  },
+
+  unInit() {
+    this.unInitIRCConversation();
+    GenericConvIMPrototype.unInit.call(this);
+  },
+
+  updateNick(aNewNick) {
+    this._name = aNewNick;
+    this.notifyObservers(null, "update-conv-title");
+  },
+  writeMessage(aWho, aMsg, aObject) {
+    const messageProps = this.handleTags(aWho, aMsg, aObject);
+    GenericConvIMPrototype.writeMessage.call(this, aWho, aMsg, messageProps);
+  },
+};
+Object.assign(ircConversation.prototype, GenericIRCConversation);
+
+function ircSocket(aAccount) {
+  this._account = aAccount;
+  this._initCharsetConverter();
+}
+ircSocket.prototype = {
+  __proto__: Socket,
+  // Although RFCs 1459 and 2812 explicitly say that \r\n is the message
+  // separator, some networks (euIRC) only send \n.
+  delimiter: /\r?\n/,
+  connectTimeout: 60, // Failure to connect after 1 minute
+  readWriteTimeout: 300, // Failure when no data for 5 minutes
+  _converter: null,
+
+  sendPing() {
+    // Send a ping using the current timestamp as a payload prefixed with
+    // an underscore to signify this was an "automatic" PING (used to avoid
+    // socket timeouts).
+    this._account.sendMessage("PING", "_" + Date.now());
+  },
+
+  _initCharsetConverter() {
+    try {
+      this._converter = new TextDecoder(this._account._encoding);
+    } catch (e) {
+      delete this._converter;
+      this.ERROR(
+        "Failed to set character set to: " +
+          this._account._encoding +
+          " for " +
+          this._account.name +
+          "."
+      );
+    }
+  },
+
+  // Implement Section 5 of RFC 2812.
+  onDataReceived(aRawMessage) {
+    let conversionWarning = "";
+    if (this._converter) {
+      try {
+        let buffer = Uint8Array.from(aRawMessage, c => c.charCodeAt(0));
+        aRawMessage = this._converter.decode(buffer);
+      } catch (e) {
+        conversionWarning =
+          "\nThis message doesn't seem to be " +
+          this._account._encoding +
+          " encoded.";
+        // Unfortunately, if the unicode converter failed once,
+        // it will keep failing so we need to reinitialize it.
+        this._initCharsetConverter();
+      }
+    }
+
+    // We've received data and are past the authentication stage.
+    if (this._account.connected) {
+      this.resetPingTimer();
+    }
+
+    // Low level dequote: replace quote character \020 followed by 0, n, r or
+    // \020 with a \0, \n, \r or \020, respectively. Any other character is
+    // replaced with itself.
+    const lowDequote = { 0: "\0", n: "\n", r: "\r", "\x10": "\x10" };
+    let dequotedMessage = aRawMessage.replace(
+      // eslint-disable-next-line no-control-regex
+      /\x10./g,
+      aStr => lowDequote[aStr[1]] || aStr[1]
+    );
+
+    try {
+      let message = new ircMessage(
+        dequotedMessage,
+        this._account._currentServerName
+      );
+      this.DEBUG(JSON.stringify(message) + conversionWarning);
+      if (!lazy.ircHandlers.handleMessage(this._account, message)) {
+        // If the message was not handled, throw a warning containing
+        // the original quoted message.
+        this.WARN("Unhandled IRC message:\n" + aRawMessage);
+      }
+    } catch (e) {
+      // Catch the error, display it and hope the connection can continue with
+      // this message in error. Errors are also caught inside of handleMessage,
+      // but we expect to handle message parsing errors here.
+      this.DEBUG(aRawMessage + conversionWarning);
+      this.ERROR(e);
+    }
+  },
+  onConnection() {
+    this._account._connectionRegistration();
+  },
+  disconnect() {
+    if (!this._account) {
+      return;
+    }
+    Socket.disconnect.call(this);
+    delete this._account;
+  },
+
+  // Throw errors if the socket has issues.
+  onConnectionClosed() {
+    // If the account was already disconnected, e.g. in response to
+    // onConnectionReset, do nothing.
+    if (!this._account) {
+      return;
+    }
+    const msg = "Connection closed by server.";
+    if (this._account.disconnecting) {
+      // The server closed the connection before we handled the ERROR
+      // response to QUIT.
+      this.LOG(msg);
+      this._account.gotDisconnected();
+    } else {
+      this.WARN(msg);
+      this._account.gotDisconnected(
+        Ci.prplIAccount.ERROR_NETWORK_ERROR,
+        lazy._("connection.error.lost")
+      );
+    }
+  },
+  onConnectionReset() {
+    this.WARN("Connection reset.");
+    this._account.gotDisconnected(
+      Ci.prplIAccount.ERROR_NETWORK_ERROR,
+      lazy._("connection.error.lost")
+    );
+  },
+  onConnectionTimedOut() {
+    this.WARN("Connection timed out.");
+    this._account.gotDisconnected(
+      Ci.prplIAccount.ERROR_NETWORK_ERROR,
+      lazy._("connection.error.timeOut")
+    );
+  },
+  onConnectionSecurityError(aTLSError, aNSSErrorMessage) {
+    this.WARN(
+      "Bad certificate or SSL connection for " +
+        this._account.name +
+        ":\n" +
+        aNSSErrorMessage
+    );
+    let error = this._account.handleConnectionSecurityError(this);
+    this._account.gotDisconnected(error, aNSSErrorMessage);
+  },
+
+  get DEBUG() {
+    return this._account.DEBUG;
+  },
+  get LOG() {
+    return this._account.LOG;
+  },
+  get WARN() {
+    return this._account.WARN;
+  },
+  get ERROR() {
+    return this._account.ERROR;
+  },
+};
+
+function ircAccountBuddy(aAccount, aBuddy, aTag, aUserName) {
+  this._init(aAccount, aBuddy, aTag, aUserName);
+}
+ircAccountBuddy.prototype = {
+  __proto__: GenericAccountBuddyPrototype,
+
+  // Returns an array of prplITooltipInfo objects to be displayed when the
+  // user hovers over the buddy.
+  getTooltipInfo() {
+    return this._account.getBuddyInfo(this.normalizedName);
+  },
+
+  // Allow sending of messages to buddies even if they are not online since IRC
+  // does not always provide status information in a timely fashion. (Note that
+  // this is OK since the server will throw an error if the user is not online.)
+  get canSendMessage() {
+    return this.account.connected;
+  },
+
+  // Called when the user wants to chat with the buddy.
+  createConversation() {
+    return this._account.createConversation(this.userName);
+  },
+
+  remove() {
+    this._account.removeBuddy(this);
+    GenericAccountBuddyPrototype.remove.call(this);
+  },
+};
+
+function ircRoomInfo(aName, aAccount) {
+  this.name = aName;
+  this._account = aAccount;
+}
+ircRoomInfo.prototype = {
+  __proto__: ClassInfo("prplIRoomInfo", "IRC RoomInfo Object"),
+  get topic() {
+    return this._account._channelList.get(this.name).topic;
+  },
+  get participantCount() {
+    return this._account._channelList.get(this.name).participantCount;
+  },
+  get chatRoomFieldValues() {
+    return this._account.getChatRoomDefaultFieldValues(this.name);
+  },
+};
+
+export function ircAccount(aProtocol, aImAccount) {
+  this._init(aProtocol, aImAccount);
+  this.buddies = new NormalizedMap(this.normalizeNick.bind(this));
+  this.conversations = new NormalizedMap(this.normalize.bind(this));
+
+  // Split the account name into usable parts.
+  const [accountNickname, server] = this.protocol.splitUsername(this.name);
+  this._accountNickname = accountNickname;
+  this._server = server;
+  // To avoid _currentServerName being null, initialize it to the server being
+  // connected to. This will also get overridden during the 001 response from
+  // the server.
+  this._currentServerName = this._server;
+
+  this._nickname = this._accountNickname;
+  this._requestedNickname = this._nickname;
+
+  // For more information, see where these are defined in the prototype below.
+  this.trackQueue = [];
+  this.pendingIsOnQueue = [];
+  this.whoisInformation = new NormalizedMap(this.normalizeNick.bind(this));
+  this._requestedCAPs = new Set();
+  this._availableCAPs = new Set();
+  this._activeCAPs = new Set();
+  this._queuedCAPs = [];
+  this._commandBuffers = new Map();
+  this._roomInfoCallbacks = new Set();
+}
+
+ircAccount.prototype = {
+  __proto__: GenericAccountPrototype,
+  _socket: null,
+  _MODE_WALLOPS: 1 << 2, // mode 'w'
+  _MODE_INVISIBLE: 1 << 3, // mode 'i'
+  get _mode() {
+    return 0;
+  },
+
+  // The name of the server we last connected to.
+  _currentServerName: null,
+  // Whether to attempt authenticating with NickServ.
+  shouldAuthenticate: true,
+  // Whether the user has successfully authenticated with NickServ.
+  isAuthenticated: false,
+  // The current in use nickname.
+  _nickname: null,
+  // The nickname stored in the account name.
+  _accountNickname: null,
+  // The nickname that was last requested by the user.
+  _requestedNickname: null,
+  // The nickname that was last requested. This can differ from
+  // _requestedNickname when a new nick is automatically generated (e.g. by
+  // adding digits).
+  _sentNickname: null,
+  // If we don't get the desired nick on connect, we try again a bit later,
+  // to see if it wasn't just our nick not having timed out yet.
+  _nickInUseTimeout: null,
+  get username() {
+    let username;
+    // Use a custom username in a hidden preference.
+    if (this.prefs.prefHasUserValue("username")) {
+      username = this.getString("username");
+    }
+    // But fallback to brandShortName if no username is provided (or is empty).
+    if (!username) {
+      username = Services.appinfo.name;
+    }
+
+    return username;
+  },
+  // The prefix minus the nick (!user@host) as returned by the server, this is
+  // necessary for guessing message lengths.
+  prefix: null,
+
+  // Parts of the specification give max lengths, keep track of them since a
+  // server can overwrite them. The defaults given here are from RFC 2812.
+  maxNicknameLength: 9, // 1.2.1 Users
+  maxChannelLength: 50, // 1.3 Channels
+  maxMessageLength: 512, // 2.3 Messages
+  maxHostnameLength: 63, // 2.3.1 Message format in Augmented BNF
+
+  // The default prefixes to modes.
+  userPrefixToModeMap: { "@": "o", "!": "n", "%": "h", "+": "v" },
+  get userPrefixes() {
+    return Object.keys(this.userPrefixToModeMap);
+  },
+  // Modes that have a nickname parameter and affect a participant. See 4.1
+  // Member Status of RFC 2811.
+  memberStatuses: ["a", "h", "o", "O", "q", "v", "!"],
+  channelPrefixes: ["&", "#", "+", "!"], // 1.3 Channels
+  channelRestrictionToModeMap: { "@": "s", "*": "p", "=": null }, // 353 RPL_NAMREPLY
+
+  // Handle Scandanavian lower case (optionally remove status indicators).
+  // See Section 2.2 of RFC 2812: the characters {}|^ are considered to be the
+  // lower case equivalents of the characters []\~, respectively.
+  normalizeExpression: /[\x41-\x5E]/g,
+  normalize(aStr, aPrefixes) {
+    let str = aStr;
+
+    if (aPrefixes) {
+      while (aPrefixes.includes(str[0])) {
+        str = str.slice(1);
+      }
+    }
+
+    return str.replace(this.normalizeExpression, c =>
+      String.fromCharCode(c.charCodeAt(0) + 0x20)
+    );
+  },
+  normalizeNick(aNick) {
+    return this.normalize(aNick, this.userPrefixes);
+  },
+
+  isMUCName(aStr) {
+    return this.channelPrefixes.includes(aStr[0]);
+  },
+
+  // Tell the server about status changes. IRC is only away or not away;
+  // consider the away, idle and unavailable status type to be away.
+  isAway: false,
+  observe(aSubject, aTopic, aData) {
+    if (aTopic != "status-changed") {
+      return;
+    }
+
+    let { statusType: type, statusText: text } = this.imAccount.statusInfo;
+    this.DEBUG("New status received:\ntype = " + type + "\ntext = " + text);
+
+    // Tell the server to mark us as away.
+    if (type < Ci.imIStatusInfo.STATUS_AVAILABLE) {
+      // We have to have a string in order to set IRC as AWAY.
+      if (!text) {
+        // If no status is given, use the the default idle/away message.
+        const IDLE_PREF_BRANCH = "messenger.status.";
+        const IDLE_PREF = "defaultIdleAwayMessage";
+        text = Services.prefs.getComplexValue(
+          IDLE_PREF_BRANCH + IDLE_PREF,
+          Ci.nsIPrefLocalizedString
+        ).data;
+
+        if (!text) {
+          // Get the default value of the localized preference.
+          text = Services.prefs
+            .getDefaultBranch(IDLE_PREF_BRANCH)
+            .getComplexValue(IDLE_PREF, Ci.nsIPrefLocalizedString).data;
+        }
+        // The last resort, fallback to a non-localized string.
+        if (!text) {
+          text = "Away";
+        }
+      }
+      this.sendMessage("AWAY", text); // Mark as away.
+    } else if (type == Ci.imIStatusInfo.STATUS_AVAILABLE && this.isAway) {
+      // Mark as back.
+      this.sendMessage("AWAY");
+    }
+  },
+
+  // The user's user mode.
+  _modes: null,
+  _userModeReceived: false,
+  setUserMode(aNick, aNewModes, aSetter, aDisplayFullMode) {
+    if (this.normalizeNick(aNick) != this.normalizeNick(this._nickname)) {
+      this.WARN("Received unexpected mode for " + aNick);
+      return false;
+    }
+
+    // Are modes being added or removed?
+    let addNewMode = aNewModes[0] == "+";
+    if (!addNewMode && aNewModes[0] != "-") {
+      this.WARN("Invalid mode string: " + aNewModes);
+      return false;
+    }
+    _setMode.call(this, addNewMode, aNewModes.slice(1));
+
+    // The server informs us of the user's mode when connecting.
+    // We should not report this initial mode message as a mode change
+    // initiated by the user, but instead display the full mode
+    // and then remember we have done so.
+    this._userModeReceived = true;
+
+    if (this._showServerTab) {
+      let msg;
+      if (aDisplayFullMode) {
+        msg = lazy._("message.yourmode", Array.from(this._modes).join(""));
+      } else {
+        msg = lazy._(
+          "message.usermode",
+          aNewModes,
+          aNick,
+          aSetter || this._currentServerName
+        );
+      }
+      this.getConversation(this._currentServerName).writeMessage(
+        this._currentServerName,
+        msg,
+        { system: true }
+      );
+    }
+    return true;
+  },
+
+  // Room info: maps channel names to {topic, participantCount}.
+  _channelList: new Map(),
+  _roomInfoCallbacks: new Set(),
+  // If true, we have sent the LIST request and are waiting for replies.
+  _pendingList: false,
+  // Callbacks receive this many channels per call while results are incoming.
+  _channelsPerBatch: 50,
+  _currentBatch: [],
+  _lastListTime: 0,
+  get isRoomInfoStale() {
+    return Date.now() - this._lastListTime > kListRefreshInterval;
+  },
+  // Called by consumers that want a list of available channels, which are
+  // provided through the callback (prplIRoomInfoCallback instance).
+  requestRoomInfo(aCallback, aIsUserRequest) {
+    // Ignore the automaticList pref if the user explicitly requests /list.
+    if (
+      !aIsUserRequest &&
+      !Services.prefs.getBoolPref("chat.irc.automaticList")
+    ) {
+      // Pretend we can't return roomInfo.
+      throw Components.Exception("", Cr.NS_ERROR_NOT_IMPLEMENTED);
+    }
+    if (this._roomInfoCallbacks.has(aCallback)) {
+      // Callback is not new.
+      return;
+    }
+    // Send a LIST request if the channel list is stale and a current request
+    // has not been sent.
+    if (this.isRoomInfoStale && !this._pendingList) {
+      this._channelList = new Map();
+      this._currentBatch = [];
+      this._pendingList = true;
+      this._lastListTime = Date.now();
+      this.sendMessage("LIST");
+    } else {
+      // Otherwise, pass channels that have already been received to the callback.
+      let rooms = [...this._channelList.keys()];
+      aCallback.onRoomInfoAvailable(rooms, !this._pendingList);
+    }
+
+    if (this._pendingList) {
+      this._roomInfoCallbacks.add(aCallback);
+    }
+  },
+  // Pass room info for any remaining channels to callbacks and clean up.
+  _sendRemainingRoomInfo() {
+    if (this._currentBatch.length) {
+      for (let callback of this._roomInfoCallbacks) {
+        callback.onRoomInfoAvailable(this._currentBatch, true);
+      }
+    }
+    this._roomInfoCallbacks.clear();
+    delete this._pendingList;
+    delete this._currentBatch;
+  },
+  getRoomInfo(aName) {
+    return new ircRoomInfo(aName, this);
+  },
+
+  // The last time a buffered command was sent.
+  _lastCommandSendTime: 0,
+  // A map from command names to the parameter buffer for that command.
+  // This buffer is a map from first parameter to the corresponding (optional)
+  // second parameter, to ensure automatic deduplication.
+  _commandBuffers: new Map(),
+  _handleCommandBuffer(aCommand) {
+    let buffer = this._commandBuffers.get(aCommand);
+    if (!buffer || !buffer.size) {
+      return;
+    }
+    // This short delay should usually not affect commands triggered by
+    // user action, but helps gather commands together which are sent
+    // by the prpl on connection (e.g. WHOIS sent in response to incoming
+    // WATCH results).
+    const kInterval = 1000;
+    let delay = kInterval - (Date.now() - this._lastCommandSendTime);
+    if (delay > 0) {
+      setTimeout(() => this._handleCommandBuffer(aCommand), delay);
+      return;
+    }
+    this._lastCommandSendTime = Date.now();
+
+    let getParams = aItems => {
+      // Taking the JOIN use case as an example, aItems is an array
+      // of [channel, key] pairs.
+      // To work around an inspircd bug (bug 1108596), we reorder
+      // the list so that entries with keys appear first.
+      let items = aItems.slice().sort(([c1, k1], [c2, k2]) => {
+        if (!k1 && k2) {
+          return 1;
+        }
+        if (k1 && !k2) {
+          return -1;
+        }
+        return 0;
+      });
+      // To send the command, we have to group all the channels and keys
+      // together, i.e. grab the columns of this matrix, and build the two
+      // parameters of the command from that.
+      let channels = items.map(([channel, key]) => channel);
+      let keys = items.map(([channel, key]) => key).filter(key => !!key);
+      let params = [channels.join(",")];
+      if (keys.length) {
+        params.push(keys.join(","));
+      }
+      return params;
+    };
+    let tooMany = aItems => {
+      let params = getParams(aItems);
+      let length = this.countBytes(this.buildMessage(aCommand, params)) + 2;
+      return this.maxMessageLength < length;
+    };
+    let send = aItems => {
+      let params = getParams(aItems);
+      // Send the command, but don't log the keys.
+      this.sendMessage(
+        aCommand,
+        params,
+        aCommand +
+          " " +
+          params[0] +
+          (params.length > 1 ? " <keys not logged>" : "")
+      );
+    };
+
+    let items = [];
+    for (let item of buffer) {
+      items.push(item);
+      if (tooMany(items)) {
+        items.pop();
+        send(items);
+        items = [item];
+      }
+    }
+    send(items);
+    buffer.clear();
+  },
+  // For commands which allow an arbitrary number of parameters, we use a
+  // buffer to send as few commands as possible, by gathering the parameters.
+  // On servers which impose command penalties (e.g. inspircd) this helps
+  // avoid triggering fakelags by minimizing the command penalty.
+  // aParam is the first and aKey the optional second parameter of a command
+  // with the syntax <param> *("," <param>) [<key> *("," <key>)]
+  // While this code is mostly abstracted, it is currently assumed the second
+  // parameter is only used for JOIN.
+  sendBufferedCommand(aCommand, aParam, aKey = "") {
+    if (!this._commandBuffers.has(aCommand)) {
+      this._commandBuffers.set(aCommand, new Map());
+    }
+    let buffer = this._commandBuffers.get(aCommand);
+    // If the buffer is empty, schedule sending the command, otherwise
+    // we just need to add the parameter to the buffer.
+    // We use executeSoon so as to not delay the sending of these
+    // commands when it is not necessary.
+    if (!buffer.size) {
+      executeSoon(() => this._handleCommandBuffer(aCommand));
+    }
+    buffer.set(aParam, aKey);
+  },
+
+  // The whois information: nicks are used as keys and refer to a map of field
+  // to value.
+  whoisInformation: null,
+  // Request WHOIS information on a buddy when the user requests more
+  // information. If we already have some WHOIS information stored for this
+  // nick, a notification with this (potentially out-of-date) information
+  // is sent out immediately. It is followed by another notification when
+  // the current WHOIS data is returned by the server.
+  // If you are only interested in the current WHOIS, requestCurrentWhois
+  // should be used instead.
+  requestBuddyInfo(aBuddyName) {
+    if (!this.connected) {
+      return;
+    }
+
+    // Return what we have stored immediately.
+    if (this.whoisInformation.has(aBuddyName)) {
+      this.notifyWhois(aBuddyName);
+    }
+
+    // Request the current whois and update.
+    this.requestCurrentWhois(aBuddyName);
+  },
+  // Request fresh WHOIS information on a nick.
+  requestCurrentWhois(aNick) {
+    if (!this.connected) {
+      return;
+    }
+
+    this.removeBuddyInfo(aNick);
+    this.sendBufferedCommand("WHOIS", aNick);
+  },
+  notifyWhois(aNick) {
+    Services.obs.notifyObservers(
+      new nsSimpleEnumerator(this.getBuddyInfo(aNick)),
+      "user-info-received",
+      this.normalizeNick(aNick)
+    );
+  },
+  // Request WHOWAS information on a buddy when the user requests more
+  // information.
+  requestOfflineBuddyInfo(aBuddyName) {
+    this.removeBuddyInfo(aBuddyName);
+    this.sendMessage("WHOWAS", aBuddyName);
+  },
+  // Return an array of prplITooltipInfo for a given nick.
+  getBuddyInfo(aNick) {
+    if (!this.whoisInformation.has(aNick)) {
+      return [];
+    }
+
+    let whoisInformation = this.whoisInformation.get(aNick);
+    if (whoisInformation.serverName && whoisInformation.serverInfo) {
+      whoisInformation.server = lazy._(
+        "tooltip.serverValue",
+        whoisInformation.serverName,
+        whoisInformation.serverInfo
+      );
+    }
+
+    // Sort the list of channels, ignoring the prefixes of channel and user.
+    let prefixes = this.userPrefixes.concat(this.channelPrefixes);
+    let sortWithoutPrefix = function (a, b) {
+      a = this.normalize(a, prefixes);
+      b = this.normalize(b, prefixes);
+      if (a < b) {
+        return -1;
+      }
+      return a > b ? 1 : 0;
+    }.bind(this);
+    let sortChannels = channels =>
+      channels.trim().split(/\s+/).sort(sortWithoutPrefix).join(" ");
+
+    // Convert booleans into a human-readable form.
+    let normalizeBool = aBool => lazy._(aBool ? "yes" : "no");
+
+    // Convert timespan in seconds into a human-readable form.
+    let normalizeTime = function (aTime) {
+      let valuesAndUnits = lazy.DownloadUtils.convertTimeUnits(aTime);
+      // If the time is exact to the first set of units, trim off
+      // the subsequent zeroes.
+      if (!valuesAndUnits[2]) {
+        valuesAndUnits.splice(2, 2);
+      }
+      return lazy._("tooltip.timespan", valuesAndUnits.join(" "));
+    };
+
+    // List of the names of the info to actually show in the tooltip and
+    // optionally a transform function to apply to the value. Each field here
+    // maps to tooltip.<fieldname> in irc.properties.
+    // See the various RPL_WHOIS* results for the options.
+    const kFields = {
+      realname: null,
+      server: null,
+      connectedFrom: null,
+      registered: normalizeBool,
+      registeredAs: null,
+      secure: normalizeBool,
+      ircOp: normalizeBool,
+      bot: normalizeBool,
+      lastActivity: normalizeTime,
+      channels: sortChannels,
+    };
+
+    let tooltipInfo = [];
+    for (let field in kFields) {
+      if (whoisInformation.hasOwnProperty(field) && whoisInformation[field]) {
+        let value = whoisInformation[field];
+        if (kFields[field]) {
+          value = kFields[field](value);
+        }
+        tooltipInfo.push(new TooltipInfo(lazy._("tooltip." + field), value));
+      }
+    }
+
+    const kSetIdleStatusAfterSeconds = 3600;
+    let statusType = Ci.imIStatusInfo.STATUS_AVAILABLE;
+    let statusText = "";
+    if ("away" in whoisInformation) {
+      statusType = Ci.imIStatusInfo.STATUS_AWAY;
+      statusText = whoisInformation.away;
+    } else if ("offline" in whoisInformation) {
+      statusType = Ci.imIStatusInfo.STATUS_OFFLINE;
+    } else if (
+      "lastActivity" in whoisInformation &&
+      whoisInformation.lastActivity > kSetIdleStatusAfterSeconds
+    ) {
+      statusType = Ci.imIStatusInfo.STATUS_IDLE;
+    }
+    tooltipInfo.push(
+      new TooltipInfo(statusType, statusText, Ci.prplITooltipInfo.status)
+    );
+
+    return tooltipInfo;
+  },
+  // Remove a WHOIS entry.
+  removeBuddyInfo(aNick) {
+    return this.whoisInformation.delete(aNick);
+  },
+  // Copies the fields of aFields into the whois table. If the field already
+  // exists, that field is ignored (it is assumed that the first server response
+  // is the most up to date information, as is the case for 312/314). Note that
+  // the whois info for a nick is reset whenever whois information is requested,
+  // so the first response from each whois is recorded.
+  setWhois(aNick, aFields = {}) {
+    // If the nickname isn't in the list yet, add it.
+    if (!this.whoisInformation.has(aNick)) {
+      this.whoisInformation.set(aNick, {});
+    }
+
+    // Set non-normalized nickname field.
+    let whoisInfo = this.whoisInformation.get(aNick);
+    whoisInfo.nick = aNick;
+
+    // Set the WHOIS fields, but only the first time a field is set.
+    for (let field in aFields) {
+      if (!whoisInfo.hasOwnProperty(field)) {
+        whoisInfo[field] = aFields[field];
+      }
+    }
+
+    return true;
+  },
+
+  trackBuddy(aNick) {
+    // Put the username as the first to be checked on the next ISON call.
+    this.trackQueue.unshift(aNick);
+  },
+  untrackBuddy(aNick) {
+    let index = this.trackQueue.indexOf(aNick);
+    if (index < 0) {
+      this.ERROR(
+        "Trying to untrack a nick that was not being tracked: " + aNick
+      );
+      return;
+    }
+    this.trackQueue.splice(index, 1);
+  },
+  addBuddy(aTag, aName) {
+    let buddy = new ircAccountBuddy(this, null, aTag, aName);
+    this.buddies.set(buddy.normalizedName, buddy);
+    this.trackBuddy(buddy.userName);
+
+    IMServices.contacts.accountBuddyAdded(buddy);
+  },
+  removeBuddy(aBuddy) {
+    this.buddies.delete(aBuddy.normalizedName);
+    this.untrackBuddy(aBuddy.userName);
+  },
+  // Loads a buddy from the local storage. Called for each buddy locally stored
+  // before connecting to the server.
+  loadBuddy(aBuddy, aTag) {
+    let buddy = new ircAccountBuddy(this, aBuddy, aTag);
+    this.buddies.set(buddy.normalizedName, buddy);
+    this.trackBuddy(buddy.userName);
+
+    return buddy;
+  },
+  changeBuddyNick(aOldNick, aNewNick) {
+    if (this.normalizeNick(aOldNick) == this.normalizeNick(this._nickname)) {
+      // Your nickname changed!
+      this._nickname = aNewNick;
+      this.conversations.forEach(conversation => {
+        // Update the nick for chats, and inform the user in every conversation.
+        if (conversation.isChat) {
+          conversation.updateNick(aOldNick, aNewNick, true);
+        } else {
+          conversation.writeMessage(
+            aOldNick,
+            lazy._conv("nickSet.you", aNewNick),
+            {
+              system: true,
+            }
+          );
+        }
+      });
+    } else {
+      this.conversations.forEach(conversation => {
+        if (conversation.isChat && conversation._participants.has(aOldNick)) {
+          // Update the nick in every chat conversation it is in.
+          conversation.updateNick(aOldNick, aNewNick, false);
+        }
+      });
+    }
+
+    // Adjust the whois table where necessary.
+    this.removeBuddyInfo(aOldNick);
+    this.setWhois(aNewNick);
+
+    // If a private conversation is open with that user, change its title.
+    if (this.conversations.has(aOldNick)) {
+      // Get the current conversation and rename it.
+      let conversation = this.getConversation(aOldNick);
+
+      // Remove the old reference to the conversation and create a new one.
+      this.removeConversation(aOldNick);
+      this.conversations.set(aNewNick, conversation);
+
+      conversation.updateNick(aNewNick);
+      conversation.writeMessage(
+        aOldNick,
+        lazy._conv("nickSet", aOldNick, aNewNick),
+        { system: true }
+      );
+    }
+  },
+
+  /*
+   * Ask the server to change the user's nick.
+   */
+  changeNick(aNewNick) {
+    this._sentNickname = aNewNick;
+    this.sendMessage("NICK", aNewNick); // Nick message.
+  },
+  /*
+   * Generate a new nick to change to if the user requested nick is already in
+   * use or is otherwise invalid.
+   *
+   * First try all the alternate nicks that were chosen by the user, and if none
+   * of them work, then generate a new nick by:
+   *  1. If there was not a digit at the end of the nick, append a 1.
+   *  2. If there was a digit, then increment the number.
+   *  3. Add leading 0s back on.
+   *  4. Ensure the nick is an appropriate length.
+   */
+  tryNewNick(aOldNick) {
+    // Split the string on commas, remove whitespace around the nicks and
+    // remove empty nicks.
+    let allNicks = this.getString("alternateNicks")
+      .split(",")
+      .map(n => n.trim())
+      .filter(n => !!n);
+    allNicks.unshift(this._accountNickname);
+
+    // If the previously tried nick is in the array and not the last
+    // element, try the next nick in the array.
+    let oldIndex = allNicks.indexOf(aOldNick);
+    if (oldIndex != -1 && oldIndex < allNicks.length - 1) {
+      let newNick = allNicks[oldIndex + 1];
+      this.LOG(aOldNick + " is already in use, trying " + newNick);
+      this.changeNick(newNick);
+      return true;
+    }
+
+    // Separate the nick into the text and digits part.
+    let kNickPattern = /^(.+?)(\d*)$/;
+    let nickParts = kNickPattern.exec(aOldNick);
+    let newNick = nickParts[1];
+
+    // No nick found from the user's preferences, so just generating one.
+    // If there is not a digit at the end of the nick, just append 1.
+    let newDigits = "1";
+    // If there is a digit at the end of the nick, increment it.
+    if (nickParts[2]) {
+      newDigits = (parseInt(nickParts[2], 10) + 1).toString();
+      // If there are leading 0s, add them back on, after we've incremented (e.g.
+      // 009 --> 010).
+      let numLeadingZeros = nickParts[2].length - newDigits.length;
+      if (numLeadingZeros > 0) {
+        newDigits = "0".repeat(numLeadingZeros) + newDigits;
+      }
+    }
+
+    // Servers truncate nicks that are too long, compare the previously sent
+    // nickname with the returned nickname and check for truncation.
+    if (aOldNick.length < this._sentNickname.length) {
+      // The nick will be too long, overwrite the end of the nick instead of
+      // appending.
+      let maxLength = aOldNick.length;
+
+      let sentNickParts = kNickPattern.exec(this._sentNickname);
+      // Resend the same digits as last time, but overwrite part of the nick
+      // this time.
+      if (nickParts[2] && sentNickParts[2]) {
+        newDigits = sentNickParts[2];
+      }
+
+      // Handle the silly case of a single letter followed by all nines.
+      if (newDigits.length == this.maxNicknameLength) {
+        newDigits = newDigits.slice(1);
+      }
+      newNick = newNick.slice(0, maxLength - newDigits.length);
+    }
+    // Append the digits.
+    newNick += newDigits;
+
+    if (this.normalize(newNick) == this.normalize(this._nickname)) {
+      // The nick we were about to try next is our current nick. This means
+      // the user attempted to change to a version of the nick with a lower or
+      // absent number suffix, and this failed.
+      let msg = lazy._("message.nick.fail", this._nickname);
+      this.conversations.forEach(conversation =>
+        conversation.writeMessage(this._nickname, msg, { system: true })
+      );
+      return true;
+    }
+
+    this.LOG(aOldNick + " is already in use, trying " + newNick);
+    this.changeNick(newNick);
+    return true;
+  },
+
+  handlePingReply(aSource, aPongTime) {
+    // Received PING response, display to the user.
+    let sentTime = new Date(parseInt(aPongTime, 10));
+
+    // The received timestamp is invalid.
+    if (isNaN(sentTime)) {
+      this.WARN(
+        aSource + " returned an invalid timestamp from a PING: " + aPongTime
+      );
+      return false;
+    }
+
+    // Find the delay in milliseconds.
+    let delay = Date.now() - sentTime;
+
+    // If the delay is negative or greater than 1 minute, something is
+    // feeding us a crazy value. Don't display this to the user.
+    if (delay < 0 || 60 * 1000 < delay) {
+      this.WARN(aSource + " returned an invalid delay from a PING: " + delay);
+      return false;
+    }
+
+    let msg = lazy.PluralForm.get(
+      delay,
+      lazy._("message.ping", aSource)
+    ).replace("#2", delay);
+    this.getConversation(aSource).writeMessage(aSource, msg, { system: true });
+    return true;
+  },
+
+  countBytes(aStr) {
+    // Assume that if it's not UTF-8 then each character is 1 byte.
+    if (this._encoding != "UTF-8") {
+      return aStr.length;
+    }
+
+    // Count the number of bytes in a UTF-8 encoded string.
+    function charCodeToByteCount(c) {
+      // UTF-8 stores:
+      // - code points below U+0080 are 1 byte,
+      // - code points below U+0800 are 2 bytes,
+      // - code points U+D800 through U+DFFF are UTF-16 surrogate halves
+      // (they indicate that JS has split a 4 bytes UTF-8 character
+      // in two halves of 2 bytes each),
+      // - other code points are 3 bytes.
+      if (c < 0x80) {
+        return 1;
+      }
+      if (c < 0x800 || (c >= 0xd800 && c <= 0xdfff)) {
+        return 2;
+      }
+      return 3;
+    }
+    let bytes = 0;
+    for (let i = 0; i < aStr.length; i++) {
+      bytes += charCodeToByteCount(aStr.charCodeAt(i));
+    }
+    return bytes;
+  },
+
+  // To check if users are online, we need to queue multiple messages.
+  // An internal queue of all nicks that we wish to know the status of.
+  trackQueue: [],
+  // The nicks that were last sent to the server that we're waiting for a
+  // response about.
+  pendingIsOnQueue: [],
+  // The time between sending isOn messages (milliseconds).
+  _isOnDelay: 60 * 1000,
+  _isOnTimer: null,
+  // The number of characters that are available to be filled with nicks for
+  // each ISON message.
+  _isOnLength: null,
+  // Generate and send an ISON message to poll for each nick's status.
+  sendIsOn() {
+    // If no buddies, just look again after the timeout.
+    if (this.trackQueue.length) {
+      // Calculate the possible length of names we can send.
+      if (!this._isOnLength) {
+        let length = this.countBytes(this.buildMessage("ISON", " ")) + 2;
+        this._isOnLength = this.maxMessageLength - length + 1;
+      }
+
+      // Always add the next nickname to the pending queue, this handles a silly
+      // case where the next nick is greater than or equal to the maximum
+      // message length.
+      this.pendingIsOnQueue = [this.trackQueue.shift()];
+
+      // Attempt to maximize the characters used in each message, this may mean
+      // that a specific user gets sent very often since they have a short name!
+      let buddiesLength = this.countBytes(this.pendingIsOnQueue[0]);
+      for (let i = 0; i < this.trackQueue.length; ++i) {
+        // If we can fit the nick, add it to the current buffer.
+        if (
+          buddiesLength + this.countBytes(this.trackQueue[i]) <
+          this._isOnLength
+        ) {
+          // Remove the name from the list and add it to the pending queue.
+          let nick = this.trackQueue.splice(i--, 1)[0];
+          this.pendingIsOnQueue.push(nick);
+
+          // Keep track of the length of the string, the + 1 is for the spaces.
+          buddiesLength += this.countBytes(nick) + 1;
+
+          // If we've filled up the message, stop looking for more nicks.
+          if (buddiesLength >= this._isOnLength) {
+            break;
+          }
+        }
+      }
+
+      // Send the message.
+      this.sendMessage("ISON", this.pendingIsOnQueue.join(" "));
+
+      // Append the pending nicks so trackQueue contains all the nicks.
+      this.trackQueue = this.trackQueue.concat(this.pendingIsOnQueue);
+    }
+
+    // Call this function again in _isOnDelay seconds.
+    // This makes the assumption that this._isOnDelay >> the response to ISON
+    // from the server.
+    this._isOnTimer = setTimeout(this.sendIsOn.bind(this), this._isOnDelay);
+  },
+
+  // The message of the day uses two fields to append messages.
+  _motd: null,
+  _motdTimer: null,
+
+  connect() {
+    this.reportConnecting();
+
+    // Mark existing MUCs as joining if they will be rejoined.
+    this.conversations.forEach(conversation => {
+      if (conversation.isChat && conversation.chatRoomFields) {
+        conversation.joining = true;
+      }
+    });
+
+    // Load preferences.
+    this._port = this.getInt("port");
+    this._ssl = this.getBool("ssl");
+
+    // Use the display name as the user's real name.
+    this._realname = this.imAccount.statusInfo.displayName;
+    this._encoding = this.getString("encoding") || "UTF-8";
+    this._showServerTab = this.getBool("showServerTab");
+
+    // Open the socket connection.
+    this._socket = new ircSocket(this);
+    this._socket.connect(this._server, this._port, this._ssl ? ["ssl"] : []);
+  },
+
+  // Functions for keeping track of whether the Client Capabilities is done.
+  // If a cap is to be handled, it should be registered with addCAP, where aCAP
+  // is a "unique" string defining what is being handled. When the cap is done
+  // being handled removeCAP should be called with the same string.
+  _availableCAPs: new Set(),
+  _activeCAPs: new Set(),
+  _requestedCAPs: new Set(),
+  _negotiatedCAPs: false,
+  _queuedCAPs: [],
+  addCAP(aCAP) {
+    if (this.connected) {
+      this.ERROR("Trying to add CAP " + aCAP + " after connection.");
+      return;
+    }
+
+    this._requestedCAPs.add(aCAP);
+  },
+  removeCAP(aDoneCAP) {
+    if (!this._requestedCAPs.has(aDoneCAP)) {
+      this.ERROR(
+        "Trying to remove a CAP (" + aDoneCAP + ") which isn't added."
+      );
+      return;
+    }
+    if (this.connected) {
+      this.ERROR("Trying to remove CAP " + aDoneCAP + " after connection.");
+      return;
+    }
+
+    // Remove any reference to the given capability.
+    this._requestedCAPs.delete(aDoneCAP);
+
+    // However only notify the server the first time during cap negotiation, not
+    // when the server exposes a new cap.
+    if (!this._requestedCAPs.size && !this._negotiatedCAPs) {
+      this.sendMessage("CAP", "END");
+      this._negotiatedCAPs = true;
+    }
+  },
+
+  // Used to wait for a response from the server.
+  _quitTimer: null,
+  // RFC 2812 Section 3.1.7.
+  quit(aMessage) {
+    this._reportDisconnecting(Ci.prplIAccount.NO_ERROR);
+    this.sendMessage(
+      "QUIT",
+      aMessage || this.getString("quitmsg") || undefined
+    );
+  },
+  // When the user clicks "Disconnect" in account manager, or uses /quit.
+  // aMessage is an optional parameter containing the quit message.
+  disconnect(aMessage) {
+    if (this.disconnected || this.disconnecting) {
+      return;
+    }
+
+    // If there's no socket, disconnect immediately to avoid waiting 2 seconds.
+    if (!this._socket || this._socket.disconnected) {
+      this.gotDisconnected();
+      return;
+    }
+
+    // Let the server know we're going to disconnect.
+    this.quit(aMessage);
+
+    // Reset original nickname for the next reconnect.
+    this._requestedNickname = this._accountNickname;
+
+    // Give the server 2 seconds to respond, otherwise just forcefully
+    // disconnect the socket. This will be cancelled if a response is heard from
+    // the server.
+    this._quitTimer = setTimeout(this.gotDisconnected.bind(this), 2 * 1000);
+  },
+
+  createConversation(aName) {
+    return this.getConversation(aName);
+  },
+
+  // aComponents implements prplIChatRoomFieldValues.
+  joinChat(aComponents) {
+    let channel = aComponents.getValue("channel");
+    // Mildly sanitize input.
+    channel = channel.trimLeft().split(",")[0].split(" ")[0];
+    if (!channel) {
+      this.ERROR("joinChat called without a valid channel name.");
+      return null;
+    }
+
+    // A channel prefix is required. If the user didn't include one,
+    // we prepend # automatically to match the behavior of other
+    // clients. Not doing it used to cause user confusion.
+    if (!this.channelPrefixes.includes(channel[0])) {
+      channel = "#" + channel;
+    }
+
+    if (this.conversations.has(channel)) {
+      let conv = this.getConversation(channel);
+      if (!conv.left) {
+        // No need to join a channel we are already in.
+        return conv;
+      } else if (!conv.chatRoomFields) {
+        // We are rejoining a channel that was parted by the user.
+        conv._rejoined = true;
+      }
+    }
+
+    let key = aComponents.getValue("password");
+    this.sendBufferedCommand("JOIN", channel, key);
+
+    // Open conversation early for better responsiveness.
+    let conv = this.getConversation(channel);
+    conv.joining = true;
+
+    // Store the prplIChatRoomFieldValues to enable later reconnections.
+    let defaultName = key ? channel + " " + key : channel;
+    conv.chatRoomFields = this.getChatRoomDefaultFieldValues(defaultName);
+
+    return conv;
+  },
+
+  chatRoomFields: {
+    channel: {
+      get label() {
+        return lazy._("joinChat.channel");
+      },
+      required: true,
+    },
+    password: {
+      get label() {
+        return lazy._("joinChat.password");
+      },
+      isPassword: true,
+    },
+  },
+
+  parseDefaultChatName(aDefaultName) {
+    let params = aDefaultName.trim().split(/\s+/);
+    let chatFields = { channel: params[0] };
+    if (params.length > 1) {
+      chatFields.password = params[1];
+    }
+    return chatFields;
+  },
+
+  // Attributes
+  get canJoinChat() {
+    return true;
+  },
+
+  // Returns a conversation (creates it if it doesn't exist)
+  getConversation(aName) {
+    if (!this.conversations.has(aName)) {
+      // If the whois information has been received, we have the proper nick
+      // capitalization.
+      if (this.whoisInformation.has(aName)) {
+        aName = this.whoisInformation.get(aName).nick;
+      }
+      let convClass = this.isMUCName(aName) ? ircChannel : ircConversation;
+      this.conversations.set(aName, new convClass(this, aName, this._nickname));
+    }
+    return this.conversations.get(aName);
+  },
+
+  removeConversation(aConversationName) {
+    if (this.conversations.has(aConversationName)) {
+      this.conversations.delete(aConversationName);
+    }
+  },
+
+  // This builds the message string that will be sent to the server.
+  buildMessage(aCommand, aParams = []) {
+    if (!aCommand) {
+      this.ERROR("IRC messages must have a command.");
+      return null;
+    }
+
+    // Ensure a command is only characters or numbers.
+    if (!/^[A-Z0-9]+$/i.test(aCommand)) {
+      this.ERROR("IRC command invalid: " + aCommand);
+      return null;
+    }
+
+    let message = aCommand;
+    // If aParams is not an array, consider it to be a single parameter and put
+    // it into an array.
+    let params = Array.isArray(aParams) ? aParams : [aParams];
+    if (params.length) {
+      if (params.slice(0, -1).some(p => p.includes(" "))) {
+        this.ERROR("IRC parameters cannot have spaces: " + params.slice(0, -1));
+        return null;
+      }
+      // Join the parameters with spaces. There are three cases in which the
+      // last parameter ("trailing" in RFC 2812) must be prepended with a colon:
+      //  1. If the last parameter contains a space.
+      //  2. If the first character of the last parameter is a colon.
+      //  3. If the last parameter is an empty string.
+      let trailing = params.slice(-1)[0];
+      if (
+        !trailing.length ||
+        trailing.includes(" ") ||
+        trailing.startsWith(":")
+      ) {
+        params.push(":" + params.pop());
+      }
+      message += " " + params.join(" ");
+    }
+
+    return message;
+  },
+
+  // Shortcut method to build & send a message at once. Use aLoggedData to log
+  // something different than what is actually sent.
+  // Returns false if the message could not be sent.
+  sendMessage(aCommand, aParams, aLoggedData) {
+    return this.sendRawMessage(
+      this.buildMessage(aCommand, aParams),
+      aLoggedData
+    );
+  },
+
+  // This sends a message over the socket and catches any errors. Use
+  // aLoggedData to log something different than what is actually sent.
+  // Returns false if the message could not be sent.
+  sendRawMessage(aMessage, aLoggedData) {
+    // Low level quoting, replace \0, \n, \r or \020 with \0200, \020n, \020r or
+    // \020\020, respectively.
+    const lowQuote = { "\0": "0", "\n": "n", "\r": "r", "\x10": "\x10" };
+    const lowRegex = new RegExp(
+      "[" + Object.keys(lowQuote).join("") + "]",
+      "g"
+    );
+    aMessage = aMessage.replace(lowRegex, aChar => "\x10" + lowQuote[aChar]);
+
+    if (!this._socket || this._socket.disconnected) {
+      this.gotDisconnected(
+        Ci.prplIAccount.ERROR_NETWORK_ERROR,
+        lazy._("connection.error.lost")
+      );
+    }
+
+    let length = this.countBytes(aMessage) + 2;
+    if (length > this.maxMessageLength) {
+      // Log if the message is too long, but try to send it anyway.
+      this.WARN(
+        "Message length too long (" +
+          length +
+          " > " +
+          this.maxMessageLength +
+          "\n" +
+          aMessage
+      );
+    }
+
+    aMessage += "\r\n";
+
+    try {
+      this._socket.sendString(aMessage, this._encoding, aLoggedData);
+      return true;
+    } catch (e) {
+      try {
+        this._socket.sendData(aMessage, aLoggedData);
+        this.WARN(
+          "Failed to convert " +
+            aMessage +
+            " from Unicode to " +
+            this._encoding +
+            "."
+        );
+        return true;
+      } catch (e) {
+        this.ERROR("Socket error:", e);
+        this.gotDisconnected(
+          Ci.prplIAccount.ERROR_NETWORK_ERROR,
+          lazy._("connection.error.lost")
+        );
+        return false;
+      }
+    }
+  },
+
+  // CTCP messages are \001<COMMAND> [<parameters>]*\001.
+  // Returns false if the message could not be sent.
+  sendCTCPMessage(aTarget, aIsNotice, aCtcpCommand, aParams = []) {
+    // Combine the CTCP command and parameters into the single IRC param.
+    let ircParam = aCtcpCommand;
+    // If aParams is not an array, consider it to be a single parameter and put
+    // it into an array.
+    let params = Array.isArray(aParams) ? aParams : [aParams];
+    if (params.length) {
+      ircParam += " " + params.join(" ");
+    }
+
+    // High/CTCP level quoting, replace \134 or \001 with \134\134 or \134a,
+    // respectively. This is only done inside the extended data message.
+    // eslint-disable-next-line no-control-regex
+    const highRegex = /\\|\x01/g;
+    ircParam = ircParam.replace(
+      highRegex,
+      aChar => "\\" + (aChar == "\\" ? "\\" : "a")
+    );
+
+    // Add the CTCP tagging.
+    ircParam = "\x01" + ircParam + "\x01";
+
+    // Send the IRC message as a NOTICE or PRIVMSG.
+    return this.sendMessage(aIsNotice ? "NOTICE" : "PRIVMSG", [
+      aTarget,
+      ircParam,
+    ]);
+  },
+
+  // Implement section 3.1 of RFC 2812
+  _connectionRegistration() {
+    // Send the Client Capabilities list command version 3.2.
+    this.sendMessage("CAP", ["LS", "302"]);
+
+    if (this.prefs.prefHasUserValue("serverPassword")) {
+      this.sendMessage(
+        "PASS",
+        this.getString("serverPassword"),
+        "PASS <password not logged>"
+      );
+    }
+
+    // Send the nick message (section 3.1.2).
+    this.changeNick(this._requestedNickname);
+
+    // Send the user message (section 3.1.3).
+    this.sendMessage("USER", [
+      this.username,
+      this._mode.toString(),
+      "*",
+      this._realname || this._requestedNickname,
+    ]);
+  },
+
+  _reportDisconnecting(aErrorReason, aErrorMessage) {
+    this.reportDisconnecting(aErrorReason, aErrorMessage);
+
+    // Cancel any pending buffered commands.
+    this._commandBuffers.clear();
+
+    // Mark all contacts on the account as having an unknown status.
+    this.buddies.forEach(aBuddy =>
+      aBuddy.setStatus(Ci.imIStatusInfo.STATUS_UNKNOWN, "")
+    );
+  },
+
+  gotDisconnected(aError = Ci.prplIAccount.NO_ERROR, aErrorMessage = "") {
+    if (!this.imAccount || this.disconnected) {
+      return;
+    }
+
+    // If we are already disconnecting, this call to gotDisconnected
+    // is when the server acknowledges our disconnection.
+    // Otherwise it's because we lost the connection.
+    if (!this.disconnecting) {
+      this._reportDisconnecting(aError, aErrorMessage);
+    }
+    this._socket.disconnect();
+    delete this._socket;
+
+    // Reset cap negotiation.
+    this._availableCAPs.clear();
+    this._activeCAPs.clear();
+    this._requestedCAPs.clear();
+    this._negotiatedCAPs = false;
+    this._queuedCAPs.length = 0;
+
+    clearTimeout(this._isOnTimer);
+    delete this._isOnTimer;
+
+    // No need to call gotDisconnected a second time.
+    clearTimeout(this._quitTimer);
+    delete this._quitTimer;
+
+    // MOTD will be resent.
+    delete this._motd;
+    clearTimeout(this._motdTimer);
+    delete this._motdTimer;
+
+    // We must authenticate if we reconnect.
+    delete this.isAuthenticated;
+
+    // Clear any pending attempt to regain our nick.
+    clearTimeout(this._nickInUseTimeout);
+    delete this._nickInUseTimeout;
+
+    // Clean up each conversation: mark as left and remove participant.
+    this.conversations.forEach(conversation => {
+      if (conversation.isChat) {
+        conversation.joining = false; // In case we never finished joining.
+        if (!conversation.left) {
+          // Remove the user's nick and mark the conversation as left as that's
+          // the final known state of the room.
+          conversation.removeParticipant(this._nickname);
+          conversation.left = true;
+        }
+      }
+    });
+
+    // If we disconnected during a pending LIST request, make sure callbacks
+    // receive any remaining channels.
+    if (this._pendingList) {
+      this._sendRemainingRoomInfo();
+    }
+
+    // Clear whois table.
+    this.whoisInformation.clear();
+
+    this.reportDisconnected();
+  },
+
+  remove() {
+    this.conversations.forEach(conv => conv.close());
+    delete this.conversations;
+    this.buddies.forEach(aBuddy => aBuddy.remove());
+    delete this.buddies;
+  },
+
+  unInit() {
+    // Disconnect if we're online while this gets called.
+    if (this._socket) {
+      if (!this.disconnecting) {
+        this.quit();
+      }
+      this._socket.disconnect();
+    }
+    delete this.imAccount;
+    clearTimeout(this._isOnTimer);
+    clearTimeout(this._quitTimer);
+  },
+};
diff --git a/comm/chat/protocols/irc/ircBase.sys.mjs b/comm/chat/protocols/irc/ircBase.sys.mjs
new file mode 100644
index 0000000000..9127dd4e24
--- /dev/null
+++ b/comm/chat/protocols/irc/ircBase.sys.mjs
@@ -0,0 +1,1768 @@
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
+
+/*
+ * This contains the implementation for the basic Internet Relay Chat (IRC)
+ * protocol covered by RFCs 2810, 2811, 2812 and 2813 (which obsoletes RFC
+ * 1459). RFC 2812 covers the client commands and protocol.
+ *   RFC 2810: Internet Relay Chat: Architecture
+ *     http://tools.ietf.org/html/rfc2810
+ *   RFC 2811: Internet Relay Chat: Channel Management
+ *     http://tools.ietf.org/html/rfc2811
+ *   RFC 2812: Internet Relay Chat: Client Protocol
+ *     http://tools.ietf.org/html/rfc2812
+ *   RFC 2813: Internet Relay Chat: Server Protocol
+ *     http://tools.ietf.org/html/rfc2813
+ *   RFC 1459: Internet Relay Chat Protocol
+ *     http://tools.ietf.org/html/rfc1459
+ */
+import { XPCOMUtils } from "resource://gre/modules/XPCOMUtils.sys.mjs";
+import {
+  l10nHelper,
+  nsSimpleEnumerator,
+} from "resource:///modules/imXPCOMUtils.sys.mjs";
+import { clearTimeout, setTimeout } from "resource://gre/modules/Timer.sys.mjs";
+import { ircHandlerPriorities } from "resource:///modules/ircHandlerPriorities.sys.mjs";
+import {
+  ctcpFormatToText,
+  conversationErrorMessage,
+  displayMessage,
+  kListRefreshInterval,
+} from "resource:///modules/ircUtils.sys.mjs";
+
+const lazy = {};
+XPCOMUtils.defineLazyGetter(lazy, "_", () =>
+  l10nHelper("chrome://chat/locale/irc.properties")
+);
+
+// Display the message and remove them from the rooms they're in.
+function leftRoom(aAccount, aNicks, aChannels, aSource, aReason, aKicked) {
+  let msgId = "message." + (aKicked ? "kicked" : "parted");
+  // If a part message was included, include it.
+  let reason = aReason ? lazy._(msgId + ".reason", aReason) : "";
+  function __(aNick, aYou) {
+    // If the user is kicked, we need to say who kicked them.
+    let msgId2 = msgId + (aYou ? ".you" : "");
+    if (aKicked) {
+      if (aYou) {
+        return lazy._(msgId2, aSource, reason);
+      }
+      return lazy._(msgId2, aNick, aSource, reason);
+    }
+    if (aYou) {
+      return lazy._(msgId2, reason);
+    }
+    return lazy._(msgId2, aNick, reason);
+  }
+
+  for (let channelName of aChannels) {
+    if (!aAccount.conversations.has(channelName)) {
+      // Handle when we closed the window.
+      continue;
+    }
+    let conversation = aAccount.getConversation(channelName);
+    for (let nick of aNicks) {
+      let msg;
+      if (aAccount.normalize(nick) == aAccount.normalize(aAccount._nickname)) {
+        msg = __(nick, true);
+        // If the user left, mark the conversation as no longer being active.
+        conversation.left = true;
+      } else {
+        msg = __(nick);
+      }
+
+      conversation.writeMessage(aSource, msg, { system: true });
+      conversation.removeParticipant(nick);
+    }
+  }
+  return true;
+}
+
+function writeMessage(aAccount, aMessage, aString, aType) {
+  let type = {};
+  type[aType] = true;
+  type.tags = aMessage.tags;
+  aAccount
+    .getConversation(aMessage.origin)
+    .writeMessage(aMessage.origin, aString, type);
+  return true;
+}
+
+// If aNoLastParam is true, the last parameter is not printed out.
+function serverMessage(aAccount, aMsg, aNoLastParam) {
+  // If we don't want to show messages from the server, just mark it as handled.
+  if (!aAccount._showServerTab) {
+    return true;
+  }
+
+  return writeMessage(
+    aAccount,
+    aMsg,
+    aMsg.params.slice(1, aNoLastParam ? -1 : undefined).join(" "),
+    "system"
+  );
+}
+
+function serverErrorMessage(aAccount, aMessage, aError) {
+  // If we don't want to show messages from the server, just mark it as handled.
+  if (!aAccount._showServerTab) {
+    return true;
+  }
+
+  return writeMessage(aAccount, aMessage, aError, "error");
+}
+
+function addMotd(aAccount, aMessage) {
+  // If there is no current MOTD to append to, start a new one.
+  if (!aAccount._motd) {
+    aAccount._motd = [];
+  }
+
+  // Traditionally, MOTD messages start with "- ", but this is not always
+  // true, try to handle that sanely.
+  let message = aMessage.params[1];
+  if (message.startsWith("-")) {
+    message = message.slice(1).trim();
+  }
+  // And traditionally, the initial message ends in " -", remove that.
+  if (message.endsWith("-")) {
+    message = message.slice(0, -1).trim();
+  }
+
+  // Actually add the message (if it still exists).
+  if (message) {
+    aAccount._motd.push(message);
+  }
+
+  // Oh, also some servers don't send a RPL_ENDOFMOTD (e.g. irc.ppy.sh), so if
+  // we don't receive another MOTD message after 1 second, consider it to be
+  // RPL_ENDOFMOTD.
+  clearTimeout(aAccount._motdTimer);
+  aAccount._motdTimer = setTimeout(
+    ircBase.commands["376"].bind(aAccount),
+    1000,
+    aMessage
+  );
+
+  return true;
+}
+
+// See RFCs 2811 & 2812 (which obsoletes RFC 1459) for a description of these
+// commands.
+export var ircBase = {
+  // Parameters
+  name: "RFC 2812", // Name identifier
+  priority: ircHandlerPriorities.DEFAULT_PRIORITY,
+  isEnabled: () => true,
+
+  // The IRC commands that can be handled.
+  commands: {
+    ERROR(aMessage) {
+      // ERROR <error message>
+      // Client connection has been terminated.
+      if (!this.disconnecting) {
+        // We received an ERROR message when we weren't expecting it, this is
+        // probably the server giving us a ping timeout.
+        this.WARN("Received unexpected ERROR response:\n" + aMessage.params[0]);
+        this.gotDisconnected(
+          Ci.prplIAccount.ERROR_NETWORK_ERROR,
+          lazy._("connection.error.lost")
+        );
+      } else {
+        // We received an ERROR message when expecting it (i.e. we've sent a
+        // QUIT command). Notify account manager.
+        this.gotDisconnected();
+      }
+      return true;
+    },
+    INVITE(aMessage) {
+      // INVITE <nickname> <channel>
+      let channel = aMessage.params[1];
+      this.addChatRequest(
+        channel,
+        () => {
+          this.joinChat(this.getChatRoomDefaultFieldValues(channel));
+        },
+        request => {
+          // Inform the user when an invitation was automatically ignored.
+          if (!request) {
+            // Otherwise just notify the user.
+            this.getConversation(channel).writeMessage(
+              aMessage.origin,
+              lazy._("message.inviteReceived", aMessage.origin, channel),
+              { system: true }
+            );
+          }
+        }
+      );
+      return true;
+    },
+    JOIN(aMessage) {
+      // JOIN ( <channel> *( "," <channel> ) [ <key> *( "," <key> ) ] ) / "0"
+      // Iterate over each channel.
+      for (let channelName of aMessage.params[0].split(",")) {
+        let conversation = this.getConversation(channelName);
+
+        // Check whether we joined the channel or if someone else did.
+        if (
+          this.normalize(aMessage.origin, this.userPrefixes) ==
+          this.normalize(this._nickname)
+        ) {
+          // If we join, clear the participants list to avoid errors with
+          // repeated participants.
+          conversation.removeAllParticipants();
+          conversation.left = false;
+          conversation.joining = false;
+
+          // Update the channel name if it has improper capitalization.
+          if (channelName != conversation.name) {
+            conversation._name = channelName;
+            conversation.notifyObservers(null, "update-conv-title");
+          }
+
+          // If the user parted from this room earlier, confirm the rejoin.
+          if (conversation._rejoined) {
+            conversation.writeMessage(
+              aMessage.origin,
+              lazy._("message.rejoined"),
+              {
+                system: true,
+              }
+            );
+            delete conversation._rejoined;
+          }
+
+          // Ensure chatRoomFields information is available for reconnection.
+          if (!conversation.chatRoomFields) {
+            this.WARN(
+              "Opening a MUC without storing its " +
+                "prplIChatRoomFieldValues first."
+            );
+            conversation.chatRoomFields =
+              this.getChatRoomDefaultFieldValues(channelName);
+          }
+        } else {
+          // Don't worry about adding ourself, RPL_NAMREPLY takes care of that
+          // case.
+          conversation.getParticipant(aMessage.origin, true);
+          let msg = lazy._("message.join", aMessage.origin, aMessage.source);
+          conversation.writeMessage(aMessage.origin, msg, {
+            system: true,
+            noLinkification: true,
+          });
+        }
+      }
+      // If the joiner is a buddy, mark as online.
+      let buddy = this.buddies.get(aMessage.origin);
+      if (buddy) {
+        buddy.setStatus(Ci.imIStatusInfo.STATUS_AVAILABLE, "");
+      }
+      return true;
+    },
+    KICK(aMessage) {
+      // KICK <channel> *( "," <channel> ) <user> *( "," <user> ) [<comment>]
+      let comment = aMessage.params.length == 3 ? aMessage.params[2] : null;
+      // Some servers (moznet) send the kicker as the comment.
+      if (comment == aMessage.origin) {
+        comment = null;
+      }
+      return leftRoom(
+        this,
+        aMessage.params[1].split(","),
+        aMessage.params[0].split(","),
+        aMessage.origin,
+        comment,
+        true
+      );
+    },
+    MODE(aMessage) {
+      // MODE <nickname> *( ( "+" / "-") *( "i" / "w" / "o" / "O" / "r" ) )
+      // MODE <channel> *( ( "-" / "+" ) *<modes> *<modeparams> )
+      if (this.isMUCName(aMessage.params[0])) {
+        // If the first parameter is a channel name, a channel/participant mode
+        // was updated.
+        this.getConversation(aMessage.params[0]).setMode(
+          aMessage.params[1],
+          aMessage.params.slice(2),
+          aMessage.origin
+        );
+
+        return true;
+      }
+
+      // Otherwise the user's own mode is being returned to them.
+      return this.setUserMode(
+        aMessage.params[0],
+        aMessage.params[1],
+        aMessage.origin,
+        !this._userModeReceived
+      );
+    },
+    NICK(aMessage) {
+      // NICK <nickname>
+      this.changeBuddyNick(aMessage.origin, aMessage.params[0]);
+      return true;
+    },
+    NOTICE(aMessage) {
+      // NOTICE <msgtarget> <text>
+      // If the message is from the server, don't show it unless the user wants
+      // to see it.
+      if (!this.connected || aMessage.origin == this._currentServerName) {
+        return serverMessage(this, aMessage);
+      }
+      return displayMessage(this, aMessage, { notification: true });
+    },
+    PART(aMessage) {
+      // PART <channel> *( "," <channel> ) [ <Part Message> ]
+      return leftRoom(
+        this,
+        [aMessage.origin],
+        aMessage.params[0].split(","),
+        aMessage.source,
+        aMessage.params.length == 2 ? aMessage.params[1] : null
+      );
+    },
+    PING(aMessage) {
+      // PING <server1> [ <server2> ]
+      // Keep the connection alive.
+      this.sendMessage("PONG", aMessage.params[0]);
+      return true;
+    },
+    PONG(aMessage) {
+      // PONG <server> [ <server2> ]
+      let pongTime = aMessage.params[1];
+
+      // Ping to keep the connection alive.
+      if (pongTime.startsWith("_")) {
+        this._socket.cancelDisconnectTimer();
+        return true;
+      }
+      // Otherwise, the ping was from a user command.
+      return this.handlePingReply(aMessage.origin, pongTime);
+    },
+    PRIVMSG(aMessage) {
+      // PRIVMSG <msgtarget> <text to be sent>
+      // Display message in conversation
+      return displayMessage(this, aMessage);
+    },
+    QUIT(aMessage) {
+      // QUIT [ < Quit Message> ]
+      // Some IRC servers automatically prefix a "Quit: " string. Remove the
+      // duplication and use a localized version.
+      let quitMsg = aMessage.params[0] || "";
+      if (quitMsg.startsWith("Quit: ")) {
+        quitMsg = quitMsg.slice(6); // "Quit: ".length
+      }
+      // If a quit message was included, show it.
+      let nick = aMessage.origin;
+      let msg = lazy._(
+        "message.quit",
+        nick,
+        quitMsg.length ? lazy._("message.quit2", quitMsg) : ""
+      );
+      // Loop over every conversation with the user and display that they quit.
+      this.conversations.forEach(conversation => {
+        if (conversation.isChat && conversation._participants.has(nick)) {
+          conversation.writeMessage(nick, msg, { system: true });
+          conversation.removeParticipant(nick);
+        }
+      });
+
+      // Remove from the whois table.
+      this.removeBuddyInfo(nick);
+
+      // If the leaver is a buddy, mark as offline.
+      let buddy = this.buddies.get(nick);
+      if (buddy) {
+        buddy.setStatus(Ci.imIStatusInfo.STATUS_OFFLINE, "");
+      }
+
+      // If we wanted this nickname, grab it.
+      if (nick == this._requestedNickname && nick != this._nickname) {
+        this.changeNick(this._requestedNickname);
+        clearTimeout(this._nickInUseTimeout);
+        delete this._nickInUseTimeout;
+      }
+      return true;
+    },
+    SQUIT(aMessage) {
+      // <server> <comment>
+      return true;
+    },
+    TOPIC(aMessage) {
+      // TOPIC <channel> [ <topic> ]
+      // Show topic as a message.
+      let conversation = this.getConversation(aMessage.params[0]);
+      let topic = aMessage.params[1];
+      // Set the topic in the conversation and update the UI.
+      conversation.setTopic(
+        topic ? ctcpFormatToText(topic) : "",
+        aMessage.origin
+      );
+      return true;
+    },
+    "001": function (aMessage) {
+      // RPL_WELCOME
+      // Welcome to the Internet Relay Network <nick>!<user>@<host>
+      this._socket.resetPingTimer();
+      // This seems a little strange, but we don't differentiate between a
+      // nickname and the servername since it can be ambiguous.
+      this._currentServerName = aMessage.origin;
+
+      // Clear user mode.
+      this._modes = new Set();
+      this._userModeReceived = false;
+
+      // Check if autoUserMode is set in the account preferences. If it is set,
+      // then notify the server that the user wants a specific mode.
+      if (this.prefs.prefHasUserValue("autoUserMode")) {
+        this.sendMessage("MODE", [
+          this._nickname,
+          this.getString("autoUserMode"),
+        ]);
+      }
+
+      // Check if our nick has changed.
+      if (aMessage.params[0] != this._nickname) {
+        this.changeBuddyNick(this._nickname, aMessage.params[0]);
+      }
+
+      // Request our own whois entry so we can set the prefix.
+      this.requestCurrentWhois(this._nickname);
+
+      // If our status is Unavailable, tell the server.
+      if (
+        this.imAccount.statusInfo.statusType < Ci.imIStatusInfo.STATUS_AVAILABLE
+      ) {
+        this.observe(null, "status-changed");
+      }
+
+      // Check if any of our buddies are online!
+      const kInitialIsOnDelay = 1000;
+      this._isOnTimer = setTimeout(this.sendIsOn.bind(this), kInitialIsOnDelay);
+
+      // If we didn't handle all the CAPs we added, something is wrong.
+      if (this._requestedCAPs.size) {
+        this.ERROR(
+          "Connected without removing CAPs: " + [...this._requestedCAPs]
+        );
+      }
+
+      // Done!
+      this.reportConnected();
+      return serverMessage(this, aMessage);
+    },
+    "002": function (aMessage) {
+      // RPL_YOURHOST
+      // Your host is <servername>, running version <ver>
+      return serverMessage(this, aMessage);
+    },
+    "003": function (aMessage) {
+      // RPL_CREATED
+      // This server was created <date>
+      // TODO parse this date and keep it for some reason? Do we care?
+      return serverMessage(this, aMessage);
+    },
+    "004": function (aMessage) {
+      // RPL_MYINFO
+      // <servername> <version> <available user modes> <available channel modes>
+      // TODO parse the available modes, let the UI respond and inform the user
+      return serverMessage(this, aMessage);
+    },
+    "005": function (aMessage) {
+      // RPL_BOUNCE
+      // Try server <server name>, port <port number>
+      return serverMessage(this, aMessage);
+    },
+
+    /*
+     * Handle response to TRACE message
+     */
+    200(aMessage) {
+      // RPL_TRACELINK
+      // Link <version & debug level> <destination> <next server>
+      // V<protocol version> <link updateime in seconds> <backstream sendq>
+      // <upstream sendq>
+      return serverMessage(this, aMessage);
+    },
+    201(aMessage) {
+      // RPL_TRACECONNECTING
+      // Try. <class> <server>
+      return serverMessage(this, aMessage);
+    },
+    202(aMessage) {
+      // RPL_TRACEHANDSHAKE
+      // H.S. <class> <server>
+      return serverMessage(this, aMessage);
+    },
+    203(aMessage) {
+      // RPL_TRACEUNKNOWN
+      // ???? <class> [<client IP address in dot form>]
+      return serverMessage(this, aMessage);
+    },
+    204(aMessage) {
+      // RPL_TRACEOPERATOR
+      // Oper <class> <nick>
+      return serverMessage(this, aMessage);
+    },
+    205(aMessage) {
+      // RPL_TRACEUSER
+      // User <class> <nick>
+      return serverMessage(this, aMessage);
+    },
+    206(aMessage) {
+      // RPL_TRACESERVER
+      // Serv <class> <int>S <int>C <server> <nick!user|*!*>@<host|server>
+      // V<protocol version>
+      return serverMessage(this, aMessage);
+    },
+    207(aMessage) {
+      // RPL_TRACESERVICE
+      // Service <class> <name> <type> <active type>
+      return serverMessage(this, aMessage);
+    },
+    208(aMessage) {
+      // RPL_TRACENEWTYPE
+      // <newtype> 0 <client name>
+      return serverMessage(this, aMessage);
+    },
+    209(aMessage) {
+      // RPL_TRACECLASS
+      // Class <class> <count>
+      return serverMessage(this, aMessage);
+    },
+    210(aMessage) {
+      // RPL_TRACERECONNECTION
+      // Unused.
+      return serverMessage(this, aMessage);
+    },
+
+    /*
+     * Handle stats messages.
+     **/
+    211(aMessage) {
+      // RPL_STATSLINKINFO
+      // <linkname> <sendq> <sent messages> <sent Kbytes> <received messages>
+      // <received Kbytes> <time open>
+      return serverMessage(this, aMessage);
+    },
+    212(aMessage) {
+      // RPL_STATSCOMMAND
+      // <command> <count> <byte count> <remote count>
+      return serverMessage(this, aMessage);
+    },
+    213(aMessage) {
+      // RPL_STATSCLINE
+      // Non-generic
+      return serverMessage(this, aMessage);
+    },
+    214(aMessage) {
+      // RPL_STATSNLINE
+      // Non-generic
+      return serverMessage(this, aMessage);
+    },
+    215(aMessage) {
+      // RPL_STATSILINE
+      // Non-generic
+      return serverMessage(this, aMessage);
+    },
+    216(aMessage) {
+      // RPL_STATSKLINE
+      // Non-generic
+      return serverMessage(this, aMessage);
+    },
+    217(aMessage) {
+      // RPL_STATSQLINE
+      // Non-generic
+      return serverMessage(this, aMessage);
+    },
+    218(aMessage) {
+      // RPL_STATSYLINE
+      // Non-generic
+      return serverMessage(this, aMessage);
+    },
+    219(aMessage) {
+      // RPL_ENDOFSTATS
+      // <stats letter> :End of STATS report
+      return serverMessage(this, aMessage);
+    },
+
+    221(aMessage) {
+      // RPL_UMODEIS
+      // <user mode string>
+      return this.setUserMode(
+        aMessage.params[0],
+        aMessage.params[1],
+        aMessage.origin,
+        true
+      );
+    },
+
+    /*
+     * Services
+     */
+    231(aMessage) {
+      // RPL_SERVICEINFO
+      // Non-generic
+      return serverMessage(this, aMessage);
+    },
+    232(aMessage) {
+      // RPL_ENDOFSERVICES
+      // Non-generic
+      return serverMessage(this, aMessage);
+    },
+    233(aMessage) {
+      // RPL_SERVICE
+      // Non-generic
+      return serverMessage(this, aMessage);
+    },
+
+    /*
+     * Server
+     */
+    234(aMessage) {
+      // RPL_SERVLIST
+      // <name> <server> <mask> <type> <hopcount> <info>
+      return serverMessage(this, aMessage);
+    },
+    235(aMessage) {
+      // RPL_SERVLISTEND
+      // <mask> <type> :End of service listing
+      return serverMessage(this, aMessage, true);
+    },
+
+    /*
+     * Stats
+     * TODO some of these have real information we could try to parse.
+     */
+    240(aMessage) {
+      // RPL_STATSVLINE
+      // Non-generic
+      return serverMessage(this, aMessage);
+    },
+    241(aMessage) {
+      // RPL_STATSLLINE
+      // Non-generic
+      return serverMessage(this, aMessage);
+    },
+    242(aMessage) {
+      // RPL_STATSUPTIME
+      // :Server Up %d days %d:%02d:%02d
+      return serverMessage(this, aMessage);
+    },
+    243(aMessage) {
+      // RPL_STATSOLINE
+      // O <hostmask> * <name>
+      return serverMessage(this, aMessage);
+    },
+    244(aMessage) {
+      // RPL_STATSHLINE
+      // Non-generic
+      return serverMessage(this, aMessage);
+    },
+    245(aMessage) {
+      // RPL_STATSSLINE
+      // Non-generic
+      // Note that this is given as 244 in RFC 2812, this seems to be incorrect.
+      return serverMessage(this, aMessage);
+    },
+    246(aMessage) {
+      // RPL_STATSPING
+      // Non-generic
+      return serverMessage(this, aMessage);
+    },
+    247(aMessage) {
+      // RPL_STATSBLINE
+      // Non-generic
+      return serverMessage(this, aMessage);
+    },
+    250(aMessage) {
+      // RPL_STATSDLINE
+      // Non-generic
+      return serverMessage(this, aMessage);
+    },
+
+    /*
+     * LUSER messages
+     */
+    251(aMessage) {
+      // RPL_LUSERCLIENT
+      // :There are <integer> users and <integer> services on <integer> servers
+      return serverMessage(this, aMessage);
+    },
+    252(aMessage) {
+      // RPL_LUSEROP, 0 if not sent
+      // <integer> :operator(s) online
+      return serverMessage(this, aMessage);
+    },
+    253(aMessage) {
+      // RPL_LUSERUNKNOWN, 0 if not sent
+      // <integer> :unknown connection(s)
+      return serverMessage(this, aMessage);
+    },
+    254(aMessage) {
+      // RPL_LUSERCHANNELS, 0 if not sent
+      // <integer> :channels formed
+      return serverMessage(this, aMessage);
+    },
+    255(aMessage) {
+      // RPL_LUSERME
+      // :I have <integer> clients and <integer> servers
+      return serverMessage(this, aMessage);
+    },
+
+    /*
+     * ADMIN messages
+     */
+    256(aMessage) {
+      // RPL_ADMINME
+      // <server> :Administrative info
+      return serverMessage(this, aMessage);
+    },
+    257(aMessage) {
+      // RPL_ADMINLOC1
+      // :<admin info>
+      // City, state & country
+      return serverMessage(this, aMessage);
+    },
+    258(aMessage) {
+      // RPL_ADMINLOC2
+      // :<admin info>
+      // Institution details
+      return serverMessage(this, aMessage);
+    },
+    259(aMessage) {
+      // RPL_ADMINEMAIL
+      // :<admin info>
+      // TODO We could parse this for a contact email.
+      return serverMessage(this, aMessage);
+    },
+
+    /*
+     * TRACELOG
+     */
+    261(aMessage) {
+      // RPL_TRACELOG
+      // File <logfile> <debug level>
+      return serverMessage(this, aMessage);
+    },
+    262(aMessage) {
+      // RPL_TRACEEND
+      // <server name> <version & debug level> :End of TRACE
+      return serverMessage(this, aMessage, true);
+    },
+
+    /*
+     * Try again.
+     */
+    263(aMessage) {
+      // RPL_TRYAGAIN
+      // <command> :Please wait a while and try again.
+      if (aMessage.params[1] == "LIST" && this._pendingList) {
+        // We may receive this from servers which rate-limit LIST if the
+        // server believes us to be asking for LIST data too soon after the
+        // previous request.
+        // Tidy up as we won't be receiving any more channels.
+        this._sendRemainingRoomInfo();
+        // Fake the last LIST time so that we may try again in one hour.
+        const kHour = 60 * 60 * 1000;
+        this._lastListTime = Date.now() - kListRefreshInterval + kHour;
+        return true;
+      }
+      return serverMessage(this, aMessage);
+    },
+
+    265(aMessage) {
+      // nonstandard
+      // :Current Local Users: <integer>  Max: <integer>
+      return serverMessage(this, aMessage);
+    },
+    266(aMessage) {
+      // nonstandard
+      // :Current Global Users: <integer>  Max: <integer>
+      return serverMessage(this, aMessage);
+    },
+    300(aMessage) {
+      // RPL_NONE
+      // Non-generic
+      return serverMessage(this, aMessage);
+    },
+
+    /*
+     * Status messages
+     */
+    301(aMessage) {
+      // RPL_AWAY
+      // <nick> :<away message>
+      // TODO set user as away on buddy list / conversation lists
+      // TODO Display an autoResponse if this is after sending a private message
+      // If the conversation is waiting for a response, it's received one.
+      if (this.conversations.has(aMessage.params[1])) {
+        delete this.getConversation(aMessage.params[1])._pendingMessage;
+      }
+      return this.setWhois(aMessage.params[1], { away: aMessage.params[2] });
+    },
+    302(aMessage) {
+      // RPL_USERHOST
+      // :*1<reply> *( " " <reply )"
+      // reply = nickname [ "*" ] "=" ( "+" / "-" ) hostname
+      // TODO Can tell op / away from this
+      return false;
+    },
+    303(aMessage) {
+      // RPL_ISON
+      // :*1<nick> *( " " <nick> )"
+      // Set the status of the buddies based the latest ISON response.
+      let receivedBuddyNames = [];
+      // The buddy names as returned by the server.
+      if (aMessage.params.length > 1) {
+        receivedBuddyNames = aMessage.params[1].trim().split(" ");
+      }
+
+      // This was received in response to the last ISON message sent.
+      for (let buddyName of this.pendingIsOnQueue) {
+        // If the buddy name is in the list returned from the server, they're
+        // online.
+        let status = !receivedBuddyNames.includes(buddyName)
+          ? Ci.imIStatusInfo.STATUS_OFFLINE
+          : Ci.imIStatusInfo.STATUS_AVAILABLE;
+
+        // Set the status with no status message, only if the buddy actually
+        // exists in the buddy list.
+        let buddy = this.buddies.get(buddyName);
+        if (buddy) {
+          buddy.setStatus(status, "");
+        }
+      }
+      return true;
+    },
+    305(aMessage) {
+      // RPL_UNAWAY
+      // :You are no longer marked as being away
+      this.isAway = false;
+      return true;
+    },
+    306(aMessage) {
+      // RPL_NOWAWAY
+      // :You have been marked as away
+      this.isAway = true;
+      return true;
+    },
+
+    /*
+     * WHOIS
+     */
+    311(aMessage) {
+      // RPL_WHOISUSER
+      // <nick> <user> <host> * :<real name>
+      // <username>@<hostname>
+      let nick = aMessage.params[1];
+      let source = aMessage.params[2] + "@" + aMessage.params[3];
+      // Some servers obfuscate the host when sending messages. Therefore,
+      // we set the account prefix by using the host from this response.
+      // We store it separately to avoid glitches due to the whois entry
+      // being temporarily deleted during future updates of the entry.
+      if (this.normalize(nick) == this.normalize(this._nickname)) {
+        this.prefix = "!" + source;
+      }
+      return this.setWhois(nick, {
+        realname: aMessage.params[5],
+        connectedFrom: source,
+      });
+    },
+    312(aMessage) {
+      // RPL_WHOISSERVER
+      // <nick> <server> :<server info>
+      return this.setWhois(aMessage.params[1], {
+        serverName: aMessage.params[2],
+        serverInfo: aMessage.params[3],
+      });
+    },
+    313(aMessage) {
+      // RPL_WHOISOPERATOR
+      // <nick> :is an IRC operator
+      return this.setWhois(aMessage.params[1], { ircOp: true });
+    },
+    314(aMessage) {
+      // RPL_WHOWASUSER
+      // <nick> <user> <host> * :<real name>
+      let source = aMessage.params[2] + "@" + aMessage.params[3];
+      return this.setWhois(aMessage.params[1], {
+        offline: true,
+        realname: aMessage.params[5],
+        connectedFrom: source,
+      });
+    },
+    315(aMessage) {
+      // RPL_ENDOFWHO
+      // <name> :End of WHO list
+      return false;
+    },
+    316(aMessage) {
+      // RPL_WHOISCHANOP
+      // Non-generic
+      return false;
+    },
+    317(aMessage) {
+      // RPL_WHOISIDLE
+      // <nick> <integer> :seconds idle
+      return this.setWhois(aMessage.params[1], {
+        lastActivity: parseInt(aMessage.params[2]),
+      });
+    },
+    318(aMessage) {
+      // RPL_ENDOFWHOIS
+      // <nick> :End of WHOIS list
+      // We've received everything about WHOIS, tell the tooltip that is waiting
+      // for this information.
+      let nick = aMessage.params[1];
+
+      if (this.whoisInformation.has(nick)) {
+        this.notifyWhois(nick);
+      } else {
+        // If there is no whois information stored at this point, the nick
+        // is either offline or does not exist, so we run WHOWAS.
+        this.requestOfflineBuddyInfo(nick);
+      }
+      return true;
+    },
+    319(aMessage) {
+      // RPL_WHOISCHANNELS
+      // <nick> :*( ( "@" / "+" ) <channel> " " )
+      return this.setWhois(aMessage.params[1], {
+        channels: aMessage.params[2],
+      });
+    },
+
+    /*
+     * LIST
+     */
+    321(aMessage) {
+      // RPL_LISTSTART
+      // Channel :Users Name
+      // Obsolete. Not used.
+      return true;
+    },
+    322(aMessage) {
+      // RPL_LIST
+      // <channel> <# visible> :<topic>
+      let name = aMessage.params[1];
+      let participantCount = aMessage.params[2];
+      let topic = aMessage.params[3];
+      // Some servers (e.g. Unreal) include the channel's modes before the topic.
+      // Omit this.
+      topic = topic.replace(/^\[\+[a-zA-Z]*\] /, "");
+      // Force the allocation of a new copy of the string so as to prevent
+      // the JS engine from retaining the whole original socket string. See bug
+      // 1058584. This hack can be removed when bug 1058653 is fixed.
+      topic = topic ? topic.normalize() : "";
+
+      this._channelList.set(name, { topic, participantCount });
+      this._currentBatch.push(name);
+      // Give callbacks a batch of channels of length _channelsPerBatch.
+      if (this._currentBatch.length == this._channelsPerBatch) {
+        for (let callback of this._roomInfoCallbacks) {
+          callback.onRoomInfoAvailable(this._currentBatch, false);
+        }
+        this._currentBatch = [];
+      }
+      return true;
+    },
+    323(aMessage) {
+      // RPL_LISTEND
+      // :End of LIST
+      this._sendRemainingRoomInfo();
+      return true;
+    },
+
+    /*
+     * Channel functions
+     */
+    324(aMessage) {
+      // RPL_CHANNELMODEIS
+      // <channel> <mode> <mode params>
+      this.getConversation(aMessage.params[1]).setMode(
+        aMessage.params[2],
+        aMessage.params.slice(3),
+        aMessage.origin
+      );
+
+      return true;
+    },
+    325(aMessage) {
+      // RPL_UNIQOPIS
+      // <channel> <nickname>
+      // TODO parse this and have the UI respond accordingly.
+      return false;
+    },
+    331(aMessage) {
+      // RPL_NOTOPIC
+      // <channel> :No topic is set
+      let conversation = this.getConversation(aMessage.params[1]);
+      // Clear the topic.
+      conversation.setTopic("");
+      return true;
+    },
+    332(aMessage) {
+      // RPL_TOPIC
+      // <channel> :<topic>
+      // Update the topic UI
+      let conversation = this.getConversation(aMessage.params[1]);
+      let topic = aMessage.params[2];
+      conversation.setTopic(topic ? ctcpFormatToText(topic) : "");
+      return true;
+    },
+    333(aMessage) {
+      // nonstandard
+      // <channel> <nickname> <time>
+      return true;
+    },
+
+    /*
+     * Invitations
+     */
+    341(aMessage) {
+      // RPL_INVITING
+      // <channel> <nick>
+      // Note that servers reply with parameters in the reverse order from the
+      // above (which is as specified by RFC 2812).
+      this.getConversation(aMessage.params[2]).writeMessage(
+        aMessage.origin,
+        lazy._("message.invited", aMessage.params[1], aMessage.params[2]),
+        { system: true }
+      );
+      return true;
+    },
+    342(aMessage) {
+      // RPL_SUMMONING
+      // <user> :Summoning user to IRC
+      return writeMessage(
+        this,
+        aMessage,
+        lazy._("message.summoned", aMessage.params[0])
+      );
+    },
+    346(aMessage) {
+      // RPL_INVITELIST
+      // <channel> <invitemask>
+      // TODO what do we do?
+      return false;
+    },
+    347(aMessage) {
+      // RPL_ENDOFINVITELIST
+      // <channel> :End of channel invite list
+      // TODO what do we do?
+      return false;
+    },
+    348(aMessage) {
+      // RPL_EXCEPTLIST
+      // <channel> <exceptionmask>
+      // TODO what do we do?
+      return false;
+    },
+    349(aMessage) {
+      // RPL_ENDOFEXCEPTIONLIST
+      // <channel> :End of channel exception list
+      // TODO update UI?
+      return false;
+    },
+
+    /*
+     * Version
+     */
+    351(aMessage) {
+      // RPL_VERSION
+      // <version>.<debuglevel> <server> :<comments>
+      return serverMessage(this, aMessage);
+    },
+
+    /*
+     * WHO
+     */
+    352(aMessage) {
+      // RPL_WHOREPLY
+      // <channel> <user> <host> <server> <nick> ( "H" / "G" ) ["*"] [ ("@" / "+" ) ] :<hopcount> <real name>
+      // TODO parse and display this?
+      return false;
+    },
+
+    /*
+     * NAMREPLY
+     */
+    353(aMessage) {
+      // RPL_NAMREPLY
+      // <target> ( "=" / "*" / "@" ) <channel> :[ "@" / "+" ] <nick> *( " " [ "@" / "+" ] <nick> )
+      let conversation = this.getConversation(aMessage.params[2]);
+      // Keep if this is secret (@), private (*) or public (=).
+      conversation.setModesFromRestriction(aMessage.params[1]);
+      // Add the participants.
+      let newParticipants = [];
+      aMessage.params[3]
+        .trim()
+        .split(" ")
+        .forEach(aNick =>
+          newParticipants.push(conversation.getParticipant(aNick, false))
+        );
+      conversation.notifyObservers(
+        new nsSimpleEnumerator(newParticipants),
+        "chat-buddy-add"
+      );
+      return true;
+    },
+
+    361(aMessage) {
+      // RPL_KILLDONE
+      // Non-generic
+      // TODO What is this?
+      return false;
+    },
+    362(aMessage) {
+      // RPL_CLOSING
+      // Non-generic
+      // TODO What is this?
+      return false;
+    },
+    363(aMessage) {
+      // RPL_CLOSEEND
+      // Non-generic
+      // TODO What is this?
+      return false;
+    },
+
+    /*
+     * Links.
+     */
+    364(aMessage) {
+      // RPL_LINKS
+      // <mask> <server> :<hopcount> <server info>
+      return serverMessage(this, aMessage);
+    },
+    365(aMessage) {
+      // RPL_ENDOFLINKS
+      // <mask> :End of LINKS list
+      return true;
+    },
+
+    /*
+     * Names
+     */
+    366(aMessage) {
+      // RPL_ENDOFNAMES
+      // <target> <channel> :End of NAMES list
+      // All participants have already been added by the 353 handler.
+
+      // This assumes that this is the last message received when joining a
+      // channel, so a few "clean up" tasks are done here.
+      let conversation = this.getConversation(aMessage.params[1]);
+
+      // Update the topic as we may have added the participant for
+      // the user after the mode message was handled, and so
+      // topicSettable may have changed.
+      conversation.notifyObservers(this, "chat-update-topic");
+
+      // If we haven't received the MODE yet, request it.
+      if (!conversation._receivedInitialMode) {
+        this.sendMessage("MODE", aMessage.params[1]);
+      }
+
+      return true;
+    },
+    /*
+     * End of a bunch of lists
+     */
+    367(aMessage) {
+      // RPL_BANLIST
+      // <channel> <banmask>
+      let conv = this.getConversation(aMessage.params[1]);
+      if (!conv.banMasks.includes(aMessage.params[2])) {
+        conv.banMasks.push(aMessage.params[2]);
+      }
+      return true;
+    },
+    368(aMessage) {
+      // RPL_ENDOFBANLIST
+      // <channel> :End of channel ban list
+      let conv = this.getConversation(aMessage.params[1]);
+      let msg;
+      if (conv.banMasks.length) {
+        msg = [lazy._("message.banMasks", aMessage.params[1])]
+          .concat(conv.banMasks)
+          .join("\n");
+      } else {
+        msg = lazy._("message.noBanMasks", aMessage.params[1]);
+      }
+      conv.writeMessage(aMessage.origin, msg, { system: true });
+      return true;
+    },
+    369(aMessage) {
+      // RPL_ENDOFWHOWAS
+      // <nick> :End of WHOWAS
+      // We've received everything about WHOWAS, tell the tooltip that is waiting
+      // for this information.
+      this.notifyWhois(aMessage.params[1]);
+      return true;
+    },
+
+    /*
+     * Server info
+     */
+    371(aMessage) {
+      // RPL_INFO
+      // :<string>
+      return serverMessage(this, aMessage);
+    },
+    372(aMessage) {
+      // RPL_MOTD
+      // :- <text>
+      return addMotd(this, aMessage);
+    },
+    373(aMessage) {
+      // RPL_INFOSTART
+      // Non-generic
+      // This is unnecessary and servers just send RPL_INFO.
+      return true;
+    },
+    374(aMessage) {
+      // RPL_ENDOFINFO
+      // :End of INFO list
+      return true;
+    },
+    375(aMessage) {
+      // RPL_MOTDSTART
+      // :- <server> Message of the day -
+      return addMotd(this, aMessage);
+    },
+    376(aMessage) {
+      // RPL_ENDOFMOTD
+      // :End of MOTD command
+      // Show the MOTD if the user wants to see server messages or if
+      // RPL_WELCOME has not been received since some servers (e.g. irc.ppy.sh)
+      // use this as a CAPTCHA like mechanism before login can occur.
+      if (this._showServerTab || !this.connected) {
+        writeMessage(this, aMessage, this._motd.join("\n"), "incoming");
+      }
+      // No reason to keep the MOTD in memory.
+      delete this._motd;
+      // Clear the MOTD timer.
+      clearTimeout(this._motdTimer);
+      delete this._motdTimer;
+
+      return true;
+    },
+
+    /*
+     * OPER
+     */
+    381(aMessage) {
+      // RPL_YOUREOPER
+      // :You are now an IRC operator
+      // TODO update UI accordingly to show oper status
+      return serverMessage(this, aMessage);
+    },
+    382(aMessage) {
+      // RPL_REHASHING
+      // <config file> :Rehashing
+      return serverMessage(this, aMessage);
+    },
+    383(aMessage) {
+      // RPL_YOURESERVICE
+      // You are service <servicename>
+      this.WARN('Received "You are a service" message.');
+      return true;
+    },
+
+    /*
+     * Info
+     */
+    384(aMessage) {
+      // RPL_MYPORTIS
+      // Non-generic
+      // TODO Parse and display?
+      return false;
+    },
+    391(aMessage) {
+      // RPL_TIME
+      // <server> :<string showing server's local time>
+
+      let msg = lazy._("ctcp.time", aMessage.params[1], aMessage.params[2]);
+      // Show the date returned from the server, note that this doesn't use
+      // the serverMessage function: since this is in response to a command, it
+      // should always be shown.
+      return writeMessage(this, aMessage, msg, "system");
+    },
+    392(aMessage) {
+      // RPL_USERSSTART
+      // :UserID   Terminal  Host
+      // TODO
+      return false;
+    },
+    393(aMessage) {
+      // RPL_USERS
+      // :<username> <ttyline> <hostname>
+      // TODO store into buddy list? List out?
+      return false;
+    },
+    394(aMessage) {
+      // RPL_ENDOFUSERS
+      // :End of users
+      // TODO Notify observers of the buddy list?
+      return false;
+    },
+    395(aMessage) {
+      // RPL_NOUSERS
+      // :Nobody logged in
+      // TODO clear buddy list?
+      return false;
+    },
+
+    // Error messages, Implement Section 5.2 of RFC 2812
+    401(aMessage) {
+      // ERR_NOSUCHNICK
+      // <nickname> :No such nick/channel
+      // Can arise in response to /mode, /invite, /kill, /msg, /whois.
+      // TODO Handled in the conversation for /whois and /mgs so far.
+      let msgId =
+        "error.noSuch" +
+        (this.isMUCName(aMessage.params[1]) ? "Channel" : "Nick");
+      if (this.conversations.has(aMessage.params[1])) {
+        // If the conversation exists and we just sent a message from it, then
+        // notify that the user is offline.
+        if (this.getConversation(aMessage.params[1])._pendingMessage) {
+          conversationErrorMessage(this, aMessage, msgId);
+        }
+      }
+
+      return serverErrorMessage(
+        this,
+        aMessage,
+        lazy._(msgId, aMessage.params[1])
+      );
+    },
+    402(aMessage) {
+      // ERR_NOSUCHSERVER
+      // <server name> :No such server
+      // TODO Parse & display an error to the user.
+      return false;
+    },
+    403(aMessage) {
+      // ERR_NOSUCHCHANNEL
+      // <channel name> :No such channel
+      return conversationErrorMessage(
+        this,
+        aMessage,
+        "error.noChannel",
+        true,
+        false
+      );
+    },
+    404(aMessage) {
+      // ERR_CANNOTSENDTOCHAN
+      // <channel name> :Cannot send to channel
+      // Notify the user that they can't send to that channel.
+      return conversationErrorMessage(
+        this,
+        aMessage,
+        "error.cannotSendToChannel"
+      );
+    },
+    405(aMessage) {
+      // ERR_TOOMANYCHANNELS
+      // <channel name> :You have joined too many channels
+      return conversationErrorMessage(
+        this,
+        aMessage,
+        "error.tooManyChannels",
+        true
+      );
+    },
+    406(aMessage) {
+      // ERR_WASNOSUCHNICK
+      // <nickname> :There was no such nickname
+      // Can arise in response to WHOWAS.
+      return serverErrorMessage(
+        this,
+        aMessage,
+        lazy._("error.wasNoSuchNick", aMessage.params[1])
+      );
+    },
+    407(aMessage) {
+      // ERR_TOOMANYTARGETS
+      // <target> :<error code> recipients. <abort message>
+      return conversationErrorMessage(
+        this,
+        aMessage,
+        "error.nonUniqueTarget",
+        false,
+        false
+      );
+    },
+    408(aMessage) {
+      // ERR_NOSUCHSERVICE
+      // <service name> :No such service
+      // TODO
+      return false;
+    },
+    409(aMessage) {
+      // ERR_NOORIGIN
+      // :No origin specified
+      // TODO failed PING/PONG message, this should never occur?
+      return false;
+    },
+    411(aMessage) {
+      // ERR_NORECIPIENT
+      // :No recipient given (<command>)
+      // If this happens a real error with the protocol occurred.
+      this.ERROR("ERR_NORECIPIENT: No recipient given for PRIVMSG.");
+      return true;
+    },
+    412(aMessage) {
+      // ERR_NOTEXTTOSEND
+      // :No text to send
+      // If this happens a real error with the protocol occurred: we should
+      // always block the user from sending empty messages.
+      this.ERROR("ERR_NOTEXTTOSEND: No text to send for PRIVMSG.");
+      return true;
+    },
+    413(aMessage) {
+      // ERR_NOTOPLEVEL
+      // <mask> :No toplevel domain specified
+      // If this response is received, a real error occurred in the protocol.
+      this.ERROR("ERR_NOTOPLEVEL: Toplevel domain not specified.");
+      return true;
+    },
+    414(aMessage) {
+      // ERR_WILDTOPLEVEL
+      // <mask> :Wildcard in toplevel domain
+      // If this response is received, a real error occurred in the protocol.
+      this.ERROR("ERR_WILDTOPLEVEL: Wildcard toplevel domain specified.");
+      return true;
+    },
+    415(aMessage) {
+      // ERR_BADMASK
+      // <mask> :Bad Server/host mask
+      // If this response is received, a real error occurred in the protocol.
+      this.ERROR("ERR_BADMASK: Bad server/host mask specified.");
+      return true;
+    },
+    421(aMessage) {
+      // ERR_UNKNOWNCOMMAND
+      // <command> :Unknown command
+      // TODO This shouldn't occur.
+      return false;
+    },
+    422(aMessage) {
+      // ERR_NOMOTD
+      // :MOTD File is missing
+      // No message of the day to display.
+      return true;
+    },
+    423(aMessage) {
+      // ERR_NOADMININFO
+      // <server> :No administrative info available
+      // TODO
+      return false;
+    },
+    424(aMessage) {
+      // ERR_FILEERROR
+      // :File error doing <file op> on <file>
+      // TODO
+      return false;
+    },
+    431(aMessage) {
+      // ERR_NONICKNAMEGIVEN
+      // :No nickname given
+      // TODO
+      return false;
+    },
+    432(aMessage) {
+      // ERR_ERRONEUSNICKNAME
+      // <nick> :Erroneous nickname
+      let msg = lazy._("error.erroneousNickname", this._requestedNickname);
+      serverErrorMessage(this, aMessage, msg);
+      if (this._requestedNickname == this._accountNickname) {
+        // The account has been set up with an illegal nickname.
+        this.ERROR(
+          "Erroneous nickname " +
+            this._requestedNickname +
+            ": " +
+            aMessage.params.slice(1).join(" ")
+        );
+        this.gotDisconnected(Ci.prplIAccount.ERROR_INVALID_USERNAME, msg);
+      } else {
+        // Reset original nickname to the account nickname in case of
+        // later reconnections.
+        this._requestedNickname = this._accountNickname;
+      }
+      return true;
+    },
+    433(aMessage) {
+      // ERR_NICKNAMEINUSE
+      // <nick> :Nickname is already in use
+      // Try to get the desired nick back in 2.5 minutes if this happens when
+      // connecting, in case it was just due to the user's nick not having
+      // timed out yet on the server.
+      if (this.connecting && aMessage.params[1] == this._requestedNickname) {
+        this._nickInUseTimeout = setTimeout(() => {
+          this.changeNick(this._requestedNickname);
+          delete this._nickInUseTimeout;
+        }, 150000);
+      }
+      return this.tryNewNick(aMessage.params[1]);
+    },
+    436(aMessage) {
+      // ERR_NICKCOLLISION
+      // <nick> :Nickname collision KILL from <user>@<host>
+      return this.tryNewNick(aMessage.params[1]);
+    },
+    437(aMessage) {
+      // ERR_UNAVAILRESOURCE
+      // <nick/channel> :Nick/channel is temporarily unavailable
+      return conversationErrorMessage(
+        this,
+        aMessage,
+        "error.unavailable",
+        true
+      );
+    },
+    441(aMessage) {
+      // ERR_USERNOTINCHANNEL
+      // <nick> <channel> :They aren't on that channel
+      // TODO
+      return false;
+    },
+    442(aMessage) {
+      // ERR_NOTONCHANNEL
+      // <channel> :You're not on that channel
+      this.ERROR(
+        "A command affecting " +
+          aMessage.params[1] +
+          " failed because you aren't in that channel."
+      );
+      return true;
+    },
+    443(aMessage) {
+      // ERR_USERONCHANNEL
+      // <user> <channel> :is already on channel
+      this.getConversation(aMessage.params[2]).writeMessage(
+        aMessage.origin,
+        lazy._(
+          "message.alreadyInChannel",
+          aMessage.params[1],
+          aMessage.params[2]
+        ),
+        { system: true }
+      );
+      return true;
+    },
+    444(aMessage) {
+      // ERR_NOLOGIN
+      // <user> :User not logged in
+      // TODO
+      return false;
+    },
+    445(aMessage) {
+      // ERR_SUMMONDISABLED
+      // :SUMMON has been disabled
+      // TODO keep track of this and disable UI associated?
+      return false;
+    },
+    446(aMessage) {
+      // ERR_USERSDISABLED
+      // :USERS has been disabled
+      // TODO Disabled all buddy list etc.
+      return false;
+    },
+    451(aMessage) {
+      // ERR_NOTREGISTERED
+      // :You have not registered
+      // If the server doesn't understand CAP it might return this error.
+      if (aMessage.params[0] == "CAP") {
+        this.LOG("Server doesn't support CAP.");
+        return true;
+      }
+      // TODO
+      return false;
+    },
+    461(aMessage) {
+      // ERR_NEEDMOREPARAMS
+      // <command> :Not enough parameters
+
+      if (!this.connected) {
+        // The account has been set up with an illegal username.
+        this.ERROR("Erroneous username: " + this.username);
+        this.gotDisconnected(
+          Ci.prplIAccount.ERROR_INVALID_USERNAME,
+          lazy._("connection.error.invalidUsername", this.user)
+        );
+        return true;
+      }
+
+      return false;
+    },
+    462(aMessage) {
+      // ERR_ALREADYREGISTERED
+      // :Unauthorized command (already registered)
+      // TODO
+      return false;
+    },
+    463(aMessage) {
+      // ERR_NOPERMFORHOST
+      // :Your host isn't among the privileged
+      // TODO
+      return false;
+    },
+    464(aMessage) {
+      // ERR_PASSWDMISMATCH
+      // :Password incorrect
+      this.gotDisconnected(
+        Ci.prplIAccount.ERROR_AUTHENTICATION_FAILED,
+        lazy._("connection.error.invalidPassword")
+      );
+      return true;
+    },
+    465(aMessage) {
+      // ERR_YOUREBANEDCREEP
+      // :You are banned from this server
+      serverErrorMessage(this, aMessage, lazy._("error.banned"));
+      this.gotDisconnected(
+        Ci.prplIAccount.ERROR_OTHER_ERROR,
+        lazy._("error.banned")
+      ); // Notify account manager.
+      return true;
+    },
+    466(aMessage) {
+      // ERR_YOUWILLBEBANNED
+      return serverErrorMessage(this, aMessage, lazy._("error.bannedSoon"));
+    },
+    467(aMessage) {
+      // ERR_KEYSET
+      // <channel> :Channel key already set
+      // TODO
+      return false;
+    },
+    471(aMessage) {
+      // ERR_CHANNELISFULL
+      // <channel> :Cannot join channel (+l)
+      return conversationErrorMessage(
+        this,
+        aMessage,
+        "error.channelFull",
+        true
+      );
+    },
+    472(aMessage) {
+      // ERR_UNKNOWNMODE
+      // <char> :is unknown mode char to me for <channel>
+      // TODO
+      return false;
+    },
+    473(aMessage) {
+      // ERR_INVITEONLYCHAN
+      // <channel> :Cannot join channel (+i)
+      return conversationErrorMessage(
+        this,
+        aMessage,
+        "error.inviteOnly",
+        true,
+        false
+      );
+    },
+    474(aMessage) {
+      // ERR_BANNEDFROMCHAN
+      // <channel> :Cannot join channel (+b)
+      return conversationErrorMessage(
+        this,
+        aMessage,
+        "error.channelBanned",
+        true,
+        false
+      );
+    },
+    475(aMessage) {
+      // ERR_BADCHANNELKEY
+      // <channel> :Cannot join channel (+k)
+      return conversationErrorMessage(
+        this,
+        aMessage,
+        "error.wrongKey",
+        true,
+        false
+      );
+    },
+    476(aMessage) {
+      // ERR_BADCHANMASK
+      // <channel> :Bad Channel Mask
+      // TODO
+      return false;
+    },
+    477(aMessage) {
+      // ERR_NOCHANMODES
+      // <channel> :Channel doesn't support modes
+      // TODO
+      return false;
+    },
+    478(aMessage) {
+      // ERR_BANLISTFULL
+      // <channel> <char> :Channel list is full
+      // TODO
+      return false;
+    },
+    481(aMessage) {
+      // ERR_NOPRIVILEGES
+      // :Permission Denied- You're not an IRC operator
+      // TODO ask to auth?
+      return false;
+    },
+    482(aMessage) {
+      // ERR_CHANOPRIVSNEEDED
+      // <channel> :You're not channel operator
+      return conversationErrorMessage(this, aMessage, "error.notChannelOp");
+    },
+    483(aMessage) {
+      // ERR_CANTKILLSERVER
+      // :You can't kill a server!
+      // TODO Display error?
+      return false;
+    },
+    484(aMessage) {
+      // ERR_RESTRICTED
+      // :Your connection is restricted!
+      // Indicates user mode +r
+      // TODO
+      return false;
+    },
+    485(aMessage) {
+      // ERR_UNIQOPPRIVSNEEDED
+      // :You're not the original channel operator
+      // TODO ask to auth?
+      return false;
+    },
+    491(aMessage) {
+      // ERR_NOOPERHOST
+      // :No O-lines for your host
+      // TODO
+      return false;
+    },
+    492(aMessage) {
+      // ERR_NOSERVICEHOST
+      // Non-generic
+      // TODO
+      return false;
+    },
+    501(aMessage) {
+      // ERR_UMODEUNKNOWNFLAGS
+      // :Unknown MODE flag
+      return serverErrorMessage(
+        this,
+        aMessage,
+        lazy._("error.unknownMode", aMessage.params[1])
+      );
+    },
+    502(aMessage) {
+      // ERR_USERSDONTMATCH
+      // :Cannot change mode for other users
+      return serverErrorMessage(this, aMessage, lazy._("error.mode.wrongUser"));
+    },
+  },
+};
diff --git a/comm/chat/protocols/irc/ircCAP.sys.mjs b/comm/chat/protocols/irc/ircCAP.sys.mjs
new file mode 100644
index 0000000000..3bcff48d8b
--- /dev/null
+++ b/comm/chat/protocols/irc/ircCAP.sys.mjs
@@ -0,0 +1,170 @@
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
+
+/*
+ * This implements the IRC Client Capabilities sub-protocol.
+ *   Client Capab Proposal
+ *     http://www.leeh.co.uk/ircd/client-cap.txt
+ *   RFC Drafts: IRC Client Capabilities
+ *     http://tools.ietf.org/html/draft-baudis-irc-capab-00
+ *     http://tools.ietf.org/html/draft-mitchell-irc-capabilities-01
+ *   IRCv3
+ *     https://ircv3.net/specs/core/capability-negotiation.html
+ *
+ * Note that this doesn't include any implementation as these RFCs do not even
+ * include example parameters.
+ */
+
+import { ircHandlerPriorities } from "resource:///modules/ircHandlerPriorities.sys.mjs";
+
+/*
+ * Parses a CAP message of the form:
+ *   CAP [*|<user>] <subcommand> [*] [<parameters>]
+ * The cap field is added to the message and it has the following fields:
+ *   subcommand
+ *   parameters A list of capabilities.
+ */
+export function capMessage(aMessage, aAccount) {
+  // The CAP parameters are space separated as the last parameter.
+  let parameters = aMessage.params.slice(-1)[0].trim().split(" ");
+  // The subcommand is the second parameter...although sometimes it's the first
+  // parameter.
+  aMessage.cap = {
+    subcommand: aMessage.params[aMessage.params.length >= 3 ? 1 : 0],
+  };
+
+  const messages = parameters.map(function (aParameter) {
+    // Clone the original object.
+    let message = Object.assign({}, aMessage);
+    message.cap = Object.assign({}, aMessage.cap);
+
+    // If there's a modifier...pull it off. (This is pretty much unused, but we
+    // have to pull it off for backward compatibility.)
+    if ("-=~".includes(aParameter[0])) {
+      message.cap.modifier = aParameter[0];
+      aParameter = aParameter.substr(1);
+    } else {
+      message.cap.modifier = undefined;
+    }
+
+    // CAP v3.2 capability value
+    if (aParameter.includes("=")) {
+      let paramParts = aParameter.split("=");
+      aParameter = paramParts[0];
+      // The value itself may contain an = sign, join the rest of the parts back together.
+      message.cap.value = paramParts.slice(1).join("=");
+    }
+
+    // The names are case insensitive, arbitrarily choose lowercase.
+    message.cap.parameter = aParameter.toLowerCase();
+    message.cap.disable = message.cap.modifier == "-";
+    message.cap.sticky = message.cap.modifier == "=";
+    message.cap.ack = message.cap.modifier == "~";
+
+    return message;
+  });
+
+  // Queue up messages if the server is indicating multiple lines of caps to list.
+  if (
+    (aMessage.cap.subcommand === "LS" || aMessage.cap.subcommand === "LIST") &&
+    aMessage.params.length == 4
+  ) {
+    aAccount._queuedCAPs = aAccount._queuedCAPs.concat(messages);
+    return [];
+  }
+
+  const retMessages = aAccount._queuedCAPs.concat(messages);
+  aAccount._queuedCAPs.length = 0;
+  return retMessages;
+}
+
+export var ircCAP = {
+  name: "Client Capabilities",
+  // Slightly above default RFC 2812 priority.
+  priority: ircHandlerPriorities.DEFAULT_PRIORITY + 10,
+  isEnabled: () => true,
+
+  commands: {
+    CAP(message, ircHandlers) {
+      // [* | <nick>] <subcommand> :<parameters>
+      let messages = capMessage(message, this);
+
+      for (const capCommandMessage of messages) {
+        if (
+          capCommandMessage.cap.subcommand === "LS" ||
+          capCommandMessage.cap.subcommand === "NEW"
+        ) {
+          this._availableCAPs.add(capCommandMessage.cap.parameter);
+        } else if (capCommandMessage.cap.subcommand === "ACK") {
+          this._activeCAPs.add(capCommandMessage.cap.parameter);
+        } else if (capCommandMessage.cap.subcommand === "DEL") {
+          this._availableCAPs.delete(capCommandMessage.cap.parameter);
+          this._activeCAPs.delete(capCommandMessage.cap.parameter);
+        }
+      }
+
+      messages = messages.filter(
+        aMessage => !ircHandlers.handleCAPMessage(this, aMessage)
+      );
+      if (messages.length) {
+        // Display the list of unhandled CAP messages.
+        let unhandledMessages = messages
+          .map(aMsg => aMsg.cap.parameter)
+          .join(" ");
+        this.LOG(
+          "Unhandled CAP messages: " +
+            unhandledMessages +
+            "\nRaw message: " +
+            message.rawMessage
+        );
+      }
+
+      // If no CAP handlers were added, just tell the server we're done.
+      if (
+        message.cap.subcommand == "LS" &&
+        !this._requestedCAPs.size &&
+        !this._queuedCAPs.length
+      ) {
+        this.sendMessage("CAP", "END");
+        this._negotiatedCAPs = true;
+      }
+      return true;
+    },
+
+    410(aMessage) {
+      // ERR_INVALIDCAPCMD
+      // <unrecognized subcommand> :Invalid CAP subcommand
+      this.WARN("Invalid subcommand: " + aMessage.params[1]);
+      return true;
+    },
+  },
+};
+
+export var capNotify = {
+  name: "Client Capabilities",
+  priority: ircHandlerPriorities.DEFAULT_PRIORITY,
+  // This is implicitly enabled as part of CAP v3.2, so always enable it.
+  isEnabled: () => true,
+
+  commands: {
+    "cap-notify": function (aMessage) {
+      // This negotiation is entirely optional. cap-notify may thus never be formally registered.
+      if (
+        aMessage.cap.subcommand === "LS" ||
+        aMessage.cap.subcommand === "NEW"
+      ) {
+        this.addCAP("cap-notify");
+        this.sendMessage("CAP", ["REQ", "cap-notify"]);
+      } else if (
+        aMessage.cap.subcommand === "ACK" ||
+        aMessage.cap.subcommand === "NAK"
+      ) {
+        this.removeCAP("cap-notify");
+      } else {
+        return false;
+      }
+      return true;
+    },
+  },
+};
diff --git a/comm/chat/protocols/irc/ircCTCP.sys.mjs b/comm/chat/protocols/irc/ircCTCP.sys.mjs
new file mode 100644
index 0000000000..475f1f8a8d
--- /dev/null
+++ b/comm/chat/protocols/irc/ircCTCP.sys.mjs
@@ -0,0 +1,291 @@
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
+
+/**
+ * This implements the Client-to-Client Protocol (CTCP), a subprotocol of IRC.
+ *   REVISED AND UPDATED CTCP SPECIFICATION
+ *     http://www.alien.net.au/irc/ctcp.txt
+ */
+
+import { XPCOMUtils } from "resource://gre/modules/XPCOMUtils.sys.mjs";
+import { l10nHelper } from "resource:///modules/imXPCOMUtils.sys.mjs";
+import { ircHandlerPriorities } from "resource:///modules/ircHandlerPriorities.sys.mjs";
+import { displayMessage } from "resource:///modules/ircUtils.sys.mjs";
+
+const lazy = {};
+XPCOMUtils.defineLazyGetter(lazy, "_", () =>
+  l10nHelper("chrome://chat/locale/irc.properties")
+);
+
+// Split into a CTCP message which is a single command and a single parameter:
+//   <command> " " <parameter>
+// The high level dequote is to unescape \001 in the message content.
+export function CTCPMessage(aMessage, aRawCTCPMessage) {
+  let message = Object.assign({}, aMessage);
+  message.ctcp = {};
+  message.ctcp.rawMessage = aRawCTCPMessage;
+
+  // High/CTCP level dequote: replace the quote char \134 followed by a or \134
+  // with \001 or \134, respectively. Any other character after \134 is replaced
+  // with itself.
+  let dequotedCTCPMessage = message.ctcp.rawMessage.replace(
+    /\\(.|$)/g,
+    aStr => {
+      if (aStr[1]) {
+        return aStr[1] == "a" ? "\x01" : aStr[1];
+      }
+      return "";
+    }
+  );
+
+  let separator = dequotedCTCPMessage.indexOf(" ");
+  // If there's no space, then only a command is given.
+  // Do not capitalize the command, case sensitive
+  if (separator == -1) {
+    message.ctcp.command = dequotedCTCPMessage;
+    message.ctcp.param = "";
+  } else {
+    message.ctcp.command = dequotedCTCPMessage.slice(0, separator);
+    message.ctcp.param = dequotedCTCPMessage.slice(separator + 1);
+  }
+  return message;
+}
+
+// This is the CTCP handler for IRC protocol, it will call each CTCP handler.
+export var ircCTCP = {
+  name: "CTCP",
+  // Slightly above default RFC 2812 priority.
+  priority: ircHandlerPriorities.HIGH_PRIORITY,
+  isEnabled: () => true,
+
+  // CTCP uses only PRIVMSG and NOTICE commands.
+  commands: {
+    PRIVMSG: ctcpHandleMessage,
+    NOTICE: ctcpHandleMessage,
+  },
+};
+
+// Parse the message and call all CTCP handlers on the message.
+function ctcpHandleMessage(message, ircHandlers) {
+  // If there are no CTCP handlers, then don't parse the CTCP message.
+  if (!ircHandlers.hasCTCPHandlers) {
+    return false;
+  }
+
+  // The raw CTCP message is in the last parameter of the IRC message.
+  let rawCTCPParam = message.params.slice(-1)[0];
+
+  // Split the raw message into the multiple CTCP messages and pull out the
+  // command and parameters.
+  let ctcpMessages = [];
+  let otherMessage = rawCTCPParam.replace(
+    // eslint-disable-next-line no-control-regex
+    /\x01([^\x01]*)\x01/g,
+    function (aMatch, aMsg) {
+      if (aMsg) {
+        ctcpMessages.push(new CTCPMessage(message, aMsg));
+      }
+      return "";
+    }
+  );
+
+  // If no CTCP messages were found, return false.
+  if (!ctcpMessages.length) {
+    return false;
+  }
+
+  // If there's some message left, send it back through the IRC handlers after
+  // stripping out the CTCP information. I highly doubt this will ever happen,
+  // but just in case. ;)
+  if (otherMessage) {
+    message.params.pop();
+    message.params.push(otherMessage);
+    ircHandlers.handleMessage(this, message);
+  }
+
+  // Loop over each raw CTCP message.
+  for (let message of ctcpMessages) {
+    if (!ircHandlers.handleCTCPMessage(this, message)) {
+      this.WARN(
+        "Unhandled CTCP message: " +
+          message.ctcp.rawMessage +
+          "\nin IRC message: " +
+          message.rawMessage
+      );
+      // For unhandled CTCP message, respond with a NOTICE ERRMSG that echoes
+      // back the original command.
+      this.sendCTCPMessage(message.origin, true, "ERRMSG", [
+        message.ctcp.rawMessage,
+        ":Unhandled CTCP command",
+      ]);
+    }
+  }
+
+  // We have handled this message as much as we can.
+  return true;
+}
+
+// This is the the basic CTCP protocol.
+export var ctcpBase = {
+  // Parameters
+  name: "CTCP",
+  priority: ircHandlerPriorities.DEFAULT_PRIORITY,
+  isEnabled: () => true,
+
+  // These represent CTCP commands.
+  commands: {
+    ACTION(aMessage) {
+      // ACTION <text>
+      // Display message in conversation
+      return displayMessage(
+        this,
+        aMessage,
+        { action: true },
+        aMessage.ctcp.param
+      );
+    },
+
+    // Used when an error needs to be replied with.
+    ERRMSG(aMessage) {
+      this.WARN(
+        aMessage.origin +
+          " failed to handle CTCP message: " +
+          aMessage.ctcp.param
+      );
+      return true;
+    },
+
+    // This is commented out since CLIENTINFO automatically returns the
+    // supported CTCP parameters and this is not supported.
+
+    // Returns the user's full name, and idle time.
+    // "FINGER": function(aMessage) { return false; },
+
+    // Dynamic master index of what a client knows.
+    CLIENTINFO(message, ircHandlers) {
+      if (message.command == "PRIVMSG") {
+        // Received a CLIENTINFO request, respond with the support CTCP
+        // messages.
+        let info = new Set();
+        for (let handler of ircHandlers._ctcpHandlers) {
+          for (let command in handler.commands) {
+            info.add(command);
+          }
+        }
+
+        let supportedCtcp = [...info].join(" ");
+        this.LOG(
+          "Reporting support for the following CTCP messages: " + supportedCtcp
+        );
+        this.sendCTCPMessage(message.origin, true, "CLIENTINFO", supportedCtcp);
+      } else {
+        // Received a CLIENTINFO response, store the information for future
+        // use.
+        let info = message.ctcp.param.split(" ");
+        this.setWhois(message.origin, { clientInfo: info });
+      }
+      return true;
+    },
+
+    // Used to measure the delay of the IRC network between clients.
+    PING(aMessage) {
+      // PING timestamp
+      if (aMessage.command == "PRIVMSG") {
+        // Received PING request, send PING response.
+        this.LOG(
+          "Received PING request from " +
+            aMessage.origin +
+            '. Sending PING response: "' +
+            aMessage.ctcp.param +
+            '".'
+        );
+        this.sendCTCPMessage(
+          aMessage.origin,
+          true,
+          "PING",
+          aMessage.ctcp.param
+        );
+        return true;
+      }
+      return this.handlePingReply(aMessage.origin, aMessage.ctcp.param);
+    },
+
+    // These are commented out since CLIENTINFO automatically returns the
+    // supported CTCP parameters and this is not supported.
+
+    // An encryption protocol between clients without any known reference.
+    // "SED": function(aMessage) { return false; },
+
+    // Where to obtain a copy of a client.
+    // "SOURCE": function(aMessage) { return false; },
+
+    // Gets the local date and time from other clients.
+    TIME(aMessage) {
+      if (aMessage.command == "PRIVMSG") {
+        // TIME
+        // Received a TIME request, send a human readable response.
+        let now = new Date().toString();
+        this.LOG(
+          "Received TIME request from " +
+            aMessage.origin +
+            '. Sending TIME response: "' +
+            now +
+            '".'
+        );
+        this.sendCTCPMessage(aMessage.origin, true, "TIME", ":" + now);
+      } else {
+        // TIME :<human-readable-time-string>
+        // Received a TIME reply, display it.
+        // Remove the : prefix, if it exists and display the result.
+        let time = aMessage.ctcp.param.slice(aMessage.ctcp.param[0] == ":");
+        this.getConversation(aMessage.origin).writeMessage(
+          aMessage.origin,
+          lazy._("ctcp.time", aMessage.origin, time),
+          { system: true, tags: aMessage.tags }
+        );
+      }
+      return true;
+    },
+
+    // This is commented out since CLIENTINFO automatically returns the
+    // supported CTCP parameters and this is not supported.
+
+    // A string set by the user (never the client coder)
+    // "USERINFO": function(aMessage) { return false; },
+
+    // The version and type of the client.
+    VERSION(aMessage) {
+      if (aMessage.command == "PRIVMSG") {
+        // VERSION
+        // Received VERSION request, send VERSION response.
+        let version = Services.appinfo.name + " " + Services.appinfo.version;
+        this.LOG(
+          "Received VERSION request from " +
+            aMessage.origin +
+            '. Sending VERSION response: "' +
+            version +
+            '".'
+        );
+        this.sendCTCPMessage(aMessage.origin, true, "VERSION", version);
+      } else if (aMessage.command == "NOTICE" && aMessage.ctcp.param.length) {
+        // VERSION #:#:#
+        // Received VERSION response, display to the user.
+        let response = lazy._(
+          "ctcp.version",
+          aMessage.origin,
+          aMessage.ctcp.param
+        );
+        this.getConversation(aMessage.origin).writeMessage(
+          aMessage.origin,
+          response,
+          {
+            system: true,
+            tags: aMessage.tags,
+          }
+        );
+      }
+      return true;
+    },
+  },
+};
diff --git a/comm/chat/protocols/irc/ircCommands.sys.mjs b/comm/chat/protocols/irc/ircCommands.sys.mjs
new file mode 100644
index 0000000000..78d984b179
--- /dev/null
+++ b/comm/chat/protocols/irc/ircCommands.sys.mjs
@@ -0,0 +1,599 @@
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
+
+// This is to be exported directly onto the IRC prplIProtocol object, directly
+// implementing the commands field before we register them.
+import { XPCOMUtils } from "resource://gre/modules/XPCOMUtils.sys.mjs";
+import { l10nHelper } from "resource:///modules/imXPCOMUtils.sys.mjs";
+
+const lazy = {};
+XPCOMUtils.defineLazyGetter(lazy, "_", () =>
+  l10nHelper("chrome://chat/locale/irc.properties")
+);
+
+// Shortcut to get the JavaScript conversation object.
+function getConv(aConv) {
+  return aConv.wrappedJSObject;
+}
+
+// Shortcut to get the JavaScript account object.
+function getAccount(aConv) {
+  return getConv(aConv)._account;
+}
+
+// Trim leading and trailing spaces and split a string by any type of space.
+function splitInput(aString) {
+  return aString.trim().split(/\s+/);
+}
+
+// Kick a user from a channel
+// aMsg is <user> [comment]
+function kickCommand(aMsg, aConv) {
+  if (!aMsg.length) {
+    return false;
+  }
+
+  let params = [aConv.name];
+  let offset = aMsg.indexOf(" ");
+  if (offset != -1) {
+    params.push(aMsg.slice(0, offset));
+    params.push(aMsg.slice(offset + 1));
+  } else {
+    params.push(aMsg);
+  }
+
+  getAccount(aConv).sendMessage("KICK", params);
+  return true;
+}
+
+// Send a message directly to a user.
+// aMsg is <user> <message>
+// aReturnedConv is optional and returns the resulting conversation.
+function messageCommand(aMsg, aConv, aReturnedConv, aIsNotice = false) {
+  // Trim leading whitespace.
+  aMsg = aMsg.trimLeft();
+
+  let nickname = aMsg;
+  let message = "";
+
+  let sep = aMsg.indexOf(" ");
+  if (sep > -1) {
+    nickname = aMsg.slice(0, sep);
+    message = aMsg.slice(sep + 1);
+  }
+  if (!nickname.length) {
+    return false;
+  }
+
+  let conv = getAccount(aConv).getConversation(nickname);
+  if (aReturnedConv) {
+    aReturnedConv.value = conv;
+  }
+
+  if (!message.length) {
+    return true;
+  }
+
+  return privateMessage(aConv, message, nickname, aReturnedConv, aIsNotice);
+}
+
+// aAdd is true to add a mode, false to remove a mode.
+function setMode(aNickname, aConv, aMode, aAdd) {
+  if (!aNickname.length) {
+    return false;
+  }
+
+  // Change the mode for each nick, as separator by spaces.
+  return splitInput(aNickname).every(aNick =>
+    simpleCommand(aConv, "MODE", [
+      aConv.name,
+      (aAdd ? "+" : "-") + aMode,
+      aNick,
+    ])
+  );
+}
+
+function actionCommand(aMsg, aConv) {
+  // Don't try to send an empty action.
+  if (!aMsg || !aMsg.trim().length) {
+    return false;
+  }
+
+  let conv = getConv(aConv);
+
+  conv.sendMsg(aMsg, true);
+
+  return true;
+}
+
+// This will open the conversation, and send and display the text.
+// aReturnedConv is optional and returns the resulting conversation.
+// aIsNotice is optional and sends a NOTICE instead of a PRIVMSG.
+function privateMessage(aConv, aMsg, aNickname, aReturnedConv, aIsNotice) {
+  if (!aMsg.length) {
+    return false;
+  }
+
+  let conv = getAccount(aConv).getConversation(aNickname);
+  conv.sendMsg(aMsg, false, aIsNotice);
+  if (aReturnedConv) {
+    aReturnedConv.value = conv;
+  }
+  return true;
+}
+
+// This will send a command to the server, if no parameters are given, it is
+// assumed that the command takes no parameters. aParams can be either a single
+// string or an array of parameters.
+function simpleCommand(aConv, aCommand, aParams) {
+  if (!aParams || !aParams.length) {
+    getAccount(aConv).sendMessage(aCommand);
+  } else {
+    getAccount(aConv).sendMessage(aCommand, aParams);
+  }
+  return true;
+}
+
+// Sends a CTCP message to aTarget using the CTCP command aCommand and aMsg as
+// a CTCP parameter.
+function ctcpCommand(aConv, aTarget, aCommand, aParams) {
+  return getAccount(aConv).sendCTCPMessage(aTarget, false, aCommand, aParams);
+}
+
+// Replace the command name in the help string so translators do not attempt to
+// translate it.
+export var commands = [
+  {
+    name: "action",
+    get helpString() {
+      return lazy._("command.action", "action");
+    },
+    run: actionCommand,
+  },
+  {
+    name: "ban",
+    get helpString() {
+      return lazy._("command.ban", "ban");
+    },
+    usageContext: Ci.imICommand.CMD_CONTEXT_CHAT,
+    run: (aMsg, aConv) => setMode(aMsg, aConv, "b", true),
+  },
+  {
+    name: "ctcp",
+    get helpString() {
+      return lazy._("command.ctcp", "ctcp");
+    },
+    run(aMsg, aConv) {
+      let separator = aMsg.indexOf(" ");
+      // Ensure we have two non-empty parameters.
+      if (separator < 1 || separator + 1 == aMsg.length) {
+        return false;
+      }
+
+      // The first word is used as the target, the rest is used as CTCP command
+      // and parameters.
+      ctcpCommand(aConv, aMsg.slice(0, separator), aMsg.slice(separator + 1));
+      return true;
+    },
+  },
+  {
+    name: "chanserv",
+    get helpString() {
+      return lazy._("command.chanserv", "chanserv");
+    },
+    run: (aMsg, aConv) => privateMessage(aConv, aMsg, "ChanServ"),
+  },
+  {
+    name: "deop",
+    get helpString() {
+      return lazy._("command.deop", "deop");
+    },
+    usageContext: Ci.imICommand.CMD_CONTEXT_CHAT,
+    run: (aMsg, aConv) => setMode(aMsg, aConv, "o", false),
+  },
+  {
+    name: "devoice",
+    get helpString() {
+      return lazy._("command.devoice", "devoice");
+    },
+    usageContext: Ci.imICommand.CMD_CONTEXT_CHAT,
+    run: (aMsg, aConv) => setMode(aMsg, aConv, "v", false),
+  },
+  {
+    name: "invite",
+    get helpString() {
+      return lazy._("command.invite2", "invite");
+    },
+    run(aMsg, aConv) {
+      let params = splitInput(aMsg);
+
+      // Try to find one, and only one, channel in the list of parameters.
+      let channel;
+      let account = getAccount(aConv);
+      // Find the first param that could be a channel name.
+      for (let i = 0; i < params.length; ++i) {
+        if (account.isMUCName(params[i])) {
+          // If channel is set, two channel names have been found.
+          if (channel) {
+            return false;
+          }
+
+          // Remove that parameter and store it.
+          channel = params.splice(i, 1)[0];
+        }
+      }
+
+      // If no parameters or only a channel are given.
+      if (!params[0].length) {
+        return false;
+      }
+
+      // Default to using the current conversation as the channel to invite to.
+      if (!channel) {
+        channel = aConv.name;
+      }
+
+      params.forEach(p => simpleCommand(aConv, "INVITE", [p, channel]));
+      return true;
+    },
+  },
+  {
+    name: "join",
+    get helpString() {
+      return lazy._("command.join", "join");
+    },
+    run(aMsg, aConv, aReturnedConv) {
+      let params = aMsg.trim().split(/,\s*/);
+      let account = getAccount(aConv);
+      let conv;
+      if (!params[0]) {
+        conv = getConv(aConv);
+        if (!conv.isChat || !conv.left) {
+          return false;
+        }
+        // Rejoin the current channel. If the channel was explicitly parted
+        // by the user, chatRoomFields will have been deleted.
+        // Otherwise, make use of it (e.g. if the user was kicked).
+        if (conv.chatRoomFields) {
+          account.joinChat(conv.chatRoomFields);
+          return true;
+        }
+        params = [conv.name];
+      }
+      params.forEach(function (joinParam) {
+        if (joinParam) {
+          let chatroomfields = account.getChatRoomDefaultFieldValues(joinParam);
+          conv = account.joinChat(chatroomfields);
+        }
+      });
+      if (aReturnedConv) {
+        aReturnedConv.value = conv;
+      }
+      return true;
+    },
+  },
+  {
+    name: "kick",
+    get helpString() {
+      return lazy._("command.kick", "kick");
+    },
+    usageContext: Ci.imICommand.CMD_CONTEXT_CHAT,
+    run: kickCommand,
+  },
+  {
+    name: "list",
+    get helpString() {
+      return lazy._("command.list", "list");
+    },
+    run(aMsg, aConv, aReturnedConv) {
+      let account = getAccount(aConv);
+      let serverName = account._currentServerName;
+      let serverConv = account.getConversation(serverName);
+      let pendingChats = [];
+      account.requestRoomInfo(
+        {
+          onRoomInfoAvailable(aRooms) {
+            if (!pendingChats.length) {
+              (async function () {
+                // pendingChats has no rooms added yet, so ensure we wait a tick.
+                let t = 0;
+                const kMaxBlockTime = 10; // Unblock every 10ms.
+                do {
+                  if (Date.now() > t) {
+                    await new Promise(resolve =>
+                      Services.tm.dispatchToMainThread(resolve)
+                    );
+                    t = Date.now() + kMaxBlockTime;
+                  }
+                  let name = pendingChats.pop();
+                  let roomInfo = account.getRoomInfo(name);
+                  serverConv.writeMessage(
+                    serverName,
+                    name +
+                      " (" +
+                      roomInfo.participantCount +
+                      ") " +
+                      roomInfo.topic,
+                    {
+                      incoming: true,
+                      noLog: true,
+                    }
+                  );
+                } while (pendingChats.length);
+              })();
+            }
+            pendingChats = pendingChats.concat(aRooms);
+          },
+        },
+        true
+      );
+      if (aReturnedConv) {
+        aReturnedConv.value = serverConv;
+      }
+      return true;
+    },
+  },
+  {
+    name: "me",
+    get helpString() {
+      return lazy._("command.action", "me");
+    },
+    run: actionCommand,
+  },
+  {
+    name: "memoserv",
+    get helpString() {
+      return lazy._("command.memoserv", "memoserv");
+    },
+    run: (aMsg, aConv) => privateMessage(aConv, aMsg, "MemoServ"),
+  },
+  {
+    name: "mode",
+    get helpString() {
+      return (
+        lazy._("command.modeUser2", "mode") +
+        "\n" +
+        lazy._("command.modeChannel2", "mode")
+      );
+    },
+    run(aMsg, aConv) {
+      function isMode(aString) {
+        return "+-".includes(aString[0]);
+      }
+      let params = splitInput(aMsg);
+      let channel = aConv.name;
+      // Add the channel as parameter when the target is not specified. i.e
+      // 1. message is empty.
+      // 2. the first parameter is a mode.
+      if (!aMsg) {
+        params = [channel];
+      } else if (isMode(params[0])) {
+        params.unshift(channel);
+      }
+
+      // Ensure mode string to be the second argument.
+      if (params.length >= 2 && !isMode(params[1])) {
+        return false;
+      }
+
+      return simpleCommand(aConv, "MODE", params);
+    },
+  },
+  {
+    name: "msg",
+    get helpString() {
+      return lazy._("command.msg", "msg");
+    },
+    run: messageCommand,
+  },
+  {
+    name: "nick",
+    get helpString() {
+      return lazy._("command.nick", "nick");
+    },
+    run(aMsg, aConv) {
+      let newNick = aMsg.trim();
+      // eslint-disable-next-line mozilla/use-includes-instead-of-indexOf
+      if (newNick.indexOf(/\s+/) != -1) {
+        return false;
+      }
+
+      let account = getAccount(aConv);
+      // The user wants to change their nick, so overwrite the account
+      // nickname for this session.
+      account._requestedNickname = newNick;
+      account.changeNick(newNick);
+
+      return true;
+    },
+  },
+  {
+    name: "nickserv",
+    get helpString() {
+      return lazy._("command.nickserv", "nickserv");
+    },
+    run: (aMsg, aConv) => privateMessage(aConv, aMsg, "NickServ"),
+  },
+  {
+    name: "notice",
+    get helpString() {
+      return lazy._("command.notice", "notice");
+    },
+    run: (aMsg, aConv, aReturnedConv) =>
+      messageCommand(aMsg, aConv, aReturnedConv, true),
+  },
+  {
+    name: "op",
+    get helpString() {
+      return lazy._("command.op", "op");
+    },
+    usageContext: Ci.imICommand.CMD_CONTEXT_CHAT,
+    run: (aMsg, aConv) => setMode(aMsg, aConv, "o", true),
+  },
+  {
+    name: "operserv",
+    get helpString() {
+      return lazy._("command.operserv", "operserv");
+    },
+    run: (aMsg, aConv) => privateMessage(aConv, aMsg, "OperServ"),
+  },
+  {
+    name: "part",
+    get helpString() {
+      return lazy._("command.part", "part");
+    },
+    usageContext: Ci.imICommand.CMD_CONTEXT_CHAT,
+    run(aMsg, aConv) {
+      getConv(aConv).part(aMsg);
+      return true;
+    },
+  },
+  {
+    name: "ping",
+    get helpString() {
+      return lazy._("command.ping", "ping");
+    },
+    run(aMsg, aConv) {
+      // Send a ping to the entered nick using the current time (in
+      // milliseconds) as the param. If no nick is entered, ping the
+      // server.
+      if (aMsg && aMsg.trim().length) {
+        ctcpCommand(aConv, aMsg, "PING", Date.now());
+      } else {
+        getAccount(aConv).sendMessage("PING", Date.now());
+      }
+
+      return true;
+    },
+  },
+  {
+    name: "query",
+    get helpString() {
+      return lazy._("command.msg", "query");
+    },
+    run: messageCommand,
+  },
+  {
+    name: "quit",
+    get helpString() {
+      return lazy._("command.quit", "quit");
+    },
+    run(aMsg, aConv) {
+      let account = getAccount(aConv);
+      account.disconnect(aMsg);
+      // While prpls shouldn't usually touch imAccount, this disconnection
+      // is an action the user requested via the UI. Without this call,
+      // the imAccount would immediately reconnect the account.
+      account.imAccount.disconnect();
+      return true;
+    },
+  },
+  {
+    name: "quote",
+    get helpString() {
+      return lazy._("command.quote", "quote");
+    },
+    run(aMsg, aConv) {
+      if (!aMsg.length) {
+        return false;
+      }
+
+      getAccount(aConv).sendRawMessage(aMsg);
+      return true;
+    },
+  },
+  {
+    name: "remove",
+    get helpString() {
+      return lazy._("command.kick", "remove");
+    },
+    usageContext: Ci.imICommand.CMD_CONTEXT_CHAT,
+    run: kickCommand,
+  },
+  {
+    name: "time",
+    get helpString() {
+      return lazy._("command.time", "time");
+    },
+    run(aMsg, aConv) {
+      // Send a time command to the entered nick using the current time (in
+      // milliseconds) as the param. If no nick is entered, get the current
+      // server time.
+      if (aMsg && aMsg.trim().length) {
+        ctcpCommand(aConv, aMsg, "TIME");
+      } else {
+        getAccount(aConv).sendMessage("TIME");
+      }
+
+      return true;
+    },
+  },
+  {
+    name: "topic",
+    get helpString() {
+      return lazy._("command.topic", "topic");
+    },
+    usageContext: Ci.imICommand.CMD_CONTEXT_CHAT,
+    run(aMsg, aConv) {
+      aConv.topic = aMsg;
+      return true;
+    },
+  },
+  {
+    name: "umode",
+    get helpString() {
+      return lazy._("command.umode", "umode");
+    },
+    run(aMsg, aConv) {
+      let params = aMsg ? splitInput(aMsg) : [];
+      params.unshift(getAccount(aConv)._nickname);
+      return simpleCommand(aConv, "MODE", params);
+    },
+  },
+  {
+    name: "version",
+    get helpString() {
+      return lazy._("command.version", "version");
+    },
+    run(aMsg, aConv) {
+      if (!aMsg || !aMsg.trim().length) {
+        return false;
+      }
+      ctcpCommand(aConv, aMsg, "VERSION");
+      return true;
+    },
+  },
+  {
+    name: "voice",
+    get helpString() {
+      return lazy._("command.voice", "voice");
+    },
+    usageContext: Ci.imICommand.CMD_CONTEXT_CHAT,
+    run: (aMsg, aConv) => setMode(aMsg, aConv, "v", true),
+  },
+  {
+    name: "whois",
+    get helpString() {
+      return lazy._("command.whois2", "whois");
+    },
+    run(aMsg, aConv) {
+      // Note that this will automatically run whowas if the nick is offline.
+      aMsg = aMsg.trim();
+      // If multiple parameters are given, this is an error.
+      if (aMsg.includes(" ")) {
+        return false;
+      }
+      // If the user does not provide a nick, but is in a private conversation,
+      // assume the user is trying to whois the person they are talking to.
+      if (!aMsg) {
+        if (aConv.isChat) {
+          return false;
+        }
+        aMsg = aConv.name;
+      }
+      getConv(aConv).requestCurrentWhois(aMsg);
+      return true;
+    },
+  },
+];
diff --git a/comm/chat/protocols/irc/ircDCC.sys.mjs b/comm/chat/protocols/irc/ircDCC.sys.mjs
new file mode 100644
index 0000000000..afd88f52be
--- /dev/null
+++ b/comm/chat/protocols/irc/ircDCC.sys.mjs
@@ -0,0 +1,66 @@
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
+
+/*
+ * This contains an implementation of the Direct Client-to-Client (DCC)
+ * protocol.
+ *   A description of the DCC protocol
+ *     http://www.irchelp.org/irchelp/rfc/dccspec.html
+ */
+
+import { ircHandlerPriorities } from "resource:///modules/ircHandlerPriorities.sys.mjs";
+
+// Parse a CTCP message into a DCC message. A DCC message is a CTCP message of
+// the form:
+//   DCC <type> <argument> <address> <port> [<size>]
+function DCCMessage(aMessage, aAccount) {
+  let message = aMessage;
+  let params = message.ctcp.param.split(" ");
+  if (params.length < 4) {
+    aAccount.ERROR("Not enough DCC parameters:\n" + JSON.stringify(aMessage));
+    return null;
+  }
+
+  try {
+    // Address, port and size should be treated as unsigned long, unsigned short
+    // and unsigned long, respectively. The protocol is designed to handle
+    // further arguments, if necessary.
+    message.ctcp.dcc = {
+      type: params[0],
+      argument: params[1],
+      address: Number(params[2]),
+      port: Number(params[3]),
+      size: params.length == 5 ? Number(params[4]) : null,
+      furtherArguments: params.length > 5 ? params.slice(5) : [],
+    };
+  } catch (e) {
+    aAccount.ERROR(
+      "Error parsing DCC parameters:\n" + JSON.stringify(aMessage)
+    );
+    return null;
+  }
+
+  return message;
+}
+
+// This is the DCC handler for CTCP, it will call each DCC handler.
+export var ctcpDCC = {
+  name: "DCC",
+  // Slightly above default CTCP priority.
+  priority: ircHandlerPriorities.HIGH_PRIORITY + 10,
+  isEnabled: () => true,
+
+  commands: {
+    // Handle a DCC message by parsing the message and executing any handlers.
+    DCC(message, ircHandlers) {
+      // If there are no DCC handlers, then don't parse the DCC message.
+      if (!ircHandlers.hasDCCHandlers) {
+        return false;
+      }
+
+      // Parse the message and attempt to handle it.
+      return ircHandlers.handleDCCMessage(this, DCCMessage(message, this));
+    },
+  },
+};
diff --git a/comm/chat/protocols/irc/ircEchoMessage.sys.mjs b/comm/chat/protocols/irc/ircEchoMessage.sys.mjs
new file mode 100644
index 0000000000..24a27be902
--- /dev/null
+++ b/comm/chat/protocols/irc/ircEchoMessage.sys.mjs
@@ -0,0 +1,41 @@
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
+
+/*
+ * This implements the echo-message capability for IRC.
+ *   https://ircv3.net/specs/extensions/echo-message-3.2
+ *
+ * When enabled, displaying of a sent messages is disabled (until it is received
+ * by the server and sent back to the sender). This helps to ensure the ordering
+ * of messages is consistent for all participants in a channel and also helps
+ * signify whether a message was properly sent to a channel during disconnect.
+ */
+
+import { ircHandlerPriorities } from "resource:///modules/ircHandlerPriorities.sys.mjs";
+
+export var capEchoMessage = {
+  name: "echo-message CAP",
+  priority: ircHandlerPriorities.DEFAULT_PRIORITY,
+  isEnabled: () => true,
+
+  commands: {
+    "echo-message": function (aMessage) {
+      if (
+        aMessage.cap.subcommand === "LS" ||
+        aMessage.cap.subcommand === "NEW"
+      ) {
+        this.addCAP("echo-message");
+        this.sendMessage("CAP", ["REQ", "echo-message"]);
+      } else if (
+        aMessage.cap.subcommand === "ACK" ||
+        aMessage.cap.subcommand === "NAK"
+      ) {
+        this.removeCAP("echo-message");
+      } else {
+        return false;
+      }
+      return true;
+    },
+  },
+};
diff --git a/comm/chat/protocols/irc/ircHandlerPriorities.sys.mjs b/comm/chat/protocols/irc/ircHandlerPriorities.sys.mjs
new file mode 100644
index 0000000000..68d48d51b8
--- /dev/null
+++ b/comm/chat/protocols/irc/ircHandlerPriorities.sys.mjs
@@ -0,0 +1,16 @@
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
+
+export const ircHandlerPriorities = {
+  // Some constant priorities.
+  get LOW_PRIORITY() {
+    return -100;
+  },
+  get DEFAULT_PRIORITY() {
+    return 0;
+  },
+  get HIGH_PRIORITY() {
+    return 100;
+  },
+};
diff --git a/comm/chat/protocols/irc/ircHandlers.sys.mjs b/comm/chat/protocols/irc/ircHandlers.sys.mjs
new file mode 100644
index 0000000000..c461d158db
--- /dev/null
+++ b/comm/chat/protocols/irc/ircHandlers.sys.mjs
@@ -0,0 +1,306 @@
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
+
+import { ircBase } from "resource:///modules/ircBase.sys.mjs";
+import {
+  ircISUPPORT,
+  isupportBase,
+} from "resource:///modules/ircISUPPORT.sys.mjs";
+import { ircCAP, capNotify } from "resource:///modules/ircCAP.sys.mjs";
+import { ircCTCP, ctcpBase } from "resource:///modules/ircCTCP.sys.mjs";
+import {
+  ircServices,
+  servicesBase,
+} from "resource:///modules/ircServices.sys.mjs";
+import { ctcpDCC } from "resource:///modules/ircDCC.sys.mjs";
+import { capEchoMessage } from "resource:///modules/ircEchoMessage.sys.mjs";
+import {
+  isupportNAMESX,
+  capMultiPrefix,
+} from "resource:///modules/ircMultiPrefix.sys.mjs";
+import { ircNonStandard } from "resource:///modules/ircNonStandard.sys.mjs";
+import {
+  ircWATCH,
+  isupportWATCH,
+  ircMONITOR,
+  isupportMONITOR,
+} from "resource:///modules/ircWatchMonitor.sys.mjs";
+import { ircSASL, capSASL } from "resource:///modules/ircSASL.sys.mjs";
+import {
+  capServerTime,
+  tagServerTime,
+} from "resource:///modules/ircServerTime.sys.mjs";
+
+export var ircHandlers = {
+  /*
+   * Object to hold the IRC handlers, each handler is an object that implements:
+   *   name        The display name of the handler.
+   *   priority    The priority of the handler (0 is default, positive is
+   *               higher priority)
+   *   isEnabled   A function where 'this' is bound to the account object. This
+   *               should reflect whether this handler should be used for this
+   *               account.
+   *   commands    An object of commands, each command is a function which
+   *               accepts a message object and has 'this' bound to the account
+   *               object. It should return whether the message was successfully
+   *               handler or not.
+   */
+  _ircHandlers: [
+    // High priority
+    ircCTCP,
+    ircServices,
+    // Default priority + 10
+    ircCAP,
+    ircISUPPORT,
+    ircWATCH,
+    ircMONITOR,
+    // Default priority + 1
+    ircNonStandard,
+    // Default priority
+    ircSASL,
+    ircBase,
+  ],
+  // Object to hold the ISUPPORT handlers, expects the same fields as
+  // _ircHandlers.
+  _isupportHandlers: [
+    // Default priority + 10
+    isupportNAMESX,
+    isupportWATCH,
+    isupportMONITOR,
+    // Default priority
+    isupportBase,
+  ],
+  // Object to hold the Client Capabilities handlers, expects the same fields as
+  // _ircHandlers.
+  _capHandlers: [
+    // High priority
+    capMultiPrefix,
+    // Default priority
+    capNotify,
+    capEchoMessage,
+    capSASL,
+    capServerTime,
+  ],
+  // Object to hold the CTCP handlers, expects the same fields as _ircHandlers.
+  _ctcpHandlers: [
+    // High priority + 10
+    ctcpDCC,
+    // Default priority
+    ctcpBase,
+  ],
+  // Object to hold the DCC handlers, expects the same fields as _ircHandlers.
+  _dccHandlers: [],
+  // Object to hold the Services handlers, expects the same fields as
+  // _ircHandlers.
+  _servicesHandlers: [servicesBase],
+  // Object to hold irc message tag handlers, expects the same fields as
+  // _ircHandlers.
+  _tagHandlers: [tagServerTime],
+
+  _registerHandler(aArray, aHandler) {
+    // Protect ourselves from adding broken handlers.
+    if (!("commands" in aHandler)) {
+      console.error(
+        new Error(
+          'IRC handlers must have a "commands" property: ' + aHandler.name
+        )
+      );
+      return false;
+    }
+    if (!("isEnabled" in aHandler)) {
+      console.error(
+        new Error(
+          'IRC handlers must have a "isEnabled" property: ' + aHandler.name
+        )
+      );
+      return false;
+    }
+
+    aArray.push(aHandler);
+    aArray.sort((a, b) => b.priority - a.priority);
+    return true;
+  },
+
+  _unregisterHandler(aArray, aHandler) {
+    return aArray.filter(h => h.name != aHandler.name);
+  },
+
+  registerHandler(aHandler) {
+    return this._registerHandler(this._ircHandlers, aHandler);
+  },
+  unregisterHandler(aHandler) {
+    this._ircHandlers = this._unregisterHandler(this._ircHandlers, aHandler);
+  },
+
+  registerISUPPORTHandler(aHandler) {
+    return this._registerHandler(this._isupportHandlers, aHandler);
+  },
+  unregisterISUPPORTHandler(aHandler) {
+    this._isupportHandlers = this._unregisterHandler(
+      this._isupportHandlers,
+      aHandler
+    );
+  },
+
+  registerCAPHandler(aHandler) {
+    return this._registerHandler(this._capHandlers, aHandler);
+  },
+  unregisterCAPHandler(aHandler) {
+    this._capHandlers = this._unregisterHandler(this._capHandlers, aHandler);
+  },
+
+  registerCTCPHandler(aHandler) {
+    return this._registerHandler(this._ctcpHandlers, aHandler);
+  },
+  unregisterCTCPHandler(aHandler) {
+    this._ctcpHandlers = this._unregisterHandler(this._ctcpHandlers, aHandler);
+  },
+
+  registerDCCHandler(aHandler) {
+    return this._registerHandler(this._dccHandlers, aHandler);
+  },
+  unregisterDCCHandler(aHandler) {
+    this._dccHandlers = this._unregisterHandler(this._dccHandlers, aHandler);
+  },
+
+  registerServicesHandler(aHandler) {
+    return this._registerHandler(this._servicesHandlers, aHandler);
+  },
+  unregisterServicesHandler(aHandler) {
+    this._servicesHandlers = this._unregisterHandler(
+      this._servicesHandlers,
+      aHandler
+    );
+  },
+
+  registerTagHandler(aHandler) {
+    return this._registerHandler(this._tagHandlers, aHandler);
+  },
+  unregisterTagHandler(aHandler) {
+    this._tagHandlers = this._unregisterHandler(this._tagHandlers, aHandler);
+  },
+
+  // Handle a message based on a set of handlers.
+  _handleMessage(aHandlers, aAccount, aMessage, aCommand) {
+    // Loop over each handler and run the command until one handles the message.
+    for (let handler of aHandlers) {
+      try {
+        // Attempt to execute the command, by checking if the handler has the
+        // command.
+        // Parse the command with the JavaScript account object as "this".
+        if (
+          handler.isEnabled.call(aAccount) &&
+          aCommand in handler.commands &&
+          handler.commands[aCommand].call(aAccount, aMessage, ircHandlers)
+        ) {
+          return true;
+        }
+      } catch (e) {
+        // We want to catch an error here because one of our handlers are
+        // broken, if we don't catch the error, the whole IRC plug-in will die.
+        aAccount.ERROR(
+          "Error running command " +
+            aCommand +
+            " with handler " +
+            handler.name +
+            ":\n" +
+            JSON.stringify(aMessage),
+          e
+        );
+      }
+    }
+
+    return false;
+  },
+
+  handleMessage(aAccount, aMessage) {
+    return this._handleMessage(
+      this._ircHandlers,
+      aAccount,
+      aMessage,
+      aMessage.command.toUpperCase()
+    );
+  },
+
+  handleISUPPORTMessage(aAccount, aMessage) {
+    return this._handleMessage(
+      this._isupportHandlers,
+      aAccount,
+      aMessage,
+      aMessage.isupport.parameter
+    );
+  },
+
+  handleCAPMessage(aAccount, aMessage) {
+    return this._handleMessage(
+      this._capHandlers,
+      aAccount,
+      aMessage,
+      aMessage.cap.parameter
+    );
+  },
+
+  // aMessage is a CTCP Message, which inherits from an IRC Message.
+  handleCTCPMessage(aAccount, aMessage) {
+    return this._handleMessage(
+      this._ctcpHandlers,
+      aAccount,
+      aMessage,
+      aMessage.ctcp.command
+    );
+  },
+
+  // aMessage is a DCC Message, which inherits from a CTCP Message.
+  handleDCCMessage(aAccount, aMessage) {
+    return this._handleMessage(
+      this._dccHandlers,
+      aAccount,
+      aMessage,
+      aMessage.ctcp.dcc.type
+    );
+  },
+
+  // aMessage is a Services Message.
+  handleServicesMessage(aAccount, aMessage) {
+    return this._handleMessage(
+      this._servicesHandlers,
+      aAccount,
+      aMessage,
+      aMessage.serviceName
+    );
+  },
+
+  // aMessage is a Tag Message.
+  handleTag(aAccount, aMessage) {
+    return this._handleMessage(
+      this._tagHandlers,
+      aAccount,
+      aMessage,
+      aMessage.tagName
+    );
+  },
+
+  // Checking if handlers exist.
+  get hasHandlers() {
+    return this._ircHandlers.length > 0;
+  },
+  get hasISUPPORTHandlers() {
+    return this._isupportHandlers.length > 0;
+  },
+  get hasCAPHandlers() {
+    return this._capHandlers.length > 0;
+  },
+  get hasCTCPHandlers() {
+    return this._ctcpHandlers.length > 0;
+  },
+  get hasDCCHandlers() {
+    return this._dccHandlers.length > 0;
+  },
+  get hasServicesHandlers() {
+    return this._servicesHandlers.length > 0;
+  },
+  get hasTagHandlers() {
+    return this._tagHandlers.length > 0;
+  },
+};
diff --git a/comm/chat/protocols/irc/ircISUPPORT.sys.mjs b/comm/chat/protocols/irc/ircISUPPORT.sys.mjs
new file mode 100644
index 0000000000..9d2ce29afb
--- /dev/null
+++ b/comm/chat/protocols/irc/ircISUPPORT.sys.mjs
@@ -0,0 +1,246 @@
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
+
+/*
+ * This implements the ISUPPORT parameters for the 005 numeric to allow a server
+ * to notify a client of what capabilities it supports.
+ *   The 005 numeric
+ *     http://www.irc.org/tech_docs/005.html
+ *   RFC Drafts: IRC RPL_ISUPPORT Numeric Definition
+ *     https://tools.ietf.org/html/draft-brocklesby-irc-isupport-03
+ *     https://tools.ietf.org/html/draft-hardy-irc-isupport-00
+ */
+
+import { ircHandlerPriorities } from "resource:///modules/ircHandlerPriorities.sys.mjs";
+
+/*
+ * Parses an ircMessage into an ISUPPORT message for each token of the form:
+ *   <parameter>=<value> or -<value>
+ * The isupport field is added to the message and it has the following fields:
+ *   parameter  What is being configured by this ISUPPORT token.
+ *   useDefault Whether this parameter should be reset to the default value, as
+ *              defined by the RFC.
+ *   value      The new value for the parameter.
+ */
+function isupportMessage(aMessage) {
+  // Separate the ISUPPORT parameters.
+  let tokens = aMessage.params.slice(1, -1);
+
+  let message = aMessage;
+  message.isupport = {};
+
+  return tokens.map(function (aToken) {
+    let newMessage = JSON.parse(JSON.stringify(message));
+    newMessage.isupport.useDefault = aToken[0] == "-";
+    let token = (
+      newMessage.isupport.useDefault ? aToken.slice(1) : aToken
+    ).split("=");
+    newMessage.isupport.parameter = token[0];
+    newMessage.isupport.value = token[1] || null;
+    return newMessage;
+  });
+}
+
+export var ircISUPPORT = {
+  name: "ISUPPORT",
+  // Slightly above default RFC 2812 priority.
+  priority: ircHandlerPriorities.DEFAULT_PRIORITY + 10,
+  isEnabled: () => true,
+
+  commands: {
+    // RPL_ISUPPORT
+    // [-]<parameter>[=<value>] :are supported by this server
+    "005": function (message, ircHandlers) {
+      let messages = isupportMessage(message);
+
+      messages = messages.filter(
+        aMessage => !ircHandlers.handleISUPPORTMessage(this, aMessage)
+      );
+      if (messages.length) {
+        // Display the list of unhandled ISUPPORT messages.
+        let unhandledMessages = messages
+          .map(aMsg => aMsg.isupport.parameter)
+          .join(" ");
+        this.LOG(
+          "Unhandled ISUPPORT messages: " +
+            unhandledMessages +
+            "\nRaw message: " +
+            message.rawMessage
+        );
+      }
+
+      return true;
+    },
+  },
+};
+
+function setSimpleNumber(aAccount, aField, aMessage, aDefaultValue) {
+  let value = aMessage.isupport.value ? Number(aMessage.isupport.value) : null;
+  aAccount[aField] = value && !isNaN(value) ? value : aDefaultValue;
+  return true;
+}
+
+// Generates an expression to search for the ASCII range of a-b.
+function generateNormalize(a, b) {
+  return new RegExp(
+    "[\\x" + a.toString(16) + "-\\x" + b.toString(16) + "]",
+    "g"
+  );
+}
+
+export var isupportBase = {
+  name: "ISUPPORT",
+  priority: ircHandlerPriorities.DEFAULT_PRIORITY,
+  isEnabled: () => true,
+
+  commands: {
+    CASEMAPPING(aMessage) {
+      // CASEMAPPING=<mapping>
+      // Allows the server to specify which method it uses to compare equality
+      // of case-insensitive strings.
+
+      // By default, use rfc1459 type case mapping.
+      let value = aMessage.isupport.useDefault
+        ? "rfc1493"
+        : aMessage.isupport.value;
+
+      // Set the normalize function of the account to use the proper case
+      // mapping.
+      if (value == "ascii") {
+        // The ASCII characters 97 to 122 (decimal) are the lower-case
+        // characters of ASCII 65 to 90 (decimal).
+        this.normalizeExpression = generateNormalize(65, 90);
+      } else if (value == "rfc1493") {
+        // The ASCII characters 97 to 126 (decimal) are the lower-case
+        // characters of ASCII 65 to 94 (decimal).
+        this.normalizeExpression = generateNormalize(65, 94);
+      } else if (value == "strict-rfc1459") {
+        // The ASCII characters 97 to 125 (decimal) are the lower-case
+        // characters of ASCII 65 to 93 (decimal).
+        this.normalizeExpression = generateNormalize(65, 93);
+      }
+      return true;
+    },
+    CHANLIMIT(aMessage) {
+      // CHANLIMIT=<prefix>:<number>[,<prefix>:<number>]*
+      // Note that each <prefix> can actually contain multiple prefixes, this
+      // means the sum of those prefixes is given.
+      this.maxChannels = {};
+
+      let pairs = aMessage.isupport.value.split(",");
+      for (let pair of pairs) {
+        let [prefix, num] = pair.split(":");
+        this.maxChannels[prefix] = num;
+      }
+      return true;
+    },
+    CHANMODES: aMessage => false,
+    CHANNELLEN(aMessage) {
+      // CHANNELLEN=<number>
+      // Default is from RFC 1493.
+      return setSimpleNumber(this, "maxChannelLength", aMessage, 200);
+    },
+    CHANTYPES(aMessage) {
+      // CHANTYPES=[<channel prefix>]*
+      let value = aMessage.isupport.useDefault ? "#&" : aMessage.isupport.value;
+      this.channelPrefixes = value.split("");
+      return true;
+    },
+    EXCEPTS: aMessage => false,
+    IDCHAN: aMessage => false,
+    INVEX: aMessage => false,
+    KICKLEN(aMessage) {
+      // KICKLEN=<number>
+      // Default value is Infinity.
+      return setSimpleNumber(this, "maxKickLength", aMessage, Infinity);
+    },
+    MAXLIST: aMessage => false,
+    MODES: aMessage => false,
+    NETWORK: aMessage => false,
+    NICKLEN(aMessage) {
+      // NICKLEN=<number>
+      // Default value is from RFC 1493.
+      return setSimpleNumber(this, "maxNicknameLength", aMessage, 9);
+    },
+    PREFIX(aMessage) {
+      // PREFIX=[(<mode character>*)<prefix>*]
+      let value = aMessage.isupport.useDefault
+        ? "(ov)@+"
+        : aMessage.isupport.value;
+
+      this.userPrefixToModeMap = {};
+      // A null value specifier indicates that no prefixes are supported.
+      if (!value.length) {
+        return true;
+      }
+
+      let matches = /\(([a-z]*)\)(.*)/i.exec(value);
+      if (!matches) {
+        // The pattern doesn't match.
+        this.WARN("Invalid PREFIX value: " + value);
+        return false;
+      }
+      if (matches[1].length != matches[2].length) {
+        this.WARN(
+          "Invalid PREFIX value, does not provide one-to-one mapping:" + value
+        );
+        return false;
+      }
+
+      for (let i = 0; i < matches[2].length; i++) {
+        this.userPrefixToModeMap[matches[2][i]] = matches[1][i];
+      }
+      return true;
+    },
+    // SAFELIST allows the client to request the server buffer LIST responses to
+    // avoid flooding the client. This is not an issue for us, so just ignore
+    // it.
+    SAFELIST: aMessage => true,
+    // SECURELIST tells us that the server won't send LIST data directly after
+    // connection. Unfortunately, the exact time the client has to wait is
+    // configurable, so we can't do anything with this information.
+    SECURELIST: aMessage => true,
+    STATUSMSG: aMessage => false,
+    STD(aMessage) {
+      // This was never updated as the RFC was never formalized.
+      if (aMessage.isupport.value != "rfcnnnn") {
+        this.WARN("Unknown ISUPPORT numeric form: " + aMessage.isupport.value);
+      }
+      return true;
+    },
+    TARGMAX(aMessage) {
+      // TARGMAX=<command>:<max targets>[,<command>:<max targets>]*
+      if (aMessage.isupport.useDefault) {
+        this.maxTargets = 1;
+        return true;
+      }
+
+      this.maxTargets = {};
+      let commands = aMessage.isupport.value.split(",");
+      for (let i = 0; i < commands.length; i++) {
+        let [command, limitStr] = commands[i].split("=");
+        let limit = limitStr ? Number(limit) : Infinity;
+        if (isNaN(limit)) {
+          this.WARN("Invalid maximum number of targets: " + limitStr);
+          continue;
+        }
+        this.maxTargets[command] = limit;
+      }
+      return true;
+    },
+    TOPICLEN(aMessage) {
+      // TOPICLEN=<number>
+      // Default value is Infinity.
+      return setSimpleNumber(this, "maxTopicLength", aMessage, Infinity);
+    },
+
+    // The following are considered "obsolete" by the RFC, but are still in use.
+    CHARSET: aMessage => false,
+    MAXBANS: aMessage => false,
+    MAXCHANNELS: aMessage => false,
+    MAXTARGETS(aMessage) {
+      return setSimpleNumber(this, "maxTargets", aMessage, 1);
+    },
+  },
+};
diff --git a/comm/chat/protocols/irc/ircMultiPrefix.sys.mjs b/comm/chat/protocols/irc/ircMultiPrefix.sys.mjs
new file mode 100644
index 0000000000..abf9727981
--- /dev/null
+++ b/comm/chat/protocols/irc/ircMultiPrefix.sys.mjs
@@ -0,0 +1,60 @@
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
+
+/*
+ * This contains an implementation of the multi-prefix IRC extension. This fixes
+ * a protocol level bug where the following can happen:
+ *   foo MODE +h
+ *   foo MODE +o
+ *   bar JOINs the channel (and receives @foo)
+ *   foo MODE -o
+ * foo knows that it has mode +h, but bar does not know foo has +h set.
+ *
+ *   https://docs.inspircd.org/2/modules/namesx/
+ *   https://ircv3.net/specs/extensions/multi-prefix-3.1
+ */
+
+import { ircHandlerPriorities } from "resource:///modules/ircHandlerPriorities.sys.mjs";
+
+export var isupportNAMESX = {
+  name: "ISUPPORT NAMESX",
+  // Slightly above default ISUPPORT priority.
+  priority: ircHandlerPriorities.DEFAULT_PRIORITY + 10,
+  isEnabled: () => true,
+
+  commands: {
+    NAMESX(aMessage) {
+      this.sendMessage("PROTOCTL", "NAMESX");
+      return true;
+    },
+  },
+};
+
+export var capMultiPrefix = {
+  name: "CAP multi-prefix",
+  // Slightly above default ISUPPORT priority.
+  priority: ircHandlerPriorities.HIGH_PRIORITY,
+  isEnabled: () => true,
+
+  commands: {
+    "multi-prefix": function (aMessage) {
+      // Request to use multi-prefix if it is supported.
+      if (
+        aMessage.cap.subcommand === "LS" ||
+        aMessage.cap.subcommand === "NEW"
+      ) {
+        this.addCAP("multi-prefix");
+        this.sendMessage("CAP", ["REQ", "multi-prefix"]);
+      } else if (
+        aMessage.cap.subcommand === "ACK" ||
+        aMessage.cap.subcommand === "NAK"
+      ) {
+        this.removeCAP("multi-prefix");
+      } else {
+        return false;
+      }
+      return true;
+    },
+  },
+};
diff --git a/comm/chat/protocols/irc/ircNonStandard.sys.mjs b/comm/chat/protocols/irc/ircNonStandard.sys.mjs
new file mode 100644
index 0000000000..aeb373feb9
--- /dev/null
+++ b/comm/chat/protocols/irc/ircNonStandard.sys.mjs
@@ -0,0 +1,262 @@
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
+
+/*
+ * There are a variety of non-standard extensions to IRC that are implemented by
+ * different servers. This implementation is based on a combination of
+ * documentation and reverse engineering. Each handler must include a comment
+ * listing the known servers that support this extension.
+ *
+ * Resources for these commands include:
+ *  https://github.com/atheme/charybdis/blob/master/include/numeric.h
+ *  https://github.com/unrealircd/unrealircd/blob/unreal42/include/numeric.h
+ */
+import { XPCOMUtils } from "resource://gre/modules/XPCOMUtils.sys.mjs";
+import { l10nHelper } from "resource:///modules/imXPCOMUtils.sys.mjs";
+import { ircHandlerPriorities } from "resource:///modules/ircHandlerPriorities.sys.mjs";
+import {
+  conversationErrorMessage,
+  kListRefreshInterval,
+} from "resource:///modules/ircUtils.sys.mjs";
+
+const lazy = {};
+XPCOMUtils.defineLazyGetter(lazy, "_", () =>
+  l10nHelper("chrome://chat/locale/irc.properties")
+);
+
+export var ircNonStandard = {
+  name: "Non-Standard IRC Extensions",
+  priority: ircHandlerPriorities.DEFAULT_PRIORITY + 1,
+  isEnabled: () => true,
+
+  commands: {
+    NOTICE(aMessage) {
+      // NOTICE <msgtarget> <text>
+
+      if (
+        aMessage.params[1].startsWith("*** You cannot list within the first")
+      ) {
+        // SECURELIST: "You cannot list within the first N seconds of connecting.
+        // Please try again later." This NOTICE will be followed by a 321/323
+        // pair, but no list data.
+        // We fake the last LIST time so that we will retry LIST the next time
+        // the user requires it after the interval specified.
+        const kMinute = 60000;
+        let waitTime = aMessage.params[1].split(" ")[7] * 1000 || kMinute;
+        this._lastListTime = Date.now() + waitTime - kListRefreshInterval;
+        return true;
+      }
+
+      // If the user is connected, fallback to normal processing, everything
+      // past this points deals with NOTICE messages that occur before 001 is
+      // received.
+      if (this.connected) {
+        return false;
+      }
+
+      let target = aMessage.params[0].toLowerCase();
+
+      // If we receive a ZNC error message requesting a password, the
+      // serverPassword preference was not set by the user. Attempt to log into
+      // ZNC using the account password.
+      if (
+        target == "auth" &&
+        aMessage.params[1].startsWith("*** You need to send your password.")
+      ) {
+        if (this.imAccount.password) {
+          // Send the password now, if it is available.
+          this.shouldAuthenticate = false;
+          this.sendMessage(
+            "PASS",
+            this.imAccount.password,
+            "PASS <password not logged>"
+          );
+        } else {
+          // Otherwise, put the account in an error state.
+          this.gotDisconnected(
+            Ci.prplIAccount.ERROR_AUTHENTICATION_IMPOSSIBLE,
+            lazy._("connection.error.passwordRequired")
+          );
+        }
+
+        // All done for ZNC.
+        return true;
+      }
+
+      // Some servers, e.g. irc.umich.edu, use NOTICE during connection
+      // negotiation to give directions to users, these MUST be shown to the
+      // user. If the message starts with ***, we assume it is probably an AUTH
+      // message, which falls through to normal NOTICE processing.
+      // Note that if the user's nick is auth this COULD be a notice directed at
+      // them. For reference: moznet sends Auth (previously sent AUTH), freenode
+      // sends *.
+      let isAuth = target == "auth" && this._nickname.toLowerCase() != "auth";
+      if (!aMessage.params[1].startsWith("***") && !isAuth) {
+        this.getConversation(aMessage.origin).writeMessage(
+          aMessage.origin,
+          aMessage.params[1],
+          {
+            incoming: true,
+            tags: aMessage.tags,
+          }
+        );
+        return true;
+      }
+
+      return false;
+    },
+
+    "042": function (aMessage) {
+      // RPL_YOURID (IRCnet)
+      // <nick> <id> :your unique ID
+      return true;
+    },
+
+    307(aMessage) {
+      // TODO RPL_SUSERHOST (AustHex)
+      // TODO RPL_USERIP (Undernet)
+      // <user ips>
+
+      // RPL_WHOISREGNICK (Unreal & Bahamut)
+      // <nick> :is a registered nick
+      if (aMessage.params.length == 3) {
+        return this.setWhois(aMessage.params[1], { registered: true });
+      }
+
+      return false;
+    },
+
+    317(aMessage) {
+      // RPL_WHOISIDLE (Unreal & Charybdis)
+      // <nick> <integer> <integer> :seconds idle, signon time
+      // This is a non-standard extension to RPL_WHOISIDLE which includes the
+      // sign-on time.
+      if (aMessage.params.length == 5) {
+        this.setWhois(aMessage.params[1], { signonTime: aMessage.params[3] });
+      }
+
+      return false;
+    },
+
+    328(aMessage) {
+      // RPL_CHANNEL_URL (Bahamut & Austhex)
+      // <channel> :<URL>
+      return true;
+    },
+
+    329(aMessage) {
+      // RPL_CREATIONTIME (Bahamut & Unreal)
+      // <channel> <creation time>
+      return true;
+    },
+
+    330(aMessage) {
+      // TODO RPL_WHOWAS_TIME
+
+      // RPL_WHOISACCOUNT (Charybdis, ircu & Quakenet)
+      // <nick> <authname> :is logged in as
+      if (aMessage.params.length == 4) {
+        let [, nick, authname] = aMessage.params;
+        // If the authname differs from the nickname, add it to the WHOIS
+        // information; otherwise, ignore it.
+        if (this.normalize(nick) != this.normalize(authname)) {
+          this.setWhois(nick, { registeredAs: authname });
+        }
+      }
+      return true;
+    },
+
+    335(aMessage) {
+      // RPL_WHOISBOT (Unreal)
+      // <nick> :is a \002Bot\002 on <network>
+      return this.setWhois(aMessage.params[1], { bot: true });
+    },
+
+    338(aMessage) {
+      // RPL_CHANPASSOK
+      // RPL_WHOISACTUALLY (ircu, Bahamut, Charybdis)
+      // <nick> <user> <ip> :actually using host
+      return true;
+    },
+
+    378(aMessage) {
+      // RPL_WHOISHOST (Unreal & Charybdis)
+      // <nick> :is connecting from <host> <ip>
+      let [host, ip] = aMessage.params[2].split(" ").slice(-2);
+      return this.setWhois(aMessage.params[1], { host, ip });
+    },
+
+    379(aMessage) {
+      // RPL_WHOISMODES (Unreal, Inspircd)
+      // <nick> :is using modes <modes>
+      // Sent in response to a WHOIS on the user.
+      return true;
+    },
+
+    396(aMessage) {
+      // RPL_HOSTHIDDEN (Charybdis, Hybrid, ircu, etc.)
+      // RPL_VISIBLEHOST (Plexus)
+      // RPL_YOURDISPLAYEDHOST (Inspircd)
+      // <host> :is now your hidden host
+
+      // This is the host that will be sent to other users.
+      this.prefix = "!" + aMessage.user + "@" + aMessage.params[1];
+      return true;
+    },
+
+    464(aMessage) {
+      // :Password required
+      // If we receive a ZNC error message requesting a password, eat it since
+      // a NOTICE AUTH will follow causing us to send the password. This numeric
+      // is, unfortunately, also sent if you give a wrong password. The
+      // parameter in that case is "Invalid Password".
+      return (
+        aMessage.origin == "irc.znc.in" &&
+        aMessage.params[1] == "Password required"
+      );
+    },
+
+    470(aMessage) {
+      // Channel forward (Unreal, inspircd)
+      // <requested channel> <redirect channel>: You may not join this channel,
+      // so you are automatically being transferred to the redirect channel.
+      // Join redirect channel so when the automatic join happens, we are
+      // not surprised.
+      this.joinChat(this.getChatRoomDefaultFieldValues(aMessage.params[2]));
+      // Mark requested channel as left and add a system message.
+      return conversationErrorMessage(
+        this,
+        aMessage,
+        "error.channelForward",
+        true,
+        false
+      );
+    },
+
+    499(aMessage) {
+      // ERR_CHANOWNPRIVNEEDED (Unreal)
+      // <channel> :You're not the channel owner (status +q is needed)
+      return conversationErrorMessage(this, aMessage, "error.notChannelOwner");
+    },
+
+    671(aMessage) {
+      // RPL_WHOISSECURE (Unreal & Charybdis)
+      // <nick> :is using a Secure connection
+      return this.setWhois(aMessage.params[1], { secure: true });
+    },
+
+    998(aMessage) {
+      // irc.umich.edu shows an ASCII captcha that must be typed in by the user.
+      this.getConversation(aMessage.origin).writeMessage(
+        aMessage.origin,
+        aMessage.params[1],
+        {
+          incoming: true,
+          noFormat: true,
+        }
+      );
+      return true;
+    },
+  },
+};
diff --git a/comm/chat/protocols/irc/ircSASL.sys.mjs b/comm/chat/protocols/irc/ircSASL.sys.mjs
new file mode 100644
index 0000000000..0708d0180a
--- /dev/null
+++ b/comm/chat/protocols/irc/ircSASL.sys.mjs
@@ -0,0 +1,179 @@
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
+
+/*
+ * This implements SASL for IRC.
+ *   https://raw.github.com/atheme/atheme/master/doc/SASL
+ *   https://ircv3.net/specs/extensions/sasl-3.2
+ */
+
+import { ircHandlerPriorities } from "resource:///modules/ircHandlerPriorities.sys.mjs";
+
+export var ircSASL = {
+  name: "SASL AUTHENTICATE",
+  priority: ircHandlerPriorities.DEFAULT_PRIORITY,
+  isEnabled() {
+    return this._activeCAPs.has("sasl");
+  },
+
+  commands: {
+    AUTHENTICATE(aMessage) {
+      // Expect an empty response, if something different is received abort.
+      if (aMessage.params[0] != "+") {
+        this.sendMessage("AUTHENTICATE", "*");
+        this.WARN(
+          "Aborting SASL authentication, unexpected message " +
+            "received:\n" +
+            aMessage.rawMessage
+        );
+        return true;
+      }
+
+      // An authentication identity, authorization identity and password are
+      // used, separated by null.
+      let data = [
+        this._requestedNickname,
+        this._requestedNickname,
+        this.imAccount.password,
+      ].join("\0");
+      // btoa for Unicode, see https://developer.mozilla.org/en-US/docs/DOM/window.btoa
+      let base64Data = btoa(unescape(encodeURIComponent(data)));
+      this.sendMessage(
+        "AUTHENTICATE",
+        base64Data,
+        "AUTHENTICATE <base64 encoded nick, user and password not logged>"
+      );
+      return true;
+    },
+
+    900(aMessage) {
+      // RPL_LOGGEDIN
+      // <nick>!<ident>@<host> <account> :You are now logged in as <user>
+      // Now logged in ("whether by SASL or otherwise").
+      this.isAuthenticated = true;
+      return true;
+    },
+
+    901(aMessage) {
+      // RPL_LOGGEDOUT
+      // The user's account name is unset (whether by SASL or otherwise).
+      this.isAuthenticated = false;
+      return true;
+    },
+
+    902(aMessage) {
+      // ERR_NICKLOCKED
+      // Authentication failed because the account is currently locked out,
+      // held, or otherwise administratively made unavailable.
+      this.WARN(
+        "You must use a nick assigned to you. SASL authentication failed."
+      );
+      this.removeCAP("sasl");
+      return true;
+    },
+
+    903(aMessage) {
+      // RPL_SASLSUCCESS
+      // Authentication was successful.
+      this.isAuthenticated = true;
+      this.LOG("SASL authentication successful.");
+      // We may receive this again while already connected if the user manually
+      // identifies with Nickserv.
+      if (!this.connected) {
+        this.removeCAP("sasl");
+      }
+      return true;
+    },
+
+    904(aMessage) {
+      // ERR_SASLFAIL
+      // Sent when the SASL authentication fails because of invalid credentials
+      // or other errors not explicitly mentioned by other numerics.
+      this.WARN("Authentication with SASL failed.");
+      this.removeCAP("sasl");
+      return true;
+    },
+
+    905(aMessage) {
+      // ERR_SASLTOOLONG
+      // Sent when credentials are valid, but the SASL authentication fails
+      // because the client-sent `AUTHENTICATE` command was too long.
+      this.ERROR("SASL: AUTHENTICATE command was too long.");
+      this.removeCAP("sasl");
+      return true;
+    },
+
+    906(aMessage) {
+      // ERR_SASLABORTED
+      // The client completed registration before SASL authentication completed,
+      // or because we sent `AUTHENTICATE` with `*` as the parameter.
+      //
+      // Freenode sends 906 in addition to 904, ignore 906 in this case.
+      if (this._requestedCAPs.has("sasl")) {
+        this.ERROR(
+          "Registration completed before SASL authentication completed."
+        );
+        this.removeCAP("sasl");
+      }
+      return true;
+    },
+
+    907(aMessage) {
+      // ERR_SASLALREADY
+      // Response if client attempts to AUTHENTICATE after successful
+      // authentication.
+      this.ERROR("Attempting SASL authentication twice?!");
+      this.removeCAP("sasl");
+      return true;
+    },
+
+    908(aMessage) {
+      // RPL_SASLMECHS
+      // <nick> <mechanisms> :are available SASL mechanisms
+      // List of SASL mechanisms supported by the server (or network, services).
+      // The numeric contains a comma-separated list of mechanisms.
+      return false;
+    },
+  },
+};
+
+export var capSASL = {
+  name: "SASL CAP",
+  priority: ircHandlerPriorities.DEFAULT_PRIORITY,
+  isEnabled: () => true,
+
+  commands: {
+    sasl(aMessage) {
+      // Return early if we are already authenticated (can happen due to cap-notify)
+      if (this.isAuthenticated) {
+        return true;
+      }
+
+      if (
+        (aMessage.cap.subcommand === "LS" ||
+          aMessage.cap.subcommand === "NEW") &&
+        this.imAccount.password
+      ) {
+        if (aMessage.cap.value) {
+          const mechanisms = aMessage.cap.value.split(",");
+          // We only support the plain authentication mechanism for now, abort if it's not available.
+          if (!mechanisms.includes("PLAIN")) {
+            return true;
+          }
+        }
+        // If it supports SASL, let the server know we're requiring SASL.
+        this.addCAP("sasl");
+        this.sendMessage("CAP", ["REQ", "sasl"]);
+      } else if (aMessage.cap.subcommand === "ACK") {
+        // The server acknowledges our choice to use SASL, send the first
+        // message.
+        this.sendMessage("AUTHENTICATE", "PLAIN");
+      } else if (aMessage.cap.subcommand === "NAK") {
+        this.removeCAP("sasl");
+      }
+
+      return true;
+    },
+  },
+};
diff --git a/comm/chat/protocols/irc/ircServerTime.sys.mjs b/comm/chat/protocols/irc/ircServerTime.sys.mjs
new file mode 100644
index 0000000000..14ce2436f3
--- /dev/null
+++ b/comm/chat/protocols/irc/ircServerTime.sys.mjs
@@ -0,0 +1,80 @@
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
+
+/*
+ * This implements server-time for IRC.
+ *   https://ircv3.net/specs/extensions/server-time-3.2
+ */
+
+import { ircHandlerPriorities } from "resource:///modules/ircHandlerPriorities.sys.mjs";
+
+function handleServerTimeTag(aMsg) {
+  if (aMsg.tagValue) {
+    // Normalize leap seconds to the next second before it.
+    const time = aMsg.tagValue.replace(/60.\d{3}(?=Z$)/, "59.999");
+    aMsg.message.time = Math.floor(Date.parse(time) / 1000);
+    aMsg.message.delayed = true;
+  }
+}
+
+export var tagServerTime = {
+  name: "server-time Tags",
+  priority: ircHandlerPriorities.DEFAULT_PRIORITY,
+  isEnabled() {
+    return (
+      this._activeCAPs.has("server-time") ||
+      this._activeCAPs.has("znc.in/server-time-iso")
+    );
+  },
+
+  commands: {
+    time: handleServerTimeTag,
+    "znc.in/server-time-iso": handleServerTimeTag,
+  },
+};
+
+export var capServerTime = {
+  name: "server-time CAP",
+  priority: ircHandlerPriorities.DEFAULT_PRIORITY,
+  isEnabled: () => true,
+
+  commands: {
+    "server-time": function (aMessage) {
+      if (
+        aMessage.cap.subcommand === "LS" ||
+        aMessage.cap.subcommand === "NEW"
+      ) {
+        this.addCAP("server-time");
+        this.sendMessage("CAP", ["REQ", "server-time"]);
+      } else if (
+        aMessage.cap.subcommand === "ACK" ||
+        aMessage.cap.subcommand === "NAK"
+      ) {
+        this.removeCAP("server-time");
+      } else {
+        return false;
+      }
+      return true;
+    },
+    "znc.in/server-time-iso": function (aMessage) {
+      // Only request legacy server time CAP if the standard one is not available.
+      if (
+        (aMessage.cap.subcommand === "LS" ||
+          aMessage.cap.subcommand === "NEW") &&
+        !this._availableCAPs.has("server-time")
+      ) {
+        this.addCAP("znc.in/server-time-iso");
+        this.sendMessage("CAP", ["REQ", "znc.in/server-time-iso"]);
+      } else if (
+        aMessage.cap.subcommand === "ACK" ||
+        aMessage.cap.subcommand === "NAK"
+      ) {
+        this.removeCAP("znc.in/server-time-iso");
+      } else {
+        return false;
+      }
+      return true;
+    },
+  },
+};
diff --git a/comm/chat/protocols/irc/ircServices.sys.mjs b/comm/chat/protocols/irc/ircServices.sys.mjs
new file mode 100644
index 0000000000..4f39bda237
--- /dev/null
+++ b/comm/chat/protocols/irc/ircServices.sys.mjs
@@ -0,0 +1,317 @@
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
+
+/*
+ * This attempts to handle dealing with IRC services, which are a diverse set of
+ * programs to automate and add features to IRCd. Often these services are seen
+ * with the names NickServ, ChanServ, OperServ and MemoServ; but other services
+ * do exist and are in use.
+ *
+ * Since the "protocol" behind services is really just text-based, human
+ * readable messages, attempt to parse them, but always fall back to just
+ * showing the message to the user if we're unsure what to do.
+ *
+ * Anope
+ *  https://www.anope.org/docgen/1.8/
+ */
+
+import { setTimeout, clearTimeout } from "resource://gre/modules/Timer.sys.mjs";
+import { ircHandlerPriorities } from "resource:///modules/ircHandlerPriorities.sys.mjs";
+
+/*
+ * If a service is found, an extra field (serviceName) is added with the
+ * "generic" service name (e.g. a bot which performs NickServ like functionality
+ * will be mapped to NickServ).
+ */
+function ServiceMessage(aAccount, aMessage) {
+  // This should be a property of the account or configurable somehow, it maps
+  // from server specific service names to our generic service names (e.g. if
+  // irc.foo.net has a service called bar, which acts as a NickServ, we would
+  // map "bar": "NickServ"). Note that the keys of this map should be
+  // normalized.
+  let nicknameToServiceName = {
+    chanserv: "ChanServ",
+    infoserv: "InfoServ",
+    nickserv: "NickServ",
+    saslserv: "SaslServ",
+    "freenode-connect": "freenode-connect",
+  };
+
+  let nickname = aAccount.normalize(aMessage.origin);
+  if (nicknameToServiceName.hasOwnProperty(nickname)) {
+    aMessage.serviceName = nicknameToServiceName[nickname];
+  }
+
+  return aMessage;
+}
+
+export var ircServices = {
+  name: "IRC Services",
+  priority: ircHandlerPriorities.HIGH_PRIORITY,
+  isEnabled: () => true,
+  sendIdentify(aAccount) {
+    if (
+      aAccount.imAccount.password &&
+      aAccount.shouldAuthenticate &&
+      !aAccount.isAuthenticated
+    ) {
+      aAccount.sendMessage(
+        "IDENTIFY",
+        aAccount.imAccount.password,
+        "IDENTIFY <password not logged>"
+      );
+    }
+  },
+
+  commands: {
+    // If we automatically reply to a NOTICE message this does not abide by RFC
+    // 2812. Oh well.
+    NOTICE(ircMessage, ircHandlers) {
+      if (!ircHandlers.hasServicesHandlers) {
+        return false;
+      }
+
+      let message = ServiceMessage(this, ircMessage);
+
+      // If no service was found, return early.
+      if (!message.hasOwnProperty("serviceName")) {
+        return false;
+      }
+
+      // If the name is recognized as a service name, add the service name field
+      // and run it through the handlers.
+      return ircHandlers.handleServicesMessage(this, message);
+    },
+
+    NICK(aMessage) {
+      let newNick = aMessage.params[0];
+      // We only auto-authenticate for the account nickname.
+      if (this.normalize(newNick) != this.normalize(this._accountNickname)) {
+        return false;
+      }
+
+      // If we're not identified already, try to identify.
+      if (!this.isAuthenticated) {
+        ircServices.sendIdentify(this);
+      }
+
+      // We always want the RFC 2812 handler to handle NICK, so return false.
+      return false;
+    },
+
+    "001": function (aMessage) {
+      // RPL_WELCOME
+      // If SASL authentication failed, attempt IDENTIFY.
+      ircServices.sendIdentify(this);
+
+      // We always want the RFC 2812 handler to handle 001, so return false.
+      return false;
+    },
+
+    421(aMessage) {
+      // ERR_UNKNOWNCOMMAND
+      // <command> :Unknown command
+      // IDENTIFY failed, try NICKSERV IDENTIFY.
+      if (
+        aMessage.params[1] == "IDENTIFY" &&
+        this.imAccount.password &&
+        this.shouldAuthenticate &&
+        !this.isAuthenticated
+      ) {
+        this.sendMessage(
+          "NICKSERV",
+          ["IDENTIFY", this.imAccount.password],
+          "NICKSERV IDENTIFY <password not logged>"
+        );
+        return true;
+      }
+      if (aMessage.params[1] == "NICKSERV") {
+        this.WARN("NICKSERV command does not exist.");
+        return true;
+      }
+      return false;
+    },
+  },
+};
+
+export var servicesBase = {
+  name: "IRC Services",
+  priority: ircHandlerPriorities.DEFAULT_PRIORITY,
+  isEnabled: () => true,
+
+  commands: {
+    ChanServ(aMessage) {
+      // [<channel name>] <message>
+      let channel = aMessage.params[1].split(" ", 1)[0];
+      if (!channel || channel[0] != "[" || channel.slice(-1)[0] != "]") {
+        return false;
+      }
+
+      // Remove the [ and ].
+      channel = channel.slice(1, -1);
+      // If it isn't a channel or doesn't exist, return early.
+      if (!this.isMUCName(channel) || !this.conversations.has(channel)) {
+        return false;
+      }
+
+      // Otherwise, display the message in that conversation.
+      let params = { incoming: true };
+      if (aMessage.command == "NOTICE") {
+        params.notification = true;
+      }
+
+      // The message starts after the channel name, plus [, ] and a space.
+      let message = aMessage.params[1].slice(channel.length + 3);
+      this.getConversation(channel).writeMessage(
+        aMessage.origin,
+        message,
+        params
+      );
+      return true;
+    },
+
+    InfoServ(aMessage) {
+      let text = aMessage.params[1];
+
+      // Show the message of the day in the server tab.
+      if (text == "*** \u0002Message(s) of the Day\u0002 ***") {
+        this._infoServMotd = [text];
+        return true;
+      } else if (text == "*** \u0002End of Message(s) of the Day\u0002 ***") {
+        if (this._showServerTab && this._infoServMotd) {
+          this._infoServMotd.push(text);
+          this.getConversation(aMessage.origin).writeMessage(
+            aMessage.origin,
+            this._infoServMotd.join("\n"),
+            {
+              incoming: true,
+            }
+          );
+          delete this._infoServMotd;
+        }
+        return true;
+      } else if (this.hasOwnProperty("_infoServMotd")) {
+        this._infoServMotd.push(text);
+        return true;
+      }
+
+      return false;
+    },
+
+    NickServ(message, ircHandlers) {
+      // Since we feed the messages back through the system at the end of the
+      // timeout when waiting for a log-in, we need to NOT try to handle them
+      // here and let them fall through to the default handler.
+      if (this.isHandlingQueuedMessages) {
+        return false;
+      }
+
+      let text = message.params[1];
+
+      // If we have a queue of messages, we're waiting for authentication.
+      if (this.nickservMessageQueue) {
+        if (
+          text == "Password accepted - you are now recognized." || // Anope.
+          text.startsWith("You are now identified for \x02")
+        ) {
+          // Atheme.
+          // Password successfully accepted by NickServ, don't display the
+          // queued messages.
+          this.LOG("Successfully authenticated with NickServ.");
+          this.isAuthenticated = true;
+          clearTimeout(this.nickservAuthTimeout);
+          delete this.nickservAuthTimeout;
+          delete this.nickservMessageQueue;
+        } else {
+          // Queue any other messages that occur during the timeout so they
+          // appear in the proper order.
+          this.nickservMessageQueue.push(message);
+        }
+        return true;
+      }
+
+      // NickServ wants us to identify.
+      if (
+        text == "This nick is owned by someone else.  Please choose another." || // Anope.
+        text == "This nickname is registered and protected.  If it is your" || // Anope (SECURE enabled).
+        text ==
+          "This nickname is registered. Please choose a different nickname, or identify via \x02/msg NickServ identify <password>\x02."
+      ) {
+        // Atheme.
+        this.LOG("Authentication requested by NickServ.");
+
+        // Wait one second before showing the message to the user (giving the
+        // the server time to process the log-in).
+        this.nickservMessageQueue = [message];
+        this.nickservAuthTimeout = setTimeout(
+          function () {
+            this.isHandlingQueuedMessages = true;
+            this.nickservMessageQueue.every(aMessage =>
+              ircHandlers.handleMessage(this, aMessage)
+            );
+            delete this.isHandlingQueuedMessages;
+            delete this.nickservMessageQueue;
+          }.bind(this),
+          10000
+        );
+        return true;
+      }
+
+      if (
+        !this.isAuthenticated &&
+        (text == "You are already identified." || // Anope.
+          text.startsWith("You are already logged in as \x02"))
+      ) {
+        // Atheme.
+        // Do not show the message if caused by the automatic reauthentication.
+        this.isAuthenticated = true;
+        return true;
+      }
+
+      return false;
+    },
+
+    /**
+     * Ignore useless messages from SaslServ (unless showing of server messages
+     * is enabled).
+     *
+     * @param {object} aMessage The IRC message object.
+     * @returns {boolean} True if the message was handled, false if it should be
+     *    processed by another handler.
+     */
+    SaslServ(aMessage) {
+      // If the user would like to see server messages, fall through to the
+      // standard handler.
+      if (this._showServerTab) {
+        return false;
+      }
+
+      // Only ignore the message notifying of last login.
+      let text = aMessage.params[1];
+      return text.startsWith("Last login from: ");
+    },
+
+    /*
+     * freenode sends some annoying messages on start-up from a freenode-connect
+     * bot. Only show these if the user wants to see server messages. See bug
+     * 1521761.
+     */
+    "freenode-connect": function (aMessage) {
+      // If the user would like to see server messages, fall through to the
+      // standard handler.
+      if (this._showServerTab) {
+        return false;
+      }
+
+      // Only ignore the message notifying of scanning (and include additional
+      // checking of the hostname).
+      return (
+        aMessage.host.startsWith("freenode/utility-bot/") &&
+        aMessage.params[1].includes(
+          "connections will be scanned for vulnerabilities"
+        )
+      );
+    },
+  },
+};
diff --git a/comm/chat/protocols/irc/ircUtils.sys.mjs b/comm/chat/protocols/irc/ircUtils.sys.mjs
new file mode 100644
index 0000000000..190ed8f830
--- /dev/null
+++ b/comm/chat/protocols/irc/ircUtils.sys.mjs
@@ -0,0 +1,303 @@
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
+
+import { XPCOMUtils } from "resource://gre/modules/XPCOMUtils.sys.mjs";
+import { l10nHelper } from "resource:///modules/imXPCOMUtils.sys.mjs";
+
+const lazy = {};
+XPCOMUtils.defineLazyGetter(lazy, "_", () =>
+  l10nHelper("chrome://chat/locale/irc.properties")
+);
+
+XPCOMUtils.defineLazyGetter(lazy, "TXTToHTML", function () {
+  let cs = Cc["@mozilla.org/txttohtmlconv;1"].getService(Ci.mozITXTToHTMLConv);
+  return aTXT => cs.scanTXT(aTXT, cs.kEntities);
+});
+
+// The timespan after which we consider LIST roomInfo to be stale.
+export var kListRefreshInterval = 12 * 60 * 60 * 1000; // 12 hours.
+
+/*
+ * The supported formatting control characters, as described in
+ * http://www.invlogic.com/irc/ctcp.html#3.11
+ * If a string is given, it will replace the control character; if null is
+ * given, the current HTML tag stack will be closed; if a function is given,
+ * it expects two parameters:
+ *  aStack  The ordered list of open HTML tags.
+ *  aInput  The current input string.
+ * There are three output values returned in an array:
+ *  The new ordered list of open HTML tags.
+ *  The new text output to append.
+ *  The number of characters (from the start of the input string) that the
+ *  function handled.
+ */
+var CTCP_TAGS = {
+  "\x02": "b", // \002, ^B, Bold
+  "\x16": "i", // \026, ^V, Reverse or Inverse (Italics)
+  "\x1D": "i", // \035, ^], Italics (mIRC)
+  "\x1F": "u", // \037, ^_, Underline
+  "\x03": mIRCColoring, // \003, ^C, Coloring
+  "\x0F": null, // \017, ^O, Clear all formatting
+};
+
+// Generate an expression that will search for any of the control characters.
+var CTCP_TAGS_EXP = new RegExp("[" + Object.keys(CTCP_TAGS).join("") + "]");
+
+// Remove all CTCP formatting characters.
+export function ctcpFormatToText(aString) {
+  let next,
+    input = aString,
+    output = "",
+    length;
+
+  while ((next = CTCP_TAGS_EXP.exec(input))) {
+    if (next.index > 0) {
+      output += input.substr(0, next.index);
+    }
+    // We assume one character will be stripped.
+    length = 1;
+    let tag = CTCP_TAGS[input[next.index]];
+    // If the tag is a function, calculate how many characters are handled.
+    if (typeof tag == "function") {
+      [, , length] = tag([], input.substr(next.index));
+    }
+
+    // Avoid infinite loops.
+    length = Math.max(1, length);
+    // Skip to after the last match.
+    input = input.substr(next.index + length);
+  }
+  // Append the unmatched bits before returning the output.
+  return output + input;
+}
+
+function openStack(aStack) {
+  return aStack.map(aTag => "<" + aTag + ">").join("");
+}
+
+// Close the tags in the opposite order they were opened.
+function closeStack(aStack) {
+  return aStack
+    .reverse()
+    .map(aTag => "</" + aTag.split(" ", 1) + ">")
+    .join("");
+}
+
+/**
+ * Convert a string from CTCP escaped formatting to HTML markup.
+ *
+ * @param aString the string with CTCP formatting to parse
+ * @returns The HTML output string
+ */
+export function ctcpFormatToHTML(aString) {
+  let next,
+    stack = [],
+    input = lazy.TXTToHTML(aString),
+    output = "",
+    newOutput,
+    length;
+
+  while ((next = CTCP_TAGS_EXP.exec(input))) {
+    if (next.index > 0) {
+      output += input.substr(0, next.index);
+    }
+    length = 1;
+    let tag = CTCP_TAGS[input[next.index]];
+    if (tag === null) {
+      // Clear all formatting.
+      output += closeStack(stack);
+      stack = [];
+    } else if (typeof tag == "function") {
+      [stack, newOutput, length] = tag(stack, input.substr(next.index));
+      output += newOutput;
+    } else {
+      let offset = stack.indexOf(tag);
+      if (offset == -1) {
+        // Tag not found; open new tag.
+        output += "<" + tag + ">";
+        stack.push(tag);
+      } else {
+        // Tag found; close existing tag (and all tags after it).
+        output += closeStack(stack.slice(offset));
+        // Reopen the tags that came after it.
+        output += openStack(stack.slice(offset + 1));
+        // Remove the tag from the stack.
+        stack.splice(offset, 1);
+      }
+    }
+
+    // Avoid infinite loops.
+    length = Math.max(1, length);
+    // Skip to after the last match.
+    input = input.substr(next.index + length);
+  }
+  // Return unmatched bits and close any open tags at the end.
+  return output + input + closeStack(stack);
+}
+
+// mIRC colors are defined at http://www.mirc.com/colors.html.
+// This expression matches \003<one or two digits>[,<one or two digits>].
+// eslint-disable-next-line no-control-regex
+var M_IRC_COLORS_EXP = /^\x03(?:(\d\d?)(?:,(\d\d?))?)?/;
+var M_IRC_COLOR_MAP = {
+  0: "white",
+  1: "black",
+  2: "navy", // blue (navy)
+  3: "green",
+  4: "red",
+  5: "maroon", // brown (maroon)
+  6: "purple",
+  7: "orange", // orange (olive)
+  8: "yellow",
+  9: "lime", // light green (lime)
+  10: "teal", // teal (a green/blue cyan)
+  11: "aqua", // light cyan (cyan) (aqua)
+  12: "blue", // light blue (royal)",
+  13: "fuchsia", // pink (light purple) (fuchsia)
+  14: "grey",
+  15: "silver", // light grey (silver)
+  99: "transparent",
+};
+
+function mIRCColoring(aStack, aInput) {
+  function getColor(aKey) {
+    let key = aKey;
+    // Single digit numbers can (must?) be prefixed by a zero.
+    if (key.length == 2 && key[0] == "0") {
+      key = key[1];
+    }
+
+    if (M_IRC_COLOR_MAP.hasOwnProperty(key)) {
+      return M_IRC_COLOR_MAP[key];
+    }
+
+    return null;
+  }
+
+  let matches,
+    stack = aStack,
+    input = aInput,
+    output = "",
+    length = 1;
+
+  if ((matches = M_IRC_COLORS_EXP.exec(input))) {
+    let format = ["font"];
+
+    // Only \003 was found with no formatting digits after it, close the
+    // first open font tag.
+    if (!matches[1]) {
+      // Find the first font tag.
+      let offset = stack.map(aTag => aTag.indexOf("font") === 0).indexOf(true);
+
+      // Close all tags from the first font tag on.
+      output = closeStack(stack.slice(offset));
+      // Remove the font tags from the stack.
+      stack = stack.filter(aTag => aTag.indexOf("font"));
+      // Reopen the other tags.
+      output += openStack(stack.slice(offset));
+    } else {
+      // Otherwise we have a match and are setting new colors.
+      // The foreground color.
+      let color = getColor(matches[1]);
+      if (color) {
+        format.push('color="' + color + '"');
+      }
+
+      // The background color.
+      if (matches[2]) {
+        let color = getColor(matches[2]);
+        if (color) {
+          format.push('background="' + color + '"');
+        }
+      }
+
+      if (format.length > 1) {
+        let tag = format.join(" ");
+        output = "<" + tag + ">";
+        stack.push(tag);
+        length = matches[0].length;
+      }
+    }
+  }
+
+  return [stack, output, length];
+}
+
+// Print an error message into a conversation, optionally mark the conversation
+// as not joined and/or not rejoinable.
+export function conversationErrorMessage(
+  aAccount,
+  aMessage,
+  aError,
+  aJoinFailed = false,
+  aRejoinable = true
+) {
+  let conv = aAccount.getConversation(aMessage.params[1]);
+  conv.writeMessage(
+    aMessage.origin,
+    lazy._(aError, aMessage.params[1], aMessage.params[2] || undefined),
+    {
+      error: true,
+      system: true,
+    }
+  );
+  delete conv._pendingMessage;
+
+  // Channels have a couple extra things that can be done to them.
+  if (aAccount.isMUCName(aMessage.params[1])) {
+    // If a value for joining is explicitly given, mark it.
+    if (aJoinFailed) {
+      conv.joining = false;
+    }
+    // If the conversation cannot be rejoined automatically, delete
+    // chatRoomFields.
+    if (!aRejoinable) {
+      delete conv.chatRoomFields;
+    }
+  }
+
+  return true;
+}
+
+/**
+ * Display a PRIVMSG or NOTICE in a conversation.
+ *
+ * @param {ircAccount} aAccount - The current account.
+ * @param {ircMessage} aMessage - The IRC message to display, provides the IRC
+ *  tags, conversation name, and sender.
+ * @param {object} aExtraParams - (Extra) parameters to pass to ircConversation.writeMessage.
+ * @param {string|null} aText - The text to display, defaults to the second parameter
+ *  on aMessage.
+ * @returns {boolean} True if the message was sent successfully.
+ */
+export function displayMessage(aAccount, aMessage, aExtraParams, aText) {
+  let params = { tags: aMessage.tags, ...aExtraParams };
+  // If the the message is from our nick, it is outgoing to the conversation it
+  // is targeting. Otherwise, the message is incoming, but could be for a
+  // private message or a channel.
+  //
+  // Note that the only time it is expected to receive a message from us is if
+  // the echo-message capability is enabled.
+  let convName;
+  if (
+    aAccount.normalizeNick(aMessage.origin) ==
+    aAccount.normalizeNick(aAccount._nickname)
+  ) {
+    params.outgoing = true;
+    // The conversation name is who it is being sent to.
+    convName = aMessage.params[0];
+  } else {
+    params.incoming = true;
+    // If the target is a MUC name, use the target as the conversation name.
+    // Otherwise, this is a private message: use the sender as the conversation
+    // name.
+    convName = aAccount.isMUCName(aMessage.params[0])
+      ? aMessage.params[0]
+      : aMessage.origin;
+  }
+  aAccount
+    .getConversation(convName)
+    .writeMessage(aMessage.origin, aText || aMessage.params[1], params);
+  return true;
+}
diff --git a/comm/chat/protocols/irc/ircWatchMonitor.sys.mjs b/comm/chat/protocols/irc/ircWatchMonitor.sys.mjs
new file mode 100644
index 0000000000..c7bdb2bf7b
--- /dev/null
+++ b/comm/chat/protocols/irc/ircWatchMonitor.sys.mjs
@@ -0,0 +1,467 @@
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
+
+/*
+ * This implements the WATCH and MONITOR commands: ways to more efficiently
+ * (compared to ISON) keep track of a user's status.
+ *
+ *   MONITOR (supported by Charybdis)
+ *     https://github.com/atheme/charybdis/blob/master/doc/monitor.txt
+ *   WATCH (supported by Bahamut and UnrealIRCd)
+ *     http://www.stack.nl/~jilles/cgi-bin/hgwebdir.cgi/irc-documentation-jilles/raw-file/tip/reference/draft-meglio-irc-watch-00.txt
+ */
+
+import { clearTimeout } from "resource://gre/modules/Timer.sys.mjs";
+import { ircHandlerPriorities } from "resource:///modules/ircHandlerPriorities.sys.mjs";
+
+function setStatus(aAccount, aNick, aStatus) {
+  if (!aAccount.watchEnabled && !aAccount.monitorEnabled) {
+    return false;
+  }
+
+  if (aStatus == "AWAY") {
+    // We need to request the away message.
+    aAccount.requestCurrentWhois(aNick);
+  } else {
+    // Clear the WHOIS information.
+    aAccount.removeBuddyInfo(aNick);
+  }
+
+  let buddy = aAccount.buddies.get(aNick);
+  if (!buddy) {
+    return false;
+  }
+  buddy.setStatus(Ci.imIStatusInfo["STATUS_" + aStatus], "");
+  return true;
+}
+
+function trackBuddyWatch(aNicks) {
+  // aNicks is an array when WATCH is initialized, and a single nick
+  // in all later calls.
+  if (!Array.isArray(aNicks)) {
+    // We update the trackQueue if an individual nick is being added,
+    // so the nick will also be monitored after a reconnect.
+    Object.getPrototypeOf(this).trackBuddy.call(this, aNicks);
+    aNicks = [aNicks];
+  }
+
+  let nicks = aNicks.map(aNick => "+" + aNick);
+  if (!nicks.length) {
+    return;
+  }
+
+  let newWatchLength = this.watchLength + nicks.length;
+  if (newWatchLength > this.maxWatchLength) {
+    this.WARN(
+      "Attempting to WATCH " +
+        newWatchLength +
+        " nicks; maximum size is " +
+        this.maxWatchLength +
+        "."
+    );
+    // TODO We should trim the list and add the extra users to an ISON queue,
+    // but that's not currently implemented, so just hope the server doesn't
+    // enforce it's own limit.
+  }
+  this.watchLength = newWatchLength;
+
+  // Watch away as well as online.
+  let params = [];
+  if (this.watchAwayEnabled) {
+    params.push("A");
+  }
+  let maxLength =
+    this.maxMessageLength -
+    2 -
+    this.countBytes(this.buildMessage("WATCH", params));
+  for (let nick of nicks) {
+    if (this.countBytes(params + " " + nick) >= maxLength) {
+      // If the message would be too long, first send this message.
+      this.sendMessage("WATCH", params);
+      // Reset for the next message.
+      params = [];
+      if (this.watchAwayEnabled) {
+        params.push("A");
+      }
+    }
+    params.push(nick);
+  }
+  this.sendMessage("WATCH", params);
+}
+function untrackBuddyWatch(aNick) {
+  --this.watchLength;
+  this.sendMessage("WATCH", "-" + aNick);
+  Object.getPrototypeOf(this).untrackBuddy.call(this, aNick);
+}
+
+export var isupportWATCH = {
+  name: "WATCH",
+  // Slightly above default ISUPPORT priority.
+  priority: ircHandlerPriorities.DEFAULT_PRIORITY + 10,
+  isEnabled: () => true,
+
+  commands: {
+    WATCH(aMessage) {
+      if (!aMessage.isupport.useDefault) {
+        this.maxWatchLength = 128;
+      } else {
+        let size = parseInt(aMessage.isupport.value, 10);
+        if (isNaN(size)) {
+          return false;
+        }
+        this.maxWatchLength = size;
+      }
+
+      this.watchEnabled = true;
+
+      // Clear our watchlist in case there is garbage in it.
+      this.sendMessage("WATCH", "C");
+      this.watchLength = 0;
+
+      // Kill the ISON polling loop.
+      clearTimeout(this._isOnTimer);
+
+      return true;
+    },
+
+    WATCHOPTS(aMessage) {
+      const watchOptToOption = {
+        H: "watchMasksEnabled",
+        A: "watchAwayEnabled",
+      };
+
+      // For each option, mark it as supported.
+      aMessage.isupport.value.split("").forEach(function (aWatchOpt) {
+        if (watchOptToOption.hasOwnProperty(aWatchOpt)) {
+          this[watchOptToOption[aWatchOpt]] = true;
+        }
+      }, this);
+
+      return true;
+    },
+  },
+};
+
+export var ircWATCH = {
+  name: "WATCH",
+  // Slightly above default IRC priority.
+  priority: ircHandlerPriorities.DEFAULT_PRIORITY + 10,
+  // Use WATCH if it is supported.
+  isEnabled() {
+    return !!this.watchEnabled;
+  },
+
+  commands: {
+    251(aMessage) {
+      // RPL_LUSERCLIENT
+      // ":There are <integer> users and <integer> services on <integer> servers"
+      // Assume that this will always be sent after the 005 handler on
+      // connection registration. If WATCH is enabled, then set the new function
+      // to keep track of nicks and send the messages to watch the nicks.
+
+      // Ensure that any new buddies are set to be watched, and removed buddies
+      // are no longer watched.
+      this.trackBuddy = trackBuddyWatch;
+      this.untrackBuddy = untrackBuddyWatch;
+
+      // Build the watchlist from the current list of nicks.
+      this.trackBuddy(this.trackQueue);
+
+      // Fall through to other handlers since we're only using this as an entry
+      // point and not actually handling the message.
+      return false;
+    },
+
+    301(aMessage) {
+      // RPL_AWAY
+      // <nick> :<away message>
+      // Set the received away message.
+      let buddy = this.buddies.get(aMessage.params[1]);
+      if (buddy) {
+        buddy.setStatus(Ci.imIStatusInfo.STATUS_AWAY, aMessage.params[2]);
+      }
+
+      // Fall through to the other implementations after setting the status
+      // message.
+      return false;
+    },
+
+    303(aMessage) {
+      // RPL_ISON
+      // :*1<nick> *( " " <nick> )
+      // We don't want ircBase to interfere with us, so override the ISON
+      // handler to do nothing.
+      return true;
+    },
+
+    512(aMessage) {
+      // ERR_TOOMANYWATCH
+      // Maximum size for WATCH-list is <watchlimit> entries
+      this.ERROR(
+        "Maximum size for WATCH list exceeded (" + this.watchLength + ")."
+      );
+      return true;
+    },
+
+    597(aMessage) {
+      // RPL_REAWAY
+      // <nickname> <username> <hostname> <awaysince> :<away reason>
+      return setStatus(this, aMessage.params[1], "AWAY");
+    },
+
+    598(aMessage) {
+      // RPL_GONEAWAY
+      // <nickname> <username> <hostname> <awaysince> :<away reason>
+      // We use a negative index as inspircd versions < 2.0.18 don't send
+      // the user's nick as the first parameter (see bug 1078223).
+      return setStatus(
+        this,
+        aMessage.params[aMessage.params.length - 5],
+        "AWAY"
+      );
+    },
+
+    599(aMessage) {
+      // RPL_NOTAWAY
+      // <nickname> <username> <hostname> <awaysince> :is no longer away
+      // We use a negative index as inspircd versions < 2.0.18 don't send
+      // the user's nick as the first parameter (see bug 1078223).
+      return setStatus(
+        this,
+        aMessage.params[aMessage.params.length - 5],
+        "AVAILABLE"
+      );
+    },
+
+    600(aMessage) {
+      // RPL_LOGON
+      // <nickname> <username> <hostname> <signontime> :logged on
+      return setStatus(this, aMessage.params[1], "AVAILABLE");
+    },
+
+    601(aMessage) {
+      // RPL_LOGOFF
+      // <nickname> <username> <hostname> <lastnickchange> :logged off
+      return setStatus(this, aMessage.params[1], "OFFLINE");
+    },
+
+    602(aMessage) {
+      // RPL_WATCHOFF
+      // <nickname> <username> <hostname> <lastnickchange> :stopped watching
+      return true;
+    },
+
+    603(aMessage) {
+      // RPL_WATCHSTAT
+      // You have <entrycount> and are on <onlistcount> WATCH entries
+      // TODO I don't think we really need to care about this.
+      return false;
+    },
+
+    604(aMessage) {
+      // RPL_NOWON
+      // <nickname> <username> <hostname> <lastnickchange> :is online
+      return setStatus(this, aMessage.params[1], "AVAILABLE");
+    },
+
+    605(aMessage) {
+      // RPL_NOWOFF
+      // <nickname> <username> <hostname> <lastnickchange> :is offline
+      return setStatus(this, aMessage.params[1], "OFFLINE");
+    },
+
+    606(aMessage) {
+      // RPL_WATCHLIST
+      // <entrylist>
+      // TODO
+      return false;
+    },
+
+    607(aMessage) {
+      // RPL_ENDOFWATCHLIST
+      // End of WATCH <parameter>
+      // TODO
+      return false;
+    },
+
+    608(aMessage) {
+      // RPL_CLEARWATCH
+      // Your WATCH list is now empty
+      // Note that this is optional for servers to send, so ignore it.
+      return true;
+    },
+
+    609(aMessage) {
+      // RPL_NOWISAWAY
+      // <nickname> <username> <hostname> <awaysince> :<away reason>
+      return setStatus(this, aMessage.params[1], "AWAY");
+    },
+  },
+};
+
+export var isupportMONITOR = {
+  name: "MONITOR",
+  // Slightly above default ISUPPORT priority.
+  priority: ircHandlerPriorities.DEFAULT_PRIORITY + 10,
+  isEnabled: () => true,
+
+  commands: {
+    MONITOR(aMessage) {
+      if (!aMessage.isupport.useDefault) {
+        this.maxMonitorLength = Infinity;
+      } else {
+        let size = parseInt(aMessage.isupport.value, 10);
+        if (isNaN(size)) {
+          return false;
+        }
+        this.maxMonitorLength = size;
+      }
+
+      this.monitorEnabled = true;
+
+      // Clear our monitor list in case there is garbage in it.
+      this.sendMessage("MONITOR", "C");
+      this.monitorLength = 0;
+
+      // Kill the ISON polling loop.
+      clearTimeout(this._isOnTimer);
+
+      return true;
+    },
+  },
+};
+
+function trackBuddyMonitor(aNicks) {
+  // aNicks is an array when MONITOR is initialized, and a single nick
+  // in all later calls.
+  if (!Array.isArray(aNicks)) {
+    // We update the trackQueue if an individual nick is being added,
+    // so the nick will also be monitored after a reconnect.
+    Object.getPrototypeOf(this).trackBuddy.call(this, aNicks);
+    aNicks = [aNicks];
+  }
+
+  let nicks = aNicks;
+  if (!nicks.length) {
+    return;
+  }
+
+  let newMonitorLength = this.monitorLength + nicks.length;
+  if (newMonitorLength > this.maxMonitorLength) {
+    this.WARN(
+      "Attempting to MONITOR " +
+        newMonitorLength +
+        " nicks; maximum size is " +
+        this.maxMonitorLength +
+        "."
+    );
+    // TODO We should trim the list and add the extra users to an ISON queue,
+    // but that's not currently implemented, so just hope the server doesn't
+    // enforce it's own limit.
+  }
+  this.monitorLength = newMonitorLength;
+
+  let params = [];
+  let maxLength =
+    this.maxMessageLength -
+    2 -
+    this.countBytes(this.buildMessage("MONITOR", "+"));
+  for (let nick of nicks) {
+    if (this.countBytes(params + " " + nick) >= maxLength) {
+      // If the message would be too long, first send this message.
+      this.sendMessage("MONITOR", ["+", params.join(",")]);
+      // Reset for the next message.
+      params = [];
+    }
+    params.push(nick);
+  }
+  this.sendMessage("MONITOR", ["+", params.join(",")]);
+}
+function untrackBuddyMonitor(aNick) {
+  --this.monitorLength;
+  this.sendMessage("MONITOR", ["-", aNick]);
+  Object.getPrototypeOf(this).untrackBuddy.call(this, aNick);
+}
+
+export var ircMONITOR = {
+  name: "MONITOR",
+  // Slightly above default IRC priority.
+  priority: ircHandlerPriorities.DEFAULT_PRIORITY + 10,
+  // Use MONITOR only if MONITOR is enabled and WATCH is not enabled, as WATCH
+  // supports more features.
+  isEnabled() {
+    return this.monitorEnabled && !this.watchEnabled;
+  },
+
+  commands: {
+    251(aMessage) {
+      // RPL_LUSERCLIENT
+      // ":There are <integer> users and <integer> services on <integer> servers"
+      // Assume that this will always be sent after the 005 handler on
+      // connection registration. If MONITOR is enabled, then set the new
+      // function to keep track of nicks and send the messages to watch the
+      // nicks.
+
+      // Ensure that any new buddies are set to be watched, and removed buddies
+      // are no longer watched.
+      this.trackBuddy = trackBuddyMonitor;
+      this.untrackBuddy = untrackBuddyMonitor;
+
+      // Build the watchlist from the current list of nicks.
+      this.trackBuddy(this.trackQueue);
+
+      // Fall through to other handlers since we're only using this as an entry
+      // point and not actually handling the message.
+      return false;
+    },
+
+    303(aMessage) {
+      // RPL_ISON
+      // :*1<nick> *( " " <nick> )
+      // We don't want ircBase to interfere with us, so override the ISON
+      // handler to do nothing if we're using MONITOR.
+      return true;
+    },
+
+    730(aMessage) {
+      // RPL_MONONLINE
+      // :<server> 730 <nick> :nick!user@host[,nick!user@host]*
+      // Mark each nick as online.
+      return aMessage.params[1]
+        .split(",")
+        .map(aNick => setStatus(this, aNick.split("!", 1)[0], "AVAILABLE"))
+        .every(aResult => aResult);
+    },
+
+    731(aMessage) {
+      // RPL_MONOFFLINE
+      // :<server> 731 <nick> :nick[,nick1]*
+      return aMessage.params[1]
+        .split(",")
+        .map(aNick => setStatus(this, aNick, "OFFLINE"))
+        .every(aResult => aResult);
+    },
+
+    732(aMessage) {
+      // RPL_MONLIST
+      // :<server> 732 <nick> :nick[,nick1]*
+      return false;
+    },
+
+    733(aMessage) {
+      // RPL_ENDOFMONLIST
+      // :<server> 733 <nick> :End of MONITOR list
+      return false;
+    },
+
+    734(aMessage) {
+      // ERR_MONLISTFULL
+      // :<server> 734 <nick> <limit> <nicks> :Monitor list is full.
+      this.ERROR(
+        "Maximum size for MONITOR list exceeded (" + this.params[1] + ")."
+      );
+      return true;
+    },
+  },
+};
diff --git a/comm/chat/protocols/irc/jar.mn b/comm/chat/protocols/irc/jar.mn
new file mode 100644
index 0000000000..4ef677131e
--- /dev/null
+++ b/comm/chat/protocols/irc/jar.mn
@@ -0,0 +1,9 @@
+# This Source Code Form is subject to the terms of the Mozilla Public
+# License, v. 2.0. If a copy of the MPL was not distributed with this
+# file, You can obtain one at http://mozilla.org/MPL/2.0/.
+
+chat.jar:
+% skin prpl-irc classic/1.0 %skin/classic/prpl/irc/
+	skin/classic/prpl/irc/icon32.png	(icons/prpl-irc-32.png)
+	skin/classic/prpl/irc/icon48.png	(icons/prpl-irc-48.png)
+	skin/classic/prpl/irc/icon.png	(icons/prpl-irc.png)
diff --git a/comm/chat/protocols/irc/moz.build b/comm/chat/protocols/irc/moz.build
new file mode 100644
index 0000000000..8e72a57f4e
--- /dev/null
+++ b/comm/chat/protocols/irc/moz.build
@@ -0,0 +1,33 @@
+# vim: set filetype=python:
+# This Source Code Form is subject to the terms of the Mozilla Public
+# License, v. 2.0. If a copy of the MPL was not distributed with this
+# file, You can obtain one at http://mozilla.org/MPL/2.0/.
+
+XPCSHELL_TESTS_MANIFESTS += ["test/xpcshell.ini"]
+
+EXTRA_JS_MODULES += [
+    "irc.sys.mjs",
+    "ircAccount.sys.mjs",
+    "ircBase.sys.mjs",
+    "ircCAP.sys.mjs",
+    "ircCommands.sys.mjs",
+    "ircCTCP.sys.mjs",
+    "ircDCC.sys.mjs",
+    "ircEchoMessage.sys.mjs",
+    "ircHandlerPriorities.sys.mjs",
+    "ircHandlers.sys.mjs",
+    "ircISUPPORT.sys.mjs",
+    "ircMultiPrefix.sys.mjs",
+    "ircNonStandard.sys.mjs",
+    "ircSASL.sys.mjs",
+    "ircServerTime.sys.mjs",
+    "ircServices.sys.mjs",
+    "ircUtils.sys.mjs",
+    "ircWatchMonitor.sys.mjs",
+]
+
+JAR_MANIFESTS += ["jar.mn"]
+
+XPCOM_MANIFESTS += [
+    "components.conf",
+]
diff --git a/comm/chat/protocols/irc/test/test_ctcpColoring.js b/comm/chat/protocols/irc/test/test_ctcpColoring.js
new file mode 100644
index 0000000000..2875bdff36
--- /dev/null
+++ b/comm/chat/protocols/irc/test/test_ctcpColoring.js
@@ -0,0 +1,72 @@
+/* Any copyright is dedicated to the Public Domain.
+ * http://creativecommons.org/publicdomain/zero/1.0/ */
+
+var { ctcpFormatToText, ctcpFormatToHTML } = ChromeUtils.importESModule(
+  "resource:///modules/ircUtils.sys.mjs"
+);
+
+var input = [
+  // From http://www.mirc.com/colors.html
+  "\x035,12colored text and background\x03",
+  "\x035colored text\x03",
+  "\x033colored text \x035,2more colored text and background\x03",
+  "\x033,5colored text and background \x038other colored text but same background\x03",
+  "\x033,5colored text and background \x038,7other colored text and different background\x03",
+
+  // Based on above, but more complicated.
+  "\x02\x035,12colored \x1Ftext and background\x03. You sure about this?",
+
+  // Implied by above.
+  "So a \x03,8 attribute is not valid and thus ignored.",
+
+  // Try some of the above with two digits.
+  "\x0303,5colored text and background \x0308other colored text but same background\x03",
+  "\x0303,05colored text and background \x038,7other colored text and different background\x03",
+];
+
+function run_test() {
+  add_test(test_mIRCColoring);
+  add_test(test_ctcpFormatToText);
+
+  run_next_test();
+}
+
+function test_mIRCColoring() {
+  let expectedOutput = [
+    '<font color="maroon" background="blue">colored text and background</font>',
+    '<font color="maroon">colored text</font>',
+    '<font color="green">colored text <font color="maroon" background="navy">more colored text and background</font></font>',
+    '<font color="green" background="maroon">colored text and background <font color="yellow">other colored text but same background</font></font>',
+    '<font color="green" background="maroon">colored text and background <font color="yellow" background="orange">other colored text and different background</font></font>',
+    '<b><font color="maroon" background="blue">colored <u>text and background</u></font><u>. You sure about this?</u></b>',
+    "So a ,8 attribute is not valid and thus ignored.",
+    '<font color="green" background="maroon">colored text and background <font color="yellow">other colored text but same background</font></font>',
+    '<font color="green" background="maroon">colored text and background <font color="yellow" background="orange">other colored text and different background</font></font>',
+  ];
+
+  for (let i = 0; i < input.length; i++) {
+    equal(expectedOutput[i], ctcpFormatToHTML(input[i]));
+  }
+
+  run_next_test();
+}
+
+function test_ctcpFormatToText() {
+  let expectedOutput = [
+    "colored text and background",
+    "colored text",
+    "colored text more colored text and background",
+    "colored text and background other colored text but same background",
+    "colored text and background other colored text and different background",
+    "colored text and background. You sure about this?",
+    "So a ,8 attribute is not valid and thus ignored.",
+    "colored text and background other colored text but same background",
+    "colored text and background other colored text and different background",
+  ];
+
+  for (let i = 0; i < input.length; i++) {
+    equal(expectedOutput[i], ctcpFormatToText(input[i]));
+  }
+
+  run_next_test();
+}
diff --git a/comm/chat/protocols/irc/test/test_ctcpDequote.js b/comm/chat/protocols/irc/test/test_ctcpDequote.js
new file mode 100644
index 0000000000..1a1e7fcc9d
--- /dev/null
+++ b/comm/chat/protocols/irc/test/test_ctcpDequote.js
@@ -0,0 +1,55 @@
+/* Any copyright is dedicated to the Public Domain.
+ * http://creativecommons.org/publicdomain/zero/1.0/ */
+
+var { CTCPMessage } = ChromeUtils.importESModule(
+  "resource:///modules/ircCTCP.sys.mjs"
+);
+
+var input = [
+  "ACTION",
+  "ACTION test",
+  "ACTION \x5Ctest",
+  "ACTION te\x5Cst",
+  "ACTION test\x5C",
+  "ACTION \x5C\x5Ctest",
+  "ACTION te\x5C\x5Cst",
+  "ACTION test\x5C\x5C",
+  "ACTION \x5C\x5C\x5Ctest",
+  "ACTION te\x5C\x5C\x5Cst",
+  "ACTION test\x5C\x5C\x5C",
+  "ACTION \x5Catest",
+  "ACTION te\x5Cast",
+  "ACTION test\x5Ca",
+  "ACTION \x5C\x5C\x5Catest",
+  "ACTION \x5C\x5Catest",
+];
+
+var expectedOutputParam = [
+  "",
+  "test",
+  "test",
+  "test",
+  "test",
+  "\x5Ctest",
+  "te\x5Cst",
+  "test\x5C",
+  "\x5Ctest",
+  "te\x5Cst",
+  "test\x5C",
+  "\x01test",
+  "te\x01st",
+  "test\x01",
+  "\x5C\x01test",
+  "\x5Catest",
+];
+
+function run_test() {
+  let output = input.map(aStr => CTCPMessage({}, aStr));
+  // Ensure both arrays have the same length.
+  equal(expectedOutputParam.length, output.length);
+  // Ensure the values in the arrays are equal.
+  for (let i = 0; i < output.length; ++i) {
+    equal(expectedOutputParam[i], output[i].ctcp.param);
+    equal("ACTION", output[i].ctcp.command);
+  }
+}
diff --git a/comm/chat/protocols/irc/test/test_ctcpFormatting.js b/comm/chat/protocols/irc/test/test_ctcpFormatting.js
new file mode 100644
index 0000000000..022b194d4c
--- /dev/null
+++ b/comm/chat/protocols/irc/test/test_ctcpFormatting.js
@@ -0,0 +1,59 @@
+/* Any copyright is dedicated to the Public Domain.
+ * http://creativecommons.org/publicdomain/zero/1.0/ */
+
+var { ctcpFormatToText, ctcpFormatToHTML } = ChromeUtils.importESModule(
+  "resource:///modules/ircUtils.sys.mjs"
+);
+
+// TODO add a test for special JS characters (|, etc...)
+
+var input = [
+  "The quick brown fox \x02jumps\x02 over the lazy dog.",
+  "The quick brown fox \x02jumps\x0F over the lazy dog.",
+  "The quick brown \x16fox jumps\x16 over the lazy dog.",
+  "The quick brown \x16fox jumps\x0F over the lazy dog.",
+  "The quick \x1Fbrown fox jumps over the lazy\x1F dog.",
+  "The quick \x1Fbrown fox jumps over the lazy\x0F dog.",
+  "The quick \x1Fbrown fox \x02jumps over the lazy\x1F dog.",
+  "The quick \x1Fbrown fox \x02jumps\x1F over the lazy\x02 dog.",
+  "The quick \x1Fbrown \x16fox \x02jumps\x1F over\x16 the lazy\x02 dog.",
+  "The quick \x1Fbrown \x16fox \x02jumps\x0F over \x16the lazy \x02dog.",
+];
+
+function run_test() {
+  add_test(test_ctcpFormatToHTML);
+  add_test(test_ctcpFormatToText);
+
+  run_next_test();
+}
+
+function test_ctcpFormatToHTML() {
+  let expectedOutput = [
+    "The quick brown fox <b>jumps</b> over the lazy dog.",
+    "The quick brown fox <b>jumps</b> over the lazy dog.",
+    "The quick brown <i>fox jumps</i> over the lazy dog.",
+    "The quick brown <i>fox jumps</i> over the lazy dog.",
+    "The quick <u>brown fox jumps over the lazy</u> dog.",
+    "The quick <u>brown fox jumps over the lazy</u> dog.",
+    "The quick <u>brown fox <b>jumps over the lazy</b></u><b> dog.</b>",
+    "The quick <u>brown fox <b>jumps</b></u><b> over the lazy</b> dog.",
+    "The quick <u>brown <i>fox <b>jumps</b></i></u><i><b> over</b></i><b> the lazy</b> dog.",
+    "The quick <u>brown <i>fox <b>jumps</b></i></u> over <i>the lazy <b>dog.</b></i>",
+  ];
+
+  for (let i = 0; i < input.length; i++) {
+    equal(expectedOutput[i], ctcpFormatToHTML(input[i]));
+  }
+
+  run_next_test();
+}
+
+function test_ctcpFormatToText() {
+  let expectedOutput = "The quick brown fox jumps over the lazy dog.";
+
+  for (let i = 0; i < input.length; ++i) {
+    equal(expectedOutput, ctcpFormatToText(input[i]));
+  }
+
+  run_next_test();
+}
diff --git a/comm/chat/protocols/irc/test/test_ctcpQuote.js b/comm/chat/protocols/irc/test/test_ctcpQuote.js
new file mode 100644
index 0000000000..0c919236b9
--- /dev/null
+++ b/comm/chat/protocols/irc/test/test_ctcpQuote.js
@@ -0,0 +1,64 @@
+/* Any copyright is dedicated to the Public Domain.
+ * http://creativecommons.org/publicdomain/zero/1.0/ */
+
+var { ircAccount } = ChromeUtils.importESModule(
+  "resource:///modules/ircAccount.sys.mjs"
+);
+
+var input = [
+  undefined,
+  "test",
+  "\\test",
+  "te\\st",
+  "test\\",
+  "\\\\test",
+  "te\\\\st",
+  "test\\\\",
+  "\\\\\\test",
+  "te\\\\\\st",
+  "test\\\\\\",
+  "\x01test",
+  "te\x01st",
+  "test\x01",
+  "\\\\\x01test",
+  "\\\\atest",
+];
+
+var expectedOutputParams = [
+  "ACTION",
+  "ACTION test",
+  "ACTION \\\\test",
+  "ACTION te\\\\st",
+  "ACTION test\\\\",
+  "ACTION \\\\\\\\test",
+  "ACTION te\\\\\\\\st",
+  "ACTION test\\\\\\\\",
+  "ACTION \\\\\\\\\\\\test",
+  "ACTION te\\\\\\\\\\\\st",
+  "ACTION test\\\\\\\\\\\\",
+  "ACTION \\atest",
+  "ACTION te\\ast",
+  "ACTION test\\a",
+  "ACTION \\\\\\\\\\atest",
+  "ACTION \\\\\\\\atest",
+];
+
+var outputParams = [];
+
+ircAccount.prototype.sendMessage = function (aCommand, aParams) {
+  equal("PRIVMSG", aCommand);
+  outputParams.push(aParams[1]);
+};
+
+function run_test() {
+  input.map(aStr =>
+    ircAccount.prototype.sendCTCPMessage("", false, "ACTION", aStr)
+  );
+
+  // Ensure both arrays have the same length.
+  equal(expectedOutputParams.length, outputParams.length);
+  // Ensure the values in the arrays are equal.
+  for (let i = 0; i < outputParams.length; ++i) {
+    equal("\x01" + expectedOutputParams[i] + "\x01", outputParams[i]);
+  }
+}
diff --git a/comm/chat/protocols/irc/test/test_ircCAP.js b/comm/chat/protocols/irc/test/test_ircCAP.js
new file mode 100644
index 0000000000..a79a926efc
--- /dev/null
+++ b/comm/chat/protocols/irc/test/test_ircCAP.js
@@ -0,0 +1,236 @@
+/* Any copyright is dedicated to the Public Domain.
+ * http://creativecommons.org/publicdomain/zero/1.0/ */
+
+var { capMessage } = ChromeUtils.importESModule(
+  "resource:///modules/ircCAP.sys.mjs"
+);
+
+var testData = [
+  // A normal LS from the server.
+  [
+    ["*", "LS", "multi-prefix sasl userhost-in-names"],
+    [
+      {
+        subcommand: "LS",
+        parameter: "multi-prefix",
+      },
+      {
+        subcommand: "LS",
+        parameter: "sasl",
+      },
+      {
+        subcommand: "LS",
+        parameter: "userhost-in-names",
+      },
+    ],
+  ],
+
+  // LS with both valid and invalid vendor specific capabilities.
+  [
+    [
+      "*",
+      "LS",
+      "sasl server-time znc.in/server-time-iso znc.in/playback palaverapp.com",
+    ],
+    [
+      {
+        subcommand: "LS",
+        parameter: "sasl",
+      },
+      {
+        subcommand: "LS",
+        parameter: "server-time",
+      },
+      // Valid vendor prefixes (of the form <domain name>/<capability>).
+      {
+        subcommand: "LS",
+        parameter: "znc.in/server-time-iso",
+      },
+      {
+        subcommand: "LS",
+        parameter: "znc.in/playback",
+      },
+      // Invalid vendor prefix, but we should treat it as an opaque identifier.
+      {
+        subcommand: "LS",
+        parameter: "palaverapp.com",
+      },
+    ],
+  ],
+
+  // Some implementations include one less parameter.
+  [
+    ["LS", "sasl"],
+    [
+      {
+        subcommand: "LS",
+        parameter: "sasl",
+      },
+    ],
+  ],
+
+  // Modifier tests, ensure the modified is stripped from the capaibility and is
+  // parsed correctly.
+  [
+    ["LS", "-disable =sticky ~ack"],
+    [
+      {
+        subcommand: "LS",
+        parameter: "disable",
+        modifier: "-",
+        disable: true,
+      },
+      {
+        subcommand: "LS",
+        parameter: "sticky",
+        modifier: "=",
+        sticky: true,
+      },
+      {
+        subcommand: "LS",
+        parameter: "ack",
+        modifier: "~",
+        ack: true,
+      },
+    ],
+  ],
+
+  // IRC v3.2 multi-line LS response
+  [
+    ["*", "LS", "*", "sasl"],
+    ["*", "LS", "server-time"],
+    [
+      {
+        subcommand: "LS",
+        parameter: "sasl",
+      },
+      {
+        subcommand: "LS",
+        parameter: "server-time",
+      },
+    ],
+  ],
+
+  // IRC v3.2 multi-line LIST response
+  [
+    ["*", "LIST", "*", "sasl"],
+    ["*", "LIST", "server-time"],
+    [
+      {
+        subcommand: "LIST",
+        parameter: "sasl",
+      },
+      {
+        subcommand: "LIST",
+        parameter: "server-time",
+      },
+    ],
+  ],
+
+  // IRC v3.2 cap value
+  [
+    ["*", "LS", "multi-prefix sasl=EXTERNAL sts=port=6697"],
+    [
+      {
+        subcommand: "LS",
+        parameter: "multi-prefix",
+      },
+      {
+        subcommand: "LS",
+        parameter: "sasl",
+        value: "EXTERNAL",
+      },
+      {
+        subcommand: "LS",
+        parameter: "sts",
+        value: "port=6697",
+      },
+    ],
+  ],
+
+  // cap-notify new cap
+  [
+    ["*", "NEW", "batch"],
+    [
+      {
+        subcommand: "NEW",
+        parameter: "batch",
+      },
+    ],
+  ],
+
+  // cap-notify delete cap
+  [
+    ["*", "DEL", "multi-prefix"],
+    [
+      {
+        subcommand: "DEL",
+        parameter: "multi-prefix",
+      },
+    ],
+  ],
+];
+
+function run_test() {
+  add_test(testCapMessages);
+
+  run_next_test();
+}
+
+/*
+ * Test round tripping parsing and then rebuilding the messages from RFC 2812.
+ */
+function testCapMessages() {
+  for (let data of testData) {
+    // Generate an ircMessage to send into capMessage.
+    let i = 0;
+    let message;
+    let outputs;
+    const account = {
+      _queuedCAPs: [],
+    };
+
+    // Generate an ircMessage to send into capMessage.
+    while (typeof data[i][0] == "string") {
+      message = {
+        params: data[i],
+      };
+
+      // Create the CAP message.
+      outputs = capMessage(message, account);
+      ++i;
+    }
+
+    // The original message should get a cap object added with the subcommand
+    // set.
+    ok(message.cap);
+    equal(message.cap.subcommand, data[i][0].subcommand);
+
+    // We only care about the "cap" part of each return message.
+    outputs = outputs.map(o => o.cap);
+
+    // Ensure the expected output is an array.
+    let expectedCaps = data[i];
+    if (!Array.isArray(expectedCaps)) {
+      expectedCaps = [expectedCaps];
+    }
+
+    // Add defaults to the expected output.
+    for (let expectedCap of expectedCaps) {
+      // By default there's no modifier.
+      if (!("modifier" in expectedCap)) {
+        expectedCap.modifier = undefined;
+      }
+      for (let param of ["disable", "sticky", "ack"]) {
+        if (!(param in expectedCap)) {
+          expectedCap[param] = false;
+        }
+      }
+    }
+
+    // Ensure each item in the arrays are equal.
+    deepEqual(outputs, expectedCaps);
+  }
+
+  run_next_test();
+}
diff --git a/comm/chat/protocols/irc/test/test_ircChannel.js b/comm/chat/protocols/irc/test/test_ircChannel.js
new file mode 100644
index 0000000000..eb8b04dcc7
--- /dev/null
+++ b/comm/chat/protocols/irc/test/test_ircChannel.js
@@ -0,0 +1,187 @@
+/* Any copyright is dedicated to the Public Domain.
+ * http://creativecommons.org/publicdomain/zero/1.0/ */
+
+var { ircChannel } = ChromeUtils.importESModule(
+  "resource:///modules/ircAccount.sys.mjs"
+);
+
+function waitForTopic(target, targetTopic) {
+  return new Promise(resolve => {
+    let observer = {
+      observe(subject, topic, data) {
+        if (topic === targetTopic) {
+          resolve({ subject, data });
+          target.removeObserver(observer);
+        }
+      },
+    };
+    target.addObserver(observer);
+  });
+}
+
+function getChannel(account) {
+  const channelStub = {
+    _observers: [],
+    _name: "#test",
+    _account: {
+      _currentServerName: "test",
+      imAccount: {
+        statusInfo: {},
+      },
+      _nickname: "user",
+      _activeCAPs: new Set(),
+      ...account,
+    },
+  };
+  Object.setPrototypeOf(channelStub, ircChannel.prototype);
+  return channelStub;
+}
+
+add_task(async function test_dispatchMessage_normal() {
+  let didSend = false;
+  const channelStub = getChannel({
+    sendMessage(type, data) {
+      equal(type, "PRIVMSG");
+      deepEqual(data, ["#test", "foo"]);
+      didSend = true;
+      return true;
+    },
+  });
+  const newText = waitForTopic(channelStub, "new-text");
+  channelStub.dispatchMessage("foo");
+  ok(didSend);
+  const { subject: sentMessage } = await newText;
+  equal(sentMessage.message, "foo");
+  ok(sentMessage.outgoing);
+  ok(!sentMessage.notification);
+  equal(sentMessage.who, "user");
+});
+
+add_task(async function test_dispatchMessage_empty() {
+  let didSend = false;
+  const channelStub = getChannel({
+    sendMessage(type, data) {
+      ok(false, "Should not send empty message");
+      didSend = true;
+      return true;
+    },
+  });
+  channelStub.writeMessage = () => {
+    ok(false, "Should not display empty unsent message");
+    didSend = true;
+  };
+  ircChannel.prototype.dispatchMessage.call(channelStub, "");
+  ok(!didSend);
+});
+
+add_task(async function test_dispatchMessage_echoed() {
+  let didSend = false;
+  let didWrite = false;
+  const channelStub = getChannel({
+    sendMessage(type, data) {
+      equal(type, "PRIVMSG");
+      deepEqual(data, ["#test", "foo"]);
+      didSend = true;
+      return true;
+    },
+  });
+  channelStub._account._activeCAPs.add("echo-message");
+  channelStub.writeMessage = () => {
+    ok(false, "Should not write message when echo is on");
+    didWrite = true;
+  };
+  ircChannel.prototype.dispatchMessage.call(channelStub, "foo");
+  ok(didSend);
+  ok(!didWrite);
+});
+
+add_task(async function test_dispatchMessage_error() {
+  let didSend = false;
+  const channelStub = getChannel({
+    sendMessage(type, data) {
+      equal(type, "PRIVMSG");
+      deepEqual(data, ["#test", "foo"]);
+      didSend = true;
+      return false;
+    },
+  });
+  const newText = waitForTopic(channelStub, "new-text");
+  ircChannel.prototype.dispatchMessage.call(channelStub, "foo");
+  ok(didSend);
+  const { subject: writtenMessage } = await newText;
+  ok(writtenMessage.error);
+  ok(writtenMessage.system);
+  equal(writtenMessage.who, "test");
+});
+
+add_task(async function test_dispatchMessage_action() {
+  let didSend = false;
+  const channelStub = getChannel({
+    sendMessage(type, data) {
+      ok(false, "Action should not be sent as normal message");
+      return false;
+    },
+    sendCTCPMessage(target, isNotice, command, params) {
+      equal(target, "#test");
+      ok(!isNotice);
+      equal(command, "ACTION");
+      equal(params, "foo");
+      didSend = true;
+      return true;
+    },
+  });
+  const newText = waitForTopic(channelStub, "new-text");
+  ircChannel.prototype.dispatchMessage.call(channelStub, "foo", true);
+  ok(didSend);
+  const { subject: sentMessage } = await newText;
+  equal(sentMessage.message, "foo");
+  ok(sentMessage.outgoing);
+  ok(!sentMessage.notification);
+  ok(sentMessage.action);
+  equal(sentMessage.who, "user");
+});
+
+add_task(async function test_dispatchMessage_actionError() {
+  let didSend = false;
+  const channelStub = getChannel({
+    sendMessage(type, data) {
+      ok(false, "Action should not be sent as normal message");
+      return false;
+    },
+    sendCTCPMessage(target, isNotice, command, params) {
+      equal(target, "#test");
+      ok(!isNotice);
+      equal(command, "ACTION");
+      equal(params, "foo");
+      didSend = true;
+      return false;
+    },
+  });
+  const newText = waitForTopic(channelStub, "new-text");
+  ircChannel.prototype.dispatchMessage.call(channelStub, "foo", true);
+  ok(didSend, "Message was sent");
+  const { subject: sentMessage } = await newText;
+  ok(sentMessage.error, "Shown message is error");
+  ok(sentMessage.system, "Shown message is from system");
+  equal(sentMessage.who, "test");
+});
+
+add_task(async function test_dispatchMessage_notice() {
+  let didSend = false;
+  const channelStub = getChannel({
+    sendMessage(type, data) {
+      equal(type, "NOTICE");
+      deepEqual(data, ["#test", "foo"]);
+      didSend = true;
+      return true;
+    },
+  });
+  const newText = waitForTopic(channelStub, "new-text");
+  ircChannel.prototype.dispatchMessage.call(channelStub, "foo", false, true);
+  ok(didSend);
+  const { subject: sentMessage } = await newText;
+  equal(sentMessage.message, "foo");
+  ok(sentMessage.outgoing);
+  ok(sentMessage.notification);
+  equal(sentMessage.who, "user");
+});
diff --git a/comm/chat/protocols/irc/test/test_ircCommands.js b/comm/chat/protocols/irc/test/test_ircCommands.js
new file mode 100644
index 0000000000..4bd6ab2954
--- /dev/null
+++ b/comm/chat/protocols/irc/test/test_ircCommands.js
@@ -0,0 +1,218 @@
+/* Any copyright is dedicated to the Public Domain.
+ * http://creativecommons.org/publicdomain/zero/1.0/ */
+
+var { IMServices } = ChromeUtils.importESModule(
+  "resource:///modules/IMServices.sys.mjs"
+);
+var { commands } = ChromeUtils.importESModule(
+  "resource:///modules/ircCommands.sys.mjs"
+);
+var { ircProtocol } = ChromeUtils.importESModule(
+  "resource:///modules/irc.sys.mjs"
+);
+var { ircAccount, ircConversation } = ChromeUtils.importESModule(
+  "resource:///modules/ircAccount.sys.mjs"
+);
+
+// Ensure the commands have been initialized.
+IMServices.conversations.initConversations();
+
+var fakeProto = {
+  id: "fake-proto",
+  usernameSplits: ircProtocol.prototype.usernameSplits,
+  splitUsername: ircProtocol.prototype.splitUsername,
+};
+
+function run_test() {
+  add_test(testUserModeCommand);
+  add_test(testModeCommand);
+  run_next_test();
+}
+
+// Test the /mode command.
+function testModeCommand() {
+  const testChannelCommands = [
+    {
+      msg: "",
+      channel: "#instantbird",
+      expectedMessage: "MODE #instantbird",
+    },
+    {
+      msg: "#instantbird",
+      channel: "#instantbird",
+      expectedMessage: "MODE #instantbird",
+    },
+    {
+      msg: "-s",
+      channel: "#Fins",
+      expectedMessage: "MODE #Fins -s",
+    },
+    {
+      msg: "#introduction +is",
+      channel: "#introduction",
+      expectedMessage: "MODE #introduction +is",
+    },
+    {
+      msg: "-s",
+      channel: "&Gills",
+      expectedMessage: "MODE &Gills -s",
+    },
+    {
+      msg: "#Gamers +o KennyS",
+      channel: "#Gamers",
+      expectedMessage: "MODE #Gamers +o KennyS",
+    },
+    {
+      msg: "+o lisp",
+      channel: "&IB",
+      expectedMessage: "MODE &IB +o lisp",
+    },
+    {
+      msg: "+b nick!abc@server",
+      channel: "#Alphabet",
+      expectedMessage: "MODE #Alphabet +b nick!abc@server",
+    },
+    {
+      msg: "+b nick",
+      channel: "#Alphabet",
+      expectedMessage: "MODE #Alphabet +b nick",
+    },
+    {
+      msg: "#instantbird +b nick!abc@server",
+      channel: "#instantbird",
+      expectedMessage: "MODE #instantbird +b nick!abc@server",
+    },
+    {
+      msg: "+v Wiz",
+      channel: "#TheMatrix",
+      expectedMessage: "MODE #TheMatrix +v Wiz",
+    },
+    {
+      msg: "+k passcode",
+      channel: "#TheMatrix",
+      expectedMessage: "MODE #TheMatrix +k passcode",
+    },
+    {
+      msg: "#Mafia +k keyword",
+      channel: "#Mafia",
+      expectedMessage: "MODE #Mafia +k keyword",
+    },
+    {
+      msg: "#introduction +l 100",
+      channel: "#introduction",
+      expectedMessage: "MODE #introduction +l 100",
+    },
+    {
+      msg: "+l 100",
+      channel: "#introduction",
+      expectedMessage: "MODE #introduction +l 100",
+    },
+  ];
+
+  const testUserCommands = [
+    {
+      msg: "nickolas +x",
+      expectedMessage: "MODE nickolas +x",
+    },
+    {
+      msg: "matrixisreal -x",
+      expectedMessage: "MODE matrixisreal -x",
+    },
+    {
+      msg: "matrixisreal_19 +oWp",
+      expectedMessage: "MODE matrixisreal_19 +oWp",
+    },
+    {
+      msg: "nick",
+      expectedMessage: "MODE nick",
+    },
+  ];
+
+  let account = new ircAccount(fakeProto, {
+    name: "defaultnick@instantbird.org",
+  });
+
+  // check if the message being sent is same as expected message.
+  account.sendRawMessage = aMessage => {
+    equal(aMessage, account._expectedMessage);
+  };
+
+  const command = _getRunCommand("mode");
+
+  // First test Channel Commands.
+  for (let test of testChannelCommands) {
+    let conv = new ircConversation(account, test.channel);
+    account._expectedMessage = test.expectedMessage;
+    command(test.msg, conv);
+  }
+
+  // Now test the User Commands.
+  let conv = new ircConversation(account, "dummyConversation");
+  account._nickname = "test_nick";
+  for (let test of testUserCommands) {
+    account._expectedMessage = test.expectedMessage;
+    command(test.msg, conv);
+  }
+
+  run_next_test();
+}
+
+// Test the /umode command.
+function testUserModeCommand() {
+  const testData = [
+    {
+      msg: "+x",
+      expectedMessage: "MODE test_nick +x",
+    },
+    {
+      msg: "-x",
+      expectedMessage: "MODE test_nick -x",
+    },
+    {
+      msg: "-pa",
+      expectedMessage: "MODE test_nick -pa",
+    },
+    {
+      msg: "+oWp",
+      expectedMessage: "MODE test_nick +oWp",
+    },
+    {
+      msg: "",
+      expectedMessage: "MODE test_nick",
+    },
+  ];
+
+  let account = new ircAccount(fakeProto, {
+    name: "test_nick@instantbird.org",
+  });
+  account._nickname = "test_nick";
+  let conv = new ircConversation(account, "newconv");
+
+  // check if the message being sent is same as expected message.
+  account.sendRawMessage = aMessage => {
+    equal(aMessage, account._expectedMessage);
+  };
+
+  const command = _getRunCommand("umode");
+
+  // change the nick and runUserModeCommand for each test
+  for (let test of testData) {
+    account._expectedMessage = test.expectedMessage;
+    command(test.msg, conv);
+  }
+
+  run_next_test();
+}
+
+// Fetch the run() of a named command.
+function _getRunCommand(aCommandName) {
+  for (let command of commands) {
+    if (command.name == aCommandName) {
+      return command.run;
+    }
+  }
+
+  // Fail if no command was found.
+  ok(false, "Could not find the '" + aCommandName + "' command.");
+  return null; // Shut-up eslint.
+}
diff --git a/comm/chat/protocols/irc/test/test_ircMessage.js b/comm/chat/protocols/irc/test/test_ircMessage.js
new file mode 100644
index 0000000000..4420856c84
--- /dev/null
+++ b/comm/chat/protocols/irc/test/test_ircMessage.js
@@ -0,0 +1,336 @@
+/* Any copyright is dedicated to the Public Domain.
+ * http://creativecommons.org/publicdomain/zero/1.0/ */
+
+var { ircAccount, ircMessage } = ChromeUtils.importESModule(
+  "resource:///modules/ircAccount.sys.mjs"
+);
+
+var testData = [
+  // First off, let's test the messages from RFC 2812.
+  "PASS secretpasswordhere",
+  "NICK Wiz",
+  ":WiZ!jto@tolsun.oulu.fi NICK Kilroy",
+  "USER guest 0 * :Ronnie Reagan",
+  "USER guest 8 * :Ronnie Reagan",
+  "OPER foo bar",
+  "MODE WiZ -w",
+  "MODE Angel +i",
+  "MODE WiZ -o",
+  "SERVICE dict * *.fr 0 0 :French Dictionary",
+  "QUIT :Gone to have lunch",
+  ":syrk!kalt@millennium.stealth.net QUIT :Gone to have lunch",
+  "SQUIT tolsun.oulu.fi :Bad Link ?",
+  ":Trillian SQUIT cm22.eng.umd.edu :Server out of control",
+  "JOIN #foobar",
+  "JOIN &foo fubar",
+  "JOIN #foo,&bar fubar",
+  "JOIN #foo,#bar fubar,foobar",
+  "JOIN #foo,#bar",
+  "JOIN 0",
+  ":WiZ!jto@tolsun.oulu.fi JOIN #Twilight_zone",
+  "PART #twilight_zone",
+  "PART #oz-ops,&group5",
+  ":WiZ!jto@tolsun.oulu.fi PART #playzone :I lost",
+  "MODE #Finnish +imI *!*@*.fi",
+  "MODE #Finnish +o Kilroy",
+  "MODE #Finnish +v Wiz",
+  "MODE #Fins -s",
+  "MODE #42 +k oulu",
+  "MODE #42 -k oulu",
+  "MODE #eu-opers +l 10",
+  ":WiZ!jto@tolsun.oulu.fi MODE #eu-opers -l",
+  "MODE &oulu +b",
+  "MODE &oulu +b *!*@*",
+  "MODE &oulu +b *!*@*.edu +e *!*@*.bu.edu",
+  "MODE #bu +be *!*@*.edu *!*@*.bu.edu",
+  "MODE #meditation e",
+  "MODE #meditation I",
+  "MODE !12345ircd O",
+  ":WiZ!jto@tolsun.oulu.fi TOPIC #test :New topic",
+  "TOPIC #test :another topic",
+  "TOPIC #test :",
+  "TOPIC #test",
+  "NAMES #twilight_zone,#42",
+  "NAMES",
+  "LIST",
+  "LIST #twilight_zone,#42",
+  ":Angel!wings@irc.org INVITE Wiz #Dust",
+  "INVITE Wiz #Twilight_Zone",
+  "KICK &Melbourne Matthew",
+  "KICK #Finnish John :Speaking English",
+  ":WiZ!jto@tolsun.oulu.fi KICK #Finnish John",
+  ":Angel!wings@irc.org PRIVMSG Wiz :Are you receiving this message ?",
+  "PRIVMSG Angel :yes I'm receiving it !",
+  "PRIVMSG jto@tolsun.oulu.fi :Hello !",
+  "PRIVMSG kalt%millennium.stealth.net@irc.stealth.net :Are you a frog?",
+  "PRIVMSG kalt%millennium.stealth.net :Do you like cheese?",
+  "PRIVMSG Wiz!jto@tolsun.oulu.fi :Hello !",
+  "PRIVMSG $*.fi :Server tolsun.oulu.fi rebooting.",
+  "PRIVMSG #*.edu :NSFNet is undergoing work, expect interruptions",
+  "VERSION tolsun.oulu.fi",
+  "STATS m",
+  "LINKS *.au",
+  "LINKS *.edu *.bu.edu",
+  "TIME tolsun.oulu.fi",
+  "CONNECT tolsun.oulu.fi 6667",
+  "TRACE *.oulu.fi",
+  "ADMIN tolsun.oulu.fi",
+  "ADMIN syrk",
+  "INFO csd.bu.edu",
+  "INFO Angel",
+  "SQUERY irchelp :HELP privmsg",
+  "SQUERY dict@irc.fr :fr2en blaireau",
+  "WHO *.fi",
+  "WHO jto* o",
+  "WHOIS wiz",
+  "WHOIS eff.org trillian",
+  "WHOWAS Wiz",
+  "WHOWAS Mermaid 9",
+  "WHOWAS Trillian 1 *.edu",
+  "PING tolsun.oulu.fi",
+  "PING WiZ tolsun.oulu.fi",
+  // Below fails, we don't use the (unnecessary) colon.
+  // "PING :irc.funet.fi",
+  "PONG csd.bu.edu tolsun.oulu.fi",
+  "ERROR :Server *.fi already exists",
+  "NOTICE WiZ :ERROR from csd.bu.edu -- Server *.fi already exists",
+  "AWAY :Gone to lunch.  Back in 5",
+  "REHASH",
+  "DIE",
+  "RESTART",
+  "SUMMON jto",
+  "SUMMON jto tolsun.oulu.fi",
+  "USERS eff.org",
+  ":csd.bu.edu WALLOPS :Connect '*.uiuc.edu 6667' from Joshua",
+  "USERHOST Wiz Michael syrk",
+  // Below fails, we don't use the (unnecessary) colon.
+  // ":ircd.stealth.net 302 yournick :syrk=+syrk@millennium.stealth.net",
+  "ISON phone trillian WiZ jarlek Avalon Angel Monstah syrk",
+
+  // Now for the torture test, specially crafted messages that might be
+  // "difficult" to handle.
+  "PRIVMSG foo ::)", // Test sending a colon as the first character.
+  "PRIVMSG foo :This is a test.", // Test sending a space.
+  "PRIVMSG foo :", // Empty last parameter.
+  "PRIVMSG foo :This is :a test.", // A "second" last parameter.
+];
+
+function run_test() {
+  add_test(testRFC2812Messages);
+  add_test(testBrokenUnrealMessages);
+  add_test(testNewLinesInMessages);
+  add_test(testLocalhost);
+  add_test(testTags);
+
+  run_next_test();
+}
+
+/*
+ * Test round tripping parsing and then rebuilding the messages from RFC 2812.
+ */
+function testRFC2812Messages() {
+  for (let expectedStringMessage of testData) {
+    // Pass in an empty default origin in order to check this below.
+    let message = ircMessage(expectedStringMessage, "");
+
+    let stringMessage = ircAccount.prototype.buildMessage(
+      message.command,
+      message.params
+    );
+
+    // Let's do a little dance here...we don't rebuild the "source" of the
+    // message (the server does that), so when comparing our output message, we
+    // need to avoid comparing to that part.
+    if (message.origin) {
+      expectedStringMessage = expectedStringMessage.slice(
+        expectedStringMessage.indexOf(" ") + 1
+      );
+    }
+
+    equal(stringMessage, expectedStringMessage);
+  }
+
+  run_next_test();
+}
+
+// Unreal sends a couple of broken messages, see ircMessage in irc.jsm for a
+// description of what's wrong.
+function testBrokenUnrealMessages() {
+  let messages = {
+    // Two spaces after command.
+    ":gravel.mozilla.org 432  #momo :Erroneous Nickname: Illegal characters": {
+      rawMessage:
+        ":gravel.mozilla.org 432  #momo :Erroneous Nickname: Illegal characters",
+      command: "432",
+      params: ["", "#momo", "Erroneous Nickname: Illegal characters"],
+      origin: "gravel.mozilla.org",
+      user: undefined,
+      host: undefined,
+      source: "",
+      tags: new Map(),
+    },
+    // An extraneous space at the end.
+    ":gravel.mozilla.org MODE #tckk +n ": {
+      rawMessage: ":gravel.mozilla.org MODE #tckk +n ",
+      command: "MODE",
+      params: ["#tckk", "+n"],
+      origin: "gravel.mozilla.org",
+      user: undefined,
+      host: undefined,
+      source: "",
+      tags: new Map(),
+    },
+    // Two extraneous spaces at the end.
+    ":services.esper.net MODE #foo-bar +o foobar  ": {
+      rawMessage: ":services.esper.net MODE #foo-bar +o foobar  ",
+      command: "MODE",
+      params: ["#foo-bar", "+o", "foobar"],
+      origin: "services.esper.net",
+      user: undefined,
+      host: undefined,
+      source: "",
+      tags: new Map(),
+    },
+  };
+
+  for (let messageStr in messages) {
+    deepEqual(messages[messageStr], ircMessage(messageStr, ""));
+  }
+
+  run_next_test();
+}
+
+// After unescaping we can end up with line breaks inside of IRC messages. Test
+// this edge case specifically.
+function testNewLinesInMessages() {
+  let messages = {
+    ":test!Instantbir@host PRIVMSG #instantbird :First line\nSecond line": {
+      rawMessage:
+        ":test!Instantbir@host PRIVMSG #instantbird :First line\nSecond line",
+      command: "PRIVMSG",
+      params: ["#instantbird", "First line\nSecond line"],
+      origin: "test",
+      user: "Instantbir",
+      host: "host",
+      tags: new Map(),
+      source: "Instantbir@host",
+    },
+    ":test!Instantbir@host PRIVMSG #instantbird :First line\r\nSecond line": {
+      rawMessage:
+        ":test!Instantbir@host PRIVMSG #instantbird :First line\r\nSecond line",
+      command: "PRIVMSG",
+      params: ["#instantbird", "First line\r\nSecond line"],
+      origin: "test",
+      user: "Instantbir",
+      host: "host",
+      tags: new Map(),
+      source: "Instantbir@host",
+    },
+  };
+
+  for (let messageStr in messages) {
+    deepEqual(messages[messageStr], ircMessage(messageStr));
+  }
+
+  run_next_test();
+}
+
+// Sometimes it is a bit hard to tell whether a prefix is a nickname or a
+// servername. Generally this happens when connecting to localhost or a local
+// hostname and is likely seen with bouncers.
+function testLocalhost() {
+  let messages = {
+    ":localhost 001 clokep :Welcome to the BitlBee gateway, clokep": {
+      rawMessage:
+        ":localhost 001 clokep :Welcome to the BitlBee gateway, clokep",
+      command: "001",
+      params: ["clokep", "Welcome to the BitlBee gateway, clokep"],
+      origin: "localhost",
+      user: undefined,
+      host: undefined,
+      tags: new Map(),
+      source: "",
+    },
+  };
+
+  for (let messageStr in messages) {
+    deepEqual(messages[messageStr], ircMessage(messageStr));
+  }
+
+  run_next_test();
+}
+
+function testTags() {
+  let messages = {
+    "@aaa=bBb;ccc;example.com/ddd=eee :nick!ident@host.com PRIVMSG me :Hello": {
+      rawMessage:
+        "@aaa=bBb;ccc;example.com/ddd=eee :nick!ident@host.com PRIVMSG me :Hello",
+      command: "PRIVMSG",
+      params: ["me", "Hello"],
+      origin: "nick",
+      user: "ident",
+      host: "host.com",
+      tags: new Map([
+        ["aaa", "bBb"],
+        ["ccc", undefined],
+        ["example.com/ddd", "eee"],
+      ]),
+      source: "ident@host.com",
+    },
+    "@xn--e1afmkfd.org/foo :nick@host.com PRIVMSG him :Test": {
+      rawMessage: "@xn--e1afmkfd.org/foo :nick@host.com PRIVMSG him :Test",
+      command: "PRIVMSG",
+      params: ["him", "Test"],
+      origin: "nick",
+      // Note that this is a bug, it should be undefined for user and host.com
+      // for host/source.
+      user: "host.com",
+      host: undefined,
+      tags: new Map([["xn--e1afmkfd.org/foo", undefined]]),
+      source: "host.com@undefined",
+    },
+    "@aaa=\\\\n\\:\\n\\r\\s :nick@host.com PRIVMSG it :Yes": {
+      rawMessage: "@aaa=\\\\n\\:\\n\\r\\s :nick@host.com PRIVMSG it :Yes",
+      command: "PRIVMSG",
+      params: ["it", "Yes"],
+      origin: "nick",
+      // Note that this is a bug, it should be undefined for user and host.com
+      // for host/source.
+      user: "host.com",
+      host: undefined,
+      tags: new Map([["aaa", "\\n;\n\r "]]),
+      source: "host.com@undefined",
+    },
+    "@c;h=;a=b :quux ab cd": {
+      rawMessage: "@c;h=;a=b :quux ab cd",
+      command: "ab",
+      params: ["cd"],
+      origin: "quux",
+      user: undefined,
+      host: undefined,
+      tags: new Map([
+        ["c", undefined],
+        ["h", ""],
+        ["a", "b"],
+      ]),
+      source: "",
+    },
+    "@time=2012-06-30T23:59:60.419Z :John!~john@1.2.3.4 JOIN #chan": {
+      rawMessage:
+        "@time=2012-06-30T23:59:60.419Z :John!~john@1.2.3.4 JOIN #chan",
+      command: "JOIN",
+      params: ["#chan"],
+      origin: "John",
+      user: "~john",
+      host: "1.2.3.4",
+      tags: new Map([["time", "2012-06-30T23:59:60.419Z"]]),
+      source: "~john@1.2.3.4",
+    },
+  };
+
+  for (let messageStr in messages) {
+    deepEqual(messages[messageStr], ircMessage(messageStr, ""));
+  }
+
+  run_next_test();
+}
diff --git a/comm/chat/protocols/irc/test/test_ircNonStandard.js b/comm/chat/protocols/irc/test/test_ircNonStandard.js
new file mode 100644
index 0000000000..bcc445e661
--- /dev/null
+++ b/comm/chat/protocols/irc/test/test_ircNonStandard.js
@@ -0,0 +1,209 @@
+/* Any copyright is dedicated to the Public Domain.
+ * http://creativecommons.org/publicdomain/zero/1.0/ */
+
+var { ircMessage } = ChromeUtils.importESModule(
+  "resource:///modules/ircAccount.sys.mjs"
+);
+const { ircNonStandard } = ChromeUtils.importESModule(
+  "resource:///modules/ircNonStandard.sys.mjs"
+);
+
+// The function that is under test here.
+var NOTICE = ircNonStandard.commands.NOTICE;
+
+function FakeConversation() {}
+FakeConversation.prototype = {
+  writeMessage(aSender, aTarget, aOpts) {},
+};
+
+function FakeAccount(aPassword) {
+  this.imAccount = {
+    password: aPassword,
+  };
+  this.buffer = [];
+  this.convs = [];
+}
+FakeAccount.prototype = {
+  connected: false,
+  shouldAuthenticate: undefined,
+  _nickname: "nick", // Can be anything except "auth" for most tests.
+  sendMessage(aCommand, aParams) {
+    this.buffer.push([aCommand, aParams]);
+  },
+  gotDisconnected(aReason, aMsg) {
+    this.connected = false;
+  },
+  getConversation(aName) {
+    this.convs.push(aName);
+    return new FakeConversation();
+  },
+};
+
+function run_test() {
+  add_test(testSecureList);
+  add_test(testZncAuth);
+  add_test(testUMich);
+  add_test(testAuthNick);
+  add_test(testIgnoredNotices);
+
+  run_next_test();
+}
+
+/*
+ * Test that SECURELIST properly sets the timer such that another LIST call can
+ * happen soon. See bug 1082501.
+ */
+function testSecureList() {
+  const kSecureListMsg =
+    ":fripp.mozilla.org NOTICE aleth-build :*** You cannot list within the first 60 seconds of connecting. Please try again later.";
+
+  let message = ircMessage(kSecureListMsg, "");
+  let account = new FakeAccount();
+  account.connected = true;
+  let result = NOTICE.call(account, message);
+
+  // Yes, it was handled.
+  ok(result);
+
+  // Undo the expected calculation, this should be near 0.
+  let value = account._lastListTime - Date.now() - 60000 + 12 * 60 * 60 * 1000;
+  // Give some wiggle room.
+  less(Math.abs(value), 5 * 1000);
+
+  run_next_test();
+}
+
+/*
+ * ZNC allows a client to send PASS after connection has occurred if it has not
+ * yet been provided. See bug 955244, bug 1197584.
+ */
+function testZncAuth() {
+  const kZncMsgs = [
+    ":irc.znc.in NOTICE AUTH :*** You need to send your password. Try /quote PASS <username>:<password>",
+    ":irc.znc.in NOTICE AUTH :*** You need to send your password. Configure your client to send a server password.",
+  ];
+
+  for (let msg of kZncMsgs) {
+    let message = ircMessage(msg, "");
+    // No provided password.
+    let account = new FakeAccount();
+    let result = NOTICE.call(account, message);
+
+    // Yes, it was handled.
+    Assert.ok(result);
+
+    // No sent data and parameters should be unchanged.
+    equal(account.buffer.length, 0);
+    equal(account.shouldAuthenticate, undefined);
+
+    // With a password.
+    account = new FakeAccount("password");
+    result = NOTICE.call(account, message);
+
+    // Yes, it was handled.
+    ok(result);
+
+    // Check if the proper message was sent.
+    let sent = account.buffer[0];
+    equal(sent[0], "PASS");
+    equal(sent[1], "password");
+    equal(account.buffer.length, 1);
+
+    // Don't try to authenticate with NickServ.
+    equal(account.shouldAuthenticate, false);
+
+    // Finally, check if the message is wrong.
+    account = new FakeAccount("password");
+    message.params[1] = "Test";
+    result = NOTICE.call(account, message);
+
+    // This would be handled as a normal NOTICE.
+    equal(result, false);
+  }
+
+  run_next_test();
+}
+
+/*
+ * irc.umich.edu sends a lot of garbage and has a non-standard captcha. See bug
+ * 954350.
+ */
+function testUMich() {
+  // The above should not print out.
+  const kMsgs = [
+    "NOTICE AUTH :*** Processing connection to irc.umich.edu",
+    "NOTICE AUTH :*** Looking up your hostname...",
+    "NOTICE AUTH :*** Checking Ident",
+    "NOTICE AUTH :*** Found your hostname",
+    "NOTICE AUTH :*** No Ident response",
+  ];
+
+  const kFinalMsg =
+    ':irc.umich.edu NOTICE clokep :To complete your connection to this server, type "/QUOTE PONG :cookie", where cookie is the following ascii.';
+
+  let account = new FakeAccount();
+  for (let msg of kMsgs) {
+    let message = ircMessage(msg, "");
+    let result = NOTICE.call(account, message);
+
+    // These initial notices are not handled (i.e. they'll be subject to
+    // _showServerTab).
+    equal(result, false);
+  }
+
+  // And finally the last one should be printed out, always. It contains the
+  // directions of what to do next.
+  let message = ircMessage(kFinalMsg, "");
+  let result = NOTICE.call(account, message);
+  ok(result);
+  equal(account.convs.length, 1);
+  equal(account.convs[0], "irc.umich.edu");
+
+  run_next_test();
+}
+
+/*
+ * Test an edge-case of the user having the nickname of auth. See bug 1083768.
+ */
+function testAuthNick() {
+  const kMsg =
+    ':irc.umich.edu NOTICE AUTH :To complete your connection to this server, type "/QUOTE PONG :cookie", where cookie is the following ascii.';
+
+  let account = new FakeAccount();
+  account._nickname = "AUTH";
+
+  let message = ircMessage(kMsg, "");
+  let result = NOTICE.call(account, message);
+
+  // Since it is ambiguous if it was an authentication message or a message
+  // directed at the user, print it out.
+  ok(result);
+
+  run_next_test();
+}
+
+/*
+ * We ignore some messages that are annoying to the user and offer little value.
+ * "Ignore" in this context means subject to the normal NOTICE processing.
+ */
+function testIgnoredNotices() {
+  const kMsgs = [
+    // moznet sends a welcome message which is useless.
+    ":levin.mozilla.org NOTICE Auth :Welcome to \u0002Mozilla\u0002!",
+    // Some servers (oftc) send a NOTICE that isn't an auth, but notifies about
+    // the connection. See bug 1182735.
+    ":beauty.oftc.net NOTICE myusername :*** Connected securely via UNKNOWN AES128-SHA-128",
+  ];
+
+  for (let msg of kMsgs) {
+    let account = new FakeAccount();
+
+    let message = ircMessage(msg, "");
+    let result = NOTICE.call(account, message);
+
+    // This message should *NOT* be shown.
+    equal(result, false);
+  }
+
+  run_next_test();
+}
diff --git a/comm/chat/protocols/irc/test/test_ircProtocol.js b/comm/chat/protocols/irc/test/test_ircProtocol.js
new file mode 100644
index 0000000000..f4394b4115
--- /dev/null
+++ b/comm/chat/protocols/irc/test/test_ircProtocol.js
@@ -0,0 +1,20 @@
+/* Any copyright is dedicated to the Public Domain.
+ * http://creativecommons.org/publicdomain/zero/1.0/ */
+
+const { ircProtocol } = ChromeUtils.importESModule(
+  "resource:///modules/irc.sys.mjs"
+);
+
+add_task(function test_splitUsername() {
+  const bareUsername = "foobar";
+  const bareSplit = ircProtocol.prototype.splitUsername(bareUsername);
+  deepEqual(bareSplit, []);
+
+  const fullAccountName = "foobar@example.com";
+  const fullSplit = ircProtocol.prototype.splitUsername(fullAccountName);
+  deepEqual(fullSplit, ["foobar", "example.com"]);
+
+  const extraAt = "foo@bar@example.com";
+  const extraSplit = ircProtocol.prototype.splitUsername(extraAt);
+  deepEqual(extraSplit, ["foo@bar", "example.com"]);
+});
diff --git a/comm/chat/protocols/irc/test/test_ircServerTime.js b/comm/chat/protocols/irc/test/test_ircServerTime.js
new file mode 100644
index 0000000000..9f91ab7432
--- /dev/null
+++ b/comm/chat/protocols/irc/test/test_ircServerTime.js
@@ -0,0 +1,130 @@
+/* Any copyright is dedicated to the Public Domain.
+ * http://creativecommons.org/publicdomain/zero/1.0/ */
+
+var { tagServerTime } = ChromeUtils.importESModule(
+  "resource:///modules/ircServerTime.sys.mjs"
+);
+var { ircMessage } = ChromeUtils.importESModule(
+  "resource:///modules/ircAccount.sys.mjs"
+);
+
+function getTags(aRawMsg) {
+  const { tags } = ircMessage(aRawMsg, "does.not@matter");
+
+  return tags;
+}
+
+function run_test() {
+  add_test(specMessages);
+
+  run_next_test();
+}
+
+function specMessages() {
+  const kMessages = [
+    {
+      tags: getTags(
+        "@time=2011-10-19T16:40:51.620Z :Angel!angel@example.com PRIVMSG #test :Hello"
+      ),
+      who: "Angel!angel@example.com",
+      get originalMessage() {
+        return "Hello";
+      },
+      message: "Hello",
+      incoming: true,
+    },
+    {
+      tags: getTags(
+        "@time=2012-06-30T23:59:60.419Z :John!~john@1.2.3.4 JOIN #chan"
+      ),
+      who: "John!~john@1.2.3.4",
+      message: "John joined #chan",
+      get originalMessage() {
+        return "John joined #chan";
+      },
+      system: true,
+      incoming: true,
+    },
+    {
+      tags: getTags(
+        "@znc.in/server-time-iso=2016-11-13T19:20:45.284Z :John!~john@1.2.3.4 JOIN #chan"
+      ),
+      who: "John!~john@1.2.3.4",
+      message: "John joined #chan",
+      get originalMessage() {
+        return "John joined #chan";
+      },
+      system: true,
+      incoming: true,
+    },
+    {
+      tags: getTags("@time= :empty!Empty@host.local JOIN #test"),
+      who: "empty!Empty@localhost",
+      message: "Empty joined #test",
+      get originalMessage() {
+        return "Empty joined #test";
+      },
+      system: true,
+      incoming: true,
+    },
+    {
+      tags: getTags("NoTags!notags@1.2.3.4 PART #test"),
+      who: "NoTags!notags@1.2.3.4",
+      message: "NoTags left #test",
+      get originalMessage() {
+        return "NoTags left #test";
+      },
+      system: true,
+      incoming: true,
+    },
+  ];
+
+  const kExpectedTimes = [
+    Math.floor(Date.parse(kMessages[0].tags.get("time")) / 1000),
+    Math.floor(Date.parse("2012-06-30T23:59:59.999Z") / 1000),
+    Math.floor(
+      Date.parse(kMessages[2].tags.get("znc.in/server-time-iso")) / 1000
+    ),
+    undefined,
+    undefined,
+  ];
+
+  for (let m in kMessages) {
+    const msg = kMessages[m];
+    const isZNC = kMessages[m].tags.has("znc.in/server-time-iso");
+    const tag = isZNC ? "znc.in/server-time-iso" : "time";
+    const tagMessage = {
+      message: Object.assign({}, msg),
+      tagName: tag,
+      tagValue: msg.tags.get(tag),
+    };
+    tagServerTime.commands[tag](tagMessage);
+
+    // Ensuring that the expected properties and their values as given in
+    // kMessages are still the same after the handler.
+    for (let i in msg) {
+      equal(
+        tagMessage.message[i],
+        msg[i],
+        "Property '" + i + "' was not modified"
+      );
+    }
+    // The time should only be adjusted when we expect a valid server-time tag.
+    equal(
+      "time" in tagMessage.message,
+      kExpectedTimes[m] !== undefined,
+      "Message time was set when expected"
+    );
+
+    if (kExpectedTimes[m] !== undefined) {
+      ok(tagMessage.message.delayed, "Delayed flag was set");
+      equal(
+        kExpectedTimes[m],
+        tagMessage.message.time,
+        "Time was parsed properly"
+      );
+    }
+  }
+
+  run_next_test();
+}
diff --git a/comm/chat/protocols/irc/test/test_sendBufferedCommand.js b/comm/chat/protocols/irc/test/test_sendBufferedCommand.js
new file mode 100644
index 0000000000..5558979db3
--- /dev/null
+++ b/comm/chat/protocols/irc/test/test_sendBufferedCommand.js
@@ -0,0 +1,199 @@
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
+
+var { IMServices } = ChromeUtils.importESModule(
+  "resource:///modules/IMServices.sys.mjs"
+);
+var { ircAccount } = ChromeUtils.importESModule(
+  "resource:///modules/ircAccount.sys.mjs"
+);
+var { clearTimeout, setTimeout } = ChromeUtils.importESModule(
+  "resource://gre/modules/Timer.sys.mjs"
+);
+
+function FakeAccount() {
+  this._commandBuffers = new Map();
+  this.callbacks = [];
+}
+FakeAccount.prototype = {
+  __proto__: ircAccount.prototype,
+  maxMessageLength: 60,
+  callbacks: [],
+  sendMessage(aCommand, aParams) {
+    this.callbacks.shift()(aCommand, aParams);
+  },
+};
+
+var account = new FakeAccount();
+
+function run_test() {
+  test_parameterCollect();
+  test_maxLength();
+  run_next_test();
+}
+
+function test_parameterCollect() {
+  // Individual tests, data consisting of [channel, key] pairs.
+  let tests = [
+    {
+      data: [["one"], ["one"]], // also tests deduplication
+      result: "JOIN one",
+    },
+    {
+      data: [["one", ""]], // explicit empty password string
+      result: "JOIN one",
+    },
+    {
+      data: [["one"], ["two"], ["three"]],
+      result: "JOIN one,two,three",
+    },
+    {
+      data: [["one"], ["two", "password"], ["three"]],
+      result: "JOIN two,one,three password",
+    },
+    {
+      data: [
+        ["one"],
+        ["two", "password"],
+        ["three"],
+        ["four", "anotherpassword"],
+      ],
+      result: "JOIN two,four,one,three password,anotherpassword",
+    },
+  ];
+
+  for (let test of tests) {
+    let timeout;
+    // Destructure test to local variables so each function
+    // generated here gets the correct value in its scope.
+    let { data, result } = test;
+    account.callbacks.push((aCommand, aParams) => {
+      let msg = account.buildMessage(aCommand, aParams);
+      equal(msg, result, "Test buffering of parameters");
+      clearTimeout(timeout);
+      account._lastCommandSendTime = 0;
+      run_next_test();
+    });
+    add_test(() => {
+      // This timeout lets the test fail more quickly if
+      // some of the callbacks we added don't get called.
+      // Not strictly speaking necessary.
+      // eslint-disable-next-line mozilla/no-arbitrary-setTimeout
+      timeout = setTimeout(() => {
+        ok(false, "test_parameterCollect failed after timeout.");
+        run_next_test();
+      }, 2000);
+      for (let [channel, key] of data) {
+        account.sendBufferedCommand("JOIN", channel, key);
+      }
+    });
+  }
+
+  // Test this still works when adding commands on different ticks of
+  // the event loop.
+  account._lastCommandSendTime = 0;
+  for (let test of tests) {
+    let timeout;
+    let { data, result } = test;
+    account.callbacks.push((aCommand, aParams) => {
+      let msg = account.buildMessage(aCommand, aParams);
+      equal(msg, result, "Test buffering with setTimeout");
+      clearTimeout(timeout);
+      run_next_test();
+    });
+    add_test(() => {
+      // This timeout lets the test fail more quickly if
+      // some of the callbacks we added don't get called.
+      // Not strictly speaking necessary.
+      // eslint-disable-next-line mozilla/no-arbitrary-setTimeout
+      timeout = setTimeout(() => {
+        ok(false, "test_parameterCollect failed after timeout.");
+        run_next_test();
+      }, 2000);
+      let delay = 0;
+      for (let params of data) {
+        let [channel, key] = params;
+        delay += 200;
+        // eslint-disable-next-line mozilla/no-arbitrary-setTimeout
+        setTimeout(() => {
+          account.sendBufferedCommand("JOIN", channel, key);
+        }, delay);
+      }
+    });
+  }
+}
+
+function test_maxLength() {
+  let tests = [
+    {
+      data: [
+        ["applecustard"],
+        ["pearpie"],
+        ["strawberryfield"],
+        ["blueberrypancake"],
+        ["mangojuice"],
+        ["raspberryberet"],
+        ["pineapplesoup"],
+        ["limejelly"],
+        ["lemonsorbet"],
+      ],
+      results: [
+        "JOIN applecustard,pearpie,strawberryfield,blueberrypancake",
+        "JOIN mangojuice,raspberryberet,pineapplesoup,limejelly",
+        "JOIN lemonsorbet",
+      ],
+    },
+    {
+      data: [
+        ["applecustard"],
+        ["pearpie"],
+        ["strawberryfield", "password1"],
+        ["blueberrypancake"],
+        ["mangojuice"],
+        ["raspberryberet"],
+        ["pineapplesoup"],
+        ["limejelly", "password2"],
+        ["lemonsorbet"],
+      ],
+      results: [
+        "JOIN strawberryfield,applecustard,pearpie password1",
+        "JOIN blueberrypancake,mangojuice,raspberryberet",
+        "JOIN limejelly,pineapplesoup,lemonsorbet password2",
+      ],
+    },
+  ];
+
+  account._lastCommandSendTime = 0;
+  for (let test of tests) {
+    let timeout;
+    // Destructure test to local variables so each function
+    // generated here gets the correct value in its scope.
+    let { data, results } = test;
+    for (let r of results) {
+      let result = r;
+      account.callbacks.push((aCommand, aParams) => {
+        let msg = account.buildMessage(aCommand, aParams);
+        equal(msg, result, "Test maximum message length constraint");
+        // After all results are checked, run the next test.
+        if (result == results[results.length - 1]) {
+          clearTimeout(timeout);
+          run_next_test();
+        }
+      });
+    }
+    add_test(() => {
+      // This timeout lets the test fail more quickly if
+      // some of the callbacks we added don't get called.
+      // Not strictly speaking necessary.
+      // eslint-disable-next-line mozilla/no-arbitrary-setTimeout
+      timeout = setTimeout(() => {
+        ok(false, "test_maxLength failed after timeout.");
+        run_next_test();
+      }, 2000);
+      for (let [channel, key] of data) {
+        account.sendBufferedCommand("JOIN", channel, key);
+      }
+    });
+  }
+}
diff --git a/comm/chat/protocols/irc/test/test_setMode.js b/comm/chat/protocols/irc/test/test_setMode.js
new file mode 100644
index 0000000000..9a329beaa5
--- /dev/null
+++ b/comm/chat/protocols/irc/test/test_setMode.js
@@ -0,0 +1,70 @@
+/* Any copyright is dedicated to the Public Domain.
+ * http://creativecommons.org/publicdomain/zero/1.0/ */
+
+var { IMServices } = ChromeUtils.importESModule(
+  "resource:///modules/IMServices.sys.mjs"
+);
+var { ircAccount, ircChannel } = ChromeUtils.importESModule(
+  "resource:///modules/ircAccount.sys.mjs"
+);
+
+IMServices.conversations.initConversations();
+
+function FakeAccount() {
+  this.normalizeNick = ircAccount.prototype.normalizeNick.bind(this);
+}
+FakeAccount.prototype = {
+  __proto__: ircAccount.prototype,
+  setWhois: (n, f) => true,
+  ERROR: do_throw,
+};
+
+function run_test() {
+  add_test(test_topicSettable);
+  add_test(test_topicSettableJoinAsOp);
+
+  run_next_test();
+}
+
+// Test joining a channel, then being set as op.
+function test_topicSettable() {
+  let channel = new ircChannel(new FakeAccount(), "#test", "nick");
+  // We're not in the room yet, so the topic is NOT editable.
+  equal(channel.topicSettable, false);
+
+  // Join the room.
+  channel.getParticipant("nick");
+  // The topic should be editable.
+  equal(channel.topicSettable, true);
+
+  // Receive the channel mode.
+  channel.setMode("+t", [], "ChanServ");
+  // Mode +t means that you need status to set the mode.
+  equal(channel.topicSettable, false);
+
+  // Receive a user mode.
+  channel.setMode("+o", ["nick"], "ChanServ");
+  // Nick is now an op and can set the topic!
+  equal(channel.topicSettable, true);
+
+  run_next_test();
+}
+
+// Test when you join as an op (as opposed to being set to op after joining).
+function test_topicSettableJoinAsOp() {
+  let channel = new ircChannel(new FakeAccount(), "#test", "nick");
+  // We're not in the room yet, so the topic is NOT editable.
+  equal(channel.topicSettable, false);
+
+  // Join the room as an op.
+  channel.getParticipant("@nick");
+  // The topic should be editable.
+  equal(channel.topicSettable, true);
+
+  // Receive the channel mode.
+  channel.setMode("+t", [], "ChanServ");
+  // The topic should still be editable.
+  equal(channel.topicSettable, true);
+
+  run_next_test();
+}
diff --git a/comm/chat/protocols/irc/test/test_splitLongMessages.js b/comm/chat/protocols/irc/test/test_splitLongMessages.js
new file mode 100644
index 0000000000..b507d4ec99
--- /dev/null
+++ b/comm/chat/protocols/irc/test/test_splitLongMessages.js
@@ -0,0 +1,44 @@
+/* Any copyright is dedicated to the Public Domain.
+ * http://creativecommons.org/publicdomain/zero/1.0/ */
+
+var { GenericIRCConversation, ircAccount } = ChromeUtils.importESModule(
+  "resource:///modules/ircAccount.sys.mjs"
+);
+
+var messages = {
+  // Exactly 51 characters.
+  "This is a test.": ["This is a test."],
+  // Too long.
+  "This is a message that is too long.": [
+    "This is a",
+    "message that is",
+    "too long.",
+  ],
+  // Too short.
+  "Short msg.": ["Short msg."],
+  "Thismessagecan'tbecut.": ["Thismessagecan'", "tbecut."],
+};
+
+function run_test() {
+  for (let message in messages) {
+    let msg = { message };
+    let generatedMsgs = GenericIRCConversation.prepareForSending.call(
+      {
+        __proto__: GenericIRCConversation,
+        name: "target",
+        _account: {
+          __proto__: ircAccount.prototype,
+          _nickname: "sender",
+          prefix: "!user@host",
+          maxMessageLength: 51, // For convenience.
+        },
+      },
+      msg
+    );
+
+    // The expected messages as defined above.
+    let expectedMsgs = messages[message];
+    // Ensure the arrays are equal.
+    deepEqual(generatedMsgs, expectedMsgs);
+  }
+}
diff --git a/comm/chat/protocols/irc/test/test_tryNewNick.js b/comm/chat/protocols/irc/test/test_tryNewNick.js
new file mode 100644
index 0000000000..dbd2692d4c
--- /dev/null
+++ b/comm/chat/protocols/irc/test/test_tryNewNick.js
@@ -0,0 +1,148 @@
+/* Any copyright is dedicated to the Public Domain.
+ * http://creativecommons.org/publicdomain/zero/1.0/ */
+
+var { ircProtocol } = ChromeUtils.importESModule(
+  "resource:///modules/irc.sys.mjs"
+);
+var { ircAccount } = ChromeUtils.importESModule(
+  "resource:///modules/ircAccount.sys.mjs"
+);
+
+var fakeProto = {
+  id: "fake-proto",
+  options: { alternateNicks: "" },
+  _getOptionDefault(aOption) {
+    return this.options[aOption];
+  },
+  usernameSplits: ircProtocol.prototype.usernameSplits,
+  splitUsername: ircProtocol.prototype.splitUsername,
+};
+
+function test_tryNewNick() {
+  const testData = {
+    clokep: "clokep1",
+    clokep1: "clokep2",
+    clokep10: "clokep11",
+    clokep0: "clokep1",
+    clokep01: "clokep02",
+    clokep09: "clokep10",
+
+    // Now put a number in the "first part".
+    clo1kep: "clo1kep1",
+    clo1kep1: "clo1kep2",
+    clo1kep10: "clo1kep11",
+    clo1kep0: "clo1kep1",
+    clo1kep01: "clo1kep02",
+    clo1kep09: "clo1kep10",
+  };
+
+  let account = new ircAccount(fakeProto, {
+    name: "clokep@instantbird.org",
+  });
+  account.LOG = function (aStr) {};
+  account.normalize = aStr => aStr;
+
+  for (let currentNick in testData) {
+    account._sentNickname = currentNick;
+    account.sendMessage = (aCommand, aNewNick) =>
+      equal(aNewNick, testData[currentNick]);
+
+    account.tryNewNick(currentNick);
+  }
+
+  run_next_test();
+}
+
+// This tests a bunch of cases near the max length by maintaining the state
+// through a series of test nicks.
+function test_maxLength() {
+  let testData = [
+    // First try adding a digit, as normal.
+    ["abcdefghi", "abcdefghi1"],
+    // The "received" nick back will now be the same though, so it was too long.
+    ["abcdefghi", "abcdefgh1"],
+    // And just ensure we're iterating properly.
+    ["abcdefgh1", "abcdefgh2"],
+    ["abcdefgh2", "abcdefgh3"],
+    ["abcdefgh3", "abcdefgh4"],
+    ["abcdefgh4", "abcdefgh5"],
+    ["abcdefgh5", "abcdefgh6"],
+    ["abcdefgh6", "abcdefgh7"],
+    ["abcdefgh7", "abcdefgh8"],
+    ["abcdefgh8", "abcdefgh9"],
+    ["abcdefgh9", "abcdefgh10"],
+    ["abcdefgh1", "abcdefg10"],
+    ["abcdefg10", "abcdefg11"],
+    ["abcdefg99", "abcdefg100"],
+    ["abcdefg10", "abcdef100"],
+    ["a99999999", "a100000000"],
+    ["a10000000", "a00000000"],
+  ];
+
+  let account = new ircAccount(fakeProto, {
+    name: "clokep@instantbird.org",
+  });
+  account.LOG = function (aStr) {};
+  account._sentNickname = "abcdefghi";
+  account.normalize = aStr => aStr;
+
+  for (let currentNick of testData) {
+    account.sendMessage = (aCommand, aNewNick) =>
+      equal(aNewNick, currentNick[1]);
+
+    account.tryNewNick(currentNick[0]);
+  }
+
+  run_next_test();
+}
+
+function test_altNicks() {
+  const altNicks = ["clokep_", "clokep|"];
+  const testData = {
+    // Test account nick.
+    clokep: [altNicks, "clokep_"],
+    // Test first element in list.
+    clokep_: [altNicks, "clokep|"],
+    // Test last element in list.
+    "clokep|": [altNicks, "clokep|1"],
+    // Test element not in list with number at end.
+    clokep1: [altNicks, "clokep2"],
+
+    // Test messy alternatives.
+    "clokep[": [" clokep ,\n clokep111,,,\tclokep[, clokep_", "clokep_"],
+  };
+
+  let account = new ircAccount(fakeProto, {
+    name: "clokep@instantbird.org",
+  });
+  account.LOG = function (aStr) {};
+  account.normalize = aStr => aStr;
+
+  for (let currentNick in testData) {
+    // Only one pref is touched in here, override the default to return
+    // what this test needs.
+    account.getString = function (aStr) {
+      let data = testData[currentNick][0];
+      if (Array.isArray(data)) {
+        return data.join(",");
+      }
+      return data;
+    };
+    account._sentNickname = currentNick;
+
+    account.sendMessage = (aCommand, aNewNick) =>
+      equal(aNewNick, testData[currentNick][1]);
+
+    account.tryNewNick(currentNick);
+  }
+
+  run_next_test();
+}
+
+function run_test() {
+  add_test(test_tryNewNick);
+  add_test(test_maxLength);
+  add_test(test_altNicks);
+
+  run_next_test();
+}
diff --git a/comm/chat/protocols/irc/test/xpcshell.ini b/comm/chat/protocols/irc/test/xpcshell.ini
new file mode 100644
index 0000000000..1f2e8bf907
--- /dev/null
+++ b/comm/chat/protocols/irc/test/xpcshell.ini
@@ -0,0 +1,18 @@
+[DEFAULT]
+head =
+tail =
+
+[test_ctcpFormatting.js]
+[test_ctcpColoring.js]
+[test_ctcpDequote.js]
+[test_ctcpQuote.js]
+[test_ircCAP.js]
+[test_ircChannel.js]
+[test_ircCommands.js]
+[test_ircMessage.js]
+[test_ircNonStandard.js]
+[test_ircServerTime.js]
+[test_sendBufferedCommand.js]
+[test_setMode.js]
+[test_splitLongMessages.js]
+[test_tryNewNick.js]