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

package/dist/server/config.js

@@ -1,49 +1,45 @@
-"use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-/* eslint-disable @typescript-eslint/no-var-requires */
-const path_1 = __importDefault(require("path"));
-const fs_1 = __importDefault(require("fs"));
-const os_1 = __importDefault(require("os"));
-const lodash_1 = __importDefault(require("lodash"));
-const chalk_1 = __importDefault(require("chalk"));
-const log_1 = __importDefault(require("./log"));
-const helper_1 = __importDefault(require("./helper"));
-const utils_1 = __importDefault(require("./command-line/utils"));
+import path from "node:path";
+import fs from "node:fs";
+import os from "node:os";
+import _ from "lodash";
+import colors from "chalk";
+import { pathToFileURL } from "node:url";
+import log from "./log.js";
+import Helper from "./helper.js";
+import Utils from "./command-line/utils.js";
+import defaultConfig from "../defaults/config.js";
 class Config {
-    values = require(path_1.default.resolve(path_1.default.join(__dirname, "..", "defaults", "config.js")));
+    values = { ..._.cloneDeep(defaultConfig), themeColor: "" };
     #homePath = "";
     getHomePath() {
         return this.#homePath;
     }
     getConfigPath() {
-        return path_1.default.join(this.#homePath, "config.js");
+        return path.join(this.#homePath, "config.js");
     }
     getUserLogsPath() {
-        return path_1.default.join(this.#homePath, "logs");
+        return path.join(this.#homePath, "logs");
     }
     getStoragePath() {
-        return path_1.default.join(this.#homePath, "storage");
+        return path.join(this.#homePath, "storage");
     }
     getFileUploadPath() {
-        return path_1.default.join(this.#homePath, "uploads");
+        return path.join(this.#homePath, "uploads");
     }
     getUsersPath() {
-        return path_1.default.join(this.#homePath, "users");
+        return path.join(this.#homePath, "users");
     }
     getUserConfigPath(name) {
-        return path_1.default.join(this.getUsersPath(), `${name}.json`);
+        return path.join(this.getUsersPath(), `${name}.json`);
     }
     getClientCertificatesPath() {
-        return path_1.default.join(this.#homePath, "certificates");
+        return path.join(this.#homePath, "certificates");
     }
     getPackagesPath() {
-        return path_1.default.join(this.#homePath, "packages");
+        return path.join(this.#homePath, "packages");
     }
     getPackageModulePath(packageName) {
-        return path_1.default.join(this.getPackagesPath(), "node_modules", packageName);
+        return path.join(this.getPackagesPath(), "node_modules", packageName);
     }
     getDefaultNick() {
         if (!this.values.defaults.nick) {
@@ -59,37 +55,45 @@ class Config {
         // it mutates the oldConfig, but returns it as a convenience for testing
         for (const key in newConfig) {
             if (!Object.prototype.hasOwnProperty.call(oldConfig, key)) {
-                log_1.default.warn(`Unknown key "${chalk_1.default.bold(key)}", please verify your config.`);
+                log.warn(`Unknown key "${colors.bold(key)}", please verify your config.`);
             }
         }
-        return lodash_1.default.mergeWith(oldConfig, newConfig, (objValue, srcValue, key) => {
+        return _.mergeWith(oldConfig, newConfig, (objValue, srcValue, key) => {
             // Do not override config variables if the type is incorrect (e.g. object changed into a string)
             if (typeof objValue !== "undefined" &&
                 objValue !== null &&
                 typeof objValue !== typeof srcValue) {
-                log_1.default.warn(`Incorrect type for "${chalk_1.default.bold(key)}", please verify your config.`);
+                log.warn(`Incorrect type for "${colors.bold(key)}", please verify your config.`);
                 // eslint-disable-next-line @typescript-eslint/no-unsafe-return
                 return objValue;
             }
             // For arrays, simply override the value with user provided one.
-            if (lodash_1.default.isArray(objValue)) {
+            if (_.isArray(objValue)) {
                 // eslint-disable-next-line @typescript-eslint/no-unsafe-return
                 return srcValue;
             }
         });
     }
-    setHome(newPath) {
-        this.#homePath = helper_1.default.expandHome(newPath);
+    async setHome(newPath) {
+        this.#homePath = Helper.expandHome(newPath);
         // Reload config from new home location
         const configPath = this.getConfigPath();
-        if (fs_1.default.existsSync(configPath)) {
-            const userConfig = require(configPath);
-            if (lodash_1.default.isEmpty(userConfig)) {
-                log_1.default.warn(`The file located at ${chalk_1.default.green(configPath)} does not appear to expose anything.`);
-                log_1.default.warn(`Make sure it is non-empty and the configuration is exported using ${chalk_1.default.bold("module.exports = { ... }")}.`);
-                log_1.default.warn("Using default configuration...");
+        if (fs.existsSync(configPath)) {
+            try {
+                const configUrl = pathToFileURL(configPath).href;
+                const userConfigModule = await import(configUrl);
+                const userConfig = userConfigModule.default || userConfigModule;
+                if (_.isEmpty(userConfig)) {
+                    log.warn(`The file located at ${colors.green(configPath)} does not appear to expose anything.`);
+                    log.warn(`Make sure it is non-empty and the configuration is exported using ${colors.bold("export default { ... }")}.`);
+                    log.warn("Using default configuration...");
+                }
+                this.merge(userConfig);
+            }
+            catch (error) {
+                log.error(`Failed to load config from ${configPath}:`, String(error));
+                log.warn("Using default configuration...");
             }
-            this.merge(userConfig);
         }
         if (this.values.fileUpload.baseUrl) {
             try {
@@ -97,42 +101,47 @@ class Config {
             }
             catch (e) {
                 this.values.fileUpload.baseUrl = undefined;
-                log_1.default.warn(`The ${chalk_1.default.bold("fileUpload.baseUrl")} you specified is invalid: ${String(e)}`);
+                log.warn(`The ${colors.bold("fileUpload.baseUrl")} you specified is invalid: ${String(e)}`);
             }
         }
-        const manifestPath = utils_1.default.getFileFromRelativeToRoot("public", "thelounge.webmanifest");
+        const manifestPath = Utils.getFileFromRelativeToRoot("public", "thelounge.webmanifest");
         // Check if manifest exists, if not, the app most likely was not built
-        if (!fs_1.default.existsSync(manifestPath)) {
-            log_1.default.error(`The client application was not built. Run ${chalk_1.default.bold("NODE_ENV=production yarn build")} to resolve this.`);
-            process.exit(1);
+        // Skip this check in test environment
+        if (!fs.existsSync(manifestPath)) {
+            if (process.env.NODE_ENV !== "test") {
+                log.error(`The client application was not built. Run ${colors.bold("NODE_ENV=production yarn build")} to resolve this.`);
+                process.exit(1);
+            }
+        }
+        else {
+            // Load theme color from the web manifest
+            const manifest = JSON.parse(fs.readFileSync(manifestPath, "utf8"));
+            this.values.themeColor = manifest.theme_color;
         }
-        // Load theme color from the web manifest
-        const manifest = JSON.parse(fs_1.default.readFileSync(manifestPath, "utf8"));
-        this.values.themeColor = manifest.theme_color;
         // log dir probably shouldn't be world accessible.
         // Create it with the desired permission bits if it doesn't exist yet.
         let logsStat = undefined;
         const userLogsPath = this.getUserLogsPath();
         try {
-            logsStat = fs_1.default.statSync(userLogsPath);
+            logsStat = fs.statSync(userLogsPath);
         }
         catch {
             // ignored on purpose, node v14.17.0 will give us {throwIfNoEntry: false}
         }
         if (!logsStat) {
             try {
-                fs_1.default.mkdirSync(userLogsPath, { recursive: true, mode: 0o750 });
+                fs.mkdirSync(userLogsPath, { recursive: true, mode: 0o750 });
             }
             catch (e) {
-                log_1.default.error("Unable to create logs directory", e);
+                log.error("Unable to create logs directory", String(e));
             }
         }
         else if (logsStat && logsStat.mode & 0o001) {
-            log_1.default.warn(userLogsPath, "is world readable.", "The log files may be exposed. Please fix the permissions.");
-            if (os_1.default.platform() !== "win32") {
-                log_1.default.warn(`run \`chmod o-x "${userLogsPath}"\` to correct it.`);
+            log.warn(userLogsPath, "is world readable.", "The log files may be exposed. Please fix the permissions.");
+            if (os.platform() !== "win32") {
+                log.warn(`run \`chmod o-x "${userLogsPath}"\` to correct it.`);
             }
         }
     }
 }
-exports.default = new Config();
+export default new Config();

package/dist/server/helper.js

@@ -1,15 +1,11 @@
-"use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-const package_json_1 = __importDefault(require("../package.json"));
-const lodash_1 = __importDefault(require("lodash"));
-const path_1 = __importDefault(require("path"));
-const os_1 = __importDefault(require("os"));
-const net_1 = __importDefault(require("net"));
-const bcryptjs_1 = __importDefault(require("bcryptjs"));
-const crypto_1 = __importDefault(require("crypto"));
+import pkg from "../package.json" with { type: "json" };
+import _ from "lodash";
+import path from "node:path";
+import os from "node:os";
+import net from "node:net";
+import bcrypt from "bcryptjs";
+import crypto from "node:crypto";
+import { execSync } from "node:child_process";
 const Helper = {
     expandHome,
     getVersion,
@@ -21,20 +17,21 @@ const Helper = {
     compareHostmask,
     compareWithWildcard,
     catch_to_error,
+    toTrimmedString,
     password: {
         hash: passwordHash,
         compare: passwordCompare,
         requiresUpdate: passwordRequiresUpdate,
     },
 };
-exports.default = Helper;
+export default Helper;
 function getVersion() {
     const gitCommit = getGitCommit();
-    const version = `v${package_json_1.default.version}`;
+    const version = `v${pkg.version}`;
     return gitCommit ? `source (${gitCommit} / ${version})` : version;
 }
 function getVersionNumber() {
-    return package_json_1.default.version;
+    return pkg.version;
 }
 let _fetchedGitCommit = false;
 let _gitCommit = null;
@@ -46,27 +43,25 @@ function getGitCommit() {
     // --git-dir ".git" makes git only check current directory for `.git`, and not travel upwards
     // We set cwd to the location of `index.js` as soon as the process is started
     try {
-        // eslint-disable-next-line @typescript-eslint/no-var-requires
-        _gitCommit = require("child_process")
-            .execSync('git --git-dir ".git" rev-parse --short HEAD', // Returns hash of current commit
+        _gitCommit = execSync('git --git-dir ".git" rev-parse --short HEAD', // Returns hash of current commit
         { stdio: ["ignore", "pipe", "ignore"] })
             .toString()
             .trim();
         return _gitCommit;
     }
-    catch (e) {
+    catch {
         // Not a git repository or git is not installed
         _gitCommit = null;
         return null;
     }
 }
 function getVersionCacheBust() {
-    const hash = crypto_1.default.createHash("sha256").update(Helper.getVersion()).digest("hex");
+    const hash = crypto.createHash("sha256").update(Helper.getVersion()).digest("hex");
     return hash.substring(0, 10);
 }
 function ip2hex(address) {
     // no ipv6 support
-    if (!net_1.default.isIPv4(address)) {
+    if (!net.isIPv4(address)) {
         return "00000000";
     }
     return address
@@ -86,17 +81,17 @@ function expandHome(shortenedPath) {
     if (!shortenedPath) {
         return "";
     }
-    const home = os_1.default.homedir().replace("$", "$$$$");
-    return path_1.default.resolve(shortenedPath.replace(/^~($|\/|\\)/, home + "$1"));
+    const home = os.homedir().replace("$", "$$$$");
+    return path.resolve(shortenedPath.replace(/^~($|\/|\\)/, home + "$1"));
 }
 function passwordRequiresUpdate(password) {
-    return bcryptjs_1.default.getRounds(password) !== 11;
+    return bcrypt.getRounds(password) !== 11;
 }
 function passwordHash(password) {
-    return bcryptjs_1.default.hashSync(password, bcryptjs_1.default.genSaltSync(11));
+    return bcrypt.hashSync(password, bcrypt.genSaltSync(11));
 }
 function passwordCompare(password, expected) {
-    return bcryptjs_1.default.compare(password, expected);
+    return bcrypt.compare(password, expected);
 }
 function parseHostmask(hostmask) {
     let nick = "";
@@ -139,7 +134,7 @@ function compareWithWildcard(a, b) {
     // so we tokenize and join with the proper char back together,
     // escaping any other regex modifier
     const wildmany_split = a.split("*").map((sub) => {
-        const wildone_split = sub.split("?").map((p) => lodash_1.default.escapeRegExp(p));
+        const wildone_split = sub.split("?").map((p) => _.escapeRegExp(p));
         return wildone_split.join(".");
     });
     const user_regex = wildmany_split.join(".*");
@@ -155,7 +150,13 @@ function catch_to_error(prefix, err) {
         msg = err;
     }
     else {
-        msg = err.toString();
+        msg = String(err);
     }
     return new Error(`${prefix}: ${msg}`);
 }
+function toTrimmedString(value) {
+    if (typeof value !== "string") {
+        return "";
+    }
+    return String(value ?? "").trim();
+}

package/dist/server/identification.js

@@ -1,44 +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 fs_1 = __importDefault(require("fs"));
-const net_1 = __importDefault(require("net"));
-const chalk_1 = __importDefault(require("chalk"));
-const helper_1 = __importDefault(require("./helper"));
-const config_1 = __importDefault(require("./config"));
-const log_1 = __importDefault(require("./log"));
+import fs from "fs";
+import net from "net";
+import colors from "chalk";
+import Helper from "./helper.js";
+import Config from "./config.js";
+import log from "./log.js";
 class Identification {
     connectionId;
     connections;
     oidentdFile;
+    identdServer;
     constructor(startedCallback) {
         this.connectionId = 0;
         this.connections = new Map();
-        if (typeof config_1.default.values.oidentd === "string") {
-            this.oidentdFile = helper_1.default.expandHome(config_1.default.values.oidentd);
-            log_1.default.info(`Oidentd file: ${chalk_1.default.green(this.oidentdFile)}`);
+        if (typeof Config.values.oidentd === "string") {
+            this.oidentdFile = Helper.expandHome(Config.values.oidentd);
+            log.info(`Oidentd file: ${colors.green(this.oidentdFile)}`);
             this.refresh();
         }
-        if (config_1.default.values.identd.enable) {
+        if (Config.values.identd.enable) {
             if (this.oidentdFile) {
-                log_1.default.warn("Using both identd and oidentd at the same time, this is most likely not intended.");
+                log.warn("Using both identd and oidentd at the same time, this is most likely not intended.");
             }
-            const server = net_1.default.createServer(this.serverConnection.bind(this));
+            this.identdServer = net.createServer(this.serverConnection.bind(this));
+            const server = this.identdServer;
             server.on("error", (err) => {
                 startedCallback(this, err);
             });
             server.listen({
-                port: config_1.default.values.identd.port || 113,
-                host: config_1.default.values.bind,
+                port: Config.values.identd.port || 113,
+                host: Config.values.bind,
             }, () => {
                 const address = server.address();
                 if (typeof address === "string") {
-                    log_1.default.info(`Identd server available on ${chalk_1.default.green(address)}`);
+                    log.info(`Identd server available on ${colors.green(address)}`);
                 }
                 else if (address?.address) {
-                    log_1.default.info(`Identd server available on ${chalk_1.default.green(address.address + ":" + address.port.toString())}`);
+                    log.info(`Identd server available on ${colors.green(address.address + ":" + address.port.toString())}`);
                 }
                 startedCallback(this);
             });
@@ -48,9 +45,9 @@ class Identification {
         }
     }
     serverConnection(socket) {
-        socket.on("error", (err) => log_1.default.error(`Identd socket error: ${err}`));
+        socket.on("error", (err) => log.error(`Identd socket error: ${err}`));
         socket.setTimeout(5000, () => {
-            log_1.default.warn(`identd: no data received, closing connection to ${socket.remoteAddress || "undefined"}`);
+            log.warn(`identd: no data received, closing connection to ${socket.remoteAddress || "undefined"}`);
             socket.destroy();
         });
         socket.once("data", (data) => {
@@ -60,17 +57,17 @@ class Identification {
     }
     respondToIdent(socket, buffer) {
         if (!socket.remoteAddress) {
-            log_1.default.warn("identd: no remote address");
+            log.warn("identd: no remote address");
             return;
         }
         const data = buffer.toString().split(",");
         const lport = parseInt(data[0], 10) || 0;
         const fport = parseInt(data[1], 10) || 0;
         if (lport < 1 || fport < 1 || lport > 65535 || fport > 65535) {
-            log_1.default.warn(`identd: bogus request from ${socket.remoteAddress}`);
+            log.warn(`identd: bogus request from ${socket.remoteAddress}`);
             return;
         }
-        log_1.default.debug(`identd: remote ${socket.remoteAddress} query ${lport}, ${fport}`);
+        log.debug(`identd: remote ${socket.remoteAddress} query ${lport}, ${fport}`);
         for (const connection of this.connections.values()) {
             // we only want to respond if all the ip,port tuples match, to avoid user enumeration
             if (connection.socket.remotePort === fport &&
@@ -78,13 +75,13 @@ class Identification {
                 socket.remoteAddress === connection.socket.remoteAddress &&
                 socket.localAddress === connection.socket.localAddress) {
                 const reply = `${lport}, ${fport} : USERID : TheLounge : ${connection.user}\r\n`;
-                log_1.default.debug(`identd: reply is ${reply.trimEnd()}`);
+                log.debug(`identd: reply is ${reply.trimEnd()}`);
                 socket.write(reply);
                 return;
             }
         }
         const reply = `${lport}, ${fport} : ERROR : NO-USER\r\n`;
-        log_1.default.debug(`identd: reply is ${reply.trimEnd()}`);
+        log.debug(`identd: reply is ${reply.trimEnd()}`);
         socket.write(reply);
     }
     addSocket(socket, user) {
@@ -108,15 +105,15 @@ class Identification {
                 // Race condition: this can happen when more than one socket gets disconnected at
                 // once, since we `refresh()` for each one being added/removed. This results
                 // in there possibly being one or more disconnected sockets remaining when we get here.
-                log_1.default.warn(`oidentd: socket has no remote or local port (id=${id}). See https://github.com/thelounge/thelounge/pull/4695.`);
+                log.warn(`oidentd: socket has no remote or local port (id=${id}). See https://github.com/lordbex/thelounge/pull/4695.`);
                 return;
             }
             if (!connection.socket.remoteAddress) {
-                log_1.default.warn(`oidentd: socket has no remote address, will not respond to queries`);
+                log.warn(`oidentd: socket has no remote address, will not respond to queries`);
                 return;
             }
             if (!connection.socket.localAddress) {
-                log_1.default.warn(`oidentd: socket has no local address, will not respond to queries`);
+                log.warn(`oidentd: socket has no local address, will not respond to queries`);
                 return;
             }
             // we only want to respond if all the ip,port tuples match, to avoid user enumeration
@@ -128,12 +125,20 @@ class Identification {
                     ` { reply "${connection.user}" }\n`;
         });
         if (this.oidentdFile) {
-            fs_1.default.writeFile(this.oidentdFile, file, { flag: "w+" }, function (err) {
+            fs.writeFile(this.oidentdFile, file, { flag: "w+" }, function (err) {
                 if (err) {
-                    log_1.default.error("Failed to update oidentd file!", err.message);
+                    log.error("Failed to update oidentd file!", err.message);
                 }
             });
         }
     }
+    close(callback) {
+        if (this.identdServer) {
+            this.identdServer.close(callback);
+        }
+        else {
+            callback();
+        }
+    }
 }
-exports.default = Identification;
+export default Identification;

package/dist/server/index.js

@@ -1,3 +1 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-require("./command-line");
+import "./command-line/index.js";

package/dist/server/log.js

@@ -1,35 +1,38 @@
-"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 read_1 = __importDefault(require("read"));
+import colors from "chalk";
+import { read } from "read";
+import Config from "./config.js";
 function timestamp() {
     const datetime = new Date().toISOString().split(".")[0].replace("T", " ");
-    return chalk_1.default.dim(datetime);
+    return colors.dim(datetime);
 }
 const log = {
     /* eslint-disable no-console */
     error(...args) {
-        console.error(timestamp(), chalk_1.default.red("[ERROR]"), ...args);
+        console.error(timestamp(), colors.red("[ERROR]"), ...args);
     },
     warn(...args) {
-        console.error(timestamp(), chalk_1.default.yellow("[WARN]"), ...args);
+        console.error(timestamp(), colors.yellow("[WARN]"), ...args);
     },
     info(...args) {
-        console.log(timestamp(), chalk_1.default.blue("[INFO]"), ...args);
+        console.log(timestamp(), colors.blue("[INFO]"), ...args);
     },
     debug(...args) {
-        console.log(timestamp(), chalk_1.default.green("[DEBUG]"), ...args);
+        if (!Config.values.debug.logs)
+            return;
+        console.log(timestamp(), colors.green("[DEBUG]"), ...args);
     },
     raw(...args) {
         console.log(...args);
     },
     /* eslint-enable no-console */
-    prompt(options, callback) {
-        options.prompt = [timestamp(), chalk_1.default.cyan("[PROMPT]"), options.text].join(" ");
-        (0, read_1.default)(options, callback);
+    async prompt(options) {
+        const promptText = [timestamp(), colors.cyan("[PROMPT]"), options.text].join(" ");
+        const result = await read({
+            default: options.default,
+            prompt: promptText,
+            silent: options.silent,
+        });
+        return String(result);
     },
 };
-exports.default = log;
+export default log;