@lordbex/thelounge 4.4.3-blowfish

package/dist/server/plugins/inputs/ban.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");
+const chan_1 = require("../../../shared/types/chan");
+const commands = ["ban", "unban", "banlist", "kickban"];
+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;
+    }
+    if (cmd !== "banlist" && args.length === 0) {
+        if (args.length === 0) {
+            chan.pushMessage(this, new msg_1.default({
+                type: msg_2.MessageType.ERROR,
+                text: `Usage: /${cmd} <nick>`,
+            }));
+            return;
+        }
+    }
+    switch (cmd) {
+        case "kickban":
+            irc.raw("KICK", chan.name, args[0], args.slice(1).join(" "));
+        // fall through
+        case "ban":
+            irc.ban(chan.name, args[0]);
+            break;
+        case "unban":
+            irc.unban(chan.name, args[0]);
+            break;
+        case "banlist":
+            irc.banlist(chan.name);
+            break;
+    }
+};
+exports.default = {
+    commands,
+    input,
+};

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

@@ -0,0 +1,44 @@
+"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 = ["blow"];
+const input = function (network, chan, _cmd, args) {
+    if (!chan) {
+        return true;
+    }
+    if (args.length === 0) {
+        chan.pushMessage(this, new msg_1.default({
+            type: msg_2.MessageType.NOTICE,
+            text: chan.blowfishKey
+                ? `FiSH: Key is set for ${chan.name}. Use /blow off to clear.`
+                : `FiSH: No key set for ${chan.name}. Use /blow <key> to set.`,
+        }));
+        return true;
+    }
+    const sub = args.join(" ").trim();
+    if (!sub) {
+        return true;
+    }
+    if (sub.toLowerCase() === "off" || sub.toLowerCase() === "clear") {
+        chan.blowfishKey = undefined;
+        chan.pushMessage(this, new msg_1.default({
+            type: msg_2.MessageType.NOTICE,
+            text: `FiSH: Key cleared for ${chan.name}.`,
+        }));
+        return true;
+    }
+    chan.blowfishKey = sub;
+    chan.pushMessage(this, new msg_1.default({
+        type: msg_2.MessageType.NOTICE,
+        text: `FiSH: Key set for ${chan.name}.`,
+    }));
+    return true;
+};
+exports.default = {
+    commands,
+    input,
+};

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

@@ -0,0 +1,41 @@
+"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 = ["connect", "server"];
+const allowDisconnected = true;
+const input = function (network, chan, cmd, args) {
+    if (args.length === 0) {
+        network.userDisconnected = false;
+        this.save();
+        const irc = network.irc;
+        if (!irc) {
+            return;
+        }
+        if (irc.connected) {
+            chan.pushMessage(this, new msg_1.default({
+                type: msg_2.MessageType.ERROR,
+                text: "You are already connected.",
+            }));
+            return;
+        }
+        irc.connect();
+        return;
+    }
+    let port = args[1] || "";
+    const tls = port[0] === "+";
+    if (tls) {
+        port = port.substring(1);
+    }
+    const host = args[0];
+    this.connectToNetwork({ host, port, tls });
+    return true;
+};
+exports.default = {
+    commands,
+    input,
+    allowDisconnected,
+};

package/dist/server/plugins/inputs/ctcp.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");
+const commands = ["ctcp"];
+const input = function ({ irc }, chan, cmd, args) {
+    if (args.length < 2) {
+        chan.pushMessage(this, new msg_1.default({
+            type: msg_2.MessageType.ERROR,
+            text: "Usage: /ctcp <nick> <ctcp_type>",
+        }));
+        return;
+    }
+    const target = args.shift();
+    const type = args.shift();
+    chan.pushMessage(this, new msg_1.default({
+        type: msg_2.MessageType.CTCP_REQUEST,
+        ctcpMessage: `"${type}" to ${target}`,
+        from: chan.getUser(irc.user.nick),
+    }));
+    irc.ctcpRequest(target, type, ...args);
+};
+exports.default = {
+    commands,
+    input,
+};

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

@@ -0,0 +1,15 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const commands = ["disconnect"];
+const allowDisconnected = true;
+const input = function (network, chan, cmd, args) {
+    const quitMessage = args[0] ? args.join(" ") : undefined;
+    network.quit(quitMessage);
+    network.userDisconnected = true;
+    this.save();
+};
+exports.default = {
+    commands,
+    input,
+    allowDisconnected,
+};

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

@@ -0,0 +1,74 @@
+"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 helper_1 = __importDefault(require("../../helper"));
+const msg_2 = require("../../../shared/types/msg");
+const commands = ["ignore", "unignore"];
+const input = function (network, chan, cmd, args) {
+    const client = this;
+    if (args.length === 0 || args[0].trim().length === 0) {
+        chan.pushMessage(client, new msg_1.default({
+            type: msg_2.MessageType.ERROR,
+            text: `Usage: /${cmd} <nick>[!ident][@host]`,
+        }));
+        return;
+    }
+    const target = args[0].trim();
+    const hostmask = helper_1.default.parseHostmask(target);
+    switch (cmd) {
+        case "ignore": {
+            // IRC nicks are case insensitive
+            if (hostmask.nick.toLowerCase() === network.nick.toLowerCase()) {
+                chan.pushMessage(client, new msg_1.default({
+                    type: msg_2.MessageType.ERROR,
+                    text: "You can't ignore yourself",
+                }));
+                return;
+            }
+            if (network.ignoreList.some(function (entry) {
+                return helper_1.default.compareHostmask(entry, hostmask);
+            })) {
+                chan.pushMessage(client, new msg_1.default({
+                    type: msg_2.MessageType.ERROR,
+                    text: "The specified user/hostmask is already ignored",
+                }));
+                return;
+            }
+            network.ignoreList.push({
+                ...hostmask,
+                when: Date.now(),
+            });
+            client.save();
+            chan.pushMessage(client, new msg_1.default({
+                type: msg_2.MessageType.ERROR, // TODO: Successfully added via type.Error 🤔 ?
+                text: `\u0002${hostmask.nick}!${hostmask.ident}@${hostmask.hostname}\u000f added to ignorelist`,
+            }));
+            return;
+        }
+        case "unignore": {
+            const idx = network.ignoreList.findIndex(function (entry) {
+                return helper_1.default.compareHostmask(entry, hostmask);
+            });
+            if (idx === -1) {
+                chan.pushMessage(client, new msg_1.default({
+                    type: msg_2.MessageType.ERROR,
+                    text: "The specified user/hostmask is not ignored",
+                }));
+                return;
+            }
+            network.ignoreList.splice(idx, 1);
+            client.save();
+            chan.pushMessage(client, new msg_1.default({
+                type: msg_2.MessageType.ERROR, // TODO: Successfully removed via type.Error 🤔 ?
+                text: `Successfully removed \u0002${hostmask.nick}!${hostmask.ident}@${hostmask.hostname}\u000f from ignorelist`,
+            }));
+        }
+    }
+};
+exports.default = {
+    commands,
+    input,
+};

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

@@ -0,0 +1,50 @@
+"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 chan_1 = require("../../../shared/types/chan");
+const msg_2 = require("../../../shared/types/msg");
+const commands = ["ignorelist"];
+const input = function (network, chan, _cmd, _args) {
+    const client = this;
+    if (network.ignoreList.length === 0) {
+        chan.pushMessage(client, new msg_1.default({
+            type: msg_2.MessageType.ERROR,
+            text: "Ignorelist is empty",
+        }));
+        return;
+    }
+    const chanName = "Ignored users";
+    const ignored = network.ignoreList.map((data) => ({
+        hostmask: `${data.nick}!${data.ident}@${data.hostname}`,
+        when: data.when,
+    }));
+    let newChan = network.getChannel(chanName);
+    if (typeof newChan === "undefined") {
+        newChan = client.createChannel({
+            type: chan_1.ChanType.SPECIAL,
+            special: chan_1.SpecialChanType.IGNORELIST,
+            name: chanName,
+            data: ignored,
+        });
+        client.emit("join", {
+            network: network.uuid,
+            chan: newChan.getFilteredClone(true),
+            shouldOpen: false,
+            index: network.addChannel(newChan),
+        });
+        return;
+    }
+    // TODO: add type for this chan/event
+    newChan.data = ignored;
+    client.emit("msg:special", {
+        chan: newChan.id,
+        data: ignored,
+    });
+};
+exports.default = {
+    commands,
+    input,
+};

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

@@ -0,0 +1,105 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const log_1 = __importDefault(require("../../log"));
+const clientSideCommands = ["/collapse", "/expand", "/search"];
+const passThroughCommands = [
+    "/as",
+    "/bs",
+    "/cs",
+    "/ho",
+    "/hs",
+    "/join",
+    "/ms",
+    "/ns",
+    "/os",
+    "/rs",
+];
+const userInputs = new Map();
+const builtInInputs = [
+    "action",
+    "away",
+    "ban",
+    "connect",
+    "ctcp",
+    "disconnect",
+    "ignore",
+    "ignorelist",
+    "invite",
+    "kick",
+    "kill",
+    "list",
+    "mode",
+    "msg",
+    "nick",
+    "notice",
+    "part",
+    "quit",
+    "raw",
+    "rejoin",
+    "topic",
+    "whois",
+    "mute",
+    "blow",
+];
+for (const input of builtInInputs) {
+    Promise.resolve(`${`./${input}`}`).then(s => __importStar(require(s))).then((plugin) => {
+        plugin.default.commands.forEach((command) => userInputs.set(command, plugin.default));
+    })
+        .catch((err) => {
+        log_1.default.error(err);
+    });
+}
+const pluginCommands = new Map();
+const getCommands = () => Array.from(userInputs.keys())
+    .concat(Array.from(pluginCommands.keys()))
+    .map((command) => `/${command}`)
+    .concat(clientSideCommands)
+    .concat(passThroughCommands)
+    .sort();
+const addPluginCommand = (packageInfo, command, obj) => {
+    if (typeof command !== "string") {
+        log_1.default.error(`plugin {packageInfo.packageName} tried to register a bad command`);
+        return;
+    }
+    else if (!obj || typeof obj.input !== "function") {
+        log_1.default.error(`plugin ${packageInfo.packageName} tried to register command "${command} without a callback"`);
+        return;
+    }
+    pluginCommands.set(command, {
+        packageInfo: packageInfo,
+        input: obj.input,
+        allowDisconnected: obj.allowDisconnected,
+    });
+};
+exports.default = {
+    addPluginCommand,
+    getCommands,
+    pluginCommands,
+    userInputs,
+};

package/dist/server/plugins/inputs/invite.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");
+const chan_1 = require("../../../shared/types/chan");
+const commands = ["invite", "invitelist"];
+const input = function ({ irc }, chan, cmd, args) {
+    if (cmd === "invitelist") {
+        irc.inviteList(chan.name);
+        return;
+    }
+    if (args.length === 2) {
+        irc.raw("INVITE", args[0], args[1]); // Channel provided in the command
+    }
+    else if (args.length === 1 && chan.type === chan_1.ChanType.CHANNEL) {
+        irc.raw("INVITE", args[0], chan.name); // Current channel
+    }
+    else {
+        chan.pushMessage(this, new msg_1.default({
+            type: msg_2.MessageType.ERROR,
+            text: `${cmd} command can only be used in channels or by specifying a target.`,
+        }));
+    }
+};
+exports.default = {
+    commands,
+    input,
+};

package/dist/server/plugins/inputs/kick.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");
+const chan_1 = require("../../../shared/types/chan");
+const commands = ["kick"];
+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;
+    }
+    if (args.length !== 0) {
+        irc.raw("KICK", chan.name, args[0], args.slice(1).join(" "));
+    }
+    return true;
+};
+exports.default = {
+    commands,
+    input,
+};

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

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

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

@@ -0,0 +1,12 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const commands = ["list"];
+const input = function (network, chan, cmd, args) {
+    network.chanCache = [];
+    network.irc.list(...args);
+    return true;
+};
+exports.default = {
+    commands,
+    input,
+};

package/dist/server/plugins/inputs/mode.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 chan_1 = require("../../../shared/types/chan");
+const commands = ["mode", "umode", "op", "deop", "hop", "dehop", "voice", "devoice"];
+const input = function ({ irc, nick }, chan, cmd, args) {
+    if (cmd === "umode") {
+        irc.raw("MODE", nick, ...args);
+        return;
+    }
+    else if (cmd !== "mode") {
+        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;
+        }
+        const target = args.filter((arg) => arg !== "");
+        if (target.length === 0) {
+            chan.pushMessage(this, new msg_1.default({
+                type: msg_2.MessageType.ERROR,
+                text: `Usage: /${cmd} <nick> [...nick]`,
+            }));
+            return;
+        }
+        const mode = {
+            op: "+o",
+            hop: "+h",
+            voice: "+v",
+            deop: "-o",
+            dehop: "-h",
+            devoice: "-v",
+        }[cmd];
+        const limit = parseInt(irc.network.supports("MODES")) || target.length;
+        for (let i = 0; i < target.length; i += limit) {
+            const targets = target.slice(i, i + limit);
+            const amode = `${mode[0]}${mode[1].repeat(targets.length)}`;
+            irc.raw("MODE", chan.name, amode, ...targets);
+        }
+        return;
+    }
+    if (args.length === 0 || args[0][0] === "+" || args[0][0] === "-") {
+        args.unshift(chan.type === chan_1.ChanType.CHANNEL || chan.type === chan_1.ChanType.QUERY ? chan.name : nick);
+    }
+    irc.raw("MODE", ...args);
+};
+exports.default = {
+    commands,
+    input,
+};

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

@@ -0,0 +1,106 @@
+"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 fish_1 = require("../../utils/fish");
+const commands = ["query", "msg", "say"];
+function getTarget(cmd, args, chan) {
+    switch (cmd) {
+        case "msg":
+        case "query":
+            return args.shift();
+        default:
+            return chan.name;
+    }
+}
+const input = function (network, chan, cmd, args) {
+    let targetName = getTarget(cmd, args, chan);
+    if (cmd === "query") {
+        if (!targetName) {
+            chan.pushMessage(this, new msg_1.default({
+                type: msg_2.MessageType.ERROR,
+                text: "You cannot open a query window without an argument.",
+            }));
+            return;
+        }
+        const target = network.getChannel(targetName);
+        if (typeof target === "undefined") {
+            const char = targetName[0];
+            if (network.irc.network.options.CHANTYPES &&
+                network.irc.network.options.CHANTYPES.includes(char)) {
+                chan.pushMessage(this, new msg_1.default({
+                    type: msg_2.MessageType.ERROR,
+                    text: "You can not open query windows for channels, use /join instead.",
+                }));
+                return;
+            }
+            for (let i = 0; i < network.irc.network.options.PREFIX.length; i++) {
+                if (network.irc.network.options.PREFIX[i].symbol === char) {
+                    chan.pushMessage(this, new msg_1.default({
+                        type: msg_2.MessageType.ERROR,
+                        text: "You can not open query windows for names starting with a user prefix.",
+                    }));
+                    return;
+                }
+            }
+            const newChan = this.createChannel({
+                type: chan_1.ChanType.QUERY,
+                name: targetName,
+            });
+            this.emit("join", {
+                network: network.uuid,
+                chan: newChan.getFilteredClone(true),
+                shouldOpen: true,
+                index: network.addChannel(newChan),
+            });
+            this.save();
+            newChan.loadMessages(this, network);
+        }
+    }
+    if (args.length === 0) {
+        return true;
+    }
+    if (!targetName) {
+        return true;
+    }
+    const msg = args.join(" ");
+    if (msg.length === 0) {
+        return true;
+    }
+    // Determine if we should encrypt using FiSH for this target
+    const targetChan = network.getChannel(targetName) || (chan.name === targetName ? chan : undefined);
+    const key = targetChan?.blowfishKey;
+    const toSend = key ? "+OK " + (0, fish_1.fishEncryptPayload)(msg, key) : msg;
+    network.irc.say(targetName, toSend);
+    // If the IRCd does not support echo-message, simulate the message
+    // being sent back to us. Emit the same text we sent (encrypted or plain)
+    // so that inbound pipeline can decrypt and store plaintext.
+    if (!network.irc.network.cap.isEnabled("echo-message")) {
+        const parsedTarget = network.irc.network.extractTargetGroup(targetName);
+        let targetGroup = undefined;
+        if (parsedTarget) {
+            targetName = parsedTarget.target;
+            targetGroup = parsedTarget.target_group;
+        }
+        const channel = network.getChannel(targetName);
+        if (typeof channel !== "undefined") {
+            network.irc.emit("privmsg", {
+                nick: network.irc.user.nick,
+                ident: network.irc.user.username,
+                hostname: network.irc.user.host,
+                target: targetName,
+                group: targetGroup,
+                message: toSend,
+            });
+        }
+    }
+    return true;
+};
+exports.default = {
+    commands,
+    input,
+};