hubot-pushbot/src/pushbot.js

PushBot implementation for hubot which is: "PushBot is an IRC bot that manages the topic in an IRC channel that has a push train."

// Description:
//   Pushbot for hubot
//
// Dependencies:
//   "typescript": "^1.5.0-beta",
//   "xregexp": "^2.0.0"
//
// Commands:
//   .join - Starts a pushbot session
//   .join before <username> - Starts a new pushbot session and moves before users's session
//   .join with <username> - Joins to a pushbot session
//   .hold <message> - Hold session, won't allow to change state or make it done
//   .unhold - Unhold session
//   .(uhoh|notgood|bad|fuck|fucked) - Mark yourself as not-all-good in the current push state
//   .(good|ok|in|go|great) - Mark yourself as all-good in the current push state
//   .(nm|nevermind|leave) - Hop out of queue
//   .message <message text> - Set session message
//   .kick <user> - Kicks user from session
//   .at <statename> - Changes session state
//   .done - Finishes session
//   .(drive|lead) - Take over leadership of session
//   .sessions - List sessions
//   .clearplease - Remove all sessions (all means all, not only for the room, but from the entire bot)


var __extends = (this && this.__extends) || function (d, b) {
    for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p];
    function __() { this.constructor = d; }
    d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
};
var KickAction = (function () {
    function KickAction() {
    }
    KickAction.prototype.requireLeader = function () {
        return false;
    };
    KickAction.prototype.requireMembership = function () {
        return true;
    };
    KickAction.prototype.requireAllUserGood = function () {
        return false;
    };
    return KickAction;
}());
var DoneAction = (function () {
    function DoneAction() {
    }
    DoneAction.prototype.requireLeader = function () {
        return false;
    };
    DoneAction.prototype.requireMembership = function () {
        return true;
    };
    DoneAction.prototype.requireAllUserGood = function () {
        return false;
    };
    return DoneAction;
}());
var PushbotErrors;
(function (PushbotErrors) {
    var PushbotError = (function () {
        function PushbotError() {
            this.stack = (new Error()).stack;
        }
        return PushbotError;
    }());
    var NotInSessionError = (function (_super) {
        __extends(NotInSessionError, _super);
        function NotInSessionError() {
            _super.apply(this, arguments);
            this.name = 'NotInSessionError';
            this.message = 'User not found in session';
        }
        return NotInSessionError;
    }(PushbotError));
    PushbotErrors.NotInSessionError = NotInSessionError;
    var NotLeadingError = (function (_super) {
        __extends(NotLeadingError, _super);
        function NotLeadingError() {
            _super.apply(this, arguments);
            this.name = 'NotLeadingError';
            this.message = 'You are not leading any session';
        }
        return NotLeadingError;
    }(PushbotError));
    PushbotErrors.NotLeadingError = NotLeadingError;
    var UserNotKickableError = (function (_super) {
        __extends(UserNotKickableError, _super);
        function UserNotKickableError() {
            _super.apply(this, arguments);
            this.name = 'UserNotKickable';
            this.message = 'You can not kick user';
        }
        return UserNotKickableError;
    }(PushbotError));
    PushbotErrors.UserNotKickableError = UserNotKickableError;
    var AlreadyInSessionError = (function (_super) {
        __extends(AlreadyInSessionError, _super);
        function AlreadyInSessionError() {
            _super.apply(this, arguments);
            this.name = 'AlreadyInSessionError';
            this.message = 'User already participating in session';
        }
        return AlreadyInSessionError;
    }(PushbotError));
    PushbotErrors.AlreadyInSessionError = AlreadyInSessionError;
    var PermissionDeniedError = (function (_super) {
        __extends(PermissionDeniedError, _super);
        function PermissionDeniedError() {
            _super.apply(this, arguments);
            this.name = 'PermissionDeniedError';
            this.message = 'You have no permission to perform the action';
        }
        return PermissionDeniedError;
    }(PushbotError));
    PushbotErrors.PermissionDeniedError = PermissionDeniedError;
    var UsersNotReadyError = (function (_super) {
        __extends(UsersNotReadyError, _super);
        function UsersNotReadyError(users) {
            _super.call(this);
            this.name = 'UsersNotReadyError';
            if (users && users.length) {
                this.message = 'Users are not ready: ' + users.join(', ');
            }
            else {
                this.message = 'Users are not ready';
            }
        }
        return UsersNotReadyError;
    }(PushbotError));
    PushbotErrors.UsersNotReadyError = UsersNotReadyError;
    var UserNotFoundError = (function (_super) {
        __extends(UserNotFoundError, _super);
        function UserNotFoundError() {
            _super.apply(this, arguments);
            this.name = 'UserNotFoundError';
            this.message = 'User not found';
        }
        return UserNotFoundError;
    }(PushbotError));
    PushbotErrors.UserNotFoundError = UserNotFoundError;
    var LeaderCanNotLeaveError = (function (_super) {
        __extends(LeaderCanNotLeaveError, _super);
        function LeaderCanNotLeaveError() {
            _super.apply(this, arguments);
            this.name = 'LeaderCanNotLeaveError';
            this.message = 'Leader can not leave the session';
        }
        return LeaderCanNotLeaveError;
    }(PushbotError));
    PushbotErrors.LeaderCanNotLeaveError = LeaderCanNotLeaveError;
    var NotChangedError = (function (_super) {
        __extends(NotChangedError, _super);
        function NotChangedError() {
            _super.apply(this, arguments);
            this.name = 'NotChangedError';
            this.message = 'Value not changed';
        }
        return NotChangedError;
    }(PushbotError));
    PushbotErrors.NotChangedError = NotChangedError;
    var RoomHoldedError = (function (_super) {
        __extends(RoomHoldedError, _super);
        function RoomHoldedError() {
            _super.apply(this, arguments);
            this.name = 'RoomHoldedError';
            this.message = 'Room holded';
        }
        return RoomHoldedError;
    }(PushbotError));
    PushbotErrors.RoomHoldedError = RoomHoldedError;
})(PushbotErrors || (PushbotErrors = {}));
var util;
(function (util) {
    function findIndex(array, test) {
        var index = -1;
        for (var i = 0, rl = array.length; i < rl; i++) {
            if (test(array[i])) {
                index = i;
                break;
            }
        }
        return index;
    }
    util.findIndex = findIndex;
    function invoke(method) {
        return function (obj) {
            return obj[method]();
        };
    }
    util.invoke = invoke;
})(util || (util = {}));
var User;
(function (User_1) {
    (function (UserState) {
        UserState[UserState["Good"] = 0] = "Good";
        UserState[UserState["Uhoh"] = 1] = "Uhoh";
        UserState[UserState["Waiting"] = 2] = "Waiting";
        UserState[UserState["Spectate"] = 3] = "Spectate";
    })(User_1.UserState || (User_1.UserState = {}));
    var UserState = User_1.UserState;
    var User = (function () {
        function User(userData) {
            this.name = userData.name;
            this.state = userData.state;
            this.__ref = userData;
        }
        User.prototype.getName = function () {
            return this.name;
        };
        User.prototype.getState = function () {
            return this.state;
        };
        User.prototype.setState = function (state) {
            this.__ref.state = state;
            this.state = state;
        };
        User.prototype.isGood = function () {
            return this.getState() === UserState.Good;
        };
        User.prototype.isHolding = function () {
            return this.getState() === UserState.Uhoh;
        };
        User.prototype.isSpectating = function () {
            return this.getState() === UserState.Spectate;
        };
        return User;
    }());
    User_1.User = User;
    function createUser(userData) {
        return new User(userData);
    }
    User_1.createUser = createUser;
})(User || (User = {}));
var Session;
(function (Session_1) {
    var Session = (function () {
        function Session(session) {
            this.leader = session.leader;
            this.state = session.state;
            this.message = session.message;
            this.users = session.users;
            this.__ref = session;
        }
        Session.prototype.getLeader = function () {
            return this.leader;
        };
        Session.prototype.getUsers = function () {
            return this.users;
        };
        Session.prototype.getState = function () {
            return this.state;
        };
        Session.prototype.getMessage = function () {
            return this.message;
        };
        Session.prototype.getHoldMessage = function () {
            return this.holdMessage;
        };
        Session.prototype.setState = function (state) {
            this.state = state;
            this.__ref.state = state;
        };
        Session.prototype.setMessage = function (message) {
            this.message = message;
            this.__ref.message = message;
        };
        Session.prototype.setLeader = function (leaderName) {
            this.leader = leaderName;
            this.__ref.leader = leaderName;
        };
        Session.prototype.addUser = function (userName) {
            this.getUsers().push({
                name: userName,
                state: User.UserState.Waiting
            });
        };
        Session.prototype.isLeaderJoined = function () {
            var _this = this;
            return this.getUsers().some(function (user) {
                return _this.isUserLeader(User.createUser(user).getName());
            });
        };
        Session.prototype.isUserLeader = function (userName) {
            return this.getLeader() === userName;
        };
        Session.prototype.isUserMember = function (userName) {
            return this.getUsers().some(function (user) { return User.createUser(user).getName() === userName; });
        };
        Session.prototype.isAllUserGood = function () {
            return this.getUsers().map(User.createUser).every(util.invoke('isGood'));
        };
        Session.prototype.isAnyUserBad = function () {
            return this.getUsers().map(User.createUser).some(util.invoke('isHolding'));
        };
        Session.prototype.resetUsers = function () {
            this.getUsers().map(User.createUser).forEach(function (user) {
                user.setState(User.UserState.Waiting);
            });
        };
        Session.prototype.getUserIndex = function (userName) {
            var index = -1;
            var users = this.getUsers();
            index = util.findIndex(users, function (user) {
                return User.createUser(user).getName() === userName;
            });
            return index;
        };
        Session.prototype.getHoldingUsers = function () {
            return this.getUsers().map(User.createUser).filter(function (user) {
                return user.isGood();
            });
        };
        return Session;
    }());
    Session_1.Session = Session;
    function sessionObj(session) {
        return new Session(session);
    }
    Session_1.sessionObj = sessionObj;
})(Session || (Session = {}));
var Room;
(function (Room_1) {
    var Room = (function () {
        function Room(room) {
            this.sessions = room.sessions;
            this.holdMessage = room.holdMessage;
            this.holded = room.holded;
            this.__ref = room;
        }
        Room.prototype.getSessions = function () {
            return this.sessions;
        };
        Room.prototype.setSessions = function (sessions) {
            this.sessions = sessions;
            this.__ref.sessions = sessions;
        };
        Room.prototype.isHolded = function () {
            return this.holded;
        };
        Room.prototype.hold = function () {
            this.holded = true;
            this.__ref.holded = true;
        };
        Room.prototype.unhold = function () {
            this.holded = false;
            this.__ref.holded = false;
        };
        Room.prototype.setHoldMessage = function (message) {
            this.holdMessage = message;
            this.__ref.holdMessage = message;
        };
        Room.prototype.getHoldMessage = function () {
            return this.holdMessage;
        };
        Room.prototype.isUserInSession = function (userName) {
            var roomSessions = this.getSessions();
            if (!roomSessions) {
                return false;
            }
            var index = util.findIndex(roomSessions, function (session) {
                return Session.sessionObj(session).isUserMember(userName);
            });
            return index > -1;
        };
        return Room;
    }());
    Room_1.Room = Room;
})(Room || (Room = {}));
var Brain;
(function (Brain_1) {
    var Brain = (function () {
        function Brain(robot) {
            if (!robot.brain.data.pushbot) {
                robot.brain.data.pushbot = Object.create(null);
            }
            this.data = robot.brain.data.pushbot;
        }
        Brain.prototype.getRooms = function () {
            return this.data;
        };
        Brain.prototype.getRoom = function (room) {
            var roomObj = this.getRooms()[room];
            if (roomObj) {
                return new Room.Room(roomObj);
            }
            return null;
        };
        Brain.prototype.getRoomSessions = function (room) {
            var roomData = this.getRoom(room);
            return roomData && roomData.getSessions();
        };
        Brain.prototype.hasSessions = function (room) {
            var roomSessions = this.getRoomSessions(room);
            return roomSessions && roomSessions.length > 0;
        };
        Brain.prototype.setRoomData = function (room) {
            this.getRooms()[room] = {
                holded: false,
                sessions: []
            };
        };
        Brain.prototype.setRoomSessions = function (room, sessions) {
            var roomData = this.getRoom(room);
            if (!roomData) {
                this.setRoomData(room);
            }
            this.getRoom(room).setSessions(sessions);
        };
        Brain.prototype.clearRoomSessions = function (room) {
            this.setRoomData(room);
        };
        Brain.prototype.setRoomSessionAtIndex = function (room, index, session) {
            this.getRoomSessions(room)[index] = session;
        };
        Brain.prototype.getRoomSessionAtIndex = function (room, index) {
            var rooms = this.getRoomSessions(room);
            if (rooms && rooms.length > index) {
                return rooms[index];
            }
            return null;
        };
        return Brain;
    }());
    Brain_1.Brain = Brain;
})(Brain || (Brain = {}));
var XRegExp = require('xregexp');
function createAction(name) {
    var output;
    switch (name) {
        case 'kick':
            output = new KickAction();
            break;
        case 'done':
            output = new DoneAction();
            break;
        default:
            output = null;
    }
    return output;
}
var defaultMessage = '-';
function createSession(leader) {
    return {
        leader: leader,
        state: '',
        holded: false,
        holdMessage: '',
        message: defaultMessage,
        users: [{
                name: leader,
                state: User.UserState.Waiting
            }]
    };
}
module.exports = function (robot) {
    'use strict';
    function createBrain() {
        return new Brain.Brain(robot);
    }
    var commands = {
        join: ['join'],
        joinBefore: ['join before'],
        joinWith: ['join with'],
        hold: ['hold'],
        unhold: ['unhold'],
        uhoh: ['uhoh', 'notgood', 'bad', 'fuck', 'fucked'],
        good: ['good', 'ok', 'in', 'go', 'great'],
        spectate: ['spectate'],
        nevermind: ['leave', 'nevermind', 'nm'],
        message: ['message'],
        kick: ['kick'],
        at: ['at'],
        done: ['done'],
        drive: ['drive', 'lead'],
        sessions: ['sessions'],
        clearplease: ['clearplease']
    };
    var messageRegexp = '[\\p{Latin}\\p{Common}\\w\'"(){}\\[\\]+*&%$#@~<>=/\\\\ .:;!?_-]+', userNameRegexp = '[\\w_-][\\w._-]+', stateNameRegexp = '[\\p{Latin}\\p{Common}\\w_-]+';
    var emptyMessage = '-';
    var bot = '.', goodUserMarker = '✓', holdingUserMarker = '✗', spectateUserMarker = '☺';
    function hasPermission(user, action, session) {
        if (action.requireLeader() && user !== session.getLeader()) {
            return false;
        }
        if (action.requireMembership() && !session.isUserMember(user)) {
            return false;
        }
        return true;
    }
    function isUsersStateOk(action, session) {
        return !action.requireAllUserGood() || !session.isAllUserGood();
    }
    function getSortedSessionUsers(sess) {
        var users = sess.getUsers().map(User.createUser);
        var leader = sess.getLeader();
        users.sort(function (a, b) {
            if (a.getName() === leader) {
                return -1;
            }
            else if (b.getName() === leader) {
                return 1;
            }
            else {
                return 0;
            }
        });
        return users;
    }
    function getUserListStr(users) {
        return users.map(function (user) {
            var userName = user.getName();
            if (user.isGood()) {
                return "" + goodUserMarker + userName;
            }
            else if (user.isHolding()) {
                return "" + holdingUserMarker + userName;
            }
            else if (user.isSpectating()) {
                return "" + spectateUserMarker + userName;
            }
            else {
                return userName;
            }
        }).join(' + ');
    }
    function getStateStrForSession(session) {
        var sess = Session.sessionObj(session);
        var msg = [];
        if (sess.getMessage() && sess.getMessage() !== emptyMessage) {
            msg.push(sess.getMessage());
        }
        if (sess.getState()) {
            msg.push('<' + sess.getState() + '>');
        }
        msg.push(getUserListStr(getSortedSessionUsers(sess)));
        return msg.join(' ');
    }
    function createRoom(room) {
        var brain = createBrain();
        if (!brain.getRoomSessions(room)) {
            brain.setRoomSessions(room, []);
        }
    }
    function setTopic(msg) {
        var topic = getTopicString(msg.message.room);
        robot.logger.debug('Set topic:', topic, 'room:', msg.message.room);
        if ('setTopic' in msg.robot.adapter) {
            return msg.runWithMiddleware('setTopic', { plaintext: true }, topic);
        }
        return msg.topic(topic);
    }
    function addSession(room, leader) {
        createRoom(room);
        var roomSessions = createBrain().getRoomSessions(room);
        roomSessions.push(createSession(leader));
        return null;
    }
    function insertSession(room, leader, beforeIndex) {
        var roomSessions = createBrain().getRoomSessions(room);
        roomSessions.splice(beforeIndex, 0, createSession(leader));
        return null;
    }
    function removeSession(room, leader) {
        var brain = createBrain();
        var roomSessions = brain.getRoomSessions(room);
        var index = -1;
        index = util.findIndex(roomSessions, function (session) {
            return Session.sessionObj(session).isUserLeader(leader);
        });
        if (index > -1) {
            roomSessions.splice(index, 1);
            brain.setRoomSessions(room, roomSessions);
        }
    }
    function findSessionIndexWithUser(room, userName) {
        var brain = createBrain(), roomSessions;
        if (!brain.hasSessions(room)) {
            return -1;
        }
        roomSessions = brain.getRoomSessions(room);
        return util.findIndex(roomSessions, function (session) {
            return Session.sessionObj(session).getUserIndex(userName) > -1;
        });
    }
    function leaveSession(room, userName) {
        createRoom(room);
        var brain = createBrain();
        var roomSessions = brain.getRoomSessions(room);
        var index = util.findIndex(roomSessions, function (session) {
            return Session.sessionObj(session).getUserIndex(userName) > -1;
        });
        if (brain.getRoom(room).isUserInSession(userName)) {
            var session = brain.getRoomSessionAtIndex(room, index);
            ;
            var sess = Session.sessionObj(session);
            if (sess.isUserLeader(userName)) {
                return new PushbotErrors.LeaderCanNotLeaveError();
            }
            var userIndex = sess.getUserIndex(userName);
            if (userIndex === -1) {
                return new PushbotErrors.UserNotFoundError();
            }
            var users = sess.getUsers();
            users.splice(userIndex, 1);
            if (users.length === 0) {
                removeSession(room, sess.getLeader());
            }
            else {
                if (!sess.isLeaderJoined()) {
                    sess.setLeader(users[0].name);
                }
                brain.setRoomSessionAtIndex(room, index, session);
            }
            return null;
        }
        else {
            return new PushbotErrors.NotInSessionError();
        }
    }
    function joinSession(room, refUser, user) {
        createRoom(room);
        var sessionIndex = findSessionIndexWithUser(room, refUser);
        if (sessionIndex === -1) {
            return new PushbotErrors.NotInSessionError();
        }
        var session = createBrain().getRoomSessionAtIndex(room, sessionIndex);
        if (Session.sessionObj(session).getUserIndex(user) > -1) {
            return new PushbotErrors.AlreadyInSessionError();
        }
        else {
            Session.sessionObj(session).addUser(user);
            return null;
        }
    }
    function setUserState(room, userName, state) {
        var index = findSessionIndexWithUser(room, userName);
        if (index > -1) {
            var brain = createBrain();
            var session = brain.getRoomSessionAtIndex(room, index);
            var sess = Session.sessionObj(session);
            var userIndex = sess.getUserIndex(userName);
            if (User.createUser(sess.getUsers()[userIndex]).getState() === state) {
                return new PushbotErrors.NotChangedError();
            }
            sess.getUsers()[userIndex].state = state;
            brain.setRoomSessionAtIndex(room, index, session);
            return null;
        }
        else {
            return new PushbotErrors.NotInSessionError();
        }
    }
    function finish(room, userName) {
        createRoom(room);
        var brain = createBrain();
        if (brain.getRoom(room).isHolded()) {
            return new PushbotErrors.RoomHoldedError();
        }
        var index = findSessionIndexWithUser(room, userName);
        if (index > -1) {
            var session = createBrain().getRoomSessionAtIndex(room, index);
            var sess = Session.sessionObj(session);
            var action = createAction('done');
            if (!hasPermission(userName, action, sess)) {
                return new PushbotErrors.PermissionDeniedError();
            }
            if (!isUsersStateOk(action, sess)) {
                return new PushbotErrors.UsersNotReadyError(sess.getHoldingUsers().map(util.invoke('getName')));
            }
            removeSession(room, sess.getLeader());
            return null;
        }
        return new PushbotErrors.NotInSessionError();
    }
    function setRoomState(room, userName, state) {
        createRoom(room);
        var brain = createBrain();
        if (brain.getRoom(room).isHolded()) {
            return new PushbotErrors.RoomHoldedError();
        }
        var index = findSessionIndexWithUser(room, userName);
        robot.logger.debug('set room state call', index, room, userName, state);
        if (index !== -1) {
            var session = brain.getRoomSessionAtIndex(room, index);
            var sess = Session.sessionObj(session);
            if (sess.isAnyUserBad()) {
                var userNames = sess.getUsers()
                    .map(User.createUser)
                    .filter(util.invoke('isHolding'))
                    .map(util.invoke('getName'));
                return new PushbotErrors.UsersNotReadyError(userNames);
            }
            if (sess.getState() === state) {
                return new PushbotErrors.NotChangedError();
            }
            sess.setState(state);
            sess.resetUsers();
            return null;
        }
        else {
            return new PushbotErrors.NotLeadingError();
        }
    }
    function unholdRoom(room) {
        createRoom(room);
        var brain = createBrain();
        var roomObj = brain.getRoom(room);
        if (!roomObj) {
            createRoom(room);
            roomObj = brain.getRoom(room);
        }
        if (!roomObj.isHolded()) {
            return new PushbotErrors.NotChangedError();
        }
        roomObj.unhold();
        roomObj.setHoldMessage('');
        return null;
    }
    function holdRoom(room, message) {
        createRoom(room);
        var brain = createBrain();
        var roomObj = brain.getRoom(room);
        roomObj.hold();
        roomObj.setHoldMessage(message);
        return null;
    }
    function driveSession(room, userName) {
        var sessionIndex = findSessionIndexWithUser(room, userName);
        if (sessionIndex === -1) {
            return new PushbotErrors.NotInSessionError();
        }
        var session = createBrain().getRoomSessionAtIndex(room, sessionIndex);
        var sess = Session.sessionObj(session);
        if (sess.isUserLeader(userName)) {
            return new PushbotErrors.NotChangedError();
        }
        Session.sessionObj(session).setLeader(userName);
        return null;
    }
    function getTopicString(room) {
        var brain = createBrain();
        var roomObj = brain.getRoom(room);
        var roomSessions = createBrain().getRoomSessions(room);
        var topic = [];
        if (roomObj.isHolded()) {
            var holdMessage = roomObj.getHoldMessage();
            topic.push("HOLD: \u2602 " + holdMessage + "  \u2602");
        }
        topic = topic.concat(roomSessions.map(getStateStrForSession));
        return topic.join(' | ');
    }
    function kickUser(room, leader, userName) {
        var index = findSessionIndexWithUser(room, leader);
        if (index === -1) {
            return new PushbotErrors.NotInSessionError();
        }
        var session = createBrain().getRoomSessionAtIndex(room, index);
        if (!hasPermission(leader, createAction('kick'), Session.sessionObj(session))) {
            return new PushbotErrors.PermissionDeniedError();
        }
        if (leader === userName) {
            return new PushbotErrors.UserNotKickableError();
        }
        return leaveSession(room, userName);
    }
    function setMessage(room, userName, message) {
        var sessionIndex = findSessionIndexWithUser(room, userName);
        if (sessionIndex === -1) {
            return new PushbotErrors.NotInSessionError();
        }
        var session = createBrain().getRoomSessionAtIndex(room, sessionIndex);
        var sess = Session.sessionObj(session);
        if (sess.getMessage() === message) {
            return new PushbotErrors.NotChangedError();
        }
        sess.setMessage(message);
        return null;
    }
    function extractMsgDetails(msg) {
        return {
            room: msg.message.room,
            userName: msg.message.user.name
        };
    }
    function onJoinCommand(msg) {
        var _a = extractMsgDetails(msg), room = _a.room, userName = _a.userName;
        var err = addSession(room, userName);
        if (err) {
            msg.reply(err.message);
            robot.logger.error(err);
        }
        else {
            setTopic(msg);
        }
    }
    function onNevermindCommand(msg) {
        var _a = extractMsgDetails(msg), room = _a.room, userName = _a.userName;
        var err = leaveSession(room, userName);
        if (err && !(err instanceof PushbotErrors.NotInSessionError)) {
            msg.reply(err.message);
            robot.logger.error('.nevermind:', err);
        }
        else {
            setTopic(msg);
        }
    }
    function onJoinWithCommand(msg) {
        var _a = extractMsgDetails(msg), room = _a.room, userName = _a.userName;
        var leader = msg.match[1];
        var err = joinSession(room, leader, userName);
        if (err) {
            msg.reply(err.message);
            robot.logger.error('.join with:', err);
        }
        else {
            setTopic(msg);
        }
    }
    function onJoinBeforeCommand(msg) {
        var _a = extractMsgDetails(msg), room = _a.room, userName = _a.userName;
        var refUser = msg.match[1];
        var sessionIndex = findSessionIndexWithUser(room, refUser);
        var err;
        if (sessionIndex === -1) {
            err = new PushbotErrors.NotInSessionError();
        }
        else {
            err = insertSession(room, userName, sessionIndex);
        }
        if (err) {
            msg.reply(err.message);
            robot.logger.error('.join before:', err);
        }
        else {
            setTopic(msg);
        }
    }
    function onDoneCommand(msg) {
        var _a = extractMsgDetails(msg), room = _a.room, userName = _a.userName;
        var err = finish(room, userName);
        if (err) {
            if (!(err instanceof PushbotErrors.NotInSessionError)) {
                msg.reply(err.message);
            }
        }
        else {
            var nextSession = createBrain().getRoomSessionAtIndex(room, 0);
            if (nextSession) {
                msg.send(nextSession.users.map(User.createUser).map(util.invoke('getName')).join(', ') + ': You are up!');
            }
            setTopic(msg);
        }
    }
    function onAtCommand(msg) {
        var _a = extractMsgDetails(msg), room = _a.room, userName = _a.userName;
        var err = setRoomState(room, userName, msg.match[1]);
        robot.logger.debug('set room state', err);
        if (err) {
            if (!(err instanceof PushbotErrors.NotChangedError)) {
                msg.reply(err.message);
                robot.logger.error('.at:', err);
            }
        }
        else {
            setTopic(msg);
        }
    }
    function onGoodCommand(msg) {
        var _a = extractMsgDetails(msg), room = _a.room, userName = _a.userName;
        var err = setUserState(room, userName, User.UserState.Good);
        if (err) {
            if (!(err instanceof PushbotErrors.NotChangedError)) {
                msg.reply(err.message);
                robot.logger.error('.good:', err);
            }
        }
        else {
            var sessionIndex = findSessionIndexWithUser(room, userName);
            var session = createBrain().getRoomSessionAtIndex(room, sessionIndex);
            var sess = Session.sessionObj(session);
            if (sess.isAllUserGood()) {
                msg.send(getSortedSessionUsers(sess).map(util.invoke('getName')).join(', ') + ': Everyone is ready');
            }
            setTopic(msg);
        }
    }
    function onUhOhCommand(msg) {
        var _a = extractMsgDetails(msg), room = _a.room, userName = _a.userName;
        var err = setUserState(room, userName, User.UserState.Uhoh);
        if (err) {
            if (!(err instanceof PushbotErrors.NotChangedError)) {
                msg.reply(err.message);
                robot.logger.error('.uhoh:', err);
            }
        }
        else {
            setTopic(msg);
        }
    }
    function onSpectateCommand(msg) {
        var _a = extractMsgDetails(msg), room = _a.room, userName = _a.userName;
        var err = setUserState(room, userName, User.UserState.Spectate);
        if (err) {
            if (!(err instanceof PushbotErrors.NotChangedError)) {
                msg.reply(err.message);
                robot.logger.error('.spectate:', err);
            }
        }
        else {
            setTopic(msg);
        }
    }
    function onHoldCommand(msg) {
        robot.logger.debug('COMMANBD HOLD');
        var room = msg.message.room;
        var message = msg.match[1];
        var err = holdRoom(room, message);
        if (err) {
            msg.reply(err.message);
            robot.logger.error('.hold:', err);
        }
        else {
            setTopic(msg);
        }
    }
    function onUnholdCommand(msg) {
        var room = msg.message.room;
        var err = unholdRoom(room);
        if (err) {
            if (!(err instanceof PushbotErrors.NotChangedError)) {
                msg.reply(err.message);
                robot.logger.error('.unhold:', err);
            }
        }
        else {
            setTopic(msg);
        }
    }
    function onSessionsCommand(msg) {
        var room = msg.message.room;
        var brain = createBrain();
        var roomSessions = brain.getRoomSessions(room);
        if (roomSessions && roomSessions.length) {
            msg.reply(roomSessions.map(function (session) {
                var msg = [];
                var sess = Session.sessionObj(session);
                if (sess.getState()) {
                    msg.push('<' + sess.getState() + '>');
                }
                if (sess.getMessage() && sess.getMessage() !== emptyMessage) {
                    msg.push('message: ' + sess.getMessage());
                }
                msg.push('leader: ' + sess.getLeader());
                if (sess.getUsers().length > 1) {
                    msg.push('participants: ' + getUserListStr(getSortedSessionUsers(sess).filter(function (u) {
                        return u.getName() !== sess.getLeader();
                    })));
                }
                return msg.join(', ');
            }).join('\n'));
        }
        else {
            msg.reply('No sessions so far');
        }
    }
    function onKickCommand(msg) {
        var _a = extractMsgDetails(msg), room = _a.room, userName = _a.userName;
        var err = kickUser(room, userName, msg.match[1]);
        if (err && !(err instanceof PushbotErrors.NotInSessionError)) {
            msg.reply(err.message);
            robot.logger.error('.kick:', err);
        }
        else {
            setTopic(msg);
        }
    }
    function onMessageCommand(msg) {
        var _a = extractMsgDetails(msg), room = _a.room, userName = _a.userName;
        var err = setMessage(room, userName, msg.match[1]);
        if (err) {
            if (!(err instanceof PushbotErrors.NotChangedError)) {
                msg.reply(err.message);
            }
        }
        else {
            setTopic(msg);
        }
    }
    function onClearPleaseCommand(msg) {
        createBrain().clearRoomSessions(msg.message.room);
        setTopic(msg);
    }
    function onDriveCommand(msg) {
        var _a = extractMsgDetails(msg), room = _a.room, userName = _a.userName;
        var err = driveSession(room, userName);
        if (err) {
            if (err instanceof PushbotErrors.NotChangedError) {
                return;
            }
            msg.reply(err.message);
            return;
        }
        setTopic(msg);
    }
    function createCommandRegexp(commands, args) {
        if (args) {
            return new XRegExp('^\\' + bot + '(?:' + commands.join('|') + ') (' + args + ')\\s*$');
        }
        else {
            return new XRegExp('^\\' + bot + '(?:' + commands.join('|') + ')\\s*$');
        }
    }
    robot.brain.on('loaded', function () {
        if (!robot.brain.data.pushbot) {
            robot.brain.data.pushbot = {};
        }
    });
    robot.hear(createCommandRegexp(commands.join), onJoinCommand);
    robot.hear(createCommandRegexp(commands.nevermind), onNevermindCommand);
    robot.hear(createCommandRegexp(commands.joinWith, userNameRegexp), onJoinWithCommand);
    robot.hear(createCommandRegexp(commands.joinBefore, userNameRegexp), onJoinBeforeCommand);
    robot.hear(createCommandRegexp(commands.done), onDoneCommand);
    robot.hear(createCommandRegexp(commands.at, stateNameRegexp), onAtCommand);
    robot.hear(createCommandRegexp(commands.good), onGoodCommand);
    robot.hear(createCommandRegexp(commands.uhoh), onUhOhCommand);
    robot.hear(createCommandRegexp(commands.spectate), onSpectateCommand);
    robot.hear(createCommandRegexp(commands.hold, messageRegexp), onHoldCommand);
    robot.hear(createCommandRegexp(commands.unhold), onUnholdCommand);
    robot.hear(createCommandRegexp(commands.sessions), onSessionsCommand);
    robot.hear(createCommandRegexp(commands.kick, userNameRegexp), onKickCommand);
    robot.hear(createCommandRegexp(commands.message, messageRegexp), onMessageCommand);
    robot.hear(createCommandRegexp(commands.clearplease), onClearPleaseCommand);
    robot.hear(createCommandRegexp(commands.drive), onDriveCommand);
};