@lordbex/thelounge 4.4.3-blowfish → 4.5.0-blowfish-pre

package/dist/server/server.js

@@ -1,71 +1,43 @@
-"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 lodash_1 = __importDefault(require("lodash"));
-const ws_1 = require("ws");
-const express_1 = __importDefault(require("express"));
-const fs_1 = __importDefault(require("fs"));
-const path_1 = __importDefault(require("path"));
-const socket_io_1 = require("socket.io");
-const dns_1 = __importDefault(require("dns"));
-const chalk_1 = __importDefault(require("chalk"));
-const net_1 = __importDefault(require("net"));
-const log_1 = __importDefault(require("./log"));
-const client_1 = __importDefault(require("./client"));
-const clientManager_1 = __importDefault(require("./clientManager"));
-const uploader_1 = __importDefault(require("./plugins/uploader"));
-const helper_1 = __importDefault(require("./helper"));
-const config_1 = __importDefault(require("./config"));
-const identification_1 = __importDefault(require("./identification"));
-const changelog_1 = __importDefault(require("./plugins/changelog"));
-const inputs_1 = __importDefault(require("./plugins/inputs"));
-const auth_1 = __importDefault(require("./plugins/auth"));
-const themes_1 = __importDefault(require("./plugins/packages/themes"));
-themes_1.default.loadLocalThemes();
-const index_1 = __importDefault(require("./plugins/packages/index"));
-const utils_1 = __importDefault(require("./command-line/utils"));
-const chan_1 = require("../shared/types/chan");
+import _ from "lodash";
+import { WebSocketServer as wsServer } from "ws";
+import express from "express";
+import fs from "fs";
+import path from "path";
+import { Server as ioServer } from "socket.io";
+import dns from "dns";
+import colors from "chalk";
+import net from "net";
+import log from "./log.js";
+import Client from "./client.js";
+import ClientManager from "./clientManager.js";
+import Uploader from "./plugins/uploader.js";
+import Helper from "./helper.js";
+import Config from "./config.js";
+import Identification from "./identification.js";
+import changelog from "./plugins/changelog.js";
+import inputs from "./plugins/inputs/index.js";
+import Auth from "./plugins/auth.js";
+import themes from "./plugins/packages/themes.js";
+themes.loadLocalThemes();
+import packages from "./plugins/packages/index.js";
+import Utils from "./command-line/utils.js";
+import { ChanType } from "../shared/types/chan.js";
 // A random number that will force clients to reload the page if it differs
 const serverHash = Math.floor(Date.now() * Math.random());
 let manager = null;
-async function default_1(options = {
+export default async function (options = {
     dev: false,
 }) {
-    log_1.default.info(`The Lounge ${chalk_1.default.green(helper_1.default.getVersion())} \
-(Node.js ${chalk_1.default.green(process.versions.node)} on ${chalk_1.default.green(process.platform)} ${process.arch})`);
-    log_1.default.info(`Configuration file: ${chalk_1.default.green(config_1.default.getConfigPath())}`);
+    log.info(`The Lounge ${colors.green(Helper.getVersion())} \
+(Node.js ${colors.green(process.versions.node)} on ${colors.green(process.platform)} ${process.arch})`);
+    log.info(`Configuration file: ${colors.green(Config.getConfigPath())}`);
     const staticOptions = {
         redirect: false,
         maxAge: 86400 * 1000,
     };
-    const app = (0, express_1.default)();
+    const app = express();
     if (options.dev) {
-        (await Promise.resolve().then(() => __importStar(require("./plugins/dev-server")))).default(app);
+        (await import("./plugins/dev-server.js")).default(app);
     }
     app.set("env", "production")
         .disable("x-powered-by")
@@ -75,10 +47,10 @@ async function default_1(options = {
         .get("/service-worker.js", forceNoCacheRequest)
         .get("/js/bundle.js.map", forceNoCacheRequest)
         .get("/css/style.css.map", forceNoCacheRequest)
-        .use(express_1.default.static(utils_1.default.getFileFromRelativeToRoot("public"), staticOptions))
-        .use("/storage/", express_1.default.static(config_1.default.getStoragePath(), staticOptions));
-    if (config_1.default.values.fileUpload.enable) {
-        uploader_1.default.router(app);
+        .use(express.static(Utils.getFileFromRelativeToRoot("public"), staticOptions))
+        .use("/storage/", express.static(Config.getStoragePath(), staticOptions));
+    if (Config.values.fileUpload.enable) {
+        Uploader.router(app);
     }
     // This route serves *installed themes only*. Local themes are served directly
     // from the `public/themes/` folder as static assets, without entering this
@@ -86,7 +58,7 @@ async function default_1(options = {
     // local themes will not get those changes.
     app.get("/themes/:theme.css", (req, res) => {
         const themeName = encodeURIComponent(req.params.theme);
-        const theme = themes_1.default.getByName(themeName);
+        const theme = themes.getByName(themeName);
         if (theme === undefined || theme.filename === undefined) {
             return res.status(404).send("Not found");
         }
@@ -95,161 +67,196 @@ async function default_1(options = {
     app.get("/packages/:package/:filename", (req, res) => {
         const packageName = req.params.package;
         const fileName = req.params.filename;
-        const packageFile = index_1.default.getPackage(packageName);
-        if (!packageFile || !index_1.default.getFiles().includes(`${packageName}/${fileName}`)) {
+        const packageFile = packages.getPackage(packageName);
+        if (!packageFile || !packages.getFiles().includes(`${packageName}/${fileName}`)) {
             return res.status(404).send("Not found");
         }
-        const packagePath = config_1.default.getPackageModulePath(packageName);
-        return res.sendFile(path_1.default.join(packagePath, fileName));
+        const packagePath = Config.getPackageModulePath(packageName);
+        return res.sendFile(path.join(packagePath, fileName));
     });
-    if (config_1.default.values.public && (config_1.default.values.ldap || {}).enable) {
-        log_1.default.warn("Server is public and set to use LDAP. Set to private mode if trying to use LDAP authentication.");
+    if (Config.values.public && (Config.values.ldap || {}).enable) {
+        log.warn("Server is public and set to use LDAP. Set to private mode if trying to use LDAP authentication.");
     }
     let server;
-    if (!config_1.default.values.https.enable) {
-        const createServer = (await Promise.resolve().then(() => __importStar(require("http")))).createServer;
+    if (!Config.values.https.enable) {
+        const createServer = (await import("http")).createServer;
         server = createServer(app);
     }
     else {
-        const keyPath = helper_1.default.expandHome(config_1.default.values.https.key);
-        const certPath = helper_1.default.expandHome(config_1.default.values.https.certificate);
-        const caPath = helper_1.default.expandHome(config_1.default.values.https.ca);
-        if (!keyPath.length || !fs_1.default.existsSync(keyPath)) {
-            log_1.default.error("Path to SSL key is invalid. Stopping server...");
+        const keyPath = Helper.expandHome(Config.values.https.key);
+        const certPath = Helper.expandHome(Config.values.https.certificate);
+        const caPath = Helper.expandHome(Config.values.https.ca);
+        if (!keyPath.length || !fs.existsSync(keyPath)) {
+            log.error("Path to SSL key is invalid. Stopping server...");
             process.exit(1);
         }
-        if (!certPath.length || !fs_1.default.existsSync(certPath)) {
-            log_1.default.error("Path to SSL certificate is invalid. Stopping server...");
+        if (!certPath.length || !fs.existsSync(certPath)) {
+            log.error("Path to SSL certificate is invalid. Stopping server...");
             process.exit(1);
         }
-        if (caPath.length && !fs_1.default.existsSync(caPath)) {
-            log_1.default.error("Path to SSL ca bundle is invalid. Stopping server...");
+        if (caPath.length && !fs.existsSync(caPath)) {
+            log.error("Path to SSL ca bundle is invalid. Stopping server...");
             process.exit(1);
         }
-        const createServer = (await Promise.resolve().then(() => __importStar(require("https")))).createServer;
+        const createServer = (await import("https")).createServer;
         server = createServer({
-            key: fs_1.default.readFileSync(keyPath),
-            cert: fs_1.default.readFileSync(certPath),
-            ca: caPath ? fs_1.default.readFileSync(caPath) : undefined,
+            key: fs.readFileSync(keyPath),
+            cert: fs.readFileSync(certPath),
+            ca: caPath ? fs.readFileSync(caPath) : undefined,
         }, app);
     }
     let listenParams;
-    if (typeof config_1.default.values.host === "string" && config_1.default.values.host.startsWith("unix:")) {
-        listenParams = config_1.default.values.host.replace(/^unix:/, "");
+    if (typeof Config.values.host === "string" && Config.values.host.startsWith("unix:")) {
+        listenParams = Config.values.host.replace(/^unix:/, "");
     }
     else {
         listenParams = {
-            port: config_1.default.values.port,
-            host: config_1.default.values.host,
+            port: Config.values.port,
+            host: Config.values.host,
         };
     }
-    // eslint-disable-next-line @typescript-eslint/restrict-template-expressions
-    server.on("error", (err) => log_1.default.error(`${err}`));
-    server.listen(listenParams, () => {
-        if (typeof listenParams === "string") {
-            log_1.default.info("Available on socket " + chalk_1.default.green(listenParams));
-        }
-        else {
-            const protocol = config_1.default.values.https.enable ? "https" : "http";
-            const address = server?.address();
-            if (address && typeof address !== "string") {
-                // TODO: Node may revert the Node 18 family string --> number change
-                // @ts-expect-error This condition will always return 'false' since the types 'string' and 'number' have no overlap.
-                if (address.family === "IPv6" || address.family === 6) {
-                    address.address = "[" + address.address + "]";
+    server.on("error", (err) => log.error(`${err}`));
+    let sockets = null;
+    let identd = null;
+    return new Promise((resolve) => {
+        server.listen(listenParams, () => {
+            void (async () => {
+                if (typeof listenParams === "string") {
+                    log.info("Available on socket " + colors.green(listenParams));
                 }
-                log_1.default.info("Available at " +
-                    chalk_1.default.green(`${protocol}://${address.address}:${address.port}/`) +
-                    ` in ${chalk_1.default.bold(config_1.default.values.public ? "public" : "private")} mode`);
-            }
-        }
-        // This should never happen
-        if (!server) {
-            return;
-        }
-        const sockets = new socket_io_1.Server(server, {
-            wsEngine: ws_1.Server,
-            cookie: false,
-            serveClient: false,
-            // TODO: type as Server.Transport[]
-            transports: config_1.default.values.transports,
-            pingTimeout: 60000,
-        });
-        sockets.on("connect", (socket) => {
-            // eslint-disable-next-line @typescript-eslint/restrict-template-expressions
-            socket.on("error", (err) => log_1.default.error(`io socket error: ${err}`));
-            if (config_1.default.values.public) {
-                performAuthentication.call(socket, {});
-            }
-            else {
-                socket.on("auth:perform", performAuthentication);
-                socket.emit("auth:start", serverHash);
-            }
-        });
-        manager = new clientManager_1.default();
-        index_1.default.loadPackages();
-        const defaultTheme = themes_1.default.getByName(config_1.default.values.theme);
-        if (defaultTheme === undefined) {
-            log_1.default.warn(`The specified default theme "${chalk_1.default.red(config_1.default.values.theme)}" does not exist, verify your config.`);
-            config_1.default.values.theme = "default";
-        }
-        else if (defaultTheme.themeColor) {
-            config_1.default.values.themeColor = defaultTheme.themeColor;
-        }
-        new identification_1.default((identHandler, err) => {
-            if (err) {
-                log_1.default.error(`Could not start identd server, ${err.message}`);
-                process.exit(1);
-            }
-            else if (!manager) {
-                log_1.default.error("Could not start identd server, ClientManager is undefined");
-                process.exit(1);
-            }
-            manager.init(identHandler, sockets);
-        });
-        // Handle ctrl+c and kill gracefully
-        let suicideTimeout = null;
-        const exitGracefully = async function () {
-            if (suicideTimeout !== null) {
-                return;
-            }
-            log_1.default.info("Exiting...");
-            // Close all client and IRC connections
-            if (manager) {
-                manager.clients.forEach((client) => client.quit());
-            }
-            if (config_1.default.values.prefetchStorage) {
-                log_1.default.info("Clearing prefetch storage folder, this might take a while...");
-                (await Promise.resolve().then(() => __importStar(require("./plugins/storage")))).default.emptyDir();
-            }
-            // Forcefully exit after 3 seconds
-            suicideTimeout = setTimeout(() => process.exit(1), 3000);
-            // Close http server
-            server?.close(() => {
-                if (suicideTimeout !== null) {
-                    clearTimeout(suicideTimeout);
+                else {
+                    const protocol = Config.values.https.enable ? "https" : "http";
+                    const address = server?.address();
+                    if (address && typeof address !== "string") {
+                        // Node.js changed address.family from number (4, 6) to string ("IPv4", "IPv6")
+                        // in v18, but may revert this change. Support both formats for compatibility.
+                        const family = address.family;
+                        if (family === "IPv6" || family === 6) {
+                            address.address = "[" + address.address + "]";
+                        }
+                        log.info("Available at " +
+                            colors.green(`${protocol}://${address.address}:${address.port}/`) +
+                            ` in ${colors.bold(Config.values.public ? "public" : "private")} mode`);
+                    }
                 }
-                process.exit(0);
-            });
-        };
-        /* eslint-disable @typescript-eslint/no-misused-promises */
-        process.on("SIGINT", exitGracefully);
-        process.on("SIGTERM", exitGracefully);
-        /* eslint-enable @typescript-eslint/no-misused-promises */
-        // Clear storage folder after server starts successfully
-        if (config_1.default.values.prefetchStorage) {
-            Promise.resolve().then(() => __importStar(require("./plugins/storage"))).then(({ default: storage }) => {
-                storage.emptyDir();
-            })
-                .catch((err) => {
-                log_1.default.error(`Could not clear storage folder, ${err.message}`);
-            });
-        }
-        changelog_1.default.checkForUpdates(manager);
+                // This should never happen
+                if (!server) {
+                    return;
+                }
+                sockets = new ioServer(server, {
+                    wsEngine: wsServer,
+                    cookie: false,
+                    serveClient: false,
+                    transports: Config.values.transports,
+                    pingTimeout: 60000,
+                });
+                sockets.on("connect", (socket) => {
+                    socket.on("error", (err) => log.error(`io socket error: ${err}`));
+                    if (Config.values.public) {
+                        performAuthentication.call(socket, {});
+                    }
+                    else {
+                        socket.on("auth:perform", performAuthentication);
+                        socket.emit("auth:start", serverHash);
+                    }
+                });
+                manager = new ClientManager();
+                await packages.loadPackages();
+                const defaultTheme = themes.getByName(Config.values.theme);
+                if (defaultTheme === undefined) {
+                    log.warn(`The specified default theme "${colors.red(Config.values.theme)}" does not exist, verify your config.`);
+                    Config.values.theme = "default";
+                }
+                else if (defaultTheme.themeColor) {
+                    Config.values.themeColor = defaultTheme.themeColor;
+                }
+                new Identification((identHandler, err) => {
+                    if (err) {
+                        log.error(`Could not start identd server, ${err.message}`);
+                        process.exit(1);
+                    }
+                    else if (!manager) {
+                        log.error("Could not start identd server, ClientManager is undefined");
+                        process.exit(1);
+                    }
+                    identd = identHandler;
+                    manager.init(identHandler, sockets);
+                });
+                // Handle ctrl+c and kill gracefully
+                let suicideTimeout = null;
+                const exitGracefully = function () {
+                    if (suicideTimeout !== null) {
+                        return;
+                    }
+                    log.info("Exiting...");
+                    // Close all client and IRC connections
+                    if (manager) {
+                        manager.clients.forEach((client) => client.quit());
+                    }
+                    if (Config.values.prefetchStorage) {
+                        log.info("Clearing prefetch storage folder, this might take a while...");
+                        import("./plugins/storage.js")
+                            .then(({ default: storage }) => {
+                            storage.emptyDir();
+                        })
+                            .catch((err) => {
+                            log.error(`Could not clear storage folder, ${err.message}`);
+                        });
+                    }
+                    // Forcefully exit after 3 seconds
+                    suicideTimeout = setTimeout(() => process.exit(1), 3000);
+                    // Close http server
+                    server?.close(() => {
+                        if (suicideTimeout !== null) {
+                            clearTimeout(suicideTimeout);
+                        }
+                        process.exit(0);
+                    });
+                };
+                process.on("SIGINT", exitGracefully);
+                process.on("SIGTERM", exitGracefully);
+                // Clear storage folder after server starts successfully
+                if (Config.values.prefetchStorage) {
+                    import("./plugins/storage.js")
+                        .then(({ default: storage }) => {
+                        storage.emptyDir();
+                    })
+                        .catch((err) => {
+                        log.error(`Could not clear storage folder, ${err.message}`);
+                    });
+                }
+                changelog.checkForUpdates(manager);
+                // Create stop method that properly closes everything
+                const stop = (callback) => {
+                    // Stop changelog update checks to clear the 24-hour timeout
+                    changelog.stopUpdateChecks();
+                    // Stop file watchers
+                    packages.stopWatching();
+                    if (manager) {
+                        manager.stopAutoloadUsers();
+                    }
+                    // Remove signal handlers to prevent double-close on SIGTERM/SIGINT
+                    process.removeListener("SIGINT", exitGracefully);
+                    process.removeListener("SIGTERM", exitGracefully);
+                    // Close identd first, then HTTP server (which will auto-close Socket.IO)
+                    if (identd) {
+                        identd.close(() => {
+                            server.close(callback);
+                        });
+                    }
+                    else {
+                        server.close(callback);
+                    }
+                };
+                resolve({
+                    httpServer: server,
+                    io: sockets,
+                    stop,
+                });
+            })();
+        });
     });
-    return server;
 }
-exports.default = default_1;
 function getClientLanguage(socket) {
     const acceptLanguage = socket.handshake.headers["accept-language"];
     if (typeof acceptLanguage === "string" && /^[\x00-\x7F]{1,50}$/.test(acceptLanguage)) {
@@ -260,11 +267,11 @@ function getClientLanguage(socket) {
 }
 function getClientIp(socket) {
     let ip = socket.handshake.address || "127.0.0.1";
-    if (config_1.default.values.reverseProxy) {
+    if (Config.values.reverseProxy) {
         const forwarded = String(socket.handshake.headers["x-forwarded-for"])
             .split(/\s*,\s*/)
             .filter(Boolean);
-        if (forwarded.length && net_1.default.isIP(forwarded[0])) {
+        if (forwarded.length && net.isIP(forwarded[0])) {
             ip = forwarded[0];
         }
     }
@@ -272,7 +279,7 @@ function getClientIp(socket) {
 }
 function getClientSecure(socket) {
     let secure = socket.handshake.secure;
-    if (config_1.default.values.reverseProxy && socket.handshake.headers["x-forwarded-proto"] === "https") {
+    if (Config.values.reverseProxy && socket.handshake.headers["x-forwarded-proto"] === "https") {
         secure = true;
     }
     return secure;
@@ -297,7 +304,7 @@ function addSecurityHeaders(_req, res, next) {
     // If prefetch is enabled, but storage is not, we have to allow mixed content
     // - https://user-images.githubusercontent.com is where we currently push our changelog screenshots
     // - data: is required for the HTML5 video player
-    if (config_1.default.values.prefetchStorage || !config_1.default.values.prefetch) {
+    if (Config.values.prefetchStorage || !Config.values.prefetch) {
         policies.push("img-src 'self' data: https://user-images.githubusercontent.com");
         policies.unshift("block-all-mixed-content");
     }
@@ -316,17 +323,17 @@ function forceNoCacheRequest(_req, res, next) {
 }
 function indexRequest(_req, res) {
     res.setHeader("Content-Type", "text/html");
-    fs_1.default.readFile(utils_1.default.getFileFromRelativeToRoot("client/index.html.tpl"), "utf-8", (err, file) => {
+    fs.readFile(Utils.getFileFromRelativeToRoot("client/index.html.tpl"), "utf-8", (err, file) => {
         if (err) {
-            log_1.default.error(`failed to server index request: ${err.name}, ${err.message}`);
+            log.error(`failed to server index request: ${err.name}, ${err.message}`);
             res.sendStatus(500);
             return;
         }
         const config = {
             ...getServerConfiguration(),
-            ...{ cacheBust: helper_1.default.getVersionCacheBust() },
+            ...{ cacheBust: Helper.getVersionCacheBust() },
         };
-        res.send(lodash_1.default.template(file)(config));
+        res.send(_.template(file)(config));
     });
 }
 function initializeClient(socket, client, token, lastMessage, openChannel) {
@@ -344,27 +351,43 @@ function initializeClient(socket, client, token, lastMessage, openChannel) {
     else {
         openChannel = client.lastActiveChannel;
     }
-    if (config_1.default.values.fileUpload.enable) {
-        new uploader_1.default(socket);
+    // If no valid active channel, default to the first channel of the first network
+    if (!openChannel || openChannel < 0) {
+        const firstNetwork = client.networks[0];
+        if (firstNetwork && firstNetwork.channels.length > 0) {
+            openChannel = firstNetwork.channels[0].id;
+        }
+    }
+    if (Config.values.fileUpload.enable) {
+        new Uploader(socket);
     }
     socket.on("disconnect", function () {
         process.nextTick(() => client.clientDetach(socket.id));
     });
     socket.on("input", (data) => {
-        if (lodash_1.default.isPlainObject(data)) {
+        if (_.isPlainObject(data)) {
             client.input(data);
         }
     });
     socket.on("more", (data) => {
-        if (lodash_1.default.isPlainObject(data)) {
+        if (_.isPlainObject(data)) {
             const history = client.more(data);
             if (history !== null) {
                 socket.emit("more", history);
             }
         }
     });
+    // Fetch messages around a specific time (for jumping to search results)
+    socket.on("messages:around", async (data) => {
+        if (_.isPlainObject(data)) {
+            const result = await client.getMessagesAround(data);
+            if (result !== null) {
+                socket.emit("messages:around", result);
+            }
+        }
+    });
     socket.on("network:new", (data) => {
-        if (lodash_1.default.isPlainObject(data)) {
+        if (_.isPlainObject(data)) {
             // prevent people from overriding webirc settings
             data.uuid = null;
             data.commands = null;
@@ -376,30 +399,30 @@ function initializeClient(socket, client, token, lastMessage, openChannel) {
         if (typeof data !== "string") {
             return;
         }
-        const network = lodash_1.default.find(client.networks, { uuid: data });
+        const network = _.find(client.networks, { uuid: data });
         if (!network) {
             return;
         }
         socket.emit("network:info", network.exportForEdit());
     });
     socket.on("network:edit", (data) => {
-        if (!lodash_1.default.isPlainObject(data)) {
+        if (!_.isPlainObject(data)) {
             return;
         }
-        const network = lodash_1.default.find(client.networks, { uuid: data.uuid });
+        const network = _.find(client.networks, { uuid: data.uuid });
         if (!network) {
             return;
         }
         network.edit(client, data);
     });
     socket.on("history:clear", (data) => {
-        if (lodash_1.default.isPlainObject(data)) {
+        if (_.isPlainObject(data)) {
             client.clearHistory(data);
         }
     });
-    if (!config_1.default.values.public && !config_1.default.values.ldap.enable) {
+    if (!Config.values.public && !Config.values.ldap.enable) {
         socket.on("change-password", (data) => {
-            if (lodash_1.default.isPlainObject(data)) {
+            if (_.isPlainObject(data)) {
                 const old = data.old_password;
                 const p1 = data.new_password;
                 const p2 = data.verify_password;
@@ -410,7 +433,7 @@ function initializeClient(socket, client, token, lastMessage, openChannel) {
                     });
                     return;
                 }
-                helper_1.default.password
+                Helper.password
                     .compare(old || "", client.config.password)
                     .then((matching) => {
                     if (!matching) {
@@ -420,7 +443,7 @@ function initializeClient(socket, client, token, lastMessage, openChannel) {
                         });
                         return;
                     }
-                    const hash = helper_1.default.password.hash(p1);
+                    const hash = Helper.password.hash(p1);
                     client.setPassword(hash, (success) => {
                         socket.emit("change-password", {
                             success: success,
@@ -429,7 +452,7 @@ function initializeClient(socket, client, token, lastMessage, openChannel) {
                     });
                 })
                     .catch((error) => {
-                    log_1.default.error(`Error while checking users password. Error: ${error.message}`);
+                    log.error(`Error while checking users password. Error: ${error.message}`);
                 });
             }
         });
@@ -438,7 +461,7 @@ function initializeClient(socket, client, token, lastMessage, openChannel) {
         client.open(socket.id, data);
     });
     socket.on("sort:networks", (data) => {
-        if (!lodash_1.default.isPlainObject(data)) {
+        if (!_.isPlainObject(data)) {
             return;
         }
         if (!Array.isArray(data.order)) {
@@ -447,7 +470,7 @@ function initializeClient(socket, client, token, lastMessage, openChannel) {
         client.sortNetworks(data.order);
     });
     socket.on("sort:channels", (data) => {
-        if (!lodash_1.default.isPlainObject(data)) {
+        if (!_.isPlainObject(data)) {
             return;
         }
         if (!Array.isArray(data.order) || typeof data.network !== "string") {
@@ -456,25 +479,25 @@ function initializeClient(socket, client, token, lastMessage, openChannel) {
         client.sortChannels(data.network, data.order);
     });
     socket.on("names", (data) => {
-        if (lodash_1.default.isPlainObject(data)) {
+        if (_.isPlainObject(data)) {
             client.names(data);
         }
     });
     socket.on("changelog", () => {
-        Promise.all([changelog_1.default.fetch(), index_1.default.outdated()])
+        Promise.all([changelog.fetch(), packages.outdated()])
             .then(([changelogData, packageUpdate]) => {
             changelogData.packages = packageUpdate;
             socket.emit("changelog", changelogData);
         })
             .catch((error) => {
-            log_1.default.error(`Error while fetching changelog. Error: ${error.message}`);
+            log.error(`Error while fetching changelog. Error: ${error.message}`);
         });
     });
     // In public mode only one client can be connected,
     // so there's no need to handle msg:preview:toggle
-    if (!config_1.default.values.public) {
+    if (!Config.values.public) {
         socket.on("msg:preview:toggle", (data) => {
-            if (lodash_1.default.isPlainObject(data)) {
+            if (_.isPlainObject(data)) {
                 return;
             }
             const networkAndChan = client.find(data.target);
@@ -516,7 +539,7 @@ function initializeClient(socket, client, token, lastMessage, openChannel) {
     socket.on("mentions:dismiss_all", () => {
         client.mentions = [];
     });
-    if (!config_1.default.values.public) {
+    if (!Config.values.public) {
         socket.on("push:register", (subscription) => {
             if (!Object.prototype.hasOwnProperty.call(client.config.sessions, token)) {
                 return;
@@ -535,10 +558,10 @@ function initializeClient(socket, client, token, lastMessage, openChannel) {
     }
     const sendSessionList = () => {
         // TODO: this should use the ClientSession type currently in client
-        const sessions = lodash_1.default.map(client.config.sessions, (session, sessionToken) => {
+        const sessions = _.map(client.config.sessions, (session, sessionToken) => {
             return {
                 current: sessionToken === token,
-                active: lodash_1.default.reduce(client.attachedClients, (count, attachedClient) => count + (attachedClient.token === sessionToken ? 1 : 0), 0),
+                active: _.reduce(client.attachedClients, (count, attachedClient) => count + (attachedClient.token === sessionToken ? 1 : 0), 0),
                 lastUse: session.lastUse,
                 ip: session.ip,
                 agent: session.agent,
@@ -548,9 +571,9 @@ function initializeClient(socket, client, token, lastMessage, openChannel) {
         socket.emit("sessions:list", sessions);
     };
     socket.on("sessions:get", sendSessionList);
-    if (!config_1.default.values.public) {
+    if (!Config.values.public) {
         socket.on("setting:set", (newSetting) => {
-            if (!lodash_1.default.isPlainObject(newSetting)) {
+            if (!_.isPlainObject(newSetting)) {
                 return;
             }
             if (typeof newSetting.value === "object" ||
@@ -597,15 +620,15 @@ function initializeClient(socket, client, token, lastMessage, openChannel) {
             }
             const { chan, network } = networkAndChan;
             // If the user mutes the lobby, we mute the entire network.
-            if (chan.type === chan_1.ChanType.LOBBY) {
+            if (chan.type === ChanType.LOBBY) {
                 for (const channel of network.channels) {
-                    if (channel.type !== chan_1.ChanType.SPECIAL) {
+                    if (channel.type !== ChanType.SPECIAL) {
                         channel.setMuteStatus(setMutedTo);
                     }
                 }
             }
             else {
-                if (chan.type !== chan_1.ChanType.SPECIAL) {
+                if (chan.type !== ChanType.SPECIAL) {
                     chan.setMuteStatus(setMutedTo);
                 }
             }
@@ -617,6 +640,25 @@ function initializeClient(socket, client, token, lastMessage, openChannel) {
             }
             client.save();
         });
+        socket.on("pin:change", ({ target, setPinnedTo }) => {
+            const networkAndChan = client.find(target);
+            if (!networkAndChan) {
+                return;
+            }
+            const { chan } = networkAndChan;
+            // Only allow pinning queries
+            if (chan.type !== ChanType.QUERY) {
+                return;
+            }
+            chan.pinned = setPinnedTo;
+            for (const attachedClient of Object.keys(client.attachedClients)) {
+                manager.sockets.in(attachedClient).emit("pin:changed", {
+                    target,
+                    status: setPinnedTo,
+                });
+            }
+            client.save();
+        });
     }
     socket.on("sign-out", (tokenToSignOut) => {
         // If no token provided, sign same client out
@@ -628,7 +670,7 @@ function initializeClient(socket, client, token, lastMessage, openChannel) {
         }
         delete client.config.sessions[tokenToSignOut];
         client.save();
-        lodash_1.default.map(client.attachedClients, (attachedClient, socketId) => {
+        _.map(client.attachedClients, (attachedClient, socketId) => {
             if (attachedClient.token !== tokenToSignOut) {
                 return;
             }
@@ -649,9 +691,9 @@ function initializeClient(socket, client, token, lastMessage, openChannel) {
             networks: client.networks.map((network) => network.getFilteredClone(openChannel, lastMessage)),
             token: tokenToSend,
         });
-        socket.emit("commands", inputs_1.default.getCommands());
+        socket.emit("commands", inputs.getCommands());
     };
-    if (config_1.default.values.public) {
+    if (Config.values.public) {
         sendInitEvent();
     }
     else if (!token) {
@@ -669,59 +711,58 @@ function initializeClient(socket, client, token, lastMessage, openChannel) {
 }
 function getClientConfiguration() {
     const common = {
-        fileUpload: config_1.default.values.fileUpload.enable,
-        ldapEnabled: config_1.default.values.ldap.enable,
-        isUpdateAvailable: changelog_1.default.isUpdateAvailable,
+        fileUpload: Config.values.fileUpload.enable,
+        ldapEnabled: Config.values.ldap.enable,
+        isUpdateAvailable: changelog.isUpdateAvailable,
         applicationServerKey: manager.webPush.vapidKeys.publicKey,
-        version: helper_1.default.getVersionNumber(),
-        gitCommit: helper_1.default.getGitCommit(),
-        themes: themes_1.default.getAll(),
-        defaultTheme: config_1.default.values.theme,
-        public: config_1.default.values.public,
-        useHexIp: config_1.default.values.useHexIp,
-        prefetch: config_1.default.values.prefetch,
-        fileUploadMaxFileSize: uploader_1.default ? uploader_1.default.getMaxFileSize() : undefined, // TODO can't be undefined?
+        version: Helper.getVersionNumber(),
+        gitCommit: Helper.getGitCommit(),
+        themes: themes.getAll(),
+        defaultTheme: Config.values.theme,
+        public: Config.values.public,
+        useHexIp: Config.values.useHexIp,
+        prefetch: Config.values.prefetch,
+        fileUploadMaxFileSize: Uploader ? Uploader.getMaxFileSize() : undefined, // TODO can't be undefined?
     };
     const defaultsOverride = {
-        nick: config_1.default.getDefaultNick(), // expand the number part
+        nick: Config.getDefaultNick(), // expand the number part
         // TODO: this doesn't seem right, if the client needs this as a buffer
         // the client ought to add it on its own
         sasl: "",
         saslAccount: "",
         saslPassword: "",
     };
-    if (!config_1.default.values.lockNetwork) {
+    if (!Config.values.lockNetwork) {
         const defaults = {
-            ...lodash_1.default.clone(config_1.default.values.defaults),
+            ..._.clone(Config.values.defaults),
             ...defaultsOverride,
         };
         const result = {
             ...common,
             defaults: defaults,
-            lockNetwork: config_1.default.values.lockNetwork,
+            lockNetwork: Config.values.lockNetwork,
         };
         return result;
     }
     // Only send defaults that are visible on the client
     const defaults = {
-        ...lodash_1.default.pick(config_1.default.values.defaults, ["name", "username", "password", "realname", "join"]),
+        ..._.omit(Config.values.defaults, ["host", "name", "port", "tls", "rejectUnauthorized"]),
         ...defaultsOverride,
     };
     const result = {
         ...common,
-        lockNetwork: config_1.default.values.lockNetwork,
+        lockNetwork: Config.values.lockNetwork,
         defaults: defaults,
     };
     return result;
 }
 function getServerConfiguration() {
-    return { ...config_1.default.values, ...{ stylesheets: index_1.default.getStylesheets() } };
+    return { ...Config.values, ...{ stylesheets: packages.getStylesheets() } };
 }
 function performAuthentication(data) {
-    if (!lodash_1.default.isPlainObject(data)) {
+    if (!_.isPlainObject(data)) {
         return;
     }
-    const socket = this;
     let client;
     let token;
     const finalInit = () => {
@@ -739,7 +780,7 @@ function performAuthentication(data) {
         if (!client) {
             throw new Error("finalInit called with undefined client, this is a bug");
         }
-        initializeClient(socket, client, token, lastMessage, openChannel);
+        initializeClient(this, client, token, lastMessage, openChannel);
     };
     const initClient = () => {
         if (!client) {
@@ -748,17 +789,17 @@ function performAuthentication(data) {
         // Configuration does not change during runtime of TL,
         // and the client listens to this event only once
         if (data && (!("hasConfig" in data) || !data.hasConfig)) {
-            socket.emit("configuration", getClientConfiguration());
-            socket.emit("push:issubscribed", token && client.config.sessions[token].pushSubscription ? true : false);
+            this.emit("configuration", getClientConfiguration());
+            this.emit("push:issubscribed", token && client.config.sessions[token].pushSubscription ? true : false);
         }
-        const clientIP = getClientIp(socket);
+        const clientIP = getClientIp(this);
         client.config.browser = {
             ip: clientIP,
-            isSecure: getClientSecure(socket),
-            language: getClientLanguage(socket),
+            isSecure: getClientSecure(this),
+            language: getClientLanguage(this),
         };
         // If webirc is enabled perform reverse dns lookup
-        if (config_1.default.values.webirc === null) {
+        if (Config.values.webirc === null) {
             return finalInit();
         }
         const cb_client = client; // ensure that TS figures out that client can't be nil
@@ -767,13 +808,13 @@ function performAuthentication(data) {
             finalInit();
         });
     };
-    if (config_1.default.values.public) {
-        client = new client_1.default(manager);
+    if (Config.values.public) {
+        client = new Client(manager);
         client.connect();
         manager.clients.push(client);
         const cb_client = client; // ensure TS can see we never have a nil client
-        socket.on("disconnect", function () {
-            manager.clients = lodash_1.default.without(manager.clients, cb_client);
+        this.on("disconnect", () => {
+            manager.clients = _.without(manager.clients, cb_client);
             cb_client.quit();
         });
         initClient();
@@ -786,12 +827,12 @@ function performAuthentication(data) {
         // Authorization failed
         if (!success) {
             if (!client) {
-                log_1.default.warn(`Authentication for non existing user attempted from ${chalk_1.default.bold(getClientIp(socket))}`);
+                log.warn(`Authentication for non existing user attempted from ${colors.bold(getClientIp(this))}`);
             }
             else {
-                log_1.default.warn(`Authentication failed for user ${chalk_1.default.bold(data.user)} from ${chalk_1.default.bold(getClientIp(socket))}`);
+                log.warn(`Authentication failed for user ${colors.bold(data.user)} from ${colors.bold(getClientIp(this))}`);
             }
-            socket.emit("auth:failed");
+            this.emit("auth:failed");
             return;
         }
         // If authorization succeeded but there is no loaded user,
@@ -815,13 +856,19 @@ function performAuthentication(data) {
         }
     }
     if (!("user" in data && "password" in data)) {
-        log_1.default.warn("performAuthentication: callback data has no user or no password");
+        log.warn("performAuthentication: callback data has no user or no password");
+        authCallback(false);
+        return;
+    }
+    if (!manager) {
+        log.error("performAuthentication: ClientManager not initialized");
         authCallback(false);
         return;
     }
-    auth_1.default.initialize().then(() => {
+    const clientManager = manager;
+    void Auth.initialize().then(() => {
         // Perform password checking
-        auth_1.default.auth(manager, client, data.user, data.password, authCallback);
+        Auth.auth(clientManager, client, data.user, data.password, authCallback);
     });
 }
 function reverseDnsLookup(ip, callback) {
@@ -829,11 +876,11 @@ function reverseDnsLookup(ip, callback) {
     // returning SERVFAIL it seems: https://github.com/thelounge/thelounge/issues/4768
     // so we manually resolve with the ip as a fallback in case something fails
     try {
-        dns_1.default.reverse(ip, (reverseErr, hostnames) => {
+        dns.reverse(ip, (reverseErr, hostnames) => {
             if (reverseErr || hostnames.length < 1) {
                 return callback(ip);
             }
-            dns_1.default.resolve(hostnames[0], net_1.default.isIP(ip) === 6 ? "AAAA" : "A", (resolveErr, resolvedIps) => {
+            dns.resolve(hostnames[0], net.isIP(ip) === 6 ? "AAAA" : "A", (resolveErr, resolvedIps) => {
                 // TODO: investigate SoaRecord class
                 if (!Array.isArray(resolvedIps)) {
                     return callback(ip);
@@ -851,7 +898,7 @@ function reverseDnsLookup(ip, callback) {
         });
     }
     catch (err) {
-        log_1.default.error(`failed to resolve rDNS for ${ip}, using ip instead`, err.toString());
+        log.error(`failed to resolve rDNS for ${ip}, using ip instead`, String(err));
         setImmediate(callback, ip); // makes sure we always behave asynchronously
     }
 }