@joe-broadhead/messaging 0.7.1 → 0.8.0

package/dist/lib/modules/core/conversation/log.js

@@ -12,11 +12,14 @@ import { b64u } from "../b64u.js";
 import { asMessagingError, parseWith } from "../check.js";
 import { canonicalize } from "../jcs.js";
 import { Hash as HashSchema, LIMITS } from "../schema/common.js";
-import { ConvHead as ConvHeadSchema, ConvId as ConvIdSchema, MsgBody as MsgBodySchema, } from "../schema/conversation.js";
+import { ConvExpiredEntry as ExpiredSchema, ConvHead as ConvHeadSchema, ConvId as ConvIdSchema, MsgBody as MsgBodySchema, } from "../schema/conversation.js";
 import { MessagingError } from "../schema/errors.js";
 import { RealmId as RealmIdSchema } from "../schema/realm.js";
 import { admitConvEvent, convEntryHash, convEventSigned, convGenesisHash, convLinkHash, deepFreeze } from "./event.js";
 import { dmConvId, participantAgent, participantOf, participantPerson, selfConvId } from "./ids.js";
+import { verifyGuestInvitation } from "./guest-invitation.js";
+import { checkRequestEvent, requestLogState } from "./request-log.js";
+import { RequestImport } from "../schema/contact-request.js";
 const STRICTNESS = { none: 0, seats: 1, members: 2 };
 const BRIDGE_STRICTNESS = { none: 0, admins: 1, members: 2 };
 const isAdminRole = (role) => role === "owner" || role === "admin";
@@ -77,6 +80,13 @@ export class ConvLog {
     /** h(0), h(1), ...; an expired entry keeps its hash. */
     #hashes;
     #entries = [];
+    /** Opened bodies, when available, for a replay after a device cut. */
+    #bodies = new Map();
+    /** Authenticated chain links awaiting a current-device check in the member's verified realm. */
+    #held = new Set();
+    #ids = new Set();
+    /** A device's first authenticated revocation point in this conversation. */
+    #revoked = new Map();
     /** seq of each op entry, ascending. */
     #ops = [];
     /** seqs of entries whose content expired: an op head must never name one. */
@@ -98,13 +108,117 @@ export class ConvLog {
             throw asMessagingError(error, "conversation log");
         }
     }
-    /** Replays `entries` (each with the opened body of a `msg`, when the caller has it). Throws the first failure. */
-    static fromEntries(cid, realm, entries) {
+    /** Replays a prefix; callers with a verified realm supply its removed-device check for every device rekey. */
+    static fromEntries(cid, realm, entries, checks = {}, onInvalidBody) {
+        return ConvLog.#replay(cid, realm, entries, undefined, checks, onInvalidBody);
+    }
+    /** Replays a complete prefix, retaining chain links for cut and expired entries. */
+    static #replay(cid, realm, entries, lastLive, checks = {}, onInvalidBody) {
+        const cuts = [];
+        // Later cuts can invalidate an earlier rekey too. Walk backwards so a cut rekey never cuts another device.
+        for (const { entry, held } of [...entries].reverse()) {
+            if (held)
+                continue; // An unresolved author cannot cut another device's state.
+            if (!entry || typeof entry !== "object" || !("event" in entry))
+                continue;
+            const outer = parseWith(EntryShape, entry, "conversation entry");
+            const event = admitConvEvent(outer.event);
+            if (event.class !== "op" || event.body.op !== "rekey" || event.body.cause !== "device" || event.body.until === undefined)
+                continue;
+            if (cuts.some((c) => event.by.device === c.device && outer.seq > c.until && outer.seq < c.rekey))
+                continue;
+            if (event.realm !== realm || event.cid !== cid || !convEventSigned(event))
+                fail("bad_signature", "invalid device rekey");
+            if (event.body.until >= outer.seq)
+                fail("invalid_request", "a device cut precedes its rekey");
+            cuts.push({ device: event.body.device, until: event.body.until, rekey: outer.seq });
+        }
         const log = ConvLog.open(cid, realm);
-        for (const { entry, body } of entries)
-            log.apply(entry, body === undefined ? {} : { body });
+        for (let i = 0; i < entries.length; i++) {
+            const { entry, body, held } = entries[i];
+            if (entry && typeof entry === "object" && "digest" in entry && !("event" in entry)) {
+                log.applyExpired(entry);
+                continue;
+            }
+            const outer = parseWith(EntryShape, entry, "conversation entry");
+            const event = admitConvEvent(outer.event);
+            const cut = cuts.some((c) => event.by.device === c.device && outer.seq > c.until && outer.seq < c.rekey);
+            if (cut || held) {
+                log.#applyCut(outer);
+                if (held && !cut)
+                    log.#held.add(outer.seq);
+            }
+            else {
+                const live = i === entries.length - 1 && lastLive ? lastLive : checks;
+                try {
+                    log.#apply(entry, { ...(body === undefined ? {} : { body }), live });
+                }
+                catch (error) {
+                    if (!(error instanceof MessagingError) || !onInvalidBody || body === undefined || event.class !== "msg")
+                        throw error;
+                    // Retrying without the body distinguishes plaintext authority failures from structural failures.
+                    log.#apply(entry, { live });
+                    onInvalidBody(outer.seq);
+                }
+            }
+        }
         return log;
     }
+    /** Keeps a cut event's authenticated hash and op position, never its state or opened body. */
+    #applyCut(raw) {
+        const event = admitConvEvent(raw.event);
+        if (event.class === "keys" || event.realm !== this.realm || event.cid !== this.cid)
+            fail("invalid_request", "invalid cut entry");
+        const head = this.head();
+        if (raw.seq !== head.seq + 1 || raw.prev !== head.hash)
+            fail("conv_conflict", "cut entry does not extend the log");
+        if (!convEventSigned(event))
+            fail("bad_signature", "cut entry signature is invalid");
+        if (this.#ids.has(event.id))
+            fail("duplicate", "event id already used in this conversation");
+        if (this.#revoked.has(event.by.device))
+            fail("unknown_device", "the author's device was rekeyed out");
+        if (event.seen && event.seen.seq >= raw.seq)
+            fail("invalid_request", "seen names a position at or past the event");
+        if (event.class === "op")
+            this.#ops.push(raw.seq);
+        this.#ids.add(event.id);
+        this.#hashes.push(convEntryHash(raw.prev, event));
+        this.#entries.push(deepFreeze({ ...raw, event }));
+    }
+    #replace(other) {
+        this.#hashes.length = 0;
+        for (const v of other.#hashes)
+            this.#hashes.push(v);
+        this.#entries.length = 0;
+        for (const v of other.#entries)
+            this.#entries.push(v);
+        this.#ops.length = 0;
+        for (const v of other.#ops)
+            this.#ops.push(v);
+        this.#snapshots.length = 0;
+        for (const v of other.#snapshots)
+            this.#snapshots.push(v);
+        this.#expired.clear();
+        for (const v of other.#expired)
+            this.#expired.add(v);
+        this.#ids.clear();
+        for (const v of other.#ids)
+            this.#ids.add(v);
+        this.#revoked.clear();
+        for (const [k, v] of other.#revoked)
+            this.#revoked.set(k, v);
+        this.#messages.clear();
+        for (const [k, v] of other.#messages)
+            this.#messages.set(k, v);
+        this.#bodies.clear();
+        for (const [k, v] of other.#bodies)
+            this.#bodies.set(k, v);
+        this.#held.clear();
+        for (const seq of other.#held)
+            this.#held.add(seq);
+        this.#pinned = other.#pinned;
+    }
     head() {
         const seq = this.#hashes.length - 1;
         return { seq, hash: this.#hashes[seq] };
@@ -121,6 +235,8 @@ export class ConvLog {
     entries() {
         return [...this.#entries];
     }
+    /** Held links are in the hash chain, but contribute neither state nor messages. */
+    held() { return [...this.#held]; }
     /** The state at the head; undefined before `create`. */
     state() {
         return this.#snapshots[this.#snapshots.length - 1]?.snapshot;
@@ -164,6 +280,18 @@ export class ConvLog {
      */
     apply(raw, options = {}) {
         try {
+            const shape = EntryShape.safeParse(raw);
+            if (shape.success) {
+                const event = admitConvEvent(shape.data.event);
+                if (event.class === "op" && event.body.op === "rekey" && event.body.cause === "device" && event.body.until !== undefined) {
+                    const entries = this.#entries.map((entry) => ({ entry, held: this.#held.has(entry.seq), ...(this.#bodies.has(entry.seq) ? { body: this.#bodies.get(entry.seq) } : {}) }));
+                    entries.push({ entry: raw, ...(options.body === undefined ? {} : { body: options.body }) });
+                    const checks = { isRemovedDevice: options.live?.isRemovedDevice, requestBinding: options.live?.requestBinding };
+                    const rebuilt = ConvLog.#replay(this.cid, this.realm, entries, options.live, checks);
+                    this.#replace(rebuilt);
+                    return this.head().hash;
+                }
+            }
             return this.#apply(raw, options);
         }
         catch (error) {
@@ -171,8 +299,9 @@ export class ConvLog {
         }
     }
     /**
-     * Appends an entry whose content the relay expired (spec §16.4, "Retention"), by its digest: the chain stays
-     * verifiable and the state does not change. An op is never expired: a later op head that names this seq fails.
+     * Appends a `msg` entry whose content the relay expired (spec §16.4, "Retention"), by its digest: the chain stays
+     * verifiable and the state does not change. The create (seq 1) never expires (`invalid_request`), nor does any op:
+     * a later op head that names this seq fails.
      */
     applyExpired(raw) {
         try {
@@ -180,8 +309,6 @@ export class ConvLog {
             const head = this.head();
             if (entry.seq !== head.seq + 1 || entry.prev !== head.hash)
                 fail("conv_conflict", `entry does not extend head ${head.seq}`);
-            if (head.seq === 0)
-                fail("invalid_request", "the create entry never expires");
             const hash = convLinkHash(entry.prev, b64u.decode(entry.digest));
             this.#hashes.push(hash);
             this.#entries.push(entry);
@@ -192,11 +319,62 @@ export class ConvLog {
             throw asMessagingError(error, "expired entry");
         }
     }
+    /**
+     * Checks a key share against this log (spec §16.6); a share is not an entry, so nothing changes. In order: I-JSON,
+     * size and schema, realm and cid (`invalid_request`, `too_large`); the signature (`bad_signature`); the live checks
+     * given (`expired`, `unknown_device`); `by.agent` absent (`forbidden`); `opHead` names an op of this log
+     * (`conv_conflict`); then, in the state at `opHead`, the author's person is a member participant person
+     * (`not_member`) and the recipient's person a participant person (`forbidden`), and live, the recipient device is a
+     * current device of that person (`unknown_device`). Returns the frozen event.
+     */
+    checkShare(raw, live = {}) {
+        try {
+            const event = admitConvEvent(raw);
+            if (event.class !== "keys")
+                fail("invalid_request", "not a key share");
+            const share = event;
+            if (share.realm !== this.realm)
+                fail("invalid_request", "share is for another realm");
+            if (share.cid !== this.cid)
+                fail("invalid_request", "share is for another conversation");
+            if (!convEventSigned(share))
+                fail("bad_signature", "key share signature is invalid");
+            if (live.now !== undefined && Math.abs(share.ts - live.now) > (live.skewMs ?? LIMITS.clockSkewMs))
+                fail("expired", "share ts is outside the clock skew window");
+            if (live.isDevice && !live.isDevice(share.by.person, share.by.device))
+                fail("unknown_device", "the author device is not a current device of its person");
+            if (share.by.agent !== undefined)
+                fail("forbidden", "key shares are a device's: an agent never writes one");
+            this.#checkOpHead(share);
+            const revokedAt = this.#revoked.get(share.by.device);
+            if (revokedAt !== undefined && share.opHead.seq >= revokedAt)
+                fail("unknown_device", "the share author's device was rekeyed out");
+            const s = this.at(share.opHead.seq);
+            if (s === undefined)
+                fail("conv_conflict", "a share names an op of the conversation");
+            if (!s.participants.some((p) => p.person === share.by.person && p.state === "member"))
+                fail("not_member", "the author's person is not a participant");
+            const to = share.body.to;
+            if (!s.participants.some((p) => p.person === to.person && p.state === "member"))
+                fail("forbidden", "a share goes only to an accepted participant person");
+            if ((s.kind === "group" || s.history === "none") && s.rekeyDue.includes("added"))
+                fail("stale_epoch", "acceptance requires a rekey before sharing keys");
+            if (live.isDevice && !live.isDevice(to.person, to.device))
+                fail("unknown_device", "a share goes only to a current device");
+            return share;
+        }
+        catch (error) {
+            throw asMessagingError(error, "key share");
+        }
+    }
     #apply(raw, options) {
         const live = options.live ?? {};
         canonicalize(raw);
         const outer = parseWith(EntryShape, raw, "conversation entry");
-        const event = admitConvEvent(outer.event);
+        const admitted = admitConvEvent(outer.event);
+        if (admitted.class === "keys")
+            fail("invalid_request", "a key share is not an entry of the log");
+        const event = admitted;
         const entry = deepFreeze({ seq: outer.seq, prev: outer.prev, event });
         if (event.realm !== this.realm)
             fail("invalid_request", "event is for another realm");
@@ -211,15 +389,34 @@ export class ConvLog {
             fail("expired", "event ts is outside the clock skew window");
         if (live.isDevice && !live.isDevice(event.by.person, event.by.device))
             fail("unknown_device", "the author device is not a current device of its person");
-        if (this.#messages.has(event.id))
+        if (this.#ids.has(event.id))
             fail("duplicate", "event id already used in this conversation");
+        if (this.#revoked.has(event.by.device))
+            fail("unknown_device", "the author's device was rekeyed out");
         if (event.seen && event.seen.seq >= entry.seq)
             fail("invalid_request", "seen names a position at or past the event");
-        const commit = this.#authorize(entry, options);
+        if (live.requestBinding)
+            checkRequestEvent(this, outer.event, live.requestBinding, options.body);
+        // Keep our own parsed body: callers may mutate their input after apply, but a later cut must replay the
+        // originally accepted plaintext. Parse before committing so a failure cannot leave a partial append.
+        const imported = live.requestBinding && event.class === "msg" && event.request !== undefined;
+        const body = options.body === undefined || event.class !== "msg" ? undefined
+            : imported ? parseWith(RequestImport, options.body, "request import") : parseWith(MsgBodySchema, options.body, "message body");
+        const importedDelete = live.requestBinding && body?.t === "delete" && requestLogState(this, live.requestBinding).reservations.has(body.target) ? body.target : undefined;
+        // Portable imports retain their wrapper author. Their proof, rather than MsgBody, supplies source authority.
+        const commit = this.#authorize(entry, { ...options, body: imported || importedDelete ? undefined : body });
         const hash = convEntryHash(entry.prev, event);
         commit();
+        if (importedDelete) {
+            const target = this.#messages.get(importedDelete);
+            if (target)
+                target.deleted = true;
+        }
         this.#hashes.push(hash);
         this.#entries.push(entry);
+        this.#ids.add(event.id);
+        if (body !== undefined)
+            this.#bodies.set(entry.seq, body);
         return hash;
     }
     #authorize(entry, options) {
@@ -248,8 +445,6 @@ export class ConvLog {
             };
         }
         this.#checkOpHead(event);
-        if (event.class === "keys")
-            return this.#keys(current, event, seq, author, options.live ?? {});
         return this.#msg(current, event, seq, author, options);
     }
     #checkOpHead(event) {
@@ -372,9 +567,12 @@ export class ConvLog {
             if (participantAgent(s.p) !== undefined && person !== by && (s.device !== undefined || s.respondTo !== undefined)) {
                 fail("forbidden", "only an agent's own person seats it");
             }
-            if (live.orgOf && participantAgent(s.p) === undefined && s.role !== "guest" && person !== by && live.orgOf(person) !== org) {
+            if (live.orgOf && s.role !== "guest" && person !== by && (org === undefined || live.orgOf(person) !== org)) {
                 fail("forbidden", "a person of another org is added as a guest");
             }
+            const owner = seats.find((p) => p.p === person) ?? this.state()?.participants.find((p) => p.p === person);
+            if (participantAgent(s.p) !== undefined && owner?.role === "guest" && s.role !== "guest")
+                fail("forbidden", "a guest's agent inherits the guest role");
         }
     }
     #op(d, event, seq, live) {
@@ -396,6 +594,13 @@ export class ConvLog {
             return rec;
         };
         const owners = () => [...d.participants.values()].filter((p) => p.role === "owner" && p.agent === undefined);
+        // A sealed op is sealed as a message is: never under a key a removed device holds (spec §16.7).
+        const sealedUnder = (epoch) => {
+            if (epoch !== d.epoch)
+                fail("stale_epoch", `the current epoch is ${d.epoch}`);
+            if (d.rekeyDue.size > 0)
+                fail("stale_epoch", "a rekey is due before the next sealed op");
+        };
         const removeWithAgents = (p) => {
             const target = d.participants.get(p);
             d.participants.delete(p);
@@ -434,7 +639,7 @@ export class ConvLog {
                     const state = agentOf !== undefined ? (agentOf === by ? "member" : "invited") : s.role === "guest" ? "invited" : "member";
                     d.participants.set(s.p, participantFrom(s, state, seq));
                 }
-                if (d.kind === "group")
+                if ((d.kind === "group" || d.history === "none") && op.participants.some((s) => d.participants.get(s.p).state === "member"))
                     d.rekeyDue.add("added");
                 return undefined;
             }
@@ -443,7 +648,15 @@ export class ConvLog {
                     fail("not_member", "the author is not a participant");
                 if (me.state !== "invited")
                     fail("invalid_state", "the author is not invited");
+                if (me.role === "guest") {
+                    if (op.invitation === undefined)
+                        fail("forbidden", "a guest accepts a signed exposure preview");
+                    verifyGuestInvitation(this, op.invitation, by, event.ts);
+                }
                 me.state = "member";
+                me.since = seq;
+                if (d.kind === "group" || d.history === "none")
+                    d.rekeyDue.add("added");
                 return undefined;
             }
             case "join": {
@@ -456,6 +669,8 @@ export class ConvLog {
                 if (d.participants.size + 1 > LIMITS.convParticipants)
                     fail("too_large", "the channel is full");
                 d.participants.set(by, participantFrom({ p: by, role: "member" }, "member", seq));
+                if (d.history === "none")
+                    d.rekeyDue.add("added");
                 return undefined;
             }
             case "leave": {
@@ -500,6 +715,10 @@ export class ConvLog {
                 const target = d.participants.get(op.p);
                 if (!target)
                     fail("not_found", "not a participant");
+                if (target.role === "guest" && op.role !== "guest")
+                    fail("forbidden", "a guest cannot be promoted");
+                if (target.agent !== undefined && d.participants.get(target.person)?.role === "guest" && op.role !== "guest")
+                    fail("forbidden", "a guest's agent inherits the guest role");
                 if (rec.role === "admin" && (target.role === "owner" || (op.role !== "member" && op.role !== "guest"))) {
                     fail("forbidden", "an admin sets only member or guest, and never an owner's role");
                 }
@@ -516,6 +735,13 @@ export class ConvLog {
                     fail("invalid_request", "only an agent is seated");
                 if (target.person !== by)
                     fail("forbidden", "only the agent's own person seats it");
+                if (target.role === "guest" && (me?.state !== "member" || me.role !== "guest"))
+                    fail("forbidden", "a guest agent's owner must be an accepted, visible guest");
+                if (target.state === "invited") {
+                    target.since = seq;
+                    if (d.kind === "group" || d.history === "none")
+                        d.rekeyDue.add("added");
+                }
                 target.state = "member";
                 if (op.device !== undefined)
                     target.device = op.device;
@@ -560,6 +786,12 @@ export class ConvLog {
                     fail("not_member", "the author's person is not a participant");
                 if (op.epoch !== d.epoch + 1)
                     fail("invalid_request", "a rekey starts the next epoch");
+                if (op.cause === "device") {
+                    if (op.until !== undefined && op.until >= seq)
+                        fail("invalid_request", "a device cut precedes its rekey");
+                    if (live.isRemovedDevice && !live.isRemovedDevice(op.device))
+                        fail("forbidden", "the device is not removed in the verified realm");
+                }
                 if (op.cause === "schedule") {
                     if (event.ts - d.epochTs < LIMITS.rekeyScheduleMs)
                         fail("invalid_state", "the epoch is not yet due for a scheduled rekey");
@@ -571,25 +803,50 @@ export class ConvLog {
                 d.epochSince = seq;
                 d.epochTs = event.ts;
                 d.rekeyDue.clear();
+                return op.cause === "device" ? () => { if (!this.#revoked.has(op.device))
+                    this.#revoked.set(op.device, seq); } : undefined;
+            }
+            case "policy": {
+                if (d.kind === "self")
+                    fail("forbidden", "a self conversation has no policy");
+                const rec = requireMember();
+                if (d.kind === "channel") {
+                    if (!isAdminRole(rec.role))
+                        fail("forbidden", "only an owner or admin sets a channel's policy");
+                    if (op.agentContext !== undefined)
+                        d.agentContext = op.agentContext;
+                    if (op.bridges !== undefined)
+                        d.bridges = op.bridges;
+                }
+                else {
+                    const vote = { ...d.votes.get(by) };
+                    if (op.agentContext !== undefined)
+                        vote.agentContext = op.agentContext;
+                    if (op.bridges !== undefined)
+                        vote.bridges = op.bridges;
+                    d.votes.set(by, vote);
+                }
+                return undefined;
+            }
+            case "meta": {
+                if (d.kind === "dm" || d.kind === "self")
+                    fail("forbidden", `a ${d.kind} has no meta`);
+                const rec = requireMember();
+                if (d.kind === "channel" && !isAdminRole(rec.role))
+                    fail("forbidden", "only an owner or admin sets a channel's meta");
+                sealedUnder(op.epoch);
+                return undefined;
+            }
+            case "setting": {
+                if (d.kind !== "self")
+                    fail("forbidden", "a setting goes in the self conversation only");
+                requireMember();
+                sealedUnder(op.epoch);
                 return undefined;
             }
         }
     }
     // ---- keys and messages ----
-    #keys(s, event, seq, author, live) {
-        if (event.by.agent !== undefined)
-            fail("forbidden", "key shares are a device's: an agent never writes one");
-        const persons = new Set(s.participants.map((p) => p.person));
-        if (!s.participants.some((p) => p.person === event.by.person && p.state === "member"))
-            fail("not_member", "the author's person is not a participant");
-        for (const share of event.body.shares) {
-            if (!persons.has(share.to.person))
-                fail("forbidden", "a share goes only to a device of a participant person");
-            if (live.isDevice && !live.isDevice(share.to.person, share.to.device))
-                fail("unknown_device", "a share goes only to a current device");
-        }
-        return () => this.#record(event, seq, author);
-    }
     #msg(s, event, seq, author, options) {
         const rec = s.participants.find((p) => p.p === author);
         if (!rec)
@@ -723,44 +980,9 @@ export class ConvLog {
                 this.#target(body.target);
                 return () => record();
             }
-            case "meta": {
-                if (s.kind === "dm")
-                    fail("forbidden", "a dm has no meta");
-                if (s.kind === "channel" && !isAdminRole(rec.role))
-                    fail("forbidden", "only an owner or admin sets a channel's meta");
-                return () => record();
-            }
-            case "policy": {
-                if (event.by.agent !== undefined)
-                    fail("forbidden", "a policy is a person's: an agent never sets one");
-                if (s.kind === "channel" && !isAdminRole(rec.role))
-                    fail("forbidden", "only an owner or admin sets a channel's policy");
-                const d = draftOf(s);
-                if (s.kind === "channel") {
-                    if (body.agentContext !== undefined)
-                        d.agentContext = body.agentContext;
-                    if (body.bridges !== undefined)
-                        d.bridges = body.bridges;
-                }
-                else {
-                    const vote = { ...d.votes.get(event.by.person) };
-                    if (body.agentContext !== undefined)
-                        vote.agentContext = body.agentContext;
-                    if (body.bridges !== undefined)
-                        vote.bridges = body.bridges;
-                    d.votes.set(event.by.person, vote);
-                }
-                d.changed = seq;
-                const next = freezeDraft(d);
-                return () => {
-                    record();
-                    this.#push(seq, next);
-                };
-            }
             case "sync":
                 return () => record();
         }
     }
 }
 const EntryShape = z.strictObject({ seq: z.number().int().min(1), prev: HashSchema, event: z.unknown() });
-const ExpiredSchema = z.strictObject({ seq: z.number().int().min(1), prev: HashSchema, digest: HashSchema });