@gryt/core 0.17.1 → 0.18.1

package/dist/mls/deliveryService.fake.d.ts

@@ -14,6 +14,10 @@ interface GroupRow {
     epoch: number;
     headSeq: number;
     log: MlsLogEntry[];
+    info?: {
+        epoch: number;
+        data: Uint8Array;
+    };
 }
 interface Socket {
     serverUserId: string;

package/dist/mls/deliveryService.fake.js

@@ -264,6 +264,29 @@ export class FakeDeliveryService {
                 this.welcomes = this.welcomes.filter((w) => !(w.serverUserId === me && w.deviceId === deviceId && welcomeIds.includes(w.welcomeId)));
                 return { ok: true, deleted: before - this.welcomes.length };
             },
+            putGroupInfo: async ({ conversationId, deviceId, groupInfo }) => {
+                await tick();
+                if (!member(conversationId))
+                    return fail("not_found", "No such conversation.");
+                if (!this.isDevice(me, deviceId))
+                    return fail("unknown_device", "Publish KeyPackages from this device first.");
+                const g = this.groups.get(conversationId);
+                if (!g)
+                    return fail("no_group", "This conversation has no group yet.");
+                g.info = { epoch: g.epoch, data: groupInfo.slice() };
+                return { ok: true };
+            },
+            getGroupInfo: async ({ conversationId, deviceId }) => {
+                await tick();
+                if (!member(conversationId))
+                    return fail("not_found", "No such conversation.");
+                if (!this.isDevice(me, deviceId))
+                    return fail("unknown_device", "Publish KeyPackages from this device first.");
+                const g = this.groups.get(conversationId);
+                if (!g?.info || g.info.epoch !== g.epoch)
+                    return fail("no_group_info", "There's nothing to join from yet.");
+                return { ok: true, epoch: g.info.epoch, groupInfo: g.info.data.slice() };
+            },
             requestAdd: async ({ conversationId, deviceId }) => {
                 await tick();
                 if (!member(conversationId))

package/dist/mls/dmDriver.js

@@ -1,4 +1,4 @@
-import { addMlsMembers, asIdentityScope, base64UrlDecode, createMlsGroup, decodeMlsGroupState, encodeMlsGroupState, encryptMlsMessage, forgetMlsSecrets, generateMlsKeyPackage, joinMlsGroup, mlsGroupInfo, mlsGroupMembers, mlsWelcomeRefs, processMlsMessage, readDeviceCertificate, readMlsKeyPackage, removeMlsMembers, } from "@gryt/crypto";
+import { addMlsMembers, asIdentityScope, base64UrlDecode, createMlsGroup, decodeMlsGroupState, encodeMlsGroupState, encryptMlsMessage, forgetMlsSecrets, generateMlsKeyPackage, joinMlsGroup, joinMlsGroupExternally, mlsGroupInfo, mlsGroupInfoForJoining, mlsGroupMembers, mlsWelcomeRefs, processMlsMessage, readDeviceCertificate, readMlsKeyPackage, removeMlsMembers, } from "@gryt/crypto";
 /** Devices per person per server. Must match the server's MLS_MAX_DEVICES, or extra devices are left out quietly. */
 const MLS_MAX_DEVICES_PER_PERSON = 100;
 const COMMIT_ATTEMPTS = 5;
@@ -90,6 +90,8 @@ export function createMlsDmDriver(options) {
     }
     const raw = options.transport;
     const rawRequestAdd = raw.requestAdd?.bind(raw);
+    const rawPutGroupInfo = raw.putGroupInfo?.bind(raw);
+    const rawGetGroupInfo = raw.getGroupInfo?.bind(raw);
     const transport = {
         publishKeyPackages: stopOnRemoval((req) => raw.publishKeyPackages(req)),
         claimKeyPackages: stopOnRemoval((req) => raw.claimKeyPackages(req)),
@@ -102,6 +104,8 @@ export function createMlsDmDriver(options) {
         sync: stopOnRemoval((req) => raw.sync(req)),
         ackWelcomes: stopOnRemoval((req) => raw.ackWelcomes(req)),
         ...(rawRequestAdd ? { requestAdd: stopOnRemoval(rawRequestAdd) } : {}),
+        ...(rawPutGroupInfo ? { putGroupInfo: stopOnRemoval(rawPutGroupInfo) } : {}),
+        ...(rawGetGroupInfo ? { getGroupInfo: stopOnRemoval(rawGetGroupInfo) } : {}),
     };
     const scope = asIdentityScope(options.scope);
     const trusts = new Map();
@@ -277,7 +281,7 @@ export function createMlsDmDriver(options) {
             }
             else {
                 try {
-                    const r = await processMlsMessage(open.state, e.data);
+                    const r = await processMlsMessage(open.state, e.data, scope);
                     if (r.kind === "handshake" && r.removed) {
                         await store.deleteGroup(open.rec.conversationId);
                         left.add(open.rec.conversationId);
@@ -384,6 +388,7 @@ export function createMlsDmDriver(options) {
                 forgetMlsSecrets(c.consumed);
                 open.rec = { ...open.rec, pending: undefined };
                 await save(open);
+                void publishGroupInfo(open);
                 return;
             }
             open.rec = { ...open.rec, pending: undefined };
@@ -526,6 +531,53 @@ export function createMlsDmDriver(options) {
             welcomeWaiters.set(conversationId, [...(welcomeWaiters.get(conversationId) ?? []), done]);
         });
     }
+    /** For the next device of either person to join by itself. An old server has nowhere to keep it. */
+    async function publishGroupInfo(open) {
+        if (!transport.putGroupInfo)
+            return;
+        try {
+            const groupInfo = await mlsGroupInfoForJoining(open.state);
+            await transport.putGroupInfo({ conversationId: open.rec.conversationId, deviceId: (await ownDevice()).deviceId, groupInfo });
+        }
+        catch {
+            // A stale epoch or an old server: the next commit uploads one again.
+        }
+    }
+    /* Joins from the GroupInfo a member left, with nobody else online (GRYT-1859). False when
+       there's none, it's behind, or this server can't: then the device asks to be added. */
+    async function joinByItself(conversationId) {
+        if (!transport.getGroupInfo)
+            return false;
+        const d = await ownDevice();
+        const got = await transport.getGroupInfo({ conversationId, deviceId: d.deviceId }).catch(() => null);
+        if (!got?.ok)
+            return false;
+        return run(conversationId, async () => {
+            if (await store.loadGroup(conversationId))
+                return true;
+            let joined;
+            try {
+                joined = await joinMlsGroupExternally({ groupInfo: got.groupInfo, device: d, trust: trustFor(conversationId) });
+            }
+            catch {
+                return false;
+            }
+            const r = await transport.commit({ conversationId, deviceId: d.deviceId, commit: joined.commit });
+            if (!r.ok)
+                return false;
+            const open = {
+                rec: { conversationId, groupId: groupIdOf(joined.state), state: new Uint8Array(), cursor: r.seq, joinedEpoch: epochOf(joined.state) },
+                state: joined.state,
+            };
+            await save(open);
+            await notePeople(conversationId, joined.state);
+            reconciled.delete(conversationId);
+            left.delete(conversationId);
+            events.onJoined?.({ conversationId, groupId: open.rec.groupId });
+            void publishGroupInfo(open);
+            return true;
+        });
+    }
     /* Only a member can add a device, so one that's out asks the members' apps to. An old
        server doesn't answer, which is why nothing waits on it. */
     async function askToBeAdded(conversationId, force = false) {
@@ -543,7 +595,10 @@ export function createMlsDmDriver(options) {
                 return;
             void store
                 .loadGroup(conversationId)
-                .then((rec) => (rec ? undefined : askToBeAdded(conversationId)))
+                .then(async (rec) => {
+                if (!rec && !(await joinByItself(conversationId)))
+                    await askToBeAdded(conversationId);
+            })
                 .catch(() => undefined);
         }, NOT_ADDED_GRACE_MS);
     }
@@ -556,6 +611,8 @@ export function createMlsDmDriver(options) {
         if (unjoinable.has(conversationId)) {
             throw new MlsDriverError("peer_unverified", "This device was added, and a member's key isn't pinned here to join with.");
         }
+        if (await joinByItself(conversationId))
+            return;
         void askToBeAdded(conversationId).catch(() => undefined);
         await waitForWelcome(conversationId);
     }

package/dist/mls/interfaces.d.ts

@@ -146,6 +146,19 @@ export interface MlsTransport {
         conversationId: string;
         deviceId: string;
     }): Promise<MlsReply<object>>;
+    /** The group's GroupInfo for its current epoch, so a device of a member can join by itself (GRYT-1859). */
+    putGroupInfo?(req: {
+        conversationId: string;
+        deviceId: string;
+        groupInfo: Uint8Array;
+    }): Promise<MlsReply<object>>;
+    getGroupInfo?(req: {
+        conversationId: string;
+        deviceId: string;
+    }): Promise<MlsReply<{
+        epoch: number;
+        groupInfo: Uint8Array;
+    }>>;
 }
 /** `server:info.mls`. Absent means the server can't do MLS. */
 export interface MlsServerCapability {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@gryt/core",
-  "version": "0.17.1",
+  "version": "0.18.1",
   "description": "Gryt's shared application logic: one implementation of the things the desktop and mobile apps both do.",
   "license": "AGPL-3.0-only",
   "repository": {
@@ -43,7 +43,7 @@
     "access": "public"
   },
   "dependencies": {
-    "@gryt/crypto": "0.9.0",
+    "@gryt/crypto": "0.11.0",
     "@noble/hashes": "^2.3.0"
   }
 }