safesupport-bot/dist/bot.js

"use strict";

var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");

var _interopRequireWildcard = require("@babel/runtime/helpers/interopRequireWildcard");

Object.defineProperty(exports, "__esModule", {
  value: true
});
exports.default = void 0;

var fs = _interopRequireWildcard(require("fs"));

var os = _interopRequireWildcard(require("os"));

var path = _interopRequireWildcard(require("path"));

var util = _interopRequireWildcard(require("util"));

var _nodeLocalstorage = require("node-localstorage");

var matrix = _interopRequireWildcard(require("matrix-js-sdk"));

var _logger = _interopRequireDefault(require("./logger"));

var _encryptAttachment = _interopRequireDefault(require("./encrypt-attachment"));

global.Olm = require("olm");
const BOT_SIGNAL_END_CHAT = 'END_CHAT';
const BOT_SIGNAL_CHAT_OFFLINE = 'CHAT_OFFLINE';

class OcrccBot {
  constructor(config) {
    this.config = config;
    this.client = matrix.createClient(this.config.matrixServerUrl);
    this.joinedRooms = [];
    this.inactivityTimers = {};
  }

  createLocalStorage() {
    const storageLoc = `matrix-chatbot-${this.config.botUsername}`;
    const dir = path.resolve(path.join(os.homedir(), ".local-storage"));

    if (!fs.existsSync(dir)) {
      fs.mkdirSync(dir);
    }

    const localStoragePath = path.resolve(path.join(dir, storageLoc));
    return new _nodeLocalstorage.LocalStorage(localStoragePath);
  }

  async sendTextMessage(roomId, msgText, showToUser = null) {
    const content = {
      msgtype: "m.text",
      body: msgText,
      showToUser: showToUser
    };
    await this.sendMessage(roomId, content);
  }

  async sendNotice(roomId, message) {
    try {
      await this.client.sendNotice(roomId, message);

      _logger.default.log("info", `SENT *NOTICE*: ${message}`);
    } catch (err) {
      switch (err["name"]) {
        case "UnknownDeviceError":
          Object.keys(err.devices).forEach(userId => {
            Object.keys(err.devices[userId]).map(async deviceId => {
              try {
                await this.client.setDeviceVerified(userId, deviceId, true);
              } catch (err) {
                _logger.default.log("error", `ERROR VERIFYING DEVICE: ${err}`);
              }
            });
          });
          await this.sendNotice(roomId, message);

        default:
          _logger.default.log("error", `ERROR SENDING *NOTICE*: ${err}`);

          break;
      }
    }
  }

  async sendMessage(roomId, content) {
    try {
      await this.client.sendMessage(roomId, content);

      _logger.default.log("info", `SENT MESSAGE: ${content.body}`);
    } catch (err) {
      switch (err["name"]) {
        case "UnknownDeviceError":
          Object.keys(err.devices).forEach(userId => {
            Object.keys(err.devices[userId]).map(async deviceId => {
              try {
                await this.client.setDeviceVerified(userId, deviceId, true);
              } catch (err) {
                _logger.default.log("error", `ERROR VERIFYING DEVICE: ${err}`);
              }
            });
          });
          await this.sendMessage(roomId, content);

        default:
          _logger.default.log("error", `ERROR SENDING MESSAGE ${content.body}: ${err}`);

          break;
      }
    }
  }

  kickUserFromRoom(roomId, member) {
    try {
      this.client.kick(roomId, member, this.config.kickReason);
    } catch (err) {
      this.handleBotCrash(roomId, err);

      _logger.default.log("error", `ERROR KICKING OUT MEMBER: ${err}`);
    }
  }

  async inviteFacilitatorIfOnline(roomId, memberId) {
    const user = this.client.getUser(memberId);

    if (user && user.presence !== "offline" && memberId !== this.config.botUserId) {
      try {
        this.client.invite(roomId, memberId);

        _logger.default.log("info", `CHAT INVITATION SENT TO ${memberId} FOR ROOM ${roomId}`);

        return memberId;
      } catch (err) {
        this.handleBotCrash(roomId, err);
        return null;
      }
    } else {
      return null;
    }
  }

  async inviteFacilitators(roomId) {
    try {
      this.localStorage.setItem(`${roomId}-waiting`, 'true');
      let invitations = [];
      const roomMembers = await this.client.getJoinedRoomMembers(this.config.facilitatorRoomId);
      const members = Object.keys(roomMembers["joined"]);

      for (const memberId of members) {
        const invited = await this.inviteFacilitatorIfOnline(roomId, memberId);
        invitations.push(invited);
      }

      if (invitations.filter(i => i).length > 0) {
        this.localStorage.setItem(`${roomId}-invitations`, invitations);
      } else {
        this.sendBotSignal(roomId, BOT_SIGNAL_CHAT_OFFLINE); // send notification to Support Chat Notifications room

        const currentDate = new Date();
        const closedTime = currentDate.toLocaleTimeString();
        const roomRef = roomId.split(':')[0];
        const notification = `No facilitators were online, chat closed at ${closedTime} (room ID: ${roomRef})`;

        _logger.default.log('info', `NO FACILITATORS ONLINE, CHAT CLOSED AT ${closedTime} (room ID: ${roomRef})`);

        this.sendTextMessage(this.config.facilitatorRoomId, notification);
      }
    } catch (err) {
      this.handleBotCrash(roomId, err);

      _logger.default.log("error", `ERROR GETTING FACILITATORS: ${err}`);
    }
  }

  async uninviteFacilitators(roomId) {
    try {
      this.localStorage.removeItem(`${roomId}-waiting`);
      const facilitatorsRoomMembers = await this.client.getJoinedRoomMembers(this.config.facilitatorRoomId);
      const supportRoomMembers = await this.client.getJoinedRoomMembers(roomId);
      const roomMembersIds = Object.keys(supportRoomMembers["joined"]);
      const facilitatorsIds = Object.keys(facilitatorsRoomMembers["joined"]);
      if (!roomMembersIds || !facilitatorsIds) return;
      facilitatorsIds.forEach(f => {
        if (!roomMembersIds.includes(f)) {
          this.kickUserFromRoom(roomId, f);
        }
      });
    } catch (err) {
      this.handleBotCrash(roomId, err);

      _logger.default.log("ERROR UNINVITING FACILITATORS", err);
    }
  }

  handleBotCrash(roomId, error) {
    if (roomId) {
      this.sendTextMessage(roomId, this.config.botErrorMessage);
      this.sendBotSignal(roomId, BOT_SIGNAL_END_CHAT);
    }

    this.sendTextMessage(this.config.facilitatorRoomId, `${this.config.botDisplayName} ran into an error: ${error}. Please verify that the chat service is working.`);
  }

  handleMessageEvent(event) {
    const content = event.getContent();
    const sender = event.getSender();
    const roomId = event.getRoomId(); // do nothing if there's no content

    if (!content) {
      return;
    } // if it's a chat message and the facilitator has joined, reset the inactivity timeout


    const facilitatorId = this.localStorage.getItem(`${roomId}-facilitator`);

    if (Boolean(facilitatorId) && sender !== this.config.botUserId) {
      this.setInactivityTimeout(roomId);
    } // bot commands


    if (content.body.startsWith("!bot")) {
      return this.handleBotCommand(event);
    } // write to transcript


    if (this.config.captureTranscripts) {
      return this.writeToTranscript(event);
    }
  }

  writeToTranscript(event) {
    try {
      const sender = event.getSender();
      const roomId = event.getRoomId();
      const content = event.getContent();
      const date = event.getDate();
      const time = date.toLocaleTimeString("en-GB", {
        timeZone: "America/New_York"
      });
      const filepath = this.localStorage.getItem(`${roomId}-transcript`);

      if (!filepath) {
        return _logger.default.log("error", `NO TRANSCRIPT FILE FOR ROOM: ${roomId}. This message will not be added: ${content.body}`);
      }

      const message = `${sender} [${time}]: ${content.body}\n`;
      fs.appendFileSync(filepath, message, "utf8");
    } catch (err) {
      _logger.default.log("error", `ERROR APPENDING TO TRANSCRIPT FILE: ${err}`);
    }
  }

  handleBotCommand(event) {
    const botCommands = [{
      keyword: 'transcript',
      function: (senderId, roomId) => {
        this.sendTranscript(senderId, roomId);
      }
    }, {
      keyword: 'delete transcript',
      function: (senderId, roomId) => {
        this.deleteTranscript(senderId, roomId, true);
      } // delete transcript and send confirmation message

    }, {
      keyword: 'say',
      function: (senderId, roomId, message) => {
        this.sendTextMessage(roomId, message, senderId);
      }
    }, {
      keyword: 'hi',
      function: (senderId, roomId) => {
        const responses = ["Hi!", "Hello", "Hey :)", "Hi there", "Bleep bloop"];
        const message = responses[Math.floor(Math.random() * responses.length)];
        this.sendTextMessage(roomId, message, senderId);
      }
    }];

    try {
      const senderId = event.getSender();
      const roomId = event.getRoomId();
      const content = event.getContent();
      const commandText = content.body.substring("!bot".length).trim();
      const command = botCommands.find(c => commandText.startsWith(c.keyword));

      if (!command) {
        this.sendTextMessage(roomId, `Sorry, I don't know that command. I'm not a very smart bot.`, senderId);
      }

      const args = commandText.substring(command.keyword.length).trim();
      command.function(senderId, roomId, args);
    } catch (err) {
      _logger.default.log("error", `ERROR EXECUTING BOT COMMAND: ${err}`);
    }
  }

  async leaveEmptyRooms() {
    try {
      const roomData = await this.client.getJoinedRooms();
      const joinedRoomsIds = roomData["joined_rooms"];
      joinedRoomsIds.forEach(async roomId => {
        const room = this.client.getRoom(roomId);

        if (room && room.getJoinedMemberCount() === 1) {
          try {
            await this.client.leave(roomId);

            _logger.default.log('info', `LEAVING EMPTY ROOM => ${roomId}`);
          } catch (err) {
            _logger.default.log('error', `ERROR LEAVING ROOM ${roomId} => ${err}`);
          }
        }
      });
    } catch (err) {
      _logger.default.log("error", `ERROR LEAVING EMPTY ROOMS: ${err}`);
    }
  }

  async sendTranscript(senderId, roomId) {
    try {
      const transcriptFile = this.localStorage.getItem(`${roomId}-transcript`);

      if (!transcriptFile) {
        this.sendTextMessage(roomId, "Cannot send transcript, there is no transcript for this chat.", senderId);
      }

      if (this.client.isRoomEncrypted(roomId)) {
        let encryptInfo;
        const filename = path.basename(transcriptFile) || "Transcript";
        const data = fs.readFileSync(transcriptFile);
        const encryptResult = await _encryptAttachment.default.encryptAttachment(data);
        const buffer = Buffer.from(encryptResult.data);
        encryptInfo = encryptResult.info;
        const url = await this.client.uploadContent(buffer, {
          rawResponse: false,
          name: filename
        });
        encryptInfo.url = url.content_uri;
        encryptInfo.mimetype = 'text/plain';
        const content = {
          msgtype: "m.file",
          body: filename,
          info: {
            mimetype: 'text/plain'
          },
          file: encryptInfo,
          url: url.content_uri,
          showToUser: senderId,
          mimetype: 'text/plain'
        };
        this.sendMessage(roomId, content);
      } else {
        const filename = path.basename(transcriptFile) || "Transcript";
        const file = fs.readFileSync(transcriptFile);
        const stats = fs.statSync(transcriptFile);
        const url = await this.client.uploadContent(file, {
          rawResponse: false,
          name: filename
        });

        _logger.default.log('info', url);

        const content = {
          msgtype: "m.file",
          body: filename,
          info: {
            size: stats.size,
            mimetype: 'text/plain'
          },
          url: url.content_uri,
          showToUser: senderId,
          mimetype: 'text/plain'
        };
        this.sendMessage(roomId, content);
      }
    } catch (err) {
      _logger.default.log("error", `ERROR UPLOADING CONTENT: ${err}`);

      this.sendTextMessage(roomId, "There was an error uploading the transcript.", senderId);
    }
  }

  deleteTranscript(senderId, roomId, sendConfirmation = false) {
    const transcriptFile = this.localStorage.getItem(`${roomId}-transcript`);

    if (!transcriptFile) {
      return this.sendTextMessage(roomId, "Cannot delete transcript, there is no transcript for this chat.", senderId);
    }

    fs.unlink(transcriptFile, err => {
      if (err) {
        _logger.default.log('error', "UNABLE TO DELETE TRANSCRIPT FILE => " + transcriptFile);

        _logger.default.log('error', err);

        return this.sendTextMessage(roomId, `There was an error deleting the transcript: ${err}`, senderId);
      }

      if (sendConfirmation) {
        this.sendTextMessage(roomId, `The transcript file has been deleted.`, senderId);
      }

      _logger.default.log('info', "DELETED TRANSCRIPT FILE => " + transcriptFile);

      this.localStorage.removeItem(`${roomId}-transcript`);
    });
  }

  async deleteOldDevices() {
    const currentDeviceId = this.client.getDeviceId();
    const deviceData = await this.client.getDevices();
    const allDeviceIds = deviceData.devices.map(d => d.device_id);
    const oldDevices = allDeviceIds.filter(id => id !== currentDeviceId);

    try {
      await this.client.deleteMultipleDevices(oldDevices);
    } catch (err) {
      _logger.default.log("info", "RETRYING DELETE OLD DEVICES WITH AUTH");

      const auth = {
        session: err.data.session,
        type: "m.login.password",
        user: this.config.botUserId,
        identifier: {
          type: "m.id.user",
          user: this.config.botUserId
        },
        password: this.config.botPassword
      };
      await this.client.deleteMultipleDevices(oldDevices, auth);

      _logger.default.log("info", "DELETED OLD DEVICES");
    }
  }

  async trackJoinedRooms() {
    const roomData = await this.client.getJoinedRooms();
    this.joinedRooms = roomData["joined_rooms"];

    _logger.default.log("info", "JOINED ROOMS => " + this.joinedRooms);
  }

  async setMembershipListeners() {
    // Automatically accept all room invitations
    this.client.on("RoomMember.membership", async (event, member) => {
      if (member.membership === "invite" && member.userId === this.config.botUserId && !this.joinedRooms.includes(member.roomId)) {
        try {
          const roomData = await this.client.getJoinedRooms();
          const joinedRooms = roomData["joined_rooms"];

          if (!joinedRooms.includes(member.roomId)) {
            const room = await this.client.joinRoom(member.roomId);

            _logger.default.log("info", "AUTO JOINED ROOM => " + room.roomId);

            const inviteDate = event.getDate();
            const chatDate = inviteDate.toLocaleDateString();
            const chatTime = inviteDate.toLocaleTimeString();
            const roomId = room.roomId.split(':')[0];
            const notification = `Incoming support chat at ${chatTime} (room ID: ${roomId})`;
            this.sendTextMessage(this.config.facilitatorRoomId, notification);
            this.inviteFacilitators(room.roomId);
            this.setTimeoutforFacilitator(room.roomId);
          }
        } catch (err) {
          _logger.default.log("error", "ERROR JOINING ROOM => " + err);
        }
      }

      if (member.membership === "join" && member.userId !== this.config.botUserId && this.localStorage.getItem(`${member.roomId}-waiting`)) {
        try {
          // make sure it's a facilitator joining
          const roomMembers = await this.client.getJoinedRoomMembers(this.config.facilitatorRoomId);
          const members = Object.keys(roomMembers["joined"]);
          const isFacilitator = members.includes(member.userId);

          if (isFacilitator) {
            // made facilitator a moderator in the room
            this.localStorage.setItem(`${member.roomId}-facilitator`, member.userId);
            const event = {
              getType: () => {
                return "m.room.power_levels";
              },
              getContent: () => {
                return {
                  users: {
                    [this.config.botUserId]: 100,
                    [member.userId]: 50
                  }
                };
              }
            };
            this.client.setPowerLevel(member.roomId, member.userId, 50, event); // send notification to Support Chat Notifications room

            const currentDate = new Date();
            const chatTime = currentDate.toLocaleTimeString();
            const roomId = member.roomId.split(':')[0];
            const notification = `${member.name} joined the chat at ${chatTime} (room ID: ${roomId})`;
            this.sendTextMessage(this.config.facilitatorRoomId, notification); // send notification to chat room

            this.sendTextMessage(member.roomId, `${member.name} has joined the chat.`); // revoke the other invitations

            this.uninviteFacilitators(member.roomId); // set transcript file

            if (this.config.captureTranscripts) {
              const currentDate = new Date();
              const dateOpts = {
                year: "numeric",
                month: "short",
                day: "numeric"
              };
              const chatDate = currentDate.toLocaleDateString("en-GB", dateOpts);
              const chatTime = currentDate.toLocaleTimeString("en-GB", {
                timeZone: "America/New_York"
              });
              const filename = `${chatDate} - ${chatTime} - ${member.roomId}.txt`;
              const filepath = path.resolve(path.join("transcripts", filename));
              this.localStorage.setItem(`${member.roomId}-transcript`, filepath);
            }
          }
        } catch (err) {
          _logger.default.log("error", `ERROR WHEN FACILITATOR JOINED ROOM ==> ${err}`);
        }
      }

      if (member.membership === "leave" && member.userId !== this.config.botUserId) {
        // notify room if the facilitator has left
        try {
          const facilitatorId = this.localStorage.getItem(`${member.roomId}-facilitator`);

          if (member.userId === facilitatorId) {
            this.sendTextMessage(member.roomId, `${member.name} has left the chat.`); // send notification to Support Chat Notifications room

            const currentDate = new Date();
            const chatTime = currentDate.toLocaleTimeString();
            const roomId = member.roomId.split(':')[0];
            const notification = `${member.name} left the chat at ${chatTime} (room ID: ${roomId})`;
            await this.sendTextMessage(this.config.facilitatorRoomId, notification);
          }
        } catch (err) {
          _logger.default.log("error", `ERROR NOTIFYING THAT FACLITATOR HAS LEFT THE ROOM ==> ${err}`);
        }

        const room = this.client.getRoom(member.roomId);
        if (!room) return;
        const roomMembers = await room.getJoinedMembers(); // array
        // leave if there is nobody in the room

        try {
          const memberCount = roomMembers.length;
          const isBotInRoom = Boolean(roomMembers.find(member => member.userId === this.config.botUserId));

          if (memberCount === 1 && isBotInRoom) {
            // just the bot left
            _logger.default.log("info", `LEAVING EMPTY ROOM: ${member.roomId}`);

            this.deleteTranscript(member.userId, member.roomId);
            this.localStorage.removeItem(`${member.roomId}-facilitator`);
            this.localStorage.removeItem(`${member.roomId}-transcript`);
            this.localStorage.removeItem(`${member.roomId}-waiting`);
            return await this.client.leave(member.roomId);
          }
        } catch (err) {
          return _logger.default.log("error", `ERROR LEAVING EMPTY ROOM ==> ${err}`);
        } // send signal to close the chat if there are no facilitators in the room


        try {
          const facilitatorRoomMembers = await this.client.getJoinedRoomMembers(this.config.facilitatorRoomId); // object

          const facilitators = facilitatorRoomMembers['joined'];
          let facilitatorInRoom = false;
          roomMembers.forEach(member => {
            if (member.userId !== this.config.botUserId && Boolean(facilitators[member.userId])) {
              facilitatorInRoom = true;
            }
          });

          if (!facilitatorInRoom) {
            _logger.default.log("info", `NO FACILITATORS LEFT, SENDING SIGNAL TO END CHAT`);

            this.sendBotSignal(member.roomId, BOT_SIGNAL_END_CHAT);
          }
        } catch (err) {
          _logger.default.log("error", `ERROR SENDING BOT SIGNAL ==> ${err}`);
        }
      }
    });
  }

  setTimeoutforFacilitator(roomId) {
    setTimeout(async () => {
      const stillWaiting = this.localStorage.getItem(`${roomId}-waiting`);

      if (stillWaiting) {
        await this.sendTextMessage(roomId, this.config.chatNotAvailableMessage);
        this.sendBotSignal(roomId, BOT_SIGNAL_END_CHAT); // send notification to Support Chat Notifications room

        const currentDate = new Date();
        const closedTime = currentDate.toLocaleTimeString();
        const roomRef = roomId.split(':')[0];
        const notification = `No facilitators joined the chat within the maximum wait time, chat closed at ${closedTime} (room ID: ${roomRef})`;
        this.sendTextMessage(this.config.facilitatorRoomId, notification);

        _logger.default.log("info", `NO FACILITATORS JOINED THE CHAT WITHIN THE MAXIMUM WAIT TIME, CHAT CLOSED AT ${closedTime} (room ID: ${roomRef})`);
      }
    }, this.config.maxWaitTime * 1000); // convert seconds to milliseconds
  }

  setInactivityTimeout(roomId) {
    const oldTimeout = this.inactivityTimers[roomId];

    if (oldTimeout) {
      clearTimeout(oldTimeout);
    }

    const newTimeout = setTimeout(async () => {
      _logger.default.log("info", `CHAT IS INACTIVE, SENDING SIGNAL TO END CHAT`);

      await this.sendTextMessage(roomId, this.config.chatInactiveMessage);
      this.sendBotSignal(roomId, BOT_SIGNAL_END_CHAT);
    }, this.config.maxInactiveTime * 1000); // convert seconds to milliseconds

    this.inactivityTimers[roomId] = newTimeout;
  }

  async setMessageListeners() {
    // encrypted messages
    this.client.on("Event.decrypted", (event, err) => {
      if (err) {
        return _logger.default.log("error", `ERROR DECRYPTING EVENT: ${err}`);
      }

      if (event.getType() === "m.room.message") {
        this.handleMessageEvent(event);
      }
    }); // unencrypted messages

    this.client.on("Room.timeline", (event, room, toStartOfTimeline) => {
      if (event.getType() === "m.room.message" && !event.isEncrypted()) {
        this.handleMessageEvent(event);
      }
    });
  }

  async sendBotSignal(roomId, signal, args) {
    let content = {
      signal: signal,
      args: args
    };

    try {
      await this.client.sendStateEvent(roomId, 'm.bot.signal', content);
    } catch (err) {
      _logger.default.log('error', "ERROR SENDING BOT SIGNAL => " + err);
    }
  }

  async start() {
    try {
      const localStorage = this.createLocalStorage();
      this.localStorage = localStorage;
      const auth = {
        user: this.config.botUsername,
        password: this.config.botPassword,
        initial_device_display_name: this.config.botDisplayName
      };
      const account = await this.client.login("m.login.password", auth);

      _logger.default.log("info", `ACCOUNT ==> ${JSON.stringify(account)}`);

      let opts = {
        baseUrl: this.config.matrixServerUrl,
        accessToken: account.access_token,
        userId: this.config.botUserId,
        deviceId: account.device_id,
        sessionStore: new matrix.WebStorageSessionStore(localStorage)
      };
      this.client = matrix.createClient(opts);
      await this.client.initCrypto();
      this.client.startClient({
        initialSyncLimit: 0
      });
      this.client.once('sync', async (state, prevState, data) => {
        _logger.default.log("info", `SYNC STATUS: ${state}`);

        if (state === 'PREPARED') {
          await this.deleteOldDevices();
          await this.leaveEmptyRooms();
          await this.trackJoinedRooms();
          await this.setMembershipListeners();
          await this.setMessageListeners();
        }
      });
    } catch (err) {
      this.handleBotCrash(undefined, err);

      _logger.default.log("error", `ERROR INITIALIZING CLIENT: ${err}`);
    }
  }

}

var _default = OcrccBot;
exports.default = _default;