@lordbex/thelounge 4.4.3-blowfish

package/dist/server/plugins/irc-events/mode.js

@@ -0,0 +1,124 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const lodash_1 = __importDefault(require("lodash"));
+const msg_1 = __importDefault(require("../../models/msg"));
+const msg_2 = require("../../../shared/types/msg");
+exports.default = (function (irc, network) {
+    const client = this;
+    // The following saves the channel key based on channel mode instead of
+    // extracting it from `/join #channel key`. This lets us not have to
+    // temporarily store the key until successful join, but also saves the key
+    // if a key is set or changed while being on the channel.
+    irc.on("channel info", function (data) {
+        if (!data.modes) {
+            return;
+        }
+        const targetChan = network.getChannel(data.channel);
+        if (typeof targetChan === "undefined") {
+            return;
+        }
+        data.modes.forEach((mode) => {
+            const text = mode.mode;
+            const add = text[0] === "+";
+            const char = text[1];
+            if (char === "k") {
+                targetChan.key = add ? mode.param : "";
+                client.save();
+            }
+        });
+        const msg = new msg_1.default({
+            type: msg_2.MessageType.MODE_CHANNEL,
+            text: `${data.raw_modes} ${data.raw_params.join(" ")}`,
+        });
+        targetChan.pushMessage(client, msg);
+    });
+    irc.on("user info", function (data) {
+        const serverChan = network.getLobby();
+        const msg = new msg_1.default({
+            type: msg_2.MessageType.MODE_USER,
+            raw_modes: data.raw_modes,
+            self: false,
+            showInActive: true,
+        });
+        serverChan.pushMessage(client, msg);
+    });
+    irc.on("mode", function (data) {
+        let targetChan;
+        if (data.target === irc.user.nick) {
+            targetChan = network.getLobby();
+        }
+        else {
+            targetChan = network.getChannel(data.target);
+            if (typeof targetChan === "undefined") {
+                return;
+            }
+        }
+        const msg = new msg_1.default({
+            time: data.time,
+            type: msg_2.MessageType.MODE,
+            from: targetChan.getUser(data.nick),
+            text: `${data.raw_modes} ${data.raw_params.join(" ")}`,
+            self: data.nick === irc.user.nick,
+        });
+        const users = [];
+        for (const param of data.raw_params) {
+            if (targetChan.findUser(param)) {
+                users.push(param);
+            }
+        }
+        if (users.length > 0) {
+            msg.users = users;
+        }
+        targetChan.pushMessage(client, msg);
+        let usersUpdated = false;
+        const userModeSortPriority = {};
+        const supportsMultiPrefix = network.irc.network.cap.isEnabled("multi-prefix");
+        irc.network.options.PREFIX.forEach((prefix, index) => {
+            userModeSortPriority[prefix.symbol] = index;
+        });
+        data.modes.forEach((mode) => {
+            const add = mode.mode[0] === "+";
+            const char = mode.mode[1];
+            if (char === "k") {
+                targetChan.key = add ? mode.param : "";
+                client.save();
+            }
+            if (!mode.param) {
+                return;
+            }
+            const user = targetChan.findUser(mode.param);
+            if (!user) {
+                return;
+            }
+            usersUpdated = true;
+            if (!supportsMultiPrefix) {
+                return;
+            }
+            const changedMode = network.serverOptions.PREFIX.modeToSymbol[char];
+            if (!add) {
+                lodash_1.default.pull(user.modes, changedMode);
+            }
+            else if (!user.modes.includes(changedMode)) {
+                user.modes.push(changedMode);
+                user.modes.sort(function (a, b) {
+                    return userModeSortPriority[a] - userModeSortPriority[b];
+                });
+            }
+        });
+        if (!usersUpdated) {
+            return;
+        }
+        if (!supportsMultiPrefix) {
+            // TODO: This is horrible
+            irc.raw("NAMES", data.target);
+        }
+        else {
+            client.emit("users", {
+                chan: targetChan.id,
+            });
+        }
+    });
+});

package/dist/server/plugins/irc-events/modelist.js

@@ -0,0 +1,67 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const msg_1 = __importDefault(require("../../models/msg"));
+const msg_2 = require("../../../shared/types/msg");
+const chan_1 = require("../../../shared/types/chan");
+exports.default = (function (irc, network) {
+    const client = this;
+    irc.on("banlist", (list) => {
+        const data = list.bans.map((ban) => ({
+            hostmask: ban.banned,
+            banned_by: ban.banned_by,
+            banned_at: ban.banned_at * 1000,
+        }));
+        handleList(chan_1.SpecialChanType.BANLIST, "Ban list", list.channel, data);
+    });
+    irc.on("inviteList", (list) => {
+        const data = list.invites.map((invite) => ({
+            hostmask: invite.invited,
+            invited_by: invite.invited_by,
+            invited_at: invite.invited_at * 1000,
+        }));
+        handleList(chan_1.SpecialChanType.INVITELIST, "Invite list", list.channel, data);
+    });
+    function handleList(type, name, channel, data) {
+        if (data.length === 0) {
+            const msg = new msg_1.default({
+                time: new Date(),
+                type: msg_2.MessageType.ERROR,
+                text: `${name} is empty`,
+            });
+            let chan = network.getChannel(channel);
+            // Send error to lobby if we receive empty list for a channel we're not in
+            if (typeof chan === "undefined") {
+                msg.showInActive = true;
+                chan = network.getLobby();
+            }
+            chan.pushMessage(client, msg, true);
+            return;
+        }
+        const chanName = `${name} for ${channel}`;
+        let chan = network.getChannel(chanName);
+        if (typeof chan === "undefined") {
+            chan = client.createChannel({
+                type: chan_1.ChanType.SPECIAL,
+                special: type,
+                name: chanName,
+                data: data,
+            });
+            client.emit("join", {
+                network: network.uuid,
+                chan: chan.getFilteredClone(true),
+                shouldOpen: false,
+                index: network.addChannel(chan),
+            });
+        }
+        else {
+            chan.data = data;
+            client.emit("msg:special", {
+                chan: chan.id,
+                data: data,
+            });
+        }
+    }
+});

package/dist/server/plugins/irc-events/motd.js

@@ -0,0 +1,29 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const msg_1 = __importDefault(require("../../models/msg"));
+const msg_2 = require("../../../shared/types/msg");
+exports.default = (function (irc, network) {
+    const client = this;
+    irc.on("motd", function (data) {
+        const lobby = network.getLobby();
+        if (data.motd) {
+            const msg = new msg_1.default({
+                type: msg_2.MessageType.MONOSPACE_BLOCK,
+                command: "motd",
+                text: data.motd,
+            });
+            lobby.pushMessage(client, msg);
+        }
+        if (data.error) {
+            const msg = new msg_1.default({
+                type: msg_2.MessageType.MONOSPACE_BLOCK,
+                command: "motd",
+                text: data.error,
+            });
+            lobby.pushMessage(client, msg);
+        }
+    });
+});

package/dist/server/plugins/irc-events/names.js

@@ -0,0 +1,21 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.default = (function (irc, network) {
+    const client = this;
+    irc.on("userlist", function (data) {
+        const chan = network.getChannel(data.channel);
+        if (typeof chan === "undefined") {
+            return;
+        }
+        const newUsers = new Map();
+        data.users.forEach((user) => {
+            const newUser = chan.getUser(user.nick);
+            newUser.setModes(user.modes, network.serverOptions.PREFIX);
+            newUsers.set(user.nick.toLowerCase(), newUser);
+        });
+        chan.users = newUsers;
+        client.emit("users", {
+            chan: chan.id,
+        });
+    });
+});

package/dist/server/plugins/irc-events/nick.js

@@ -0,0 +1,45 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const msg_1 = __importDefault(require("../../models/msg"));
+const msg_2 = require("../../../shared/types/msg");
+exports.default = (function (irc, network) {
+    const client = this;
+    irc.on("nick", function (data) {
+        const self = data.nick === irc.user.nick;
+        if (self) {
+            network.setNick(data.new_nick);
+            const lobby = network.getLobby();
+            const msg = new msg_1.default({
+                text: `You're now known as ${data.new_nick}`,
+            });
+            lobby.pushMessage(client, msg, true);
+            client.save();
+            client.emit("nick", {
+                network: network.uuid,
+                nick: data.new_nick,
+            });
+        }
+        network.channels.forEach((chan) => {
+            const user = chan.findUser(data.nick);
+            if (typeof user === "undefined") {
+                return;
+            }
+            const msg = new msg_1.default({
+                time: data.time,
+                from: user,
+                type: msg_2.MessageType.NICK,
+                new_nick: data.new_nick,
+            });
+            chan.pushMessage(client, msg);
+            chan.removeUser(user);
+            user.nick = data.new_nick;
+            chan.setUser(user);
+            client.emit("users", {
+                chan: chan.id,
+            });
+        });
+    });
+});

package/dist/server/plugins/irc-events/part.js

@@ -0,0 +1,35 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const msg_1 = __importDefault(require("../../models/msg"));
+const msg_2 = require("../../../shared/types/msg");
+exports.default = (function (irc, network) {
+    const client = this;
+    irc.on("part", function (data) {
+        if (!data.channel) {
+            return;
+        }
+        const chan = network.getChannel(data.channel);
+        if (typeof chan === "undefined") {
+            return;
+        }
+        const user = chan.getUser(data.nick);
+        const msg = new msg_1.default({
+            type: msg_2.MessageType.PART,
+            time: data.time,
+            text: data.message || "",
+            hostmask: data.ident + "@" + data.hostname,
+            from: user,
+            self: data.nick === irc.user.nick,
+        });
+        chan.pushMessage(client, msg);
+        if (data.nick === irc.user.nick) {
+            client.part(network, chan);
+        }
+        else {
+            chan.removeUser(user);
+        }
+    });
+});

package/dist/server/plugins/irc-events/quit.js

@@ -0,0 +1,32 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const msg_1 = __importDefault(require("../../models/msg"));
+const msg_2 = require("../../../shared/types/msg");
+exports.default = (function (irc, network) {
+    const client = this;
+    irc.on("quit", function (data) {
+        network.channels.forEach((chan) => {
+            const user = chan.findUser(data.nick);
+            if (typeof user === "undefined") {
+                return;
+            }
+            const msg = new msg_1.default({
+                time: data.time,
+                type: msg_2.MessageType.QUIT,
+                text: data.message || "",
+                hostmask: data.ident + "@" + data.hostname,
+                from: user,
+            });
+            chan.pushMessage(client, msg);
+            chan.removeUser(user);
+        });
+        // If user with the nick we are trying to keep has quit, try to get this nick
+        if (network.keepNick === data.nick) {
+            irc.changeNick(network.keepNick);
+            network.keepNick = null;
+        }
+    });
+});

package/dist/server/plugins/irc-events/sasl.js

@@ -0,0 +1,26 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const msg_1 = __importDefault(require("../../models/msg"));
+const msg_2 = require("../../../shared/types/msg");
+exports.default = (function (irc, network) {
+    const client = this;
+    irc.on("loggedin", (data) => {
+        const lobby = network.getLobby();
+        const msg = new msg_1.default({
+            type: msg_2.MessageType.LOGIN,
+            text: "Logged in as: " + data.account,
+        });
+        lobby.pushMessage(client, msg, true);
+    });
+    irc.on("loggedout", () => {
+        const lobby = network.getLobby();
+        const msg = new msg_1.default({
+            type: msg_2.MessageType.LOGOUT,
+            text: "Logged out",
+        });
+        lobby.pushMessage(client, msg, true);
+    });
+});

package/dist/server/plugins/irc-events/topic.js

@@ -0,0 +1,42 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const msg_1 = __importDefault(require("../../models/msg"));
+const msg_2 = require("../../../shared/types/msg");
+exports.default = (function (irc, network) {
+    const client = this;
+    irc.on("topic", function (data) {
+        const chan = network.getChannel(data.channel);
+        if (typeof chan === "undefined") {
+            return;
+        }
+        const msg = new msg_1.default({
+            time: data.time,
+            type: msg_2.MessageType.TOPIC,
+            from: data.nick && chan.getUser(data.nick),
+            text: data.topic,
+            self: data.nick === irc.user.nick,
+        });
+        chan.pushMessage(client, msg);
+        chan.topic = data.topic;
+        client.emit("topic", {
+            chan: chan.id,
+            topic: chan.topic,
+        });
+    });
+    irc.on("topicsetby", function (data) {
+        const chan = network.getChannel(data.channel);
+        if (typeof chan === "undefined") {
+            return;
+        }
+        const msg = new msg_1.default({
+            type: msg_2.MessageType.TOPIC_SET_BY,
+            from: chan.getUser(data.nick),
+            when: new Date(data.when * 1000),
+            self: data.nick === irc.user.nick,
+        });
+        chan.pushMessage(client, msg);
+    });
+});

package/dist/server/plugins/irc-events/unhandled.js

@@ -0,0 +1,31 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const msg_1 = __importDefault(require("../../models/msg"));
+const msg_2 = require("../../../shared/types/msg");
+exports.default = (function (irc, network) {
+    const client = this;
+    irc.on("unknown command", function (command) {
+        let target = network.getLobby();
+        // Do not display users own name
+        if (command.params.length > 0 && command.params[0] === network.irc.user.nick) {
+            command.params.shift();
+        }
+        // Check the length again because we may shift the nick above
+        if (command.params.length > 0) {
+            // If this numeric starts with a channel name that exists
+            // put this message in that channel
+            const channel = network.getChannel(command.params[0]);
+            if (typeof channel !== "undefined") {
+                target = channel;
+            }
+        }
+        target.pushMessage(client, new msg_1.default({
+            type: msg_2.MessageType.UNHANDLED,
+            command: command.command,
+            params: command.params,
+        }), true);
+    });
+});

package/dist/server/plugins/irc-events/welcome.js

@@ -0,0 +1,22 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const msg_1 = __importDefault(require("../../models/msg"));
+exports.default = (function (irc, network) {
+    const client = this;
+    irc.on("registered", function (data) {
+        network.setNick(data.nick);
+        const lobby = network.getLobby();
+        const msg = new msg_1.default({
+            text: "You're now known as " + data.nick,
+        });
+        lobby.pushMessage(client, msg);
+        client.save();
+        client.emit("nick", {
+            network: network.uuid,
+            nick: data.nick,
+        });
+    });
+});

package/dist/server/plugins/irc-events/whois.js

@@ -0,0 +1,57 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const msg_1 = __importDefault(require("../../models/msg"));
+const msg_2 = require("../../../shared/types/msg");
+const chan_1 = require("../../../shared/types/chan");
+exports.default = (function (irc, network) {
+    const client = this;
+    irc.on("whois", handleWhois);
+    irc.on("whowas", (data) => {
+        data.whowas = true;
+        handleWhois(data);
+    });
+    function handleWhois(data) {
+        let chan = network.getChannel(data.nick);
+        if (typeof chan === "undefined") {
+            // Do not create new windows for errors as they may contain illegal characters
+            if (data.error) {
+                chan = network.getLobby();
+            }
+            else {
+                chan = client.createChannel({
+                    type: chan_1.ChanType.QUERY,
+                    name: data.nick,
+                });
+                client.emit("join", {
+                    network: network.uuid,
+                    chan: chan.getFilteredClone(true),
+                    shouldOpen: true,
+                    index: network.addChannel(chan),
+                });
+                chan.loadMessages(client, network);
+                client.save();
+            }
+        }
+        let msg;
+        if (data.error) {
+            msg = new msg_1.default({
+                type: msg_2.MessageType.ERROR,
+                text: "No such nick: " + data.nick,
+            });
+        }
+        else {
+            // Absolute datetime in milliseconds since nick is idle
+            data.idleTime = Date.now() - data.idle * 1000;
+            // Absolute datetime in milliseconds when nick logged on.
+            data.logonTime = data.logon * 1000;
+            msg = new msg_1.default({
+                type: msg_2.MessageType.WHOIS,
+                whois: data,
+            });
+        }
+        chan.pushMessage(client, msg);
+    }
+});