hfs 0.1.6 → 0.26.2

package/src/QuickZipStream.js

@@ -0,0 +1,285 @@
+"use strict";
+// This file is part of HFS - Copyright 2021-2022, 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.QuickZipStream = void 0;
+const stream_1 = require("stream");
+// @ts-ignore
+const buffer_crc32_1 = require("buffer-crc32");
+const assert_1 = __importDefault(require("assert"));
+const ZIP64_SIZE_LIMIT = 0xffffffff;
+const ZIP64_NUMBER_LIMIT = 0xffff;
+let crc32function;
+Promise.resolve().then(() => __importStar(require('@node-rs/crc32'))).then(lib => crc32function = lib.crc32, () => {
+    console.log('using generic lib for crc32');
+    crc32function = buffer_crc32_1.unsigned;
+});
+const FLAGS = 0x0808; // bit3 = no crc in local header + bit11 = utf8
+class QuickZipStream extends stream_1.Readable {
+    constructor(walker) {
+        super({});
+        this.walker = walker;
+        this.finished = false;
+        this.entries = [];
+        this.dataWritten = 0;
+        this.consumedCalculating = [];
+        this.skip = 0;
+    }
+    earlyClose() {
+        this.finished = true;
+        this.push(null);
+    }
+    applyRange(start, end) {
+        if (end < start)
+            return this.earlyClose();
+        this.skip = start;
+        this.limit = end - start + 1;
+    }
+    controlledPush(chunk) {
+        if (Array.isArray(chunk))
+            chunk = buffer(chunk);
+        this.dataWritten += chunk.length;
+        if (this.skip) {
+            if (this.skip >= chunk.length) {
+                this.skip -= chunk.length;
+                return true;
+            }
+            chunk = chunk.subarray(this.skip);
+            this.skip = 0;
+        }
+        const lastBit = this.limit < chunk.length;
+        if (lastBit)
+            chunk = chunk.subarray(0, this.limit);
+        const ret = this.push(chunk);
+        if (lastBit)
+            this.earlyClose();
+        return ret;
+    }
+    async calculateSize(howLong = 1000) {
+        const endBy = Date.now() + howLong;
+        while (1) {
+            if (Date.now() >= endBy)
+                return NaN;
+            const { value } = await this.walker.next();
+            if (!value)
+                break;
+            this.consumedCalculating.push(value); // we keep same shape of the generator, so
+        }
+        // if we reach here, then we were able to consume all entries of the walker (in time)
+        let offset = 0;
+        let centralDirSize = 0;
+        for (const file of this.consumedCalculating) {
+            const pathSize = Buffer.from(file.path, 'utf8').length;
+            const extraLength = (file.size > ZIP64_SIZE_LIMIT ? 2 : 0) + (offset > ZIP64_SIZE_LIMIT ? 1 : 0);
+            const extraDataSize = extraLength && (2 + 2 + extraLength * 8);
+            offset += 4 + 2 + 2 + 2 + 4 + 4 + 4 + 4 + 2 + 2 + pathSize + file.size;
+            centralDirSize += 4 + 2 + 2 + 2 + 2 + 4 + 4 + 4 + 4 + 2 + 2 + 2 + 2 + 2 + 4 + 4 + pathSize + extraDataSize;
+        }
+        const n = this.consumedCalculating.length;
+        const centralDirOffset = offset;
+        if (n >= ZIP64_NUMBER_LIMIT
+            || centralDirOffset >= ZIP64_SIZE_LIMIT
+            || centralDirSize >= ZIP64_SIZE_LIMIT)
+            centralDirSize += 4 + 8 + 2 + 2 + 4 + 4 + 8 + 8 + 8 + 8 + 4 + 4 + 8 + 4;
+        centralDirSize += 4 + 4 + 2 + 2 + 4 + 4 + 2;
+        return offset + centralDirSize;
+    }
+    async _read() {
+        if (this.finished || this.destroyed)
+            return;
+        if (this.workingFile)
+            return this.workingFile.resume();
+        const file = this.consumedCalculating.shift() || (await this.walker.next()).value;
+        if (!file)
+            return this.closeArchive();
+        let { path, sourcePath, getData, size, ts, mode } = file;
+        const pathAsBuffer = Buffer.from(path, 'utf8');
+        const offset = this.dataWritten;
+        const version = 20;
+        this.controlledPush([
+            4, 0x04034b50,
+            2, version,
+            2, FLAGS,
+            2, 0,
+            ...ts2buf(ts),
+            4, 0,
+            4, 0,
+            4, 0,
+            2, pathAsBuffer.length,
+            2, 0, // extra length
+        ]);
+        this.controlledPush(pathAsBuffer);
+        if (this.finished)
+            return;
+        const cache = sourcePath ? crcCache[sourcePath] : undefined;
+        const cacheHit = Number(cache === null || cache === void 0 ? void 0 : cache.ts) === Number(ts);
+        let crc = cacheHit ? cache.crc : crc32function('');
+        const extAttr = !mode ? 0 : (mode | 0x8000) * 0x10000; // it's like <<16 but doesn't overflow so easily
+        const entry = { size, crc, pathAsBuffer, ts, offset, version, extAttr };
+        if (this.skip >= size && cacheHit) {
+            this.skip -= size;
+            this.dataWritten += size;
+            this.entries.push(entry);
+            setTimeout(() => this.push('')); // this "signal" works only after _read() is done
+            return;
+        }
+        const data = getData();
+        data.on('error', (err) => console.error(err));
+        data.on('end', () => {
+            this.workingFile = undefined;
+            entry.crc = crc;
+            if (sourcePath)
+                crcCache[sourcePath] = { ts, crc };
+            this.entries.push(entry);
+            this.push(''); // continue piping
+        });
+        this.workingFile = data;
+        data.on('data', chunk => {
+            if (this.destroyed)
+                return data.destroy();
+            if (!this.controlledPush(chunk)) // destination buffer full
+                data.pause(); // slow down
+            if (!cacheHit)
+                crc = crc32function(chunk, crc);
+            if (this.finished)
+                return data.destroy();
+        });
+    }
+    closeArchive() {
+        this.finished = true;
+        let centralDirOffset = this.dataWritten;
+        for (let { size, ts, crc, offset, pathAsBuffer, version, extAttr } of this.entries) {
+            const extra = [];
+            if (size > ZIP64_SIZE_LIMIT) {
+                extra.push(size, size);
+                size = ZIP64_SIZE_LIMIT;
+            }
+            if (offset > ZIP64_SIZE_LIMIT) {
+                extra.push(offset);
+                offset = ZIP64_SIZE_LIMIT;
+            }
+            const extraData = buffer(!extra.length ? []
+                : [2, 1, 2, 8 * extra.length, ...extra.map(x => [8, x]).flat()]);
+            if (extraData.length && version < 45)
+                version = 45;
+            this.controlledPush([
+                4, 0x02014b50,
+                2, version,
+                2, version,
+                2, FLAGS,
+                2, 0,
+                ...ts2buf(ts),
+                4, crc,
+                4, size,
+                4, size,
+                2, pathAsBuffer.length,
+                2, extraData.length,
+                2, 0,
+                2, 0,
+                2, 0,
+                4, extAttr,
+                4, offset,
+            ]);
+            this.controlledPush(pathAsBuffer);
+            this.controlledPush(extraData);
+        }
+        const after = this.dataWritten;
+        let centralDirSize = after - centralDirOffset;
+        let n = this.entries.length;
+        if (n >= ZIP64_NUMBER_LIMIT
+            || centralDirOffset >= ZIP64_SIZE_LIMIT
+            || centralDirSize >= ZIP64_SIZE_LIMIT) {
+            this.controlledPush([
+                4, 0x06064b50,
+                8, 44,
+                2, 45,
+                2, 45,
+                4, 0,
+                4, 0,
+                8, n,
+                8, n,
+                8, centralDirSize,
+                8, centralDirOffset,
+            ]);
+            this.controlledPush([
+                4, 0x07064b50,
+                4, 0,
+                8, after,
+                4, 1,
+            ]);
+            centralDirOffset = ZIP64_SIZE_LIMIT;
+            centralDirSize = ZIP64_SIZE_LIMIT;
+            n = ZIP64_NUMBER_LIMIT;
+        }
+        this.controlledPush([
+            4, 0x06054b50,
+            4, 0,
+            2, n,
+            2, n,
+            4, centralDirSize,
+            4, centralDirOffset,
+            2, 0, // comment length
+        ]);
+        this.push(null); // EOF
+    }
+}
+exports.QuickZipStream = QuickZipStream;
+function buffer(pairs) {
+    (0, assert_1.default)(pairs.length % 2 === 0);
+    let total = 0;
+    for (let i = 0; i < pairs.length; i += 2)
+        total += pairs[i];
+    const ret = Buffer.alloc(total, 0);
+    let offset = 0;
+    let i = 0;
+    while (i < pairs.length) {
+        const size = pairs[i++];
+        const data = pairs[i++];
+        if (size === 1)
+            ret.writeUInt8(data, offset);
+        else if (size === 2)
+            ret.writeUInt16LE(data, offset);
+        else if (size === 4)
+            ret.writeUInt32LE(data, offset);
+        else if (size === 8)
+            ret.writeBigUInt64LE(BigInt(data), offset);
+        else
+            throw 'unsupported';
+        offset += size;
+    }
+    return ret;
+}
+function ts2buf(ts) {
+    const date = ((ts.getFullYear() - 1980) & 0x7F) << 9 | (ts.getMonth() + 1) << 5 | ts.getDate();
+    const time = ts.getHours() << 11 | ts.getMinutes() << 5 | (ts.getSeconds() / 2) & 0x0F;
+    return [
+        2, time,
+        2, date,
+    ];
+}
+const crcCache = {};

package/src/ThrottledStream.js

@@ -0,0 +1,93 @@
+"use strict";
+// This file is part of HFS - Copyright 2021-2022, Massimo Melina <a@rejetto.com> - License https://www.gnu.org/licenses/gpl-3.0.txt
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ThrottleGroup = exports.ThrottledStream = void 0;
+const stream_1 = require("stream");
+const limiter_1 = require("limiter");
+// throttled stream
+class ThrottledStream extends stream_1.Transform {
+    constructor(group, copyStats) {
+        super();
+        this.group = group;
+        this.sent = 0;
+        this.lastSpeed = 0;
+        this.lastSpeedTime = Date.now();
+        this.totalSent = 0; // total sent over connection, since connection can be re-used for multiple requests
+        if (!copyStats)
+            return;
+        this.sent = copyStats.sent;
+        this.totalSent = copyStats.totalSent;
+        this.lastSpeedTime = copyStats.lastSpeedTime;
+        this.lastSpeed = copyStats.lastSpeed;
+    }
+    async _transform(chunk, encoding, done) {
+        let pos = 0;
+        while (1) {
+            let n = this.group.suggestChunkSize();
+            const slice = chunk.slice(pos, pos + n);
+            n = slice.length;
+            if (!n) // we're done here
+                return done();
+            try {
+                await this.group.consume(n);
+                this.push(slice);
+                this.sent += n;
+                this.totalSent += n;
+                pos += n;
+                this.emit('sent', n);
+            }
+            catch (e) {
+                done(e);
+                return;
+            }
+        }
+    }
+    // @return kBs
+    getSpeed() {
+        const now = Date.now();
+        const past = now - this.lastSpeedTime;
+        if (past >= 1000) { // recalculate?
+            this.lastSpeedTime = now;
+            this.lastSpeed = this.sent / past;
+            this.sent = 0;
+        }
+        return this.lastSpeed;
+    }
+    getBytesSent() {
+        return this.totalSent;
+    }
+}
+exports.ThrottledStream = ThrottledStream;
+class ThrottleGroup {
+    constructor(kBs, parent) {
+        this.parent = parent;
+        this.bucket = this.updateLimit(kBs); // assignment is redundant and yet the best way I've found to shut up typescript
+    }
+    // @return kBs
+    getLimit() {
+        return this.bucket.bucketSize / 1000;
+    }
+    updateLimit(kBs) {
+        if (kBs < 0)
+            throw new Error('invalid bytesPerSecond');
+        kBs *= 1000;
+        return this.bucket = new limiter_1.TokenBucket({
+            bucketSize: kBs,
+            tokensPerInterval: kBs,
+            interval: 'second',
+        });
+    }
+    suggestChunkSize() {
+        var _a;
+        let b = this.bucket;
+        b.parentBucket = (_a = this.parent) === null || _a === void 0 ? void 0 : _a.bucket;
+        let min = b.bucketSize;
+        while (b = b.parentBucket)
+            min = Math.min(min, b.bucketSize);
+        return min / 10;
+    }
+    consume(n) {
+        return this.bucket.removeTokens(n);
+    }
+}
+exports.ThrottleGroup = ThrottleGroup;

package/src/adminApis.js

@@ -0,0 +1,169 @@
+"use strict";
+// This file is part of HFS - Copyright 2021-2022, 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.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(400);
+        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(404, 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.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-2022, 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((0, perm_1.getAccounts)()) };
+    },
+    get_account({ username }, ctx) {
+        return prepareAccount((0, perm_1.getAccount)(username || (0, perm_1.getCurrentUsername)(ctx)))
+            || new apiMiddleware_1.ApiError(404);
+    },
+    get_accounts() {
+        return { list: Object.values((0, perm_1.getAccounts)()).map(prepareAccount) };
+    },
+    get_admins() {
+        return { list: Object.values((0, perm_1.getAccounts)()).map(prepareAccount).filter(ac => ac === null || ac === void 0 ? void 0 : ac.adminActualAccess).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(400, "invalid admin");
+        return (0, perm_1.setAccount)(username, changes) ? {} : new apiMiddleware_1.ApiError(400);
+    },
+    add_account({ username, ...rest }) {
+        if ((0, perm_1.getAccount)(username))
+            return new apiMiddleware_1.ApiError(const_1.FORBIDDEN);
+        if (!(0, perm_1.addAccount)(username, rest))
+            return new apiMiddleware_1.ApiError(400);
+        return {};
+    },
+    del_account({ username }) {
+        return (0, perm_1.delAccount)(username) ? {} : new apiMiddleware_1.ApiError(400);
+    },
+    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;