@vex-chat/libvex 6.5.1 → 6.5.3

package/src/Client.ts

@@ -350,18 +350,6 @@ import { uuidToUint8 } from "./utils/uint8uuid.js";
 
 const _protocolMsgRegex = /��\w+:\w+��/g;
 
-/**
- * Permission is a permission to a resource.
- *
- * Common fields:
- * - `permissionID`: unique permission row ID
- * - `userID`: user receiving this grant
- * - `resourceID`: target server/channel/etc.
- * - `resourceType`: type string for the resource
- * - `powerLevel`: authorization level
- */
-export type { Permission } from "@vex-chat/types";
-
 /**
  * @ignore
  */
@@ -378,27 +366,6 @@ export interface Channels {
     userList: (channelID: string) => Promise<User[]>;
 }
 
-/**
- * Device record associated with a user account.
- *
- * Common fields:
- * - `deviceID`: unique device identifier
- * - `owner`: owning user ID
- * - `signKey`: signing public key
- * - `name`: user-facing device name
- * - `lastLogin`: last login timestamp string
- * - `deleted`: soft-delete flag
- */
-export type { Device } from "@vex-chat/types";
-
-/**
- * Public passkey record returned by `client.passkeys.list()` and
- * `client.passkeys.finishRegistration()`. Server-private fields
- * (credential ID, public key, COSE algorithm, signature counter) are
- * never exposed.
- */
-export type { Passkey } from "@vex-chat/types";
-
 /**
  * ClientOptions are the options you can pass into the client.
  */
@@ -436,8 +403,41 @@ export interface ClientOptions {
     unsafeHttp?: boolean;
 }
 
+/**
+ * Permission is a permission to a resource.
+ *
+ * Common fields:
+ * - `permissionID`: unique permission row ID
+ * - `userID`: user receiving this grant
+ * - `resourceID`: target server/channel/etc.
+ * - `resourceType`: type string for the resource
+ * - `powerLevel`: authorization level
+ */
+export type { Permission } from "@vex-chat/types";
+
 export type DeviceRegistrationResult = Device | PendingDeviceRegistration;
 
+/**
+ * Device record associated with a user account.
+ *
+ * Common fields:
+ * - `deviceID`: unique device identifier
+ * - `owner`: owning user ID
+ * - `signKey`: signing public key
+ * - `name`: user-facing device name
+ * - `lastLogin`: last login timestamp string
+ * - `deleted`: soft-delete flag
+ */
+export type { Device } from "@vex-chat/types";
+
+/**
+ * Public passkey record returned by `client.passkeys.list()` and
+ * `client.passkeys.finishRegistration()`. Server-private fields
+ * (credential ID, public key, COSE algorithm, signature counter) are
+ * never exposed.
+ */
+export type { Passkey } from "@vex-chat/types";
+
 /**
  * @ignore
  */
@@ -556,6 +556,29 @@ export interface Files {
     retrieve: (fileID: string, key: string) => Promise<FileResponse | null>;
 }
 
+/**
+ * @ignore
+ */
+export interface Invites {
+    /** Creates an invite for a server and duration. */
+    create: (serverID: string, duration: string) => Promise<Invite>;
+    /** Redeems an invite and returns the created permission grant. */
+    redeem: (inviteID: string) => Promise<Permission>;
+    /** Lists active invites for a server. */
+    retrieve: (serverID: string) => Promise<Invite[]>;
+}
+
+/**
+ * Keys are a pair of ed25519 public and private keys,
+ * encoded as hex strings.
+ */
+export interface Keys {
+    /** Secret Ed25519 key as hex. Store securely. */
+    private: string;
+    /** Public Ed25519 key as hex. */
+    public: string;
+}
+
 /**
  * Channel is a chat channel on a server.
  *
@@ -581,29 +604,6 @@ export type { Server } from "@vex-chat/types";
  */
 export type { ServerChannelBootstrap } from "@vex-chat/types";
 
-/**
- * @ignore
- */
-export interface Invites {
-    /** Creates an invite for a server and duration. */
-    create: (serverID: string, duration: string) => Promise<Invite>;
-    /** Redeems an invite and returns the created permission grant. */
-    redeem: (inviteID: string) => Promise<Permission>;
-    /** Lists active invites for a server. */
-    retrieve: (serverID: string) => Promise<Invite[]>;
-}
-
-/**
- * Keys are a pair of ed25519 public and private keys,
- * encoded as hex strings.
- */
-export interface Keys {
-    /** Secret Ed25519 key as hex. Store securely. */
-    private: string;
-    /** Public Ed25519 key as hex. */
-    public: string;
-}
-
 /**
  * @ignore
  */
@@ -753,6 +753,59 @@ export interface RetryRequest {
     source: "decrypt_failure" | "server_notify";
 }
 
+function compareInboxEntries(
+    a: [Uint8Array, MailWS, string],
+    b: [Uint8Array, MailWS, string],
+): number {
+    const timeCmp = a[2].localeCompare(b[2]);
+    if (timeCmp !== 0) {
+        return timeCmp;
+    }
+
+    const aMail = a[1];
+    const bMail = b[1];
+    if (aMail.sender !== bMail.sender) {
+        return aMail.sender.localeCompare(bMail.sender, "en");
+    }
+
+    const typeCmp = aMail.mailType - bMail.mailType;
+    if (typeCmp !== 0) {
+        return typeCmp;
+    }
+
+    if (
+        aMail.mailType === MailType.subsequent &&
+        bMail.mailType === MailType.subsequent
+    ) {
+        const aHeader = tryDecodeRatchetHeader(aMail.extra);
+        const bHeader = tryDecodeRatchetHeader(bMail.extra);
+        if (aHeader && bHeader) {
+            const dhCmp = XUtils.encodeHex(aHeader.dhPub).localeCompare(
+                XUtils.encodeHex(bHeader.dhPub),
+                "en",
+            );
+            if (dhCmp !== 0) {
+                return dhCmp;
+            }
+            const pnCmp = aHeader.pn - bHeader.pn;
+            if (pnCmp !== 0) {
+                return pnCmp;
+            }
+            return aHeader.n - bHeader.n;
+        }
+    }
+
+    return aMail.nonce.toString().localeCompare(bMail.nonce.toString(), "en");
+}
+
+function tryDecodeRatchetHeader(extra: Uint8Array) {
+    try {
+        return decodeRatchetHeader(extra);
+    } catch {
+        return null;
+    }
+}
+
 /** Zod schema matching the {@link Message} interface for forwarded-message decode. */
 const messageSchema: z.ZodType<Message> = z.object({
     authorID: z.string(),
@@ -1344,6 +1397,8 @@ export class Client {
         retrieve: this.fetchUser.bind(this),
     };
 
+    private autoReconnectEnabled = false;
+
     private readonly cryptoProfile: CryptoProfile;
 
     private readonly database: Storage;
@@ -1390,18 +1445,19 @@ export class Client {
     private readonly notFoundUsers = new Map<string, number>();
 
     private readonly options?: ClientOptions | undefined;
-
     private pingInterval: null | ReturnType<typeof setTimeout> = null;
     /**
      * Bumped when the WebSocket is torn down and re-opened so the previous
      * `postAuth` loop exits instead of overlapping a new one.
      */
     private postAuthVersion = 0;
-
     private readonly prefixes:
         | { HTTP: "http://"; WS: "ws://" }
         | { HTTP: "https://"; WS: "wss://" };
     private reading: boolean = false;
+    private reconnectAttempt = 0;
+    private reconnectPromise: null | Promise<void> = null;
+    private reconnectTimer: null | ReturnType<typeof setTimeout> = null;
     private retentionPurgeDebounce: null | ReturnType<typeof setTimeout> = null;
     private readonly seenMailIDs: Set<string> = new Set();
     private readonly sessionHealBackoffUntil = new Map<string, number>();
@@ -1711,6 +1767,11 @@ export class Client {
      */
     public async close(muteEvent = false): Promise<void> {
         this.manuallyClosing = true;
+        this.autoReconnectEnabled = false;
+        if (this.reconnectTimer) {
+            clearTimeout(this.reconnectTimer);
+            this.reconnectTimer = null;
+        }
         this.httpAbortController.abort();
         this.socket.close();
         await this.database.close();
@@ -1776,6 +1837,7 @@ export class Client {
         const { deviceToken } = decodeAxios(ConnectResponseCodec, res.data);
         this.http.defaults.headers.common["X-Device-Token"] = deviceToken;
 
+        this.autoReconnectEnabled = true;
         this.initSocket();
         // Yield the event loop so the WS open callback fires and sends the
         // auth message before OTK generation starts. OTK top-up is best-effort
@@ -1979,45 +2041,20 @@ export class Client {
      * newly-registered second device.
      */
     public async reconnectWebsocket(): Promise<void> {
-        this.postAuthVersion++;
-        if (this.pingInterval) {
-            clearInterval(this.pingInterval);
-            this.pingInterval = null;
+        if (this.isManualCloseInFlight()) {
+            throw new WebSocketNotOpenError(this.socket.readyState);
         }
-        this.socket.close();
-        try {
-            await new Promise<void>((resolve, reject) => {
-                const t = setTimeout(() => {
-                    this.off("connected", onC);
-                    reject(
-                        new Error(
-                            "reconnectWebsocket: timed out waiting for authorized",
-                        ),
-                    );
-                }, 15_000);
-                const onC = () => {
-                    clearTimeout(t);
-                    this.off("connected", onC);
-                    resolve();
-                };
-                this.on("connected", onC);
-                try {
-                    this.initSocket();
-                } catch (err: unknown) {
-                    clearTimeout(t);
-                    this.off("connected", onC);
-                    const e =
-                        err instanceof Error
-                            ? err
-                            : new Error(String(err), { cause: err });
-                    reject(e);
-                }
-            });
-        } catch (e: unknown) {
-            throw e instanceof Error ? e : new Error(String(e), { cause: e });
+        if (this.reconnectTimer) {
+            clearTimeout(this.reconnectTimer);
+            this.reconnectTimer = null;
         }
-        await new Promise((r) => setTimeout(r, 0));
-        await this.negotiateOTK();
+        if (this.reconnectPromise) {
+            return this.reconnectPromise;
+        }
+        this.reconnectPromise = this.reconnectWebsocketOnce().finally(() => {
+            this.reconnectPromise = null;
+        });
+        return this.reconnectPromise;
     }
 
     /**
@@ -3017,7 +3054,7 @@ export class Client {
             const rawInbox = z
                 .array(mailInboxEntry)
                 .parse(msgpack.decode(mailBuffer));
-            const inbox = rawInbox.sort((a, b) => b[2].localeCompare(a[2]));
+            const inbox = rawInbox.sort(compareInboxEntries);
 
             if (libvexDebugDmEnabled()) {
                 const did = (() => {
@@ -3062,8 +3099,9 @@ export class Client {
                     fetchErr,
                 );
             }
+        } finally {
+            this.fetchingMail = false;
         }
-        this.fetchingMail = false;
     }
 
     private async getMessageHistory(userID: string): Promise<Message[]> {
@@ -3220,7 +3258,6 @@ export class Client {
             }
             case "mail":
                 await this.getMail();
-                this.fetchingMail = false;
                 break;
             case "permission":
                 this.emitter.emit(
@@ -3323,12 +3360,14 @@ export class Client {
                 }
                 if (!this.manuallyClosing) {
                     this.emitter.emit("disconnect");
+                    this.scheduleReconnect();
                 }
             });
 
             this.socket.on("error", (_error: Error) => {
                 if (!this.manuallyClosing) {
                     this.emitter.emit("disconnect");
+                    this.scheduleReconnect();
                 }
             });
 
@@ -3363,6 +3402,7 @@ export class Client {
                             "Received unauthorized message from server.",
                         );
                     case "authorized":
+                        this.reconnectAttempt = 0;
                         this.emitter.emit("connected");
                         this.postAuth().catch(ignoreSocketTeardown);
                         break;
@@ -3654,7 +3694,6 @@ export class Client {
             try {
                 await this.getMail();
                 count++;
-                this.fetchingMail = false;
 
                 if (count > 10) {
                     void this.negotiateOTK();
@@ -4234,7 +4273,9 @@ export class Client {
                                     },
                                 );
                             }
-                            healSession();
+                            if (failureCount >= 2) {
+                                healSession();
+                            }
                             if (failureCount === 1) {
                                 this.emitter.emit("retryRequest", {
                                     mailID: mail.mailID,
@@ -4367,6 +4408,48 @@ export class Client {
         }
     }
 
+    private async reconnectWebsocketOnce(): Promise<void> {
+        this.postAuthVersion++;
+        if (this.pingInterval) {
+            clearInterval(this.pingInterval);
+            this.pingInterval = null;
+        }
+        this.socket.close();
+        try {
+            await new Promise<void>((resolve, reject) => {
+                const t = setTimeout(() => {
+                    this.off("connected", onC);
+                    reject(
+                        new Error(
+                            "reconnectWebsocket: timed out waiting for authorized",
+                        ),
+                    );
+                }, 15_000);
+                const onC = () => {
+                    clearTimeout(t);
+                    this.off("connected", onC);
+                    resolve();
+                };
+                this.on("connected", onC);
+                try {
+                    this.initSocket();
+                } catch (err: unknown) {
+                    clearTimeout(t);
+                    this.off("connected", onC);
+                    const e =
+                        err instanceof Error
+                            ? err
+                            : new Error(String(err), { cause: err });
+                    reject(e);
+                }
+            });
+        } catch (e: unknown) {
+            throw e instanceof Error ? e : new Error(String(e), { cause: e });
+        }
+        await new Promise((r) => setTimeout(r, 0));
+        await this.negotiateOTK();
+    }
+
     private async redeemInvite(inviteID: string): Promise<Permission> {
         const res = await this.http.patch(
             this.getHost() + "/invite/" + inviteID,
@@ -4601,6 +4684,25 @@ export class Client {
         }
     }
 
+    private scheduleReconnect(): void {
+        if (
+            !this.autoReconnectEnabled ||
+            this.isManualCloseInFlight() ||
+            this.reconnectPromise ||
+            this.reconnectTimer
+        ) {
+            return;
+        }
+        const delayMs = Math.min(30_000, 250 * 2 ** this.reconnectAttempt);
+        this.reconnectAttempt = Math.min(this.reconnectAttempt + 1, 8);
+        this.reconnectTimer = setTimeout(() => {
+            this.reconnectTimer = null;
+            this.reconnectWebsocket().catch(() => {
+                this.scheduleReconnect();
+            });
+        }, delayMs);
+    }
+
     private scheduleRetentionPurge(): void {
         if (this.retentionPurgeDebounce) {
             clearTimeout(this.retentionPurgeDebounce);
@@ -4623,7 +4725,8 @@ export class Client {
                 throw new WebSocketNotOpenError(this.socket.readyState);
             }
             if (this.socket.readyState === 2 || this.socket.readyState === 3) {
-                throw new WebSocketNotOpenError(this.socket.readyState);
+                await this.reconnectWebsocket();
+                continue;
             }
             if (elapsed >= maxWaitMs) {
                 throw new WebSocketNotOpenError(this.socket.readyState);
@@ -4644,7 +4747,20 @@ export class Client {
         // discarded callers (`pong`, `ping`) can `.catch(ignore)` the
         // teardown without an unhandled rejection, and real callers
         // can choose to retry on the next reconnect.
-        this.socket.send(XUtils.packMessage(msg, header));
+        const packed = XUtils.packMessage(msg, header);
+        try {
+            this.socket.send(packed);
+        } catch (err: unknown) {
+            if (
+                err instanceof WebSocketNotOpenError &&
+                !this.isManualCloseInFlight()
+            ) {
+                await this.reconnectWebsocket();
+                this.socket.send(packed);
+                return;
+            }
+            throw err;
+        }
     }
 
     private async sendGroupMessage(