core-3nweb-client-lib 0.44.12 → 0.45.1

package/build/tests/jasmine.js

@@ -0,0 +1,45 @@
+"use strict";
+/*
+ Copyright (C) 2016, 2020 - 2022, 2025 3NSoft Inc.
+ 
+ This program is free software: you can redistribute it and/or modify it under
+ the terms of the GNU General Public License as published by the Free Software
+ Foundation, either version 3 of the License, or (at your option) any later
+ version.
+ 
+ This program is distributed in the hope that it will be useful, but
+ WITHOUT ANY WARRANTY; without even the implied warranty of
+ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
+ See the GNU General Public License for more details.
+ 
+ You should have received a copy of the GNU General Public License along with
+ this program. If not, see <http://www.gnu.org/licenses/>.
+*/
+Object.defineProperty(exports, "__esModule", { value: true });
+const jasmine = require("jasmine");
+const jas = new jasmine({});
+const specsFromCLI = [];
+for (let i = 2; i < process.argv.length; i += 1) {
+    specsFromCLI.push(process.argv[i]);
+}
+const ALL_SPECS = [
+    'units/*.js',
+    'caps-api/startup/*.js',
+    'caps-api/keyrings.js',
+    'caps-api/mailerid.js',
+    'caps-api/storage.js',
+    'caps-api/asmail.js',
+    // 'computer.3nweb.core/*.js',
+    'computer.3nweb.core/id-manager.js',
+    // 'computer.3nweb.core/inbox/*.js'
+];
+jas.loadConfig({
+    spec_dir: 'build/tests',
+    spec_files: ((specsFromCLI.length > 0) ? specsFromCLI : ALL_SPECS),
+    random: false,
+    failSpecWithNoExpectations: false,
+});
+jas.configureDefaultReporter({
+    showColors: true
+});
+jas.execute();

package/build/tests/libs-for-tests/bytes-equal.d.ts

@@ -0,0 +1 @@
+export declare function bytesEqual(a: Uint8Array, b: Uint8Array): boolean;

package/build/tests/libs-for-tests/bytes-equal.js

@@ -0,0 +1,32 @@
+"use strict";
+/*
+ Copyright (C) 2016 3NSoft Inc.
+ 
+ This program is free software: you can redistribute it and/or modify it under
+ the terms of the GNU General Public License as published by the Free Software
+ Foundation, either version 3 of the License, or (at your option) any later
+ version.
+ 
+ This program is distributed in the hope that it will be useful, but
+ WITHOUT ANY WARRANTY; without even the implied warranty of
+ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
+ See the GNU General Public License for more details.
+ 
+ You should have received a copy of the GNU General Public License along with
+ this program. If not, see <http://www.gnu.org/licenses/>. */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.bytesEqual = bytesEqual;
+function bytesEqual(a, b) {
+    if (a.BYTES_PER_ELEMENT !== b.BYTES_PER_ELEMENT) {
+        return false;
+    }
+    if (a.length !== b.length) {
+        return false;
+    }
+    for (let i = 0; i < a.length; i += 1) {
+        if (a[i] !== b[i]) {
+            return false;
+        }
+    }
+    return true;
+}

package/build/tests/libs-for-tests/caps-ipc-wrap.d.ts

@@ -0,0 +1,11 @@
+type StartupW3N = web3n.startup.W3N;
+type CommonW3N = web3n.caps.common.W3N;
+export declare function wrapStartupW3N(coreW3N: StartupW3N): {
+    clientW3N: StartupW3N;
+    close: () => void;
+};
+export declare function wrapCommonW3N(coreW3N: CommonW3N): {
+    clientW3N: CommonW3N;
+    close: () => void;
+};
+export {};

package/build/tests/libs-for-tests/caps-ipc-wrap.js

@@ -0,0 +1,55 @@
+"use strict";
+/*
+ Copyright (C) 2020 - 2021, 2024 3NSoft Inc.
+ 
+ This program is free software: you can redistribute it and/or modify it under
+ the terms of the GNU General Public License as published by the Free Software
+ Foundation, either version 3 of the License, or (at your option) any later
+ version.
+ 
+ This program is distributed in the hope that it will be useful, but
+ WITHOUT ANY WARRANTY; without even the implied warranty of
+ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
+ See the GNU General Public License for more details.
+ 
+ You should have received a copy of the GNU General Public License along with
+ this program. If not, see <http://www.gnu.org/licenses/>.
+*/
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.wrapStartupW3N = wrapStartupW3N;
+exports.wrapCommonW3N = wrapCommonW3N;
+const rxjs_1 = require("rxjs");
+const operators_1 = require("rxjs/operators");
+const ipc_1 = require("../../ipc");
+function makePipe() {
+    const fromCore = new rxjs_1.Subject();
+    const toClient = fromCore.asObservable().pipe((0, operators_1.map)(msg => ipc_1.msgProtoType.pack(msg)), (0, operators_1.delay)(1), (0, operators_1.map)(buf => ipc_1.msgProtoType.unpack(buf)));
+    const fromClient = new rxjs_1.Subject();
+    const toCore = fromClient.asObservable().pipe((0, operators_1.map)(msg => ipc_1.msgProtoType.pack(msg)), (0, operators_1.delay)(1), (0, operators_1.map)(buf => ipc_1.msgProtoType.unpack(buf)));
+    const coreSide = ipc_1.ObjectsConnector.makeCoreSide(fromCore, toCore);
+    const listObjInCore = path => {
+        const lst = coreSide.exposedServices.listObj(path);
+        if (lst) {
+            return lst;
+        }
+        else {
+            throw (0, ipc_1.makeIPCException)({ objectNotFound: true });
+        }
+    };
+    const clientSide = ipc_1.ObjectsConnector.makeClientSide(fromClient, toClient, listObjInCore);
+    return { coreSide, clientSide };
+}
+function wrapStartupW3N(coreW3N) {
+    const { clientSide, coreSide } = makePipe();
+    (0, ipc_1.exposeStartupW3N)(coreSide, coreW3N);
+    const clientW3N = (0, ipc_1.makeStartupW3Nclient)(clientSide);
+    const close = () => coreSide.close();
+    return { clientW3N, close };
+}
+function wrapCommonW3N(coreW3N) {
+    const { clientSide, coreSide } = makePipe();
+    (0, ipc_1.exposeW3N)(coreSide, coreW3N);
+    const clientW3N = (0, ipc_1.makeW3Nclient)(clientSide);
+    const close = () => coreSide.close();
+    return { clientW3N, close };
+}

package/build/tests/libs-for-tests/core-runner.d.ts

@@ -0,0 +1,39 @@
+import { Core } from "../../lib-index";
+export declare const testApp: {
+    appDomain: string;
+    capsRequested: web3n.caps.common.RequestedCAPs;
+};
+export interface User {
+    userId: string;
+    pass: string;
+}
+type CommonW3N = web3n.caps.common.W3N;
+type StartupW3N = web3n.startup.W3N;
+export declare class CoreRunner {
+    readonly signUpUrl: string;
+    runningCore: Core | undefined;
+    user: User;
+    private appCaps;
+    private coreNum;
+    readonly dataFolder: string;
+    constructor(signUpUrl: string);
+    get core(): Core;
+    private setNewCore;
+    close(): Promise<void>;
+    cleanup(showLogs: boolean): Promise<void>;
+    removeDataFolder(): Promise<void>;
+    restart(rmCache: boolean, loginUser: boolean): Promise<void>;
+    loginUser(): Promise<void>;
+    createUser(userId: string): Promise<User>;
+    startCore(capsViaIPC?: boolean): {
+        w3n: StartupW3N;
+        coreInit: Promise<string>;
+        coreAppsInit: Promise<void>;
+        closeIPC: () => void;
+    };
+    setupTestAppCaps(): void;
+    get rawAppCaps(): CommonW3N;
+    get appCapsViaIPC(): CommonW3N;
+    makeAndLoginNewCore(): Promise<CoreRunner>;
+}
+export {};

package/build/tests/libs-for-tests/core-runner.js

@@ -0,0 +1,231 @@
+"use strict";
+/*
+ Copyright (C) 2020 - 2022, 2025 - 2026 3NSoft Inc.
+ 
+ This program is free software: you can redistribute it and/or modify it under
+ the terms of the GNU General Public License as published by the Free Software
+ Foundation, either version 3 of the License, or (at your option) any later
+ version.
+ 
+ This program is distributed in the hope that it will be useful, but
+ WITHOUT ANY WARRANTY; without even the implied warranty of
+ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
+ See the GNU General Public License for more details.
+ 
+ You should have received a copy of the GNU General Public License along with
+ this program. If not, see <http://www.gnu.org/licenses/>.
+*/
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CoreRunner = exports.testApp = void 0;
+const lib_index_1 = require("../../lib-index");
+const path_1 = require("path");
+const async_fs_node_1 = require("../../lib-common/async-fs-node");
+const random_node_1 = require("../../lib-common/random-node");
+const app_files_1 = require("../../core/app-files");
+const log_to_file_1 = require("../../lib-client/logging/log-to-file");
+const error_1 = require("../../lib-common/exceptions/error");
+const assert_1 = require("../../lib-common/assert");
+const caps_ipc_wrap_1 = require("./caps-ipc-wrap");
+const service_locator_1 = require("../../lib-client/service-locator");
+const dns_1 = require("dns");
+const napi_nacl_1 = require("napi-nacl");
+exports.testApp = {
+    appDomain: 'test.3nweb.app',
+    capsRequested: {
+        keyrings: 'all',
+        mailerid: true,
+        mail: {
+            receivingFrom: 'all',
+            sendingTo: 'all'
+        },
+        storage: {
+            appFS: [
+                {
+                    domain: "test.3nweb.app",
+                    storage: "synced-n-local"
+                }, {
+                    domain: "mail.test.3nweb.app",
+                    storage: "synced-n-local"
+                }, {
+                    domain: "contacts.test.3nweb.app",
+                    storage: "synced-n-local"
+                }
+            ],
+            userFS: 'all',
+            sysFS: 'all'
+        },
+        logToPlatform: true
+    }
+};
+let numOfRunningCores = 0;
+const DATA_FOLDER = (0, path_1.join)(__dirname, '..', '..', '..', 'test-data');
+class CoreRunner {
+    constructor(signUpUrl) {
+        this.signUpUrl = signUpUrl;
+        this.runningCore = undefined;
+        this.user = undefined;
+        this.appCaps = undefined;
+        numOfRunningCores += 1;
+        this.coreNum = numOfRunningCores;
+        this.dataFolder = `${DATA_FOLDER}-${this.coreNum}-${Date.now()}`;
+        this.setNewCore();
+        Object.seal(this);
+    }
+    get core() {
+        (0, assert_1.assert)(!!this.runningCore);
+        return this.runningCore;
+    }
+    setNewCore() {
+        if (this.appCaps) {
+            this.appCaps.close();
+            this.appCaps = undefined;
+        }
+        this.runningCore = lib_index_1.Core.make({ dataDir: this.dataFolder, signUpUrl: this.signUpUrl }, lib_index_1.makeNetClient, (0, service_locator_1.makeServiceLocator)({
+            resolveTxt: domain => new Promise((resolve, reject) => (0, dns_1.resolveTxt)(domain, (err, texts) => {
+                if (err) {
+                    reject(err);
+                }
+                else {
+                    resolve(texts);
+                }
+            }))
+        }), napi_nacl_1.makeNativeCryptor);
+    }
+    async close() {
+        if (this.appCaps) {
+            this.appCaps.close();
+            this.appCaps = undefined;
+            // XXX
+            //  - should we do this.setNewCore() ? 
+        }
+        if (this.runningCore) {
+            await this.runningCore.close();
+            this.runningCore = undefined;
+        }
+    }
+    async cleanup(showLogs) {
+        if (showLogs) {
+            await showLogsFrom(this.dataFolder);
+        }
+        await this.removeDataFolder();
+    }
+    async removeDataFolder() {
+        await (0, async_fs_node_1.rmDirWithContent)(this.dataFolder).catch((exc) => {
+            if (!exc.notFound) {
+                throw exc;
+            }
+        });
+    }
+    async restart(rmCache, loginUser) {
+        await this.close();
+        if (rmCache) {
+            await this.cleanup(false);
+        }
+        this.setNewCore();
+        if (loginUser) {
+            (0, assert_1.assert)(!!this.user);
+            await this.loginUser();
+        }
+    }
+    async loginUser() {
+        if (!this.runningCore) {
+            this.setNewCore();
+        }
+        const { capsForStartup: caps, coreInit, coreAppsInit } = this.core.start();
+        const usersOnDisk = await caps.signIn.getUsersOnDisk();
+        let isLogged;
+        if (usersOnDisk.find(userOnDisk => (userOnDisk === this.user.userId))) {
+            isLogged = await caps.signIn.useExistingStorage(this.user.userId, this.user.pass, () => { });
+        }
+        else {
+            const userExists = await caps.signIn.startLoginToRemoteStorage(this.user.userId);
+            if (!userExists) {
+                throw new Error(`Attempt to login ${this.user.userId} fails, cause server doesn't recongize this user.`);
+            }
+            isLogged = await caps.signIn.completeLoginAndLocalSetup(this.user.pass, () => { });
+        }
+        if (!isLogged) {
+            throw new Error(`Cannot create user ${this.user.userId}. It may already exists.`);
+        }
+        await coreInit;
+        await coreAppsInit;
+    }
+    async createUser(userId) {
+        if (this.user) {
+            throw new Error('App already has associated user.');
+        }
+        const { capsForStartup: caps, coreInit, coreAppsInit } = this.core.start();
+        const pass = await (0, random_node_1.stringOfB64Chars)(16);
+        await caps.signUp.createUserParams(pass, () => { });
+        const isCreated = await caps.signUp.addUser(userId);
+        if (!isCreated) {
+            throw new Error(`Cannot create user ${userId}. It may already exists.`);
+        }
+        await coreInit;
+        await coreAppsInit;
+        this.user = { userId, pass };
+        return this.user;
+    }
+    startCore(capsViaIPC = true) {
+        const { capsForStartup: rawW3N, coreInit, coreAppsInit } = this.core.start();
+        if (capsViaIPC) {
+            const { clientW3N: w3n, close: closeIPC } = (0, caps_ipc_wrap_1.wrapStartupW3N)(rawW3N);
+            return { w3n, coreInit, coreAppsInit, closeIPC };
+        }
+        else {
+            return { w3n: rawW3N, coreInit, coreAppsInit, closeIPC: () => { } };
+        }
+    }
+    setupTestAppCaps() {
+        (0, assert_1.assert)(!this.appCaps, `Expect that app CAPs not to be set.`);
+        const { caps, close: closeCAPs } = this.core.makeCAPsForApp(exports.testApp.appDomain, exports.testApp.capsRequested);
+        const { clientW3N, close } = (0, caps_ipc_wrap_1.wrapCommonW3N)(caps);
+        this.appCaps = {
+            raw: caps,
+            ipc: clientW3N,
+            close: () => {
+                closeCAPs();
+                close();
+            }
+        };
+    }
+    get rawAppCaps() {
+        (0, assert_1.assert)(!!this.appCaps, `Expect that app CAPs is set.`);
+        return this.appCaps.raw;
+    }
+    get appCapsViaIPC() {
+        (0, assert_1.assert)(!!this.appCaps, `Expect that app CAPs is set.`);
+        return this.appCaps.ipc;
+    }
+    async makeAndLoginNewCore() {
+        const r = new CoreRunner(this.signUpUrl);
+        r.user = this.user;
+        await r.loginUser();
+        r.setupTestAppCaps();
+        return r;
+    }
+}
+exports.CoreRunner = CoreRunner;
+Object.freeze(CoreRunner.prototype);
+Object.freeze(CoreRunner);
+async function showLogsFrom(dataFolder) {
+    const logsFolder = (0, path_1.join)(dataFolder, app_files_1.UTIL_DIR, log_to_file_1.LOGS_FOLDER);
+    try {
+        const logFiles = await (0, async_fs_node_1.readdir)(logsFolder);
+        if (logFiles.length === 0) {
+            return;
+        }
+        console.log(`\n---------------------------\nLogs from directory ${logsFolder}\n`);
+        for (const file of logFiles) {
+            const log = await (0, async_fs_node_1.readFile)((0, path_1.join)(logsFolder, file), { encoding: 'utf8' })
+                .catch(err => `Error occured in reading log file ${file}:\n${(0, error_1.stringifyErr)(err)}`);
+            console.log(`Log file ${file}:\n${log}\n---------------------------`);
+        }
+    }
+    catch (err) {
+        if (!err.notFound) {
+            console.log(`Error occured in reading log folder:\n${(0, error_1.stringifyErr)(err)}`);
+        }
+    }
+}
+Object.freeze(exports);

package/build/tests/libs-for-tests/jasmine-utils.d.ts

@@ -0,0 +1,13 @@
+export declare function itCond(expectation: string, assertion?: () => Promise<void>, timeout?: number, setup?: {
+    isUp: boolean;
+}): void;
+export declare function xitCond(expectation: string, assertion?: () => Promise<void>, timeout?: number, setup?: {
+    isUp: boolean;
+}): void;
+export declare function fitCond(expectation: string, assertion?: () => Promise<void>, timeout?: number, setup?: {
+    isUp: boolean;
+}): void;
+export declare function beforeAllWithTimeoutLog(action: () => Promise<void>, timeout?: number): void;
+export declare function beforeEachWithTimeoutLog(action: () => Promise<void>, timeout?: number): void;
+export declare function afterAllCond(action: () => Promise<void>, timeout?: number): void;
+export declare function afterEachCond(action: () => Promise<void>, timeout?: number): void;

package/build/tests/libs-for-tests/jasmine-utils.js

@@ -0,0 +1,110 @@
+"use strict";
+/*
+ Copyright (C) 2016 - 2018, 2020 - 2022 3NSoft Inc.
+ 
+ This program is free software: you can redistribute it and/or modify it under
+ the terms of the GNU General Public License as published by the Free Software
+ Foundation, either version 3 of the License, or (at your option) any later
+ version.
+ 
+ This program is distributed in the hope that it will be useful, but
+ WITHOUT ANY WARRANTY; without even the implied warranty of
+ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
+ See the GNU General Public License for more details.
+ 
+ You should have received a copy of the GNU General Public License along with
+ this program. If not, see <http://www.gnu.org/licenses/>.
+*/
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.itCond = itCond;
+exports.xitCond = xitCond;
+exports.fitCond = fitCond;
+exports.beforeAllWithTimeoutLog = beforeAllWithTimeoutLog;
+exports.beforeEachWithTimeoutLog = beforeEachWithTimeoutLog;
+exports.afterAllCond = afterAllCond;
+exports.afterEachCond = afterEachCond;
+const error_1 = require("../../lib-common/exceptions/error");
+const timeout_1 = require("../../lib-common/processes/timeout");
+function itCond(expectation, assertion, timeout, setup) {
+    if (assertion) {
+        it(expectation, callbackFor(assertion, setup), timeout);
+    }
+    else {
+        it(expectation);
+    }
+}
+function callbackFor(assertion, setup) {
+    return async () => {
+        if (setup && !setup.isUp) {
+            fail(`Test setup is not up`);
+        }
+        else {
+            try {
+                await assertion();
+            }
+            catch (err) {
+                if (typeof err === 'string') {
+                    fail(err);
+                }
+                else if (err.runtimeException) {
+                    fail((0, error_1.stringifyErr)(err));
+                }
+                else {
+                    throw err;
+                }
+            }
+        }
+    };
+}
+function xitCond(expectation, assertion, timeout, setup) {
+    if (assertion) {
+        xit(expectation, callbackFor(assertion, setup), timeout);
+    }
+    else {
+        xit(expectation);
+    }
+}
+function fitCond(expectation, assertion, timeout, setup) {
+    if (assertion) {
+        fit(expectation, callbackFor(assertion, setup), timeout);
+    }
+    else {
+        fit(expectation);
+    }
+}
+function beforeAllWithTimeoutLog(action, timeout) {
+    beforeAll(callbackWithTimeout(action, true, timeout, 'beforeAll'), timeout);
+}
+const DEFAULT_TIMEOUT_INTERVAL = 5000;
+function callbackWithTimeout(action, throwIfErr, timeout, actionType) {
+    const millisToSleep = ((timeout === undefined) ?
+        DEFAULT_TIMEOUT_INTERVAL : timeout);
+    const timeoutErr = {};
+    return async () => {
+        try {
+            await (0, timeout_1.callWithTimeout)(action, millisToSleep - 5, () => timeoutErr);
+        }
+        catch (err) {
+            if (err === timeoutErr) {
+                console.log(`\n>>> timeout in ${actionType}: action hasn't completed in ${millisToSleep - 5} milliseconds`);
+            }
+            else if (throwIfErr) {
+                console.log(`\n>>> ${actionType} threw`, err);
+                fail(err.runtimeException ?
+                    (0, error_1.stringifyErr)(err) : err);
+            }
+        }
+    };
+}
+function beforeEachWithTimeoutLog(action, timeout) {
+    beforeEach(callbackWithTimeout(action, true, timeout, 'beforeEach'), timeout);
+}
+// Adjust this static flag to hide/show errors thrown in afterXXX()
+const throwErrorInAfter = false;
+function afterAllCond(action, timeout) {
+    afterAll(callbackWithTimeout(action, throwErrorInAfter, timeout, 'afterAll'), timeout);
+}
+function afterEachCond(action, timeout) {
+    afterEach(callbackWithTimeout(action, throwErrorInAfter, timeout, 'afterEach'), timeout);
+}
+Object.freeze(exports);

package/build/tests/libs-for-tests/json-equal.d.ts

@@ -0,0 +1 @@
+export declare function deepEqual(a: any, b: any, trimUndefinedObjFields?: boolean): boolean;

package/build/tests/libs-for-tests/json-equal.js

@@ -0,0 +1,78 @@
+"use strict";
+/*
+ Copyright (C) 2015, 2025 3NSoft Inc.
+ 
+ This program is free software: you can redistribute it and/or modify it under
+ the terms of the GNU General Public License as published by the Free Software
+ Foundation, either version 3 of the License, or (at your option) any later
+ version.
+ 
+ This program is distributed in the hope that it will be useful, but
+ WITHOUT ANY WARRANTY; without even the implied warranty of
+ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
+ See the GNU General Public License for more details.
+ 
+ You should have received a copy of the GNU General Public License along with
+ this program. If not, see <http://www.gnu.org/licenses/>.
+*/
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.deepEqual = deepEqual;
+function deepEqual(a, b, trimUndefinedObjFields = true) {
+    let t = typeof a;
+    if (t !== typeof b) {
+        return false;
+    }
+    if (t !== 'object') {
+        return (a === b);
+    }
+    if (a === b) {
+        return true;
+    }
+    if ((a === null) || (b === null)) {
+        return false;
+    }
+    if (Array.isArray(a)) {
+        if (!Array.isArray(b)) {
+            return false;
+        }
+        let aArr = a;
+        let bArr = b;
+        if (aArr.length !== bArr.length) {
+            return false;
+        }
+        for (let i = 0; i < aArr.length; i += 1) {
+            if (!deepEqual(aArr[i], bArr[i])) {
+                return false;
+            }
+        }
+    }
+    else {
+        let aKeys = Object.keys(a);
+        let bKeys = Object.keys(b);
+        if (trimUndefinedObjFields) {
+            for (let i = 0; i < aKeys.length; i += 1) {
+                if (a[aKeys[i]] === undefined) {
+                    aKeys.splice(i, 1);
+                    i -= 1;
+                }
+            }
+            for (let i = 0; i < bKeys.length; i += 1) {
+                if (b[bKeys[i]] === undefined) {
+                    bKeys.splice(i, 1);
+                    i -= 1;
+                }
+            }
+        }
+        if (aKeys.length !== bKeys.length) {
+            return false;
+        }
+        for (let i = 0; i < aKeys.length; i += 1) {
+            let key = aKeys[i];
+            if (!deepEqual(a[key], b[key])) {
+                return false;
+            }
+        }
+    }
+    return true;
+}
+Object.freeze(exports);

package/build/tests/libs-for-tests/services-runner.d.ts

@@ -0,0 +1,18 @@
+export declare class ServicesRunner {
+    readonly port: number;
+    readonly domains: {
+        noTokenSignup: string[];
+        other: string[];
+    };
+    private stopFn;
+    readonly dataFolder: string;
+    private serverNum;
+    constructor(port: number, domains: {
+        noTokenSignup: string[];
+        other: string[];
+    });
+    start(): Promise<void>;
+    stop(cleanup?: boolean): Promise<void>;
+    private cleanup;
+    createSingleUserSignupCtx(userId: string): Promise<string>;
+}