@vex-chat/libvex 6.3.0 → 6.3.2

package/src/Client.ts

@@ -42,7 +42,9 @@ import type { AxiosInstance } from "axios";
 
 import {
     type CryptoProfile,
+    enterCryptoProfileScope,
     getCryptoProfile,
+    leaveCryptoProfileScope,
     setCryptoProfile,
     xBoxKeyPairAsync,
     xBoxKeyPairFromSecretAsync,
@@ -387,6 +389,14 @@ export type DeviceRegistrationResult = Device | PendingDeviceRegistration;
  * @ignore
  */
 export interface Devices {
+    /**
+     * Deletes an unpublished enrollment before any owner notification
+     * (e.g. user picked "not my account").
+     */
+    abortPendingRegistration: (args: {
+        challenge: string;
+        requestID: string;
+    }) => Promise<void>;
     /** Approves a pending device registration request as the current device. */
     approveRequest: (requestID: string) => Promise<Device>;
     /** Deletes one of the account's devices (except the currently active one). */
@@ -414,6 +424,14 @@ export interface Devices {
         challenge: string;
         requestID: string;
     }) => Promise<null | PendingDeviceRequest>;
+    /**
+     * After the user confirms the pending enrollment is theirs, notifies
+     * their existing devices (same proof as poll).
+     */
+    publishPendingRegistration: (args: {
+        challenge: string;
+        requestID: string;
+    }) => Promise<void>;
     /** Registers the current key material as a new device. */
     register: () => Promise<DeviceRegistrationResult | null>;
     /** Rejects a pending device registration request as the current device. */
@@ -1003,12 +1021,16 @@ export class Client {
      * Device management methods.
      */
     public devices: Devices = {
+        abortPendingRegistration:
+            this.abortPendingDeviceRegistration.bind(this),
         approveRequest: this.approveDeviceRequest.bind(this),
         delete: this.deleteDevice.bind(this),
         getRequest: this.getDeviceRegistrationRequest.bind(this),
         list: this.listDevices.bind(this),
         listRequests: this.listDeviceRegistrationRequests.bind(this),
         pollPendingRegistration: this.pollPendingDeviceRegistration.bind(this),
+        publishPendingRegistration:
+            this.publishPendingDeviceRegistration.bind(this),
         register: this.registerDevice.bind(this),
         rejectRequest: this.rejectDeviceRequest.bind(this),
         retrieve: this.getDeviceByID.bind(this),
@@ -1320,6 +1342,8 @@ export class Client {
     private reading: boolean = false;
     private retentionPurgeDebounce: null | ReturnType<typeof setTimeout> = null;
     private readonly seenMailIDs: Set<string> = new Set();
+    private readonly sessionHealBackoffUntil = new Map<string, number>();
+    private readonly sessionHealInFlight = new Set<string>();
     private sessionRecords: Record<string, SessionCrypto> = {};
 
     // these are created from one set of sign keys
@@ -2124,6 +2148,23 @@ export class Client {
         return whoami;
     }
 
+    private async abortPendingDeviceRegistration(args: {
+        challenge: string;
+        requestID: string;
+    }): Promise<void> {
+        const signed = await this.signPendingRegistrationChallenge(
+            args.challenge,
+        );
+        await this.http.post(
+            this.getHost() +
+                "/user/devices/requests/" +
+                args.requestID +
+                "/abort",
+            msgpack.encode({ signed }),
+            { headers: { "Content-Type": "application/msgpack" } },
+        );
+    }
+
     private acknowledgeInboundMail(mail: MailWS): void {
         this.seenMailIDs.add(mail.mailID);
         this.sendReceipt(new Uint8Array(mail.nonce));
@@ -2561,7 +2602,6 @@ export class Client {
     private async deletePermission(permissionID: string): Promise<void> {
         await this.http.delete(this.getHost() + "/permission/" + permissionID);
     }
-
     private async deleteServer(serverID: string): Promise<void> {
         await this.http.delete(this.getHost() + "/server/" + serverID);
     }
@@ -2578,6 +2618,7 @@ export class Client {
         }
         return "";
     }
+
     /**
      * Gets a list of permissions for a server.
      *
@@ -2760,7 +2801,7 @@ export class Client {
                 continue;
             }
             try {
-                await this.sendMail(
+                await this.sendMailWithRecovery(
                     device,
                     this.getUser(),
                     msgBytes,
@@ -3078,6 +3119,8 @@ export class Client {
         return decodeAxios(UserArrayCodec, res.data);
     }
 
+    // ── Passkeys ────────────────────────────────────────────────────────
+
     private async handleNotify(msg: NotifyMsg) {
         switch (msg.event) {
             case "deviceRequest": {
@@ -3146,8 +3189,6 @@ export class Client {
         this.emitter.emit("ready");
     }
 
-    // ── Passkeys ────────────────────────────────────────────────────────
-
     private initSocket() {
         try {
             if (!this.token) {
@@ -3431,21 +3472,12 @@ export class Client {
         );
     }
 
-    /**
-     * Polls the public unauthenticated request status endpoint as the
-     * requesting device. Signs the server-issued challenge with the local
-     * private signing key so the server can verify ownership of the pending
-     * request without us needing a user token.
-     */
     private async pollPendingDeviceRegistration(args: {
         challenge: string;
         requestID: string;
     }): Promise<null | PendingDeviceRequest> {
-        const signed = XUtils.encodeHex(
-            await xSignAsync(
-                XUtils.decodeHex(args.challenge),
-                this.signKeys.secretKey,
-            ),
+        const signed = await this.signPendingRegistrationChallenge(
+            args.challenge,
         );
         try {
             const response = await this.http.post(
@@ -3555,6 +3587,23 @@ export class Client {
         }
     }
 
+    private async publishPendingDeviceRegistration(args: {
+        challenge: string;
+        requestID: string;
+    }): Promise<void> {
+        const signed = await this.signPendingRegistrationChallenge(
+            args.challenge,
+        );
+        await this.http.post(
+            this.getHost() +
+                "/user/devices/requests/" +
+                args.requestID +
+                "/publish",
+            msgpack.encode({ signed }),
+            { headers: { "Content-Type": "application/msgpack" } },
+        );
+    }
+
     private async purgeHistory(): Promise<void> {
         await this.database.purgeHistory();
     }
@@ -3598,23 +3647,50 @@ export class Client {
 
         try {
             await this.runWithThisCryptoProfile(async () => {
-                const healSession = async () => {
+                const healSession = () => {
                     if (this.manuallyClosing || !this.xKeyRing) {
                         return;
                     }
-                    const deviceEntry = await this.getDeviceByID(mail.sender);
-                    const [user, _err] = await this.fetchUser(mail.authorID);
-                    if (deviceEntry && user) {
-                        void this.createSession(
-                            deviceEntry,
-                            user,
-                            new Uint8Array(),
-                            mail.group,
-                            uuid.v4(),
-                            false,
-                            true,
-                        );
+                    const senderDeviceID = mail.sender;
+                    const now = Date.now();
+                    const blockedUntil =
+                        this.sessionHealBackoffUntil.get(senderDeviceID) ?? 0;
+                    if (now < blockedUntil) {
+                        return;
+                    }
+                    if (this.sessionHealInFlight.has(senderDeviceID)) {
+                        return;
                     }
+                    this.sessionHealInFlight.add(senderDeviceID);
+                    void (async () => {
+                        try {
+                            const deviceEntry =
+                                await this.getDeviceByID(senderDeviceID);
+                            const [user, _err] = await this.fetchUser(
+                                mail.authorID,
+                            );
+                            if (deviceEntry && user) {
+                                await this.createSession(
+                                    deviceEntry,
+                                    user,
+                                    new Uint8Array(),
+                                    mail.group,
+                                    uuid.v4(),
+                                    false,
+                                    true,
+                                );
+                            }
+                        } finally {
+                            // Avoid hammering /keyBundle when a bad/corrupt mail item
+                            // triggers repeated decrypt failures for the same sender.
+                            // Use a conservative backoff to cap load during auth churn.
+                            this.sessionHealBackoffUntil.set(
+                                senderDeviceID,
+                                Date.now() + 30_000,
+                            );
+                            this.sessionHealInFlight.delete(senderDeviceID);
+                        }
+                    })();
                 };
 
                 switch (mail.mailType) {
@@ -3955,7 +4031,7 @@ export class Client {
                         }
 
                         if (!session) {
-                            void healSession();
+                            healSession();
                             return;
                         }
 
@@ -3989,7 +4065,7 @@ export class Client {
                         const HMAC = xHMAC(mail, messageKey);
 
                         if (!XUtils.bytesEqual(HMAC, header)) {
-                            void healSession();
+                            healSession();
                             return;
                         }
 
@@ -4085,7 +4161,7 @@ export class Client {
                             ] = session;
                             this.acknowledgeInboundMail(mail);
                         } else {
-                            void healSession();
+                            healSession();
                             this.emitter.emit("retryRequest", {
                                 mailID: mail.mailID,
                                 source: "decrypt_failure",
@@ -4320,15 +4396,11 @@ export class Client {
     private async runWithThisCryptoProfile<T>(
         fn: () => Promise<T>,
     ): Promise<T> {
-        const prev = getCryptoProfile();
-        if (prev === this.cryptoProfile) {
-            return await fn();
-        }
-        setCryptoProfile(this.cryptoProfile);
+        enterCryptoProfileScope(this.cryptoProfile);
         try {
             return await fn();
         } finally {
-            setCryptoProfile(prev);
+            leaveCryptoProfileScope();
         }
     }
 
@@ -4350,10 +4422,14 @@ export class Client {
         let elapsed = 0;
         let backoff = 50;
         while (this.socket.readyState !== 1) {
+            if (this.isManualCloseInFlight()) {
+                throw new WebSocketNotOpenError(this.socket.readyState);
+            }
+            if (this.socket.readyState === 2 || this.socket.readyState === 3) {
+                throw new WebSocketNotOpenError(this.socket.readyState);
+            }
             if (elapsed >= maxWaitMs) {
-                throw new Error(
-                    "WebSocket did not reach OPEN state within 30 seconds.",
-                );
+                throw new WebSocketNotOpenError(this.socket.readyState);
             }
             await sleep(backoff);
             elapsed += backoff;
@@ -4441,7 +4517,7 @@ export class Client {
                 continue;
             }
             try {
-                await this.sendMail(
+                await this.sendMailWithRecovery(
                     device,
                     ownerRecord,
                     msgBytes,
@@ -4661,6 +4737,32 @@ export class Client {
         }
     }
 
+    private async sendMailWithRecovery(
+        device: Device,
+        user: User,
+        msg: Uint8Array,
+        group: null | Uint8Array,
+        mailID: null | string,
+        forward: boolean,
+    ): Promise<void> {
+        try {
+            await this.sendMail(device, user, msg, group, mailID, forward);
+        } catch (err: unknown) {
+            if (!this.shouldRetryDeliveryWithFreshSession(err)) {
+                throw err;
+            }
+            await this.sendMail(
+                device,
+                user,
+                msg,
+                group,
+                mailID,
+                forward,
+                true,
+            );
+        }
+    }
+
     private async sendMessage(
         userID: string,
         message: string,
@@ -4739,7 +4841,7 @@ export class Client {
                             recipientDevice: device.deviceID,
                         });
                     }
-                    await this.sendMail(
+                    await this.sendMailWithRecovery(
                         device,
                         userEntry,
                         XUtils.decodeUTF8(payload),
@@ -4805,6 +4907,44 @@ export class Client {
 
     private setUser(user: User): void {
         this.user = user;
+        // Fresh identity / token: drop stale 404 negative-cache entries so a
+        // prior transient miss (or wrong host) cannot block DM sends for 30m.
+        this.notFoundUsers.clear();
+    }
+
+    private shouldRetryDeliveryWithFreshSession(err: unknown): boolean {
+        if (err instanceof WebSocketNotOpenError) {
+            return true;
+        }
+        const message =
+            err instanceof Error
+                ? err.message.toLowerCase()
+                : String(err).toLowerCase();
+        return (
+            message.includes("mail delivery failed") ||
+            message.includes("not authenticated") ||
+            message.includes("unauthorized") ||
+            message.includes("websocket") ||
+            message.includes("network") ||
+            message.includes("timed out")
+        );
+    }
+
+    /**
+     * Polls the public unauthenticated request status endpoint as the
+     * requesting device. Signs the server-issued challenge with the local
+     * private signing key so the server can verify ownership of the pending
+     * request without us needing a user token.
+     */
+    private async signPendingRegistrationChallenge(
+        challengeHex: string,
+    ): Promise<string> {
+        return XUtils.encodeHex(
+            await xSignAsync(
+                XUtils.decodeHex(challengeHex),
+                this.signKeys.secretKey,
+            ),
+        );
     }
 
     private async submitOTK(amount: number) {

package/src/Storage.ts

@@ -93,7 +93,8 @@ export interface Storage extends EventEmitter {
     on(event: "error", callback: (error: Error) => void): this;
     /**
      * Deletes local messages older than the effective per-row retention:
-     * `min(30 days, clientMaxRetentionDays, retentionHintDays ?? 30)`.
+     * `min(30 days, clientMaxRetentionDays, effectiveMessageRetentionHintDays(row))`
+     * (invalid or non-positive stored hints are treated like 30).
      */
     pruneExpiredLocalMessages: (
         clientMaxRetentionDays: number,

package/src/__tests__/harness/memory-storage.ts

@@ -24,13 +24,16 @@ import {
     XUtils,
 } from "@vex-chat/crypto";
 
+import { EventEmitter } from "eventemitter3";
+
+import { effectiveMessageRetentionHintDays } from "../../retention.js";
+
 /**
  * Minimal in-memory Storage for browser/RN platform tests.
  *
  * Uses eventemitter3 (browser-safe) instead of Node's events module.
  * No persistence — just enough for the register/login/connect/DM test flow.
  */
-import { EventEmitter } from "eventemitter3";
 
 export class MemoryStorage extends EventEmitter implements Storage {
     public ready = false;
@@ -178,7 +181,9 @@ export class MemoryStorage extends EventEmitter implements Storage {
         const now = Date.now();
         const msPerDay = 86_400_000;
         this.messages = this.messages.filter((m) => {
-            const hintDays = m.retentionHintDays ?? 30;
+            const hintDays = effectiveMessageRetentionHintDays(
+                m.retentionHintDays,
+            );
             const maxDays = Math.min(30, cap, hintDays);
             const ts = new Date(m.timestamp).getTime();
             if (!Number.isFinite(ts)) {

package/src/__tests__/retention.test.ts

@@ -7,6 +7,7 @@ import { describe, expect, it } from "vitest";
 
 import {
     clampLocalMessageRetentionDays,
+    effectiveMessageRetentionHintDays,
     formatVexRetentionEnvelope,
     MAX_LOCAL_MESSAGE_RETENTION_DAYS,
     stripVexRetentionEnvelope,
@@ -36,4 +37,14 @@ describe("retention", () => {
     it("MAX matches server contract constant name in docs", () => {
         expect(MAX_LOCAL_MESSAGE_RETENTION_DAYS).toBe(30);
     });
+
+    it("effectiveMessageRetentionHintDays treats 0 and invalid as 30-day default", () => {
+        expect(effectiveMessageRetentionHintDays(undefined)).toBe(30);
+        expect(effectiveMessageRetentionHintDays(null)).toBe(30);
+        expect(effectiveMessageRetentionHintDays(0)).toBe(30);
+        expect(effectiveMessageRetentionHintDays(-3)).toBe(30);
+        expect(effectiveMessageRetentionHintDays(Number.NaN)).toBe(30);
+        expect(effectiveMessageRetentionHintDays(7)).toBe(7);
+        expect(effectiveMessageRetentionHintDays(45)).toBe(30);
+    });
 });

package/src/index.ts

@@ -40,6 +40,7 @@ export type {
 export { createCodec, msgpack } from "./codec.js";
 export {
     clampLocalMessageRetentionDays,
+    effectiveMessageRetentionHintDays,
     MAX_LOCAL_MESSAGE_RETENTION_DAYS,
 } from "./retention.js";
 export type { Storage } from "./Storage.js";

package/src/retention.ts

@@ -24,6 +24,23 @@ export function clampLocalMessageRetentionDays(
     return Math.min(MAX_LOCAL_MESSAGE_RETENTION_DAYS, Math.max(1, n));
 }
 
+/**
+ * Normalizes a per-message `retentionHintDays` value read from storage.
+ * Non-finite, missing, or non-positive values behave like "no hint" (30 days)
+ * so a corrupt `0` row cannot wipe the entire local history on prune.
+ */
+export function effectiveMessageRetentionHintDays(
+    stored: null | number | undefined,
+): number {
+    if (stored == null || !Number.isFinite(stored) || stored < 1) {
+        return MAX_LOCAL_MESSAGE_RETENTION_DAYS;
+    }
+    return Math.min(
+        MAX_LOCAL_MESSAGE_RETENTION_DAYS,
+        Math.max(1, Math.round(stored)),
+    );
+}
+
 const RETENTION_PREFIX = /^vex-retention:([1-9]|[12]\d|30)\n/;
 
 /**

package/src/storage/sqlite.ts

@@ -28,6 +28,13 @@ import type { Device, PreKeysSQL, SessionSQL } from "@vex-chat/types";
  *
  * This replaces three separate storage classes (Storage.ts, TauriStorage,
  * ExpoStorage) with a single implementation.
+ *
+ * **One database file today** holds both `sessions` (Double Ratchet /
+ * X3DH state — required to decrypt *new* traffic) and `messages` (history).
+ * If the file is lost or corrupted you lose both; restoring from backup
+ * re-seeds device keys but cannot reconstruct dropped ratchet chains from
+ * the server alone. A future split could park `sessions` + OTKs in a
+ * smaller “crypto state” store separate from bulk message history.
  */
 import {
     getCryptoProfile,
@@ -44,6 +51,7 @@ import {
 import { EventEmitter } from "eventemitter3";
 import { type Kysely, sql } from "kysely";
 
+import { effectiveMessageRetentionHintDays } from "../retention.js";
 import { parseSkippedKeysStrict } from "../utils/ratchet.js";
 
 export class SqliteStorage extends EventEmitter implements Storage {
@@ -436,7 +444,9 @@ export class SqliteStorage extends EventEmitter implements Storage {
         const msPerDay = 86_400_000;
         const toDelete: string[] = [];
         for (const r of rows) {
-            const hintDays = r.retentionHintDays ?? 30;
+            const hintDays = effectiveMessageRetentionHintDays(
+                r.retentionHintDays,
+            );
             const maxDays = Math.min(30, cap, hintDays);
             const ts = new Date(r.timestamp).getTime();
             if (!Number.isFinite(ts)) {
@@ -668,6 +678,14 @@ export class SqliteStorage extends EventEmitter implements Storage {
     ): Promise<Message[]> {
         const fips = getCryptoProfile() === "fips";
         const out: Message[] = [];
+        let processed = 0;
+        /** Yield so RN / web UIs can paint between at-rest decrypt blocks. */
+        const yieldToHost = (): Promise<void> =>
+            new Promise((resolve) => {
+                setTimeout(resolve, 0);
+            });
+        const yieldEvery = 28;
+
         for (const msg of messages) {
             const decryptedFlag = msg.decrypted !== 0;
             let plaintext = msg.message;
@@ -707,6 +725,11 @@ export class SqliteStorage extends EventEmitter implements Storage {
                 rowMessage.retentionHintDays = msg.retentionHintDays;
             }
             out.push(rowMessage);
+
+            processed += 1;
+            if (processed % yieldEvery === 0) {
+                await yieldToHost();
+            }
         }
         return out;
     }