hfs 3.3.4 → 3.4.0-alpha2

package/src/perm.js

@@ -33,17 +33,7 @@ const auth_1 = require("./auth");
 const sessionStamp_1 = require("./sessionStamp");
 // provides the username and all other usernames it inherits based on the 'belongs' attribute. Useful to check permissions
 function expandUsername(who) {
-    const ret = new Set();
-    const q = [who];
-    for (const u of q) {
-        const a = getAccount(u);
-        if (!a || a.disabled)
-            continue;
-        ret.add(u);
-        if (a.belongs)
-            q.push(...a.belongs);
-    }
-    return ret;
+    return new Set(Array.from(walkActiveAccounts([who]), a => a.username));
 }
 // check if current username or any ancestor match the provided usernames
 function ctxBelongsTo(ctx, usernames) {
@@ -235,14 +225,29 @@ function delAccount(username) {
 }
 // get some property from account, searching in its groups if necessary. Search is breadth-first, and this determines priority of inheritance.
 function getFromAccount(account, getter) {
-    const search = [account];
+    const root = typeof account === 'string' ? getAccount(account) : account;
+    if (!root)
+        return;
+    let res = getter(root); // always consider direct properties; only inherited groups are filtered by active status
+    if (res !== undefined)
+        return res;
+    for (const a of walkActiveAccounts(root.belongs || [])) {
+        res = getter(a);
+        if (res !== undefined)
+            return res;
+    }
+}
+function* walkActiveAccounts(roots) {
+    const search = [...roots];
+    const visited = new Set();
     for (const accountOrUsername of search) {
         const a = typeof accountOrUsername === 'string' ? getAccount(accountOrUsername) : accountOrUsername;
-        if (!a)
+        if (!a || visited.has(a.username))
             continue;
-        const res = getter(a);
-        if (res !== undefined)
-            return res;
+        visited.add(a.username);
+        if (accountIsDisabled(a))
+            continue;
+        yield a;
         if (a.belongs)
             search.push(...a.belongs);
     }
@@ -257,10 +262,23 @@ function accountCanLogin(account) {
     return accountHasLoginMethod(account) && !accountIsDisabled(account);
 }
 function accountIsDisabled(account) {
-    return Boolean(account.disabled
-        || account.expire < Date.now()
-        || account.belongs?.length // don't every() on empty array, as it returns true
-            && account.belongs.map(u => getAccount(u, false)).every(a => a && accountIsDisabled(a)));
+    return check(account, new Set());
+    function check(account, visiting) {
+        if (account.disabled || account.expire < Date.now())
+            return true;
+        if (!account.belongs?.length)
+            return false;
+        // consider invalid membership cycles disabled so they cannot grant privileges
+        if (visiting.has(account.username))
+            return true;
+        visiting.add(account.username);
+        const ret = account.belongs.every(u => {
+            const a = getAccount(u, false);
+            return Boolean(a && check(a, visiting));
+        });
+        visiting.delete(account.username);
+        return ret;
+    }
 }
 function accountCanLoginAdmin(account) {
     return accountCanLogin(account) && getFromAccount(account, a => a.admin) || false;

package/src/pluginCatalog.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 });
+exports.getPluginCatalog = getPluginCatalog;
+exports.searchPluginCatalog = searchPluginCatalog;
+const github_1 = require("./github");
+const persistence_1 = require("./persistence");
+const const_1 = require("./const");
+const lodash_1 = __importDefault(require("lodash"));
+const CACHE_KEY = 'pluginCatalog';
+let refreshing;
+async function* getPluginCatalog() {
+    await persistence_1.storedMap.ready();
+    const saved = await persistence_1.storedMap.get(CACHE_KEY);
+    // compatibility is determined by this HFS version, including fallback api branches
+    const previous = saved?.version === const_1.VERSION ? saved : undefined;
+    const age = previous ? Date.now() - previous.updatedAt : Infinity;
+    if (previous && age < 24 * 60 * 60_000)
+        yield { ...previous, refreshing: age >= 5 * 60_000 };
+    if (age < 5 * 60_000)
+        return;
+    // all searches share the same refresh, even if the initiating client disconnects
+    refreshing ??= refresh().finally(() => { refreshing = undefined; });
+    yield { ...await refreshing, refreshing: false };
+    async function refresh() {
+        const repositories = [];
+        for await (const repo of (0, github_1.apiGithubPaginated)('search/repositories?q=topic:hfs-plugin', { requireComplete: true }))
+            repositories.push(lodash_1.default.pick(repo, ['full_name', 'description', 'pushed_at', 'default_branch', 'stargazers_count', 'license']));
+        const old = new Map(previous?.entries.map(entry => [entry.repository.full_name, entry]));
+        const entries = await Promise.all(repositories.map(async (repository) => {
+            const cached = old.get(repository.full_name);
+            let plugin = cached?.plugin;
+            if (!cached || cached.repository.pushed_at !== repository.pushed_at
+                || cached.repository.default_branch !== repository.default_branch) {
+                plugin = await (0, github_1.readOnlineCompatiblePlugin)(repository.full_name, repository.default_branch)
+                    .catch((error) => {
+                    // repositories can carry the topic without providing a plugin at the expected path
+                    if (error.message !== '404')
+                        throw error;
+                }) ?? null;
+            }
+            return { repository, plugin: plugin ?? null };
+        }));
+        const next = { version: const_1.VERSION, updatedAt: Date.now(), entries };
+        // never replace a complete catalog with the result of a failed refresh
+        await persistence_1.storedMap.put(CACHE_KEY, next);
+        return next;
+    }
+}
+async function searchPluginCatalog(catalog, text = '', skipRepos = []) {
+    const central = await (0, github_1.getProjectInfo)();
+    const terms = text.toLowerCase().split(/\s+/).filter(Boolean);
+    return catalog.entries.flatMap(({ repository, plugin }) => {
+        const repo = repository.full_name;
+        const searchable = `${repo} ${repository.description || ''} ${plugin?.description || ''}`.toLowerCase();
+        if (!plugin || skipRepos.includes(repo) || central?.repo_blacklist?.[repo]?.message
+            || !terms.every(term => searchable.includes(term)))
+            return [];
+        // API responses add live state and dependency errors; keep the persisted metadata untouched
+        return [{ ...plugin, id: repo, repo, pushed_at: repository.pushed_at,
+                stargazers_count: repository.stargazers_count, default_branch: repository.default_branch,
+                license: repository.license?.spdx_id }];
+    });
+}

package/src/pluginUsage.js

@@ -0,0 +1,64 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const node_crypto_1 = require("node:crypto");
+const misc_1 = require("./misc");
+const config_1 = require("./config");
+const plugins_1 = require("./plugins");
+const persistence_1 = require("./persistence");
+const util_http_1 = require("./util-http");
+const debounceAsync_1 = require("./debounceAsync");
+const shareUsageStats = (0, config_1.defineConfig)(misc_1.CFG.share_usage_stats, false);
+const installationId = persistence_1.storedMap.singleSync('pluginUsageId', '');
+const lastReport = persistence_1.storedMap.singleSync('lastPluginUsageReport', 0);
+const ready = Promise.all([config_1.configReady, plugins_1.pluginsScanned, installationId.ready(), lastReport.ready()]);
+const syncPluginUsage = (0, debounceAsync_1.debounceAsync)(async () => {
+    await ready;
+    let uuid = installationId.get();
+    if (!shareUsageStats.get()) {
+        if (!uuid)
+            return;
+        await send('DELETE', { uuid });
+        installationId.set('');
+        lastReport.set(0);
+        return;
+    }
+    if (Date.now() < lastReport.get() + misc_1.DAY)
+        return;
+    if (!uuid) {
+        uuid = (0, node_crypto_1.randomUUID)();
+        installationId.set(uuid);
+    }
+    const enabled = plugins_1.enablePlugins.get();
+    const plugins = selectReportedPlugins([
+        ...(0, plugins_1.mapPlugins)((plugin, id) => ({ ...plugin.getData(), id, enabled: enabled.includes(id) }), false),
+        ...(0, plugins_1.getInactivePlugins)().map(plugin => ({ ...plugin, enabled: enabled.includes(plugin.id) })),
+    ]);
+    await send('POST', { uuid, hfsVersion: String(config_1.currentVersion), plugins });
+    lastReport.set(Date.now());
+    function selectReportedPlugins(installed) {
+        const selected = new Map();
+        for (const plugin of installed) {
+            const repo = typeof plugin.repo === 'string' ? plugin.repo : plugin.repo?.main;
+            if (!repo)
+                continue;
+            const current = selected.get(repo);
+            if (!current || better(plugin, current))
+                selected.set(repo, plugin);
+        }
+        return Array.from(selected, ([repo, plugin]) => ({
+            repo,
+            version: plugin.version,
+            enabled: plugin.enabled,
+        })).sort((a, b) => a.repo.localeCompare(b.repo));
+        function better(a, b) {
+            return Number(a.enabled) > Number(b.enabled)
+                || a.enabled === b.enabled && (a.id.length < b.id.length
+                    || a.id.length === b.id.length && a.id.localeCompare(b.id) < 0);
+        }
+    }
+});
+shareUsageStats.sub(() => void syncPluginUsage().catch(() => { }));
+(0, misc_1.repeat)(misc_1.HOUR, syncPluginUsage);
+async function send(method, body) {
+    await (0, util_http_1.httpWithBody)(misc_1.PLUGIN_USAGE_URL + '/report', { method, body, timeout: 5000 });
+}

package/src/plugins.js

@@ -53,6 +53,7 @@ exports.getInactivePlugins = getInactivePlugins;
 exports.rescan = rescan;
 exports.parsePluginSource = parsePluginSource;
 exports.getMissingDependencies = getMissingDependencies;
+const acmeDns_1 = require("./acmeDns");
 const fast_glob_1 = __importDefault(require("fast-glob"));
 const watchLoad_1 = require("./watchLoad");
 const lodash_1 = __importDefault(require("lodash"));
@@ -232,6 +233,13 @@ async function initPlugin(pl, morePassedToInit, onInitError) {
                 return result;
             }
         },
+        registerAcmeDnsProvider(...args) {
+            if (unloading)
+                throw Error("Plugin is unloading");
+            const unregister = (0, acmeDns_1.registerAcmeDnsProvider)(...args);
+            cleanups.push(unregister);
+            return unregister;
+        },
         misc, _: lodash_1.default,
         customApiCall, notifyClient: frontEndApis_1.notifyClient, addBlock: block_1.addBlock, ctxBelongsTo: perm_1.ctxBelongsTo, getConnections: connections_1.getConnections, normalizeFilename: vfs_1.normalizeFilename,
         getCurrentUsername: auth_1.getCurrentUsername, getAccount: perm_1.getAccount, getUsernames: perm_1.getUsernames, addAccount: perm_1.addAccount, delAccount: perm_1.delAccount, updateAccount: perm_1.updateAccount, renameAccount: perm_1.renameAccount,
@@ -290,8 +298,8 @@ const pluginsMiddleware = async (ctx, next) => {
             const a = path.substring(const_1.PLUGINS_PUB_URI.length).split('/');
             const name = a.shift();
             if (plugins.has(name)) { // do it only if the plugin is loaded
-                if (ctx.get('referer')?.endsWith('/'))
-                    ctx.state.considerAsGui = true;
+                // this server-owned route is GUI content; client headers must not grant the exemption
+                ctx.state.considerAsGui = true;
                 await (0, serveFile_1.serveFile)(ctx, plugins.get(name).folder + '/public/' + a.join('/'), const_1.MIME_AUTO);
             }
             return;
@@ -734,6 +742,10 @@ function parsePluginSource(id, source) {
     pl.depend = (0, misc_1.tryJson)(/exports.depend\s*=\s*(\[[\s\S]*?])/m.exec(source)?.[1])?.filter((x) => typeof x.repo === 'string' && x.version === undefined || typeof x.version === 'number'
         || console.warn("Plugin dependency discarded", x));
     pl.changelog = (0, misc_1.tryJson)(/exports.changelog\s*=\s*(\[[\s\S]*?])/m.exec(source)?.[1]);
+    if (!Array.isArray(pl.changelog))
+        delete pl.changelog;
+    else if (lodash_1.default.remove(pl.changelog, entry => !Number.isFinite(entry?.version) || typeof entry?.message !== 'string').length)
+        console.warn("Invalid plugin changelog entries discarded", id);
     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);

package/src/roots.js

@@ -3,7 +3,7 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.rootsMiddleware = exports.roots = void 0;
+exports.rootsMiddleware = exports.rootsHostGuard = exports.roots = void 0;
 const config_1 = require("./config");
 const misc_1 = require("./misc");
 const connections_1 = require("./connections");
@@ -17,6 +17,26 @@ exports.roots = (0, config_1.defineConfig)(misc_1.CFG.roots, {}, map => {
     return (host) => values[matchers.findIndex(m => m(host))];
 });
 const forceAddress = (0, config_1.defineConfig)(misc_1.CFG.force_address, false);
+const rootsHostGuard = (ctx, next) => {
+    if (!ctx.path || lodash_1.default.isEmpty(exports.roots.get()))
+        return next();
+    if (ctx.path.startsWith(misc_1.SPECIAL_URI)) {
+        if (!ctx.path.startsWith(misc_1.API_URI))
+            return next();
+        const { referer } = ctx.headers;
+        const fromAdmin = referer && (0, misc_1.try_)(() => new URL(referer).pathname.startsWith(ctx.state.revProxyPath + misc_1.ADMIN_URI));
+        // authentication must remain reachable before ctxAdminAccess can succeed
+        if (fromAdmin && ((0, adminApis_1.ctxAdminAccess)(ctx)
+            || ['login', 'loginSrp1', 'loginSrp2'].some(x => ctx.path === misc_1.API_URI + x)))
+            return next();
+    }
+    const root = ctx.state.root = exports.roots.compiled()(ctx.host);
+    return !ctx.state.skipFilters && forceAddress.get()
+        && root === undefined && !(0, misc_1.isLocalHost)(ctx) && ctx.host !== listen_1.baseUrl.compiled()
+        ? (0, connections_1.disconnect)(ctx, forceAddress.key())
+        : next();
+};
+exports.rootsHostGuard = rootsHostGuard;
 const rootsMiddleware = (ctx, next) => (() => {
     if (!ctx.path) // it was once reported "Cannot read properties of null (reading 'startsWith')" but I can't reproduce it, and it shouldn't happen anyway
         return (0, connections_1.disconnect)(ctx, 'no path'); // let's assume that such requests can't be served anyway. This will leave a trace with an ip, anyway
@@ -27,19 +47,8 @@ const rootsMiddleware = (ctx, next) => (() => {
             return; // ...unless it's an api
         params = ctx.state.params || ctx.query; // for api we'll translate params
         changeUriParams(v => (0, misc_1.removeStarting)(ctx.state.revProxyPath, v)); // this removal must be done before adding the root; this operation doesn't conceptually belong to "roots", and it may be placed in different middleware, but it's convenient to do it here
-        const { referer } = ctx.headers;
-        const fromAdmin = referer && (0, misc_1.try_)(() => new URL(referer).pathname.startsWith(ctx.state.revProxyPath + misc_1.ADMIN_URI));
-        // authentication must remain reachable before ctxAdminAccess can succeed
-        if (fromAdmin && ((0, adminApis_1.ctxAdminAccess)(ctx)
-            || ['login', 'loginSrp1', 'loginSrp2'].some(x => ctx.path === misc_1.API_URI + x)))
-            return;
     }
-    if (lodash_1.default.isEmpty(exports.roots.get()))
-        return;
-    const root = ctx.state.root = exports.roots.compiled()(ctx.host);
-    if (!ctx.state.skipFilters && forceAddress.get()
-        && root === undefined && !(0, misc_1.isLocalHost)(ctx) && ctx.host !== listen_1.baseUrl.compiled())
-        return (0, connections_1.disconnect)(ctx, forceAddress.key()); // returning truthy will not call next
+    const { root } = ctx.state;
     if (!root || root === '/')
         return; // no transformation is required
     changeUriParams(v => (0, misc_1.join)(root, v));

package/src/serveFile.js

@@ -8,6 +8,9 @@ exports.forceDownload = forceDownload;
 exports.disposition = disposition;
 exports.serveFileNode = serveFileNode;
 exports.enforceDownloadLimits = enforceDownloadLimits;
+exports.resolveFileMime = resolveFileMime;
+exports.getNodeMime = getNodeMime;
+exports.isActiveContentMime = isActiveContentMime;
 exports.serveFile = serveFile;
 exports.monitorAsDownload = monitorAsDownload;
 exports.applyRange = applyRange;
@@ -26,11 +29,12 @@ const errorPages_1 = require("./errorPages");
 const stream_1 = require("stream");
 const crypto_1 = require("crypto");
 const iconv_lite_1 = __importDefault(require("iconv-lite"));
+const upload_1 = require("./upload");
 const allowedReferer = (0, config_1.defineConfig)(misc_1.CFG.allowed_referer, '');
+const requireUploadApprovalForActiveContent = (0, config_1.defineConfig)(misc_1.CFG.require_upload_approval_for_active_content, true);
 const maxDownloads = downloadLimiter((0, config_1.defineConfig)(misc_1.CFG.max_downloads, 0), () => true);
 const maxDownloadsPerIp = downloadLimiter((0, config_1.defineConfig)(misc_1.CFG.max_downloads_per_ip, 0), ctx => ctx.ip);
 const maxDownloadsPerAccount = downloadLimiter((0, config_1.defineConfig)(misc_1.CFG.max_downloads_per_account, 0), ctx => (0, auth_1.getCurrentUsername)(ctx) || undefined);
-const GUI_ASSET_MIME = /^(image\/|audio\/|video\/|font\/|text\/css$|(?:text|application)\/(?:javascript|ecmascript)$|application\/x-javascript$)/i;
 function toAsciiEquivalent(s) {
     return iconv_lite_1.default.encode(iconv_lite_1.default.decode(Buffer.from(s), 'utf-8'), 'ascii').toString().replaceAll('?', '');
 }
@@ -49,6 +53,7 @@ async function serveFileNode(ctx, node) {
     const name = (0, vfs_1.getNodeName)(node);
     const mimeString = typeof mime === 'string' ? mime
         : lodash_1.default.find(mime, (_val, mask) => (0, misc_1.matches)(name, mask));
+    const effectiveMime = resolveFileMime(source || '', mimeString);
     if (allowedReferer.get()) {
         const ref = (0, misc_1.try_)(() => new URL(ctx.get('referer') || '').host);
         if (ref && ref !== ctx.host // automatically accept if the referer is basically the hosting domain
@@ -58,12 +63,13 @@ async function serveFileNode(ctx, node) {
     ctx.state.vfsNode = node; // useful to tell service files from files shared by the user
     const download = 'dl' in ctx.query;
     disposition(ctx, name, download);
-    const fetchDest = ctx.get('sec-fetch-dest');
-    ctx.state.considerAsGui ??= !download && ctx.get('referer')?.endsWith('/')
-        && (fetchDest ? fetchDest !== 'document' && fetchDest !== 'empty' // modern clients
-            // legacy clients often send Accept: */* for archive downloads, so the served mime is a safer signal than request headers here
-            : GUI_ASSET_MIME.test(mimeString || mime_types_1.default.lookup(source || '') || ''));
-    await serveFile(ctx, source || '', mimeString);
+    if (!download && source && isActiveContentMime(effectiveMime)) {
+        if ((0, upload_1.isUploading)(source)
+            || requireUploadApprovalForActiveContent.get() && (await (0, upload_1.getUploadMeta)(source))?.approved === false)
+            return (0, errorPages_1.sendErrorPage)(ctx, const_1.HTTP_FORBIDDEN);
+    }
+    // shared files count even when embedded: client headers cannot grant exemptions from limits or logging
+    await serveFile(ctx, source || '', effectiveMime);
     await enforceDownloadLimits(ctx);
 }
 async function enforceDownloadLimits(ctx) {
@@ -75,14 +81,25 @@ const mimeCfg = (0, config_1.defineConfig)(misc_1.CFG.mime, {}, obj => {
     const values = Object.values(obj);
     return (name) => values[matchers.findIndex(matcher => matcher(name))];
 });
+function resolveFileMime(filePath, mime) {
+    mime ??= mimeCfg.compiled()((0, path_1.basename)(filePath));
+    return mime === undefined || mime === const_1.MIME_AUTO ? mime_types_1.default.lookup(filePath) || '' : mime;
+}
+function getNodeMime(node) {
+    const name = (0, vfs_1.getNodeName)(node);
+    const mime = typeof node.mime === 'string' ? node.mime
+        : lodash_1.default.find(node.mime, (_val, mask) => (0, misc_1.matches)(name, mask));
+    return resolveFileMime(node.source || '', mime);
+}
+function isActiveContentMime(mime) {
+    return /^(?:text\/html|application\/xhtml\+xml|image\/svg\+xml)(?:;|$)/i.test(mime);
+}
 // after this number of seconds, the browser should check the server to see if there's a newer version of the file
 const cacheControlDiskFiles = (0, config_1.defineConfig)(misc_1.CFG.cache_control_disk_files, 5);
 async function serveFile(ctx, filePath, mime, cached) {
     if (!filePath)
         return;
-    mime ??= mimeCfg.compiled()((0, path_1.basename)(filePath));
-    if (mime === undefined || mime === const_1.MIME_AUTO)
-        mime = mime_types_1.default.lookup(filePath) || '';
+    mime = resolveFileMime(filePath, mime);
     if (mime)
         ctx.type = mime;
     if (ctx.method === 'OPTIONS') {
@@ -90,7 +107,7 @@ async function serveFile(ctx, filePath, mime, cached) {
         ctx.set({ Allow: 'OPTIONS, GET, HEAD' });
         return;
     }
-    if (ctx.method !== 'GET')
+    if (!ctx.state.getOrHead)
         return ctx.status = const_1.HTTP_METHOD_NOT_ALLOWED;
     try {
         const stats = cached?.stats || await (0, util_1.promisify)(fs_1.stat)(filePath); // using fs's function instead of fs/promises, because only the former is supported by pkg

package/src/serveGuiAndSharedFiles.js

@@ -96,7 +96,7 @@ const serveSharedFiles = async (ctx, next) => {
         }
         return;
     }
-    if (/^\/favicon.ico(\??.*)/.test(ctx.originalUrl) && adminApis_1.favicon.get() && ctx.method === 'GET') // originalUrl to not be subject to changes (vhosting plugin)
+    if (ctx.state.getOrHead && /^\/favicon.ico(\??.*)/.test(ctx.originalUrl) && adminApis_1.favicon.get()) // originalUrl to not be subject to changes (vhosting plugin)
         return (0, serveFile_1.serveFile)(ctx, adminApis_1.favicon.get());
     let node = await (0, vfs_1.urlToNode)(path, ctx);
     if (!node)
@@ -123,11 +123,11 @@ const serveSharedFiles = async (ctx, next) => {
             return ctx.status = cross_const_1.HTTP_SERVER_ERROR;
         }
     }
-    if (path.endsWith('/') && !get) { // final slash needed on browsers to make resource urls working with html pages
-        const found = await (0, vfs_1.getDefaultFile)(node, ctx);
-        if (found && /\.html?/i.test((0, vfs_1.getNodeName)(node = found)))
-            ctx.state.considerAsGui = true;
-    }
+    if (path.endsWith('/') && !get) // final slash needed on browsers to make resource urls working with html pages
+        node = await (0, vfs_1.getDefaultFile)(node, ctx) || node;
+    // classify the resolved default so a file can override its folder's GUI status
+    if (node.gui_asset)
+        ctx.state.considerAsGui = true;
     if (get === 'icon')
         return (0, serveFile_1.serveFile)(ctx, node.icon || '|'); // pipe to cause not-found
     if (!(0, vfs_1.nodeIsFolder)(node))

package/src/serveGuiFiles.js

@@ -19,6 +19,7 @@ const customHtml_1 = require("./customHtml");
 const lodash_1 = __importDefault(require("lodash"));
 const config_1 = require("./config");
 const lang_1 = require("./lang");
+const adminLang_1 = require("./adminLang");
 const upload_1 = require("./upload");
 const icons_1 = require("./icons");
 const middlewares_1 = require("./middlewares");
@@ -40,10 +41,10 @@ function serveStatic(uri) {
             ctx.state.dontLog = true;
         if (ctx.method === 'OPTIONS') {
             ctx.status = const_1.HTTP_NO_CONTENT;
-            ctx.set({ Allow: 'OPTIONS, GET' });
+            ctx.set({ Allow: 'OPTIONS, GET, HEAD' });
             return;
         }
-        if (ctx.method !== 'GET')
+        if (!ctx.state.getOrHead)
             return ctx.status = const_1.HTTP_METHOD_NOT_ALLOWED;
         const serveApp = shouldServeApp(ctx);
         const fullPath = (0, path_1.join)(root, serveApp ? '/index.html' : ctx.path);
@@ -107,7 +108,8 @@ async function treatIndex(ctx, filesUri, body) {
         return !lodash_1.default.isEmpty(configs) && [name, configs];
     })));
     const timestamp = await getFaviconTimestamp();
-    const lang = await (0, lang_1.getLangData)(ctx);
+    const adminLangs = isFrontend ? [] : await (0, adminLang_1.getAdminLangs)();
+    const lang = isFrontend ? await (0, lang_1.getLangData)(ctx) : await (0, adminLang_1.getAdminLangData)(ctx, adminLangs);
     let group = 0; // this represents the loading-group: all plugins with the same group can be loaded concurrently
     const loadScripts = (0, misc_1.onlyTruthy)((0, plugins_1.mapPlugins)((p, id) => {
         const js = p.frontend_js?.map(f => f.includes('//') ? f : pub + id + '/' + f);
@@ -148,7 +150,8 @@ async function treatIndex(ctx, filesUri, body) {
                 customHtml: lodash_1.default.omit((0, customHtml_1.getAllSections)(), ['top', 'bottom', 'htmlHead', 'style']), // exclude the sections we already apply in this phase
                 ...(0, misc_1.newObj)(misc_1.FRONTEND_OPTIONS, (v, k) => (0, config_1.getConfig)(k)),
                 icons: Object.assign({}, ...(0, plugins_1.mapPlugins)(p => iconsToObj(p.icons, p.id + '/')), iconsToObj(icons_1.customizedIcons)), // name-to-uri 
-                lang
+                lang,
+                ...(isFrontend ? {} : { adminLangs, adminLang: adminLang_1.adminLang.get() })
             }, null, 4).replace(/<(\/script)/g, '<"+"$1') /*avoid breaking our script container*/}
                     document.documentElement.setAttribute('ver', HFS.VERSION.split('-')[0])
                     document.documentElement.setAttribute('browser', ${JSON.stringify((0, misc_1.shortenAgent)(ctx.get('user-agent')))})

package/src/update.js

@@ -10,7 +10,7 @@ exports.getVersions = getVersions;
 exports.getUpdates = getUpdates;
 exports.localUpdateAvailable = localUpdateAvailable;
 exports.previousAvailable = previousAvailable;
-exports.updateSupported = updateSupported;
+exports.updateNotSupported = updateNotSupported;
 exports.update = update;
 const github_1 = require("./github");
 const const_1 = require("./const");
@@ -29,6 +29,7 @@ const lodash_1 = __importDefault(require("lodash"));
 const argv_1 = require("./argv");
 const promises_2 = require("stream/promises");
 const updateChangelog_1 = require("./updateChangelog");
+const fast_xml_parser_1 = require("fast-xml-parser");
 const updateToBeta = (0, config_1.defineConfig)(misc_1.CFG.update_to_beta, false);
 const autoCheckUpdate = (0, config_1.defineConfig)(misc_1.CFG.auto_check_update, true);
 const lastCheckUpdate = persistence_1.storedMap.singleSync('lastCheckUpdate', 0);
@@ -59,15 +60,16 @@ exports.checkForUpdates = (0, misc_1.debounceAsync)(async () => {
 async function getBestUpdate() {
     return (await getUpdates(true))[0];
 }
-const ReleaseKeys = ['prerelease', 'tag_name', 'name', 'body', 'assets', 'isNewer', 'versionScalar'];
-const ReleaseAssetKeys = ['name', 'browser_download_url'];
+const releaseKeys = ['prerelease', 'tag_name', 'name', 'body', 'assets', 'isNewer', 'versionScalar'];
+const releaseAssetKeys = ['name', 'browser_download_url'];
+const assetPrefix = `hfs-${(0, misc_1.xlate)(process.platform, { win32: 'windows', darwin: 'mac' })}-${process.arch}`;
 const curV = config_1.currentVersion.scalar;
 function prepareRelease(r) {
     const v = (0, config_1.versionToScalar)(r.name);
-    return Object.assign(lodash_1.default.pick(r, ReleaseKeys), {
+    return Object.assign(lodash_1.default.pick(r, releaseKeys), {
         versionScalar: v,
         isNewer: v > curV, // make easy to know what's newer
-        assets: r.assets.map((a) => lodash_1.default.pick(a, ReleaseAssetKeys))
+        assets: r.assets.map((a) => lodash_1.default.pick(a, releaseAssetKeys))
     });
 }
 async function getVersions(filter, max = 30, stopAtCurrent = false) {
@@ -91,10 +93,19 @@ async function getVersions(filter, max = 30, stopAtCurrent = false) {
 async function getUpdates(strict = false) {
     console.log("Checking for updates");
     void (0, github_1.getProjectInfo)(); // also check for alerts and print them asap in the console
-    const stable = prepareRelease(await (0, github_1.getRepoInfo)(const_1.HFS_REPO + '/releases/latest'));
     const includeBetas = updateToBeta.get() || const_1.RUNNING_BETA;
-    // we don't consider betas before stable
-    const betas = !includeBetas ? [] : await getVersions(x => x.prerelease && x.versionScalar > stable.versionScalar && (!strict || x.isNewer));
+    const latest = await (0, misc_1.httpStream)(`https://github.com/${const_1.HFS_REPO}/releases/latest`, { method: 'HEAD', noRedirect: true });
+    const stableTag = latest.headers.location?.split('/').at(-1);
+    if (!stableTag)
+        throw Error('Cannot determine latest stable version');
+    if ((0, config_1.versionToScalar)(stableTag) === curV && !includeBetas)
+        return [];
+    let stable = prepareRelease({ prerelease: false, tag_name: stableTag, name: stableTag, body: '', assets: [probableAsset(stableTag)], isNewer: false, versionScalar: 0 });
+    if (stable.isNewer || const_1.RUNNING_BETA && !strict)
+        stable = await (0, github_1.getRepoInfo)(const_1.HFS_REPO + '/releases/tags/' + stableTag).then(prepareRelease).catch(() => stable);
+    const betas = !includeBetas ? [] : await getVersions(x => x.prerelease && x.versionScalar > stable.versionScalar && (!strict || x.isNewer))
+        // preserve update detection when GitHub's REST quota is exhausted
+        .catch(() => getVersionsFromAtom(x => x.prerelease && x.versionScalar > stable.versionScalar && (!strict || x.isNewer)));
     if (stable.isNewer || const_1.RUNNING_BETA && !strict)
         betas.push(stable);
     if (stable.isNewer && stable.body) {
@@ -102,7 +113,28 @@ async function getUpdates(strict = false) {
             .catch(() => []); // missing history must not prevent installing an available update
         stable.body = (0, updateChangelog_1.updateChangelog)(stable, history, curV);
     }
-    return betas;
+    return lodash_1.default.sortBy(betas, x => -x.versionScalar);
+    async function getVersionsFromAtom(filter) {
+        const feed = new fast_xml_parser_1.XMLParser({ ignoreAttributes: false })
+            .parse(await (0, misc_1.httpString)(`https://github.com/${const_1.HFS_REPO}/releases.atom`))?.feed;
+        return lodash_1.default.sortBy(lodash_1.default.castArray(feed?.entry)
+            .map((x) => prepareRelease({
+            prerelease: /^v?\d+\.\d+\.\d+-/.test(x.title),
+            tag_name: x.id.split('/').at(-1),
+            name: x.title,
+            body: x.content?.['#text'] || '',
+            assets: [probableAsset(x.id.split('/').at(-1))],
+            isNewer: false,
+            versionScalar: 0,
+        }))
+            .filter(x => Number.isFinite(x.versionScalar) && !x.name.endsWith('-ignore')
+            && x.versionScalar !== curV && filter(x)), x => -x.versionScalar);
+    }
+    function probableAsset(tag) {
+        const name = `${assetPrefix}-${tag.replace(/^v/, '')}.zip`;
+        // release-assets.yml uses this predictable name, keeping degraded checks installable
+        return { name, browser_download_url: `https://github.com/${const_1.HFS_REPO}/releases/download/${tag}/${name}` };
+    }
 }
 const LOCAL_UPDATE = 'hfs-update.zip'; // update from file takes precedence over net
 const INSTALLED_FN = 'hfs-installed.zip';
@@ -113,13 +145,16 @@ function localUpdateAvailable() {
 function previousAvailable() {
     return (0, misc_1.exists)(PREVIOUS_FN);
 }
-function updateSupported() {
-    return !process.env.DISABLE_UPDATE && (argv_1.argv.forceupdate || const_1.IS_BINARY);
+function updateNotSupported() {
+    return process.env.DISABLE_UPDATE ? "Automatic updates are disabled"
+        : !(argv_1.argv.forceupdate || const_1.IS_BINARY) ? "Only binary versions support automatic updates"
+            : (0, promises_1.access)((0, path_1.dirname)(process.execPath), fs_1.constants.W_OK | fs_1.constants.X_OK)
+                .then(() => '', () => `Executable directory is not writable: ${(0, path_1.dirname)(process.execPath)}`);
 }
 async function update(tagOrUrl = '') {
-    if (!updateSupported())
-        throw process.env.DISABLE_UPDATE ? "Automatic updates are disabled"
-            : "Only binary versions support automatic updates";
+    const error = await updateNotSupported();
+    if (error)
+        throw error;
     let url = tagOrUrl.includes('://') && tagOrUrl;
     if (tagOrUrl === const_1.PREVIOUS_TAG)
         await (0, promises_1.rename)(PREVIOUS_FN, LOCAL_UPDATE);
@@ -135,11 +170,9 @@ async function update(tagOrUrl = '') {
             });
         if (!update)
             throw "No update has been found";
-        const plat = '-' + (0, misc_1.xlate)(process.platform, { win32: 'windows', darwin: 'mac' });
-        const assetSearch = `${plat}-${process.arch}`;
-        const asset = update.assets.find((x) => x.name.includes(assetSearch) && x.name.endsWith('.zip'));
+        const asset = update.assets.find((x) => x.name.includes(assetPrefix) && x.name.endsWith('.zip'));
         if (!asset)
-            throw `Asset not found: ${assetSearch}`;
+            throw `Asset not found: ${assetPrefix}`;
         url = asset.browser_download_url;
     }
     if (url) {