core-3nweb-client-lib 0.49.7 → 0.49.8

package/build/api-defs/asmail.d.ts

@@ -299,6 +299,7 @@ declare namespace web3n.asmail {
 		objNotFound?: true;
 		objId?: string;
 		msgIsBroken?: true;
+		failToDecrypt?: true;
 	}
 
 	interface ASMailSendException extends RuntimeException {

package/build/core/asmail/inbox/index.d.ts

@@ -72,35 +72,12 @@ export interface ResourcesForReceiving {
  * messages have not been removed via direct action or due to expiry.
  * This object is also responsible for expiring messages on the server.
  */
-export declare class InboxOnServer {
-    private readonly r;
-    private readonly msgReceiver;
-    private readonly storages;
-    private readonly cryptor;
-    private readonly random;
-    private readonly downloader;
-    private readonly cache;
-    private readonly index;
-    private readonly logError;
-    private readonly inboxEvents;
-    private readonly procs;
-    private readonly recentlyOpenedMsgs;
-    private constructor();
-    static makeAndStart(cachePath: string, syncedFS: WritableFS, localFS: WritableFS, r: ResourcesForReceiving): Promise<InboxOnServer>;
-    close(): Promise<void>;
-    makeCAP(): InboxService;
-    private removeMsg;
-    private removeMsgFromServerAndCache;
-    private msgFromDiskOrDownload;
-    private startCachingAndAddKeyToIndex;
-    private markOwnParams;
-    private absorbSendingParams;
-    private listMsgs;
-    private listNewMsgs;
-    private getMsg;
-    private msgToUIForm;
-    suspendNetworkActivity(): void;
-    resumeNetworkActivity(): void;
-    get connectivityEvent$(): import("rxjs").Observable<import("./inbox-events").InboxConnectionStatus>;
-}
+export type InboxOnServer = Awaited<ReturnType<typeof makeInboxOnServer>>;
+export declare function makeInboxOnServer(cachePath: string, syncedFS: WritableFS, localFS: WritableFS, r: ResourcesForReceiving): Promise<{
+    connectivityEvent$: import("rxjs").Observable<import("./inbox-events").InboxConnectionStatus>;
+    resumeNetworkActivity: () => void;
+    suspendNetworkActivity: () => void;
+    close: () => Promise<void>;
+    makeCAP: () => InboxService;
+}>;
 export {};

package/build/core/asmail/inbox/index.js

@@ -16,8 +16,7 @@
  this program. If not, see <http://www.gnu.org/licenses/>.
 */
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.InboxOnServer = void 0;
-const error_1 = require("../../../lib-common/exceptions/error");
+exports.makeInboxOnServer = makeInboxOnServer;
 const synced_1 = require("../../../lib-common/processes/synced");
 const recipient_1 = require("../../../lib-client/asmail/recipient");
 const opener_1 = require("../msg/opener");
@@ -32,189 +31,161 @@ const cached_msgs_1 = require("./cached-msgs");
 const timed_cache_1 = require("../../../lib-common/timed-cache");
 const fs_sync_utils_1 = require("../../../lib-client/fs-utils/fs-sync-utils");
 const MSG_INDEX_FOLDER = 'msg-index';
-/**
- * Instance of this class represents inbox-on-mail-server.
- * It uses api to manage messages on a ASMail server, caching and recording
- * some information to allow faster response, and to keep message keys, while
- * messages have not been removed via direct action or due to expiry.
- * This object is also responsible for expiring messages on the server.
- */
-class InboxOnServer {
-    constructor(r, msgReceiver, storages, cryptor, random, downloader, cache, index, logError) {
-        this.r = r;
-        this.msgReceiver = msgReceiver;
-        this.storages = storages;
-        this.cryptor = cryptor;
-        this.random = random;
-        this.downloader = downloader;
-        this.cache = cache;
-        this.index = index;
-        this.logError = logError;
-        this.procs = new synced_1.NamedProcs();
-        this.recentlyOpenedMsgs = (0, timed_cache_1.makeTimedCache)(60 * 1000);
-        this.inboxEvents = new inbox_events_1.InboxEvents(this.msgReceiver, this.getMsg.bind(this), this.listNewMsgs.bind(this), this.removeMsg.bind(this), this.logError);
-        Object.seal(this);
+async function makeInboxOnServer(cachePath, syncedFS, localFS, r) {
+    const procs = new synced_1.NamedProcs();
+    const recentlyOpenedMsgs = (0, timed_cache_1.makeTimedCache)(60 * 1000);
+    const { getStorages, cryptor, random, logError, } = r;
+    (0, file_1.ensureCorrectFS)(syncedFS, 'synced', true);
+    const indexSyncedFS = await (0, fs_sync_utils_1.getOrMakeSyncedDirOnInit)(syncedFS, MSG_INDEX_FOLDER);
+    const indexLocalFS = await localFS.writableSubRoot(MSG_INDEX_FOLDER);
+    const msgReceiver = new recipient_1.MailRecipient(r.address, r.getSigner, () => r.asmailResolver(r.address), r.makeNet());
+    const downloader = new msg_downloader_1.MsgDownloader(msgReceiver);
+    const cache = await cached_msgs_1.CachedMessages.makeFor(cachePath, downloader, r.logError);
+    const index = await (0, msg_indexing_1.makeMsgIndex)(indexSyncedFS, indexLocalFS, r.logError);
+    const inboxEvents = new inbox_events_1.InboxEvents(msgReceiver, getMsg, listNewMsgs, removeMsg, r.logError);
+    async function close() {
+        index.stopSyncing();
+        inboxEvents.close();
     }
-    static async makeAndStart(cachePath, syncedFS, localFS, r) {
-        try {
-            (0, file_1.ensureCorrectFS)(syncedFS, 'synced', true);
-            const msgReceiver = new recipient_1.MailRecipient(r.address, r.getSigner, () => r.asmailResolver(r.address), r.makeNet());
-            const downloader = new msg_downloader_1.MsgDownloader(msgReceiver);
-            const cache = await cached_msgs_1.CachedMessages.makeFor(cachePath, downloader, r.logError);
-            const indexSyncedFS = await (0, fs_sync_utils_1.getOrMakeSyncedDirOnInit)(syncedFS, MSG_INDEX_FOLDER);
-            const indexLocalFS = await localFS.writableSubRoot(MSG_INDEX_FOLDER);
-            const index = await (0, msg_indexing_1.makeMsgIndex)(indexSyncedFS, indexLocalFS, r.logError);
-            const inbox = new InboxOnServer(r.correspondents, msgReceiver, r.getStorages, r.cryptor, r.random, downloader, cache, index, r.logError);
-            return inbox;
-        }
-        catch (err) {
-            throw (0, error_1.errWithCause)(err, 'Failed to initialize Inbox');
-        }
-    }
-    async close() {
-        this.index.stopSyncing();
-        this.inboxEvents.close();
-    }
-    makeCAP() {
+    function makeCAP() {
         const service = {
-            getMsg: this.getMsg.bind(this),
-            listMsgs: this.listMsgs.bind(this),
-            removeMsg: this.removeMsg.bind(this),
-            subscribe: this.inboxEvents.subscribe.bind(this.inboxEvents)
+            getMsg,
+            listMsgs,
+            removeMsg,
+            subscribe: inboxEvents.subscribe.bind(inboxEvents)
         };
         return Object.freeze(service);
     }
-    async removeMsg(msgId) {
+    async function removeMsg(msgId) {
         // check for an already started process
         const procId = 'removal of ' + msgId;
-        const promise = this.procs.latestTaskAtThisMoment(procId);
+        const promise = procs.latestTaskAtThisMoment(procId);
         if (promise) {
             return promise;
         }
         // start removal process
-        return this.procs.start(procId, (async () => {
+        return procs.start(procId, (async () => {
             await Promise.all([
-                this.index.remove(msgId),
-                this.removeMsgFromServerAndCache(msgId)
+                index.remove(msgId),
+                removeMsgFromServerAndCache(msgId)
             ]);
         }));
     }
-    async removeMsgFromServerAndCache(msgId) {
+    async function removeMsgFromServerAndCache(msgId) {
         await Promise.all([
-            this.cache.deleteMsg(msgId),
+            cache.deleteMsg(msgId),
             // XXX the following is suspicious, as it swallows other exceptions too
-            this.msgReceiver.removeMsg(msgId).catch(() => { })
+            msgReceiver.removeMsg(msgId).catch(() => { })
         ]);
     }
-    async msgFromDiskOrDownload(msgId) {
-        const msgOnDisk = await this.cache.findMsg(msgId);
+    async function msgFromDiskOrDownload(msgId) {
+        const msgOnDisk = await cache.findMsg(msgId);
         if (msgOnDisk) {
             return msgOnDisk;
         }
-        const meta = await this.downloader.getMsgMeta(msgId);
-        return await this.cache.addMsg(msgId, meta);
+        const meta = await downloader.getMsgMeta(msgId);
+        return await cache.addMsg(msgId, meta);
+    }
+    function checkerOfMidKeyCerts(deliveryTS) {
+        return (certs) => (0, key_verification_1.checkAndExtractPKeyWithAddress)(msgReceiver.getNet(), r.correspondents.midResolver, certs, Math.round(deliveryTS / 1000));
+    }
+    function msgReadingAndOpening(msgId, mainObjId, msgOnDisk) {
+        // lazy main obj source
+        let mainObjSrc = undefined;
+        async function getMainObjHeader() {
+            if (!mainObjSrc) {
+                mainObjSrc = await msgOnDisk.getMsgObj(mainObjId);
+            }
+            return mainObjSrc.readHeader();
+        }
+        async function getOpenedMsg(mainObjFileKey, msgKeyPackLen) {
+            if (!mainObjSrc) {
+                mainObjSrc = await msgOnDisk.getMsgObj(mainObjId);
+            }
+            return await (0, opener_1.openMsg)(msgId, mainObjId, mainObjSrc, msgKeyPackLen, mainObjFileKey, cryptor);
+        }
+        return {
+            getMainObjHeader, getOpenedMsg
+        };
     }
-    async startCachingAndAddKeyToIndex(msgId) {
-        const msgOnDisk = await this.msgFromDiskOrDownload(msgId);
+    async function startCachingAndAddKeyToIndex(msgId) {
+        const msgOnDisk = await msgFromDiskOrDownload(msgId);
         const meta = await msgOnDisk.getMsgMeta();
+        const { getMainObjHeader, getOpenedMsg } = msgReadingAndOpening(msgId, meta.extMeta.objIds[0], msgOnDisk);
         try {
-            // setup closures, some memoized, for use by keyring
-            let mainObjSrc = undefined;
-            const mainObjId = meta.extMeta.objIds[0];
-            const getMainObjHeader = async () => {
-                if (!mainObjSrc) {
-                    mainObjSrc = await msgOnDisk.getMsgObj(mainObjId);
-                }
-                return mainObjSrc.readHeader();
-            };
-            const getOpenedMsg = async (mainObjFileKey, msgKeyPackLen) => {
-                if (!mainObjSrc) {
-                    mainObjSrc = await msgOnDisk.getMsgObj(mainObjId);
-                }
-                const openedMsg = await (0, opener_1.openMsg)(msgId, mainObjId, mainObjSrc, msgKeyPackLen, mainObjFileKey, this.cryptor);
-                return openedMsg;
-            };
-            const checkMidKeyCerts = (certs) => {
-                return (0, key_verification_1.checkAndExtractPKeyWithAddress)(this.msgReceiver.getNet(), this.r.midResolver, certs, Math.round(msgOnDisk.deliveryTS / 1000));
-            };
-            const decrOut = await this.r.msgDecryptor(meta.extMeta, getMainObjHeader, getOpenedMsg, checkMidKeyCerts);
+            const decrOut = await r.correspondents.msgDecryptor(meta.extMeta, getMainObjHeader, getOpenedMsg, checkerOfMidKeyCerts(msgOnDisk.deliveryTS));
             if (decrOut) {
                 const { decrInfo, openedMsg } = decrOut;
                 openedMsg.setMsgKeyRole(decrInfo.keyStatus);
+                // XXX we have never used this part of protocol, should it be removed at all from ASMail protocol?
                 checkServerAuthIfPresent(meta, decrInfo);
                 // add records cache and to index
-                this.recentlyOpenedMsgs.set(msgId, openedMsg);
+                recentlyOpenedMsgs.set(msgId, openedMsg);
                 const msgInfo = {
                     msgType: openedMsg.getSection('Msg Type'),
                     msgId,
                     deliveryTS: msgOnDisk.deliveryTS
                 };
-                await this.index.add(msgInfo, decrInfo);
+                await index.add(msgInfo, decrInfo);
                 await Promise.all([
-                    this.absorbSendingParams(openedMsg),
-                    this.markOwnParams(meta, openedMsg.sender)
+                    absorbSendingParams(openedMsg),
+                    markOwnParams(meta, openedMsg.sender)
                 ]);
             }
             else {
                 // check, if msg has already been indexed
-                const knownDecr = await this.index.getKeyFor(msgId, msgOnDisk.deliveryTS);
+                const knownDecr = await index.getKeyFor(msgId, msgOnDisk.deliveryTS);
                 if (!knownDecr) {
-                    await msgOnDisk.updateMsgKeyStatus('not-found');
                     return false;
                 }
-                // TODO try to open main message, just as a check
             }
-            await msgOnDisk.updateMsgKeyStatus('ok');
             return true;
         }
         catch (exc) {
-            await this.logError(exc, `Problem with opening message ${msgId}`);
-            if (msgOnDisk.keyStatus !== 'ok') {
-                await msgOnDisk.updateMsgKeyStatus('fail');
-            }
+            await logError(exc, `Problem with opening message ${msgId}`);
             return false;
         }
     }
-    async markOwnParams(meta, sender) {
+    async function markOwnParams(meta, sender) {
         if (!meta.invite) {
             return;
         }
-        await this.r.markOwnSendingParamsAsUsed(sender, meta.invite);
+        await r.correspondents.markOwnSendingParamsAsUsed(sender, meta.invite);
     }
-    async absorbSendingParams(openedMsg) {
+    async function absorbSendingParams(openedMsg) {
         const sendingParams = openedMsg.nextSendingParams;
         if (!sendingParams) {
             return;
         }
         const address = openedMsg.sender;
-        await this.r.saveParamsForSendingTo(address, sendingParams);
+        await r.correspondents.saveParamsForSendingTo(address, sendingParams);
     }
-    async listMsgs(fromTS) {
-        const checkServer = true; // XXX in future this will be an option from req
-        if (!checkServer) {
-            return this.index.listMsgs(fromTS);
-        }
-        // check for an already started process
-        const procId = 'listing msgs';
-        const promise = this.procs.latestTaskAtThisMoment(procId);
+    function debouncingProc(procId, action) {
+        const promise = procs.latestTaskAtThisMoment(procId);
         if (promise) {
             return promise;
         }
-        // start message listing process
-        return this.procs.start(procId, async () => {
+        return procs.start(procId, action);
+    }
+    async function listMsgs(fromTS) {
+        const checkServer = true; // XXX in future this will be an option from req
+        if (!checkServer) {
+            return index.listMsgs(fromTS);
+        }
+        return debouncingProc('listing msgs', async () => {
             // message listing info is located in index, yet, process involves
             // getting and caching messages' metadata
             let msgIds;
             try {
-                msgIds = await this.msgReceiver.listMsgs(fromTS);
+                msgIds = await msgReceiver.listMsgs(fromTS);
             }
             catch (exc) {
                 if (exc.type !== 'connect') {
                     throw exc;
                 }
-                return this.index.listMsgs(fromTS);
+                return index.listMsgs(fromTS);
             }
-            const indexedMsgs = await this.index.listMsgs(fromTS);
+            const indexedMsgs = await index.listMsgs(fromTS);
             for (const info of indexedMsgs) {
                 const ind = msgIds.indexOf(info.msgId);
                 if (ind >= 0) {
@@ -224,17 +195,17 @@ class InboxOnServer {
             if (msgIds.length === 0) {
                 return indexedMsgs;
             }
-            await Promise.all(msgIds.map(msgId => this.startCachingAndAddKeyToIndex(msgId)
+            await Promise.all(msgIds.map(msgId => startCachingAndAddKeyToIndex(msgId)
                 .catch(async (exc) => {
-                await this.logError(exc, `Failed to start caching message ${msgId}`);
+                await logError(exc, `Failed to start caching message ${msgId}`);
             })));
-            return this.index.listMsgs(fromTS);
+            return index.listMsgs(fromTS);
         });
     }
-    async listNewMsgs(fromTS) {
-        const msgIds = await this.msgReceiver.listMsgs(fromTS);
+    async function listNewMsgs(fromTS) {
+        const msgIds = await msgReceiver.listMsgs(fromTS);
         // remove from listing messages already in index
-        const indexedMsgs = await this.index.listMsgs(fromTS);
+        const indexedMsgs = await index.listMsgs(fromTS);
         for (const info of indexedMsgs) {
             const ind = msgIds.indexOf(info.msgId);
             if (ind >= 0) {
@@ -245,54 +216,39 @@ class InboxOnServer {
             return [];
         }
         // cache and index these
-        await Promise.all(msgIds.map(msgId => this.startCachingAndAddKeyToIndex(msgId)));
+        await Promise.all(msgIds.map(msgId => startCachingAndAddKeyToIndex(msgId)));
         // get info's from index, focusing on specific messages only
-        return (await this.index.listMsgs(fromTS)).filter(({ msgId }) => msgIds.includes(msgId));
+        return (await index.listMsgs(fromTS)).filter(({ msgId }) => msgIds.includes(msgId));
     }
-    async getMsg(msgId) {
+    async function getMsg(msgId) {
         if (!msgId || (typeof msgId !== 'string')) {
             throw `Given message id is not a non-empty string`;
         }
-        const procId = `get msg #${msgId}`;
-        const promise = this.procs.latestTaskAtThisMoment(procId);
-        if (promise) {
-            return promise;
-        }
-        return this.procs.start(procId, async () => {
-            const msgOnDisk = await this.msgFromDiskOrDownload(msgId);
-            let msg = this.recentlyOpenedMsgs.get(msgId);
+        return debouncingProc(`get msg #${msgId}`, async () => {
+            const msgOnDisk = await msgFromDiskOrDownload(msgId);
+            let msg = recentlyOpenedMsgs.get(msgId);
             if (msg) {
-                return this.msgToUIForm(msg, msgOnDisk.deliveryTS, msgOnDisk);
-            }
-            if ((msgOnDisk.keyStatus === 'not-found')
-                || (msgOnDisk.keyStatus === 'fail')) {
-                // XXX 
-                // message cannot be opened, and should be removed
-                // await Promise.all([
-                // 	this.index.remove(msgInfo),
-                // 	this.removeMsgFromServerAndCache(msgId)
-                // ]);
-                throw (0, recipient_1.makeMsgNotFoundException)(msgId);
-            }
-            else if (msgOnDisk.keyStatus === 'not-checked') {
-                await this.startCachingAndAddKeyToIndex(msgId);
-            }
-            else if (msgOnDisk.keyStatus !== 'ok') {
-                throw new Error(`Unknown message key status ${msgOnDisk.keyStatus}`);
+                return msgToUIForm(msg, msgOnDisk.deliveryTS, msgOnDisk);
             }
             const meta = await msgOnDisk.getMsgMeta();
             const mainObjId = meta.extMeta.objIds[0];
             const mainObj = await msgOnDisk.getMsgObj(mainObjId);
-            const msgKey = await this.index.getKeyFor(msgId, meta.deliveryCompletion);
+            let msgKey = await index.getKeyFor(msgId, meta.deliveryCompletion);
             if (!msgKey) {
-                throw (0, recipient_1.makeMsgNotFoundException)(msgId);
+                if (!(await startCachingAndAddKeyToIndex(msgId))) {
+                    throw (0, recipient_1.makeFailToDecryptMsgException)(msgId);
+                }
+                msgKey = await index.getKeyFor(msgId, meta.deliveryCompletion);
+                if (!msgKey) {
+                    throw (0, recipient_1.makeFailToDecryptMsgException)(msgId);
+                }
             }
-            msg = await (0, opener_1.openMsg)(msgId, mainObjId, mainObj, msgKey.mainObjHeaderOfs, msgKey.msgKey, this.cryptor);
+            msg = await (0, opener_1.openMsg)(msgId, mainObjId, mainObj, msgKey.mainObjHeaderOfs, msgKey.msgKey, cryptor);
             msg.setMsgKeyRole(msgKey.msgKeyRole);
-            return this.msgToUIForm(msg, msgOnDisk.deliveryTS, msgOnDisk);
+            return msgToUIForm(msg, msgOnDisk.deliveryTS, msgOnDisk);
         });
     }
-    msgToUIForm(msg, deliveryTS, msgOnDisk) {
+    function msgToUIForm(msg, deliveryTS, msgOnDisk) {
         const m = {
             sender: msg.sender,
             establishedSenderKeyChain: msg.establishedKeyChain,
@@ -317,23 +273,18 @@ class InboxOnServer {
         }
         const attachments = msg.attachmentsJSON;
         if (attachments) {
-            m.attachments = (0, fs_1.fsForAttachments)(msgOnDisk, attachments, this.storages, this.cryptor, this.random, this.logError);
+            m.attachments = (0, fs_1.fsForAttachments)(msgOnDisk, attachments, getStorages, cryptor, random, logError);
         }
         return m;
     }
-    suspendNetworkActivity() {
-        this.inboxEvents.suspendNetworkActivity();
-    }
-    resumeNetworkActivity() {
-        this.inboxEvents.resumeNetworkActivity();
-    }
-    get connectivityEvent$() {
-        return this.inboxEvents.connectionEvent$;
-    }
+    return {
+        connectivityEvent$: inboxEvents.connectionEvent$,
+        resumeNetworkActivity: inboxEvents.resumeNetworkActivity.bind(inboxEvents),
+        suspendNetworkActivity: inboxEvents.suspendNetworkActivity.bind(inboxEvents),
+        close,
+        makeCAP
+    };
 }
-exports.InboxOnServer = InboxOnServer;
-Object.freeze(InboxOnServer.prototype);
-Object.freeze(InboxOnServer);
 function checkServerAuthIfPresent(meta, { correspondent }) {
     // if sender authenticated to server, check that it matches address,
     // recovered from message decryption 

package/build/core/asmail/inbox/msg-on-disk.d.ts

@@ -2,14 +2,12 @@ import { ObjOnDisk } from '../../../lib-client/objs-on-disk/obj-on-disk';
 import { MsgMeta } from '../../../lib-common/service-api/asmail/retrieval';
 import { ObjSource } from 'xsp-files';
 import { MsgDownloader } from './msg-downloader';
-export type MsgKeyStatus = 'not-checked' | 'not-found' | 'fail' | 'ok';
 export interface ObjSize {
     header: number;
     segments: number;
 }
 export interface MsgStatus {
     msgId: string;
-    keyStatus: MsgKeyStatus;
     onDisk: boolean;
     mainObjId: string;
     deliveryTS: number;
@@ -31,7 +29,4 @@ export declare class MsgOnDisk {
     getObjFile(objId: string): Promise<ObjOnDisk>;
     getMsgObj(objId: string): Promise<ObjSource>;
     get deliveryTS(): number;
-    get keyStatus(): MsgKeyStatus;
-    updateMsgKeyStatus(newStatus: Exclude<MsgKeyStatus, 'not-checked'>): Promise<void>;
-    private saveStatusToDisk;
 }

package/build/core/asmail/inbox/msg-on-disk.js

@@ -1,6 +1,6 @@
 "use strict";
 /*
- Copyright (C) 2016 - 2019 3NSoft Inc.
+ Copyright (C) 2016 - 2019, 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
@@ -27,7 +27,6 @@ const STATUS_FNAME = 'status.json';
 function makeInitMsgStatus(msgId, meta) {
     return {
         msgId,
-        keyStatus: 'not-checked',
         onDisk: false,
         mainObjId: meta.extMeta.objIds[0],
         deliveryTS: meta.deliveryStart
@@ -94,26 +93,6 @@ class MsgOnDisk {
     get deliveryTS() {
         return this.status.deliveryTS;
     }
-    get keyStatus() {
-        return this.status.keyStatus;
-    }
-    updateMsgKeyStatus(newStatus) {
-        return this.syncProc.startOrChain(async () => {
-            if (this.status.keyStatus === 'not-checked') {
-                this.status.keyStatus = newStatus;
-            }
-            else if (this.status.keyStatus === newStatus) {
-                return;
-            }
-            else {
-                throw Error(`Message has key status ${this.status.keyStatus}, and can't be updated to ${newStatus}`);
-            }
-            await this.saveStatusToDisk();
-        });
-    }
-    async saveStatusToDisk() {
-        await writeJSON(this.msgFolderPath, STATUS_FNAME, this.status);
-    }
 }
 exports.MsgOnDisk = MsgOnDisk;
 Object.freeze(MsgOnDisk.prototype);

package/build/core/asmail/index.js

@@ -90,7 +90,7 @@ class ASMail {
         const cachePath = this.inboxPathForUser(this.address);
         const inboxSyncedFS = await (0, fs_sync_utils_1.getOrMakeSyncedDirOnInit)(syncedFS, INBOX_DATA_FOLDER);
         const inboxLocalFS = await localFS.writableSubRoot(INBOX_DATA_FOLDER);
-        this.inbox = await inbox_1.InboxOnServer.makeAndStart(cachePath, inboxSyncedFS, inboxLocalFS, {
+        this.inbox = await (0, inbox_1.makeInboxOnServer)(cachePath, inboxSyncedFS, inboxLocalFS, {
             address: this.address,
             cryptor: this.cryptor,
             random: this.random,

package/build/core/keyring/index.js

@@ -31,11 +31,10 @@ const buffer_utils_1 = require("../../lib-common/buffer-utils");
 var common_2 = require("./common");
 Object.defineProperty(exports, "KEY_USE", { enumerable: true, get: function () { return common_2.KEY_USE; } });
 const INTRO_KEYS_FOLDER = 'introductory-keys';
-const INTRO_KEY_ON_SERVER_FILE = `published-on-server.json`;
 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 publishedKeys = await (0, published_intro_key_1.makeHolderOfPublishedIntroKey)(await introKeysFS.writableFile(INTRO_KEY_ON_SERVER_FILE), getSigner, random, pkeyOnServer);
+    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) {
         if (introPKeyFromServer.alg !== ecma_nacl_1.box.JWK_ALG_NAME) {

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

@@ -2,9 +2,9 @@ import { ParamOnServer } from '../../../lib-client/asmail/service-config';
 import { AsyncRNG } from '../../../lib-common/rng-def';
 import { GetSigner } from '../../id-manager';
 import { JWKeyPair, MsgKeyRole } from '../common';
-type WritableFile = web3n.files.WritableFile;
+type WritableFS = web3n.files.WritableFS;
 type IntroKeyCAP = web3n.keys.Keyrings['introKeyOnASMailServer'];
-export declare function makeHolderOfPublishedIntroKey(file: WritableFile, getSigner: GetSigner, random: AsyncRNG, pkeyOnServer: ParamOnServer<'init-pub-key'>): Promise<{
+export declare function makeHolderOfPublishedIntroKey(introKeysFS: WritableFS, getSigner: GetSigner, random: AsyncRNG, pkeyOnServer: ParamOnServer<'init-pub-key'>): Promise<{
     startExpiryCheckProcess: () => void;
     close: () => Promise<void>;
     makeIntroKeyCAP: () => IntroKeyCAP;

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

@@ -17,53 +17,28 @@
 */
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.makeHolderOfPublishedIntroKey = makeHolderOfPublishedIntroKey;
-const file_based_json_1 = require("../../../lib-client/xsp-fs/util/file-based-json");
+const single_file_1 = require("../../../lib-common/dataset-sync/single-file");
 const jwkeys_1 = require("../../../lib-common/jwkeys");
 const common_1 = require("../common");
 const INTRO_KEY_VALIDITY = 31 * 24 * 60 * 60;
 const UPDATE_BEFORE_EXPIRY = 7 * 24 * 60 * 60;
-async function makeHolderOfPublishedIntroKey(file, getSigner, random, pkeyOnServer) {
+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;
-    let published = {
-        previous: []
-    };
-    // XXX JsonFileProc is too little, in comparison to operations syn, and watching file
-    const fileProc = new file_based_json_1.JsonFileProc(onFileEvent);
-    async function onFileEvent(ev) {
-        if (ev.src === 'local') {
-            return;
-        }
-        switch (ev.type) {
-            case 'file-change':
-                await fileProc.order.startOrChain(() => absorbRemoteChanges());
-                break;
-            case 'removed':
-                throw new Error(`Unexpected removal of file with parameter "anon-sender/invites"`);
-            default:
-                return;
-        }
+    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();
     }
-    function setFromJSON(json) {
-        if (!Array.isArray(json.previous)) { // migration part
-            json.previous = (json.previous ? [json.previous] : []);
-        }
-        published = json;
-    }
-    function toFileJSON() {
-        return published;
-    }
-    // private toServerParam(): PKeyCertChain|undefined {
-    // 	return published.current?.certs;
-    // }
-    async function 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 fileProc.get();
-        // setFromJSON(json);
+    await setKeysFromFile();
+    const { changeProc, stopFileWatching, triggerUpload } = (0, single_file_1.watchAndApplyChangesFromOtherDevices)(keysFile, () => changeProc.startOrChain(setKeysFromFile), doOnConflict);
+    if (keysFile.isNew) {
+        await update();
     }
+    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() {
         const signer = await getSigner();
         const pair = await (0, common_1.generateKeyPair)(random);
@@ -76,24 +51,60 @@ async function makeHolderOfPublishedIntroKey(file, getSigner, random, pkeyOnServ
         return { pair, certs };
     }
     function update() {
-        return fileProc.order.startOrChain(async () => {
+        return changeProc.startOrChain(async () => {
             const { certs, pair: keyPair } = await makeNewIntroKey();
             await pkeyOnServer.setOnServer(certs);
             retireCurrent(keyPair.createdAt);
-            published.current = { keyPair, certs };
-            await fileProc.save(toFileJSON(), false);
+            keys.current = { keyPair, certs };
+            await keysFile.writeJSON(keys);
+            triggerUpload();
             return certs;
         });
     }
     ;
     function retireCurrent(retiredAt) {
-        if (!published.current) {
+        if (!keys.current) {
             return;
         }
-        const current = published.current;
+        const current = keys.current;
         current.keyPair.retiredAt = retiredAt;
-        published.previous.push(current.keyPair);
-        published.current = undefined;
+        keys.previous.push(current.keyPair);
+        if (keys.previous.length > MAX_NUM_OF_PREV) {
+            keys.previous.splice(0, keys.previous.length - MAX_NUM_OF_PREV);
+        }
+        keys.current = undefined;
+    }
+    function doOnConflict() {
+        return changeProc.startOrChain(async () => {
+            var _a, _b, _c, _d, _e, _f;
+            const { remote } = await keysFile.v.sync.status(false);
+            if (!remote) {
+                return;
+            }
+            const onRemote = (await keysFile.v.readJSON({ remoteVersion: remote.latest })).json;
+            if (((_a = onRemote.current) === null || _a === void 0 ? void 0 : _a.keyPair.pkey.kid) === ((_b = keys.current) === null || _b === void 0 ? void 0 : _b.keyPair.pkey.kid)) {
+                await keysFile.v.sync.adoptRemote();
+                return;
+            }
+            const certsOnServer = await pkeyOnServer.getFromServer();
+            const currentOnServer = (certsOnServer ? (0, jwkeys_1.getPubKey)(certsOnServer.pkeyCert) : undefined);
+            if ((currentOnServer === null || currentOnServer === void 0 ? void 0 : currentOnServer.kid) === ((_c = keys.current) === null || _c === void 0 ? void 0 : _c.keyPair.pkey.kid)) {
+                await keysFile.v.sync.upload({ uploadVersion: remote.latest + 1 });
+            }
+            else if ((currentOnServer === null || currentOnServer === void 0 ? void 0 : currentOnServer.kid) === ((_d = onRemote.current) === null || _d === void 0 ? void 0 : _d.keyPair.pkey.kid)) {
+                await keysFile.v.sync.adoptRemote({ remoteVersion: remote.latest });
+            }
+            else {
+                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?
+            }
+        });
     }
     /**
      * This looks for a published key with a given key id. If it is found, an
@@ -108,15 +119,15 @@ async function makeHolderOfPublishedIntroKey(file, getSigner, random, pkeyOnServ
      */
     function find(kid) {
         // check current key
-        if (published.current
-            && (published.current.keyPair.skey.kid === kid)) {
+        if (keys.current
+            && (keys.current.keyPair.skey.kid === kid)) {
             return {
                 role: 'published_intro',
-                pair: published.current.keyPair
+                pair: keys.current.keyPair
             };
         }
         // check previous key
-        const pair = published.previous.find(({ skey }) => (skey.kid === kid));
+        const pair = keys.previous.find(({ skey }) => (skey.kid === kid));
         if (pair) {
             return {
                 role: 'prev_published_intro',
@@ -137,24 +148,25 @@ async function makeHolderOfPublishedIntroKey(file, getSigner, random, pkeyOnServ
     }
     async function getCurrent() {
         var _a;
-        const certs = (_a = published.current) === null || _a === void 0 ? void 0 : _a.certs;
+        const certs = (_a = keys.current) === null || _a === void 0 ? void 0 : _a.certs;
         return (certs ? certs : null);
     }
     async function removeCurrent() {
-        if (!published.current) {
+        if (!keys.current) {
             return;
         }
-        return fileProc.order.startOrChain(async () => {
+        return changeProc.startOrChain(async () => {
             await pkeyOnServer.setOnServer(null);
             retireCurrent(Math.floor(Date.now() / 1000));
+            await keysFile.writeJSON(keys);
+            triggerUpload();
         });
     }
-    let periodicExpiryCheck = undefined;
-    function startExpiryCheckProcess() {
-        if (!published.current) {
+    function updateIfCurrentExpired() {
+        if (!keys.current) {
             return;
         }
-        const { pkeyCert } = published.current.certs;
+        const { pkeyCert } = keys.current.certs;
         const expiryInSeconds = (0, jwkeys_1.getKeyCert)(pkeyCert).expiresAt;
         const now = Math.floor(Date.now() / 1000);
         if (expiryInSeconds < (now + UPDATE_BEFORE_EXPIRY)) {
@@ -162,26 +174,14 @@ async function makeHolderOfPublishedIntroKey(file, getSigner, random, pkeyOnServ
         }
     }
     async function close() {
+        stopFileWatching();
         if (periodicExpiryCheck) {
             clearTimeout(periodicExpiryCheck);
             periodicExpiryCheck = undefined;
         }
-        await fileProc.close();
-    }
-    if (file.isNew) {
-        await fileProc.start(file, toFileJSON);
-        await update();
-    }
-    else {
-        await fileProc.start(file, undefined);
-        setFromJSON((await fileProc.get()).json);
-        await absorbRemoteChanges();
-        startExpiryCheckProcess();
-        periodicExpiryCheck = setTimeout(startExpiryCheckProcess, UPDATE_BEFORE_EXPIRY * 1000 / 20);
-        (_a = periodicExpiryCheck.unref) === null || _a === void 0 ? void 0 : _a.call(periodicExpiryCheck);
     }
     return {
-        startExpiryCheckProcess,
+        startExpiryCheckProcess: updateIfCurrentExpired,
         close,
         makeIntroKeyCAP,
         find

package/build/lib-client/asmail/recipient.d.ts

@@ -5,6 +5,7 @@ import { SubscribingClient } from '../../lib-common/ipc/ws-ipc';
 type InboxException = web3n.asmail.InboxException;
 type Observer<T> = web3n.Observer<T>;
 export declare function makeMsgNotFoundException(msgId: string): InboxException;
+export declare function makeFailToDecryptMsgException(msgId: string): InboxException;
 export declare function makeObjNotFoundException(msgId: string, objId: string): InboxException;
 export declare function makeMsgIsBrokenException(msgId: string): InboxException;
 export declare class MailRecipient extends ServiceUser {

package/build/lib-client/asmail/recipient.js

@@ -18,6 +18,7 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.MailRecipient = void 0;
 exports.makeMsgNotFoundException = makeMsgNotFoundException;
+exports.makeFailToDecryptMsgException = makeFailToDecryptMsgException;
 exports.makeObjNotFoundException = makeObjNotFoundException;
 exports.makeMsgIsBrokenException = makeMsgIsBrokenException;
 const request_utils_1 = require("../request-utils");
@@ -37,6 +38,16 @@ function makeMsgNotFoundException(msgId) {
     };
     return exc;
 }
+function makeFailToDecryptMsgException(msgId) {
+    const exc = {
+        runtimeException: true,
+        type: 'inbox',
+        msgId,
+        failToDecrypt: true,
+        stack: (0, runtime_1.getStackHere)(1)
+    };
+    return exc;
+}
 function makeObjNotFoundException(msgId, objId) {
     const exc = {
         runtimeException: true,

package/build/lib-client/xsp-fs/folder-node.js

@@ -36,7 +36,6 @@ const folder_node_serialization_1 = require("./folder-node-serialization");
 const attrs_1 = require("./attrs");
 const node_persistence_1 = require("./node-persistence");
 const assert_1 = require("../../lib-common/assert");
-const for_arrays_1 = require("./util/for-arrays");
 function jsonToInfoAndAttrs(json) {
     const folderInfo = {
         nodes: (0, json_utils_1.copy)(json.nodes)
@@ -870,7 +869,7 @@ class FolderNode extends node_in_fs_1.NodeInFS {
     async uploadRemovalOf(removedNodes) {
         const rmObjs = [];
         for (const node of removedNodes) {
-            (0, for_arrays_1.appendArray)(rmObjs, await this.listRemovedInTreeToUploadRm(node));
+            appendArray(rmObjs, await this.listRemovedInTreeToUploadRm(node));
         }
         await this.uploadRemovalOfObjs(rmObjs);
     }
@@ -896,7 +895,7 @@ class FolderNode extends node_in_fs_1.NodeInFS {
             const src = await storage.getObjSrc(node.objId, versionBeforeRm, true);
             const folderContent = await FolderPersistance.readFolderContent(node.objId, node.key, src, storage.cryptor, storage.random);
             for (const child of Object.values(folderContent.nodes)) {
-                (0, for_arrays_1.appendArray)(objs, await this.listRemovedInTreeToUploadRm(child));
+                appendArray(objs, await this.listRemovedInTreeToUploadRm(child));
             }
             return objs;
         }
@@ -1136,6 +1135,17 @@ class FolderNode extends node_in_fs_1.NodeInFS {
 exports.FolderNode = FolderNode;
 Object.freeze(FolderNode.prototype);
 Object.freeze(FolderNode);
+function appendArray(arr, elems) {
+    if (elems !== undefined) {
+        if (Array.isArray(elems)) {
+            arr.push(...elems);
+        }
+        else {
+            arr.push(elems);
+        }
+    }
+    return arr;
+}
 const EMPTY_ARR = new Uint8Array(0);
 function noop() { }
 function checkFolderInfo(folderJson) {

package/build/lib-common/dataset-sync/per-device-json-array-logs.js

@@ -403,7 +403,7 @@ function startDatasetSync(periodicCheckAndUploadOfData, millisBeforeNextRun, log
     // We pass this single process point out to wrap fn's with it, in an attempt to explicitly keeping it at the
     // boundary of incoming operations, either from fn calls, or from handling changes passed via fs events.
     const changeProc = new synced_1.SingleProc();
-    function dbSyncCheckAndAction() {
+    function datasetCheckAndSyncAction() {
         changeProc.startOrChain(periodicCheckAndUploadOfData);
     }
     let interval = undefined;
@@ -411,7 +411,7 @@ function startDatasetSync(periodicCheckAndUploadOfData, millisBeforeNextRun, log
         if (interval !== undefined) {
             clearInterval(interval);
         }
-        interval = setInterval(dbSyncCheckAndAction, millisBeforeNextRun()).unref();
+        interval = setInterval(datasetCheckAndSyncAction, millisBeforeNextRun()).unref();
     }
     resetSyncInterval();
     // XXX we should watch for reconnect events and run similar to start checks of possibly missed ops

package/build/lib-common/dataset-sync/single-file.d.ts

@@ -0,0 +1,10 @@
+import { SingleProc } from "../processes/synced";
+type WritableFS = web3n.files.WritableFS;
+type WritableFile = web3n.files.WritableFile;
+export declare function initSyncedFile(syncedFS: WritableFS, fName: string, initNewFile: (newFile: WritableFile) => Promise<void>): Promise<WritableFile>;
+export declare function watchAndApplyChangesFromOtherDevices(file: WritableFile, onChangeFromOtherDevices: (changeProc: SingleProc, file: WritableFile) => Promise<void>, onConflictingChangeFromOtherDevices: (changeProc: SingleProc, file: WritableFile) => Promise<void>): {
+    changeProc: SingleProc;
+    stopFileWatching: () => void;
+    triggerUpload: () => void;
+};
+export {};

package/build/lib-common/dataset-sync/single-file.js

@@ -0,0 +1,77 @@
+"use strict";
+/*
+ Copyright (C) 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.initSyncedFile = initSyncedFile;
+exports.watchAndApplyChangesFromOtherDevices = watchAndApplyChangesFromOtherDevices;
+const synced_1 = require("../processes/synced");
+async function initSyncedFile(syncedFS, fName, initNewFile) {
+    const file = await syncedFS.writableFile(fName);
+    if (file.isNew) {
+        await initNewFile(file);
+        await file.v.sync.upload();
+        await syncedFS.v.sync.upload('.');
+    }
+    // XXX add initial sync no-connection handling
+    return file;
+}
+function watchAndApplyChangesFromOtherDevices(file, onChangeFromOtherDevices, onConflictingChangeFromOtherDevices) {
+    const changeProc = new synced_1.SingleProc();
+    const stopFileWatching = file.watch({
+        next: ev => {
+            if (ev.type === 'remote-change') {
+                changeProc.startOrChain(async () => {
+                    await file.v.sync.adoptRemote({ remoteVersion: ev.newRemoteVersion })
+                        .catch((exc) => {
+                        if (exc.type === 'connect') {
+                            // XXX need to have watcher for connection to continue processing
+                        }
+                    });
+                });
+            }
+            else if ((ev.type === 'file-change') && (ev.src === 'sync')) {
+                onChangeFromOtherDevices(changeProc, file);
+            }
+        }
+    });
+    function triggerUpload() {
+        changeProc.startOrChain(async () => file.v.sync.upload())
+            .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?
+            }
+        });
+    }
+    file.v.sync.status()
+        .then(async ({ state }) => {
+        if (state === 'behind') {
+            await changeProc.startOrChain(() => file.v.sync.adoptRemote());
+        }
+        else if (state === 'conflicting') {
+            await onConflictingChangeFromOtherDevices(changeProc, file);
+        }
+        else if (state === 'unsynced') {
+            triggerUpload();
+        }
+    })
+        .catch(exc => {
+        // XXX need to have watcher for connection to continue processing
+    });
+    return { changeProc, stopFileWatching, triggerUpload };
+}
+Object.freeze(exports);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "core-3nweb-client-lib",
-  "version": "0.49.7",
+  "version": "0.49.8",
   "description": "3NWeb client core library, embeddable into different environments",
   "main": "build/lib-index.js",
   "types": "build/lib-index.d.ts",

package/build/lib-client/xsp-fs/util/for-arrays.d.ts

@@ -1 +0,0 @@
-export declare function appendArray<T>(arr: T[], elems: T[] | T | undefined): T[];

package/build/lib-client/xsp-fs/util/for-arrays.js

@@ -1,31 +0,0 @@
-"use strict";
-/*
- Copyright (C) 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.appendArray = appendArray;
-function appendArray(arr, elems) {
-    if (elems !== undefined) {
-        if (Array.isArray(elems)) {
-            arr.push(...elems);
-        }
-        else {
-            arr.push(elems);
-        }
-    }
-    return arr;
-}
-Object.freeze(exports);