450 lines
16 KiB
JavaScript
450 lines
16 KiB
JavaScript
/**
|
|
* BetterDiscord Content Manager Module
|
|
* Copyright (c) 2015-present Jiiks/JsSucks - https://github.com/Jiiks / https://github.com/JsSucks
|
|
* All rights reserved.
|
|
* https://betterdiscord.net
|
|
*
|
|
* This source code is licensed under the MIT license found in the
|
|
* LICENSE file in the root directory of this source tree.
|
|
*/
|
|
|
|
import asar from 'asar';
|
|
import path, { dirname } from 'path';
|
|
import rimraf from 'rimraf';
|
|
|
|
import { remote } from 'electron';
|
|
import Content from './content';
|
|
import Globals from './globals';
|
|
import Database from './database';
|
|
import { Utils, FileUtils, ClientLogger as Logger } from 'common';
|
|
import { SettingsSet, ErrorEvent } from 'structs';
|
|
import { Modals } from 'ui';
|
|
import Combokeys from 'combokeys';
|
|
import Settings from './settings';
|
|
|
|
/**
|
|
* Base class for managing external content
|
|
*/
|
|
export default class {
|
|
|
|
/**
|
|
* Any errors that happened.
|
|
* @return {Array}
|
|
*/
|
|
static get errors() {
|
|
return this._errors || (this._errors = []);
|
|
}
|
|
|
|
/**
|
|
* Locally stored content.
|
|
* @return {Array}
|
|
*/
|
|
static get localContent() {
|
|
return this._localContent ? this._localContent : (this._localContent = []);
|
|
}
|
|
|
|
/**
|
|
* The type of content this content manager manages.
|
|
*/
|
|
static get contentType() {
|
|
return undefined;
|
|
}
|
|
|
|
/**
|
|
* The name of this content manager.
|
|
*/
|
|
static get moduleName() {
|
|
return undefined;
|
|
}
|
|
|
|
/**
|
|
* The path used to store this content manager's content.
|
|
*/
|
|
static get pathId() {
|
|
return undefined;
|
|
}
|
|
|
|
/**
|
|
* Local path for content.
|
|
* @return {String}
|
|
*/
|
|
static get contentPath() {
|
|
return Globals.getPath(this.pathId);
|
|
}
|
|
|
|
static async packContent(path, contentPath) {
|
|
return new Promise((resolve, reject) => {
|
|
remote.dialog.showSaveDialog({
|
|
title: 'Save Package',
|
|
defaultPath: path,
|
|
filters: [
|
|
{
|
|
name: 'BetterDiscord Package',
|
|
extensions: ['bd']
|
|
}
|
|
]
|
|
}, filepath => {
|
|
if (!filepath) return;
|
|
|
|
asar.uncache(filepath);
|
|
asar.createPackage(contentPath, filepath, () => {
|
|
resolve(filepath);
|
|
});
|
|
});
|
|
});
|
|
}
|
|
|
|
/**
|
|
* Load all locally stored content.
|
|
* @param {bool} suppressErrors Suppress any errors that occur during loading of content
|
|
*/
|
|
static async loadAllContent(suppressErrors = false) {
|
|
try {
|
|
await FileUtils.ensureDirectory(this.contentPath);
|
|
const directories = await FileUtils.listDirectory(this.contentPath);
|
|
|
|
for (const dir of directories) {
|
|
const packed = dir.endsWith('.bd');
|
|
|
|
if (!packed) {
|
|
try {
|
|
await FileUtils.directoryExists(path.join(this.contentPath, dir));
|
|
} catch (err) { continue; }
|
|
}
|
|
|
|
try {
|
|
if (packed) {
|
|
await this.preloadPackedContent(dir);
|
|
} else {
|
|
await this.preloadContent(dir);
|
|
}
|
|
} catch (err) {
|
|
this.errors.push(new ErrorEvent({
|
|
module: this.moduleName,
|
|
message: `Failed to load ${dir}`,
|
|
err
|
|
}));
|
|
|
|
Logger.err(this.moduleName, err);
|
|
}
|
|
}
|
|
|
|
if (this.errors.length && !suppressErrors) {
|
|
Modals.error({
|
|
header: `${this.moduleName} - ${this.errors.length} ${this.contentType}${this.errors.length !== 1 ? 's' : ''} failed to load`,
|
|
module: this.moduleName,
|
|
type: 'err',
|
|
content: this.errors
|
|
});
|
|
this._errors = [];
|
|
}
|
|
} catch (err) {
|
|
throw err;
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Refresh locally stored content
|
|
* @param {bool} suppressErrors Suppress any errors that occur during loading of content
|
|
*/
|
|
static async refreshContent(suppressErrors = false) {
|
|
if (!this.localContent.length) return this.loadAllContent();
|
|
|
|
try {
|
|
await FileUtils.ensureDirectory(this.contentPath);
|
|
const directories = await FileUtils.listDirectory(this.contentPath);
|
|
|
|
for (const dir of directories) {
|
|
const packed = dir.endsWith('.bd');
|
|
|
|
// If content is already loaded this should resolve
|
|
if (this.getContentByDirName(dir)) continue;
|
|
|
|
try {
|
|
await FileUtils.directoryExists(path.join(this.contentPath, dir));
|
|
} catch (err) { continue; }
|
|
|
|
try {
|
|
// Load if not
|
|
await this.preloadContent(dir);
|
|
} catch (err) {
|
|
// We don't want every plugin/theme to fail loading when one does
|
|
this.errors.push(new ErrorEvent({
|
|
module: this.moduleName,
|
|
message: `Failed to load ${dir}`,
|
|
err
|
|
}));
|
|
|
|
Logger.err(this.moduleName, err);
|
|
}
|
|
}
|
|
|
|
for (const content of this.localContent) {
|
|
if (directories.includes(content.dirName)) continue;
|
|
|
|
try {
|
|
// Plugin/theme was deleted manually, stop it and remove any reference
|
|
await this.unloadContent(content);
|
|
} catch (err) {
|
|
this.errors.push(new ErrorEvent({
|
|
module: this.moduleName,
|
|
message: `Failed to unload ${content.dirName}`,
|
|
err
|
|
}));
|
|
|
|
Logger.err(this.moduleName, err);
|
|
}
|
|
}
|
|
|
|
if (this.errors.length && !suppressErrors) {
|
|
Modals.error({
|
|
header: `${this.moduleName} - ${this.errors.length} ${this.contentType}${this.errors.length !== 1 ? 's' : ''} failed to load`,
|
|
module: this.moduleName,
|
|
type: 'err',
|
|
content: this.errors
|
|
});
|
|
this._errors = [];
|
|
}
|
|
} catch (err) {
|
|
throw err;
|
|
}
|
|
}
|
|
|
|
static async preloadPackedContent(pkg, reload = false, index) {
|
|
try {
|
|
const packagePath = path.join(this.contentPath, pkg);
|
|
const packageName = pkg.replace('.bd', '');
|
|
await FileUtils.fileExists(packagePath);
|
|
|
|
const config = JSON.parse(asar.extractFile(packagePath, 'config.json').toString());
|
|
const unpackedPath = path.join(Globals.getPath('tmp'), packageName);
|
|
|
|
asar.extractAll(packagePath, unpackedPath);
|
|
|
|
return this.preloadContent({
|
|
config,
|
|
contentPath: unpackedPath,
|
|
packagePath: packagePath,
|
|
pkg,
|
|
packageName,
|
|
packed: true
|
|
}, reload, index);
|
|
} catch (err) {
|
|
Logger.log('ContentManager', ['Error extracting packed content', err]);
|
|
throw err;
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Common loading procedure for loading content before passing it to the actual loader
|
|
* @param {any} dirName Base directory for content
|
|
* @param {any} reload Is content being reloaded
|
|
* @param {any} index Index of content in {localContent}
|
|
*/
|
|
static async preloadContent(dirName, reload = false, index) {
|
|
try {
|
|
const unsafeAllowed = Settings.getSetting('security', 'default', 'unsafe-content').value;
|
|
const packed = typeof dirName === 'object' && dirName.packed;
|
|
|
|
// Block any unpacked content as they can't be verified
|
|
if (!packed && !unsafeAllowed) {
|
|
throw 'Blocked unsafe content';
|
|
}
|
|
|
|
const contentPath = packed ? dirName.contentPath : path.join(this.contentPath, dirName);
|
|
|
|
await FileUtils.directoryExists(contentPath);
|
|
|
|
if (!reload && this.getContentByPath(contentPath))
|
|
throw { 'message': `Attempted to load already loaded user content: ${path}` };
|
|
|
|
const configPath = path.resolve(contentPath, 'config.json');
|
|
const readConfig = packed ? dirName.config : await FileUtils.readJsonFromFile(configPath);
|
|
const mainPath = path.join(contentPath, readConfig.main || 'index.js');
|
|
|
|
const defaultConfig = new SettingsSet({
|
|
settings: readConfig.defaultConfig,
|
|
schemes: readConfig.configSchemes
|
|
});
|
|
|
|
const userConfig = {
|
|
enabled: false,
|
|
config: undefined,
|
|
data: {}
|
|
};
|
|
|
|
try {
|
|
const id = readConfig.info.id || readConfig.info.name.toLowerCase().replace(/[^a-zA-Z0-9-]/g, '-').replace(/--/g, '-');
|
|
const readUserConfig = await Database.find({ type: `${this.contentType}-config`, id });
|
|
if (readUserConfig.length) {
|
|
userConfig.enabled = readUserConfig[0].enabled || false;
|
|
userConfig.config = readUserConfig[0].config;
|
|
userConfig.data = readUserConfig[0].data || {};
|
|
}
|
|
} catch (err) {
|
|
// We don't care if this fails it either means that user config doesn't exist or there's something wrong with it so we revert to default config
|
|
Logger.warn(this.moduleName, [`Failed reading config for ${this.contentType} ${readConfig.info.name} in ${packed ? dirName.pkg : dirName}`, err]);
|
|
}
|
|
|
|
userConfig.config = defaultConfig.clone({ settings: userConfig.config });
|
|
userConfig.config.setSaved();
|
|
|
|
for (const setting of userConfig.config.findSettings(() => true)) {
|
|
// This will load custom settings
|
|
// Setting the content's path on only the live config (and not the default config) ensures that custom settings will not be loaded on the default settings
|
|
setting.setContentPath(contentPath);
|
|
}
|
|
|
|
for (const scheme of userConfig.config.schemes) {
|
|
scheme.setContentPath(contentPath);
|
|
}
|
|
|
|
Utils.deepfreeze(defaultConfig, object => object instanceof Combokeys);
|
|
|
|
const configs = {
|
|
defaultConfig,
|
|
schemes: userConfig.schemes,
|
|
userConfig
|
|
};
|
|
|
|
const paths = {
|
|
contentPath,
|
|
dirName,
|
|
mainPath
|
|
};
|
|
|
|
const content = await this.loadContent(paths, configs, readConfig.info, readConfig.main, readConfig.dependencies, readConfig.permissions, readConfig.mainExport, packed ? dirName : false);
|
|
if (!content) return undefined;
|
|
if (!reload && this.getContentById(content.id))
|
|
throw { message: `A ${this.contentType} with the ID ${content.id} already exists.` };
|
|
|
|
if (reload) this.localContent.splice(index, 1, content);
|
|
else this.localContent.push(content);
|
|
return content;
|
|
} catch (err) {
|
|
throw err;
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Delete content.
|
|
* @param {Content|String} content Content to delete
|
|
* @param {Boolean} force If true the content will be deleted even if an exception is thrown when disabling/unloading/deleting
|
|
*/
|
|
static async deleteContent(content, force) {
|
|
content = this.findContent(content);
|
|
if (!content) throw {message: `Could not find a ${this.contentType} from ${content}.`};
|
|
|
|
try {
|
|
await Modals.confirm(`Delete ${this.contentType}?`, `Are you sure you want to delete ${content.info.name} ?`, 'Delete').promise;
|
|
} catch (err) {
|
|
return false;
|
|
}
|
|
|
|
try {
|
|
const unload = this.unloadContent(content, force, false);
|
|
|
|
if (!force)
|
|
await unload;
|
|
|
|
await FileUtils.recursiveDeleteDirectory(content.paths.contentPath);
|
|
if (content.packed) await FileUtils.recursiveDeleteDirectory(content.packagePath);
|
|
return true;
|
|
} catch (err) {
|
|
Logger.err(this.moduleName, err);
|
|
throw err;
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Unload content.
|
|
* @param {Content|String} content Content to unload
|
|
* @param {Boolean} force If true the content will be unloaded even if an exception is thrown when disabling/unloading
|
|
* @param {Boolean} reload Whether to reload the content after
|
|
* @return {Content}
|
|
*/
|
|
static async unloadContent(content, force, reload) {
|
|
content = this.findContent(content);
|
|
if (!content) throw {message: `Could not find a ${this.contentType} from ${content}.`};
|
|
|
|
try {
|
|
const disablePromise = content.disable(false);
|
|
const unloadPromise = content.emit('unload', reload);
|
|
|
|
if (!force) {
|
|
await disablePromise;
|
|
await unloadPromise;
|
|
}
|
|
|
|
const index = this.getContentIndex(content);
|
|
|
|
if (this.unloadContentHook) this.unloadContentHook(content);
|
|
|
|
if (reload) return content.packed ? this.preloadPackedContent(content.packagePath, true, index) : this.preloadContent(content.dirName, true, index);
|
|
|
|
this.localContent.splice(index, 1);
|
|
} catch (err) {
|
|
Logger.err(this.moduleName, err);
|
|
throw err;
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Reload content.
|
|
* @param {Content|String} content Content to reload
|
|
* @param {Boolean} force If true the content will be unloaded even if an exception is thrown when disabling/unloading
|
|
* @return {Content}
|
|
*/
|
|
static reloadContent(content, force) {
|
|
return this.unloadContent(content, force, true);
|
|
}
|
|
|
|
/**
|
|
* Checks if the passed object is an instance of this content type.
|
|
* @param {Any} content Object to check
|
|
* @return {Boolean}
|
|
*/
|
|
static isThisContent(content) {
|
|
return content instanceof Content;
|
|
}
|
|
|
|
/**
|
|
* Returns the first content where calling {function} returns true.
|
|
* @param {Function} function A function to call to filter content
|
|
*/
|
|
static find(f) {
|
|
return this.localContent.find(f);
|
|
}
|
|
|
|
/**
|
|
* Wildcard content finder
|
|
* @param {String} wild Content ID / directory name / path / name
|
|
* @param {Boolean} nonunique Allow searching attributes that may not be unique
|
|
* @return {Content}
|
|
*/
|
|
static findContent(wild, nonunique) {
|
|
if (this.isThisContent(wild)) return wild;
|
|
let content;
|
|
content = this.getContentById(wild); if (content) return content;
|
|
content = this.getContentByDirName(wild); if (content) return content;
|
|
content = this.getContentByPath(wild); if (content) return content;
|
|
content = this.getContentByName(wild); if (content && nonunique) return content;
|
|
}
|
|
|
|
static getContentIndex(content) { return this.localContent.findIndex(c => c === content) }
|
|
static getContentById(id) { return this.localContent.find(c => c.id === id) }
|
|
static getContentByDirName(dirName) { return this.localContent.find(c => c.dirName === dirName) }
|
|
static getContentByPath(path) { return this.localContent.find(c => c.contentPath === path) }
|
|
static getContentByName(name) { return this.localContent.find(c => c.name === name) }
|
|
|
|
/**
|
|
* Wait for content to load
|
|
* @param {String} content_id
|
|
* @return {Promise => Content}
|
|
*/
|
|
static waitForContent(content_id) {
|
|
return Utils.until(() => this.getContentById(content_id), 100);
|
|
}
|
|
|
|
}
|