hfs 0.26.8 → 0.27.2

package/src/config.js

@@ -0,0 +1,168 @@
+"use strict";
+// This file is part of HFS - Copyright 2021-2023, 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.saveConfigAsap = exports.setConfig = exports.getWholeConfig = exports.getConfig = exports.getConfigDefinition = exports.defineConfig = void 0;
+const events_1 = __importDefault(require("events"));
+const const_1 = require("./const");
+const watchLoad_1 = require("./watchLoad");
+const yaml_1 = __importDefault(require("yaml"));
+const lodash_1 = __importDefault(require("lodash"));
+const misc_1 = require("./misc");
+const fs_1 = require("fs");
+const path_1 = require("path");
+const events_2 = __importDefault(require("./events"));
+const FILE = 'config.yaml';
+const configProps = {};
+let started = false; // this will tell the difference for subscribeConfig()s that are called before or after config is loaded
+let state = {};
+const cfgEvents = new events_1.default();
+cfgEvents.setMaxListeners(10000);
+const path = (0, misc_1.with_)(const_1.argv.config || process.env.HFS_CONFIG, p => {
+    if (!p)
+        return FILE;
+    p = (0, path_1.resolve)(const_1.ORIGINAL_CWD, p);
+    try {
+        if ((0, fs_1.statSync)(p).isDirectory()) // try to detect if path points to a folder, in which case we add the standard filename
+            return (0, path_1.join)(p, FILE);
+    }
+    catch (_a) { }
+    return p;
+});
+console.log("config", path);
+const legacyPosition = (0, path_1.join)(const_1.APP_PATH, FILE);
+if (!(0, fs_1.existsSync)(path) && (0, fs_1.existsSync)(legacyPosition))
+    try {
+        (0, fs_1.renameSync)(legacyPosition, path);
+        console.log("moved from legacy position", legacyPosition);
+    }
+    catch (_a) {
+        try { // attempt copying, in case moving the source file proves to be impractical
+            (0, fs_1.copyFileSync)(legacyPosition, path);
+            console.log("copied from legacy position", legacyPosition);
+        }
+        catch (_b) { }
+    }
+const { save } = (0, watchLoad_1.watchLoad)(path, values => setConfig(values || {}, false), {
+    failedOnFirstAttempt() {
+        console.log("No config file, using defaults");
+        setConfig({}, false);
+    }
+});
+function defineConfig(k, defaultValue) {
+    configProps[k] = { defaultValue };
+    return {
+        key() {
+            return k;
+        },
+        get() {
+            return getConfig(k);
+        },
+        sub(cb) {
+            return subscribeConfig(k, cb);
+        },
+        set(v) {
+            if (typeof v === 'function')
+                this.set(v(this.get()));
+            else
+                setConfig1(k, v);
+        }
+    };
+}
+exports.defineConfig = defineConfig;
+function getConfigDefinition(k) {
+    return configProps[k];
+}
+exports.getConfigDefinition = getConfigDefinition;
+const stack = [];
+function subscribeConfig(k, cb) {
+    if (started) // initial event already passed, we'll make the first call
+        cb(getConfig(k));
+    const eventName = 'new.' + k;
+    return (0, misc_1.onOff)(cfgEvents, {
+        [eventName]() {
+            if (stack.includes(cb))
+                return; // avoid infinite loop in case a subscriber changes the value
+            stack.push(cb); // @ts-ignore arguments
+            try {
+                return cb.apply(this, arguments);
+            }
+            finally {
+                stack.pop();
+            }
+        }
+    });
+}
+function getConfig(k) {
+    var _a, _b;
+    return (_a = state[k]) !== null && _a !== void 0 ? _a : lodash_1.default.cloneDeep((_b = configProps[k]) === null || _b === void 0 ? void 0 : _b.defaultValue); // clone to avoid changing
+}
+exports.getConfig = getConfig;
+function getWholeConfig({ omit, only }) {
+    const defs = (0, misc_1.objSameKeys)(configProps, x => x.defaultValue);
+    let copy = lodash_1.default.defaults({}, state, defs);
+    if (omit === null || omit === void 0 ? void 0 : omit.length)
+        copy = lodash_1.default.omit(copy, omit);
+    if (only)
+        copy = lodash_1.default.pick(copy, only);
+    return lodash_1.default.cloneDeep(copy);
+}
+exports.getWholeConfig = getWholeConfig;
+// pass a value to `save` to force saving decision, or leave undefined for auto. Passing false will also reset previously loaded configs.
+function setConfig(newCfg, save) {
+    if (!started) { // first time we consider also CLI args
+        const argCfg = lodash_1.default.pickBy((0, misc_1.objSameKeys)(configProps, (x, k) => const_1.argv[k]), x => x !== undefined);
+        if (!lodash_1.default.isEmpty(argCfg)) {
+            (0, exports.saveConfigAsap)().then(); // don't set `save` argument, as it would interfere below at check `save===false`
+            Object.assign(newCfg, argCfg);
+        }
+    }
+    for (const k in newCfg)
+        apply(k, newCfg[k]);
+    if (save) {
+        (0, exports.saveConfigAsap)().then();
+        return;
+    }
+    if (started) {
+        if (save === false) // false is used when loading whole config, and in such case we should not leave previous values untreated. Also, we need this only after we already `started`.
+            for (const k of Object.keys(state))
+                if (!newCfg.hasOwnProperty(k))
+                    apply(k, newCfg[k]);
+        return;
+    }
+    // first time we emit also for the default values
+    for (const k of Object.keys(configProps))
+        if (!newCfg.hasOwnProperty(k))
+            apply(k, newCfg[k]);
+    started = true;
+    events_2.default.emit('config ready');
+    function apply(k, newV) {
+        return setConfig1(k, newV, save === undefined);
+    }
+}
+exports.setConfig = setConfig;
+function setConfig1(k, newV, saveChanges = true) {
+    var _a;
+    if (lodash_1.default.isPlainObject(newV))
+        newV = lodash_1.default.pickBy(newV, x => x !== undefined);
+    if ((0, misc_1.same)(newV, (_a = configProps[k]) === null || _a === void 0 ? void 0 : _a.defaultValue))
+        newV = undefined;
+    if (started && (0, misc_1.same)(newV, state[k]))
+        return; // no change
+    const was = getConfig(k); // include cloned default, if necessary
+    state[k] = newV;
+    cfgEvents.emit('new.' + k, getConfig(k), was);
+    if (saveChanges)
+        (0, exports.saveConfigAsap)().then();
+}
+exports.saveConfigAsap = (0, misc_1.debounceAsync)(async () => {
+    while (!started)
+        await (0, misc_1.wait)(100);
+    let txt = yaml_1.default.stringify(state, { lineWidth: 1000 });
+    if (txt.trim() === '{}') // most users wouldn't understand
+        txt = '';
+    save(path, txt)
+        .catch(err => console.error('Failed at saving config file, please ensure it is writable.', String(err)));
+});

package/src/connections.js

@@ -0,0 +1,57 @@
+"use strict";
+// This file is part of HFS - Copyright 2021-2023, 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.updateConnection = exports.socket2connection = exports.getConnections = exports.newConnection = exports.normalizeIp = exports.Connection = void 0;
+const events_1 = __importDefault(require("./events"));
+const lodash_1 = __importDefault(require("lodash"));
+class Connection {
+    constructor(socket) {
+        this.socket = socket;
+        this.started = new Date();
+        this.sent = 0;
+        all.push(this);
+        socket.on('close', () => {
+            all.splice(all.indexOf(this), 1);
+            events_1.default.emit('connectionClosed', this);
+        });
+        events_1.default.emit('connection', this);
+    }
+    get ip() {
+        var _a, _b;
+        return ((_a = this.ctx) === null || _a === void 0 ? void 0 : _a.ip) || ((_b = this._cachedIp) !== null && _b !== void 0 ? _b : (this._cachedIp = normalizeIp(this.socket.remoteAddress || '')));
+    }
+    get secure() {
+        return this.socket.server.cert > '';
+    }
+}
+exports.Connection = Connection;
+function normalizeIp(ip) {
+    return ip.replace(/^::ffff:/, ''); // simplify ipv6-mapped addresses
+}
+exports.normalizeIp = normalizeIp;
+const all = [];
+function newConnection(socket) {
+    new Connection(socket);
+}
+exports.newConnection = newConnection;
+function getConnections() {
+    return all;
+}
+exports.getConnections = getConnections;
+function socket2connection(socket) {
+    return all.find(x => // socket exposed by Koa is TLSSocket which encapsulates simple Socket, and I've found no way to access it for simple comparison
+     x.socket.remotePort === socket.remotePort // but we can still match them because IP:PORT is key
+        && x.socket.remoteAddress === socket.remoteAddress);
+}
+exports.socket2connection = socket2connection;
+function updateConnection(conn, change) {
+    // if no change is detected, skip update. ctx is a special case
+    if (!change.ctx && Object.entries(change).every(([k, v]) => lodash_1.default.isEqual(v, conn[k])))
+        return;
+    Object.assign(conn, change);
+    events_1.default.emit('connectionUpdated', conn, change);
+}
+exports.updateConnection = updateConnection;

package/src/const.js

@@ -0,0 +1,94 @@
+"use strict";
+// This file is part of HFS - Copyright 2021-2023, 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.APP_PATH = exports.IS_WINDOWS = exports.HTTP_SERVER_ERROR = exports.HTTP_FOOL = exports.HTTP_RANGE_NOT_SATISFIABLE = exports.HTTP_CONFLICT = exports.HTTP_NOT_ACCEPTABLE = exports.HTTP_METHOD_NOT_ALLOWED = exports.HTTP_NOT_FOUND = exports.HTTP_FORBIDDEN = exports.HTTP_UNAUTHORIZED = exports.HTTP_BAD_REQUEST = exports.HTTP_NOT_MODIFIED = exports.HTTP_TEMPORARY_REDIRECT = exports.HTTP_PARTIAL_CONTENT = exports.HTTP_NO_CONTENT = exports.HTTP_OK = exports.PLUGINS_PUB_URI = exports.API_URI = exports.ADMIN_URI = exports.FRONTEND_URI = exports.SPECIAL_URI = exports.COMPATIBLE_API_VERSION = exports.API_VERSION = exports.SESSION_DURATION = exports.DAY = exports.VERSION = exports.BUILD_TIMESTAMP = exports.HFS_STARTED = exports.ORIGINAL_CWD = exports.DEV = exports.argv = void 0;
+const minimist_1 = __importDefault(require("minimist"));
+const fs = __importStar(require("fs"));
+const os_1 = require("os");
+const fs_1 = require("fs");
+const path_1 = require("path");
+exports.argv = (0, minimist_1.default)(process.argv.slice(2));
+exports.DEV = process.env.DEV || exports.argv.dev ? 'DEV' : '';
+exports.ORIGINAL_CWD = process.cwd();
+exports.HFS_STARTED = new Date();
+const PKG_PATH = (0, path_1.join)(__dirname, '..', 'package.json');
+exports.BUILD_TIMESTAMP = fs.statSync(PKG_PATH).mtime.toISOString();
+const pkg = JSON.parse(fs.readFileSync(PKG_PATH, 'utf8'));
+exports.VERSION = pkg.version;
+exports.DAY = 86400000;
+exports.SESSION_DURATION = exports.DAY;
+exports.API_VERSION = 4.1; // array.$width
+exports.COMPATIBLE_API_VERSION = 1; // while changes in the api are not breaking, this number stays the same, otherwise is made equal to API_VERSION
+exports.SPECIAL_URI = '/~/';
+exports.FRONTEND_URI = exports.SPECIAL_URI + 'frontend/';
+exports.ADMIN_URI = exports.SPECIAL_URI + 'admin/';
+exports.API_URI = exports.SPECIAL_URI + 'api/';
+exports.PLUGINS_PUB_URI = exports.SPECIAL_URI + 'plugins/';
+exports.HTTP_OK = 200;
+exports.HTTP_NO_CONTENT = 204;
+exports.HTTP_PARTIAL_CONTENT = 206;
+exports.HTTP_TEMPORARY_REDIRECT = 302;
+exports.HTTP_NOT_MODIFIED = 304;
+exports.HTTP_BAD_REQUEST = 400;
+exports.HTTP_UNAUTHORIZED = 401;
+exports.HTTP_FORBIDDEN = 403;
+exports.HTTP_NOT_FOUND = 404;
+exports.HTTP_METHOD_NOT_ALLOWED = 405;
+exports.HTTP_NOT_ACCEPTABLE = 406;
+exports.HTTP_CONFLICT = 409;
+exports.HTTP_RANGE_NOT_SATISFIABLE = 416;
+exports.HTTP_FOOL = 418;
+exports.HTTP_SERVER_ERROR = 500;
+exports.IS_WINDOWS = process.platform === 'win32';
+const IS_BINARY = !(0, path_1.basename)(process.argv0).includes('node'); // this won't be node if pkg was used
+exports.APP_PATH = (0, path_1.dirname)(IS_BINARY ? process.argv0 : __dirname);
+// we want this to be the first stuff to be printed, then we print it in this module, that is executed at the beginning
+if (exports.DEV)
+    console.clear();
+else
+    console.debug = () => { };
+console.log(`HFS ~ HTTP File Server - Copyright 2021-2023, Massimo Melina <a@rejetto.com>`);
+console.log(`License https://www.gnu.org/licenses/gpl-3.0.txt`);
+console.log('started', exports.HFS_STARTED.toLocaleString(), exports.DEV);
+console.log('version', exports.VERSION || '-');
+console.log('build', exports.BUILD_TIMESTAMP || '-');
+if (exports.argv.cwd)
+    process.chdir(exports.argv.cwd);
+else if (!process.argv0.endsWith('.exe')) { // still considering whether to use this behavior with Windows users, who may be less accustomed to it
+    const dir = (0, path_1.join)((0, os_1.homedir)(), '.hfs');
+    try {
+        (0, fs_1.mkdirSync)(dir);
+    }
+    catch (e) {
+        if (e.code !== 'EEXIST')
+            console.error(e);
+    }
+    process.chdir(dir);
+}
+console.log('cwd', process.cwd());

package/src/crypt.js

@@ -0,0 +1,21 @@
+"use strict";
+// This file is part of HFS - Copyright 2021-2023, 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.verifyPassword = exports.hashPassword = void 0;
+// simple wrapper
+// @ts-ignore
+const pbkdf2_1 = require("./pbkdf2");
+const assert_1 = __importDefault(require("assert"));
+async function hashPassword(s) {
+    return 'p2:' + await (0, pbkdf2_1.pbkdf2)(s);
+}
+exports.hashPassword = hashPassword;
+async function verifyPassword(hashed, given) {
+    const i = hashed.indexOf(':');
+    (0, assert_1.default)(i > 0, 'bad hashed');
+    return await (0, pbkdf2_1.pbkdf2Verify)(hashed.slice(i + 1), given); // for the time being we totally ignore the "method" part
+}
+exports.verifyPassword = verifyPassword;

package/src/debounceAsync.js

@@ -0,0 +1,49 @@
+"use strict";
+// This file is part of HFS - Copyright 2021-2023, Massimo Melina <a@rejetto.com> - License https://www.gnu.org/licenses/gpl-3.0.txt
+Object.defineProperty(exports, "__esModule", { value: true });
+// like lodash.debounce, but also avoids async invocations to overlap
+function debounceAsync(callback, wait = 100, { leading = false, maxWait = Infinity } = {}) {
+    let started = 0; // latest callback invocation
+    let runningCallback; // latest callback invocation result
+    let runningDebouncer; // latest wrapper invocation
+    let waitingSince = 0; // we are delaying invocation since
+    let whoIsWaiting; // args' array object identifies the pending instance, and incidentally stores args
+    const interceptingWrapper = (...args) => runningDebouncer = debouncer.apply(null, args);
+    return Object.assign(interceptingWrapper, {
+        cancel: () => {
+            waitingSince = 0;
+            whoIsWaiting = undefined;
+        },
+        flush: () => runningCallback !== null && runningCallback !== void 0 ? runningCallback : exec(),
+    });
+    async function debouncer(...args) {
+        if (runningCallback)
+            return await runningCallback;
+        whoIsWaiting = args;
+        waitingSince || (waitingSince = Date.now());
+        const waitingCap = maxWait - (Date.now() - (waitingSince || started));
+        const waitFor = Math.min(waitingCap, leading ? wait - (Date.now() - started) : wait);
+        if (waitFor > 0)
+            await new Promise(resolve => setTimeout(resolve, waitFor));
+        if (!whoIsWaiting) // canceled
+            return void (waitingSince = 0);
+        if (whoIsWaiting !== args) // another fresher call is waiting
+            return runningDebouncer;
+        return await exec();
+    }
+    async function exec() {
+        if (!whoIsWaiting)
+            return;
+        waitingSince = 0;
+        started = Date.now();
+        try {
+            runningCallback = callback.apply(null, whoIsWaiting);
+            return await runningCallback;
+        }
+        finally {
+            whoIsWaiting = undefined;
+            runningCallback = undefined;
+        }
+    }
+}
+exports.default = debounceAsync;

package/src/events.js

@@ -0,0 +1,9 @@
+"use strict";
+// This file is part of HFS - Copyright 2021-2023, 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 });
+const events_1 = __importDefault(require("events"));
+// app-wide events
+exports.default = new events_1.default();

package/src/frontEndApis.js

@@ -0,0 +1,38 @@
+"use strict";
+// This file is part of HFS - Copyright 2021-2023, 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;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.frontEndApis = void 0;
+const api_file_list_1 = require("./api.file_list");
+const api_auth = __importStar(require("./api.auth"));
+const config_1 = require("./config");
+const customHeader = (0, config_1.defineConfig)('custom_header');
+exports.frontEndApis = {
+    file_list: api_file_list_1.file_list,
+    ...api_auth,
+    config() {
+        return Object.fromEntries([customHeader].map(x => [x.key(), x.get()]));
+    }
+};

package/src/github.js

@@ -0,0 +1,104 @@
+"use strict";
+// This file is part of HFS - Copyright 2021-2023, 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.searchPlugins = exports.getFolder2repo = exports.readOnlinePlugin = exports.getRepoInfo = exports.downloadPlugin = void 0;
+const events_1 = __importDefault(require("./events"));
+const misc_1 = require("./misc");
+const plugins_1 = require("./plugins");
+const apiMiddleware_1 = require("./apiMiddleware");
+const lodash_1 = __importDefault(require("lodash"));
+const const_1 = require("./const");
+const DIST_ROOT = 'dist/';
+const downloading = {};
+function downloadProgress(id, status) {
+    if (status === undefined)
+        delete downloading[id];
+    else
+        downloading[id] = status;
+    events_1.default.emit('pluginDownload_' + id, status);
+}
+async function downloadPlugin(repo, branch = '', overwrite) {
+    if (downloading[repo])
+        return new apiMiddleware_1.ApiError(const_1.HTTP_CONFLICT, "already downloading");
+    downloadProgress(repo, true);
+    const rec = await getRepoInfo(repo);
+    if (!branch)
+        branch = rec.default_branch;
+    const short = repo.split('/')[1]; // second part, repo without the owner
+    const folder2repo = getFolder2repo();
+    const folder = overwrite ? lodash_1.default.findKey(folder2repo, x => x === repo) // use existing folder
+        : short in folder2repo ? repo.replace('/', '-') // longer form only if another plugin is using short form
+            : short;
+    const installPath = plugins_1.PATH + '/' + folder;
+    const GITHUB_ZIP_ROOT = short + '-' + branch; // GitHub puts everything within this folder
+    const rootWithinZip = GITHUB_ZIP_ROOT + '/' + DIST_ROOT;
+    const stream = await (0, misc_1.httpsStream)(`https://github.com/${repo}/archive/refs/heads/${branch}.zip`);
+    await (0, misc_1.unzip)(stream, path => path.startsWith(rootWithinZip) && installPath + '/' + path.slice(rootWithinZip.length));
+    downloadProgress(repo, undefined);
+    await (0, plugins_1.rescan)(); // workaround: for some reason, operations are not triggering the rescan of the watched folder. Let's invoke it.
+    return folder;
+}
+exports.downloadPlugin = downloadPlugin;
+function getRepoInfo(id) {
+    return apiGithub('repos/' + id);
+}
+exports.getRepoInfo = getRepoInfo;
+async function readOnlinePlugin(repoInfo, branch = '') {
+    const url = `https://raw.githubusercontent.com/${repoInfo.full_name}/${branch || repoInfo.default_branch}/${DIST_ROOT}plugin.js`;
+    const res = await (0, misc_1.httpsString)(url);
+    if (!res.ok)
+        throw res.statusCode;
+    const pl = (0, plugins_1.parsePluginSource)(repoInfo.full_name, res.body); // use 'repo' as 'id' client-side
+    pl.branch = branch || undefined;
+    return pl;
+}
+exports.readOnlinePlugin = readOnlinePlugin;
+function getFolder2repo() {
+    const ret = Object.fromEntries((0, plugins_1.getAvailablePlugins)().map(x => [x.id, x.repo]));
+    Object.assign(ret, Object.fromEntries((0, plugins_1.mapPlugins)(x => [x.id, x.getData().repo])));
+    return ret;
+}
+exports.getFolder2repo = getFolder2repo;
+async function apiGithub(uri) {
+    const res = await (0, misc_1.httpsString)('https://api.github.com/' + uri, {
+        headers: {
+            'User-Agent': 'HFS',
+            Accept: 'application/vnd.github.v3+json',
+        }
+    });
+    if (!res.ok)
+        throw res.statusCode;
+    return JSON.parse(res.body);
+}
+async function* searchPlugins(text) {
+    var _a;
+    const res = await apiGithub('search/repositories?q=topic:hfs-plugin+' + encodeURI(text));
+    for (const it of res.items) {
+        const repo = it.full_name;
+        let pl = await readOnlinePlugin(it);
+        if (!pl.apiRequired)
+            continue; // mandatory field
+        if (pl.badApi) { // we try other branches (starting with 'api')
+            const branches = (await apiGithub('repos/' + it.full_name + '/branches'))
+                .map((x) => x.name).filter((x) => x.startsWith('api')).sort();
+            for (const branch of branches) {
+                pl = await readOnlinePlugin(it, branch);
+                if (!pl.apiRequired)
+                    pl.badApi = '-';
+                if (!pl.badApi)
+                    break;
+            }
+        }
+        if (pl.badApi)
+            continue;
+        Object.assign(pl, {
+            downloading: downloading[repo],
+            license: (_a = it.license) === null || _a === void 0 ? void 0 : _a.spdx_id,
+        }, lodash_1.default.pick(it, ['pushed_at', 'stargazers_count']));
+        yield pl;
+    }
+}
+exports.searchPlugins = searchPlugins;

package/src/index.js

@@ -0,0 +1,57 @@
+#!/usr/bin/env node
+"use strict";
+// This file is part of HFS - Copyright 2021-2023, 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 };
+};
+var _a;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.app = void 0;
+const koa_1 = __importDefault(require("koa"));
+const koa_mount_1 = __importDefault(require("koa-mount"));
+const apiMiddleware_1 = require("./apiMiddleware");
+const const_1 = require("./const");
+const frontEndApis_1 = require("./frontEndApis");
+const log_1 = require("./log");
+const plugins_1 = require("./plugins");
+const throttler_1 = require("./throttler");
+const middlewares_1 = require("./middlewares");
+require("./listen");
+require("./commands");
+const adminApis_1 = require("./adminApis");
+const config_1 = require("./config");
+const assert_1 = require("assert");
+const lodash_1 = __importDefault(require("lodash"));
+const misc_1 = require("./misc");
+(0, assert_1.ok)(lodash_1.default.intersection(Object.keys(frontEndApis_1.frontEndApis), Object.keys(adminApis_1.adminApis)).length === 0); // they share same endpoints
+const keys = ((_a = process.env.COOKIE_SIGN_KEYS) === null || _a === void 0 ? void 0 : _a.split(',')) || [(0, misc_1.randomId)(30)];
+exports.app = new koa_1.default({ keys });
+exports.app.use(middlewares_1.someSecurity)
+    .use((0, middlewares_1.sessions)(exports.app))
+    .use(middlewares_1.prepareState)
+    .use(middlewares_1.headRequests)
+    .use((0, log_1.log)())
+    .use(throttler_1.throttler)
+    .use(middlewares_1.gzipper)
+    .use(middlewares_1.paramsDecoder)
+    .use((0, plugins_1.pluginsMiddleware)())
+    .use((0, koa_mount_1.default)(const_1.API_URI, (0, apiMiddleware_1.apiMiddleware)({ ...frontEndApis_1.frontEndApis, ...adminApis_1.adminApis })))
+    .use(middlewares_1.serveGuiAndSharedFiles)
+    .on('error', errorHandler);
+function errorHandler(err) {
+    const { code } = err;
+    if (const_1.DEV && code === 'ENOENT' && err.path.endsWith('sockjs-node'))
+        return; // spam out dev stuff
+    if (code === 'ECANCELED' || code === 'ECONNRESET' || code === 'ECONNABORTED' || code === 'EPIPE'
+        || code === 'HPE_INVALID_EOF_STATE')
+        return; // someone interrupted, don't care
+    console.error('server error', err);
+}
+process.on('uncaughtException', err => {
+    if (err.syscall !== 'watch')
+        console.error(err);
+});
+(0, config_1.defineConfig)('proxies', 0).sub(n => {
+    exports.app.proxy = n > 0;
+    exports.app.maxIpsCount = n;
+});