@vex-chat/libvex 7.0.2 → 7.1.1

package/src/Client.ts

@@ -429,8 +429,32 @@ export interface Devices {
      * approving device.
      */
     approveRequest: (requestID: string) => Promise<Device>;
+    /**
+     * Begin creating a passkey from a newly approved, still pending device
+     * enrollment. Proves possession of the requesting device key by signing
+     * the original pending-registration challenge.
+     */
+    beginPendingPasskeyRegistration: (args: {
+        challenge: string;
+        name: string;
+        requestID: string;
+    }) => Promise<{
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any -- WebAuthn options shape varies per simplewebauthn version
+        options: any;
+        requestID: string;
+    }>;
     /** Deletes one of the account's devices (except the currently active one). */
     delete: (deviceID: string) => Promise<void>;
+    /**
+     * Finish creating a passkey for a newly approved pending device
+     * enrollment.
+     */
+    finishPendingPasskeyRegistration: (args: {
+        challenge: string;
+        name: string;
+        requestID: string;
+        response: Record<string, unknown>;
+    }) => Promise<Passkey>;
     /** Fetches one pending registration request by ID for the current user. */
     getRequest: (requestID: string) => Promise<null | PendingDeviceRequest>;
     /** Lists every device belonging to the current account. */
@@ -1303,7 +1327,11 @@ export class Client {
         abortPendingRegistration:
             this.abortPendingDeviceRegistration.bind(this),
         approveRequest: this.approveDeviceRequest.bind(this),
+        beginPendingPasskeyRegistration:
+            this.beginPendingDevicePasskeyRegistration.bind(this),
         delete: this.deleteDevice.bind(this),
+        finishPendingPasskeyRegistration:
+            this.finishPendingDevicePasskeyRegistration.bind(this),
         getRequest: this.getDeviceRegistrationRequest.bind(this),
         list: this.listDevices.bind(this),
         listRequests: this.listDeviceRegistrationRequests.bind(this),
@@ -2529,6 +2557,29 @@ export class Client {
         return decodeHttpResponse(PasskeyOptionsCodec, response.data);
     }
 
+    private async beginPendingDevicePasskeyRegistration(args: {
+        challenge: string;
+        name: string;
+        requestID: string;
+    }): Promise<{
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any -- WebAuthn options shape varies per simplewebauthn version
+        options: any;
+        requestID: string;
+    }> {
+        const signed = await this.signPendingRegistrationChallenge(
+            args.challenge,
+        );
+        const response = await this.http.post(
+            this.getHost() +
+                "/user/devices/requests/" +
+                args.requestID +
+                "/passkeys/register/begin",
+            msgpack.encode({ name: args.name, signed }),
+            { headers: { "Content-Type": "application/msgpack" } },
+        );
+        return decodeHttpResponse(PasskeyOptionsCodec, response.data);
+    }
+
     private censorPreKey(preKey: PreKeysSQL): PreKeysWS {
         if (!preKey.index) {
             throw new Error("Key index is required.");
@@ -2685,7 +2736,7 @@ export class Client {
          * errors should not reject the full read pipeline.
          */
         allowKeyBundleFailure = false,
-    ): Promise<void> {
+    ): Promise<Message | null> {
         return this.runWithThisCryptoProfile(async () => {
             let keyBundle: KeyBundle;
 
@@ -2698,7 +2749,7 @@ export class Client {
                 );
             } catch (e) {
                 if (allowKeyBundleFailure) {
-                    return;
+                    return null;
                 }
                 const wrap =
                     e instanceof Error ? e : new Error(String(e), { cause: e });
@@ -2710,7 +2761,7 @@ export class Client {
 
             if (!this.xKeyRing) {
                 if (this.manuallyClosing) {
-                    return;
+                    return null;
                 }
                 throw new Error("Key ring not initialized.");
             }
@@ -2859,6 +2910,7 @@ export class Client {
             }
 
             await this.deliverMailResource(msg, hmac, mail);
+            return shouldEmitHandshakeMessage ? emitMsg : null;
         });
     }
 
@@ -3119,6 +3171,31 @@ export class Client {
         return decodeHttpResponse(PasskeyCodec, response.data);
     }
 
+    private async finishPendingDevicePasskeyRegistration(args: {
+        challenge: string;
+        name: string;
+        requestID: string;
+        response: Record<string, unknown>;
+    }): Promise<Passkey> {
+        const signed = await this.signPendingRegistrationChallenge(
+            args.challenge,
+        );
+        const response = await this.http.post(
+            this.getHost() +
+                "/user/devices/requests/" +
+                args.requestID +
+                "/passkeys/register/finish",
+            msgpack.encode({
+                name: args.name,
+                requestID: args.requestID,
+                response: args.response,
+                signed,
+            }),
+            { headers: { "Content-Type": "application/msgpack" } },
+        );
+        return decodeHttpResponse(PasskeyCodec, response.data);
+    }
+
     private async flushMailBatchOverSocket(
         batch: PendingMailBatchDelivery[],
     ): Promise<void> {
@@ -3223,6 +3300,8 @@ export class Client {
         const targetDevices = devices.filter(
             (device) => device.deviceID !== this.getDevice().deviceID,
         );
+        let failCount = 0;
+        let lastErr: unknown;
         for (
             let index = 0;
             index < targetDevices.length;
@@ -3243,12 +3322,27 @@ export class Client {
                             copy.mailID,
                             true,
                         );
-                    } catch {
-                        /* best-effort per device */
+                    } catch (err: unknown) {
+                        failCount += 1;
+                        lastErr = err;
                     }
                 }),
             );
         }
+        if (failCount === 0) {
+            return;
+        }
+        const base =
+            lastErr instanceof Error ? lastErr : new Error(String(lastErr));
+        if (failCount === targetDevices.length) {
+            throw base;
+        }
+        const partial = new Error(
+            `Forwarded direct message failed to reach ${String(failCount)} of ` +
+                `${String(targetDevices.length)} owned device(s).`,
+        );
+        partial.cause = base;
+        throw partial;
     }
 
     private async getChannelByID(channelID: string): Promise<Channel | null> {
@@ -3826,21 +3920,14 @@ export class Client {
     }
 
     /**
-     * Pipeline for decrypted messages — registered in `init`. After `close()` sets
-     * `manuallyClosing`, this becomes a no-op so fire-and-forget `forward` does not
-     * race HTTP teardown (we avoid `off()` here — it can interact badly with emit).
+     * Pipeline for decrypted messages - registered in `init`. After `close()` sets
+     * `manuallyClosing`, this becomes a no-op (we avoid `off()` here - it can
+     * interact badly with emit).
      */
     private readonly onInternalMessage = (message: Message): void => {
         if (this.isManualCloseInFlight()) {
             return;
         }
-        if (
-            message.direction === "outgoing" &&
-            !message.forward &&
-            message.group === null
-        ) {
-            void this.forward(message);
-        }
 
         if (
             message.direction === "incoming" &&
@@ -5184,7 +5271,7 @@ export class Client {
         mailID: null | string,
         forward: boolean,
         retry = false,
-    ): Promise<void> {
+    ): Promise<Message | null> {
         while (this.sending.has(device.deviceID)) {
             await sleep(100);
         }
@@ -5202,7 +5289,7 @@ export class Client {
                         retry: String(retry),
                     });
                 }
-                await this.createSession(
+                const createdMessage = await this.createSession(
                     device,
                     user,
                     msg,
@@ -5216,7 +5303,7 @@ export class Client {
                         peerDevice: device.deviceID,
                     });
                 }
-                return;
+                return createdMessage;
             }
 
             if (libvexDebugDmEnabled()) {
@@ -5312,6 +5399,7 @@ export class Client {
             this.sessionRecords[XUtils.encodeHex(session.publicKey)] = session;
 
             await this.deliverMailResource(msgb, hmac, mail);
+            return outMsg;
         } finally {
             this.sending.delete(device.deviceID);
         }
@@ -5324,14 +5412,21 @@ export class Client {
         group: null | Uint8Array,
         mailID: null | string,
         forward: boolean,
-    ): Promise<void> {
+    ): Promise<Message | null> {
         try {
-            await this.sendMail(device, user, msg, group, mailID, forward);
+            return await this.sendMail(
+                device,
+                user,
+                msg,
+                group,
+                mailID,
+                forward,
+            );
         } catch (err: unknown) {
             if (!this.shouldRetryDeliveryWithFreshSession(err)) {
                 throw err;
             }
-            await this.sendMail(
+            return await this.sendMail(
                 device,
                 user,
                 msg,
@@ -5411,6 +5506,9 @@ export class Client {
             // single mailID so local/UI dedupe treats it as one message.
             const messageMailID = uuid.v4();
             const msgBytes = XUtils.decodeUTF8(payload);
+            const firstOutgoingMessage: { current: Message | null } = {
+                current: null,
+            };
             for (
                 let index = 0;
                 index < deviceList.length;
@@ -5429,7 +5527,7 @@ export class Client {
                                     recipientDevice: device.deviceID,
                                 });
                             }
-                            await this.sendMailWithRecovery(
+                            const sentMessage = await this.sendMailWithRecovery(
                                 device,
                                 userEntry,
                                 msgBytes,
@@ -5437,6 +5535,13 @@ export class Client {
                                 messageMailID,
                                 false,
                             );
+                            if (
+                                firstOutgoingMessage.current === null &&
+                                sentMessage &&
+                                !sentMessage.forward
+                            ) {
+                                firstOutgoingMessage.current = sentMessage;
+                            }
                             if (libvexDebugDmEnabled()) {
                                 debugLibvexDm("sendMessage: sendMail ok", {
                                     recipientDevice: device.deviceID,
@@ -5483,6 +5588,12 @@ export class Client {
                 partial.cause = base;
                 throw partial;
             }
+            if (
+                userID !== this.getUser().userID &&
+                firstOutgoingMessage.current !== null
+            ) {
+                await this.forward(firstOutgoingMessage.current);
+            }
         } catch (err: unknown) {
             throw err;
         }

package/src/__tests__/dm-own-device-forward.test.ts

@@ -0,0 +1,157 @@
+/**
+ * Copyright (c) 2020-2026 Vex Heavy Industries LLC
+ * Licensed under AGPL-3.0. See LICENSE for details.
+ * Commercial licenses available at vex.wtf
+ */
+
+import type { Device, User } from "@vex-chat/types";
+
+import { describe, expect, it, vi } from "vitest";
+
+import { msgpack } from "../codec.js";
+import { Client, type Message } from "../index.js";
+
+interface SendMailCall {
+    device: Device;
+    forward: boolean;
+    group: null | Uint8Array;
+    mailID: null | string;
+    msg: Uint8Array;
+    user: User;
+}
+
+type SendMessage = (
+    this: unknown,
+    userID: string,
+    message: string,
+) => Promise<void>;
+
+const now = "2026-05-27T00:00:00.000Z";
+
+function device(deviceID: string, owner: string): Device {
+    return {
+        deleted: false,
+        deviceID,
+        lastLogin: now,
+        name: deviceID,
+        owner,
+        signKey: `${deviceID}-sign-key`,
+    };
+}
+
+function user(userID: string, username: string): User {
+    return {
+        lastSeen: now,
+        userID,
+        username,
+    };
+}
+
+describe("direct message own-device forwarding", () => {
+    it("sends a forwarded copy to the sender's other devices", async () => {
+        const senderUser = user("user-a", "alice");
+        const peerUser = user("user-b", "bob");
+        const senderOriginalDevice = device("a-device-1", senderUser.userID);
+        const senderCurrentDevice = device("a-device-2", senderUser.userID);
+        const peerDevice = device("b-device-1", peerUser.userID);
+        const calls: SendMailCall[] = [];
+
+        const fakeClient = {
+            fetchUser: vi.fn((userID: string) =>
+                Promise.resolve([
+                    userID === peerUser.userID ? peerUser : senderUser,
+                    null,
+                ]),
+            ),
+            fetchUserDeviceListOnce: vi.fn((userID: string) =>
+                Promise.resolve(
+                    userID === peerUser.userID
+                        ? [peerDevice]
+                        : [senderOriginalDevice, senderCurrentDevice],
+                ),
+            ),
+            fetchUserDeviceListWithBackoff: vi.fn((userID: string) =>
+                Promise.resolve(
+                    userID === peerUser.userID
+                        ? [peerDevice]
+                        : [senderOriginalDevice, senderCurrentDevice],
+                ),
+            ),
+            forward: Reflect.get(Client.prototype, "forward") as (
+                message: Message,
+            ) => Promise<void>,
+            forwarded: new Set<string>(),
+            getDevice: () => senderCurrentDevice,
+            getUser: () => senderUser,
+            isManualCloseInFlight: () => false,
+            sendMailWithRecovery: vi.fn(
+                (
+                    sentDevice: Device,
+                    sentUser: User,
+                    msg: Uint8Array,
+                    group: null | Uint8Array,
+                    mailID: null | string,
+                    forward: boolean,
+                ): Promise<Message> => {
+                    calls.push({
+                        device: sentDevice,
+                        forward,
+                        group,
+                        mailID,
+                        msg,
+                        user: sentUser,
+                    });
+                    return Promise.resolve({
+                        authorID: senderUser.userID,
+                        decrypted: true,
+                        direction: "outgoing",
+                        forward,
+                        group: null,
+                        mailID: mailID ?? "generated-mail-id",
+                        message: forward
+                            ? (msgpack.decode(msg) as Message).message
+                            : "hello from second device",
+                        nonce: `${sentDevice.deviceID}-nonce`,
+                        readerID: sentUser.userID,
+                        recipient: sentDevice.deviceID,
+                        sender: senderCurrentDevice.deviceID,
+                        timestamp: now,
+                    });
+                },
+            ),
+        };
+
+        const sendMessage = Reflect.get(
+            Client.prototype,
+            "sendMessage",
+        ) as SendMessage;
+
+        await sendMessage.call(
+            fakeClient,
+            peerUser.userID,
+            "hello from second device",
+        );
+
+        expect(calls).toHaveLength(2);
+        expect(calls[0]).toMatchObject({
+            device: peerDevice,
+            forward: false,
+            user: peerUser,
+        });
+        expect(calls[1]).toMatchObject({
+            device: senderOriginalDevice,
+            forward: true,
+            user: senderUser,
+        });
+        const forwardedPayload = msgpack.decode(calls[1]!.msg) as Message;
+        expect(forwardedPayload).toMatchObject({
+            authorID: senderUser.userID,
+            direction: "outgoing",
+            forward: false,
+            message: "hello from second device",
+            readerID: peerUser.userID,
+            sender: senderCurrentDevice.deviceID,
+        });
+        expect(forwardedPayload.mailID).toBe(calls[0]!.mailID);
+    });
+});