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

package/dist/server/plugins/sts.js

@@ -1,26 +1,21 @@
-"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 fs_1 = __importDefault(require("fs"));
-const path_1 = __importDefault(require("path"));
-const log_1 = __importDefault(require("../log"));
-const config_1 = __importDefault(require("../config"));
+import _ from "lodash";
+import fs from "fs";
+import path from "path";
+import log from "../log.js";
+import Config from "../config.js";
 class STSPolicies {
     stsFile;
     refresh;
     policies;
     constructor() {
-        this.stsFile = path_1.default.join(config_1.default.getHomePath(), "sts-policies.json");
+        this.stsFile = path.join(Config.getHomePath(), "sts-policies.json");
         this.policies = new Map();
         // eslint-disable-next-line @typescript-eslint/unbound-method
-        this.refresh = lodash_1.default.debounce(this.saveFile, 10000, { maxWait: 60000 });
-        if (!fs_1.default.existsSync(this.stsFile)) {
+        this.refresh = _.debounce(this.saveFile, 10000, { maxWait: 60000 });
+        if (!fs.existsSync(this.stsFile)) {
             return;
         }
-        const storedPolicies = JSON.parse(fs_1.default.readFileSync(this.stsFile, "utf-8"));
+        const storedPolicies = JSON.parse(fs.readFileSync(this.stsFile, "utf-8"));
         const now = Date.now();
         storedPolicies.forEach((value) => {
             if (value.expires > now) {
@@ -75,11 +70,11 @@ class STSPolicies {
             });
         });
         const file = JSON.stringify(policiesToStore, null, "\t");
-        fs_1.default.writeFile(this.stsFile, file, { flag: "w+" }, (err) => {
+        fs.writeFile(this.stsFile, file, { flag: "w+" }, (err) => {
             if (err) {
-                log_1.default.error("Failed to update STS policies file!", err.message);
+                log.error("Failed to update STS policies file!", err.message);
             }
         });
     }
 }
-exports.default = new STSPolicies();
+export default new STSPolicies();

package/dist/server/plugins/uploader.js

@@ -1,19 +1,13 @@
-"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"));
-const busboy_1 = __importDefault(require("@fastify/busboy"));
-const uuid_1 = require("uuid");
-const path_1 = __importDefault(require("path"));
-const fs_1 = __importDefault(require("fs"));
-const file_type_1 = __importDefault(require("file-type"));
-const read_chunk_1 = __importDefault(require("read-chunk"));
-const crypto_1 = __importDefault(require("crypto"));
-const is_utf8_1 = __importDefault(require("is-utf8"));
-const log_1 = __importDefault(require("../log"));
-const content_disposition_1 = __importDefault(require("content-disposition"));
+import Config from "../config.js";
+import busboy from "@fastify/busboy";
+import { v4 as uuidv4 } from "uuid";
+import path from "node:path";
+import fs from "node:fs";
+import { fileTypeFromBuffer } from "file-type";
+import { readChunk } from "read-chunk";
+import crypto from "node:crypto";
+import log from "../log.js";
+import contentDisposition from "content-disposition";
 // Map of allowed mime types to their respecive default filenames
 // that will be rendered in browser without forcing them to be downloaded
 const inlineContentDispositionTypes = {
@@ -40,7 +34,7 @@ const uploadTokens = new Map();
 class Uploader {
     constructor(socket) {
         socket.on("upload:auth", () => {
-            const token = (0, uuid_1.v4)();
+            const token = uuidv4();
             socket.emit("upload:auth", token);
             // Invalidate the token in one minute
             const timeout = Uploader.createTokenTimeout(token);
@@ -62,9 +56,8 @@ class Uploader {
     static createTokenTimeout(token) {
         return setTimeout(() => uploadTokens.delete(token), 60 * 1000);
     }
-    // TODO: type
     static router(express) {
-        express.get("/uploads/:name/:slug*?", Uploader.routeGetFile);
+        express.get("/uploads/:name{/:slug}", Uploader.routeGetFile);
         express.post("/uploads/new/:token", Uploader.routeUploadFile);
     }
     static async routeGetFile(req, res) {
@@ -74,8 +67,8 @@ class Uploader {
             return res.status(404).send("Not found");
         }
         const folder = name.substring(0, 2);
-        const uploadPath = config_1.default.getFileUploadPath();
-        const filePath = path_1.default.join(uploadPath, folder, name);
+        const uploadPath = Config.getFileUploadPath();
+        const filePath = path.join(uploadPath, folder, name);
         let detectedMimeType = await Uploader.getFileType(filePath);
         // doesn't exist
         if (detectedMimeType === null) {
@@ -89,7 +82,7 @@ class Uploader {
             slug = inlineContentDispositionTypes[detectedMimeType];
         }
         if (slug) {
-            disposition = (0, content_disposition_1.default)(slug.trim(), {
+            disposition = contentDisposition(slug.trim(), {
                 fallback: false,
                 type: disposition,
             });
@@ -137,11 +130,11 @@ class Uploader {
         const abortWithError = (err) => {
             doneCallback();
             // if we ended up erroring out, delete the output file from disk
-            if (destPath && fs_1.default.existsSync(destPath)) {
-                fs_1.default.unlinkSync(destPath);
+            if (destPath && fs.existsSync(destPath)) {
+                fs.unlinkSync(destPath);
                 destPath = null;
             }
-            return res.status(400).json({ error: err.message });
+            return res.status(400).json({ error: err instanceof Error ? err.message : String(err) });
         };
         // if the authentication token is incorrect, bail out
         if (uploadTokens.delete(req.params.token) !== true) {
@@ -159,7 +152,7 @@ class Uploader {
         // create a new busboy processor, it is wrapped in try/catch
         // because it can throw on malformed headers
         try {
-            busboyInstance = new busboy_1.default({
+            busboyInstance = new busboy({
                 headers: req.headers,
                 limits: {
                     files: 1, // only allow one file per upload
@@ -179,34 +172,33 @@ class Uploader {
         // we use do/while loop to prevent the rare case of generating a file name
         // that already exists on disk
         do {
-            randomName = crypto_1.default.randomBytes(8).toString("hex");
-            destDir = path_1.default.join(config_1.default.getFileUploadPath(), randomName.substring(0, 2));
-            destPath = path_1.default.join(destDir, randomName);
-        } while (fs_1.default.existsSync(destPath));
+            randomName = crypto.randomBytes(8).toString("hex");
+            destDir = path.join(Config.getFileUploadPath(), randomName.substring(0, 2));
+            destPath = path.join(destDir, randomName);
+        } while (fs.existsSync(destPath));
         // we split the filename into subdirectories (by taking 2 letters from the beginning)
         // this helps avoid file system and certain tooling limitations when there are
         // too many files on one folder
         try {
-            fs_1.default.mkdirSync(destDir, { recursive: true });
+            fs.mkdirSync(destDir, { recursive: true });
         }
         catch (err) {
-            log_1.default.error(`Error ensuring ${destDir} exists for uploads: ${err.message}`);
+            log.error(`Error ensuring ${destDir} exists for uploads: ${err instanceof Error ? err.message : String(err)}`);
             return abortWithError(err);
         }
         // Open a file stream for writing
-        streamWriter = fs_1.default.createWriteStream(destPath);
+        streamWriter = fs.createWriteStream(destPath);
         streamWriter.on("error", abortWithError);
         busboyInstance.on("file", (fieldname, fileStream, filename) => {
             uploadUrl = `${randomName}/${encodeURIComponent(filename)}`;
-            if (config_1.default.values.fileUpload.baseUrl) {
-                uploadUrl = new URL(uploadUrl, config_1.default.values.fileUpload.baseUrl).toString();
+            if (Config.values.fileUpload.baseUrl) {
+                uploadUrl = new URL(uploadUrl, Config.values.fileUpload.baseUrl).toString();
             }
             else {
                 uploadUrl = `uploads/${uploadUrl}`;
             }
             // if the busboy data stream errors out or goes over the file size limit
             // abort the processing with an error
-            // @ts-expect-error Argument of type '(err: any) => Response<any, Record<string, any>>' is not assignable to parameter of type '{ (err: any): Response<any, Record<string, any>>; (): void; }'.ts(2345)
             fileStream.on("error", abortWithError);
             fileStream.on("limit", () => {
                 fileStream.unpipe(streamWriter);
@@ -230,7 +222,7 @@ class Uploader {
         return req.pipe(busboyInstance);
     }
     static getMaxFileSize() {
-        const configOption = config_1.default.values.fileUpload.maxFileSize;
+        const configOption = Config.values.fileUpload.maxFileSize;
         // Busboy uses Infinity to allow unlimited file size
         if (configOption < 1) {
             return Infinity;
@@ -242,26 +234,31 @@ class Uploader {
     // Returns a string with the type otherwise
     static async getFileType(filePath) {
         try {
-            const buffer = await (0, read_chunk_1.default)(filePath, 0, 5120);
+            const buffer = await readChunk(filePath, { length: 5120, startPosition: 0 });
             // returns {ext, mime} if found, null if not.
-            const file = await file_type_1.default.fromBuffer(buffer);
+            const file = await fileTypeFromBuffer(buffer);
             // if a file type was detected correctly, return it
             if (file) {
                 return file.mime;
             }
             // if the buffer is a valid UTF-8 buffer, use text/plain
-            if ((0, is_utf8_1.default)(buffer)) {
+            try {
+                new TextDecoder("utf-8", { fatal: true }).decode(buffer);
                 return "text/plain";
             }
+            catch {
+                // Not valid UTF-8, continue to detect as binary
+            }
             // otherwise assume it's random binary data
             return "application/octet-stream";
         }
         catch (e) {
-            if (e.code !== "ENOENT") {
-                log_1.default.warn(`Failed to read ${filePath}: ${e.message}`);
+            if (e && typeof e === "object" && "code" in e && e.code !== "ENOENT") {
+                const message = e instanceof Error ? e.message : "unknown error";
+                log.warn(`Failed to read ${filePath}: ${message}`);
             }
         }
         return null;
     }
 }
-exports.default = Uploader;
+export default Uploader;

package/dist/server/plugins/webpush.js

@@ -1,45 +1,17 @@
-"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 log_1 = __importDefault(require("../log"));
-const fs_1 = __importDefault(require("fs"));
-const path_1 = __importDefault(require("path"));
-const web_push_1 = __importDefault(require("web-push"));
-const config_1 = __importDefault(require("../config"));
-const os = __importStar(require("os"));
+import _ from "lodash";
+import log from "../log.js";
+import fs from "fs";
+import path from "path";
+import WebPushAPI from "web-push";
+import Config from "../config.js";
+import * as os from "os";
 class WebPush {
     vapidKeys;
     constructor() {
-        const vapidPath = path_1.default.join(config_1.default.getHomePath(), "vapid.json");
+        const vapidPath = path.join(Config.getHomePath(), "vapid.json");
         let vapidStat = undefined;
         try {
-            vapidStat = fs_1.default.statSync(vapidPath);
+            vapidStat = fs.statSync(vapidPath);
         }
         catch {
             // ignored on purpose, node v14.17.0 will give us {throwIfNoEntry: false}
@@ -47,12 +19,12 @@ class WebPush {
         if (vapidStat) {
             const isWorldReadable = (vapidStat.mode & 0o004) !== 0;
             if (isWorldReadable) {
-                log_1.default.warn(vapidPath, "is world readable.", "The file contains secrets. Please fix the permissions.");
+                log.warn(vapidPath, "is world readable.", "The file contains secrets. Please fix the permissions.");
                 if (os.platform() !== "win32") {
-                    log_1.default.warn(`run \`chmod o= "${vapidPath}"\` to correct it.`);
+                    log.warn(`run \`chmod o= "${vapidPath}"\` to correct it.`);
                 }
             }
-            const data = fs_1.default.readFileSync(vapidPath, "utf-8");
+            const data = fs.readFileSync(vapidPath, "utf-8");
             const parsedData = JSON.parse(data);
             if (typeof parsedData.publicKey === "string" &&
                 typeof parsedData.privateKey === "string") {
@@ -63,18 +35,18 @@ class WebPush {
             }
         }
         if (!this.vapidKeys) {
-            this.vapidKeys = web_push_1.default.generateVAPIDKeys();
-            fs_1.default.writeFileSync(vapidPath, JSON.stringify(this.vapidKeys, null, "\t"), {
+            this.vapidKeys = WebPushAPI.generateVAPIDKeys();
+            fs.writeFileSync(vapidPath, JSON.stringify(this.vapidKeys, null, "\t"), {
                 mode: 0o600,
             });
-            log_1.default.info("New VAPID key pair has been generated for use with push subscription.");
+            log.info("New VAPID key pair has been generated for use with push subscription.");
         }
-        web_push_1.default.setVapidDetails("https://github.com/thelounge/thelounge", this.vapidKeys.publicKey, this.vapidKeys.privateKey);
+        WebPushAPI.setVapidDetails("https://github.com/lordbex/thelounge", this.vapidKeys.publicKey, this.vapidKeys.privateKey);
     }
     push(client, payload, onlyToOffline) {
-        lodash_1.default.forOwn(client.config.sessions, ({ pushSubscription }, token) => {
+        _.forOwn(client.config.sessions, ({ pushSubscription }, token) => {
             if (pushSubscription) {
-                if (onlyToOffline && lodash_1.default.find(client.attachedClients, { token }) !== undefined) {
+                if (onlyToOffline && _.find(client.attachedClients, { token }) !== undefined) {
                     return;
                 }
                 this.pushSingle(client, pushSubscription, payload);
@@ -82,18 +54,18 @@ class WebPush {
         });
     }
     pushSingle(client, subscription, payload) {
-        web_push_1.default.sendNotification(subscription, JSON.stringify(payload)).catch((error) => {
+        WebPushAPI.sendNotification(subscription, JSON.stringify(payload)).catch((error) => {
             if (error.statusCode >= 400 && error.statusCode < 500) {
-                log_1.default.warn(`WebPush subscription for ${client.name} returned an error (${String(error.statusCode)}), removing subscription`);
-                lodash_1.default.forOwn(client.config.sessions, ({ pushSubscription }, token) => {
+                log.warn(`WebPush subscription for ${client.name} returned an error (${String(error.statusCode)}), removing subscription`);
+                _.forOwn(client.config.sessions, ({ pushSubscription }, token) => {
                     if (pushSubscription && pushSubscription.endpoint === subscription.endpoint) {
                         client.unregisterPushSubscription(token);
                     }
                 });
                 return;
             }
-            log_1.default.error(`WebPush Error (${String(error)})`);
+            log.error(`WebPush Error (${String(error)})`);
         });
     }
 }
-exports.default = WebPush;
+export default WebPush;