hfs 0.1.6 → 0.26.2

package/src/plugins.js

@@ -0,0 +1,338 @@
+"use strict";
+// This file is part of HFS - Copyright 2021-2022, Massimo Melina <a@rejetto.com> - License https://www.gnu.org/licenses/gpl-3.0.txt
+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 });
+exports.parsePluginSource = exports.rescan = exports.pluginsConfig = exports.enablePlugins = exports.pluginsWatcher = exports.getAvailablePlugins = exports.Plugin = exports.pluginsMiddleware = exports.getPluginConfigFields = exports.mapPlugins = exports.getPluginInfo = exports.setPluginConfig = exports.enablePlugin = exports.isPluginRunning = exports.DISABLING_POSTFIX = exports.PATH = void 0;
+const fast_glob_1 = __importDefault(require("fast-glob"));
+const watchLoad_1 = require("./watchLoad");
+const lodash_1 = __importDefault(require("lodash"));
+const path_1 = __importStar(require("path"));
+const const_1 = require("./const");
+const Const = __importStar(require("./const"));
+const misc_1 = require("./misc");
+const config_1 = require("./config");
+const serveFile_1 = require("./serveFile");
+const events_1 = __importDefault(require("./events"));
+const promises_1 = require("fs/promises");
+const fs_1 = require("fs");
+const connections_1 = require("./connections");
+exports.PATH = 'plugins';
+exports.DISABLING_POSTFIX = '-disabled';
+const plugins = {};
+function isPluginRunning(id) {
+    var _a;
+    return (_a = plugins[id]) === null || _a === void 0 ? void 0 : _a.started;
+}
+exports.isPluginRunning = isPluginRunning;
+function enablePlugin(id, state = true) {
+    exports.enablePlugins.set(arr => arr.includes(id) === state ? arr
+        : state ? [...arr, id]
+            : arr.filter((x) => x !== id));
+}
+exports.enablePlugin = enablePlugin;
+// nullish values are equivalent to defaultValues
+function setPluginConfig(id, changes) {
+    exports.pluginsConfig.set(allConfigs => {
+        const fields = getPluginConfigFields(id);
+        const oldConfig = allConfigs[id];
+        const newConfig = lodash_1.default.pickBy({ ...oldConfig, ...changes }, (v, k) => { var _a; return v != null && !(0, misc_1.same)(v, (_a = fields === null || fields === void 0 ? void 0 : fields[k]) === null || _a === void 0 ? void 0 : _a.defaultValue); });
+        return { ...allConfigs, [id]: lodash_1.default.isEmpty(newConfig) ? undefined : newConfig };
+    });
+}
+exports.setPluginConfig = setPluginConfig;
+function getPluginInfo(id) {
+    var _a, _b;
+    return (_b = (_a = plugins[id]) === null || _a === void 0 ? void 0 : _a.getData()) !== null && _b !== void 0 ? _b : availablePlugins[id];
+}
+exports.getPluginInfo = getPluginInfo;
+function mapPlugins(cb) {
+    return lodash_1.default.map(plugins, (pl, plName) => {
+        try {
+            return cb(pl, plName);
+        }
+        catch (e) {
+            console.log('plugin error', plName, String(e));
+        }
+    }).filter(x => x !== undefined);
+}
+exports.mapPlugins = mapPlugins;
+function getPluginConfigFields(id) {
+    var _a;
+    return (_a = plugins[id]) === null || _a === void 0 ? void 0 : _a.getData().config;
+}
+exports.getPluginConfigFields = getPluginConfigFields;
+function pluginsMiddleware() {
+    return async (ctx, next) => {
+        var _a;
+        const after = [];
+        // run middleware plugins
+        for (const id in plugins)
+            try {
+                const pl = plugins[id];
+                const res = await ((_a = pl.middleware) === null || _a === void 0 ? void 0 : _a.call(pl, ctx));
+                if (res === true)
+                    ctx.pluginStopped = true;
+                if (typeof res === 'function')
+                    after.push(res);
+            }
+            catch (e) {
+                console.log('error middleware plugin', id, String(e));
+                console.debug(e);
+            }
+        // expose public plugins' files
+        const { path } = ctx;
+        if (!ctx.pluginStopped) {
+            if (path.startsWith(const_1.PLUGINS_PUB_URI)) {
+                const a = path.substring(const_1.PLUGINS_PUB_URI.length).split('/');
+                if (plugins.hasOwnProperty(a[0])) { // do it only if the plugin is loaded
+                    a.splice(1, 0, 'public');
+                    await (0, serveFile_1.serveFile)(exports.PATH + '/' + a.join('/'), 'auto')(ctx, next);
+                }
+            }
+            await next();
+        }
+        for (const f of after)
+            await f();
+    };
+}
+exports.pluginsMiddleware = pluginsMiddleware;
+class Plugin {
+    constructor(id, data, unwatch) {
+        var _a, _b;
+        this.id = id;
+        this.data = data;
+        this.unwatch = unwatch;
+        this.started = new Date();
+        if (!data)
+            throw 'invalid data';
+        // if a previous instance is present, we are going to overwrite it, but first call its unload callback
+        const old = plugins[id];
+        try {
+            (_b = (_a = old === null || old === void 0 ? void 0 : old.data) === null || _a === void 0 ? void 0 : _a.unload) === null || _b === void 0 ? void 0 : _b.call(_a);
+        } // we don't want all the effects of the Plugin.unload
+        catch (e) {
+            console.debug('error unloading plugin', id, String(e));
+        }
+        // track this
+        const wasStopped = availablePlugins[id];
+        if (wasStopped)
+            delete availablePlugins[id];
+        plugins[id] = this;
+        this.data = data = { ...data }; // clone to make object modifiable. Objects coming from import are not.
+        // some validation
+        for (const k of ['frontend_css', 'frontend_js']) {
+            const v = data[k];
+            if (typeof v === 'string')
+                data[k] = [v];
+            else if (v && !Array.isArray(v)) {
+                delete data[k];
+                console.warn('invalid', k);
+            }
+        }
+        events_1.default.emit(old || wasStopped ? 'pluginStarted' : 'pluginInstalled', this);
+    }
+    get middleware() {
+        var _a;
+        return (_a = this.data) === null || _a === void 0 ? void 0 : _a.middleware;
+    }
+    get frontend_css() {
+        var _a;
+        return (_a = this.data) === null || _a === void 0 ? void 0 : _a.frontend_css;
+    }
+    get frontend_js() {
+        var _a;
+        return (_a = this.data) === null || _a === void 0 ? void 0 : _a.frontend_js;
+    }
+    get onDirEntry() {
+        var _a;
+        return (_a = this.data) === null || _a === void 0 ? void 0 : _a.onDirEntry;
+    }
+    getData() {
+        return { ...this.data };
+    }
+    async unload() {
+        var _a, _b;
+        const { id } = this;
+        console.log('unloading plugin', id);
+        try {
+            await ((_b = (_a = this.data) === null || _a === void 0 ? void 0 : _a.unload) === null || _b === void 0 ? void 0 : _b.call(_a));
+        }
+        catch (e) {
+            console.debug('error unloading plugin', id, String(e));
+        }
+        delete plugins[id];
+        this.unwatch();
+        if (availablePlugins[id])
+            events_1.default.emit('pluginStopped', availablePlugins[id]);
+        else
+            events_1.default.emit('pluginUninstalled', id);
+    }
+}
+exports.Plugin = Plugin;
+let availablePlugins = {};
+function getAvailablePlugins() {
+    return Object.values(availablePlugins);
+}
+exports.getAvailablePlugins = getAvailablePlugins;
+const rescanAsap = (0, misc_1.debounceAsync)(rescan, 1000);
+if (!(0, fs_1.existsSync)(exports.PATH))
+    try {
+        (0, fs_1.mkdirSync)(exports.PATH);
+    }
+    catch (_a) { }
+exports.pluginsWatcher = (0, misc_1.watchDir)(exports.PATH, rescanAsap);
+exports.enablePlugins = (0, config_1.defineConfig)('enable_plugins', ['antibrute']);
+exports.enablePlugins.sub(rescanAsap);
+exports.pluginsConfig = (0, config_1.defineConfig)('plugins_config', {});
+async function rescan() {
+    console.debug('scanning plugins');
+    const found = [];
+    const foundDisabled = {};
+    const MASK = (0, path_1.join)(exports.PATH, '*', 'plugin.js');
+    for (const f of await (0, fast_glob_1.default)([(0, path_1.join)(const_1.APP_PATH, MASK), MASK])) {
+        const id = f.split('/').slice(-2)[0];
+        if (id.endsWith(exports.DISABLING_POSTFIX))
+            continue;
+        if (!exports.enablePlugins.get().includes(id)) {
+            try {
+                const source = await (0, promises_1.readFile)(f, 'utf8');
+                foundDisabled[id] = parsePluginSource(id, source);
+            }
+            catch (_a) { }
+            continue;
+        }
+        found.push(id);
+        if (plugins[id]) // already loaded
+            continue;
+        const module = path_1.default.resolve(f);
+        const { unwatch } = (0, watchLoad_1.watchLoad)(f, async () => {
+            try {
+                const reloading = plugins[id];
+                console.log(reloading ? "reloading plugin" : "loading plugin", id);
+                const { init, ...data } = await Promise.resolve().then(() => __importStar(require(module)));
+                delete data.default;
+                deleteModule(require.resolve(module)); // avoid caching at next import
+                calculateBadApi(data);
+                if (data.badApi)
+                    console.log("plugin", id, data.badApi);
+                const res = await (init === null || init === void 0 ? void 0 : init.call(null, {
+                    srcDir: __dirname,
+                    const: Const,
+                    require,
+                    getConnections: connections_1.getConnections,
+                    events: events_1.default,
+                    log(...args) {
+                        console.log('plugin', id, ':', ...args);
+                    },
+                    getConfig: (cfgKey) => { var _a, _b, _c, _d, _e; return (_c = (_b = (_a = exports.pluginsConfig.get()) === null || _a === void 0 ? void 0 : _a[id]) === null || _b === void 0 ? void 0 : _b[cfgKey]) !== null && _c !== void 0 ? _c : (_e = (_d = data.config) === null || _d === void 0 ? void 0 : _d[cfgKey]) === null || _e === void 0 ? void 0 : _e.defaultValue; },
+                    setConfig: (cfgKey, value) => setPluginConfig(id, { [cfgKey]: value }),
+                    subscribeConfig(cfgKey, cb) {
+                        let last = this.getConfig(cfgKey);
+                        cb(last);
+                        return exports.pluginsConfig.sub(() => {
+                            const now = this.getConfig(cfgKey);
+                            if (!(0, misc_1.same)(now, last))
+                                cb(last = now);
+                        });
+                    },
+                    getHfsConfig: config_1.getConfig,
+                }));
+                Object.assign(data, res);
+                new Plugin(id, data, unwatch);
+                if (reloading)
+                    events_1.default.emit('pluginUpdated', getPluginInfo(id));
+            }
+            catch (e) {
+                console.log("plugin error:", e);
+            }
+        });
+    }
+    for (const id in foundDisabled) {
+        const p = foundDisabled[id];
+        const a = availablePlugins[id];
+        if ((0, misc_1.same)(a, p))
+            continue;
+        availablePlugins[id] = p;
+        if (a)
+            events_1.default.emit('pluginUpdated', p);
+        else if (!plugins[id])
+            events_1.default.emit('pluginInstalled', p);
+    }
+    for (const id in availablePlugins)
+        if (!foundDisabled[id] && !found.includes(id) && !plugins[id]) {
+            delete availablePlugins[id];
+            events_1.default.emit('pluginUninstalled', id);
+        }
+    for (const id in plugins)
+        if (!found.includes(id))
+            await plugins[id].unload();
+}
+exports.rescan = rescan;
+function deleteModule(id) {
+    var _a;
+    const { cache } = require;
+    // build reversed map of dependencies
+    const requiredBy = { '.': ['.'] }; // don't touch main entry
+    for (const k in cache)
+        if (k !== id)
+            for (const child of (0, misc_1.wantArray)((_a = cache[k]) === null || _a === void 0 ? void 0 : _a.children))
+                (0, misc_1.getOrSet)(requiredBy, child.id, () => []).push(k);
+    const deleted = [];
+    recur(id);
+    function recur(id) {
+        let mod = cache[id];
+        if (!mod)
+            return;
+        delete cache[id];
+        deleted.push(id);
+        for (const child of mod.children)
+            if (!lodash_1.default.difference(requiredBy[child.id], deleted).length)
+                recur(child.id);
+    }
+}
+(0, misc_1.onProcessExit)(() => Promise.allSettled(mapPlugins(pl => pl.unload())));
+function parsePluginSource(id, source) {
+    var _a, _b, _c, _d, _e, _f;
+    const pl = { id };
+    pl.description = (0, misc_1.tryJson)((_a = /exports.description *= *(".*")/.exec(source)) === null || _a === void 0 ? void 0 : _a[1]);
+    pl.repo = (_b = /exports.repo *= *"(.*)"/.exec(source)) === null || _b === void 0 ? void 0 : _b[1];
+    pl.version = (_d = Number((_c = /exports.version *= *(\d*\.?\d+)/.exec(source)) === null || _c === void 0 ? void 0 : _c[1])) !== null && _d !== void 0 ? _d : undefined;
+    pl.apiRequired = (_f = (0, misc_1.tryJson)((_e = /exports.apiRequired *= *([ \d.,[\]]+)/.exec(source)) === null || _e === void 0 ? void 0 : _e[1])) !== null && _f !== void 0 ? _f : undefined;
+    if (Array.isArray(pl.apiRequired) && (pl.apiRequired.length !== 2 || !pl.apiRequired.every(lodash_1.default.isFinite))) // validate [from,to] form
+        pl.apiRequired = undefined;
+    calculateBadApi(pl);
+    return pl;
+}
+exports.parsePluginSource = parsePluginSource;
+function calculateBadApi(data) {
+    const r = data.apiRequired;
+    const [min, max] = Array.isArray(r) ? r : [r, r]; // normalize data type
+    data.badApi = min > const_1.API_VERSION ? "may not work correctly as it is designed for a newer version of HFS - check for updates"
+        : max < const_1.COMPATIBLE_API_VERSION ? "may not work correctly as it is designed for an older version of HFS - check for updates"
+            : undefined;
+}

package/src/serveFile.js

@@ -0,0 +1,104 @@
+"use strict";
+// This file is part of HFS - Copyright 2021-2022, Massimo Melina <a@rejetto.com> - License https://www.gnu.org/licenses/gpl-3.0.txt
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getRange = exports.serveFile = exports.serveFileNode = void 0;
+const fs_1 = require("fs");
+const const_1 = require("./const");
+const vfs_1 = require("./vfs");
+const mime_types_1 = __importDefault(require("mime-types"));
+const config_1 = require("./config");
+const micromatch_1 = require("micromatch");
+const lodash_1 = __importDefault(require("lodash"));
+const path_1 = __importDefault(require("path"));
+const util_1 = require("util");
+const allowedReferer = (0, config_1.defineConfig)('allowed_referer', '');
+function serveFileNode(node) {
+    const { source, mime } = node;
+    const name = (0, vfs_1.getNodeName)(node);
+    const mimeString = typeof mime === 'string' ? mime
+        : lodash_1.default.find(mime, (val, mask) => (0, micromatch_1.isMatch)(name, mask));
+    return (ctx, next) => {
+        var _a;
+        const allowed = allowedReferer.get();
+        if (allowed) {
+            const ref = (_a = /\/\/([^:/]+)/.exec(ctx.get('referer'))) === null || _a === void 0 ? void 0 : _a[1]; // extract host from url
+            if (ref && ref !== host() // automatic accept if referer is basically the hosting domain
+                && !(0, micromatch_1.isMatch)(ref, allowed))
+                return ctx.status = const_1.FORBIDDEN;
+            function host() {
+                const s = ctx.get('host');
+                return s[0] === '[' ? s.slice(1, s.indexOf(']')) : s === null || s === void 0 ? void 0 : s.split(':')[0];
+            }
+        }
+        ctx.vfsNode = node; // useful to tell service files from files shared by the user
+        return serveFile(source || '', mimeString)(ctx, next);
+    };
+}
+exports.serveFileNode = serveFileNode;
+const mimeCfg = (0, config_1.defineConfig)('mime', { '*': 'auto' });
+function serveFile(source, mime, content) {
+    return async (ctx) => {
+        if (!source)
+            return;
+        const fn = path_1.default.basename(source);
+        mime = mime !== null && mime !== void 0 ? mime : lodash_1.default.find(mimeCfg.get(), (v, k) => k > '' && (0, micromatch_1.isMatch)(fn, k)); // isMatch throws on an empty string
+        if (mime === vfs_1.MIME_AUTO)
+            mime = mime_types_1.default.lookup(source) || '';
+        if (mime)
+            ctx.type = mime;
+        if (ctx.method === 'OPTIONS') {
+            ctx.status = const_1.NO_CONTENT;
+            ctx.set({ Allow: 'OPTIONS, GET, HEAD' });
+            return;
+        }
+        if (ctx.method !== 'GET')
+            return ctx.status = const_1.METHOD_NOT_ALLOWED;
+        try {
+            const stats = await (0, util_1.promisify)(fs_1.stat)(source); // using fs's function instead of fs/promises, because only the former is supported by pkg
+            ctx.set('Last-Modified', stats.mtime.toUTCString());
+            ctx.fileSource = source;
+            ctx.status = 200;
+            if (ctx.fresh)
+                return ctx.status = 304;
+            if (content !== undefined)
+                return ctx.body = content;
+            const range = getRange(ctx, stats.size);
+            ctx.body = (0, fs_1.createReadStream)(source, range);
+        }
+        catch (_a) {
+            return ctx.status = 404;
+        }
+    };
+}
+exports.serveFile = serveFile;
+function getRange(ctx, totalSize) {
+    ctx.set('Accept-Ranges', 'bytes');
+    const { range } = ctx.request.header;
+    if (!range) {
+        ctx.response.length = totalSize;
+        return;
+    }
+    const ranges = range.split('=')[1];
+    if (ranges.includes(','))
+        return ctx.throw(400, 'multi-range not supported');
+    let bytes = ranges === null || ranges === void 0 ? void 0 : ranges.split('-');
+    if (!(bytes === null || bytes === void 0 ? void 0 : bytes.length))
+        return ctx.throw(400, 'bad range');
+    const max = totalSize - 1;
+    const start = bytes[0] ? Number(bytes[0]) : Math.max(0, totalSize - Number(bytes[1])); // a negative start is relative to the end
+    const end = bytes[0] ? Number(bytes[1] || max) : max; // NaN in case we are asked for last N bytes without knowing max
+    if (isNaN(end) || end > max || start > max) {
+        ctx.status = 416;
+        ctx.set('Content-Range', `bytes ${totalSize}`);
+        ctx.body = 'Requested Range Not Satisfiable';
+        return;
+    }
+    ctx.status = 206;
+    ctx.set('Content-Range', `bytes ${start}-${end}/${isNaN(totalSize) ? '*' : totalSize}`);
+    ctx.response.length = end - start + 1;
+    return { start, end };
+}
+exports.getRange = getRange;

package/src/serveGuiFiles.js

@@ -0,0 +1,113 @@
+"use strict";
+// This file is part of HFS - Copyright 2021-2022, Massimo Melina <a@rejetto.com> - License https://www.gnu.org/licenses/gpl-3.0.txt
+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 });
+exports.serveGuiFiles = void 0;
+const promises_1 = __importDefault(require("fs/promises"));
+const const_1 = require("./const");
+const serveFile_1 = require("./serveFile");
+const plugins_1 = require("./plugins");
+const api_auth_1 = require("./api.auth");
+const apiMiddleware_1 = require("./apiMiddleware");
+const path_1 = require("path");
+const misc_1 = require("./misc");
+// in case of dev env we have our static files within the 'dist' folder'
+const DEV_STATIC = process.env.DEV ? 'dist/' : '';
+function serveStatic(uri) {
+    const folder = uri.slice(2, -1); // we know folder is very similar to uri
+    const cache = {};
+    return async (ctx, next) => {
+        if (ctx.method === 'OPTIONS') {
+            ctx.status = const_1.NO_CONTENT;
+            ctx.set({ Allow: 'OPTIONS, GET' });
+            return;
+        }
+        if (ctx.method !== 'GET')
+            return ctx.status = const_1.METHOD_NOT_ALLOWED;
+        const serveApp = shouldServeApp(ctx);
+        const fullPath = (0, path_1.join)(__dirname, '..', DEV_STATIC, folder, serveApp ? '/index.html' : ctx.path);
+        const content = await (0, misc_1.getOrSet)(cache, ctx.path, async () => {
+            const data = await promises_1.default.readFile(fullPath).catch(() => null);
+            return serveApp || !data ? data
+                : adjustBundlerLinks(ctx.path, uri, data);
+        });
+        if (content === null)
+            return ctx.status = 404;
+        if (!serveApp)
+            return (0, serveFile_1.serveFile)(fullPath, 'auto', content)(ctx, next);
+        // we don't cache the index as it's small and may prevent plugins change to apply
+        ctx.body = await treatIndex(ctx, String(content), uri);
+        ctx.type = 'html';
+        ctx.set('Cache-Control', 'no-store, no-cache, must-revalidate');
+    };
+}
+function shouldServeApp(ctx) {
+    var _a;
+    return (_a = ctx.state).serveApp || (_a.serveApp = ctx.path.endsWith('/'));
+}
+function adjustBundlerLinks(path, uri, data) {
+    const ext = (0, path_1.extname)(path);
+    return ext && !ext.match(/\.(css|html|js|ts|scss)/) ? data
+        : String(data).replace(/((?:import | from )['"])\//g, `$1${uri}`);
+}
+async function treatIndex(ctx, body, filesUri) {
+    const session = await (0, api_auth_1.refresh_session)({}, ctx);
+    ctx.set('etag', '');
+    return body
+        .replace(/((?:src|href) *= *['"])\/?(?![a-z]+:\/\/)/g, '$1' + filesUri)
+        .replace('_HFS_SESSION_', session instanceof apiMiddleware_1.ApiError ? 'null' : JSON.stringify(session))
+        // replacing this text allow us to avoid injecting in frontends that don't support plugins. Don't use a <--comment--> or it will be removed by webpack
+        .replace('_HFS_PLUGINS_', pluginsInjection);
+}
+function serveProxied(port, uri) {
+    if (!port)
+        return;
+    console.debug('proxied on port', port);
+    let proxy;
+    Promise.resolve().then(() => __importStar(require('koa-better-http-proxy'))).then(lib => // dynamic import to avoid having this in final distribution
+     proxy = lib.default('127.0.0.1:' + port, {
+        proxyReqPathResolver: (ctx) => shouldServeApp(ctx) ? '/' : ctx.path,
+        userResDecorator(res, data, ctx) {
+            return shouldServeApp(ctx) ? treatIndex(ctx, String(data), uri)
+                : adjustBundlerLinks(ctx.path, uri, data);
+        }
+    }));
+    return function () {
+        return proxy.apply(this, arguments);
+    };
+}
+function pluginsInjection() {
+    const css = (0, plugins_1.mapPlugins)((plug, k) => { var _a; return (_a = plug.frontend_css) === null || _a === void 0 ? void 0 : _a.map(f => const_1.PLUGINS_PUB_URI + k + '/' + f); }).flat().filter(Boolean);
+    const js = (0, plugins_1.mapPlugins)((plug, k) => { var _a; return (_a = plug.frontend_js) === null || _a === void 0 ? void 0 : _a.map(f => const_1.PLUGINS_PUB_URI + k + '/' + f); }).flat().filter(Boolean);
+    return css.map(uri => `\n<link rel='stylesheet' type='text/css' href='${uri}'/>`).join('')
+        + js.map(uri => `\n<script defer src='${uri}'></script>`).join('');
+}
+function serveGuiFiles(proxyPort, uri) {
+    return serveProxied(proxyPort, uri) || serveStatic(uri);
+}
+exports.serveGuiFiles = serveGuiFiles;

package/src/sse.js

@@ -0,0 +1,29 @@
+"use strict";
+// This file is part of HFS - Copyright 2021-2022, Massimo Melina <a@rejetto.com> - License https://www.gnu.org/licenses/gpl-3.0.txt
+Object.defineProperty(exports, "__esModule", { value: true });
+const stream_1 = require("stream");
+function createSSE(ctx) {
+    const { socket } = ctx.req;
+    socket.setTimeout(0);
+    socket.setNoDelay(true);
+    socket.setKeepAlive(true);
+    ctx.set({
+        'Content-Type': 'text/event-stream',
+        'Cache-Control': 'no-cache',
+        'Connection': 'keep-alive',
+        'X-Accel-Buffering': 'no', // avoid buffering when reverse-proxied through nginx
+    });
+    ctx.status = 200;
+    return ctx.body = new stream_1.Transform({
+        objectMode: true,
+        transform(chunk, encoding, cb) {
+            this.push(`data: ${JSON.stringify(chunk)}\n\n`);
+            cb();
+        },
+        flush(cb) {
+            this.push('data:\n\n');
+            cb();
+        }
+    });
+}
+exports.default = createSSE;

package/src/throttler.js

@@ -0,0 +1,91 @@
+"use strict";
+// This file is part of HFS - Copyright 2021-2022, Massimo Melina <a@rejetto.com> - License https://www.gnu.org/licenses/gpl-3.0.txt
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.totalInSpeed = exports.totalOutSpeed = exports.totalGot = exports.totalSent = exports.throttler = void 0;
+const stream_1 = require("stream");
+const ThrottledStream_1 = require("./ThrottledStream");
+const config_1 = require("./config");
+const misc_1 = require("./misc");
+const connections_1 = require("./connections");
+const lodash_1 = __importDefault(require("lodash"));
+const events_1 = __importDefault(require("./events"));
+const mainThrottleGroup = new ThrottledStream_1.ThrottleGroup(Infinity);
+(0, config_1.defineConfig)('max_kbps', Infinity).sub(v => mainThrottleGroup.updateLimit(v));
+const ip2group = {};
+const SymThrStr = Symbol('stream');
+const SymTimeout = Symbol('timeout');
+const maxKbpsPerIp = (0, config_1.defineConfig)('max_kbps_per_ip', Infinity);
+const throttler = async (ctx, next) => {
+    await next();
+    const { body } = ctx;
+    if (!body || !(body instanceof stream_1.Readable))
+        return;
+    // we wrap the stream also for unlimited connections to get speed and other features
+    const ipGroup = (0, misc_1.getOrSet)(ip2group, ctx.ip, () => {
+        var _a;
+        const doLimit = ((_a = ctx.state.account) === null || _a === void 0 ? void 0 : _a.ignore_limits) || (0, misc_1.isLocalHost)(ctx) ? undefined : true;
+        const group = new ThrottledStream_1.ThrottleGroup(Infinity, doLimit && mainThrottleGroup);
+        const unsub = doLimit && maxKbpsPerIp.sub(v => group.updateLimit(v));
+        return { group, count: 0, destroy: unsub };
+    });
+    const conn = ctx.state.connection;
+    if (!conn)
+        throw 'assert throttler connection';
+    const ts = conn[SymThrStr] = new ThrottledStream_1.ThrottledStream(ipGroup.group, conn[SymThrStr]);
+    let closed = false;
+    const DELAY = 1000;
+    const update = lodash_1.default.debounce(() => {
+        const ts = conn[SymThrStr];
+        const outSpeed = roundKb(ts.getSpeed());
+        (0, connections_1.updateConnection)(conn, { outSpeed, sent: ts.getBytesSent() });
+        /* in case this stream stands still for a while (before the end), we'll have neither 'sent' or 'close' events,
+        * so who will take care to updateConnection? This artificial next-call will ensure just that */
+        clearTimeout(conn[SymTimeout]);
+        if (outSpeed || !closed)
+            conn[SymTimeout] = setTimeout(update, DELAY);
+    }, DELAY, { maxWait: DELAY });
+    ts.on('sent', (n) => {
+        exports.totalSent += n;
+        update();
+    });
+    ++ipGroup.count;
+    ts.on('close', () => {
+        var _a;
+        update.flush();
+        closed = true;
+        if (--ipGroup.count)
+            return; // any left?
+        (_a = ipGroup.destroy) === null || _a === void 0 ? void 0 : _a.call(ipGroup);
+        delete ip2group[ctx.ip];
+    });
+    const bak = ctx.response.length; // preserve
+    ctx.body = ctx.body.pipe(ts);
+    if (bak)
+        ctx.response.length = bak;
+};
+exports.throttler = throttler;
+function roundKb(n) {
+    return lodash_1.default.round(n, 1) || lodash_1.default.round(n, 3); // further precision if necessary
+}
+exports.totalSent = 0;
+exports.totalGot = 0;
+exports.totalOutSpeed = 0;
+exports.totalInSpeed = 0;
+let lastSent = exports.totalSent;
+let lastGot = exports.totalGot;
+let last = Date.now();
+setInterval(() => {
+    const now = Date.now();
+    const past = (now - last) / 1000; // seconds
+    last = now;
+    const deltaSentKb = (exports.totalSent - lastSent) / 1000;
+    lastSent = exports.totalSent;
+    const deltaGotKb = (exports.totalGot - lastGot) / 1000;
+    lastGot = exports.totalGot;
+    exports.totalOutSpeed = roundKb(deltaSentKb / past);
+    exports.totalInSpeed = roundKb(deltaGotKb / past);
+}, 1000);
+events_1.default.on('connection', (c) => c.socket.on('data', data => exports.totalGot += data.length));