@lordbex/thelounge 4.4.3-blowfish

package/dist/server/command-line/upgrade.js

@@ -0,0 +1,64 @@
+"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 log_1 = __importDefault(require("../log"));
+const chalk_1 = __importDefault(require("chalk"));
+const commander_1 = require("commander");
+const config_1 = __importDefault(require("../config"));
+const utils_1 = __importDefault(require("./utils"));
+const program = new commander_1.Command("upgrade");
+program
+    .arguments("[packages...]")
+    .description("Upgrade installed themes and packages to their latest versions")
+    .on("--help", utils_1.default.extraHelp)
+    .action(function (packages) {
+    const fs = require("fs");
+    const path = require("path");
+    // Get paths to the location of packages directory
+    const packagesConfig = path.join(config_1.default.getPackagesPath(), "package.json");
+    const packagesList = JSON.parse(fs.readFileSync(packagesConfig, "utf-8")).dependencies;
+    const argsList = ["upgrade", "--latest"];
+    let count = 0;
+    if (!Object.entries(packagesList).length) {
+        log_1.default.warn("There are no packages installed.");
+        return;
+    }
+    // If a package names are supplied, check they exist
+    if (packages.length) {
+        log_1.default.info("Upgrading the following packages:");
+        packages.forEach((p) => {
+            log_1.default.info(`- ${chalk_1.default.green(p)}`);
+            if (Object.prototype.hasOwnProperty.call(packagesList, p)) {
+                argsList.push(p);
+                count++;
+            }
+            else {
+                log_1.default.error(`${chalk_1.default.green(p)} is not installed.`);
+            }
+        });
+    }
+    else {
+        log_1.default.info("Upgrading all packages...");
+    }
+    if (count === 0 && packages.length) {
+        log_1.default.warn("There are not any packages to upgrade.");
+        return;
+    }
+    const command = argsList.shift();
+    const params = argsList;
+    if (!command) {
+        return;
+    }
+    return utils_1.default.executeYarnCommand(command, ...params)
+        .then(() => {
+        log_1.default.info("Package(s) have been successfully upgraded.");
+    })
+        .catch((code) => {
+        log_1.default.error(`Failed to upgrade package(s). Exit code ${String(code)}`);
+        process.exit(1);
+    });
+});
+exports.default = program;

package/dist/server/command-line/users/add.js

@@ -0,0 +1,67 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const log_1 = __importDefault(require("../../log"));
+const chalk_1 = __importDefault(require("chalk"));
+const commander_1 = require("commander");
+const fs_1 = __importDefault(require("fs"));
+const helper_1 = __importDefault(require("../../helper"));
+const config_1 = __importDefault(require("../../config"));
+const utils_1 = __importDefault(require("../utils"));
+const program = new commander_1.Command("add");
+program
+    .description("Add a new user")
+    .on("--help", utils_1.default.extraHelp)
+    .option("--password [password]", "new password, will be prompted if not specified")
+    .option("--save-logs", "if password is specified, this enables saving logs to disk")
+    .argument("<name>", "name of the user")
+    .action(function (name, cmdObj) {
+    if (!fs_1.default.existsSync(config_1.default.getUsersPath())) {
+        log_1.default.error(`${config_1.default.getUsersPath()} does not exist.`);
+        return;
+    }
+    // eslint-disable-next-line @typescript-eslint/no-var-requires
+    const ClientManager = require("../../clientManager").default;
+    const manager = new ClientManager();
+    const users = manager.getUsers();
+    if (users === undefined) {
+        // There was an error, already logged
+        return;
+    }
+    if (users.includes(name)) {
+        log_1.default.error(`User ${chalk_1.default.bold(name)} already exists.`);
+        return;
+    }
+    if (cmdObj.password) {
+        add(manager, name, cmdObj.password, !!cmdObj.saveLogs);
+        return;
+    }
+    log_1.default.prompt({
+        text: "Enter password:",
+        silent: true,
+    }, function (err, password) {
+        if (!password) {
+            log_1.default.error("Password cannot be empty.");
+            return;
+        }
+        if (!err) {
+            log_1.default.prompt({
+                text: "Save logs to disk?",
+                default: "yes",
+            }, function (err2, enableLog) {
+                if (!err2) {
+                    add(manager, name, password, enableLog.charAt(0).toLowerCase() === "y");
+                }
+            });
+        }
+    });
+});
+function add(manager, name, password, enableLog) {
+    const hash = helper_1.default.password.hash(password);
+    manager.addUser(name, hash, enableLog);
+    log_1.default.info(`User ${chalk_1.default.bold(name)} created.`);
+    log_1.default.info(`User file located at ${chalk_1.default.green(config_1.default.getUserConfigPath(name))}.`);
+}
+exports.default = program;

package/dist/server/command-line/users/edit.js

@@ -0,0 +1,39 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const log_1 = __importDefault(require("../../log"));
+const commander_1 = require("commander");
+const child_process_1 = __importDefault(require("child_process"));
+const chalk_1 = __importDefault(require("chalk"));
+const fs_1 = __importDefault(require("fs"));
+const config_1 = __importDefault(require("../../config"));
+const utils_1 = __importDefault(require("../utils"));
+const program = new commander_1.Command("edit");
+program
+    .description(`Edit user file located at ${chalk_1.default.green(config_1.default.getUserConfigPath("<name>"))}`)
+    .argument("<name>", "name of the user")
+    .on("--help", utils_1.default.extraHelp)
+    .action(function (name) {
+    if (!fs_1.default.existsSync(config_1.default.getUsersPath())) {
+        log_1.default.error(`${config_1.default.getUsersPath()} does not exist.`);
+        return;
+    }
+    // eslint-disable-next-line @typescript-eslint/no-var-requires
+    const ClientManager = require("../../clientManager").default;
+    const users = new ClientManager().getUsers();
+    if (users === undefined) {
+        // There was an error, already logged
+        return;
+    }
+    if (!users.includes(name)) {
+        log_1.default.error(`User ${chalk_1.default.bold(name)} does not exist.`);
+        return;
+    }
+    const child_spawn = child_process_1.default.spawn(process.env.EDITOR || "vi", [config_1.default.getUserConfigPath(name)], { stdio: "inherit" });
+    child_spawn.on("error", function () {
+        log_1.default.error(`Unable to open ${chalk_1.default.green(config_1.default.getUserConfigPath(name))}. ${chalk_1.default.bold("$EDITOR")} is not set, and ${chalk_1.default.bold("vi")} was not found.`);
+    });
+});
+exports.default = program;

package/dist/server/command-line/users/index.js

@@ -0,0 +1,17 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const config_1 = __importDefault(require("../../config"));
+let add, reset;
+if (!config_1.default.values.ldap.enable) {
+    // eslint-disable-next-line @typescript-eslint/no-var-requires
+    add = require("./add").default;
+    // eslint-disable-next-line @typescript-eslint/no-var-requires
+    reset = require("./reset").default;
+}
+const list_1 = __importDefault(require("./list"));
+const remove_1 = __importDefault(require("./remove"));
+const edit_1 = __importDefault(require("./edit"));
+exports.default = [list_1.default, remove_1.default, edit_1.default, add, reset];

package/dist/server/command-line/users/list.js

@@ -0,0 +1,53 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const log_1 = __importDefault(require("../../log"));
+const chalk_1 = __importDefault(require("chalk"));
+const commander_1 = require("commander");
+const utils_1 = __importDefault(require("../utils"));
+const program = new commander_1.Command("list");
+program
+    .description("List all users")
+    .on("--help", utils_1.default.extraHelp)
+    .action(async function () {
+    const ClientManager = (await Promise.resolve().then(() => __importStar(require("../../clientManager")))).default;
+    const users = new ClientManager().getUsers();
+    if (users === undefined) {
+        // There was an error, already logged
+        return;
+    }
+    if (users.length === 0) {
+        log_1.default.info(`There are currently no users. Create one with ${chalk_1.default.bold("thelounge add <name>")}.`);
+        return;
+    }
+    log_1.default.info("Users:");
+    users.forEach((user, i) => {
+        log_1.default.info(`${i + 1}. ${chalk_1.default.bold(user)}`);
+    });
+});
+exports.default = program;

package/dist/server/command-line/users/remove.js

@@ -0,0 +1,37 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const log_1 = __importDefault(require("../../log"));
+const chalk_1 = __importDefault(require("chalk"));
+const commander_1 = require("commander");
+const fs_1 = __importDefault(require("fs"));
+const config_1 = __importDefault(require("../../config"));
+const utils_1 = __importDefault(require("../utils"));
+const program = new commander_1.Command("remove");
+program
+    .description("Remove an existing user")
+    .on("--help", utils_1.default.extraHelp)
+    .argument("<name>", "name of the user")
+    .action(function (name) {
+    if (!fs_1.default.existsSync(config_1.default.getUsersPath())) {
+        log_1.default.error(`${config_1.default.getUsersPath()} does not exist.`);
+        return;
+    }
+    // eslint-disable-next-line @typescript-eslint/no-var-requires
+    const ClientManager = require("../../clientManager").default;
+    const manager = new ClientManager();
+    try {
+        if (manager.removeUser(name)) {
+            log_1.default.info(`User ${chalk_1.default.bold(name)} removed.`);
+        }
+        else {
+            log_1.default.error(`User ${chalk_1.default.bold(name)} does not exist.`);
+        }
+    }
+    catch (e) {
+        // There was an error, already logged
+    }
+});
+exports.default = program;

package/dist/server/command-line/users/reset.js

@@ -0,0 +1,64 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const log_1 = __importDefault(require("../../log"));
+const chalk_1 = __importDefault(require("chalk"));
+const commander_1 = require("commander");
+const fs_1 = __importDefault(require("fs"));
+const helper_1 = __importDefault(require("../../helper"));
+const config_1 = __importDefault(require("../../config"));
+const utils_1 = __importDefault(require("../utils"));
+const program = new commander_1.Command("reset");
+program
+    .description("Reset user password")
+    .on("--help", utils_1.default.extraHelp)
+    .argument("<name>", "name of the user")
+    .option("--password [password]", "new password, will be prompted if not specified")
+    .action(function (name, cmdObj) {
+    if (!fs_1.default.existsSync(config_1.default.getUsersPath())) {
+        log_1.default.error(`${config_1.default.getUsersPath()} does not exist.`);
+        return;
+    }
+    // eslint-disable-next-line @typescript-eslint/no-var-requires
+    const ClientManager = require("../../clientManager").default;
+    const users = new ClientManager().getUsers();
+    if (users === undefined) {
+        // There was an error, already logged
+        return;
+    }
+    if (!users.includes(name)) {
+        log_1.default.error(`User ${chalk_1.default.bold(name)} does not exist.`);
+        return;
+    }
+    if (cmdObj.password) {
+        change(name, cmdObj.password);
+        return;
+    }
+    log_1.default.prompt({
+        text: "Enter new password:",
+        silent: true,
+    }, function (err, password) {
+        if (err) {
+            return;
+        }
+        change(name, password);
+    });
+});
+function change(name, password) {
+    const pathReal = config_1.default.getUserConfigPath(name);
+    const pathTemp = pathReal + ".tmp";
+    const user = JSON.parse(fs_1.default.readFileSync(pathReal, "utf-8"));
+    user.password = helper_1.default.password.hash(password);
+    user.sessions = {};
+    const newUser = JSON.stringify(user, null, "\t");
+    // Write to a temp file first, in case the write fails
+    // we do not lose the original file (for example when disk is full)
+    fs_1.default.writeFileSync(pathTemp, newUser, {
+        mode: 0o600,
+    });
+    fs_1.default.renameSync(pathTemp, pathReal);
+    log_1.default.info(`Successfully reset password for ${chalk_1.default.bold(name)}.`);
+}
+exports.default = program;

package/dist/server/command-line/utils.js

@@ -0,0 +1,177 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const lodash_1 = __importDefault(require("lodash"));
+const log_1 = __importDefault(require("../log"));
+const chalk_1 = __importDefault(require("chalk"));
+const fs_1 = __importDefault(require("fs"));
+const helper_1 = __importDefault(require("../helper"));
+const config_1 = __importDefault(require("../config"));
+const path_1 = __importDefault(require("path"));
+const child_process_1 = require("child_process");
+let home;
+class Utils {
+    static extraHelp() {
+        [
+            "",
+            "Environment variable:",
+            `  THELOUNGE_HOME            Path for all configuration files and folders. Defaults to ${chalk_1.default.green(helper_1.default.expandHome(Utils.defaultHome()))}`,
+            "",
+        ].forEach((e) => log_1.default.raw(e));
+    }
+    static defaultHome() {
+        if (home) {
+            return home;
+        }
+        const distConfig = Utils.getFileFromRelativeToRoot(".thelounge_home");
+        home = fs_1.default.readFileSync(distConfig, "utf-8").trim();
+        return home;
+    }
+    static getFileFromRelativeToRoot(...fileName) {
+        // e.g. /thelounge/server/command-line/utils.ts
+        if (process.env.NODE_ENV === "test" || process.env.NODE_ENV === "development") {
+            return path_1.default.resolve(path_1.default.join(__dirname, "..", "..", ...fileName));
+        }
+        // e.g. /thelounge/dist/server/command-line/utils.ts
+        return path_1.default.resolve(path_1.default.join(__dirname, "..", "..", "..", ...fileName));
+    }
+    // Parses CLI options such as `-c public=true`, `-c debug.raw=true`, etc.
+    static parseConfigOptions(val, memo) {
+        // Invalid option that is not of format `key=value`, do nothing
+        if (!val.includes("=")) {
+            // eslint-disable-next-line @typescript-eslint/no-unsafe-return
+            return memo;
+        }
+        const parseValue = (value) => {
+            switch (value) {
+                case "true":
+                    return true;
+                case "false":
+                    return false;
+                case "undefined":
+                    return undefined;
+                case "null":
+                    return null;
+                default:
+                    if (/^-?[0-9]+$/.test(value)) {
+                        // Numbers like port
+                        return parseInt(value, 10);
+                    }
+                    else if (/^\[.*\]$/.test(value)) {
+                        // Arrays
+                        // Supporting arrays `[a,b]` and `[a, b]`
+                        const array = value.slice(1, -1).split(/,\s*/);
+                        // If [] is given, it will be parsed as `[ "" ]`, so treat this as empty
+                        if (array.length === 1 && array[0] === "") {
+                            return [];
+                        }
+                        return array.map(parseValue); // Re-parses all values of the array
+                    }
+                    return value;
+            }
+        };
+        // First time the option is parsed, memo is not set
+        if (memo === undefined) {
+            memo = {};
+        }
+        // Note: If passed `-c foo="bar=42"` (with single or double quotes), `val`
+        //       will always be passed as `foo=bar=42`, never with quotes.
+        const position = val.indexOf("="); // Only split on the first = found
+        const key = val.slice(0, position);
+        const value = val.slice(position + 1);
+        const parsedValue = parseValue(value);
+        if (lodash_1.default.has(memo, key)) {
+            log_1.default.warn(`Configuration key ${chalk_1.default.bold(key)} was already specified, ignoring...`);
+        }
+        else {
+            memo = lodash_1.default.set(memo, key, parsedValue);
+        }
+        // eslint-disable-next-line @typescript-eslint/no-unsafe-return
+        return memo;
+    }
+    static executeYarnCommand(command, ...parameters) {
+        const yarn = require.resolve("yarn/bin/yarn.js");
+        const packagesPath = config_1.default.getPackagesPath();
+        const cachePath = path_1.default.join(packagesPath, "package_manager_cache");
+        const staticParameters = [
+            "--cache-folder",
+            cachePath,
+            "--cwd",
+            packagesPath,
+            "--json",
+            "--ignore-scripts",
+            "--non-interactive",
+        ];
+        const env = {
+            // We only ever operate in production mode
+            NODE_ENV: "production",
+            // If The Lounge runs from a user that does not have a home directory,
+            // yarn may fail when it tries to read certain folders,
+            // we give it an existing folder so the reads do not throw a permission error.
+            // Yarn uses os.homedir() to figure out the path, which internally reads
+            // from the $HOME env on unix. On Windows it uses $USERPROFILE, but
+            // the user folder should always exist on Windows, so we don't set it.
+            HOME: cachePath,
+        };
+        return new Promise((resolve, reject) => {
+            let success = false;
+            const add = (0, child_process_1.spawn)(process.execPath, [yarn, command, ...staticParameters, ...parameters], { env: env });
+            add.stdout.on("data", (data) => {
+                data.toString()
+                    .trim()
+                    .split("\n")
+                    .forEach((line) => {
+                    try {
+                        const json = JSON.parse(line);
+                        if (json.type === "success") {
+                            success = true;
+                        }
+                    }
+                    catch (e) {
+                        // Stdout buffer has limitations and yarn may print
+                        // big package trees, for example in the upgrade command
+                        // See https://github.com/thelounge/thelounge/issues/3679
+                    }
+                });
+            });
+            add.stderr.on("data", (data) => {
+                data.toString()
+                    .trim()
+                    .split("\n")
+                    .forEach((line) => {
+                    try {
+                        const json = JSON.parse(line);
+                        switch (json.type) {
+                            case "error":
+                                log_1.default.error(json.data);
+                                break;
+                            case "warning":
+                                // this includes pointless things like "ignored scripts due to flag"
+                                // so let's hide it
+                                break;
+                        }
+                        return;
+                    }
+                    catch (e) {
+                        // we simply fall through and log at debug... chances are there's nothing the user can do about it
+                        // as it includes things like deprecation warnings, but we might want to know as developers
+                    }
+                    log_1.default.debug(line);
+                });
+            });
+            add.on("error", (e) => {
+                log_1.default.error(`${e.message}:`, e.stack || "");
+                process.exit(1);
+            });
+            add.on("close", (code) => {
+                if (!success || code !== 0) {
+                    return reject(code);
+                }
+                resolve(true);
+            });
+        });
+    }
+}
+exports.default = Utils;

package/dist/server/config.js

@@ -0,0 +1,138 @@
+"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"));
+class Config {
+    values = require(path_1.default.resolve(path_1.default.join(__dirname, "..", "defaults", "config.js")));
+    #homePath = "";
+    getHomePath() {
+        return this.#homePath;
+    }
+    getConfigPath() {
+        return path_1.default.join(this.#homePath, "config.js");
+    }
+    getUserLogsPath() {
+        return path_1.default.join(this.#homePath, "logs");
+    }
+    getStoragePath() {
+        return path_1.default.join(this.#homePath, "storage");
+    }
+    getFileUploadPath() {
+        return path_1.default.join(this.#homePath, "uploads");
+    }
+    getUsersPath() {
+        return path_1.default.join(this.#homePath, "users");
+    }
+    getUserConfigPath(name) {
+        return path_1.default.join(this.getUsersPath(), `${name}.json`);
+    }
+    getClientCertificatesPath() {
+        return path_1.default.join(this.#homePath, "certificates");
+    }
+    getPackagesPath() {
+        return path_1.default.join(this.#homePath, "packages");
+    }
+    getPackageModulePath(packageName) {
+        return path_1.default.join(this.getPackagesPath(), "node_modules", packageName);
+    }
+    getDefaultNick() {
+        if (!this.values.defaults.nick) {
+            return "thelounge";
+        }
+        return this.values.defaults.nick.replace(/%/g, () => Math.floor(Math.random() * 10).toString());
+    }
+    merge(newConfig) {
+        this._merge_config_objects(this.values, newConfig);
+    }
+    _merge_config_objects(oldConfig, newConfig) {
+        // semi exposed function so that we can test it
+        // 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.`);
+            }
+        }
+        return lodash_1.default.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.`);
+                // 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)) {
+                // eslint-disable-next-line @typescript-eslint/no-unsafe-return
+                return srcValue;
+            }
+        });
+    }
+    setHome(newPath) {
+        this.#homePath = helper_1.default.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...");
+            }
+            this.merge(userConfig);
+        }
+        if (this.values.fileUpload.baseUrl) {
+            try {
+                new URL("test/file.png", this.values.fileUpload.baseUrl);
+            }
+            catch (e) {
+                this.values.fileUpload.baseUrl = undefined;
+                log_1.default.warn(`The ${chalk_1.default.bold("fileUpload.baseUrl")} you specified is invalid: ${String(e)}`);
+            }
+        }
+        const manifestPath = utils_1.default.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);
+        }
+        // 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);
+        }
+        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 });
+            }
+            catch (e) {
+                log_1.default.error("Unable to create logs directory", 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.`);
+            }
+        }
+    }
+}
+exports.default = new Config();