hfs 3.2.2 → 3.3.0-alpha1

package/src/outboundProxy.js

@@ -5,6 +5,13 @@ const util_http_1 = require("./util-http");
 const util_os_1 = require("./util-os");
 const const_1 = require("./const");
 const cross_1 = require("./cross");
+const node_net_1 = require("node:net");
+(0, config_1.defineConfig)(cross_1.CFG.outbound_interface, '', v => {
+    if (!v || (0, node_net_1.isIP)(v))
+        return util_http_1.httpStream.defaultLocalAddress = v || undefined;
+    console.warn("Invalid outbound interface IP", v);
+    util_http_1.httpStream.defaultLocalAddress = undefined;
+});
 const outboundProxy = (0, config_1.defineConfig)(cross_1.CFG.outbound_proxy, '', v => {
     util_http_1.httpStream.defaultProxy = undefined;
     if (!v)

package/src/perm.js

@@ -59,7 +59,7 @@ function getAccount(username, normalize = true) {
 function saveSrpInfo(account, salt, verifier) {
     account.srp = String(salt) + '|' + String(verifier);
 }
-const createAdminConfig = (0, config_1.defineConfig)('create-admin', '');
+const createAdminConfig = (0, config_1.defineConfig)(misc_1.CFG['create-admin'], '');
 createAdminConfig.sub(v => {
     if (!v)
         return;
@@ -79,7 +79,9 @@ async function updateAccount(account, change) {
         await change?.(account);
     else {
         const u = normalizeUsername(change.username || '');
-        if (u && u !== usernameWas && getAccount(u))
+        if (!u)
+            delete change.username;
+        else if (u !== usernameWas && getAccount(u))
             throw "username already exists";
         Object.assign(account, lodash_1.default.mapValues(change, x => x || undefined));
     }
@@ -111,7 +113,7 @@ async function updateAccount(account, change) {
         saveAccountsAsap();
 }
 const saveAccountsAsap = config_1.saveConfigAsap;
-exports.accounts = (0, config_1.defineConfig)('accounts', {});
+exports.accounts = (0, config_1.defineConfig)(misc_1.CFG.accounts, {});
 exports.accounts.sub(lodash_1.default.debounce(obj => {
     // consider some validation here, in case of manual edit of the config
     lodash_1.default.each(obj, (rec, k) => {

package/src/plugins.js

@@ -80,6 +80,7 @@ const perm_1 = require("./perm");
 const auth_1 = require("./auth");
 const icons_1 = require("./icons");
 const listen_1 = require("./listen");
+const serverCode_1 = require("./serverCode");
 exports.PATH = 'plugins';
 exports.DISABLING_SUFFIX = '-disabled';
 exports.DELETE_ME_SUFFIX = '-delete_me' + exports.DISABLING_SUFFIX;
@@ -121,7 +122,7 @@ async function startPlugin(id) {
 }
 async function waitRunning(id, state = true) {
     while (isPluginRunning(id) !== state) {
-        await (0, misc_1.wait)(500);
+        await (0, misc_1.wait)(50);
         const error = getError(id);
         if (error)
             throw Error(error);
@@ -152,9 +153,10 @@ function findPluginByRepo(repo) {
 function getPluginConfigFields(id) {
     return plugins.get(id)?.getData().config;
 }
-async function initPlugin(pl, morePassedToInit) {
+async function initPlugin(pl, morePassedToInit, onInitError) {
     const undoEvents = [];
     const timeouts = [];
+    let unload = pl.unload;
     const controlledEvents = Object.create(events_1.default, (0, misc_1.objFromKeys)(['on', 'once', 'multi'], k => ({
         value() {
             if (k === 'multi')
@@ -183,7 +185,7 @@ async function initPlugin(pl, morePassedToInit) {
             }
         }
     })));
-    const res = await pl.init?.({
+    const res = await (0, misc_1.callAsPromise)(() => pl.init?.({
         Const, require,
         // intercept all subscriptions, so to be able to undo them on unload
         events: controlledEvents,
@@ -220,18 +222,25 @@ async function initPlugin(pl, morePassedToInit) {
         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,
         ...morePassedToInit
+    })).catch(async (e) => {
+        // failed initialization must not leave any partially allocated plugin resources active
+        await cleanup().catch(console.error);
+        await onInitError?.();
+        throw e;
     });
     Object.assign(pl, typeof res === 'function' ? { unload: res } : res);
-    (0, misc_1.patchKey)(pl, 'unload', was => () => {
+    unload = pl.unload;
+    (0, misc_1.patchKey)(pl, 'unload', () => cleanup);
+    events_1.default.emit('pluginInitialized', pl);
+    return pl;
+    async function cleanup() {
         for (const x of timeouts)
             clearTimeout(x);
         for (const cb of undoEvents)
             cb();
-        if (typeof was === 'function')
-            return was(...arguments);
-    });
-    events_1.default.emit('pluginInitialized', pl);
-    return pl;
+        if (typeof unload === 'function')
+            return unload();
+    }
 }
 const pluginsMiddleware = async (ctx, next) => {
     const after = {};
@@ -286,7 +295,7 @@ const pluginsMiddleware = async (ctx, next) => {
             printError(id, e);
         }
     function printChange(id) {
-        if (id === exports.SERVER_CODE_ID || (lastStatus === ctx.status && lastBody === ctx.body))
+        if (id.startsWith(exports.SERVER_CODE_ID) || (lastStatus === ctx.status && lastBody === ctx.body))
             return;
         console.debug("Plugin changed response:", id);
         lastStatus = ctx.status;
@@ -382,34 +391,44 @@ class Plugin {
             console.log('Error unloading plugin', id, String(e));
         }
         await this.onUnload();
-        if (!reloading && id !== exports.SERVER_CODE_ID) // we already printed 'reloading'
+        if (!reloading && !id.startsWith(exports.SERVER_CODE_ID)) // we already printed 'reloading'
             console.log('Unloaded plugin', id);
         if (this.data)
             this.data.unload = undefined;
     }
 }
 exports.Plugin = Plugin;
-exports.SERVER_CODE_ID = '.'; // a name that will surely be not found among plugin folders
-const serverCode = (0, config_1.defineConfig)('server_code', '', async (script, { k }) => {
-    try {
-        (await serverCode.compiled())?.unload();
-    }
-    catch { }
-    const res = {};
-    try {
-        new Function('exports,require', script)(res, require); // parse
-        await initPlugin(res);
-        res.getCustomHtml = () => (0, misc_1.callable)(res.customHtml) || {};
-        return new Plugin(exports.SERVER_CODE_ID, '', res, lodash_1.default.noop);
-    }
-    catch (e) {
-        return console.error(k + ':', e.message || String(e));
-    }
+exports.SERVER_CODE_ID = '/'; // a name that will surely be not found among plugin folders
+let unloadServerCode = lodash_1.default.noop;
+(0, config_1.defineConfig)(misc_1.CFG.server_code, '').sub(async (text) => {
+    await unloadServerCode();
+    const asPlugins = await Promise.all((0, serverCode_1.parseServerCode)(text).map(async ({ name, code }, i) => {
+        const res = {};
+        try {
+            new Function('exports,require', code)(res, require); // parse
+            await initPlugin(res);
+            res.getCustomHtml = () => (0, misc_1.callable)(res.customHtml) || {};
+            // server-code sections can share or omit names, so include the index to keep internal plugin ids unique
+            return new Plugin(exports.SERVER_CODE_ID + i + ':' + name, '', res, lodash_1.default.noop);
+        }
+        catch (e) {
+            return console.error(name + ':', e.message || String(e));
+        }
+    }));
+    // server_code is a side-effect config, so keep its cleanup outside compiled()
+    unloadServerCode = () => Promise.all(asPlugins.map(p => {
+        try {
+            return p?.unload();
+        } // catch sync errors
+        catch (e) {
+            console.error(e);
+        }
+    })).catch(console.error);
 });
 function mapPlugins(cb, includeServerCode = true) {
     let i = 0;
     return Array.from(plugins).map(([plName, pl]) => {
-        if (!includeServerCode && plName === exports.SERVER_CODE_ID)
+        if (!includeServerCode && plName.startsWith(exports.SERVER_CODE_ID))
             return;
         try {
             return cb(pl, plName, i++);
@@ -421,7 +440,7 @@ function mapPlugins(cb, includeServerCode = true) {
 }
 function firstPlugin(cb, includeServerCode = true) {
     for (const [plName, pl] of plugins.entries()) {
-        if (!includeServerCode && plName === exports.SERVER_CODE_ID)
+        if (!includeServerCode && plName.startsWith(exports.SERVER_CODE_ID))
             continue;
         try {
             const ret = cb(pl, plName);
@@ -444,10 +463,10 @@ if (!(0, fs_1.existsSync)(exports.PATH))
     }
     catch { }
 exports.pluginsWatcher = (0, misc_1.watchDir)(exports.PATH, rescanAsap);
-exports.enablePlugins = (0, config_1.defineConfig)('enable_plugins', ['antibrute']);
+exports.enablePlugins = (0, config_1.defineConfig)(misc_1.CFG.enable_plugins, ['antibrute']);
 exports.enablePlugins.sub(rescanAsap);
 exports.suspendPlugins = (0, config_1.defineConfig)(misc_1.CFG.suspend_plugins, false);
-exports.pluginsConfig = (0, config_1.defineConfig)('plugins_config', {});
+exports.pluginsConfig = (0, config_1.defineConfig)(misc_1.CFG.plugins_config, {});
 exports.PLUGIN_MAIN_FILE = 'plugin.js';
 const pluginWatchers = new Map();
 async function rescan() {
@@ -607,7 +626,7 @@ function watchPlugin(id, path) {
                 async i18n(ctx) {
                     return (0, i18n_1.i18nFromTranslations)(await (0, lang_1.getLangData)(ctx), const_1.EMBEDDED_LANGUAGE);
                 },
-            });
+            }, unloadResources);
             const folder = (0, path_1.dirname)(module);
             const { sections, unwatch } = (0, customHtml_1.watchLoadCustomHtml)(folder);
             pluginData.getCustomHtml = () => Object.assign(Object.fromEntries(sections), (0, misc_1.callable)(pluginData.customHtml) || {});
@@ -615,10 +634,7 @@ function watchPlugin(id, path) {
             const plugin = new Plugin(id, folder, pluginData, async () => {
                 unwatchIcons();
                 unwatch();
-                for (const x of subbedConfigs)
-                    x();
-                await Promise.allSettled(openDbs.map(x => x.close()));
-                openDbs.length = 0;
+                await unloadResources();
             });
             pluginReady.resolve();
             if (alreadyRunning)
@@ -630,6 +646,12 @@ function watchPlugin(id, path) {
                 events_1.default.emit(wasInstalled ? 'pluginStarted' : 'pluginInstalled', plugin);
             }
             events_1.default.emit('pluginStarted:' + id);
+            async function unloadResources() {
+                for (const x of subbedConfigs)
+                    x();
+                await Promise.allSettled(openDbs.map(x => x.close()));
+                openDbs.length = 0;
+            }
         }
         catch (e) {
             await markItInactive();

package/src/selfCheck.js

@@ -24,7 +24,8 @@ async function selfCheck(url) {
     const prjInfo = await (0, github_1.getProjectInfo)();
     console.log(`Checking server ${url}`);
     const parsed = new URL(url);
-    const family = !(0, net_1.isIP)(parsed.hostname) ? undefined : (0, net_1.isIPv6)(parsed.hostname) ? 6 : 4;
+    const hostname = (0, cross_1.normalizeHost)(parsed.hostname);
+    const family = !(0, net_1.isIP)(hostname) ? undefined : (0, net_1.isIPv6)(hostname) ? 6 : 4;
     try {
         ++activeSelfChecks;
         for (const services of lodash_1.default.chunk(lodash_1.default.shuffle(prjInfo.selfCheckServices), 2)) {
@@ -38,7 +39,7 @@ async function selfCheck(url) {
                     console.debug(svc);
                     body = applySymbols(body);
                     serviceUrl = applySymbols(serviceUrl);
-                    const timeout = 8_000;
+                    const timeout = 9_000;
                     const res = await (0, cross_1.haveTimeout)(timeout, (0, util_http_1.httpString)(serviceUrl, { family, timeout, ...rest, body }));
                     const success = new RegExp(regexpSuccess).test(res);
                     const failure = new RegExp(regexpFailure).test(res);
@@ -60,7 +61,7 @@ async function selfCheck(url) {
         --activeSelfChecks;
     }
     function applySymbols(s) {
-        return s?.replace('$IP', parsed.hostname)
+        return s?.replace('$IP', hostname)
             .replace('$PORT', parsed.port || (parsed.protocol === 'https:' ? '443' : '80'))
             .replace('$URL', url.replace(/\/$/, '') + CHECK_URL);
     }

package/src/serveFile.js

@@ -25,7 +25,7 @@ const errorPages_1 = require("./errorPages");
 const stream_1 = require("stream");
 const crypto_1 = require("crypto");
 const iconv_lite_1 = __importDefault(require("iconv-lite"));
-const allowedReferer = (0, config_1.defineConfig)('allowed_referer', '');
+const allowedReferer = (0, config_1.defineConfig)(misc_1.CFG.allowed_referer, '');
 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);
@@ -66,13 +66,13 @@ async function serveFileNode(ctx, node) {
     if (await maxDownloadsPerAccount(ctx) === undefined) // returning false will not execute other limits
         await maxDownloads(ctx) || await maxDownloadsPerIp(ctx);
 }
-const mimeCfg = (0, config_1.defineConfig)('mime', {}, obj => {
+const mimeCfg = (0, config_1.defineConfig)(misc_1.CFG.mime, {}, obj => {
     const matchers = Object.keys(obj).map(k => (0, misc_1.makeMatcher)(k));
     const values = Object.values(obj);
     return (name) => values[matchers.findIndex(matcher => matcher(name))];
 });
 // 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)('cache_control_disk_files', 5);
+const cacheControlDiskFiles = (0, config_1.defineConfig)(misc_1.CFG.cache_control_disk_files, 5);
 async function serveFile(ctx, filePath, mime, cached) {
     if (!filePath)
         return;

package/src/serveGuiAndSharedFiles.js

@@ -11,7 +11,7 @@ const events_1 = __importDefault(require("./events"));
 const cross_const_1 = require("./cross-const");
 const upload_1 = require("./upload");
 const multipartUpload_1 = require("./multipartUpload");
-const events_2 = require("events");
+const promises_1 = require("stream/promises");
 const stream_1 = require("stream");
 const serveFile_1 = require("./serveFile");
 const const_1 = require("./const");
@@ -24,11 +24,12 @@ const misc_1 = require("./misc");
 const roots_1 = require("./roots");
 const xxhashjs_1 = __importDefault(require("xxhashjs"));
 const fs_1 = __importDefault(require("fs"));
-const promises_1 = require("fs/promises");
+const promises_2 = require("fs/promises");
 const comments_1 = require("./comments");
 const basicWeb_1 = require("./basicWeb");
 const icons_1 = require("./icons");
 const plugins_1 = require("./plugins");
+const uploadOwners_1 = require("./uploadOwners");
 const serveFrontendFiles = (0, serveGuiFiles_1.serveGuiFiles)(process.env.FRONTEND_PROXY, cross_const_1.FRONTEND_URI);
 const serveFrontendPrefixed = (0, koa_mount_1.default)(cross_const_1.FRONTEND_URI.slice(0, -1), serveFrontendFiles);
 const serveAdminFiles = (0, serveGuiFiles_1.serveGuiFiles)(process.env.ADMIN_PROXY, cross_const_1.ADMIN_URI);
@@ -70,7 +71,7 @@ const serveSharedFiles = async (ctx, next) => {
         const decPath = (0, misc_1.safeDecodeURIComponent)(path, '');
         const fn = (0, path_1.basename)(decPath);
         const folderUri = (0, misc_1.pathEncode)((0, path_1.dirname)(decPath)); // re-encode to get readable urls
-        const folder = await (0, vfs_1.urlToNode)(folderUri, ctx, vfs_1.vfs, true); // we don't require the folder to already exist, but to be mapped on disk AND to have proper permissions
+        const folder = await (0, vfs_1.urlToNode)(folderUri, ctx, vfs_1.vfs.compiled(), true); // we don't require the folder to already exist, but to be mapped on disk AND to have proper permissions
         if (!folder)
             return (0, errorPages_1.sendErrorPage)(ctx, cross_const_1.HTTP_NOT_FOUND);
         ctx.state.uploadPath = decPath;
@@ -110,8 +111,9 @@ const serveSharedFiles = async (ctx, next) => {
         try {
             if ((await events_1.default.emitAsync('deleting', { node, ctx }))?.isDefaultPrevented())
                 return ctx.status = cross_const_1.HTTP_FAILED_DEPENDENCY;
-            await (0, promises_1.rm)(source, { recursive: true });
+            await (0, promises_2.rm)(source, { recursive: true });
             await (0, misc_1.deleteStoredFileAttrs)(source);
+            (0, uploadOwners_1.deleteUploadOwner)(path);
             void (0, comments_1.setCommentFor)(source, ''); // necessary only to clean a possible descript.ion or kvstorage
             return ctx.status = cross_const_1.HTTP_OK;
         }
@@ -189,9 +191,8 @@ async function calcHash(fn, limit = Infinity) {
             done();
         }
     });
-    fs_1.default.createReadStream(fn, { end: limit - 1 }).pipe(stream);
     console.debug('Hashing', fn);
-    await (0, events_2.once)(stream, 'finish');
+    await (0, promises_1.pipeline)(fs_1.default.createReadStream(fn, { end: limit - 1 }), stream);
     console.debug('Hashed', fn);
     return hash.digest().toString(16);
 }

package/src/serveGuiFiles.js

@@ -104,6 +104,18 @@ async function treatIndex(ctx, filesUri, body) {
     })));
     const timestamp = await getFaviconTimestamp();
     const lang = await (0, lang_1.getLangData)(ctx);
+    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);
+        if (!js?.length)
+            return;
+        if (p.afterPlugin) // an afterPlugin constraint needs a loading barrier before this plugin's scripts
+            group++;
+        const ret = { id, group, js };
+        if (p.beforePlugin) // a beforePlugin constraint creates a loading barrier after this plugin's scripts
+            group++;
+        return ret;
+    }));
     return body
         .replace(/((?:src|href) *= *['"])\/?(?!([a-z]+:\/)?\/)(?!\?)/g, '$1' + ctx.state.revProxyPath + filesUri)
         .replace(/<(\/)?(head|body)>/g, (all, isClose, name) => {
@@ -120,7 +132,7 @@ async function treatIndex(ctx, filesUri, body) {
                 pathSeparator: path_1.sep,
                 session: session instanceof apiMiddleware_1.ApiError ? null : session,
                 plugins,
-                loadScripts: Object.fromEntries((0, plugins_1.mapPlugins)((p, id) => [id, p.frontend_js?.map(f => f.includes('//') ? f : pub + id + '/' + f)])),
+                loadScripts,
                 prefixUrl: ctx.state.revProxyPath || '',
                 proxyDetected: Boolean((0, middlewares_1.getProxyDetected)()),
                 dontOverwriteUploading: upload_1.dontOverwriteUploading.get(),

package/src/serverCode.js

@@ -0,0 +1,27 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SERVER_CODE_SPLIT = void 0;
+exports.parseServerCode = parseServerCode;
+const lodash_1 = __importDefault(require("lodash"));
+const cross_1 = require("./cross");
+exports.SERVER_CODE_SPLIT = '//---';
+function parseServerCode(text) {
+    const split = text.split(new RegExp('(?:^|\n)' + lodash_1.default.escapeRegExp(exports.SERVER_CODE_SPLIT), 'g'));
+    const ret = [];
+    let first = true;
+    for (const part of split)
+        if (first) { // first is special, no name
+            first = false;
+            const code = part.trim();
+            if (code)
+                ret.push({ name: '', code });
+        }
+        else {
+            const [name, code] = (0, cross_1.splitAt)('\n', part);
+            ret.push({ name, code });
+        }
+    return ret;
+}

package/src/throttler.js

@@ -15,11 +15,11 @@ const lodash_1 = __importDefault(require("lodash"));
 const events_1 = __importDefault(require("./events"));
 const persistence_1 = require("./persistence");
 const mainThrottleGroup = new ThrottledStream_1.ThrottleGroup(Infinity);
-(0, config_1.defineConfig)('max_kbps', Infinity).sub(v => mainThrottleGroup.updateLimit(v));
+(0, config_1.defineConfig)(misc_1.CFG.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 maxKbpsPerIp = (0, config_1.defineConfig)(misc_1.CFG.max_kbps_per_ip, Infinity);
 maxKbpsPerIp.sub(v => {
     for (const [ip, { group }] of Object.entries(ip2group))
         if (ip) // empty-string = unlimited group
@@ -71,6 +71,7 @@ const throttler = async (ctx, next) => {
         delete ip2group[ctx.ip];
     });
     ctx.state.originalStream = body;
+    body.on('error', e => ts.destroy(e)); // pipe doesn't forward source errors, so make Koa's response stream report them
     ctx.body = body.pipe(ts);
     if (downloadTotal !== undefined) // undefined will break SSE
         ctx.response.length = downloadTotal; // preserve this info

package/src/update.js

@@ -28,8 +28,8 @@ const persistence_1 = require("./persistence");
 const lodash_1 = __importDefault(require("lodash"));
 const argv_1 = require("./argv");
 const promises_2 = require("stream/promises");
-const updateToBeta = (0, config_1.defineConfig)('update_to_beta', false);
-const autoCheckUpdate = (0, config_1.defineConfig)('auto_check_update', true);
+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);
 const AUTO_CHECK_EVERY = misc_1.DAY;
 exports.autoCheckUpdateResult = persistence_1.storedMap.singleSync('autoCheckUpdateResult', undefined);
@@ -162,7 +162,13 @@ async function update(tagOrUrl = '') {
     } while ((0, fs_1.existsSync)((0, path_1.join)(binPath, newBinFile)));
     plugins_1.pluginsWatcher.pause();
     try {
-        await (0, misc_1.unzip)((0, fs_1.createReadStream)(LOCAL_UPDATE), path => (0, path_1.join)(binPath, path === binFile ? newBinFile : path));
+        try {
+            await (0, misc_1.unzip)((0, fs_1.createReadStream)(LOCAL_UPDATE), path => (0, path_1.join)(binPath, path === binFile ? newBinFile : path));
+        }
+        catch (e) {
+            await (0, promises_1.rename)(LOCAL_UPDATE, 'hfs-update-bad.zip'); // quarantine failed archives so they don't take precedence over future downloads
+            throw e;
+        }
         const newBin = (0, path_1.join)(binPath, newBinFile);
         if (!(0, fs_1.existsSync)(newBin)) {
             if (url) // the file was downloaded, and the UI would show the "update from local file" button until we remove it

package/src/upload.js

@@ -23,10 +23,15 @@ const events_1 = __importDefault(require("./events"));
 const promises_1 = require("fs/promises");
 const expiringCache_1 = require("./expiringCache");
 const first_1 = require("./first");
-exports.deleteUnfinishedUploadsAfter = (0, config_1.defineConfig)('delete_unfinished_uploads_after', 86_400);
-exports.minAvailableMb = (0, config_1.defineConfig)('min_available_mb', 100);
-exports.dontOverwriteUploading = (0, config_1.defineConfig)('dont_overwrite_uploading', true);
+const uploadOwners_1 = require("./uploadOwners");
+exports.deleteUnfinishedUploadsAfter = (0, config_1.defineConfig)(misc_1.CFG.delete_unfinished_uploads_after, 86_400);
+exports.minAvailableMb = (0, config_1.defineConfig)(misc_1.CFG.min_available_mb, 100);
+exports.dontOverwriteUploading = (0, config_1.defineConfig)(misc_1.CFG.dont_overwrite_uploading, true);
 const waitingToBeDeleted = {};
+function cancelDeletion(path) {
+    clearTimeout(waitingToBeDeleted[path]?.timeout);
+    delete waitingToBeDeleted[path];
+}
 (0, first_1.onProcessExit)(() => {
     if (!Object.keys(waitingToBeDeleted).length)
         return;
@@ -48,7 +53,7 @@ function setUploadMeta(path, ctx) {
     });
 }
 function getUploadTempFor(fullPath) {
-    return (0, path_1.join)((0, path_1.dirname)(fullPath), 'hfs$upload-' + (0, path_1.basename)(fullPath).slice(-200));
+    return (0, path_1.join)((0, path_1.dirname)(fullPath), const_1.UPLOAD_TEMP_PREFIX + (0, path_1.basename)(fullPath).slice(-200));
 }
 const diskSpaceCache = (0, expiringCache_1.expiringCache)(3_000); // invalidate shortly
 const uploadingFiles = new Map();
@@ -105,6 +110,7 @@ function uploadWriter(base, baseUri, filename, ctx) {
             setUploadMeta(dir, ctx);
         // use temporary name while uploading
         const tempName = getUploadTempFor(fullPath);
+        const tempUri = (0, misc_1.enforceFinal)('/', baseUri) + (0, misc_1.pathEncode)((0, path_1.basename)(tempName));
         // try to catch errors early (sync): this is avoiding on chrome139 when uploading a big file (1GB) to get miss the error code and have to make a `simulate`
         try {
             fs_1.default.accessSync(tempName, fs_1.default.constants.W_OK);
@@ -130,8 +136,11 @@ function uploadWriter(base, baseUri, filename, ctx) {
                 return fail(const_1.HTTP_PRECONDITION_FAILED);
             }
         // append if resuming
-        if (!resume && stats)
+        if (!resume && stats) {
+            // a new upload discards the old resumable temp, so its owner grant must not survive
+            (0, uploadOwners_1.deleteUploadOwner)(tempUri);
             fs_1.default.unlinkSync(tempName);
+        }
         const writeStream = (0, misc_1.createStreamLimiter)(isNaN(contentLength) ? Infinity : contentLength);
         const fullSize = stillToWrite + resume;
         // allow plugins to mess with the write-stream, because the read-stream can be complicated in case of multipart
@@ -152,6 +161,9 @@ function uploadWriter(base, baseUri, filename, ctx) {
         const tracked = { ctx, got: 0, size: stillToWrite };
         uploadingFiles.set(fullPath, tracked);
         console.debug('Upload started');
+        let tempOwnerSet = false;
+        // ownership must be visible before a follow-up request can act on the unfinished file
+        ctx.req.once('aborted', setTempOwner);
         // the file stream doesn't have an event for data being written, so we use 'data' of its feeder, which happens before, so we postpone a bit, trying to have a fresher number
         writeStream.on('data', () => setTimeout(() => tracked.got = bytesGot()));
         const lockMiddleware = (0, misc_1.pendingPromise)(); // expose outside, to let know when all operations stopped
@@ -171,7 +183,8 @@ function uploadWriter(base, baseUri, filename, ctx) {
                     return (0, promises_1.rm)(tempName).catch(() => { });
                 if (ctx.isAborted()) { // in the very unlikely case the connection is interrupted between last-byte and here, we still consider it unfinished, as the client had no way to know, and will resume, but it would get an error if we finish the process
                     const sec = exports.deleteUnfinishedUploadsAfter.get();
-                    return lodash_1.default.isNumber(sec) && delayedDelete(tempName, sec);
+                    setTempOwner();
+                    return lodash_1.default.isNumber(sec) && delayedDelete(tempName, sec, tempUri);
                 }
                 if (isPartial) // we are supposed to leave the unfinished upload as it is, with its temp name
                     return ctx.status = const_1.HTTP_NO_CONTENT; // lockMiddleware contains an empty string, so we must take care of the status
@@ -194,6 +207,7 @@ function uploadWriter(base, baseUri, filename, ctx) {
                     () => (0, promises_1.rename)(tempName, dest).then(() => true, e => e?.code !== 'EBUSY' && Promise.reject(e)), { timeout: 10_000 });
                     if (!done)
                         throw 'EBUSY';
+                    (0, uploadOwners_1.deleteUploadOwner)(tempUri); // the temp URI no longer exists after rename; final ownership is recorded below
                     if (mtime) // so we use it to touch the file
                         await (0, promises_1.utimes)(dest, Date.now() / 1000, mtime / 1000);
                     cancelDeletion(tempName); // not necessary, as deletion's failure is silent, but still
@@ -202,6 +216,7 @@ function uploadWriter(base, baseUri, filename, ctx) {
                     if (ctx.query.comment)
                         void (0, comments_1.setCommentFor)(dest, String(ctx.query.comment));
                     obj.uri = (0, misc_1.enforceFinal)('/', baseUri) + (0, misc_1.pathEncode)((0, path_1.basename)(dest));
+                    await (0, uploadOwners_1.setUploadOwner)(obj.uri, ctx);
                     events_1.default.emit('uploadFinished', obj);
                     console.debug("Upload finished", dest);
                     if (resEvent)
@@ -245,6 +260,12 @@ function uploadWriter(base, baseUri, filename, ctx) {
         function bytesGot() {
             return fileStream.bytesWritten + fileStream.writableLength;
         }
+        function setTempOwner() {
+            if (tempOwnerSet)
+                return;
+            tempOwnerSet = true;
+            void (0, uploadOwners_1.setUploadOwner)(tempUri, ctx);
+        }
     }
     catch (e) {
         releaseFile();
@@ -259,21 +280,18 @@ function uploadWriter(base, baseUri, filename, ctx) {
         overwriteRequestedButForbidden = true;
         return false;
     }
-    function delayedDelete(path, secs) {
+    function delayedDelete(path, secs, tempUri) {
         clearTimeout(waitingToBeDeleted[path]?.timeout);
         return waitingToBeDeleted[path] = {
             mtime,
             expires: Date.now() + secs * 1000,
             timeout: setTimeout(() => {
                 delete waitingToBeDeleted[path];
+                (0, uploadOwners_1.deleteUploadOwner)(tempUri);
                 (0, promises_1.rm)(path).catch(() => { });
             }, secs * 1000)
         };
     }
-    function cancelDeletion(path) {
-        clearTimeout(waitingToBeDeleted[path]?.timeout);
-        delete waitingToBeDeleted[path];
-    }
     function releaseFile() {
         uploadingFiles.delete(fullPath);
     }