hfs 0.26.8 → 0.27.2

package/src/adminApis.js

@@ -0,0 +1,169 @@
+"use strict";
+// This file is part of HFS - Copyright 2021-2023, Massimo Melina <a@rejetto.com> - License https://www.gnu.org/licenses/gpl-3.0.txt
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ctxAdminAccess = exports.localhostAdmin = exports.adminApis = void 0;
+const apiMiddleware_1 = require("./apiMiddleware");
+const config_1 = require("./config");
+const listen_1 = require("./listen");
+const const_1 = require("./const");
+const api_vfs_1 = __importDefault(require("./api.vfs"));
+const api_accounts_1 = __importDefault(require("./api.accounts"));
+const api_plugins_1 = __importDefault(require("./api.plugins"));
+const api_monitor_1 = __importDefault(require("./api.monitor"));
+const connections_1 = require("./connections");
+const misc_1 = require("./misc");
+const lodash_1 = __importDefault(require("lodash"));
+const events_1 = __importDefault(require("./events"));
+const perm_1 = require("./perm");
+const middlewares_1 = require("./middlewares");
+const promises_1 = require("fs/promises");
+const fs_1 = require("fs");
+const readline = __importStar(require("readline"));
+const log_1 = require("./log");
+const child_process_1 = require("child_process");
+const util_1 = require("util");
+exports.adminApis = {
+    ...api_vfs_1.default,
+    ...api_accounts_1.default,
+    ...api_plugins_1.default,
+    ...api_monitor_1.default,
+    async set_config({ values: v }) {
+        var _a, _b;
+        if (v) {
+            const st = (0, listen_1.getStatus)();
+            const noHttp = ((_a = v.port) !== null && _a !== void 0 ? _a : listen_1.portCfg.get()) < 0 || !st.httpSrv.listening;
+            const noHttps = ((_b = v.https_port) !== null && _b !== void 0 ? _b : listen_1.httpsPortCfg.get()) < 0 || !st.httpsSrv.listening;
+            if (noHttp && noHttps)
+                return new apiMiddleware_1.ApiError(const_1.HTTP_FORBIDDEN, "You cannot switch off both http and https ports");
+            await (0, config_1.setConfig)(v);
+        }
+        return {};
+    },
+    get_config: config_1.getWholeConfig,
+    async get_status() {
+        const st = (0, listen_1.getStatus)();
+        return {
+            started: const_1.HFS_STARTED,
+            build: const_1.BUILD_TIMESTAMP,
+            version: const_1.VERSION,
+            apiVersion: const_1.API_VERSION,
+            compatibleApiVersion: const_1.COMPATIBLE_API_VERSION,
+            http: await serverStatus(st.httpSrv, listen_1.portCfg.get()),
+            https: await serverStatus(st.httpsSrv, listen_1.httpsPortCfg.get()),
+            urls: (0, listen_1.getUrls)(),
+            proxyDetected: (0, middlewares_1.getProxyDetected)(),
+            frpDetected: exports.localhostAdmin.get() && !(0, middlewares_1.getProxyDetected)()
+                && (0, connections_1.getConnections)().every(misc_1.isLocalHost)
+                && await frpDebounced(),
+        };
+        async function serverStatus(h, configuredPort) {
+            var _a;
+            const busy = await h.busy;
+            await (0, misc_1.wait)(0); // simple trick to wait for also .error to be updated. If this trickery becomes necessary elsewhere, then we should make also error a Promise.
+            return {
+                ...lodash_1.default.pick(h, ['listening', 'error']),
+                busy,
+                port: ((_a = h === null || h === void 0 ? void 0 : h.address()) === null || _a === void 0 ? void 0 : _a.port) || configuredPort,
+            };
+        }
+    },
+    async save_pem({ cert, private_key, name = 'self' }) {
+        if (!cert || !private_key)
+            return new apiMiddleware_1.ApiError(const_1.HTTP_BAD_REQUEST);
+        const files = { cert: name + '.cert', private_key: name + '.key' };
+        await (0, promises_1.writeFile)(files.private_key, private_key);
+        await (0, promises_1.writeFile)(files.cert, cert);
+        return files;
+    },
+    async get_log({ file = 'log' }, ctx) {
+        return new apiMiddleware_1.SendListReadable({
+            bufferTime: 10,
+            doAtStart(list) {
+                const logger = log_1.loggers.find(l => l.name === file);
+                if (!logger)
+                    return list.error(const_1.HTTP_NOT_FOUND, true);
+                const input = (0, fs_1.createReadStream)(logger.path);
+                input.on('error', async (e) => {
+                    if (e.code === 'ENOENT') // ignore ENOENT, consider it an empty log
+                        return list.ready();
+                    list.error(e.code || e.message);
+                });
+                input.on('end', () => list.ready());
+                input.on('ready', () => {
+                    readline.createInterface({ input }).on('line', line => {
+                        if (ctx.aborted)
+                            return input.close();
+                        const obj = parse(line);
+                        if (obj)
+                            list.add(obj);
+                    }).on('close', () => {
+                        ctx.res.once('close', (0, misc_1.onOff)(events_1.default, {
+                            [logger.name](entry) {
+                                list.add(entry);
+                            }
+                        }));
+                    });
+                });
+            }
+        });
+        function parse(line) {
+            const m = /^(.+?) (.+?) (.+?) \[(.{11}):(.{14})] "(\w+) ([^"]+) HTTP\/\d.\d" (\d+) (-|\d+)/.exec(line);
+            if (!m)
+                return;
+            const [, ip, , user, date, time, method, uri, status, length] = m;
+            return {
+                ip,
+                user: user === '-' ? undefined : user,
+                ts: new Date(date + ' ' + time),
+                method,
+                uri,
+                status: Number(status),
+                length: length === '-' ? undefined : Number(length),
+            };
+        }
+    },
+};
+for (const k in exports.adminApis) {
+    const was = exports.adminApis[k];
+    exports.adminApis[k] = (params, ctx) => ctxAdminAccess(ctx) ? was(params, ctx)
+        : new apiMiddleware_1.ApiError(const_1.HTTP_UNAUTHORIZED);
+}
+exports.localhostAdmin = (0, config_1.defineConfig)('localhost_admin', true);
+function ctxAdminAccess(ctx) {
+    return !ctx.state.proxiedFor // we consider localhost_admin only if no proxy is detected
+        && exports.localhostAdmin.get() && (0, misc_1.isLocalHost)(ctx)
+        || (0, perm_1.getFromAccount)(ctx.state.account, a => a.admin);
+}
+exports.ctxAdminAccess = ctxAdminAccess;
+const frpDebounced = (0, misc_1.debounceAsync)(async () => {
+    if (!const_1.IS_WINDOWS)
+        return false;
+    const { stdout } = await (0, util_1.promisify)(child_process_1.execFile)('tasklist', ['/fi', 'imagename eq frpc.exe', '/nh']);
+    return stdout.includes('frpc');
+});

package/src/api.accounts.js

@@ -0,0 +1,59 @@
+"use strict";
+// This file is part of HFS - Copyright 2021-2023, Massimo Melina <a@rejetto.com> - License https://www.gnu.org/licenses/gpl-3.0.txt
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const api_helpers_1 = require("./api.helpers");
+const apiMiddleware_1 = require("./apiMiddleware");
+const perm_1 = require("./perm");
+const lodash_1 = __importDefault(require("lodash"));
+const const_1 = require("./const");
+function prepareAccount(ac) {
+    return ac && {
+        ...lodash_1.default.omit(ac, ['password', 'hashed_password', 'srp']),
+        username: ac.username,
+        hasPassword: (0, perm_1.accountHasPassword)(ac),
+        adminActualAccess: (0, perm_1.accountCanLoginAdmin)(ac),
+    };
+}
+const apis = {
+    get_usernames() {
+        return { list: Object.keys(perm_1.accountsConfig.get()) };
+    },
+    get_account({ username }, ctx) {
+        return prepareAccount((0, perm_1.getAccount)(username || (0, perm_1.getCurrentUsername)(ctx)))
+            || new apiMiddleware_1.ApiError(const_1.HTTP_NOT_FOUND);
+    },
+    get_accounts() {
+        return { list: Object.values(perm_1.accountsConfig.get()).map(prepareAccount) };
+    },
+    get_admins() {
+        return { list: lodash_1.default.filter(perm_1.accountsConfig.get(), perm_1.accountCanLoginAdmin).map(ac => ac.username) };
+    },
+    set_account({ username, changes }) {
+        const { admin } = changes;
+        if (admin === null)
+            changes.admin = undefined;
+        else if (admin !== undefined && typeof admin !== 'boolean')
+            return new apiMiddleware_1.ApiError(const_1.HTTP_BAD_REQUEST, "invalid admin");
+        const acc = (0, perm_1.setAccount)(username, changes);
+        return acc ? lodash_1.default.pick(acc, 'username') : new apiMiddleware_1.ApiError(const_1.HTTP_BAD_REQUEST);
+    },
+    add_account({ username, ...rest }) {
+        if ((0, perm_1.getAccount)(username))
+            return new apiMiddleware_1.ApiError(const_1.HTTP_FORBIDDEN);
+        const acc = (0, perm_1.addAccount)(username, rest);
+        return acc ? lodash_1.default.pick(acc, 'username') : new apiMiddleware_1.ApiError(const_1.HTTP_BAD_REQUEST);
+    },
+    del_account({ username }) {
+        return (0, perm_1.delAccount)(username) ? {} : new apiMiddleware_1.ApiError(const_1.HTTP_BAD_REQUEST);
+    },
+    async change_password_others({ username, newPassword }) {
+        return (0, api_helpers_1.changePasswordHelper)((0, perm_1.getAccount)(username), newPassword);
+    },
+    async change_srp_others({ username, salt, verifier }) {
+        return (0, api_helpers_1.changeSrpHelper)((0, perm_1.getAccount)(username), salt, verifier);
+    }
+};
+exports.default = apis;

package/src/api.auth.js

@@ -0,0 +1,128 @@
+"use strict";
+// This file is part of HFS - Copyright 2021-2023, Massimo Melina <a@rejetto.com> - License https://www.gnu.org/licenses/gpl-3.0.txt
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.change_srp = exports.change_password = exports.refresh_session = exports.logout = exports.loginSrp2 = exports.srpStep1 = exports.loginSrp1 = exports.login = void 0;
+const perm_1 = require("./perm");
+const crypt_1 = require("./crypt");
+const apiMiddleware_1 = require("./apiMiddleware");
+const tssrp6a_1 = require("tssrp6a");
+const const_1 = require("./const");
+const misc_1 = require("./misc");
+const api_helpers_1 = require("./api.helpers");
+const adminApis_1 = require("./adminApis");
+const middlewares_1 = require("./middlewares");
+const srp6aNimbusRoutines = new tssrp6a_1.SRPRoutines(new tssrp6a_1.SRPParameters());
+const ongoingLogins = {}; // store data that doesn't fit session object
+// centralized log-in state
+async function loggedIn(ctx, username) {
+    const s = ctx.session;
+    if (!s)
+        return ctx.throw(const_1.HTTP_SERVER_ERROR, 'session');
+    if (username === false) {
+        delete s.username;
+        ctx.cookies.set('csrf', '');
+        return;
+    }
+    s.username = (0, perm_1.normalizeUsername)(username);
+    await (0, middlewares_1.prepareState)(ctx, async () => { }); // updating the state is necessary to send complete session data so that frontend shows admin button
+    delete s.login;
+    ctx.cookies.set('csrf', (0, misc_1.randomId)(), { signed: false, httpOnly: false });
+}
+function makeExp() {
+    return { exp: new Date(Date.now() + const_1.SESSION_DURATION) };
+}
+const login = async ({ username, password }, ctx) => {
+    if (!username || !password) // some validation
+        return new apiMiddleware_1.ApiError(const_1.HTTP_BAD_REQUEST);
+    const acc = (0, perm_1.getAccount)(username);
+    if (!acc)
+        return new apiMiddleware_1.ApiError(const_1.HTTP_UNAUTHORIZED);
+    if (!acc.hashed_password)
+        return new apiMiddleware_1.ApiError(const_1.HTTP_NOT_ACCEPTABLE);
+    if (!await (0, crypt_1.verifyPassword)(acc.hashed_password, password))
+        return new apiMiddleware_1.ApiError(const_1.HTTP_UNAUTHORIZED);
+    if (!ctx.session)
+        return new apiMiddleware_1.ApiError(const_1.HTTP_SERVER_ERROR);
+    await loggedIn(ctx, username);
+    return { ...makeExp(), redirect: acc.redirect };
+};
+exports.login = login;
+const loginSrp1 = async ({ username }, ctx) => {
+    if (!username)
+        return new apiMiddleware_1.ApiError(const_1.HTTP_BAD_REQUEST);
+    const account = (0, perm_1.getAccount)(username);
+    if (!ctx.session)
+        return new apiMiddleware_1.ApiError(const_1.HTTP_SERVER_ERROR);
+    if (!account) // TODO simulate fake account to prevent knowing valid usernames
+        return new apiMiddleware_1.ApiError(const_1.HTTP_UNAUTHORIZED);
+    try {
+        const { step1, ...rest } = await srpStep1(account);
+        const sid = Math.random();
+        ongoingLogins[sid] = step1;
+        setTimeout(() => delete ongoingLogins[sid], 60000);
+        ctx.session.login = { username, sid };
+        return rest;
+    }
+    catch (code) {
+        return new apiMiddleware_1.ApiError(code);
+    }
+};
+exports.loginSrp1 = loginSrp1;
+async function srpStep1(account) {
+    if (!account.srp)
+        throw const_1.HTTP_NOT_ACCEPTABLE;
+    const [salt, verifier] = account.srp.split('|');
+    const srpSession = new tssrp6a_1.SRPServerSession(srp6aNimbusRoutines);
+    const step1 = await srpSession.step1(account.username, BigInt(salt), BigInt(verifier));
+    return { step1, salt, pubKey: String(step1.B) }; // cast to string cause bigint can't be jsonized
+}
+exports.srpStep1 = srpStep1;
+const loginSrp2 = async ({ pubKey, proof }, ctx) => {
+    var _a;
+    if (!ctx.session)
+        return new apiMiddleware_1.ApiError(const_1.HTTP_SERVER_ERROR);
+    if (!ctx.session.login)
+        return new apiMiddleware_1.ApiError(const_1.HTTP_CONFLICT);
+    const { username, sid } = ctx.session.login;
+    const step1 = ongoingLogins[sid];
+    try {
+        const M2 = await step1.step2(BigInt(pubKey), BigInt(proof));
+        await loggedIn(ctx, username);
+        return {
+            proof: String(M2),
+            redirect: (_a = ctx.state.account) === null || _a === void 0 ? void 0 : _a.redirect,
+            ...await (0, exports.refresh_session)({}, ctx)
+        };
+    }
+    catch (e) {
+        return new apiMiddleware_1.ApiError(const_1.HTTP_UNAUTHORIZED, String(e));
+    }
+    finally {
+        delete ongoingLogins[sid];
+    }
+};
+exports.loginSrp2 = loginSrp2;
+const logout = async ({}, ctx) => {
+    if (!ctx.session)
+        return new apiMiddleware_1.ApiError(const_1.HTTP_SERVER_ERROR);
+    await loggedIn(ctx, false);
+    // 401 is a convenient code for OK: the browser clears a possible http authentication (hopefully), and Admin automatically triggers login dialog
+    return new apiMiddleware_1.ApiError(const_1.HTTP_UNAUTHORIZED);
+};
+exports.logout = logout;
+const refresh_session = async ({}, ctx) => {
+    return !ctx.session ? new apiMiddleware_1.ApiError(const_1.HTTP_SERVER_ERROR) : {
+        username: (0, perm_1.getCurrentUsername)(ctx),
+        adminUrl: (0, adminApis_1.ctxAdminAccess)(ctx) ? const_1.ADMIN_URI : undefined,
+        ...makeExp(),
+    };
+};
+exports.refresh_session = refresh_session;
+const change_password = async ({ newPassword }, ctx) => {
+    return (0, api_helpers_1.changePasswordHelper)(ctx.state.account, newPassword);
+};
+exports.change_password = change_password;
+const change_srp = async ({ salt, verifier }, ctx) => {
+    return (0, api_helpers_1.changeSrpHelper)(ctx.state.account, salt, verifier);
+};
+exports.change_srp = change_srp;

package/src/api.file_list.js

@@ -0,0 +1,110 @@
+"use strict";
+// This file is part of HFS - Copyright 2021-2023, Massimo Melina <a@rejetto.com> - License https://www.gnu.org/licenses/gpl-3.0.txt
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.file_list = void 0;
+const vfs_1 = require("./vfs");
+const apiMiddleware_1 = require("./apiMiddleware");
+const promises_1 = require("fs/promises");
+const plugins_1 = require("./plugins");
+const misc_1 = require("./misc");
+const lodash_1 = __importDefault(require("lodash"));
+const const_1 = require("./const");
+const file_list = async ({ path, offset, limit, search, omit, sse }, ctx) => {
+    let node = await (0, vfs_1.urlToNode)(path || '/', ctx);
+    const list = new apiMiddleware_1.SendListReadable();
+    if (!node)
+        return fail(const_1.HTTP_NOT_FOUND);
+    if (!(0, vfs_1.hasPermission)(node, 'can_read', ctx))
+        return fail((0, vfs_1.cantReadStatusCode)(node));
+    if ((0, misc_1.dirTraversal)(search))
+        return fail(const_1.HTTP_FOOL);
+    if (node.default)
+        return (sse ? list.custom : lodash_1.default.identity)({ redirect: path }); // sse will wrap the object in a 'custom' message, otherwise we plainly return the object
+    if (!await (0, vfs_1.nodeIsDirectory)(node))
+        return fail(const_1.HTTP_METHOD_NOT_ALLOWED);
+    offset = Number(offset);
+    limit = Number(limit);
+    const filter = (0, misc_1.pattern2filter)(search);
+    const walker = (0, vfs_1.walkNode)(node, ctx, search ? Infinity : 0);
+    const onDirEntryHandlers = (0, plugins_1.mapPlugins)(plug => plug.onDirEntry);
+    const can_upload = (0, vfs_1.hasPermission)(node, 'can_upload', ctx);
+    if (!sse)
+        return {
+            can_upload,
+            list: await (0, misc_1.asyncGeneratorToArray)(produceEntries())
+        };
+    setTimeout(async () => {
+        if (can_upload)
+            list.custom({ props: { can_upload } });
+        for await (const entry of produceEntries())
+            list.add(entry);
+        list.close();
+    });
+    return list;
+    function fail(code) {
+        if (!sse)
+            return new apiMiddleware_1.ApiError(code);
+        list.error(code);
+        list.close();
+        return list;
+    }
+    async function* produceEntries() {
+        for await (const sub of walker) {
+            if (ctx.aborted)
+                break;
+            if (!filter((0, vfs_1.getNodeName)(sub)))
+                continue;
+            const entry = await nodeToDirEntry(sub);
+            if (!entry)
+                continue;
+            const cbParams = { entry, ctx, listPath: path, node: sub };
+            try {
+                if (onDirEntryHandlers.some(cb => cb(cbParams) === false))
+                    continue;
+            }
+            catch (e) {
+                console.log("a plugin with onDirEntry is causing problems:", e);
+            }
+            if (offset) {
+                --offset;
+                continue;
+            }
+            if (omit) {
+                if (omit !== 'c')
+                    ctx.throw(const_1.HTTP_BAD_REQUEST, 'omit');
+                if (!entry.m)
+                    entry.m = entry.c;
+                delete entry.c;
+            }
+            yield entry;
+            if (limit && !--limit)
+                break;
+        }
+    }
+};
+exports.file_list = file_list;
+async function nodeToDirEntry(node) {
+    let { source, default: def } = node;
+    const name = (0, vfs_1.getNodeName)(node);
+    if (!source)
+        return name ? { n: name + '/' } : null;
+    if (def)
+        return { n: name };
+    try {
+        const st = await (0, promises_1.stat)(source);
+        const folder = st.isDirectory();
+        const { ctime, mtime } = st;
+        return {
+            n: name + (folder ? '/' : ''),
+            c: ctime,
+            m: Math.abs(+mtime - +ctime) < 1000 ? undefined : mtime,
+            s: folder ? undefined : st.size,
+        };
+    }
+    catch (_a) {
+        return null;
+    }
+}

package/src/api.helpers.js

@@ -0,0 +1,32 @@
+"use strict";
+// This file is part of HFS - Copyright 2021-2023, Massimo Melina <a@rejetto.com> - License https://www.gnu.org/licenses/gpl-3.0.txt
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.changeSrpHelper = exports.changePasswordHelper = void 0;
+const perm_1 = require("./perm");
+const apiMiddleware_1 = require("./apiMiddleware");
+const const_1 = require("./const");
+async function changePasswordHelper(account, newPassword) {
+    if (!newPassword) // clear text version
+        return new apiMiddleware_1.ApiError(const_1.HTTP_BAD_REQUEST, 'missing parameters');
+    if (!account)
+        return new apiMiddleware_1.ApiError(const_1.HTTP_UNAUTHORIZED);
+    await (0, perm_1.updateAccount)(account, account => {
+        account.password = newPassword;
+    });
+    return {};
+}
+exports.changePasswordHelper = changePasswordHelper;
+async function changeSrpHelper(account, salt, verifier) {
+    if (perm_1.allowClearTextLogin.get())
+        return new apiMiddleware_1.ApiError(const_1.HTTP_NOT_ACCEPTABLE);
+    if (!salt || !verifier)
+        return new apiMiddleware_1.ApiError(const_1.HTTP_BAD_REQUEST, 'missing parameters');
+    if (!account)
+        return new apiMiddleware_1.ApiError(const_1.HTTP_UNAUTHORIZED);
+    await (0, perm_1.updateAccount)(account, account => {
+        (0, perm_1.saveSrpInfo)(account, salt, verifier);
+        delete account.hashed_password; // remove leftovers
+    });
+    return {};
+}
+exports.changeSrpHelper = changeSrpHelper;

package/src/api.monitor.js

@@ -0,0 +1,104 @@
+"use strict";
+// This file is part of HFS - Copyright 2021-2023, Massimo Melina <a@rejetto.com> - License https://www.gnu.org/licenses/gpl-3.0.txt
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const lodash_1 = __importDefault(require("lodash"));
+const connections_1 = require("./connections");
+const misc_1 = require("./misc");
+const apiMiddleware_1 = require("./apiMiddleware");
+const throttler_1 = require("./throttler");
+const perm_1 = require("./perm");
+const apis = {
+    async disconnect({ ip, port, wait }) {
+        const match = lodash_1.default.matches({ ip, port });
+        const c = (0, connections_1.getConnections)().find(c => match(getConnAddress(c)));
+        const waiter = (0, misc_1.pendingPromise)();
+        c === null || c === void 0 ? void 0 : c.socket.end(waiter.resolve);
+        if (wait)
+            await waiter;
+        return { result: Boolean(c) };
+    },
+    get_connections({}, ctx) {
+        const list = new apiMiddleware_1.SendListReadable({ addAtStart: (0, connections_1.getConnections)().map(c => serializeConnection(c)) });
+        const throttledUpdate = lodash_1.default.throttle(update, 1000 / 20); // try to avoid clogging with updates
+        const state = Symbol('state'); // undefined=added, Timeout=add-pending, false=removed
+        list.props({ you: ctx.ip });
+        return list.events(ctx, {
+            connection(conn) {
+                conn[state] = setTimeout(() => add(conn), 100);
+            },
+            connectionClosed(conn) {
+                if (cancel(conn))
+                    return;
+                list.remove(serializeConnection(conn, true));
+                conn[state] = false;
+            },
+            connectionUpdated(conn, change) {
+                if (!change.ctx)
+                    return throttledUpdate(conn, change);
+                Object.assign(change, fromCtx(change.ctx));
+                change.ctx = undefined;
+                if (!add(conn))
+                    throttledUpdate(conn, change);
+            },
+        });
+        function add(conn) {
+            if (!cancel(conn))
+                return;
+            list.add(serializeConnection(conn));
+            return true;
+        }
+        function cancel(conn) {
+            if (!conn[state])
+                return;
+            clearTimeout(conn[state]);
+            conn[state] = undefined;
+            return true;
+        }
+        function update(conn, change) {
+            if (conn[state] === false)
+                return;
+            list.update(serializeConnection(conn, true), change);
+        }
+        function serializeConnection(conn, minimal) {
+            var _a;
+            const { socket, started, secure } = conn;
+            return Object.assign(getConnAddress(conn), !minimal && {
+                v: (((_a = socket.remoteFamily) === null || _a === void 0 ? void 0 : _a.endsWith('6')) ? 6 : 4),
+                got: socket.bytesRead,
+                sent: socket.bytesWritten,
+                started,
+                secure: (secure || undefined),
+                ...fromCtx(conn.ctx),
+            });
+        }
+        function fromCtx(ctx) {
+            return ctx && {
+                user: (0, perm_1.getCurrentUsername)(ctx),
+                archive: ctx.state.archive,
+                path: (ctx.fileSource || ctx.state.archive) && ctx.path // only for downloading files
+            };
+        }
+    },
+    async *get_connection_stats() {
+        while (1) {
+            yield {
+                outSpeed: throttler_1.totalOutSpeed,
+                inSpeed: throttler_1.totalInSpeed,
+                got: throttler_1.totalGot,
+                sent: throttler_1.totalSent,
+                connections: (0, connections_1.getConnections)().length
+            };
+            await (0, misc_1.wait)(1000);
+        }
+    },
+};
+exports.default = apis;
+function getConnAddress(conn) {
+    return {
+        ip: conn.ip,
+        port: conn.socket.remotePort,
+    };
+}