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

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

@@ -1,64 +1,63 @@
-"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");
+import log from "../../log.js";
+import colors from "chalk";
+import { Command } from "commander";
+import fs from "fs";
+import Helper from "../../helper.js";
+import Config from "../../config.js";
+import Utils from "../utils.js";
+const program = new Command("reset");
 program
     .description("Reset user password")
-    .on("--help", utils_1.default.extraHelp)
+    .on("--help", Utils.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.`);
+    .action(async function (name, cmdObj) {
+    if (!fs.existsSync(Config.getUsersPath())) {
+        log.error(`${Config.getUsersPath()} does not exist.`);
         return;
     }
-    // eslint-disable-next-line @typescript-eslint/no-var-requires
-    const ClientManager = require("../../clientManager").default;
+    const { default: ClientManager } = await import("../../clientManager.js");
     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.`);
+        log.error(`User ${colors.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;
-        }
+    try {
+        const password = await log.prompt({
+            text: "Enter new password:",
+            silent: true,
+        });
         change(name, password);
-    });
+    }
+    catch (err) {
+        log.error("Error during prompt:", String(err));
+    }
 });
 function change(name, password) {
-    const pathReal = config_1.default.getUserConfigPath(name);
+    if (!password) {
+        log.error("Password cannot be empty.");
+        return;
+    }
+    const pathReal = Config.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);
+    const user = JSON.parse(fs.readFileSync(pathReal, "utf-8"));
+    user.password = Helper.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, {
+    fs.writeFileSync(pathTemp, newUser, {
         mode: 0o600,
     });
-    fs_1.default.renameSync(pathTemp, pathReal);
-    log_1.default.info(`Successfully reset password for ${chalk_1.default.bold(name)}.`);
+    fs.renameSync(pathTemp, pathReal);
+    log.info(`Successfully reset password for ${colors.bold(name)}.`);
 }
-exports.default = program;
+export default program;

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

@@ -1,47 +1,45 @@
-"use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-const 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");
+import _ from "lodash";
+import log from "../log.js";
+import colors from "chalk";
+import fs from "node:fs";
+import Helper from "../helper.js";
+import Config from "../config.js";
+import path from "node:path";
+import { spawn } from "node:child_process";
+import { createRequire } from "node:module";
+import { getDirname } from "../path-helper.js";
 let home;
+const require = createRequire(import.meta.url);
 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()))}`,
+            `  THELOUNGE_HOME            Path for all configuration files and folders. Defaults to ${colors.green(Helper.expandHome(Utils.defaultHome()))}`,
             "",
-        ].forEach((e) => log_1.default.raw(e));
+        ].forEach((e) => log.raw(e));
     }
     static defaultHome() {
         if (home) {
             return home;
         }
         const distConfig = Utils.getFileFromRelativeToRoot(".thelounge_home");
-        home = fs_1.default.readFileSync(distConfig, "utf-8").trim();
+        home = fs.readFileSync(distConfig, "utf-8").trim();
         return home;
     }
     static getFileFromRelativeToRoot(...fileName) {
+        const __dirname = getDirname(import.meta.url);
         // 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));
+            return path.resolve(path.join(__dirname, "..", "..", ...fileName));
         }
         // e.g. /thelounge/dist/server/command-line/utils.ts
-        return path_1.default.resolve(path_1.default.join(__dirname, "..", "..", "..", ...fileName));
+        return path.resolve(path.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) => {
@@ -82,96 +80,242 @@ class Utils {
         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...`);
+        if (_.has(memo, key)) {
+            log.warn(`Configuration key ${colors.bold(key)} was already specified, ignoring...`);
         }
         else {
-            memo = lodash_1.default.set(memo, key, parsedValue);
+            memo = _.set(memo, key, parsedValue);
         }
-        // eslint-disable-next-line @typescript-eslint/no-unsafe-return
         return memo;
     }
+    // Cache for detected package manager
+    static #detectedPM = null;
+    static #detectPackageManager() {
+        if (this.#detectedPM) {
+            return this.#detectedPM;
+        }
+        // Try to find yarn first (check version)
+        try {
+            const yarnVersion = require("child_process")
+                .execSync("yarn --version", { encoding: "utf-8", stdio: ["pipe", "pipe", "pipe"] })
+                .trim();
+            if (yarnVersion.startsWith("1.")) {
+                log.debug(`Detected Yarn Classic v${yarnVersion}`);
+                this.#detectedPM = { name: "yarn1" };
+                return this.#detectedPM;
+            }
+            else if (yarnVersion.startsWith("4.") ||
+                yarnVersion.startsWith("3.") ||
+                yarnVersion.startsWith("2.")) {
+                log.debug(`Detected Yarn Berry v${yarnVersion}`);
+                this.#detectedPM = { name: "yarn4" };
+                return this.#detectedPM;
+            }
+        }
+        catch {
+            // Yarn not available
+        }
+        // Try npm (bundled with Node.js, should always be available)
+        try {
+            const npmVersion = require("child_process")
+                .execSync("npm --version", { encoding: "utf-8", stdio: ["pipe", "pipe", "pipe"] })
+                .trim();
+            log.debug(`Detected npm v${npmVersion}`);
+            this.#detectedPM = { name: "npm" };
+            return this.#detectedPM;
+        }
+        catch {
+            // npm not available
+        }
+        // Default to npm and hope for the best
+        log.warn("Could not detect package manager, defaulting to npm");
+        this.#detectedPM = { name: "npm" };
+        return this.#detectedPM;
+    }
     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 packagesPath = Config.getPackagesPath();
+        const cachePath = path.join(packagesPath, "package_manager_cache");
+        // Ensure directories exist
+        fs.mkdirSync(cachePath, { recursive: true });
+        fs.mkdirSync(path.join(packagesPath, "node_modules"), { recursive: true });
+        const pm = this.#detectPackageManager();
+        let executable;
+        let args;
         const env = {
-            // We only ever operate in production mode
+            ...process.env,
             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,
         };
+        if (pm.name === "npm") {
+            executable = "npm";
+            args = this.#buildNpmArgs(command, parameters, packagesPath, cachePath);
+        }
+        else if (pm.name === "yarn1") {
+            executable = "yarn";
+            args = this.#buildYarn1Args(command, parameters, packagesPath, cachePath);
+        }
+        else {
+            // yarn4/berry
+            executable = "yarn";
+            args = this.#buildYarn4Args(command, parameters, packagesPath);
+        }
         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;
+            const isOutdated = command === "outdated";
+            log.debug(`Running: ${executable} ${args.join(" ")}`);
+            const proc = spawn(executable, args, {
+                env: env,
+                shell: true,
+                cwd: pm.name === "yarn4" ? packagesPath : undefined,
+            });
+            proc.stdout.on("data", (data) => {
+                const output = data.toString().trim();
+                if (output) {
+                    // For yarn1 JSON output, check for success type
+                    if (pm.name === "yarn1") {
+                        try {
+                            const lines = output.split("\n");
+                            for (const line of lines) {
+                                const json = JSON.parse(line);
+                                if (json.type === "success") {
+                                    success = true;
+                                }
+                            }
+                        }
+                        catch {
+                            // Not JSON, just log it
                         }
                     }
-                    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
-                    }
-                });
+                    log.debug(output);
+                }
             });
-            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;
+            proc.stderr.on("data", (data) => {
+                const output = data.toString().trim();
+                if (output) {
+                    // Filter out noise
+                    if (output.includes("WARN") || output.includes("warning")) {
+                        log.debug(output);
+                    }
+                    else if (output.includes("ERR!") || output.includes("error")) {
+                        log.error(output);
                     }
-                    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
+                    else {
+                        log.debug(output);
                     }
-                    log_1.default.debug(line);
-                });
+                }
             });
-            add.on("error", (e) => {
-                log_1.default.error(`${e.message}:`, e.stack || "");
-                process.exit(1);
+            proc.on("error", (e) => {
+                log.error(`${e.message}:`, e.stack || "");
+                reject(new Error(e.message));
             });
-            add.on("close", (code) => {
-                if (!success || code !== 0) {
-                    return reject(code);
+            proc.on("close", (code) => {
+                // Handle exit codes
+                if (code === 0) {
+                    success = true;
+                }
+                else if (isOutdated && code === 1) {
+                    // outdated commands return 1 when packages are outdated
+                    success = true;
+                }
+                if (!success) {
+                    return reject(new Error(`Process exited with code ${code}`));
                 }
                 resolve(true);
             });
         });
     }
+    static #buildNpmArgs(command, parameters, packagesPath, cachePath) {
+        let npmCommand = command;
+        const args = [];
+        switch (command) {
+            case "add":
+                npmCommand = "install";
+                for (const param of parameters) {
+                    if (param === "--exact") {
+                        args.push("--save-exact");
+                    }
+                    else {
+                        args.push(param);
+                    }
+                }
+                break;
+            case "remove":
+                npmCommand = "uninstall";
+                args.push(...parameters);
+                break;
+            case "upgrade":
+                npmCommand = "update";
+                args.push(...parameters);
+                break;
+            default:
+                args.push(...parameters);
+        }
+        return [
+            npmCommand,
+            "--prefix",
+            packagesPath,
+            "--cache",
+            cachePath,
+            "--ignore-scripts",
+            ...args,
+        ];
+    }
+    static #buildYarn1Args(command, parameters, packagesPath, cachePath) {
+        const args = [
+            command,
+            "--cache-folder",
+            cachePath,
+            "--cwd",
+            packagesPath,
+            "--json",
+            "--ignore-scripts",
+            "--non-interactive",
+            ...parameters,
+        ];
+        return args;
+    }
+    // eslint-disable-next-line @typescript-eslint/no-unused-vars
+    static #buildYarn4Args(command, parameters, packagesPath) {
+        // Yarn 4 (Berry) has different syntax
+        // It uses the cwd option via process.cwd() or --cwd flag
+        let yarnCommand = command;
+        const args = [];
+        switch (command) {
+            case "add":
+                yarnCommand = "add";
+                for (const param of parameters) {
+                    if (param === "--exact") {
+                        args.push("--exact");
+                    }
+                    else {
+                        args.push(param);
+                    }
+                }
+                break;
+            case "remove":
+                yarnCommand = "remove";
+                args.push(...parameters);
+                break;
+            case "upgrade":
+                yarnCommand = "up";
+                args.push(...parameters);
+                break;
+            case "outdated":
+                // Yarn 4 has yarn npm audit but no direct outdated equivalent
+                // Use yarn info to check versions - but for simplicity just return success
+                // The outdated check is not critical functionality
+                yarnCommand = "info";
+                args.push("--name-only");
+                break;
+            case "install":
+                yarnCommand = "install";
+                args.push(...parameters);
+                break;
+            default:
+                args.push(...parameters);
+        }
+        // Yarn 4 uses mode flag instead of ignore-scripts
+        return [yarnCommand, "--mode=skip-build", ...args];
+    }
 }
-exports.default = Utils;
+export default Utils;