@lordbex/thelounge 4.4.3-blowfish

package/dist/server/plugins/inputs/mute.js

@@ -0,0 +1,56 @@
+"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");
+const commands = ["mute", "unmute"];
+const allowDisconnected = true;
+function args_to_channels(network, args) {
+    const targets = [];
+    for (const arg of args) {
+        const target = network.channels.find((c) => c.name === arg);
+        if (target) {
+            targets.push(target);
+        }
+    }
+    return targets;
+}
+function change_mute_state(client, target, valueToSet) {
+    if (target.type === chan_1.ChanType.SPECIAL) {
+        return;
+    }
+    target.setMuteStatus(valueToSet);
+    client.emit("mute:changed", {
+        target: target.id,
+        status: valueToSet,
+    });
+}
+const input = function (network, chan, cmd, args) {
+    const valueToSet = cmd === "mute" ? true : false;
+    const client = this;
+    if (args.length === 0) {
+        change_mute_state(client, chan, valueToSet);
+        return;
+    }
+    const targets = args_to_channels(network, args);
+    if (targets.length !== args.length) {
+        const targetNames = targets.map((ch) => ch.name);
+        const missing = args.filter((x) => !targetNames.includes(x));
+        chan.pushMessage(client, new msg_1.default({
+            type: msg_2.MessageType.ERROR,
+            text: `No open ${missing.length === 1 ? "channel or user" : "channels or users"} found for ${missing.join(",")}`,
+        }));
+        return;
+    }
+    for (const target of targets) {
+        change_mute_state(client, target, valueToSet);
+    }
+};
+exports.default = {
+    commands,
+    input,
+    allowDisconnected,
+};

package/dist/server/plugins/inputs/nick.js

@@ -0,0 +1,55 @@
+"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 commands = ["nick"];
+const allowDisconnected = true;
+const input = function (network, chan, cmd, args) {
+    if (args.length === 0) {
+        chan.pushMessage(this, new msg_1.default({
+            type: msg_2.MessageType.ERROR,
+            text: "Usage: /nick <your new nick>",
+        }));
+        return;
+    }
+    if (args.length !== 1) {
+        chan.pushMessage(this, new msg_1.default({
+            type: msg_2.MessageType.ERROR,
+            text: "Nicknames may not contain spaces.",
+        }));
+        return;
+    }
+    const newNick = args[0];
+    if (newNick.length > 100) {
+        chan.pushMessage(this, new msg_1.default({
+            type: msg_2.MessageType.ERROR,
+            text: "Nicknames may not be this long.",
+        }));
+        return;
+    }
+    // If we were trying to keep a nick and user changes nick, stop trying to keep the old one
+    network.keepNick = null;
+    // If connected to IRC, send to server and wait for ACK
+    // otherwise update the nick and UI straight away
+    if (network.irc) {
+        if (network.irc.connected) {
+            network.irc.changeNick(newNick);
+            return;
+        }
+        network.irc.options.nick = network.irc.user.nick = newNick;
+    }
+    network.setNick(newNick);
+    this.emit("nick", {
+        network: network.uuid,
+        nick: newNick,
+    });
+    this.save();
+};
+exports.default = {
+    commands,
+    input,
+    allowDisconnected,
+};

package/dist/server/plugins/inputs/notice.js

@@ -0,0 +1,42 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const fish_1 = require("../../utils/fish");
+const commands = ["notice"];
+const input = function (network, chan, cmd, args) {
+    if (!args[1]) {
+        return;
+    }
+    let targetName = args[0];
+    const message = args.slice(1).join(" ");
+    // Encrypt if a FiSH key is set for the target channel/query
+    const targetChan = network.getChannel(targetName) || (chan.name === targetName ? chan : undefined);
+    const key = targetChan?.blowfishKey;
+    const toSend = key ? "+OK " + (0, fish_1.fishEncryptPayload)(message, key) : message;
+    network.irc.notice(targetName, toSend);
+    // If the IRCd does not support echo-message, simulate the message
+    // being sent back to us.
+    if (!network.irc.network.cap.isEnabled("echo-message")) {
+        let targetGroup;
+        const parsedTarget = network.irc.network.extractTargetGroup(targetName);
+        if (parsedTarget) {
+            targetName = parsedTarget.target;
+            targetGroup = parsedTarget.target_group;
+        }
+        const targetChan2 = network.getChannel(targetName);
+        let displayMessage = toSend;
+        if (typeof targetChan2 === "undefined") {
+            displayMessage = "{to " + args[0] + "} " + message;
+        }
+        network.irc.emit("notice", {
+            nick: network.irc.user.nick,
+            target: targetName,
+            group: targetGroup,
+            message: displayMessage,
+        });
+    }
+    return true;
+};
+exports.default = {
+    commands,
+    input,
+};

package/dist/server/plugins/inputs/part.js

@@ -0,0 +1,46 @@
+"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 config_1 = __importDefault(require("../../config"));
+const msg_2 = require("../../../shared/types/msg");
+const chan_1 = require("../../../shared/types/chan");
+const commands = ["close", "leave", "part"];
+const allowDisconnected = true;
+const input = function (network, chan, cmd, args) {
+    let target = chan;
+    if (args.length > 0) {
+        const newTarget = network.getChannel(args[0]);
+        if (typeof newTarget !== "undefined") {
+            // If first argument is a channel user is in, part that channel
+            target = newTarget;
+            args.shift();
+        }
+    }
+    if (target.type === chan_1.ChanType.LOBBY) {
+        chan.pushMessage(this, new msg_1.default({
+            type: msg_2.MessageType.ERROR,
+            text: "You can not part from networks, use /quit instead.",
+        }));
+        return;
+    }
+    // If target is not a channel or we are not connected, instantly remove the channel
+    // Otherwise send part to the server and wait for response
+    if (target.type !== chan_1.ChanType.CHANNEL ||
+        target.state === chan_1.ChanState.PARTED ||
+        !network.irc.connected) {
+        this.part(network, target);
+    }
+    else {
+        const partMessage = args.join(" ") || network.leaveMessage || config_1.default.values.leaveMessage;
+        network.irc.part(target.name, partMessage);
+    }
+    return true;
+};
+exports.default = {
+    commands,
+    input,
+    allowDisconnected,
+};

package/dist/server/plugins/inputs/quit.js

@@ -0,0 +1,27 @@
+"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 clientCertificate_1 = __importDefault(require("../clientCertificate"));
+const commands = ["quit"];
+const allowDisconnected = true;
+const input = function (network, chan, cmd, args) {
+    const client = this;
+    client.networks = lodash_1.default.without(client.networks, network);
+    network.destroy();
+    client.save();
+    client.emit("quit", {
+        network: network.uuid,
+    });
+    const quitMessage = args[0] ? args.join(" ") : undefined;
+    network.quit(quitMessage);
+    clientCertificate_1.default.remove(network.uuid);
+    return true;
+};
+exports.default = {
+    commands,
+    input,
+    allowDisconnected,
+};

package/dist/server/plugins/inputs/raw.js

@@ -0,0 +1,13 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const commands = ["raw", "send", "quote"];
+const input = function ({ irc }, chan, cmd, args) {
+    if (args.length !== 0) {
+        irc.raw(...args);
+    }
+    return true;
+};
+exports.default = {
+    commands,
+    input,
+};

package/dist/server/plugins/inputs/rejoin.js

@@ -0,0 +1,25 @@
+"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");
+const commands = ["cycle", "rejoin"];
+const input = function ({ irc }, chan) {
+    if (chan.type !== chan_1.ChanType.CHANNEL) {
+        chan.pushMessage(this, new msg_1.default({
+            type: msg_2.MessageType.ERROR,
+            text: "You can only rejoin channels.",
+        }));
+        return;
+    }
+    irc.part(chan.name, "Rejoining");
+    irc.join(chan.name);
+    return true;
+};
+exports.default = {
+    commands,
+    input,
+};

package/dist/server/plugins/inputs/topic.js

@@ -0,0 +1,24 @@
+"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");
+const commands = ["topic"];
+const input = function ({ irc }, chan, cmd, args) {
+    if (chan.type !== chan_1.ChanType.CHANNEL) {
+        chan.pushMessage(this, new msg_1.default({
+            type: msg_2.MessageType.ERROR,
+            text: `${cmd} command can only be used in channels.`,
+        }));
+        return;
+    }
+    irc.setTopic(chan.name, args.join(" "));
+    return true;
+};
+exports.default = {
+    commands,
+    input,
+};

package/dist/server/plugins/inputs/whois.js

@@ -0,0 +1,19 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const commands = ["whois"];
+const input = function ({ irc }, chan, cmd, args) {
+    if (args.length === 1) {
+        // This queries server of the other user and not of the current user, which
+        // does not know idle time.
+        // See http://superuser.com/a/272069/208074.
+        irc.raw("WHOIS", args[0], args[0]);
+    }
+    else {
+        // Re-assembling the command parsed in client.js
+        irc.raw(`${cmd} ${args.join(" ")}`);
+    }
+};
+exports.default = {
+    commands,
+    input,
+};

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

@@ -0,0 +1,59 @@
+"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("away", (data) => handleAway(msg_2.MessageType.AWAY, data));
+    irc.on("back", (data) => handleAway(msg_2.MessageType.BACK, data));
+    function handleAway(type, data) {
+        const away = data.message;
+        if (data.self) {
+            const msg = new msg_1.default({
+                self: true,
+                type: type,
+                text: away,
+                time: data.time,
+            });
+            network.getLobby().pushMessage(client, msg, true);
+            return;
+        }
+        network.channels.forEach((chan) => {
+            let user;
+            switch (chan.type) {
+                case chan_1.ChanType.QUERY: {
+                    if (data.nick.toLowerCase() !== chan.name.toLowerCase()) {
+                        return;
+                    }
+                    if (chan.userAway === away) {
+                        return;
+                    }
+                    // Store current away message on channel model,
+                    // because query windows have no users
+                    chan.userAway = away;
+                    user = chan.getUser(data.nick);
+                    const msg = new msg_1.default({
+                        type: type,
+                        text: away || "",
+                        time: data.time,
+                        from: user,
+                    });
+                    chan.pushMessage(client, msg);
+                    break;
+                }
+                case chan_1.ChanType.CHANNEL: {
+                    user = chan.findUser(data.nick);
+                    if (!user || user.away === away) {
+                        return;
+                    }
+                    user.away = away;
+                    break;
+                }
+            }
+        });
+    }
+});

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

@@ -0,0 +1,62 @@
+"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 sts_1 = __importDefault(require("../sts"));
+exports.default = (function (irc, network) {
+    const client = this;
+    irc.on("cap ls", (data) => {
+        handleSTS(data, true);
+    });
+    irc.on("cap new", (data) => {
+        handleSTS(data, false);
+    });
+    function handleSTS(data, shouldReconnect) {
+        if (!Object.prototype.hasOwnProperty.call(data.capabilities, "sts")) {
+            return;
+        }
+        const isSecure = irc.connection.transport.socket.encrypted;
+        const values = {};
+        data.capabilities.sts.split(",").map((value) => {
+            value = value.split("=", 2);
+            values[value[0]] = value[1];
+        });
+        if (isSecure) {
+            const duration = parseInt(values.duration, 10);
+            if (isNaN(duration)) {
+                return;
+            }
+            sts_1.default.update(network.host, network.port, duration);
+        }
+        else {
+            const port = parseInt(values.port, 10);
+            if (isNaN(port)) {
+                return;
+            }
+            network.getLobby().pushMessage(client, new msg_1.default({
+                text: `Server sent a strict transport security policy, reconnecting to ${network.host}:${port}…`,
+            }), true);
+            // Forcefully end the connection if STS is seen in CAP LS
+            // We will update the port and tls setting if we see CAP NEW,
+            // but will not force a reconnection
+            if (shouldReconnect) {
+                irc.connection.end();
+            }
+            // Update the port
+            network.port = port;
+            irc.options.port = port;
+            // Enable TLS
+            network.tls = true;
+            network.rejectUnauthorized = true;
+            irc.options.tls = true;
+            irc.options.rejectUnauthorized = true;
+            if (shouldReconnect) {
+                // Start a new connection
+                irc.connect();
+            }
+            client.save();
+        }
+    }
+});

package/dist/server/plugins/irc-events/chghost.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;
+    // If server supports CHGHOST cap, then changing the hostname does not require
+    // sending PART and JOIN, which means less work for us over all
+    irc.on("user updated", 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.CHGHOST,
+                new_ident: data.ident !== data.new_ident ? data.new_ident : "",
+                new_host: data.hostname !== data.new_hostname ? data.new_hostname : "",
+                self: data.nick === irc.user.nick,
+                from: user,
+            });
+            chan.pushMessage(client, msg);
+        });
+    });
+});

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

@@ -0,0 +1,152 @@
+"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 log_1 = __importDefault(require("../../log"));
+const msg_1 = __importDefault(require("../../models/msg"));
+const helper_1 = __importDefault(require("../../helper"));
+const config_1 = __importDefault(require("../../config"));
+const msg_2 = require("../../../shared/types/msg");
+const chan_1 = require("../../../shared/types/chan");
+exports.default = (function (irc, network) {
+    const client = this;
+    network.getLobby().pushMessage(client, new msg_1.default({
+        text: "Network created, connecting to " + network.host + ":" + network.port + "...",
+    }), true);
+    irc.on("registered", function () {
+        if (network.irc.network.cap.enabled.length > 0) {
+            network.getLobby().pushMessage(client, new msg_1.default({
+                text: "Enabled capabilities: " + network.irc.network.cap.enabled.join(", "),
+            }), true);
+        }
+        // Always restore away message for this network
+        if (network.awayMessage) {
+            irc.raw("AWAY", network.awayMessage);
+            // Only set generic away message if there are no clients attached
+        }
+        else if (client.awayMessage && lodash_1.default.size(client.attachedClients) === 0) {
+            irc.raw("AWAY", client.awayMessage);
+        }
+        let delay = 1000;
+        if (Array.isArray(network.commands)) {
+            network.commands.forEach((cmd) => {
+                setTimeout(function () {
+                    client.input({
+                        target: network.getLobby().id,
+                        text: cmd,
+                    });
+                }, delay);
+                delay += 1000;
+            });
+        }
+        network.channels.forEach((chan) => {
+            if (chan.type !== chan_1.ChanType.CHANNEL) {
+                return;
+            }
+            setTimeout(function () {
+                network.irc.join(chan.name, chan.key);
+            }, delay);
+            delay += 1000;
+        });
+    });
+    irc.on("socket connected", function () {
+        if (irc.network.options.PREFIX) {
+            network.serverOptions.PREFIX.update(irc.network.options.PREFIX);
+        }
+        network.getLobby().pushMessage(client, new msg_1.default({
+            text: "Connected to the network.",
+        }), true);
+        sendStatus();
+    });
+    irc.on("close", function () {
+        network.getLobby().pushMessage(client, new msg_1.default({
+            text: "Disconnected from the network, and will not reconnect. Use /connect to reconnect again.",
+        }), true);
+    });
+    let identSocketId;
+    irc.on("raw socket connected", function (socket) {
+        let ident = client.name || network.username;
+        if (config_1.default.values.useHexIp) {
+            ident = helper_1.default.ip2hex(client.config.browser.ip);
+        }
+        identSocketId = client.manager.identHandler.addSocket(socket, ident);
+    });
+    irc.on("socket close", function (error) {
+        if (identSocketId > 0) {
+            client.manager.identHandler.removeSocket(identSocketId);
+            identSocketId = 0;
+        }
+        network.channels.forEach((chan) => {
+            chan.users = new Map();
+            chan.state = chan_1.ChanState.PARTED;
+        });
+        if (error) {
+            network.getLobby().pushMessage(client, new msg_1.default({
+                type: msg_2.MessageType.ERROR,
+                text: `Connection closed unexpectedly: ${String(error)}`,
+            }), true);
+        }
+        if (network.keepNick) {
+            // We disconnected without getting our original nick back yet, just set it back locally
+            irc.options.nick = irc.user.nick = network.keepNick;
+            network.setNick(network.keepNick);
+            network.keepNick = null;
+            client.emit("nick", {
+                network: network.uuid,
+                nick: network.nick,
+            });
+        }
+        sendStatus();
+    });
+    if (config_1.default.values.debug.ircFramework) {
+        irc.on("debug", function (message) {
+            log_1.default.debug(`[${client.name} (${client.id}) on ${network.name} (${network.uuid}]`, message);
+        });
+    }
+    if (config_1.default.values.debug.raw) {
+        irc.on("raw", function (message) {
+            network.getLobby().pushMessage(client, new msg_1.default({
+                self: !message.from_server,
+                type: msg_2.MessageType.RAW,
+                text: message.line,
+            }), true);
+        });
+    }
+    irc.on("socket error", function (err) {
+        network.getLobby().pushMessage(client, new msg_1.default({
+            type: msg_2.MessageType.ERROR,
+            text: "Socket error: " + err,
+        }), true);
+    });
+    irc.on("reconnecting", function (data) {
+        network.getLobby().pushMessage(client, new msg_1.default({
+            text: `Disconnected from the network. Reconnecting in ${Math.round(data.wait / 1000)} seconds… (Attempt ${Number(data.attempt)})`,
+        }), true);
+    });
+    irc.on("ping timeout", function () {
+        network.getLobby().pushMessage(client, new msg_1.default({
+            text: "Ping timeout, disconnecting…",
+        }), true);
+    });
+    irc.on("server options", function (data) {
+        network.serverOptions.PREFIX.update(data.options.PREFIX);
+        if (data.options.CHANTYPES) {
+            network.serverOptions.CHANTYPES = data.options.CHANTYPES;
+        }
+        network.serverOptions.NETWORK = data.options.NETWORK;
+        client.emit("network:options", {
+            network: network.uuid,
+            serverOptions: network.serverOptions,
+        });
+    });
+    function sendStatus() {
+        const status = network.getNetworkStatus();
+        const toSend = {
+            ...status,
+            network: network.uuid,
+        };
+        client.emit("network:status", toSend);
+    }
+});