@gryt/core 0.18.2 → 0.20.0

package/dist/index.d.ts

@@ -12,9 +12,9 @@ export { describeFolderRules, folderFollowNote, folderPhrase, } from "./permissi
 export { agreementAt, createTermsGate, GUIDELINES_URL, TERMS_STORAGE_KEY, TERMS_URL, TERMS_VERSION, } from "./terms/termsAgreement.js";
 export { createMlsDmDriver, MlsDriverError, type MlsDriverErrorCode } from "./mls/dmDriver.js";
 export { mlsPinsFromPeerPins } from "./mls/pins.js";
-export { decodeMlsDmContent, encodeMlsDmContent, MLS_DM_CONTENT_VERSION, type MlsDmContent, readMlsDmContent, } from "./mls/content.js";
+export { decodeMlsDmContent, encodeMlsDmContent, historyBatches, MAX_HISTORY_BATCH_BYTES, MLS_DM_CONTENT_VERSION, type MlsDmContent, type MlsHistoryEntry, readMlsDmContent, } from "./mls/content.js";
 export { applyMlsReaction, mlsReactionAction, type MlsReaction } from "./mls/reactions.js";
-export type { DmSealingMode, MlsAddOwnDeviceOptions, MlsClaimedKeyPackage, MlsDecryptedMessage, MlsDeviceRecord, MlsDeviceRef, MlsDmDriver, MlsDmDriverOptions, MlsDmEvents, MlsGroupPosition, MlsGroupRecord, MlsGroupView, MlsKeyPackageRecord, MlsListedDevice, MlsLogEntry, MlsOwnDevice, MlsOwnDeviceAdd, MlsPins, MlsRefusal, MlsReply, MlsServerCapability, MlsStateStore, MlsTransport, MlsWelcomeDelivery, } from "./mls/interfaces.js";
+export type { DmSealingMode, MlsAddOwnDeviceOptions, MlsClaimedKeyPackage, MlsDecryptedMessage, MlsDeviceRecord, MlsDeviceRef, MlsDmDriver, MlsDmDriverOptions, MlsDmEvents, MlsGroupPosition, MlsGroupRecord, MlsGroupView, MlsKeyPackageRecord, MlsListedDevice, MlsLogEntry, MlsDmDiagnostics, MlsOwnDevice, MlsOwnDeviceAdd, MlsPins, MlsRefusal, MlsReply, MlsServerCapability, MlsStateStore, MlsTransport, MlsWelcomeDelivery, } from "./mls/interfaces.js";
 export { createApproverPairing, type ApproverOptions, type ApproverPairing, type ApproverState, } from "./pairing/approver.js";
 export { createNewDevicePairing, PAIRING_APPROVAL_MS, type NewDeviceOptions, type NewDevicePairing, type NewDeviceState, } from "./pairing/newDevice.js";
 export { createPairingRelay, PairingRelayError, type PairingRelay } from "./pairing/relayClient.js";

package/dist/index.js

@@ -14,7 +14,7 @@ export { describeFolderRules, folderFollowNote, folderPhrase, } from "./permissi
 export { agreementAt, createTermsGate, GUIDELINES_URL, TERMS_STORAGE_KEY, TERMS_URL, TERMS_VERSION, } from "./terms/termsAgreement.js";
 export { createMlsDmDriver, MlsDriverError } from "./mls/dmDriver.js";
 export { mlsPinsFromPeerPins } from "./mls/pins.js";
-export { decodeMlsDmContent, encodeMlsDmContent, MLS_DM_CONTENT_VERSION, readMlsDmContent, } from "./mls/content.js";
+export { decodeMlsDmContent, encodeMlsDmContent, historyBatches, MAX_HISTORY_BATCH_BYTES, MLS_DM_CONTENT_VERSION, readMlsDmContent, } from "./mls/content.js";
 export { applyMlsReaction, mlsReactionAction } from "./mls/reactions.js";
 export { createApproverPairing, } from "./pairing/approver.js";
 export { createNewDevicePairing, PAIRING_APPROVAL_MS, } from "./pairing/newDevice.js";

package/dist/mls/content.d.ts

@@ -1,5 +1,21 @@
 import { type SealedAttachmentKey } from "@gryt/crypto";
+/** One message from the sender's own record of the DM, for the other person's new device (GRYT-1875). */
+export interface MlsHistoryEntry {
+    id: string;
+    /** Server user id of whoever wrote it, as the sender's record has it. */
+    senderId: string;
+    /** Milliseconds since the epoch. */
+    sentAt: number;
+    text: string;
+    replyTo?: string;
+    attachments?: Record<string, SealedAttachmentKey>;
+}
 export type MlsDmContent = {
+    type: "history";
+    /** For the batch itself, so a repeat is the same message. */
+    id: string;
+    entries: MlsHistoryEntry[];
+} | {
     type: "message";
     /** Made by the sender, a UUID. Edits and deletes name it. */
     id: string;
@@ -24,8 +40,14 @@ export type MlsDmContent = {
     action: "add" | "remove";
 };
 export declare const MLS_DM_CONTENT_VERSION = 1;
+/** Under what one `mls:send` takes once sealed and padded. */
+export declare const MAX_HISTORY_BATCH_BYTES: number;
 /** The same bytes the phone writes: `v` first, then the content's fields in this order. */
 export declare function encodeMlsDmContent(content: MlsDmContent): Uint8Array;
+/** History as batches small enough to send, oldest first. One entry too big to send on its own is left out. */
+export declare function historyBatches(entries: MlsHistoryEntry[], newId: () => string): Extract<MlsDmContent, {
+    type: "history";
+}>[];
 /** Null for anything this version can't read: a newer version, a new type, or junk. */
 export declare function decodeMlsDmContent(bytes: Uint8Array): MlsDmContent | null;
 /**

package/dist/mls/content.js

@@ -16,6 +16,9 @@ const isId = (v) => typeof v === "string" && v.length > 0 && v.length <= MAX_ID;
 const isText = (v) => typeof v === "string" && v.length <= MAX_TEXT;
 const isCount = (v) => typeof v === "number" && Number.isSafeInteger(v) && v >= 0;
 const isLabel = (v) => typeof v === "string" && v.length <= MAX_LABEL;
+const MAX_HISTORY_ENTRIES = 200;
+/** Under what one `mls:send` takes once sealed and padded. */
+export const MAX_HISTORY_BATCH_BYTES = 48 * 1024;
 /** One emoji's worth of emoji characters, so a peer can't put a sentence on a message as a reaction. */
 function isReactionEmoji(v) {
     if (typeof v !== "string")
@@ -79,7 +82,10 @@ function readAttachments(v) {
 /** The same bytes the phone writes: `v` first, then the content's fields in this order. */
 export function encodeMlsDmContent(content) {
     let body;
-    if (content.type === "message") {
+    if (content.type === "history") {
+        body = { type: content.type, id: content.id, entries: content.entries.map(historyBody) };
+    }
+    else if (content.type === "message") {
         body = { type: content.type, id: content.id, text: content.text };
         if (content.replyTo !== undefined)
             body.replyTo = content.replyTo;
@@ -100,6 +106,49 @@ export function encodeMlsDmContent(content) {
         throw new Error("That content wouldn't read back, so it isn't sent.");
     return bytes;
 }
+function historyBody(e) {
+    const out = { id: e.id, senderId: e.senderId, sentAt: e.sentAt, text: e.text };
+    if (e.replyTo !== undefined)
+        out.replyTo = e.replyTo;
+    if (e.attachments && Object.keys(e.attachments).length > 0)
+        out.attachments = e.attachments;
+    return out;
+}
+/** History as batches small enough to send, oldest first. One entry too big to send on its own is left out. */
+export function historyBatches(entries, newId) {
+    const size = (batch) => new TextEncoder().encode(JSON.stringify({ v: MLS_DM_CONTENT_VERSION, type: "history", id: "x".repeat(MAX_ID), entries: batch.map(historyBody) })).length;
+    const out = [];
+    let batch = [];
+    for (const e of [...entries].sort((a, b) => a.sentAt - b.sentAt)) {
+        if (!readHistoryEntry(historyBody(e)) || size([e]) > MAX_HISTORY_BATCH_BYTES)
+            continue;
+        if (batch.length === MAX_HISTORY_ENTRIES || size([...batch, e]) > MAX_HISTORY_BATCH_BYTES) {
+            out.push({ type: "history", id: newId(), entries: batch });
+            batch = [];
+        }
+        batch.push(e);
+    }
+    if (batch.length)
+        out.push({ type: "history", id: newId(), entries: batch });
+    return out;
+}
+function readHistoryEntry(v) {
+    if (!isObject(v) || !isId(v.id) || !isId(v.senderId) || !isText(v.text) || !isCount(v.sentAt))
+        return null;
+    const out = { id: v.id, senderId: v.senderId, sentAt: v.sentAt, text: v.text };
+    if (v.replyTo !== undefined) {
+        if (!isId(v.replyTo))
+            return null;
+        out.replyTo = v.replyTo;
+    }
+    if (v.attachments !== undefined) {
+        const attachments = readAttachments(v.attachments);
+        if (!attachments)
+            return null;
+        out.attachments = attachments;
+    }
+    return out;
+}
 /** Null for anything this version can't read: a newer version, a new type, or junk. */
 export function decodeMlsDmContent(bytes) {
     return fromRaw(parse(bytes));
@@ -112,7 +161,7 @@ export function readMlsDmContent(bytes) {
     const raw = parse(bytes);
     return fromRaw(raw) ?? (isNewer(raw) ? "newer" : null);
 }
-const KNOWN_TYPES = new Set(["message", "edit", "delete", "reaction"]);
+const KNOWN_TYPES = new Set(["message", "edit", "delete", "reaction", "history"]);
 const TYPE_NAME = /^[a-z][a-z0-9_]{0,31}$/;
 /** A later version, or a type this one doesn't know that names its message the way ours do. */
 function isNewer(raw) {
@@ -134,6 +183,12 @@ function fromRaw(raw) {
     if (!isObject(raw) || raw.v !== MLS_DM_CONTENT_VERSION || !isId(raw.id))
         return null;
     const { type, id, text } = raw;
+    if (type === "history") {
+        if (!Array.isArray(raw.entries) || raw.entries.length === 0 || raw.entries.length > MAX_HISTORY_ENTRIES)
+            return null;
+        const entries = raw.entries.map(readHistoryEntry);
+        return entries.every((e) => e !== null) ? { type, id, entries } : null;
+    }
     if (type === "message" && isText(text)) {
         const out = { type, id, text };
         if (raw.replyTo !== undefined) {

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

@@ -75,6 +75,8 @@ export declare class FakeDeliveryService {
     private devicesOf;
     private isDevice;
     private groupView;
+    /** What the server's retention sweep does to a device not seen for a while: gone, but not removed. */
+    expire(serverUserId: string, deviceId: string): void;
     private transportFor;
     private checkParts;
     private counts;

package/dist/mls/deliveryService.fake.js

@@ -1,6 +1,6 @@
 /* An in-memory stand-in for the delivery service in Gryt-chat/server#241, for tests only.
    Same answers and pushes; no auth, blocks, rate limits or member checks on adds. */
-import { base64UrlDecode, inspectMlsMessage, mlsWelcomeRefs, readMlsKeyPackage } from "@gryt/crypto";
+import { base64UrlDecode, inspectMlsMessage, mlsGroupInfoDeviceIds, mlsWelcomeRefs, readMlsKeyPackage, } from "@gryt/crypto";
 const MAX_DEVICES = 100;
 const MAX_KEY_PACKAGES = 20;
 const MAX_LOG_PAGE = 200;
@@ -85,6 +85,13 @@ export class FakeDeliveryService {
     groupView(g) {
         return { conversationId: g.conversationId, groupId: g.groupId, epoch: g.epoch, headSeq: g.headSeq };
     }
+    /** What the server's retention sweep does to a device not seen for a while: gone, but not removed. */
+    expire(serverUserId, deviceId) {
+        this.devices.set(serverUserId, (this.devices.get(serverUserId) ?? []).filter((d) => d !== deviceId));
+        this.keyPackages = this.keyPackages.filter((k) => !(k.serverUserId === serverUserId && k.deviceId === deviceId));
+        this.welcomes = this.welcomes.filter((w) => !(w.serverUserId === serverUserId && w.deviceId === deviceId));
+        this.push(this.peopleSharing(serverUserId), (d) => d.handleDevicesChanged({ serverUserId }));
+    }
     transportFor(socket) {
         const me = socket.serverUserId;
         const tick = () => new Promise((resolve) => setTimeout(resolve, 0));
@@ -276,6 +283,24 @@ export class FakeDeliveryService {
                 g.info = { epoch: g.epoch, data: groupInfo.slice() };
                 return { ok: true };
             },
+            replaceGroup: async ({ conversationId, deviceId, oldGroupId, groupId }) => {
+                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 || g.groupId !== oldGroupId)
+                    return fail("stale_group", "That isn't this conversation's group anymore.");
+                const listed = new Set(this.devicesOf(this.conversations.get(conversationId)).map((d) => d.deviceId));
+                if (!g.info || mlsGroupInfoDeviceIds(g.info.data, this.scope).some((id) => listed.has(id))) {
+                    return fail("not_abandoned", "Somebody in this group can still add devices.");
+                }
+                const fresh = { conversationId, groupId, epoch: 0, headSeq: 0, log: [] };
+                this.groups.set(conversationId, fresh);
+                this.welcomes = this.welcomes.filter((w) => w.groupId !== oldGroupId);
+                return { ok: true, group: this.groupView(fresh) };
+            },
             getGroupInfo: 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, joinMlsGroupExternally, mlsGroupInfo, mlsGroupInfoForJoining, mlsGroupMembers, mlsWelcomeRefs, processMlsMessage, readDeviceCertificate, readMlsKeyPackage, removeMlsMembers, } from "@gryt/crypto";
+import { addMlsMembers, asIdentityScope, base64UrlDecode, createMlsGroup, decodeMlsGroupState, encodeMlsGroupState, encryptMlsMessage, forgetMlsSecrets, generateMlsKeyPackage, joinMlsGroup, joinMlsGroupExternally, mlsGroupInfo, mlsGroupInfoForJoining, mlsGroupInfoDeviceIds, 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;
@@ -92,6 +92,7 @@ export function createMlsDmDriver(options) {
     const rawRequestAdd = raw.requestAdd?.bind(raw);
     const rawPutGroupInfo = raw.putGroupInfo?.bind(raw);
     const rawGetGroupInfo = raw.getGroupInfo?.bind(raw);
+    const rawReplaceGroup = raw.replaceGroup?.bind(raw);
     const transport = {
         publishKeyPackages: stopOnRemoval((req) => raw.publishKeyPackages(req)),
         claimKeyPackages: stopOnRemoval((req) => raw.claimKeyPackages(req)),
@@ -106,6 +107,7 @@ export function createMlsDmDriver(options) {
         ...(rawRequestAdd ? { requestAdd: stopOnRemoval(rawRequestAdd) } : {}),
         ...(rawPutGroupInfo ? { putGroupInfo: stopOnRemoval(rawPutGroupInfo) } : {}),
         ...(rawGetGroupInfo ? { getGroupInfo: stopOnRemoval(rawGetGroupInfo) } : {}),
+        ...(rawReplaceGroup ? { replaceGroup: stopOnRemoval(rawReplaceGroup) } : {}),
     };
     const scope = asIdentityScope(options.scope);
     const trusts = new Map();
@@ -527,7 +529,7 @@ export function createMlsDmDriver(options) {
                 const list = welcomeWaiters.get(conversationId) ?? [];
                 welcomeWaiters.set(conversationId, list.filter((w) => w !== done));
                 reject(new MlsDriverError("waiting_for_welcome", "The group exists and this device hasn't been added yet."));
-            }, WELCOME_WAIT_MS);
+            }, options.welcomeWaitMs ?? WELCOME_WAIT_MS);
             welcomeWaiters.set(conversationId, [...(welcomeWaiters.get(conversationId) ?? []), done]);
         });
     }
@@ -578,6 +580,71 @@ export function createMlsDmDriver(options) {
             return true;
         });
     }
+    /* Every device in the group is gone, so nobody can add anyone and nobody can join by itself:
+       this device starts a new group in its place. Others who held the old one follow it (core#48). */
+    async function rebuild(conversationId) {
+        const replace = transport.replaceGroup;
+        if (!replace || !transport.getGroupInfo)
+            return false;
+        const d = await ownDevice();
+        const got = await transport.getGroupInfo({ conversationId, deviceId: d.deviceId }).catch(() => null);
+        const listed = got?.ok ? await transport.listDevices({ conversationId }) : null;
+        const log = listed?.ok ? await transport.fetchLog({ conversationId, after: 0, limit: 1 }) : null;
+        if (!got?.ok || !listed?.ok || !log?.ok || !log.group)
+            return false;
+        const inGroup = mlsGroupInfoDeviceIds(got.groupInfo, scope);
+        if (inGroup.some((id) => listed.devices.some((x) => x.deviceId === id)))
+            return false;
+        const oldGroupId = log.group.groupId;
+        return run(conversationId, async () => {
+            if (await store.loadGroup(conversationId))
+                return true;
+            const state = await createMlsGroup(d, trustFor(conversationId));
+            const open = {
+                rec: { conversationId, groupId: groupIdOf(state), state: encodeMlsGroupState(state), cursor: 0, joinedEpoch: 0 },
+                state,
+            };
+            await store.saveGroup(open.rec);
+            const r = await replace({ conversationId, deviceId: d.deviceId, oldGroupId, groupId: open.rec.groupId });
+            if (!r.ok) {
+                await store.deleteGroup(conversationId);
+                return false;
+            }
+            void publishGroupInfo(open);
+            return true;
+        });
+    }
+    async function diagnose(conversationId) {
+        const d = device ?? (await store.loadDevice());
+        const rec = await store.loadGroup(conversationId);
+        let inGroup = null;
+        let epoch = -1;
+        if (rec) {
+            try {
+                const state = decodeMlsGroupState(rec.state, trustFor(conversationId));
+                epoch = epochOf(state);
+                inGroup = mlsGroupMembers(state, scope).map((m) => ({
+                    deviceId: m.certificate.deviceId,
+                    name: m.certificate.deviceName,
+                    thisDevice: m.certificate.deviceId === d?.deviceId,
+                }));
+            }
+            catch {
+                inGroup = null;
+            }
+        }
+        const listed = await transport.listDevices({ conversationId }).catch(() => null);
+        return {
+            deviceId: d?.deviceId ?? null,
+            registered,
+            group: rec ? { groupId: rec.groupId, epoch, cursor: rec.cursor, joinedEpoch: rec.joinedEpoch } : null,
+            inGroup,
+            listed: listed?.ok ? listed.devices : null,
+            left: left.has(conversationId),
+            unjoinable: unjoinable.has(conversationId),
+            askedAt: asked.get(conversationId) ?? null,
+        };
+    }
     /* 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) {
@@ -613,6 +680,8 @@ export function createMlsDmDriver(options) {
         }
         if (await joinByItself(conversationId))
             return;
+        if (await rebuild(conversationId))
+            return;
         void askToBeAdded(conversationId).catch(() => undefined);
         await waitForWelcome(conversationId);
     }
@@ -1052,6 +1121,7 @@ export function createMlsDmDriver(options) {
         handleAddRequest,
         requestAdd: (conversationId) => askToBeAdded(conversationId, true),
         ownDevices,
+        diagnose,
         async removeOwnDevice(deviceId) {
             const r = await transport.removeDevice({ deviceId });
             if (!r.ok)

package/dist/mls/interfaces.d.ts

@@ -159,6 +159,15 @@ export interface MlsTransport {
         epoch: number;
         groupInfo: Uint8Array;
     }>>;
+    /** A fresh group in place of one nobody is left in to add anyone (GRYT-1862). The server checks that. */
+    replaceGroup?(req: {
+        conversationId: string;
+        deviceId: string;
+        oldGroupId: string;
+        groupId: string;
+    }): Promise<MlsReply<{
+        group: MlsGroupView;
+    }>>;
 }
 /** `server:info.mls`. Absent means the server can't do MLS. */
 export interface MlsServerCapability {
@@ -334,6 +343,32 @@ export interface MlsDmDriverOptions {
     newDevice(): MlsDeviceRecord | Promise<MlsDeviceRecord>;
     /** How long a send waits for the server before it fails with `offline`. Five minutes. */
     sendGiveUpMs?: number;
+    /** How long a send waits for this device to be added to a group that exists. Ten seconds. */
+    welcomeWaitMs?: number;
+}
+/** One DM as this device sees it, for support (GRYT-1864). Ids and counts, never message content. */
+export interface MlsDmDiagnostics {
+    /** Null when this device has no MLS record here yet. */
+    deviceId: string | null;
+    registered: boolean;
+    group: {
+        groupId: string;
+        epoch: number;
+        cursor: number;
+        joinedEpoch: number;
+    } | null;
+    /** The devices in this device's copy of the group, named by their certificates. */
+    inGroup: {
+        deviceId: string;
+        name: string | null;
+        thisDevice: boolean;
+    }[] | null;
+    /** What the server lists for the people in this DM, or null when it didn't answer. */
+    listed: MlsListedDevice[] | null;
+    left: boolean;
+    unjoinable: boolean;
+    /** When this device last asked to be added, in ms. */
+    askedAt: number | null;
 }
 /** One per server. Calls for one conversation run one at a time, in order. */
 export interface MlsDmDriver {
@@ -364,6 +399,8 @@ export interface MlsDmDriver {
     requestAdd(conversationId: string): Promise<void>;
     /** Oldest first, as the server lists them. */
     ownDevices(): Promise<MlsOwnDevice[]>;
+    /** See `MlsDmDiagnostics`. Creates nothing, so looking can't change what it shows. */
+    diagnose(conversationId: string): Promise<MlsDmDiagnostics>;
     /** Your own devices only. Every group you share drops it on the next pass. */
     removeOwnDevice(deviceId: string): Promise<void>;
     /** Pairing: each group's cursor now, which is what the history snapshot covers. */

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@gryt/core",
-  "version": "0.18.2",
+  "version": "0.20.0",
   "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.11.1",
+    "@gryt/crypto": "0.13.0",
     "@noble/hashes": "^2.3.0"
   }
 }