@gryt/core 0.12.0 → 0.13.0

package/dist/index.d.ts

@@ -14,4 +14,4 @@ export { createMlsDmDriver, MlsDriverError, type MlsDriverErrorCode } from "./ml
 export { mlsPinsFromPeerPins } from "./mls/pins.js";
 export { decodeMlsDmContent, encodeMlsDmContent, MLS_DM_CONTENT_VERSION, type MlsDmContent, readMlsDmContent, } from "./mls/content.js";
 export { applyMlsReaction, mlsReactionAction, type MlsReaction } from "./mls/reactions.js";
-export type { DmSealingMode, MlsClaimedKeyPackage, MlsDecryptedMessage, MlsDeviceRecord, MlsDeviceRef, MlsDmDriver, MlsDmDriverOptions, MlsDmEvents, MlsGroupRecord, MlsGroupView, MlsKeyPackageRecord, MlsLogEntry, MlsPins, MlsRefusal, MlsReply, MlsServerCapability, MlsStateStore, MlsTransport, MlsWelcomeDelivery, } from "./mls/interfaces.js";
+export type { DmSealingMode, MlsClaimedKeyPackage, MlsDecryptedMessage, MlsDeviceRecord, MlsDeviceRef, MlsDmDriver, MlsDmDriverOptions, MlsDmEvents, MlsGroupRecord, MlsGroupView, MlsKeyPackageRecord, MlsListedDevice, MlsLogEntry, MlsOwnDevice, MlsPins, MlsRefusal, MlsReply, MlsServerCapability, MlsStateStore, MlsTransport, MlsWelcomeDelivery, } from "./mls/interfaces.js";

package/dist/mls/dmDriver.d.ts

@@ -1,5 +1,5 @@
 import type { MlsDmDriver, MlsDmDriverOptions, MlsRefusal } from "./interfaces.js";
-export type MlsDriverErrorCode = "refused" | "no_device" | "waiting_for_welcome" | "not_in_group" | "unexpected_member" | "peer_unverified" | "too_many_attachments" | "commit_retries";
+export type MlsDriverErrorCode = "refused" | "no_device" | "waiting_for_welcome" | "not_in_group" | "unexpected_member" | "peer_unverified" | "too_many_attachments" | "commit_retries" | "device_removed";
 export declare class MlsDriverError extends Error {
     code: MlsDriverErrorCode;
     /** The server's refusal, when there was one. */

package/dist/mls/dmDriver.js

@@ -1,4 +1,4 @@
-import { addMlsMembers, asIdentityScope, base64UrlDecode, createMlsGroup, decodeMlsGroupState, encodeMlsGroupState, encryptMlsMessage, forgetMlsSecrets, generateMlsKeyPackage, joinMlsGroup, mlsGroupInfo, mlsGroupMembers, mlsWelcomeRefs, processMlsMessage, readMlsKeyPackage, removeMlsMembers, } from "@gryt/crypto";
+import { addMlsMembers, asIdentityScope, base64UrlDecode, createMlsGroup, decodeMlsGroupState, encodeMlsGroupState, encryptMlsMessage, forgetMlsSecrets, generateMlsKeyPackage, joinMlsGroup, mlsGroupInfo, mlsGroupMembers, mlsWelcomeRefs, processMlsMessage, readDeviceCertificate, readMlsKeyPackage, removeMlsMembers, } from "@gryt/crypto";
 /** Five devices per person per server (design, section 1). The server holds the same line. */
 const MLS_MAX_DEVICES_PER_PERSON = 5;
 const COMMIT_ATTEMPTS = 5;
@@ -55,7 +55,39 @@ function keyedQueue() {
     };
 }
 export function createMlsDmDriver(options) {
-    const { transport, store, pins, events, serverUserId: self, capability } = options;
+    const { store, pins, events, serverUserId: self, capability } = options;
+    /* Once the server says `device_removed`, nothing goes to it again from this driver:
+       no sync, and above all no publish that could register this device back. */
+    let removed = false;
+    const removedError = (r) => new MlsDriverError("device_removed", "This device was removed from encrypted messages on this server.", r);
+    function stopOnRemoval(call) {
+        return async (req) => {
+            if (removed)
+                throw removedError();
+            const r = await call(req);
+            if (!r.ok && r.error === "device_removed") {
+                if (!removed) {
+                    removed = true;
+                    events.onDeviceRemoved?.();
+                }
+                throw removedError(r);
+            }
+            return r;
+        };
+    }
+    const raw = options.transport;
+    const transport = {
+        publishKeyPackages: stopOnRemoval((req) => raw.publishKeyPackages(req)),
+        claimKeyPackages: stopOnRemoval((req) => raw.claimKeyPackages(req)),
+        listDevices: stopOnRemoval((req) => raw.listDevices(req)),
+        removeDevice: stopOnRemoval((req) => raw.removeDevice(req)),
+        createGroup: stopOnRemoval((req) => raw.createGroup(req)),
+        commit: stopOnRemoval((req) => raw.commit(req)),
+        send: stopOnRemoval((req) => raw.send(req)),
+        fetchLog: stopOnRemoval((req) => raw.fetchLog(req)),
+        sync: stopOnRemoval((req) => raw.sync(req)),
+        ackWelcomes: stopOnRemoval((req) => raw.ackWelcomes(req)),
+    };
     const scope = asIdentityScope(options.scope);
     const trusts = new Map();
     /** What the engine asks about every leaf: is it somebody in this conversation, by pin. */
@@ -579,6 +611,9 @@ export function createMlsDmDriver(options) {
     /** Adds wait for the next send; a device that's gone is removed straight away. */
     async function handleDevicesChanged(push) {
         reconciled.clear();
+        // One of yours changed, and it may be this one: a sync is how the server says so.
+        if (push.serverUserId === self && registered)
+            await transport.sync({ deviceId: (await ownDevice()).deviceId });
         for (const rec of await store.listGroups()) {
             await run(rec.conversationId, async () => {
                 const open = await load(rec.conversationId);
@@ -593,6 +628,45 @@ export function createMlsDmDriver(options) {
             });
         }
     }
+    /** Names from certificates under your own person key: this device's, then your leaves in each group. */
+    async function ownDeviceNames(d, wanted) {
+        const mine = readDeviceCertificate(d.certificate, scope);
+        const names = new Map([[mine.deviceId, mine.deviceName]]);
+        const unnamed = () => [...wanted].some((id) => !names.has(id));
+        for (const rec of await store.listGroups()) {
+            if (!unnamed())
+                break;
+            let members;
+            try {
+                members = mlsGroupMembers(decodeMlsGroupState(rec.state, trustFor(rec.conversationId)), scope);
+            }
+            catch {
+                continue;
+            }
+            for (const { certificate: c } of members) {
+                if (wanted.has(c.deviceId) && !names.has(c.deviceId) && sameBytes(c.personPublicKey, mine.personPublicKey)) {
+                    names.set(c.deviceId, c.deviceName);
+                }
+            }
+        }
+        return names;
+    }
+    async function ownDevices() {
+        const r = await transport.listDevices({});
+        if (!r.ok)
+            throw refused("Listing devices", r);
+        const d = await ownDevice();
+        const listed = r.devices.filter((x) => x.serverUserId === self);
+        const names = await ownDeviceNames(d, new Set(listed.map((x) => x.deviceId)));
+        return listed.map((x) => ({
+            serverUserId: x.serverUserId,
+            deviceId: x.deviceId,
+            name: names.get(x.deviceId) ?? null,
+            addedAt: x.createdAt ?? null,
+            lastSeenAt: x.lastSeenAt ?? null,
+            thisDevice: x.deviceId === d.deviceId,
+        }));
+    }
     return {
         async start() {
             await ownDevice();
@@ -613,12 +687,7 @@ export function createMlsDmDriver(options) {
         handleMessage,
         handleWelcome,
         handleDevicesChanged,
-        async ownDevices() {
-            const r = await transport.listDevices({});
-            if (!r.ok)
-                throw refused("Listing devices", r);
-            return r.devices;
-        },
+        ownDevices,
         async removeOwnDevice(deviceId) {
             const r = await transport.removeDevice({ deviceId });
             if (!r.ok)

package/dist/mls/interfaces.d.ts

@@ -13,6 +13,11 @@ export interface MlsDeviceRef {
     serverUserId: string;
     deviceId: string;
 }
+/** A row of `mls:devices`. Your own rows say when the server first and last saw each one. */
+export interface MlsListedDevice extends MlsDeviceRef {
+    createdAt?: string;
+    lastSeenAt?: string;
+}
 /** The server's view of a group. `groupId` is lower-case hex. */
 export interface MlsGroupView {
     conversationId: string;
@@ -71,7 +76,7 @@ export interface MlsTransport {
     listDevices(req: {
         conversationId?: string;
     }): Promise<MlsReply<{
-        devices: MlsDeviceRef[];
+        devices: MlsListedDevice[];
     }>>;
     removeDevice(req: {
         deviceId: string;
@@ -232,6 +237,11 @@ export interface MlsDmEvents {
         conversationId: string;
         groupId: string;
     }): void;
+    /**
+     * The server says this device was removed here (`device_removed`). The driver has stopped for
+     * good. Wipe this server's MLS state, and don't make a new device until the person asks.
+     */
+    onDeviceRemoved?(): void;
 }
 /** Decision 4, per DM. `refused` never falls back to version 1. */
 export type DmSealingMode = {
@@ -243,6 +253,15 @@ export type DmSealingMode = {
     kind: "refused";
     reason: "peer_left_mls" | "server_dropped_mls" | "no_own_device";
 };
+/** One of your own devices on this server, for a device list. */
+export interface MlsOwnDevice extends MlsDeviceRef {
+    /** From its device certificate, found in this device or a group you share. Null when none shows it. */
+    name: string | null;
+    /** ISO times from the server, or null from a server that doesn't send them. */
+    addedAt: string | null;
+    lastSeenAt: string | null;
+    thisDevice: boolean;
+}
 export interface MlsDmDriverOptions {
     transport: MlsTransport;
     store: MlsStateStore;
@@ -272,7 +291,8 @@ export interface MlsDmDriver {
     handleDevicesChanged(push: {
         serverUserId: string;
     }): Promise<void>;
-    ownDevices(): Promise<MlsDeviceRef[]>;
+    /** Oldest first, as the server lists them. */
+    ownDevices(): Promise<MlsOwnDevice[]>;
     /** Your own devices only. Every group you share drops it on the next pass. */
     removeOwnDevice(deviceId: string): Promise<void>;
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@gryt/core",
-  "version": "0.12.0",
+  "version": "0.13.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": {