core-3nweb-client-lib 0.49.8 → 0.50.0

package/build/core/asmail/sending-params/own-params.js

@@ -1,6 +1,6 @@
 "use strict";
 /*
- Copyright (C) 2017 - 2018, 2025 3NSoft Inc.
+ Copyright (C) 2017 - 2018, 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
@@ -16,126 +16,173 @@
  this program. If not, see <http://www.gnu.org/licenses/>.
 */
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.OwnSendingParams = void 0;
-const file_based_json_1 = require("../../../lib-client/xsp-fs/util/file-based-json");
+exports.makeOwnSendingParams = makeOwnSendingParams;
 const json_utils_1 = require("../../../lib-common/json-utils");
+const single_file_1 = require("../../../lib-common/dataset-sync/single-file");
 const DEFAULT_INVITE_LABEL = 'Default';
 const DEFAULT_INVITE_MAX_MSG_SIZE = 1024 * 1024 * 1024;
-/**
- * Instance of this class keeps track of sending parameters, which user gives to
- * other correspondents for sending messages back. These parameters may have
- * invitation tokens, and this class uses config service to register tokens on
- * a server.
- */
-class OwnSendingParams {
-    constructor(anonInvites) {
-        this.anonInvites = anonInvites;
-        this.params = new Map();
-        this.defaultParams = undefined;
-        this.getFor = async (address) => {
-            let p = this.params.get(address);
-            if (p) {
-                if (p.suggested) {
-                    return p.suggested;
-                }
-                else if (p.inUse) {
-                    return; // undefined, cause params are known to correspondent,
-                    // and there are no params to suggest for future use.
-                }
-            }
-            // XXX Or, instead, should we set defaultParams?
-            if (!this.defaultParams) {
-                return;
-            }
-            p = {
-                address,
-                suggested: (0, json_utils_1.copy)(this.defaultParams)
-            };
-            p.suggested.timestamp = Date.now();
-            this.params.set(p.address, p);
-            await this.fileProc.order.startOrChain(() => this.persist());
-            return p.suggested;
-        };
-        this.setAsInUse = async (address, invite) => {
-            await this.fileProc.order.startOrChain(async () => {
-                const p = this.params.get(address);
-                if (!p || !p.suggested) {
-                    return;
-                }
-                if (p.suggested.invitation !== invite) {
-                    return;
-                }
-                p.inUse = p.suggested;
-                p.suggested = undefined;
-                await this.persist();
-            });
-        };
-        this.fileProc = new file_based_json_1.JsonFileProc(this.onFileEvent.bind(this));
-        Object.seal(this);
+async function makeOwnSendingParams(fs, fileName, anonInvites) {
+    let params = {};
+    let defaultParams = undefined;
+    const { file: paramsFile, changeProc } = await (0, single_file_1.initSyncedFile)(fs, fileName, newFile => newFile.writeJSON(currentToFileJSON()));
+    if (!paramsFile.isNew) {
+        ({ defaultParams, params } = parseFromJSON(await paramsFile.readJSON()));
     }
-    static async makeAndInit(file, anonInvites) {
-        const ownParams = new OwnSendingParams(anonInvites);
-        await ownParams.fileProc.start(file, () => ownParams.toFileJSON());
-        await ownParams.absorbChangesFromFile();
-        if (!ownParams.defaultParams) {
-            await ownParams.setDefaultParams();
-        }
-        return ownParams;
+    const { stopFileWatching, triggerUpload } = (0, single_file_1.watchAndApplyChangesFromOtherDevices)(paramsFile, changeProc, onChangeFromOtherDevices, doOnConflict);
+    if (paramsFile.isNew) {
+        await setDefaultParams();
     }
-    async setDefaultParams() {
-        await this.fileProc.order.startOrChain(async () => {
-            const invites = this.anonInvites.getAll();
+    async function setDefaultParams() {
+        await changeProc.startOrChain(async () => {
+            const invites = anonInvites.getAll();
             const defaultInvite = invites.get(DEFAULT_INVITE_LABEL);
             if (defaultInvite) {
-                this.defaultParams = {
+                defaultParams = {
                     timestamp: 0,
                     invitation: defaultInvite.invite
                 };
             }
             else {
-                const invitation = await this.anonInvites.create(DEFAULT_INVITE_LABEL, DEFAULT_INVITE_MAX_MSG_SIZE);
-                this.defaultParams = {
+                const invitation = await anonInvites.create(DEFAULT_INVITE_LABEL, DEFAULT_INVITE_MAX_MSG_SIZE);
+                defaultParams = {
                     timestamp: 0,
                     invitation
                 };
             }
-            await this.persist();
+            await persist();
         });
     }
-    toFileJSON() {
+    function currentToFileJSON() {
         return {
-            default: this.defaultParams,
-            senderSpecific: Array.from(this.params.values())
+            default: defaultParams,
+            senderSpecific: Object.values(params)
         };
     }
-    async persist() {
-        await this.fileProc.save(this.toFileJSON(), false);
-    }
-    async absorbChangesFromFile() {
-        const { json } = await this.fileProc.get(false);
-        // we may add checks to json data
-        this.params.clear();
-        json.senderSpecific.forEach(p => this.params.set(p.address, p));
-        this.defaultParams = json.default;
+    async function persist() {
+        await paramsFile.writeJSON(currentToFileJSON());
+        triggerUpload();
     }
-    async onFileEvent(ev) {
-        if (ev.src === 'local') {
-            return;
+    function parseFromJSON(json) {
+        const params = {};
+        for (const p of json.senderSpecific) {
+            params[p.address] = p;
         }
-        if (ev.type === 'removed') {
-            throw new Error(`Unexpected removal of file with invites info`);
-        }
-        if (ev.type !== 'file-change') {
-            return;
-        }
-        await this.fileProc.order.startOrChain(() => this.absorbChangesFromFile());
+        return {
+            defaultParams: json.default,
+            params
+        };
+    }
+    function onChangeFromOtherDevices(newVersion) {
+        return changeProc.startOrChain(async () => {
+            const { version, json } = await paramsFile.v.readJSON();
+            if (version === newVersion) {
+                ({ defaultParams, params } = parseFromJSON(json));
+            }
+        });
+    }
+    function doOnConflict() {
+        return changeProc.startOrChain(async () => {
+            var _a, _b, _c, _d, _e, _f, _g, _h, _j, _k;
+            const { remote, state } = await paramsFile.v.sync.status(false);
+            if ((state !== 'conflicting') || !(remote === null || remote === void 0 ? void 0 : remote.latest)) {
+                return;
+            }
+            const onRemote = parseFromJSON((await paramsFile.v.readJSON({ remoteVersion: remote.latest })).json);
+            let uploadLocal = false;
+            if (!onRemote.defaultParams && defaultParams) {
+                uploadLocal = true;
+            }
+            else if (onRemote.defaultParams && !defaultParams) {
+                defaultParams = onRemote.defaultParams;
+            }
+            else if (onRemote.defaultParams && defaultParams) {
+                if (onRemote.defaultParams.timestamp >= defaultParams.timestamp) {
+                    defaultParams = onRemote.defaultParams;
+                }
+                else {
+                    uploadLocal = true;
+                }
+            }
+            for (const [addr, p] of Object.entries(params)) {
+                const remP = onRemote.params[addr];
+                if (!remP) {
+                    uploadLocal = true;
+                    continue;
+                }
+                if ((0, json_utils_1.deepEqual)(p, remP)) {
+                    continue;
+                }
+                const tsP = Math.max((_b = (_a = p === null || p === void 0 ? void 0 : p.inUse) === null || _a === void 0 ? void 0 : _a.timestamp) !== null && _b !== void 0 ? _b : 0, (_d = (_c = p === null || p === void 0 ? void 0 : p.suggested) === null || _c === void 0 ? void 0 : _c.timestamp) !== null && _d !== void 0 ? _d : 0);
+                const tsRem = Math.max((_f = (_e = remP === null || remP === void 0 ? void 0 : remP.inUse) === null || _e === void 0 ? void 0 : _e.timestamp) !== null && _f !== void 0 ? _f : 0, (_h = (_g = remP === null || remP === void 0 ? void 0 : remP.suggested) === null || _g === void 0 ? void 0 : _g.timestamp) !== null && _h !== void 0 ? _h : 0);
+                if (tsP > tsRem) {
+                    uploadLocal = true;
+                }
+                else if (tsP < tsRem) {
+                    params[addr] = remP;
+                }
+                else if (tsP !== 0) {
+                    if (((_j = remP.inUse) === null || _j === void 0 ? void 0 : _j.timestamp) === tsP) {
+                        params[addr] = remP;
+                    }
+                    else if (((_k = p.inUse) === null || _k === void 0 ? void 0 : _k.timestamp) === tsP) {
+                        uploadLocal = true;
+                    }
+                }
+            }
+            if (uploadLocal) {
+                await paramsFile.writeJSON(currentToFileJSON());
+                await paramsFile.v.sync.upload({ uploadVersion: remote.latest + 1 });
+            }
+            else {
+                await paramsFile.v.sync.adoptRemote({ remoteVersion: remote.latest });
+            }
+        });
+    }
+    async function getUpdated(address) {
+        return changeProc.startOrChain(async () => {
+            let p = params[address];
+            if (p) {
+                if (p.suggested) {
+                    return p.suggested;
+                }
+                else if (p.inUse) {
+                    return; // undefined, cause params are known to correspondent,
+                    // and there are no params to suggest for future use.
+                }
+            }
+            // XXX Or, instead, should we set defaultParams?
+            if (!defaultParams) {
+                return;
+            }
+            p = {
+                address,
+                suggested: (0, json_utils_1.copy)(defaultParams)
+            };
+            p.suggested.timestamp = Date.now();
+            params[p.address] = p;
+            await persist();
+            return p.suggested;
+        });
+    }
+    function setAsUsed(address, invite) {
+        return changeProc.startOrChain(async () => {
+            const p = params[address];
+            if (!(p === null || p === void 0 ? void 0 : p.suggested) || (p.suggested.invitation !== invite)) {
+                return;
+            }
+            p.inUse = p.suggested;
+            p.suggested = undefined;
+            await persist();
+        });
     }
-    async close() {
-        await this.anonInvites.close();
-        await this.fileProc.close();
+    async function close() {
+        anonInvites.close();
+        stopFileWatching();
     }
+    return {
+        close,
+        getUpdated,
+        setAsUsed
+    };
 }
-exports.OwnSendingParams = OwnSendingParams;
-Object.freeze(OwnSendingParams.prototype);
-Object.freeze(OwnSendingParams);
 Object.freeze(exports);

package/build/core/asmail/sending-params/params-from-others.d.ts

@@ -1,17 +1,7 @@
 import { SendingParamsHolder } from '../sending-params';
-export { SendingParams } from '../msg/common';
-type ExposedFuncs = SendingParamsHolder['otherSides'];
-type WritableFile = web3n.files.WritableFile;
-type FileEvent = web3n.files.FileEvent;
-export declare class ParamsFromOthers {
-    private readonly params;
-    private readonly fileProc;
-    private constructor();
-    static makeAndInit(file: WritableFile): Promise<ParamsFromOthers>;
-    private absorbRemoteChanges;
-    protected onFileEvent(ev: FileEvent): Promise<void>;
-    getFor: ExposedFuncs['get'];
-    setFor: ExposedFuncs['set'];
-    private persist;
-    close(): Promise<void>;
-}
+export type { SendingParams } from '../msg/common';
+type WritableFS = web3n.files.WritableFS;
+export type ParamsFromOthers = Awaited<ReturnType<typeof makeParamsFromOthers>>;
+export declare function makeParamsFromOthers(fs: WritableFS, fileName: string): Promise<SendingParamsHolder['otherSides'] & {
+    close: () => Promise<void>;
+}>;

package/build/core/asmail/sending-params/params-from-others.js

@@ -1,6 +1,6 @@
 "use strict";
 /*
- Copyright (C) 2017 - 2018, 2025 3NSoft Inc.
+ Copyright (C) 2017 - 2018, 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
@@ -16,73 +16,103 @@
  this program. If not, see <http://www.gnu.org/licenses/>.
 */
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.ParamsFromOthers = void 0;
-const file_based_json_1 = require("../../../lib-client/xsp-fs/util/file-based-json");
-class ParamsFromOthers {
-    constructor() {
-        this.params = new Map();
-        this.getFor = (address) => {
-            const p = this.params.get(address);
-            if (!p) {
-                return;
+exports.makeParamsFromOthers = makeParamsFromOthers;
+const single_file_1 = require("../../../lib-common/dataset-sync/single-file");
+async function makeParamsFromOthers(fs, fileName) {
+    const { file: paramsFile, changeProc } = await (0, single_file_1.initSyncedFile)(fs, fileName, newFile => newFile.writeJSON([]));
+    function parseParamsFromJSON(json) {
+        if (Array.isArray(json)) {
+            // older serialization form
+            const p = {};
+            for (const paramsForSending of json) {
+                const { address, timestamp, auth, invitation } = paramsForSending;
+                p[address] = { timestamp, auth, invitation };
             }
-            return copyParams(p);
-        };
-        this.setFor = (address, params) => {
-            return this.fileProc.order.startOrChain(async () => {
-                const existing = this.params.get(address);
-                if (existing && (existing.timestamp >= params.timestamp)) {
-                    return;
-                }
-                const p = { address };
-                copyParams(params, p);
-                this.params.set(p.address, p);
-                await this.persist();
-            });
-        };
-        this.fileProc = new file_based_json_1.JsonFileProc(this.onFileEvent.bind(this));
-        Object.seal(this);
-    }
-    static async makeAndInit(file) {
-        const paramsFromOthers = new ParamsFromOthers();
-        await paramsFromOthers.fileProc.start(file, []);
-        await paramsFromOthers.absorbRemoteChanges();
-        return paramsFromOthers;
+            return p;
+        }
+        else if (json && (typeof json === 'object')) {
+            return json;
+        }
+        else {
+            return {};
+        }
     }
-    async absorbRemoteChanges() {
-        // XXX
-        //  - check for changes: what is needed here from fileProc, and what is
-        //    generic in absorbing remote changes to refactor it into JsonFileProc
-        //  - absorb and sync, if needed: what can be in JsonFileProc
-        // Code from pre-v.sync:
-        // const { json } = await this.fileProc.get();
-        // this.setFromJSON(json);
+    let params = parseParamsFromJSON(await paramsFile.readJSON());
+    async function onChangeFromOtherDevices(newVersion) {
+        changeProc.startOrChain(async () => {
+            const { version, json } = await paramsFile.v.readJSON();
+            if (version === newVersion) {
+                const incomingParams = parseParamsFromJSON(json);
+                mergeIncomingParams(incomingParams);
+            }
+        });
     }
-    async onFileEvent(ev) {
-        if (ev.src === 'local') {
-            return;
+    function mergeIncomingParams(incomingParams) {
+        for (const [address, inP] of Object.entries(incomingParams)) {
+            const existing = params[address];
+            if (existing && (existing.timestamp >= inP.timestamp)) {
+                return;
+            }
+            params[address] = inP;
         }
-        switch (ev.type) {
-            case 'file-change':
-                await this.fileProc.order.startOrChain(() => this.absorbRemoteChanges());
-                break;
-            case 'removed':
-                throw new Error(`Unexpected removal of file with invites info`);
-            default:
+    }
+    function doOnConflict() {
+        return changeProc.startOrChain(async () => {
+            const { remote, state } = await paramsFile.v.sync.status(false);
+            if ((state !== 'conflicting') || !(remote === null || remote === void 0 ? void 0 : remote.latest)) {
                 return;
+            }
+            const onRemote = parseParamsFromJSON((await paramsFile.v.readJSON({ remoteVersion: remote.latest })).json);
+            const numRemRecs = Object.keys(onRemote).length;
+            const numExistingRecs = Object.keys(params).length;
+            let paramsWhereUpdated = (numExistingRecs > numRemRecs);
+            for (const [address, inP] of Object.entries(onRemote)) {
+                const existing = params[address];
+                if (existing.timestamp < inP.timestamp) {
+                    params[address] = inP;
+                    paramsWhereUpdated = true;
+                }
+                else if (existing.timestamp > inP.timestamp) {
+                    paramsWhereUpdated = true;
+                }
+            }
+            if (paramsWhereUpdated) {
+                await paramsFile.v.sync.upload({ uploadVersion: remote.latest + 1 });
+            }
+            else {
+                await paramsFile.v.sync.adoptRemote({ remoteVersion: remote.latest });
+            }
+        });
+    }
+    const { stopFileWatching, triggerUpload } = (0, single_file_1.watchAndApplyChangesFromOtherDevices)(paramsFile, changeProc, onChangeFromOtherDevices, doOnConflict);
+    function get(address) {
+        const p = params[address];
+        if (!p) {
+            return;
         }
+        return copyParams(p);
     }
-    async persist() {
-        const json = Array.from(this.params.values());
-        await this.fileProc.save(json, false);
+    ;
+    async function set(address, params) {
+        return changeProc.startOrChain(async () => {
+            const existing = params[address];
+            if (existing && (existing.timestamp >= params.timestamp)) {
+                return;
+            }
+            params[address] = copyParams(params);
+            await paramsFile.writeJSON(params);
+            triggerUpload();
+        });
     }
-    async close() {
-        await this.fileProc.close();
+    async function close() {
+        stopFileWatching();
     }
+    return {
+        get,
+        set,
+        close
+    };
 }
-exports.ParamsFromOthers = ParamsFromOthers;
-Object.freeze(ParamsFromOthers.prototype);
-Object.freeze(ParamsFromOthers);
 /**
  * This copies SendingParams' fields, returning a copy, which was either
  * created, or given.

package/build/core/index.d.ts

@@ -7,6 +7,7 @@ export type { makeCryptor } from 'ecma-nacl-cryptors';
 type RequestedCAPs = web3n.caps.common.RequestedCAPs;
 type W3N = web3n.caps.common.W3N;
 type ProgressCB = web3n.startup.ProgressCB;
+type FSItem = web3n.files.FSItem;
 export interface CoreConf {
     dataDir: string;
     signUpUrl: string;
@@ -27,7 +28,7 @@ export declare class Core {
     private closingProc;
     private isInitialized;
     private constructor();
-    static make(conf: CoreConf, makeNet: MakeNet, makeResolver: ServiceLocatorMaker, makeCryptor: makeCryptor, random: AsyncRNG): Core;
+    static make(conf: CoreConf, makeNet: MakeNet, makeResolver: ServiceLocatorMaker, sysFilesOnDevice: () => Promise<FSItem>, makeCryptor: makeCryptor, random: AsyncRNG): Core;
     start(saveStorageKeyForAutologin?: (storageKey: Uint8Array) => void): {
         capsForStartup: web3n.startup.W3N;
         coreInit: Promise<string>;

package/build/core/index.js

@@ -31,7 +31,7 @@ const constants_1 = require("./storage/common/constants");
 const config_1 = require("./asmail/config");
 const deferred_1 = require("../lib-common/processes/deferred");
 class Core {
-    constructor(makeNet, makeResolver, makeCryptor, random, appDirs, logger, signUpUrl) {
+    constructor(makeNet, makeResolver, makeCryptor, random, appDirs, sysFilesOnDevice, logger, signUpUrl) {
         this.makeNet = makeNet;
         this.makeResolver = makeResolver;
         this.random = random;
@@ -43,14 +43,14 @@ class Core {
         this.closingProc = undefined;
         this.isInitialized = false;
         this.cryptor = makeCryptor(this.logger.logError, this.logger.logWarning);
-        this.storages = new storage_1.Storages(this.cryptor.cryptor.sbox, this.random, this.appDirs.storagePathFor);
+        this.storages = new storage_1.Storages(this.cryptor.cryptor.sbox, this.random, this.appDirs.storagePathFor, sysFilesOnDevice);
         this.asmail = new asmail_1.ASMail(this.cryptor.cryptor.sbox, this.random, this.makeNet, this.appDirs.inboxPathFor, this.logger);
         Object.seal(this);
     }
-    static make(conf, makeNet, makeResolver, makeCryptor, random) {
+    static make(conf, makeNet, makeResolver, sysFilesOnDevice, makeCryptor, random) {
         const dirs = (0, app_files_1.appDirs)(conf.dataDir);
         const logger = (0, log_to_file_1.makeLogger)(dirs.getUtilFS());
-        const core = new Core(makeNet, makeResolver, makeCryptor, random, dirs, logger, conf.signUpUrl);
+        const core = new Core(makeNet, makeResolver, makeCryptor, random, dirs, sysFilesOnDevice, logger, conf.signUpUrl);
         return core;
     }
     start(saveStorageKeyForAutologin) {

package/build/core/keyring/index.js

@@ -33,7 +33,7 @@ Object.defineProperty(exports, "KEY_USE", { enumerable: true, get: function () {
 const INTRO_KEYS_FOLDER = 'introductory-keys';
 async function makeKeyrings(cryptor, random, logger, fs, localFS, getSigner, pkeyOnServer) {
     const workLabel = cryptor_work_labels_1.cryptoWorkLabels.makeRandom('asmail');
-    const introKeysFS = await (0, fs_sync_utils_1.getOrMakeSyncedDirOnInit)(fs, INTRO_KEYS_FOLDER);
+    const introKeysFS = await (0, fs_sync_utils_1.getOrMakeDirOnInit)(fs, INTRO_KEYS_FOLDER);
     const publishedKeys = await (0, published_intro_key_1.makeHolderOfPublishedIntroKey)(introKeysFS, getSigner, random, pkeyOnServer);
     const peerKeys = await (0, peer_keys_1.makePeersKeyring)(fs, localFS, random, logger);
     async function generateIntroKeysToSendMsg(address, introPKeyFromServer) {

package/build/core/keyring/introductory-keys/published-intro-key.js

@@ -26,17 +26,23 @@ const MAX_NUM_OF_PREV = 3;
 const INTRO_KEY_ON_SERVER_FILE = `published-on-server.json`;
 async function makeHolderOfPublishedIntroKey(introKeysFS, getSigner, random, pkeyOnServer) {
     var _a;
-    const keysFile = await (0, single_file_1.initSyncedFile)(introKeysFS, INTRO_KEY_ON_SERVER_FILE, newFile => newFile.writeJSON({ previous: [] }));
-    let keys;
-    async function setKeysFromFile() {
-        keys = await keysFile.readJSON();
+    const { file: keysFile, changeProc } = await (0, single_file_1.initSyncedFile)(introKeysFS, INTRO_KEY_ON_SERVER_FILE, newFile => newFile.writeJSON({ previous: [] }));
+    let keys = await keysFile.readJSON();
+    async function onChangeFromOtherDevices(newVersion) {
+        changeProc.startOrChain(async () => {
+            const { version, json } = await keysFile.v.readJSON();
+            if (version === newVersion) {
+                keys = json;
+            }
+        });
     }
-    await setKeysFromFile();
-    const { changeProc, stopFileWatching, triggerUpload } = (0, single_file_1.watchAndApplyChangesFromOtherDevices)(keysFile, () => changeProc.startOrChain(setKeysFromFile), doOnConflict);
+    const { stopFileWatching, triggerUpload } = (0, single_file_1.watchAndApplyChangesFromOtherDevices)(keysFile, changeProc, onChangeFromOtherDevices, doOnConflict);
     if (keysFile.isNew) {
         await update();
     }
-    updateIfCurrentExpired();
+    else {
+        updateIfCurrentExpired();
+    }
     let periodicExpiryCheck = setTimeout(updateIfCurrentExpired, UPDATE_BEFORE_EXPIRY * 1000 / 20);
     (_a = periodicExpiryCheck.unref) === null || _a === void 0 ? void 0 : _a.call(periodicExpiryCheck);
     async function makeNewIntroKey() {
@@ -77,8 +83,8 @@ async function makeHolderOfPublishedIntroKey(introKeysFS, getSigner, random, pke
     function doOnConflict() {
         return changeProc.startOrChain(async () => {
             var _a, _b, _c, _d, _e, _f;
-            const { remote } = await keysFile.v.sync.status(false);
-            if (!remote) {
+            const { remote, state } = await keysFile.v.sync.status(false);
+            if ((state !== 'conflicting') || !(remote === null || remote === void 0 ? void 0 : remote.latest)) {
                 return;
             }
             const onRemote = (await keysFile.v.readJSON({ remoteVersion: remote.latest })).json;
@@ -98,12 +104,6 @@ async function makeHolderOfPublishedIntroKey(introKeysFS, getSigner, random, pke
                 await pkeyOnServer.setOnServer((_f = (_e = keys.current) === null || _e === void 0 ? void 0 : _e.certs) !== null && _f !== void 0 ? _f : null);
                 await keysFile.v.sync.upload({ uploadVersion: remote.latest + 1 });
             }
-        })
-            .catch((exc) => {
-            if (exc.type === 'connect') {
-                // XXX need to have watcher for connection to complete upload
-                //     Should this whole try-to-connect method be generic to reuse it?
-            }
         });
     }
     /**

package/build/core/keyring/peer-keys/index.js

@@ -30,9 +30,9 @@ const LOGS_DIR = 'peer-keys-logs';
 const PEER_KEYS_FOLDER = 'peer-keys-db';
 const NUM_OF_LOGS_TO_START_CUT = 200;
 async function makePeersKeyring(keyringFS, localFS, random, logger) {
-    const logsFS = await (0, fs_sync_utils_1.getOrMakeSyncedDirOnInit)(keyringFS, LOGS_DIR);
+    const logsFS = await (0, fs_sync_utils_1.getOrMakeDirOnInit)(keyringFS, LOGS_DIR);
     const logsLocalFS = await localFS.writableSubRoot(LOGS_DIR);
-    const peerKeysFS = await (0, fs_sync_utils_1.getOrMakeSyncedDirOnInit)(keyringFS, PEER_KEYS_FOLDER);
+    const peerKeysFS = await (0, fs_sync_utils_1.getOrMakeDirOnInit)(keyringFS, PEER_KEYS_FOLDER);
     // XXX log and saving reduction(!):
     //  - we don't need to log message counts
     //  - we don't have to immediately save changes in message counts
@@ -165,11 +165,10 @@ async function makePeersKeyring(keyringFS, localFS, random, logger) {
         await logs.recordGettingCryptoFromPeer(entryToLog, peerAddr);
     }
     async function periodicCheckAndUploadOfData() {
-        // XXX disable uploading for a moment by commenting out
-        // if (logs.numOfLogs() >= NUM_OF_LOGS_TO_START_CUT) {
-        // 	const syncedIndexDbVersion = await keysDB.saveAndSync();
-        // 	await logs.cutLogOnDatasetSyncAndUpload(syncedIndexDbVersion);
-        // }
+        if (logs.numOfLogs() >= NUM_OF_LOGS_TO_START_CUT) {
+            const syncedIndexDbVersion = await keysDB.saveAndSync();
+            await logs.cutLogOnDatasetSyncAndUpload(syncedIndexDbVersion);
+        }
     }
     function millisBeforeNextRun() {
         return 30 * 60 * 1000 + Math.floor(10 * 60 * 1000 * Math.random());

package/build/core/storage/index.d.ts

@@ -17,10 +17,11 @@ export declare class Storages implements FactoryOfFSs {
     private readonly cryptor;
     private readonly random;
     private readonly storageDirForUser;
+    private readonly sysFilesOnDevice;
     private synced;
     private local;
     private preCloseWaits;
-    constructor(cryptor: AsyncSBoxCryptor, random: AsyncRNG, storageDirForUser: StoragePathForUser);
+    constructor(cryptor: AsyncSBoxCryptor, random: AsyncRNG, storageDirForUser: StoragePathForUser, sysFilesOnDevice: () => Promise<FSItem>);
     makeStorageCAP(appDomain: string, policy: StoragePolicy): {
         cap: Service;
         close: () => void;

package/build/core/storage/index.js

@@ -216,10 +216,11 @@ class StorageAndFS {
 Object.freeze(StorageAndFS.prototype);
 Object.freeze(StorageAndFS);
 class Storages {
-    constructor(cryptor, random, storageDirForUser) {
+    constructor(cryptor, random, storageDirForUser, sysFilesOnDevice) {
         this.cryptor = cryptor;
         this.random = random;
         this.storageDirForUser = storageDirForUser;
+        this.sysFilesOnDevice = sysFilesOnDevice;
         this.synced = undefined;
         this.local = undefined;
         this.preCloseWaits = new Set();
@@ -349,7 +350,7 @@ class Storages {
             fs = await this.local.userFS();
         }
         else if (type === 'device') {
-            fs = await (0, system_folders_1.userFilesOnDevice)();
+            return await (0, system_folders_1.userFilesOnDevice)();
         }
         else {
             throw new Error(`Unknown storage type ${type}`);
@@ -375,7 +376,7 @@ class Storages {
             };
         }
         else if (type === 'device') {
-            return (0, system_folders_1.sysFilesOnDevice)();
+            return this.sysFilesOnDevice();
         }
         else {
             throw new Error(`Unknown storage type ${type}`);