@lordbex/thelounge 4.4.3-blowfish

package/dist/server/plugins/packages/index.js

@@ -0,0 +1,200 @@
+"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 path_1 = __importDefault(require("path"));
+const semver_1 = __importDefault(require("semver"));
+const helper_1 = __importDefault(require("../../helper"));
+const config_1 = __importDefault(require("../../config"));
+const themes_1 = __importDefault(require("./themes"));
+const inputs_1 = __importDefault(require("../inputs"));
+const fs_1 = __importDefault(require("fs"));
+const utils_1 = __importDefault(require("../../command-line/utils"));
+const packageMap = new Map();
+const stylesheets = [];
+const files = [];
+const TIME_TO_LIVE = 15 * 60 * 1000; // 15 minutes, in milliseconds
+const cache = {
+    outdated: undefined,
+};
+let experimentalWarningPrinted = false;
+exports.default = {
+    getFiles,
+    getStylesheets,
+    getPackage,
+    loadPackages,
+    outdated,
+};
+// TODO: verify binds worked. Used to be 'this' instead of 'packageApis'
+const packageApis = function (packageInfo) {
+    return {
+        Stylesheets: {
+            addFile: addStylesheet.bind(packageApis, packageInfo.packageName),
+        },
+        PublicFiles: {
+            add: addFile.bind(packageApis, packageInfo.packageName),
+        },
+        Commands: {
+            add: inputs_1.default.addPluginCommand.bind(packageApis, packageInfo),
+            runAsUser: (command, targetId, client) => client.inputLine({ target: targetId, text: command }),
+        },
+        Config: {
+            getConfig: () => config_1.default.values,
+            getPersistentStorageDir: getPersistentStorageDir.bind(packageApis, packageInfo.packageName),
+        },
+        Logger: {
+            error: (...args) => log_1.default.error(`[${packageInfo.packageName}]`, ...args),
+            warn: (...args) => log_1.default.warn(`[${packageInfo.packageName}]`, ...args),
+            info: (...args) => log_1.default.info(`[${packageInfo.packageName}]`, ...args),
+            debug: (...args) => log_1.default.debug(`[${packageInfo.packageName}]`, ...args),
+        },
+    };
+};
+function addStylesheet(packageName, filename) {
+    stylesheets.push(packageName + "/" + filename);
+}
+function getStylesheets() {
+    return stylesheets;
+}
+function addFile(packageName, filename) {
+    files.push(packageName + "/" + filename);
+}
+function getFiles() {
+    return files.concat(stylesheets);
+}
+function getPackage(name) {
+    return packageMap.get(name);
+}
+function getEnabledPackages(packageJson) {
+    try {
+        const json = JSON.parse(fs_1.default.readFileSync(packageJson, "utf-8"));
+        return Object.keys(json.dependencies);
+    }
+    catch (e) {
+        log_1.default.error(`Failed to read packages/package.json: ${chalk_1.default.red(e)}`);
+    }
+    return [];
+}
+function getPersistentStorageDir(packageName) {
+    const dir = path_1.default.join(config_1.default.getPackagesPath(), packageName);
+    fs_1.default.mkdirSync(dir, { recursive: true }); // we don't care if it already exists or not
+    return dir;
+}
+function loadPackage(packageName) {
+    let packageInfo;
+    // TODO: type
+    let packageFile;
+    try {
+        const packagePath = config_1.default.getPackageModulePath(packageName);
+        packageInfo = JSON.parse(fs_1.default.readFileSync(path_1.default.join(packagePath, "package.json"), "utf-8"));
+        if (!packageInfo.thelounge) {
+            throw "'thelounge' is not present in package.json";
+        }
+        if (packageInfo.thelounge.supports &&
+            !semver_1.default.satisfies(helper_1.default.getVersionNumber(), packageInfo.thelounge.supports, {
+                includePrerelease: true, // our pre-releases should respect the semver guarantees
+            })) {
+            throw `v${packageInfo.version} does not support this version of The Lounge. Supports: ${packageInfo.thelounge.supports}`;
+        }
+        packageFile = require(packagePath);
+    }
+    catch (e) {
+        log_1.default.error(`Package ${chalk_1.default.bold(packageName)} could not be loaded: ${chalk_1.default.red(e)}`);
+        if (e instanceof Error) {
+            log_1.default.debug(e.stack ? e.stack : e.message);
+        }
+        return;
+    }
+    const version = packageInfo.version;
+    packageInfo = {
+        ...packageInfo.thelounge,
+        packageName: packageName,
+        version,
+    };
+    packageMap.set(packageName, packageFile);
+    if (packageInfo.type === "theme") {
+        // @ts-expect-error Argument of type 'PackageInfo' is not assignable to parameter of type 'ThemeModule'.
+        themes_1.default.addTheme(packageName, packageInfo);
+        if (packageInfo.files) {
+            packageInfo.files.forEach((file) => addFile(packageName, file));
+        }
+    }
+    if (packageFile.onServerStart) {
+        packageFile.onServerStart(packageApis(packageInfo));
+    }
+    log_1.default.info(`Package ${chalk_1.default.bold(packageName)} ${chalk_1.default.green("v" + version)} loaded`);
+    if (packageInfo.type !== "theme" && !experimentalWarningPrinted) {
+        experimentalWarningPrinted = true;
+        log_1.default.info("There are packages using the experimental plugin API. " +
+            "Be aware that this API is not yet stable and may change in future The Lounge releases.");
+    }
+}
+function loadPackages() {
+    const packageJson = path_1.default.join(config_1.default.getPackagesPath(), "package.json");
+    const packages = getEnabledPackages(packageJson);
+    packages.forEach(loadPackage);
+    watchPackages(packageJson);
+}
+function watchPackages(packageJson) {
+    fs_1.default.watch(packageJson, {
+        persistent: false,
+    }, lodash_1.default.debounce(() => {
+        const updated = getEnabledPackages(packageJson);
+        for (const packageName of updated) {
+            if (packageMap.has(packageName)) {
+                continue;
+            }
+            loadPackage(packageName);
+        }
+    }, 1000, { maxWait: 10000 }));
+}
+async function outdated(cacheTimeout = TIME_TO_LIVE) {
+    if (cache.outdated !== undefined) {
+        return cache.outdated;
+    }
+    // Get paths to the location of packages directory
+    const packagesPath = config_1.default.getPackagesPath();
+    const packagesConfig = path_1.default.join(packagesPath, "package.json");
+    const packagesList = JSON.parse(fs_1.default.readFileSync(packagesConfig, "utf-8")).dependencies;
+    const argsList = [
+        "outdated",
+        "--latest",
+        "--json",
+        "--production",
+        "--ignore-scripts",
+        "--non-interactive",
+        "--cwd",
+        packagesPath,
+    ];
+    // Check if the configuration file exists
+    if (!Object.entries(packagesList).length) {
+        // CLI calls outdated with zero TTL, so we can print the warning there
+        if (!cacheTimeout) {
+            log_1.default.warn("There are no packages installed.");
+        }
+        return false;
+    }
+    const command = argsList.shift();
+    const params = argsList;
+    if (!command) {
+        return;
+    }
+    // If we get an error from calling outdated and the code isn't 0, then there are no outdated packages
+    // TODO: was (...argsList), verify this works
+    await utils_1.default.executeYarnCommand(command, ...params)
+        .then(() => updateOutdated(false))
+        .catch((code) => updateOutdated(code !== 0));
+    if (cacheTimeout > 0) {
+        setTimeout(() => {
+            delete cache.outdated;
+        }, cacheTimeout);
+    }
+    return cache.outdated;
+}
+function updateOutdated(outdatedPackages) {
+    cache.outdated = outdatedPackages;
+}

package/dist/server/plugins/packages/publicClient.js

@@ -0,0 +1,66 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const msg_1 = __importDefault(require("../../models/msg"));
+const msg_2 = require("../../../shared/types/msg");
+class PublicClient {
+    client;
+    packageInfo;
+    constructor(client, packageInfo) {
+        this.client = client;
+        this.packageInfo = packageInfo;
+    }
+    /**
+     *
+     * @param {String} command - IRC command to run, this is in the same format that a client would send to the server (eg: JOIN #test)
+     * @param {String} targetId - The id of the channel to simulate the command coming from. Replies will go to this channel if appropriate
+     */
+    runAsUser(command, targetId) {
+        this.client.inputLine({ target: targetId, text: command });
+    }
+    /**
+     *
+     * @param {Object} attributes
+     */
+    createChannel(attributes) {
+        return this.client.createChannel(attributes);
+    }
+    /**
+     * Emits an `event` to the browser client, with `data` in the body of the event.
+     *
+     * @param {String} event - Name of the event, must be something the browser will recognise
+     * @param {Object} data - Body of the event, can be anything, but will need to be properly interpreted by the client
+     */
+    // FIXME: this is utterly bonkers
+    // This needs to get wrapped into its own, typed plugin event
+    // Plus it is completely insane to let a plugin inject arbitrary events like that
+    sendToBrowser(event, data) {
+        this.client.emit(event, data);
+    }
+    /**
+     *
+     * @param {Number} chanId
+     */
+    getChannel(chanId) {
+        return this.client.find(chanId);
+    }
+    /**
+     * Sends a message to this client, displayed in the given channel.
+     *
+     * @param {String} text the message to send
+     * @param {Chan} chan the channel to send the message to
+     */
+    sendMessage(text, chan) {
+        chan.pushMessage(this.client, new msg_1.default({
+            type: msg_2.MessageType.PLUGIN,
+            text: text,
+            from: {
+                nick: this.packageInfo.name || this.packageInfo.packageName,
+                mode: "",
+            },
+        }));
+    }
+}
+exports.default = PublicClient;

package/dist/server/plugins/packages/themes.js

@@ -0,0 +1,61 @@
+"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 path_1 = __importDefault(require("path"));
+const lodash_1 = __importDefault(require("lodash"));
+const config_1 = __importDefault(require("../../config"));
+const utils_1 = __importDefault(require("../../command-line/utils"));
+const themes = new Map();
+exports.default = {
+    addTheme,
+    getAll,
+    getByName,
+    loadLocalThemes,
+};
+function loadLocalThemes() {
+    const builtInThemes = fs_1.default.readdirSync(utils_1.default.getFileFromRelativeToRoot("public", "themes"));
+    builtInThemes
+        .filter((theme) => theme.endsWith(".css"))
+        .map(makeLocalThemeObject)
+        .forEach((theme) => themes.set(theme.name, theme));
+}
+function addTheme(packageName, packageObject) {
+    const theme = makePackageThemeObject(packageName, packageObject);
+    if (theme) {
+        themes.set(theme.name, theme);
+    }
+}
+function getAll() {
+    const filteredThemes = [];
+    for (const theme of themes.values()) {
+        filteredThemes.push(lodash_1.default.pick(theme, ["displayName", "name", "themeColor"]));
+    }
+    return lodash_1.default.sortBy(filteredThemes, "displayName");
+}
+function getByName(name) {
+    return themes.get(name);
+}
+function makeLocalThemeObject(css) {
+    const themeName = css.slice(0, -4);
+    return {
+        displayName: themeName.charAt(0).toUpperCase() + themeName.slice(1),
+        name: themeName,
+        themeColor: null,
+    };
+}
+function makePackageThemeObject(moduleName, module) {
+    if (!module || module.type !== "theme") {
+        return;
+    }
+    const themeColor = /^#[0-9A-F]{6}$/i.test(module.themeColor) ? module.themeColor : null;
+    const modulePath = config_1.default.getPackageModulePath(moduleName);
+    return {
+        displayName: module.name || moduleName,
+        filename: path_1.default.join(modulePath, module.css),
+        name: encodeURIComponent(moduleName),
+        themeColor: themeColor,
+    };
+}

package/dist/server/plugins/storage.js

@@ -0,0 +1,88 @@
+"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 fs_1 = __importDefault(require("fs"));
+const path_1 = __importDefault(require("path"));
+const crypto_1 = __importDefault(require("crypto"));
+const config_1 = __importDefault(require("../config"));
+class Storage {
+    references;
+    constructor() {
+        this.references = new Map();
+    }
+    emptyDir() {
+        // Ensures that a directory is empty.
+        // Deletes directory contents if the directory is not empty.
+        // If the directory does not exist, it is created.
+        const dir = config_1.default.getStoragePath();
+        let items;
+        try {
+            items = fs_1.default.readdirSync(dir);
+        }
+        catch (e) {
+            fs_1.default.mkdirSync(dir, { recursive: true });
+            return;
+        }
+        // TODO: Use `fs.rmdirSync(dir, {recursive: true});` when it's stable (node 13+)
+        items.forEach((item) => deleteFolder(path_1.default.join(dir, item)));
+    }
+    dereference(url) {
+        const references = (this.references.get(url) || 0) - 1;
+        if (references < 0) {
+            return log_1.default.warn("Tried to dereference a file that has no references", url);
+        }
+        if (references > 0) {
+            return this.references.set(url, references);
+        }
+        this.references.delete(url);
+        // Drop "storage/" from url and join it with full storage path
+        const filePath = path_1.default.join(config_1.default.getStoragePath(), url.substring(8));
+        fs_1.default.unlink(filePath, (err) => {
+            if (err) {
+                log_1.default.error("Failed to delete stored file", err.message);
+            }
+        });
+    }
+    store(data, extension, callback) {
+        const hash = crypto_1.default.createHash("sha256").update(data).digest("hex");
+        const a = hash.substring(0, 2);
+        const b = hash.substring(2, 4);
+        const folder = path_1.default.join(config_1.default.getStoragePath(), a, b);
+        const filePath = path_1.default.join(folder, `${hash.substring(4)}.${extension}`);
+        const url = `storage/${a}/${b}/${hash.substring(4)}.${extension}`;
+        this.references.set(url, 1 + (this.references.get(url) || 0));
+        // If file with this name already exists, we don't need to write it again
+        if (fs_1.default.existsSync(filePath)) {
+            return callback(url);
+        }
+        fs_1.default.mkdir(folder, { recursive: true }, (mkdirErr) => {
+            if (mkdirErr) {
+                log_1.default.error("Failed to create storage folder", mkdirErr.message);
+                return callback("");
+            }
+            fs_1.default.writeFile(filePath, data, (err) => {
+                if (err) {
+                    log_1.default.error("Failed to store a file", err.message);
+                    return callback("");
+                }
+                callback(url);
+            });
+        });
+    }
+}
+exports.default = new Storage();
+function deleteFolder(dir) {
+    fs_1.default.readdirSync(dir).forEach((item) => {
+        item = path_1.default.join(dir, item);
+        if (fs_1.default.lstatSync(item).isDirectory()) {
+            deleteFolder(item);
+        }
+        else {
+            fs_1.default.unlinkSync(item);
+        }
+    });
+    fs_1.default.rmdirSync(dir);
+}

package/dist/server/plugins/sts.js

@@ -0,0 +1,85 @@
+"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"));
+class STSPolicies {
+    stsFile;
+    refresh;
+    policies;
+    constructor() {
+        this.stsFile = path_1.default.join(config_1.default.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)) {
+            return;
+        }
+        const storedPolicies = JSON.parse(fs_1.default.readFileSync(this.stsFile, "utf-8"));
+        const now = Date.now();
+        storedPolicies.forEach((value) => {
+            if (value.expires > now) {
+                this.policies.set(value.host, {
+                    port: value.port,
+                    duration: value.duration,
+                    expires: value.expires,
+                });
+            }
+        });
+    }
+    get(host) {
+        const policy = this.policies.get(host);
+        if (typeof policy === "undefined") {
+            return null;
+        }
+        if (policy.expires <= Date.now()) {
+            this.policies.delete(host);
+            this.refresh();
+            return null;
+        }
+        return policy;
+    }
+    update(host, port, duration) {
+        if (duration > 0) {
+            this.policies.set(host, {
+                port: port,
+                duration: duration,
+                expires: Date.now() + duration * 1000,
+            });
+        }
+        else {
+            this.policies.delete(host);
+        }
+        this.refresh();
+    }
+    refreshExpiration(host) {
+        const policy = this.policies.get(host);
+        if (typeof policy === "undefined") {
+            return null;
+        }
+        policy.expires = Date.now() + policy.duration * 1000;
+    }
+    saveFile() {
+        const policiesToStore = [];
+        this.policies.forEach((value, key) => {
+            policiesToStore.push({
+                host: key,
+                port: value.port,
+                duration: value.duration,
+                expires: value.expires,
+            });
+        });
+        const file = JSON.stringify(policiesToStore, null, "\t");
+        fs_1.default.writeFile(this.stsFile, file, { flag: "w+" }, (err) => {
+            if (err) {
+                log_1.default.error("Failed to update STS policies file!", err.message);
+            }
+        });
+    }
+}
+exports.default = new STSPolicies();