@vex-chat/libvex 6.8.0 → 7.0.1

package/dist/Client.js

@@ -269,6 +269,19 @@ const messageSchema = z.object({
     timestamp: z.string(),
 });
 const MESSAGE_BLOB_PREFIX = "vex-message:1\n";
+const MAIL_FANOUT_CONCURRENCY = 8;
+const MAIL_BATCH_MAX_SIZE = 32;
+const MAIL_BATCH_FLUSH_DELAY_MS = 8;
+const mailBatchResponseSchema = z.object({
+    results: z.array(z.object({
+        error: z.string().optional(),
+        index: z.number().int().nonnegative(),
+        mailID: z.string().optional(),
+        ok: z.boolean(),
+        recipient: z.string().optional(),
+        status: z.number().int().optional(),
+    })),
+});
 function decodeMessageBlob(body) {
     if (!body.startsWith(MESSAGE_BLOB_PREFIX)) {
         return { message: body };
@@ -535,16 +548,15 @@ export class Client {
      * Passkey ("recovery credential") methods.
      *
      * Passkeys are an account-bound second-class credential that can
-     * authenticate the owning user, list devices, delete devices, and
-     * approve/reject pending device-enrollment requests — i.e.
-     * provisioning + recovery. They cannot send/decrypt mail.
+     * authenticate the owning user, list devices, delete devices, recover a
+     * pending device enrollment, and reject pending device-enrollment
+     * requests. They cannot send/decrypt mail.
      *
      * The host app drives the WebAuthn ceremony (e.g. via
      * `@simplewebauthn/browser`) and hands the JSON response to
      * `finish*`.
      */
     passkeys = {
-        approveDeviceRequest: this.passkeyApproveDeviceRequest.bind(this),
         beginAuthentication: this.beginPasskeyAuthentication.bind(this),
         beginRegistration: this.beginPasskeyRegistration.bind(this),
         delete: this.deletePasskey.bind(this),
@@ -553,6 +565,7 @@ export class Client {
         finishRegistration: this.finishPasskeyRegistration.bind(this),
         list: this.listPasskeys.bind(this),
         listDevices: this.passkeyListDevices.bind(this),
+        recoverDeviceRequest: this.passkeyRecoverDeviceRequest.bind(this),
         rejectDeviceRequest: this.passkeyRejectDeviceRequest.bind(this),
     };
     /**
@@ -668,6 +681,9 @@ export class Client {
     isAlive = true;
     localMessageRetentionDays;
     localRetentionPurgeTimer = null;
+    mailBatchFlushTimer = null;
+    mailBatchQueue = [];
+    mailBatchUnsupported = false;
     mailInterval;
     manuallyClosing = false;
     /* Retrieves the userID with the user identifier.
@@ -924,6 +940,14 @@ export class Client {
         if (this.mailInterval) {
             clearInterval(this.mailInterval);
         }
+        if (this.mailBatchFlushTimer) {
+            clearTimeout(this.mailBatchFlushTimer);
+            this.mailBatchFlushTimer = null;
+        }
+        const pendingMailBatch = this.mailBatchQueue.splice(0);
+        for (const pending of pendingMailBatch) {
+            pending.reject(new Error("Client closed before mail batch sent."));
+        }
         if (this.localRetentionPurgeTimer) {
             clearInterval(this.localRetentionPurgeTimer);
             this.localRetentionPurgeTimer = null;
@@ -1479,7 +1503,8 @@ export class Client {
             // my keys
             const IK_A = this.xKeyRing.identityKeys.secretKey;
             const IK_AP = this.xKeyRing.identityKeys.publicKey;
-            const EK_A = this.xKeyRing.ephemeralKeys.secretKey;
+            const ephemeralKeys = await xBoxKeyPairAsync();
+            const EK_A = ephemeralKeys.secretKey;
             const fips = this.cryptoProfile === "fips";
             // their keys — FIPS: `signKey` in bundle is the peer P-256 ECDH identity (raw, typically 65B).
             const SPK_B = new Uint8Array(keyBundle.preKey.publicKey);
@@ -1519,10 +1544,10 @@ export class Client {
             const nonce = xMakeNonce();
             const cipher = await xSecretboxAsync(message, nonce, SK);
             const signKeyWire = fips ? IK_AP : this.signKeys.publicKey;
-            const ephKeyWire = this.xKeyRing.ephemeralKeys.publicKey;
+            const ephKeyWire = ephemeralKeys.publicKey;
             const extra = fips
                 ? encodeFipsInitialExtraV1(signKeyWire, ephKeyWire, PK, AD, IDX)
-                : xConcat(this.signKeys.publicKey, this.xKeyRing.ephemeralKeys.publicKey, PK, AD, IDX);
+                : xConcat(this.signKeys.publicKey, ephemeralKeys.publicKey, PK, AD, IDX);
             const mail = {
                 authorID: this.getUser().userID,
                 cipher,
@@ -1544,8 +1569,6 @@ export class Client {
                 transmissionID: uuid.v4(),
                 type: "resource",
             };
-            // discard the ephemeral keys
-            await this.newEphemeralKeys();
             const ratchet = await initRatchetSession(SK, "initiator");
             const sessionEntry = {
                 ...ratchet,
@@ -1585,33 +1608,7 @@ export class Client {
             if (shouldEmitHandshakeMessage) {
                 this.emitter.emit("message", emitMsg);
             }
-            // send mail and wait for response
-            await new Promise((res, rej) => {
-                const callback = (packedMsg) => {
-                    const [_header, receivedMsg] = XUtils.unpackMessage(packedMsg);
-                    if (receivedMsg.transmissionID === msg.transmissionID) {
-                        this.socket.off("message", callback);
-                        const parsed = WSMessageSchema.safeParse(receivedMsg);
-                        if (parsed.success && parsed.data.type === "success") {
-                            res(parsed.data.data);
-                        }
-                        else {
-                            rej(new Error("Mail delivery failed: " +
-                                JSON.stringify(receivedMsg)));
-                        }
-                    }
-                };
-                this.socket.on("message", callback);
-                // Forward send failures to the outer promise instead
-                // of leaking them as an unhandled rejection: the
-                // listener above can never resolve if the send didn't
-                // make it onto the wire, so without this the caller
-                // would hang for the full 30s send-loop timeout.
-                this.send(msg, hmac).catch((err) => {
-                    this.socket.off("message", callback);
-                    rej(err instanceof Error ? err : new Error(String(err)));
-                });
-            });
+            await this.deliverMailResource(msg, hmac, mail);
         });
     }
     async deleteChannel(channelID) {
@@ -1641,6 +1638,49 @@ export class Client {
     async deleteServer(serverID) {
         await this.http.delete(this.getHost() + "/server/" + serverID);
     }
+    deliverMailResource(msg, header, mail) {
+        if (this.mailBatchUnsupported) {
+            return this.deliverMailResourceOverSocket(msg, header);
+        }
+        return new Promise((resolve, reject) => {
+            this.mailBatchQueue.push({
+                header,
+                mail,
+                msg,
+                reject,
+                resolve,
+            });
+            if (this.mailBatchQueue.length >= MAIL_BATCH_MAX_SIZE) {
+                void this.flushMailBatchQueue();
+            }
+            else {
+                this.scheduleMailBatchFlush();
+            }
+        });
+    }
+    async deliverMailResourceOverSocket(msg, header) {
+        await new Promise((res, rej) => {
+            const callback = (packedMsg) => {
+                const [_header, receivedMsg] = XUtils.unpackMessage(packedMsg);
+                if (receivedMsg.transmissionID === msg.transmissionID) {
+                    this.socket.off("message", callback);
+                    const parsed = WSMessageSchema.safeParse(receivedMsg);
+                    if (parsed.success && parsed.data.type === "success") {
+                        res();
+                    }
+                    else {
+                        rej(new Error("Mail delivery failed: " +
+                            JSON.stringify(receivedMsg)));
+                    }
+                }
+            };
+            this.socket.on("message", callback);
+            this.send(msg, header).catch((err) => {
+                this.socket.off("message", callback);
+                rej(err instanceof Error ? err : new Error(String(err)));
+            });
+        });
+    }
     deviceListFailureDetail(err) {
         if (!isHttpError(err)) {
             return "";
@@ -1767,6 +1807,64 @@ export class Client {
         const response = await this.http.post(this.getHost() + "/user/" + userID + "/passkeys/register/finish", msgpack.encode(args), { headers: { "Content-Type": "application/msgpack" } });
         return decodeHttpResponse(PasskeyCodec, response.data);
     }
+    async flushMailBatchOverSocket(batch) {
+        await Promise.all(batch.map(async (item) => {
+            try {
+                await this.deliverMailResourceOverSocket(item.msg, item.header);
+                item.resolve();
+            }
+            catch (err) {
+                item.reject(err);
+            }
+        }));
+    }
+    async flushMailBatchQueue() {
+        if (this.mailBatchFlushTimer) {
+            clearTimeout(this.mailBatchFlushTimer);
+            this.mailBatchFlushTimer = null;
+        }
+        const batch = this.mailBatchQueue.splice(0, MAIL_BATCH_MAX_SIZE);
+        if (this.mailBatchQueue.length > 0) {
+            this.scheduleMailBatchFlush();
+        }
+        if (batch.length === 0) {
+            return;
+        }
+        if (this.mailBatchUnsupported) {
+            await this.flushMailBatchOverSocket(batch);
+            return;
+        }
+        try {
+            const response = await this.http.post(this.getHost() + "/mail/batch", msgpack.encode({
+                mails: batch.map((item) => ({
+                    header: item.header,
+                    mail: item.mail,
+                })),
+            }), { headers: { "Content-Type": "application/msgpack" } });
+            const decoded = mailBatchResponseSchema.parse(msgpack.decode(new Uint8Array(response.data)));
+            const resultsByIndex = new Map(decoded.results.map((result) => [result.index, result]));
+            for (const [index, item] of batch.entries()) {
+                const result = resultsByIndex.get(index);
+                if (result?.ok === true) {
+                    item.resolve();
+                    continue;
+                }
+                item.reject(new Error("Mail delivery failed: " +
+                    (result?.error ??
+                        `missing batch result for index ${String(index)}`)));
+            }
+        }
+        catch (err) {
+            if (isHttpError(err) && err.response?.status === 404) {
+                this.mailBatchUnsupported = true;
+                await this.flushMailBatchOverSocket(batch);
+                return;
+            }
+            for (const item of batch) {
+                item.reject(err);
+            }
+        }
+    }
     async forward(message) {
         if (this.isManualCloseInFlight()) {
             return;
@@ -1784,16 +1882,17 @@ export class Client {
         }
         const msgBytes = Uint8Array.from(msgpack.encode(copy));
         const devices = await this.fetchUserDeviceListWithBackoff(this.getUser().userID, "own");
-        for (const device of devices) {
-            if (device.deviceID === this.getDevice().deviceID) {
-                continue;
-            }
-            try {
-                await this.sendMailWithRecovery(device, this.getUser(), msgBytes, null, copy.mailID, true);
-            }
-            catch {
-                /* best-effort per device; parallel handshakes share ephemeral state */
-            }
+        const targetDevices = devices.filter((device) => device.deviceID !== this.getDevice().deviceID);
+        for (let index = 0; index < targetDevices.length; index += MAIL_FANOUT_CONCURRENCY) {
+            const batch = targetDevices.slice(index, index + MAIL_FANOUT_CONCURRENCY);
+            await Promise.all(batch.map(async (device) => {
+                try {
+                    await this.sendMailWithRecovery(device, this.getUser(), msgBytes, null, copy.mailID, true);
+                }
+                catch {
+                    /* best-effort per device */
+                }
+            }));
         }
     }
     async getChannelByID(channelID) {
@@ -2093,7 +2192,6 @@ export class Client {
         this.scheduleReconnect();
         return true;
     }
-    // ── Passkeys ────────────────────────────────────────────────────────
     /**
      * Initializes the keyring. This must be called before anything else.
      */
@@ -2108,7 +2206,6 @@ export class Client {
         this.localRetentionPurgeTimer = setInterval(() => void this.runLocalRetentionPurge(), 6 * 60 * 60 * 1000);
         this.emitter.emit("ready");
     }
-    // ── Passkeys ────────────────────────────────────────────────────────
     initSocket() {
         try {
             if (!this.token) {
@@ -2263,15 +2360,6 @@ export class Client {
         }
         await this.submitOTK(needs);
     }
-    async newEphemeralKeys() {
-        if (!this.xKeyRing) {
-            if (this.manuallyClosing) {
-                return;
-            }
-            throw new Error("Key ring not initialized.");
-        }
-        this.xKeyRing.ephemeralKeys = await xBoxKeyPairAsync();
-    }
     /**
      * Pipeline for decrypted messages — registered in `init`. After `close()` sets
      * `manuallyClosing`, this becomes a no-op so fire-and-forget `forward` does not
@@ -2293,16 +2381,6 @@ export class Client {
         void this.database.saveMessage(message);
         this.scheduleRetentionPurge();
     };
-    async passkeyApproveDeviceRequest(requestID) {
-        const userID = this.getUser().userID;
-        const response = await this.http.post(this.getHost() +
-            "/user/" +
-            userID +
-            "/passkey/devices/requests/" +
-            requestID +
-            "/approve");
-        return decodeHttpResponse(DeviceCodec, response.data);
-    }
     async passkeyDeleteDevice(deviceID) {
         const userID = this.getUser().userID;
         await this.http.delete(this.getHost() + "/user/" + userID + "/passkey/devices/" + deviceID);
@@ -2312,6 +2390,15 @@ export class Client {
         const response = await this.http.get(this.getHost() + "/user/" + userID + "/passkey/devices");
         return decodeHttpResponse(DeviceArrayCodec, response.data);
     }
+    async passkeyRecoverDeviceRequest(requestID) {
+        const userID = this.getUser().userID;
+        const response = await this.http.post(this.getHost() +
+            "/user/" +
+            userID +
+            "/passkey/recover/devices/requests/" +
+            requestID);
+        return decodeHttpResponse(DeviceCodec, response.data);
+    }
     async passkeyRejectDeviceRequest(requestID) {
         const userID = this.getUser().userID;
         await this.http.post(this.getHost() +
@@ -3116,6 +3203,15 @@ export class Client {
             leaveCryptoProfileScope();
         }
     }
+    scheduleMailBatchFlush() {
+        if (this.mailBatchFlushTimer) {
+            return;
+        }
+        this.mailBatchFlushTimer = setTimeout(() => {
+            this.mailBatchFlushTimer = null;
+            void this.flushMailBatchQueue();
+        }, MAIL_BATCH_FLUSH_DELAY_MS);
+    }
     scheduleReconnect() {
         if (!this.autoReconnectEnabled ||
             this.isManualCloseInFlight() ||
@@ -3235,20 +3331,31 @@ export class Client {
         const stableDevices = [...targetDevices.values()].sort((a, b) => a.deviceID.localeCompare(b.deviceID, "en"));
         let failCount = 0;
         let lastErr;
-        for (const device of stableDevices) {
-            const ownerRecord = device.owner === myUserID
-                ? this.getUser()
-                : this.userRecords[device.owner];
-            if (!ownerRecord) {
-                failCount += 1;
-                continue;
-            }
-            try {
-                await this.sendMailWithRecovery(device, ownerRecord, msgBytes, uuidToUint8(channelID), mailID, false);
+        for (let index = 0; index < stableDevices.length; index += MAIL_FANOUT_CONCURRENCY) {
+            const batch = stableDevices.slice(index, index + MAIL_FANOUT_CONCURRENCY);
+            const results = await Promise.all(batch.map(async (device) => {
+                const ownerRecord = device.owner === myUserID
+                    ? this.getUser()
+                    : this.userRecords[device.owner];
+                if (!ownerRecord) {
+                    return new Error(`Missing owner record for device ${device.deviceID}.`);
+                }
+                try {
+                    await this.sendMailWithRecovery(device, ownerRecord, msgBytes, uuidToUint8(channelID), mailID, false);
+                    return undefined;
+                }
+                catch (e) {
+                    return e;
+                }
+            }));
+            for (const result of results) {
+                if (result !== undefined) {
+                    lastErr = result;
+                    failCount += 1;
+                }
             }
-            catch (e) {
-                lastErr = e;
-                failCount += 1;
+            if (failCount === stableDevices.length) {
+                break;
             }
         }
         if (failCount === stableDevices.length) {
@@ -3370,31 +3477,7 @@ export class Client {
             };
             await this.database.saveSession(persisted);
             this.sessionRecords[XUtils.encodeHex(session.publicKey)] = session;
-            await new Promise((res, rej) => {
-                const callback = (packedMsg) => {
-                    const [_header, receivedMsg] = XUtils.unpackMessage(packedMsg);
-                    if (receivedMsg.transmissionID === msgb.transmissionID) {
-                        this.socket.off("message", callback);
-                        const parsed = WSMessageSchema.safeParse(receivedMsg);
-                        if (parsed.success && parsed.data.type === "success") {
-                            res(parsed.data.data);
-                        }
-                        else {
-                            rej(new Error("Mail delivery failed: " +
-                                JSON.stringify(receivedMsg)));
-                        }
-                    }
-                };
-                this.socket.on("message", callback);
-                // See the matching block above (sendMail handshake):
-                // forward send failures to the outer promise so the
-                // caller doesn't hang waiting for a response we never
-                // sent.
-                this.send(msgb, hmac).catch((err) => {
-                    this.socket.off("message", callback);
-                    rej(err instanceof Error ? err : new Error(String(err)));
-                });
-            });
+            await this.deliverMailResource(msgb, hmac, mail);
         }
         finally {
             this.sending.delete(device.deviceID);
@@ -3464,28 +3547,41 @@ export class Client {
             // One logical DM fan-outs to multiple recipient devices. Reuse a
             // single mailID so local/UI dedupe treats it as one message.
             const messageMailID = uuid.v4();
-            for (const device of deviceList) {
-                try {
-                    if (libvexDebugDmEnabled()) {
-                        debugLibvexDm("sendMessage: sendMail start", {
-                            mailID: messageMailID,
-                            recipientDevice: device.deviceID,
-                        });
+            const msgBytes = XUtils.decodeUTF8(payload);
+            for (let index = 0; index < deviceList.length; index += MAIL_FANOUT_CONCURRENCY) {
+                const batch = deviceList.slice(index, index + MAIL_FANOUT_CONCURRENCY);
+                const results = await Promise.all(batch.map(async (device) => {
+                    try {
+                        if (libvexDebugDmEnabled()) {
+                            debugLibvexDm("sendMessage: sendMail start", {
+                                mailID: messageMailID,
+                                recipientDevice: device.deviceID,
+                            });
+                        }
+                        await this.sendMailWithRecovery(device, userEntry, msgBytes, null, messageMailID, false);
+                        if (libvexDebugDmEnabled()) {
+                            debugLibvexDm("sendMessage: sendMail ok", {
+                                recipientDevice: device.deviceID,
+                            });
+                        }
+                        return undefined;
                     }
-                    await this.sendMailWithRecovery(device, userEntry, XUtils.decodeUTF8(payload), null, messageMailID, false);
-                    if (libvexDebugDmEnabled()) {
-                        debugLibvexDm("sendMessage: sendMail ok", {
-                            recipientDevice: device.deviceID,
-                        });
+                    catch (e) {
+                        if (libvexDebugDmEnabled()) {
+                            // eslint-disable-next-line no-console -- LIBVEX_DEBUG_DM only
+                            console.error("[libvex:debug-dm] sendMessage: sendMail failed for device", device.deviceID, e);
+                        }
+                        return e;
                     }
-                }
-                catch (e) {
-                    if (libvexDebugDmEnabled()) {
-                        // eslint-disable-next-line no-console -- LIBVEX_DEBUG_DM only
-                        console.error("[libvex:debug-dm] sendMessage: sendMail failed for device", device.deviceID, e);
+                }));
+                for (const result of results) {
+                    if (result !== undefined) {
+                        lastErr = result;
+                        failCount += 1;
                     }
-                    lastErr = e;
-                    failCount += 1;
+                }
+                if (failCount === deviceList.length) {
+                    break;
                 }
             }
             if (failCount > 0) {