hfs 0.57.26 → 0.57.27-beta2

package/src/stat.js

@@ -0,0 +1,40 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getStatWorker = getStatWorker;
+const node_worker_threads_1 = require("node:worker_threads");
+const node_fs_1 = require("node:fs");
+const cross_1 = require("./cross");
+// all stat requests for the same worker are serialized, potentially introducing extra latency
+const pool = new Map();
+function getStatWorker(key) {
+    const existing = pool.get(key);
+    if (existing)
+        return existing;
+    const worker = new node_worker_threads_1.Worker(__dirname + '/statWorker.js');
+    worker.unref();
+    const requests = new Map();
+    worker.on('message', (msg) => {
+        const k = msg.path;
+        requests.get(k)?.resolve(msg.error ? Promise.reject(new Error(msg.error))
+            : Object.setPrototypeOf(msg.result, node_fs_1.Stats.prototype));
+        requests.delete(k);
+    });
+    worker.on('error', (err) => {
+        for (const p of requests.values())
+            p.reject(err);
+        requests.clear();
+        worker.terminate().catch(() => { });
+        pool.delete(key);
+    });
+    pool.set(key, query);
+    return query;
+    function query(path) {
+        const was = requests.get(path);
+        if (was)
+            return was;
+        const ret = (0, cross_1.pendingPromise)();
+        requests.set(path, ret);
+        worker.postMessage(path);
+        return ret;
+    }
+}

package/src/statWorker.js

@@ -0,0 +1,11 @@
+"use strict";
+const { parentPort } = require('node:worker_threads');
+const { statSync } = require('node:fs');
+parentPort.on('message', async (path) => {
+    try { // we use statSync to not use (and not risk to saturate) libuv's thread pool
+        parentPort.postMessage({ path, result: { ...statSync(path) } });
+    }
+    catch (err) {
+        parentPort.postMessage({ path, error: err?.message || String(err) });
+    }
+});

package/src/throttler.js

@@ -26,8 +26,6 @@ maxKbpsPerIp.sub(v => {
             group.updateLimit(v);
 });
 const throttler = async (ctx, next) => {
-    var _a;
-    var _b;
     await next();
     let { body } = ctx;
     const downloadTotal = ctx.response.length;
@@ -36,11 +34,11 @@ const throttler = async (ctx, next) => {
     if (!body || !(body instanceof stream_1.Readable))
         return;
     // we wrap the stream also for unlimited connections to get speed and other features
-    const noLimit = ((_a = ctx.state.account) === null || _a === void 0 ? void 0 : _a.ignore_limits) || (0, misc_1.isLocalHost)(ctx);
-    const ipGroup = ip2group[_b = noLimit ? '' : ctx.ip] || (ip2group[_b] = {
+    const noLimit = ctx.state.account?.ignore_limits || (0, misc_1.isLocalHost)(ctx);
+    const ipGroup = ip2group[noLimit ? '' : ctx.ip] ||= {
         count: 0,
         group: new ThrottledStream_1.ThrottleGroup(noLimit ? Infinity : maxKbpsPerIp.get(), noLimit ? undefined : mainThrottleGroup),
-    });
+    };
     const conn = (0, connections_1.getConnection)(ctx);
     if (!conn)
         throw 'assert throttler connection';
@@ -95,12 +93,12 @@ setInterval(() => {
     last = now;
     {
         const v = exports.totalSent.get();
-        exports.totalOutSpeed = roundSpeed((v - (lastSent !== null && lastSent !== void 0 ? lastSent : v)) / past);
+        exports.totalOutSpeed = roundSpeed((v - (lastSent ?? v)) / past);
         lastSent = v;
     }
     {
         const v = exports.totalGot.get();
-        exports.totalInSpeed = roundSpeed((v - (lastGot !== null && lastGot !== void 0 ? lastGot : v)) / past);
+        exports.totalInSpeed = roundSpeed((v - (lastGot ?? v)) / past);
         lastGot = v;
     }
 }, 1000);

package/src/update.js

@@ -52,7 +52,7 @@ setInterval((0, misc_1.debounceAsync)(async () => {
         exports.autoCheckUpdateResult.set(u);
         lastCheckUpdate.set(Date.now());
     }
-    catch (_a) { }
+    catch { }
 }), misc_1.HOUR);
 const ReleaseKeys = ['prerelease', 'tag_name', 'name', 'body', 'assets', 'isNewer', 'versionScalar'];
 const ReleaseAssetKeys = ['name', 'browser_download_url'];
@@ -75,7 +75,7 @@ async function getVersions(interrupt) {
         const rel = prepareRelease(x);
         if (rel.versionScalar === curV)
             continue;
-        if (interrupt === null || interrupt === void 0 ? void 0 : interrupt(rel))
+        if (interrupt?.(rel))
             break; // avoid fetching too much data
         ret.push(rel);
     }
@@ -154,7 +154,7 @@ async function update(tagOrUrl = '') {
             const { mode } = await (0, misc_1.statWithTimeout)(bin);
             await (0, promises_1.chmod)(newBin, mode).catch(console.error);
         }
-        await (0, promises_1.rename)(INSTALLED_FN, PREVIOUS_FN).catch(e => (e === null || e === void 0 ? void 0 : e.code) !== 'ENOENT' && console.warn(String(e)));
+        await (0, promises_1.rename)(INSTALLED_FN, PREVIOUS_FN).catch(e => e?.code !== 'ENOENT' && console.warn(String(e)));
         await (0, promises_1.rename)(LOCAL_UPDATE, INSTALLED_FN).catch(console.warn);
         (0, first_1.onProcessExit)(() => {
             const oldBinFile = 'old-' + binFile;
@@ -162,7 +162,7 @@ async function update(tagOrUrl = '') {
             try {
                 (0, fs_1.unlinkSync)(oldBin);
             }
-            catch (_a) { }
+            catch { }
             (0, fs_1.renameSync)(bin, oldBin);
             console.log("launching new version in background", newBinFile);
             launch(newBin, ['--updating', binFile, '--cwd .'], { sync: true }); // sync necessary to work on Mac by double-click
@@ -172,11 +172,11 @@ async function update(tagOrUrl = '') {
     }
     catch (e) {
         plugins_1.pluginsWatcher.unpause();
-        throw (e === null || e === void 0 ? void 0 : e.message) || String(e);
+        throw e?.message || String(e);
     }
 }
 function launch(cmd, pars = [], options) {
-    return ((options === null || options === void 0 ? void 0 : options.sync) ? child_process_1.spawnSync : child_process_1.spawn)((0, util_os_1.cmdEscape)(cmd), pars, { detached: true, shell: true, stdio: [0, 1, 2], ...options });
+    return (options?.sync ? child_process_1.spawnSync : child_process_1.spawn)((0, util_os_1.cmdEscape)(cmd), pars, { detached: true, shell: true, stdio: [0, 1, 2], ...options });
 }
 if (argv_1.argv.updating) { // we were launched with a temporary name, restore original name to avoid breaking references
     const bin = process.execPath;
@@ -195,7 +195,7 @@ if (argv_1.argv.updating) { // we were launched with a temporary name, restore o
         try {
             (0, fs_1.writeFileSync)(const_1.ARGS_FILE, JSON.stringify(['--updated', '--cwd', process.cwd().replaceAll(' ', '\\ ')]));
         }
-        catch (_a) { }
+        catch { }
         void (0, open_1.default)(dest);
     }
     process.exit();

package/src/upload.js

@@ -23,7 +23,7 @@ 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', 86400);
+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 waitingToBeDeleted = {};
@@ -35,7 +35,7 @@ const waitingToBeDeleted = {};
         try {
             fs_1.default.rmSync(path, { force: true });
         }
-        catch (_a) { }
+        catch { }
 });
 const ATTR_UPLOADER = 'uploader';
 function getUploadMeta(path) {
@@ -50,11 +50,11 @@ 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));
 }
-const diskSpaceCache = (0, expiringCache_1.expiringCache)(3000); // invalidate shortly
+const diskSpaceCache = (0, expiringCache_1.expiringCache)(3_000); // invalidate shortly
 const uploadingFiles = new Map();
 // stay sync because we use this function with formidable()
 function uploadWriter(base, baseUri, path, ctx) {
-    if ((0, misc_1.dirTraversal)(path))
+    if ((0, misc_1.hasDirTraversal)(path))
         return fail(const_1.HTTP_FOOL);
     if ((0, vfs_1.statusCodeForMissingPerm)(base, 'can_upload', ctx))
         return fail();
@@ -77,7 +77,7 @@ function uploadWriter(base, baseUri, path, ctx) {
         try {
             // refer to the source of the closest node that actually belongs to the vfs, so that cache is more effective
             let closestVfsNode = base; // if base=root, there's no parent and no original
-            while ((closestVfsNode === null || closestVfsNode === void 0 ? void 0 : closestVfsNode.parent) && !closestVfsNode.original)
+            while (closestVfsNode?.parent && !closestVfsNode.original)
                 closestVfsNode = closestVfsNode.parent; // if it's not original, it surely has a parent
             const dirToCheck = closestVfsNode.source;
             const res = diskSpaceCache.try(dirToCheck, () => (0, util_os_1.getDiskSpaceSync)(dirToCheck));
@@ -108,7 +108,7 @@ function uploadWriter(base, baseUri, path, ctx) {
         try {
             fs_1.default.accessSync(tempName, fs_1.default.constants.W_OK);
         }
-        catch (_a) {
+        catch {
             try {
                 fs_1.default.closeSync(fs_1.default.openSync(tempName, 'w'));
                 fs_1.default.unlinkSync(tempName);
@@ -118,7 +118,7 @@ function uploadWriter(base, baseUri, path, ctx) {
             }
         }
         const stats = (0, misc_1.try_)(() => fs_1.default.statSync(tempName));
-        const resumableSize = (stats === null || stats === void 0 ? void 0 : stats.size) || 0;
+        const resumableSize = stats?.size || 0;
         // checks for resume feature
         const par = String(ctx.query.resume || '');
         const resume = parseInt(par) || 0;
@@ -136,13 +136,13 @@ function uploadWriter(base, baseUri, path, ctx) {
         // append if resuming
         if (!resume && stats)
             fs_1.default.unlinkSync(tempName);
-        const writeStream = (0, misc_1.createStreamLimiter)(contentLength !== null && contentLength !== void 0 ? contentLength : Infinity);
+        const writeStream = (0, misc_1.createStreamLimiter)(contentLength ?? Infinity);
         const fullSize = stillToWrite + resume;
         ctx.state.uploadDestinationPath = tempName;
         // allow plugins to mess with the write-stream, because the read-stream can be complicated in case of multipart
         const obj = { ctx, writeStream, fullPath, tempName, resume, fullSize, uri: '' };
         const resEvent = events_1.default.emit('uploadStart', obj);
-        if (resEvent === null || resEvent === void 0 ? void 0 : resEvent.isDefaultPrevented())
+        if (resEvent?.isDefaultPrevented())
             return;
         const fileStream = fs_1.default.createWriteStream(tempName, resume ? { flags: 'r+', start: resume } : undefined);
         writeStream.on('error', e => {
@@ -256,8 +256,7 @@ function uploadWriter(base, baseUri, path, ctx) {
         return false;
     }
     function delayedDelete(path, secs) {
-        var _a;
-        clearTimeout((_a = waitingToBeDeleted[path]) === null || _a === void 0 ? void 0 : _a.timeout);
+        clearTimeout(waitingToBeDeleted[path]?.timeout);
         return waitingToBeDeleted[path] = {
             mtime,
             expires: Date.now() + secs * 1000,
@@ -268,8 +267,7 @@ function uploadWriter(base, baseUri, path, ctx) {
         };
     }
     function cancelDeletion(path) {
-        var _a;
-        clearTimeout((_a = waitingToBeDeleted[path]) === null || _a === void 0 ? void 0 : _a.timeout);
+        clearTimeout(waitingToBeDeleted[path]?.timeout);
         delete waitingToBeDeleted[path];
     }
     function releaseFile() {

package/src/util-files.js

@@ -7,18 +7,18 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.parseFileCache = void 0;
 exports.statWithTimeout = statWithTimeout;
 exports.isDirectory = isDirectory;
-exports.readFileBusy = readFileBusy;
+exports.readFileWithBusyRetry = readFileWithBusyRetry;
 exports.watchDir = watchDir;
-exports.dirTraversal = dirTraversal;
-exports.adjustStaticPathForGlob = adjustStaticPathForGlob;
+exports.hasDirTraversal = hasDirTraversal;
+exports.escapeGlobPath = escapeGlobPath;
 exports.unzip = unzip;
-exports.prepareFolder = prepareFolder;
+exports.ensureParentFolder = ensureParentFolder;
 exports.createFileWithPath = createFileWithPath;
-exports.safeWriteStream = safeWriteStream;
+exports.createSafeWriteStream = createSafeWriteStream;
 exports.isValidFileName = isValidFileName;
 exports.exists = exists;
+exports.loadFileCached = loadFileCached;
 exports.parseFile = parseFile;
-exports.parseFileContent = parseFileContent;
 const promises_1 = require("fs/promises");
 const cross_1 = require("./cross");
 const config_1 = require("./config");
@@ -27,24 +27,34 @@ const path_1 = require("path");
 const fast_glob_1 = __importDefault(require("fast-glob"));
 const const_1 = require("./const");
 const events_1 = require("events");
+const stat_1 = require("./stat");
 // @ts-ignore
 const unzip_stream_1 = __importDefault(require("unzip-stream"));
 const fileTimeout = (0, config_1.defineConfig)('file_timeout', 3, x => x * 1000);
-function statWithTimeout(path) {
-    return (0, cross_1.haveTimeout)(fileTimeout.compiled(), (0, promises_1.stat)(path));
+// a smart (and a bit arbitrary) way to decide if we need the stat-workers functionality. Without it, we may be a bit faster. We'll see with experience if we need a dedicated configuration.
+const disableStatWorkers = Number(process.env.UV_THREADPOOL_SIZE) >= 10;
+// some paths (mostly offline networked ones) can take 20+ seconds to fail
+async function statWithTimeout(path) {
+    // with just 4 requests we saturate the default UV_THREADPOOL_SIZE, blocking even local fs operations, so we move all UNC requests to worker threads
+    const workerKey = !disableStatWorkers && const_1.IS_WINDOWS && getUncHost(path); // pool requests by server name
+    const op = workerKey ? (0, stat_1.getStatWorker)(workerKey)(path) : (0, promises_1.stat)(path);
+    return (0, cross_1.haveTimeout)(fileTimeout.compiled(), op);
+}
+function getUncHost(path) {
+    return /^\\\\([^\\]+)\\/.exec(path)?.[1];
 }
 async function isDirectory(path) {
     try {
         return (await statWithTimeout(path)).isDirectory();
     }
-    catch (_a) { }
+    catch { }
 }
-async function readFileBusy(path) {
+async function readFileWithBusyRetry(path) {
     return (0, promises_1.readFile)(path, 'utf8').catch(e => {
-        if ((e === null || e === void 0 ? void 0 : e.code) !== 'EBUSY')
+        if (e?.code !== 'EBUSY')
             throw e;
         console.debug('busy');
-        return (0, cross_1.wait)(100).then(() => readFileBusy(path));
+        return (0, cross_1.wait)(100).then(() => readFileWithBusyRetry(path));
     });
 }
 function watchDir(dir, cb, atStart = false) {
@@ -53,7 +63,7 @@ function watchDir(dir, cb, atStart = false) {
     try {
         watcher = (0, fs_1.watch)(dir, controlledCb);
     }
-    catch (_a) {
+    catch {
         // failing watching the content of the dir, we try to monitor its parent, but filtering events only for our target dir
         const base = (0, path_1.basename)(dir);
         try {
@@ -64,7 +74,7 @@ function watchDir(dir, cb, atStart = false) {
                     watcher.close(); // if we succeed, we give up the parent watching
                     watcher = (0, fs_1.watch)(dir, controlledCb); // attempt at passing to a more specific watching
                 }
-                catch (_a) { }
+                catch { }
                 controlledCb();
             });
         }
@@ -76,7 +86,7 @@ function watchDir(dir, cb, atStart = false) {
         controlledCb();
     return {
         working() { return Boolean(watcher); },
-        stop() { watcher === null || watcher === void 0 ? void 0 : watcher.close(); },
+        stop() { watcher?.close(); },
         pause() { paused = true; },
         unpause() { paused = false; },
     };
@@ -85,29 +95,29 @@ function watchDir(dir, cb, atStart = false) {
             cb();
     }
 }
-function dirTraversal(s) {
+function hasDirTraversal(s) {
     return s && /(^|[/\\])\.\.($|[/\\])/.test(s);
 }
 // apply this to paths that may contain \ as separator (not supported by fast-glob) and other special chars to be escaped (parenthesis)
-function adjustStaticPathForGlob(path) {
+function escapeGlobPath(path) {
     return fast_glob_1.default.escapePath(path.replace(/\\/g, '/'));
 }
 async function unzip(stream, cb) {
-    let pending = Promise.resolve();
+    let chain = Promise.resolve();
     return new Promise((resolve, reject) => stream.pipe(unzip_stream_1.default.Parse())
-        .on('end', () => pending.then(resolve))
+        .on('end', () => chain.then(resolve))
         .on('error', reject)
-        .on('entry', (entry) => pending = pending.then(async () => {
+        .on('entry', (entry) => chain = chain.then(async () => {
         const { path, type } = entry;
         const dest = await (0, cross_1.try_)(() => cb(path), e => console.warn(String(e)));
         if (!dest || type !== 'File')
             return entry.autodrain();
         console.debug('unzip', dest);
-        const thisFile = entry.pipe(await safeWriteStream(dest));
+        const thisFile = entry.pipe(await createSafeWriteStream(dest));
         await (0, events_1.once)(thisFile, 'finish');
     })));
 }
-async function prepareFolder(path, dirnameIt = true) {
+async function ensureParentFolder(path, dirnameIt = true) {
     if (dirnameIt)
         path = (0, path_1.dirname)(path);
     if ((0, cross_1.isWindowsDrive)(path))
@@ -116,7 +126,7 @@ async function prepareFolder(path, dirnameIt = true) {
         await (0, promises_1.mkdir)(path, { recursive: true });
         return true;
     }
-    catch (_a) {
+    catch {
         return false;
     }
 }
@@ -126,13 +136,13 @@ function createFileWithPath(path, options) {
         try {
             (0, fs_1.mkdirSync)(folder, { recursive: true });
         }
-        catch (_a) {
+        catch {
             return;
         }
     return (0, fs_1.createWriteStream)(path, options);
 }
-async function safeWriteStream(path, options) {
-    await prepareFolder(path);
+async function createSafeWriteStream(path, options) {
+    await ensureParentFolder(path);
     return new Promise((resolve, reject) => {
         const first = (0, fs_1.createWriteStream)(path, options)
             .on('open', () => resolve(first))
@@ -142,7 +152,7 @@ async function safeWriteStream(path, options) {
             if (typeof options === 'string')
                 options = { encoding: options };
             else
-                options || (options = {});
+                options ||= {};
             if (options.flags && options.flags !== 'w') // we only handle the 'w' case
                 return reject(e);
             options.flags = 'r+';
@@ -153,22 +163,22 @@ async function safeWriteStream(path, options) {
     });
 }
 function isValidFileName(name) {
-    return !(const_1.IS_WINDOWS ? /[/:"*?<>|\\]/ : /\//).test(name) && !dirTraversal(name);
+    return !(const_1.IS_WINDOWS ? /[/:"*?<>|\\]/ : /\//).test(name) && !hasDirTraversal(name);
 }
 function exists(path) {
     return (0, promises_1.access)(path).then(() => true, () => false);
 }
 // parse a file, caching unless timestamp has changed
 exports.parseFileCache = new Map();
-async function parseFile(path, parse) {
+async function loadFileCached(path, loader) {
     const { mtime: ts } = await statWithTimeout(path);
     const cached = exports.parseFileCache.get(path);
     if (cached && Number(ts) === Number(cached.ts))
         return cached.parsed;
-    const parsed = parse(path);
+    const parsed = loader(path);
     exports.parseFileCache.set(path, { ts, parsed });
     return parsed;
 }
-async function parseFileContent(path, parse) {
-    return parseFile(path, () => (0, promises_1.readFile)(path).then(parse));
+async function parseFile(path, parse) {
+    return loadFileCached(path, () => (0, promises_1.readFile)(path).then(parse));
 }

package/src/util-http.js

@@ -49,6 +49,8 @@ const lodash_1 = __importDefault(require("lodash"));
 const consumers_1 = require("node:stream/consumers");
 Object.defineProperty(exports, "stream2string", { enumerable: true, get: function () { return consumers_1.text; } });
 const tls = __importStar(require("node:tls"));
+const cross_1 = require("./cross");
+const events_1 = require("events");
 async function httpString(url, options) {
     return await (0, consumers_1.text)(await httpStream(url, options));
 }
@@ -60,22 +62,20 @@ async function httpWithBody(url, options) {
     });
 }
 function httpStream(url, { body, proxy, jar, noRedirect, httpThrow = true, ...options } = {}) {
-    var _a;
     const controller = new AbortController();
-    (_a = options.signal) !== null && _a !== void 0 ? _a : (options.signal = controller.signal);
-    return Object.assign(new Promise(async (resolve, reject) => {
-        var _a, _b, _c, _d;
-        var _e, _f, _g;
-        proxy !== null && proxy !== void 0 ? proxy : (proxy = httpStream.defaultProxy);
-        (_a = options.headers) !== null && _a !== void 0 ? _a : (options.headers = {});
+    options.signal ??= controller.signal;
+    let ret;
+    return Object.assign(ret = new Promise(async (resolve, reject) => {
+        proxy ??= httpStream.defaultProxy;
+        options.headers ??= {};
         if (body) {
-            options.method || (options.method = 'POST');
+            options.method ||= 'POST';
             if (lodash_1.default.isPlainObject(body)) {
-                (_b = (_e = options.headers)['content-type']) !== null && _b !== void 0 ? _b : (_e['content-type'] = 'application/json');
+                options.headers['content-type'] ??= 'application/json';
                 body = JSON.stringify(body);
             }
             if (!(body instanceof node_stream_1.Readable))
-                (_c = (_f = options.headers)['content-length']) !== null && _c !== void 0 ? _c : (_f['content-length'] = Buffer.byteLength(body));
+                options.headers['content-length'] ??= Buffer.byteLength(body);
         }
         if (jar)
             options.headers.cookie = lodash_1.default.map(jar, (v, k) => `${k}=${v}; `).join('')
@@ -90,17 +90,16 @@ function httpStream(url, { body, proxy, jar, noRedirect, httpThrow = true, ...op
         }
         if (proxy) {
             options.path = url; // full url as path
-            (_d = (_g = options.headers).host) !== null && _d !== void 0 ? _d : (_g.host = (0, node_url_1.parse)(url).host || undefined); // keep original host header
+            options.headers.host ??= (0, node_url_1.parse)(url).host || undefined; // keep original host header
+            options.headers.Connection = 'keep-alive'; // try to reuse connections
         }
         // this needs the prefix "proxy-"
-        const proxyAuth = (proxyParsed === null || proxyParsed === void 0 ? void 0 : proxyParsed.auth) ? { 'proxy-authorization': `Basic ${Buffer.from(proxyParsed.auth, 'utf8').toString('base64')}` } : undefined;
+        const proxyAuth = proxyParsed?.auth ? { 'proxy-authorization': `Basic ${Buffer.from(proxyParsed.auth, 'utf8').toString('base64')}` } : undefined;
         // https through proxy is better with CONNECT
         if (!proxy || parsed.protocol === 'http:' || !await connect())
             Object.assign(options.headers, proxyAuth);
         const proto = options.protocol === 'https:' ? node_https_1.default : node_http_1.default;
         const req = proto.request(options, res => {
-            var _a;
-            var _b;
             console.debug("http responded", res.statusCode, "to", url);
             if (jar)
                 for (const entry of res.headers['set-cookie'] || []) {
@@ -117,43 +116,95 @@ function httpStream(url, { body, proxy, jar, noRedirect, httpThrow = true, ...op
             let r = res.headers.location;
             if (r && !noRedirect) {
                 r = new URL(r, url).toString(); // rewrite in case r is just a path, and thus relative to current url
-                const stack = ((_b = options)._stack || (_b._stack = []));
+                const stack = (options._stack ||= []);
                 if (stack.length > 20 || stack.includes(r))
-                    return reject(new Error('endless http redirection'));
+                    return reject(Error('endless http redirection'));
                 stack.push(r);
                 delete options.method; // redirections are always GET
-                (_a = options.headers) === null || _a === void 0 ? true : delete _a['content-length'];
+                delete options.headers?.['content-length'];
+                delete options.headers?.host;
                 delete options.auth;
+                delete options.path;
+                delete options.agent;
                 return resolve(httpStream(r, options));
             }
             resolve(res);
         }).on('error', (e) => {
-            if (proxy && (e === null || e === void 0 ? void 0 : e.code) === 'ECONNREFUSED')
-                console.debug("cannot connect to proxy ", proxy);
+            if (proxy && e?.code === 'ECONNREFUSED')
+                console.debug("cannot connect to proxy", proxy);
             reject(req.res || e);
         });
+        if (options.timeout)
+            req.setTimeout(options.timeout, () => req.destroy(Error('ETIMEDOUT')));
+        options.signal?.addEventListener('abort', () => req.destroy(Error('AbortError')), { once: true });
         if (body && body instanceof node_stream_1.Readable)
             body.pipe(req).on('end', () => req.end());
         else
             req.end(body);
-        function connect() {
-            return proxyParsed && new Promise(resolve => {
+        async function connect() {
+            if (!proxyParsed)
+                return;
+            options.agent = false; // disable default pooling, we manage reuse
+            const path = `${parsed.hostname}:${parsed.port || 443}`;
+            const k = proxy + path;
+            const pool = (proxySocketPools[k] ||= []);
+            const newProm = (0, cross_1.pendingPromise)();
+            async function handleNewProm(socket) {
+                options.createConnection = () => socket;
+                try {
+                    const response = await ret;
+                    await (0, events_1.once)(response, 'close'); // ensure the response is done before reusing the same socket
+                }
+                catch { }
+                newProm.resolve(socket); // when we are done with this request, resolve and pass the socket on
+            }
+            if (pool.length >= 4)
+                return seqRace = seqRace.then(async () => {
+                    try { // race tracking the index
+                        const [i, socket] = await Promise.race(pool.map((prom, i) => prom.then(socket => [i, socket])));
+                        pool[i] = socket.poolRef = newProm; // replacing ensures the pool reflects the current usage of open sockets
+                        handleNewProm(socket);
+                        return true;
+                    }
+                    catch (e) {
+                        newProm.catch(() => { }); // without this we get UnhandledPromiseRejection
+                        newProm.reject(e);
+                        return false;
+                    }
+                });
+            pool.push(newProm);
+            return new Promise(resolve => {
+                ;
                 (proxyParsed.protocol === 'https:' ? node_https_1.default : node_http_1.default).request({
                     ...proxyParsed,
+                    auth: undefined, // void proxyParsed.auth
                     method: 'CONNECT',
-                    path: `${parsed.hostname}:${parsed.port || 443}`,
-                    auth: undefined,
-                    headers: proxyAuth
-                }).on('error', reject).on('connect', (res, socket) => {
+                    path,
+                    headers: { Host: path, ...proxyAuth }
+                }).on('connect', (res, socket) => {
                     if (res.statusCode !== 200)
-                        return resolve(false);
-                    // a TLS for every request is inefficient. Consider optimizing in the future, especially for reading plugins from github, which makes tens of requests.
-                    options.createConnection = () => tls.connect({ socket, servername: parsed.hostname || undefined });
+                        return failed(res);
+                    console.debug("new connection to proxy for", path);
+                    const tlsSocket = Object.assign(tls.connect({ socket, servername: parsed.hostname || undefined }), { poolRef: newProm });
+                    tlsSocket.on('close', disconnected);
+                    tlsSocket.on('error', disconnected);
+                    handleNewProm(tlsSocket);
                     resolve(true);
-                }).end();
+                    function disconnected() {
+                        lodash_1.default.pull(pool, tlsSocket.poolRef); // the ref may have changed in time
+                    }
+                }).on('response', failed).on('error', failed).end();
+                function failed(e) {
+                    lodash_1.default.pull(pool, newProm);
+                    newProm.catch(() => { }); // without this we get UnhandledPromiseRejection
+                    newProm.reject(e);
+                    resolve(false);
+                }
             });
         }
     }), {
         abort() { controller.abort(); }
     });
 }
+const proxySocketPools = {};
+let seqRace = Promise.resolve(false);

package/src/util-os.js

@@ -48,13 +48,12 @@ async function getDiskSpaces() {
     return parseDfResult(await (0, util_1.promisify)(child_process_1.exec)(`df -k`, { timeout: DF_TIMEOUT }).then(x => x.stdout, e => e));
 }
 function parseDfResult(result) {
-    var _a;
     if (result instanceof Error) {
         const { status } = result;
         throw status === 1 ? Error('miss') : status === 127 ? Error('unsupported') : result;
     }
     const out = result.split('\n');
-    if (!((_a = out.shift()) === null || _a === void 0 ? void 0 : _a.startsWith('Filesystem')))
+    if (!out.shift()?.startsWith('Filesystem'))
         throw Error('unsupported');
     return (0, misc_1.onlyTruthy)(out.map(one => {
         const bits = one.split(/\s+/);
@@ -80,10 +79,9 @@ async function runCmd(cmd, args = [], options = {}) {
 }
 // returns pid-to-name object
 async function getWindowsServicePids() {
-    var _a;
     const res = await runCmd('tasklist /svc /fo csv');
     const parsed = new csv_1.default().parse(res);
-    const no = (_a = parsed === null || parsed === void 0 ? void 0 : parsed[1]) === null || _a === void 0 ? void 0 : _a[2];
+    const no = parsed?.[1]?.[2];
     return Object.fromEntries(parsed.slice(2).filter(x => x[2] !== no).map(x => [x[1], x[2]]));
 }
 exports.RUNNING_AS_SERVICE = const_1.IS_WINDOWS && getWindowsServicePids().then(x => {