@lordbex/thelounge 4.4.3-blowfish

package/dist/server/models/user.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 lodash_1 = __importDefault(require("lodash"));
+const prefix_1 = __importDefault(require("./prefix"));
+class User {
+    modes;
+    // Users in the channel have only one mode assigned
+    mode;
+    away;
+    nick;
+    lastMessage;
+    constructor(attr, prefix) {
+        lodash_1.default.defaults(this, attr, {
+            modes: [],
+            away: "",
+            nick: "",
+            lastMessage: 0,
+        });
+        Object.defineProperty(this, "mode", {
+            get() {
+                // eslint-disable-next-line @typescript-eslint/no-unsafe-return
+                return this.modes[0] || "";
+            },
+        });
+        this.setModes(this.modes, prefix || new prefix_1.default([]));
+    }
+    setModes(modes, prefix) {
+        // irc-framework sets character mode, but The Lounge works with symbols
+        this.modes = modes.map((mode) => prefix.modeToSymbol[mode]);
+    }
+    toJSON() {
+        return {
+            nick: this.nick,
+            modes: this.modes,
+            lastMessage: this.lastMessage,
+        };
+    }
+}
+exports.default = User;

package/dist/server/plugins/auth/ldap.js

@@ -0,0 +1,188 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const ldapjs_1 = __importDefault(require("ldapjs"));
+const chalk_1 = __importDefault(require("chalk"));
+const log_1 = __importDefault(require("../../log"));
+const config_1 = __importDefault(require("../../config"));
+function ldapAuthCommon(user, bindDN, password, callback) {
+    const config = config_1.default.values;
+    const ldapclient = ldapjs_1.default.createClient({
+        url: config.ldap.url,
+        tlsOptions: config.ldap.tlsOptions,
+    });
+    ldapclient.on("error", function (err) {
+        log_1.default.error(`Unable to connect to LDAP server: ${err.toString()}`);
+        callback(false);
+    });
+    ldapclient.bind(bindDN, password, function (err) {
+        ldapclient.unbind();
+        if (err) {
+            log_1.default.error(`LDAP bind failed: ${err.toString()}`);
+            callback(false);
+        }
+        else {
+            callback(true);
+        }
+    });
+}
+function simpleLdapAuth(user, password, callback) {
+    if (!user || !password) {
+        return callback(false);
+    }
+    const config = config_1.default.values;
+    const userDN = user.replace(/([,\\/#+<>;"= ])/g, "\\$1");
+    const bindDN = `${config.ldap.primaryKey}=${userDN},${config.ldap.baseDN || ""}`;
+    log_1.default.info(`Auth against LDAP ${config.ldap.url} with provided bindDN ${bindDN}`);
+    ldapAuthCommon(user, bindDN, password, callback);
+}
+/**
+ * LDAP auth using initial DN search (see config comment for ldap.searchDN)
+ */
+function advancedLdapAuth(user, password, callback) {
+    if (!user || !password) {
+        return callback(false);
+    }
+    const config = config_1.default.values;
+    const userDN = user.replace(/([,\\/#+<>;"= ])/g, "\\$1");
+    const ldapclient = ldapjs_1.default.createClient({
+        url: config.ldap.url,
+        tlsOptions: config.ldap.tlsOptions,
+    });
+    const base = config.ldap.searchDN.base;
+    const searchOptions = {
+        scope: config.ldap.searchDN.scope,
+        filter: `(&(${config.ldap.primaryKey}=${userDN})${config.ldap.searchDN.filter})`,
+        attributes: ["dn"],
+    };
+    ldapclient.on("error", function (err) {
+        log_1.default.error(`Unable to connect to LDAP server: ${err.toString()}`);
+        callback(false);
+    });
+    ldapclient.bind(config.ldap.searchDN.rootDN, config.ldap.searchDN.rootPassword, function (err) {
+        if (err) {
+            log_1.default.error("Invalid LDAP root credentials");
+            ldapclient.unbind();
+            callback(false);
+            return;
+        }
+        ldapclient.search(base, searchOptions, function (err2, res) {
+            if (err2) {
+                log_1.default.warn(`LDAP User not found: ${userDN}`);
+                ldapclient.unbind();
+                callback(false);
+                return;
+            }
+            let found = false;
+            res.on("searchEntry", function (entry) {
+                found = true;
+                const bindDN = entry.objectName;
+                log_1.default.info(`Auth against LDAP ${config.ldap.url} with found bindDN ${bindDN || ""}`);
+                ldapclient.unbind();
+                // TODO: Fix type !
+                ldapAuthCommon(user, bindDN, password, callback);
+            });
+            res.on("error", function (err3) {
+                log_1.default.error(`LDAP error: ${err3.toString()}`);
+                callback(false);
+            });
+            res.on("end", function (result) {
+                ldapclient.unbind();
+                if (!found) {
+                    log_1.default.warn(`LDAP Search did not find anything for: ${userDN} (${result?.status.toString() || "unknown"})`);
+                    callback(false);
+                }
+            });
+        });
+    });
+}
+const ldapAuth = (manager, client, user, password, callback) => {
+    // TODO: Enable the use of starttls() as an alternative to ldaps
+    // TODO: move this out of here and get rid of `manager` and `client` in
+    // auth plugin API
+    function callbackWrapper(valid) {
+        if (valid && !client) {
+            manager.addUser(user, null, true);
+        }
+        callback(valid);
+    }
+    let auth;
+    if ("baseDN" in config_1.default.values.ldap) {
+        auth = simpleLdapAuth;
+    }
+    else {
+        auth = advancedLdapAuth;
+    }
+    return auth(user, password, callbackWrapper);
+};
+/**
+ * Use the LDAP filter from config to check that users still exist before loading them
+ * via the supplied callback function.
+ */
+function advancedLdapLoadUsers(users, callbackLoadUser) {
+    const config = config_1.default.values;
+    const ldapclient = ldapjs_1.default.createClient({
+        url: config.ldap.url,
+        tlsOptions: config.ldap.tlsOptions,
+    });
+    const base = config.ldap.searchDN.base;
+    ldapclient.on("error", function (err) {
+        log_1.default.error(`Unable to connect to LDAP server: ${err.toString()}`);
+    });
+    ldapclient.bind(config.ldap.searchDN.rootDN, config.ldap.searchDN.rootPassword, function (err) {
+        if (err) {
+            log_1.default.error("Invalid LDAP root credentials");
+            return true;
+        }
+        const remainingUsers = new Set(users);
+        const searchOptions = {
+            scope: config.ldap.searchDN.scope,
+            filter: `${config.ldap.searchDN.filter}`,
+            attributes: [config.ldap.primaryKey],
+            paged: true,
+        };
+        ldapclient.search(base, searchOptions, function (err2, res) {
+            if (err2) {
+                log_1.default.error(`LDAP search error: ${err2?.toString()}`);
+                return true;
+            }
+            res.on("searchEntry", function (entry) {
+                const user = entry.attributes[0].vals[0].toString();
+                if (remainingUsers.has(user)) {
+                    remainingUsers.delete(user);
+                    callbackLoadUser(user);
+                }
+            });
+            res.on("error", function (err3) {
+                log_1.default.error(`LDAP error: ${err3.toString()}`);
+            });
+            res.on("end", function () {
+                remainingUsers.forEach((user) => {
+                    log_1.default.warn(`No account info in LDAP for ${chalk_1.default.bold(user)} but user config file exists`);
+                });
+            });
+        });
+        ldapclient.unbind();
+    });
+    return true;
+}
+function ldapLoadUsers(users, callbackLoadUser) {
+    if ("baseDN" in config_1.default.values.ldap) {
+        // simple LDAP case can't test for user existence without access to the
+        // user's unhashed password, so indicate need to fallback to default
+        // loadUser behaviour by returning false
+        return false;
+    }
+    return advancedLdapLoadUsers(users, callbackLoadUser);
+}
+function isLdapEnabled() {
+    return !config_1.default.values.public && config_1.default.values.ldap.enable;
+}
+exports.default = {
+    moduleName: "ldap",
+    auth: ldapAuth,
+    isEnabled: isLdapEnabled,
+    loadUsers: ldapLoadUsers,
+};

package/dist/server/plugins/auth/local.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 chalk_1 = __importDefault(require("chalk"));
+const log_1 = __importDefault(require("../../log"));
+const helper_1 = __importDefault(require("../../helper"));
+const localAuth = (_manager, client, user, password, callback) => {
+    // If no user is found, or if the client has not provided a password,
+    // fail the authentication straight away
+    if (!client || !password) {
+        return callback(false);
+    }
+    // If this user has no password set, fail the authentication
+    if (!client.config.password) {
+        log_1.default.error(`User ${chalk_1.default.bold(user)} with no local password set tried to sign in. (Probably a LDAP user)`);
+        return callback(false);
+    }
+    helper_1.default.password
+        .compare(password, client.config.password)
+        .then((matching) => {
+        if (matching && helper_1.default.password.requiresUpdate(client.config.password)) {
+            const hash = helper_1.default.password.hash(password);
+            client.setPassword(hash, (success) => {
+                if (success) {
+                    log_1.default.info(`User ${chalk_1.default.bold(client.name)} logged in and their hashed password has been updated to match new security requirements`);
+                }
+            });
+        }
+        callback(matching);
+    })
+        .catch((error) => {
+        log_1.default.error(`Error while checking users password. Error: ${error}`);
+    });
+};
+exports.default = {
+    moduleName: "local",
+    auth: localAuth,
+    isEnabled: () => true,
+};

package/dist/server/plugins/auth.js

@@ -0,0 +1,70 @@
+"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 chalk_1 = __importDefault(require("chalk"));
+const log_1 = __importDefault(require("../log"));
+// The order defines priority: the first available plugin is used.
+// Always keep 'local' auth plugin at the end of the list; it should always be enabled.
+const plugins = [Promise.resolve().then(() => __importStar(require("./auth/ldap"))), Promise.resolve().then(() => __importStar(require("./auth/local")))];
+const toExport = {
+    moduleName: "<module with no name>",
+    // Must override: implements authentication mechanism
+    auth: () => unimplemented("auth"),
+    // Optional to override: implements filter for loading users at start up
+    // This allows an auth plugin to check if a user is still acceptable, if the plugin
+    // can do so without access to the user's unhashed password.
+    // Returning 'false' triggers fallback to default behaviour of loading all users
+    loadUsers: () => false,
+    // local auth should always be enabled, but check here to verify
+    initialized: false,
+    // TODO: fix typing
+    async initialize() {
+        if (toExport.initialized) {
+            return;
+        }
+        // Override default API stubs with exports from first enabled plugin found
+        const resolvedPlugins = await Promise.all(plugins);
+        for (const { default: plugin } of resolvedPlugins) {
+            if (plugin.isEnabled()) {
+                toExport.initialized = true;
+                for (const name in plugin) {
+                    toExport[name] = plugin[name];
+                }
+                break;
+            }
+        }
+        if (!toExport.initialized) {
+            log_1.default.error("None of the auth plugins is enabled");
+        }
+    },
+};
+function unimplemented(funcName) {
+    log_1.default.debug(`Auth module ${chalk_1.default.bold(toExport.moduleName)} doesn't implement function ${chalk_1.default.bold(funcName)}`);
+}
+// Default API implementations
+exports.default = toExport;

package/dist/server/plugins/changelog.js

@@ -0,0 +1,103 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const got_1 = __importDefault(require("got"));
+const chalk_1 = __importDefault(require("chalk"));
+const log_1 = __importDefault(require("../log"));
+const package_json_1 = __importDefault(require("../../package.json"));
+const config_1 = __importDefault(require("../config"));
+const TIME_TO_LIVE = 15 * 60 * 1000; // 15 minutes, in milliseconds
+exports.default = {
+    isUpdateAvailable: false,
+    fetch,
+    checkForUpdates,
+};
+const versions = {
+    current: {
+        prerelease: false,
+        version: `v${package_json_1.default.version}`,
+        changelog: undefined,
+        url: "", // TODO: properly init
+    },
+    expiresAt: -1,
+    latest: undefined,
+    packages: undefined,
+};
+async function fetch() {
+    const time = Date.now();
+    // Serving information from cache
+    if (versions.expiresAt > time) {
+        return versions;
+    }
+    try {
+        const response = await (0, got_1.default)("https://api.github.com/repos/thelounge/thelounge/releases", {
+            headers: {
+                Accept: "application/vnd.github.v3.html", // Request rendered markdown
+                "User-Agent": package_json_1.default.name + "; +" + package_json_1.default.repository.url, // Identify the client
+            },
+            localAddress: config_1.default.values.bind,
+        });
+        if (response.statusCode !== 200) {
+            return versions;
+        }
+        updateVersions(response);
+        // Add expiration date to the data to send to the client for later refresh
+        versions.expiresAt = time + TIME_TO_LIVE;
+    }
+    catch (error) {
+        // eslint-disable-next-line @typescript-eslint/restrict-template-expressions
+        log_1.default.error(`Failed to fetch changelog: ${error}`);
+    }
+    return versions;
+}
+function updateVersions(response) {
+    let i;
+    let release;
+    let prerelease = false;
+    const body = JSON.parse(response.body);
+    // Find the current release among releases on GitHub
+    for (i = 0; i < body.length; i++) {
+        release = body[i];
+        if (release.tag_name === versions.current.version) {
+            versions.current.changelog = release.body_html;
+            prerelease = release.prerelease;
+            break;
+        }
+    }
+    // Find the latest release made after the current one if there is one
+    if (i > 0) {
+        for (let j = 0; j < i; j++) {
+            release = body[j];
+            // Find latest release or pre-release if current version is also a pre-release
+            if (!release.prerelease || release.prerelease === prerelease) {
+                module.exports.isUpdateAvailable = true;
+                versions.latest = {
+                    prerelease: release.prerelease,
+                    version: release.tag_name,
+                    url: release.html_url,
+                };
+                break;
+            }
+        }
+    }
+}
+function checkForUpdates(manager) {
+    fetch()
+        .then((versionData) => {
+        if (!module.exports.isUpdateAvailable) {
+            // Check for updates every 24 hours + random jitter of <3 hours
+            setTimeout(() => checkForUpdates(manager), 24 * 3600 * 1000 + Math.floor(Math.random() * 10000000));
+        }
+        if (!versionData.latest) {
+            return;
+        }
+        log_1.default.info(`The Lounge ${chalk_1.default.green(versionData.latest.version)} is available. Read more on GitHub: ${versionData.latest.url}`);
+        // Notify all connected clients about the new version
+        manager.clients.forEach((client) => client.emit("changelog:newversion"));
+    })
+        .catch((error) => {
+        log_1.default.error(`Failed to check for updates: ${error.message}`);
+    });
+}

package/dist/server/plugins/clientCertificate.js

@@ -0,0 +1,115 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const path_1 = __importDefault(require("path"));
+const fs_1 = __importDefault(require("fs"));
+const crypto_1 = __importDefault(require("crypto"));
+const node_forge_1 = require("node-forge");
+const log_1 = __importDefault(require("../log"));
+const config_1 = __importDefault(require("../config"));
+exports.default = {
+    get,
+    remove,
+};
+function get(uuid) {
+    if (config_1.default.values.public) {
+        return null;
+    }
+    const folderPath = config_1.default.getClientCertificatesPath();
+    const paths = getPaths(folderPath, uuid);
+    if (!fs_1.default.existsSync(paths.privateKeyPath) || !fs_1.default.existsSync(paths.certificatePath)) {
+        return generateAndWrite(folderPath, paths);
+    }
+    try {
+        return {
+            private_key: fs_1.default.readFileSync(paths.privateKeyPath, "utf-8"),
+            certificate: fs_1.default.readFileSync(paths.certificatePath, "utf-8"),
+        };
+    }
+    catch (e) {
+        log_1.default.error("Unable to get certificate", e);
+    }
+    return null;
+}
+function remove(uuid) {
+    if (config_1.default.values.public) {
+        return null;
+    }
+    const paths = getPaths(config_1.default.getClientCertificatesPath(), uuid);
+    try {
+        if (fs_1.default.existsSync(paths.privateKeyPath)) {
+            fs_1.default.unlinkSync(paths.privateKeyPath);
+        }
+        if (fs_1.default.existsSync(paths.certificatePath)) {
+            fs_1.default.unlinkSync(paths.certificatePath);
+        }
+    }
+    catch (e) {
+        log_1.default.error("Unable to remove certificate", e);
+    }
+}
+function generateAndWrite(folderPath, paths) {
+    const certificate = generate();
+    try {
+        fs_1.default.mkdirSync(folderPath, { recursive: true });
+        fs_1.default.writeFileSync(paths.privateKeyPath, certificate.private_key, {
+            mode: 0o600,
+        });
+        fs_1.default.writeFileSync(paths.certificatePath, certificate.certificate, {
+            mode: 0o600,
+        });
+        return certificate;
+    }
+    catch (e) {
+        log_1.default.error("Unable to write certificate", String(e));
+    }
+    return null;
+}
+function generate() {
+    const keys = node_forge_1.pki.rsa.generateKeyPair(2048);
+    const cert = node_forge_1.pki.createCertificate();
+    cert.publicKey = keys.publicKey;
+    cert.serialNumber = crypto_1.default.randomBytes(16).toString("hex").toUpperCase();
+    // Set notBefore a day earlier just in case the time between
+    // the client and server is not perfectly in sync
+    cert.validity.notBefore = new Date();
+    cert.validity.notBefore.setDate(cert.validity.notBefore.getDate() - 1);
+    // Set notAfter 100 years into the future just in case
+    // the server actually validates this field
+    cert.validity.notAfter = new Date();
+    cert.validity.notAfter.setFullYear(cert.validity.notBefore.getFullYear() + 100);
+    const attrs = [
+        {
+            name: "commonName",
+            value: "The Lounge IRC Client",
+        },
+    ];
+    cert.setSubject(attrs);
+    cert.setIssuer(attrs);
+    // Set extensions that indicate this is a client authentication certificate
+    cert.setExtensions([
+        {
+            name: "extKeyUsage",
+            clientAuth: true,
+        },
+        {
+            name: "nsCertType",
+            client: true,
+        },
+    ]);
+    // Sign this certificate with a SHA256 signature
+    cert.sign(keys.privateKey, node_forge_1.md.sha256.create());
+    const pem = {
+        private_key: node_forge_1.pki.privateKeyToPem(keys.privateKey),
+        certificate: node_forge_1.pki.certificateToPem(cert),
+    };
+    return pem;
+}
+function getPaths(folderPath, uuid) {
+    return {
+        privateKeyPath: path_1.default.join(folderPath, `${uuid}.pem`),
+        certificatePath: path_1.default.join(folderPath, `${uuid}.crt`),
+    };
+}

package/dist/server/plugins/dev-server.js

@@ -0,0 +1,33 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const webpack_dev_middleware_1 = __importDefault(require("webpack-dev-middleware"));
+const webpack_hot_middleware_1 = __importDefault(require("webpack-hot-middleware"));
+const log_1 = __importDefault(require("../log"));
+const webpack_1 = __importDefault(require("webpack"));
+const webpack_config_1 = __importDefault(require("../../webpack.config"));
+exports.default = (app) => {
+    log_1.default.debug("Starting server in development mode");
+    const webpackConfig = (0, webpack_config_1.default)(undefined, { mode: "production" });
+    if (!webpackConfig ||
+        !webpackConfig.plugins?.length ||
+        !webpackConfig.entry ||
+        !webpackConfig.entry["js/bundle.js"]) {
+        throw new Error("No valid production webpack config found");
+    }
+    webpackConfig.plugins.push(new webpack_1.default.HotModuleReplacementPlugin());
+    webpackConfig.entry["js/bundle.js"].push("webpack-hot-middleware/client?path=storage/__webpack_hmr");
+    const compiler = (0, webpack_1.default)(webpackConfig);
+    app.use(
+    // eslint-disable-next-line @typescript-eslint/no-misused-promises
+    (0, webpack_dev_middleware_1.default)(compiler, {
+        index: "/",
+        publicPath: webpackConfig.output?.publicPath,
+    })).use(
+    // TODO: Fix compiler type
+    (0, webpack_hot_middleware_1.default)(compiler, {
+        path: "/storage/__webpack_hmr",
+    }));
+};

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

@@ -0,0 +1,54 @@
+"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 = ["slap", "me"];
+const input = function ({ irc }, chan, cmd, args) {
+    if (chan.type !== chan_1.ChanType.CHANNEL && chan.type !== chan_1.ChanType.QUERY) {
+        chan.pushMessage(this, new msg_1.default({
+            type: msg_2.MessageType.ERROR,
+            text: `${cmd} command can only be used in channels and queries.`,
+        }));
+        return;
+    }
+    let text;
+    switch (cmd) {
+        case "slap":
+            text = "slaps " + args[0] + " around a bit with a large trout";
+        /* fall through */
+        case "me":
+            if (args.length === 0) {
+                break;
+            }
+            text = text || args.join(" ");
+            // If FiSH key is set, encrypt CTCP ACTION and send as normal PRIVMSG with +OK
+            if (chan.blowfishKey) {
+                const ctcp = "\x01ACTION " + text + "\x01";
+                const toSend = "+OK " + (0, fish_1.fishEncryptPayload)(ctcp, chan.blowfishKey);
+                irc.say(chan.name, toSend);
+            }
+            else {
+                irc.action(chan.name, text);
+            }
+            // If the IRCd does not support echo-message, simulate the message
+            // being sent back to us.
+            if (!irc.network.cap.isEnabled("echo-message")) {
+                irc.emit("action", {
+                    nick: irc.user.nick,
+                    target: chan.name,
+                    message: text,
+                });
+            }
+            break;
+    }
+    return true;
+};
+exports.default = {
+    commands,
+    input,
+};

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

@@ -0,0 +1,20 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const commands = ["away", "back"];
+const input = function (network, chan, cmd, args) {
+    let reason = "";
+    if (cmd === "away") {
+        reason = args.join(" ") || " ";
+        network.irc.raw("AWAY", reason);
+    }
+    else {
+        // back command
+        network.irc.raw("AWAY");
+    }
+    network.awayMessage = reason;
+    this.save();
+};
+exports.default = {
+    commands,
+    input,
+};