@vex-chat/libvex 6.7.0 → 7.0.0

package/src/Storage.ts

@@ -24,6 +24,11 @@ import type { EventEmitter } from "eventemitter3";
  * - Managing prekeys / one-time keys used for session setup
  * - Emitting lifecycle events (`ready`, `error`)
  */
+export interface MessageUpdatePatch {
+    extra?: null | string | undefined;
+    message?: string | undefined;
+}
+
 export interface Storage extends EventEmitter {
     /** Closes storage resources (connections, handles, transactions, etc.). */
     close: () => Promise<void>;
@@ -131,6 +136,12 @@ export interface Storage extends EventEmitter {
         preKeys: UnsavedPreKey[],
         oneTime: boolean,
     ) => Promise<PreKeysSQL[]>;
+
     /** Persists an encryption session. */
     saveSession: (session: Session) => Promise<void>;
+    /** Updates locally persisted message plaintext and/or encrypted extra by `mailID`. */
+    updateMessage: (
+        mailID: string,
+        patch: MessageUpdatePatch,
+    ) => Promise<boolean>;
 }

package/src/__tests__/harness/memory-storage.ts

@@ -5,7 +5,7 @@
  */
 
 import type { Message } from "../../index.js";
-import type { Storage } from "../../Storage.js";
+import type { MessageUpdatePatch, Storage } from "../../Storage.js";
 import type {
     PreKeysCrypto,
     SessionCrypto,
@@ -276,6 +276,47 @@ export class MemoryStorage extends EventEmitter implements Storage {
         return Promise.resolve();
     }
 
+    async updateMessage(
+        mailID: string,
+        patch: MessageUpdatePatch,
+    ): Promise<boolean> {
+        const idx = this.messages.findIndex((m) => m.mailID === mailID);
+        if (idx < 0) {
+            return false;
+        }
+        if (
+            patch.message === undefined &&
+            !Object.prototype.hasOwnProperty.call(patch, "extra")
+        ) {
+            return false;
+        }
+        const current = this.messages[idx];
+        if (!current) {
+            return false;
+        }
+        const next = { ...current };
+        if (Object.prototype.hasOwnProperty.call(patch, "extra")) {
+            next.extra = patch.extra;
+        }
+        if (patch.message !== undefined) {
+            const fips = getCryptoProfile() === "fips";
+            const ct = fips
+                ? await xSecretboxAsync(
+                      XUtils.decodeUTF8(patch.message),
+                      XUtils.decodeHex(current.nonce),
+                      this.atRestAesKey,
+                  )
+                : xSecretbox(
+                      XUtils.decodeUTF8(patch.message),
+                      XUtils.decodeHex(current.nonce),
+                      this.atRestAesKey,
+                  );
+            next.message = XUtils.encodeHex(ct);
+        }
+        this.messages[idx] = next;
+        return true;
+    }
+
     private async decryptMessage(msg: Message): Promise<Message> {
         const copy = { ...msg };
         if (copy.decrypted) {

package/src/__tests__/messageExtra.test.ts

@@ -0,0 +1,135 @@
+/**
+ * Copyright (c) 2020-2026 Vex Heavy Industries LLC
+ * Licensed under AGPL-3.0. See LICENSE for details.
+ */
+
+import { describe, expect, it } from "vitest";
+
+import {
+    createMessageDeleteBatchEventExtra,
+    createMessageDeleteEventExtra,
+    createMessageEmbedExtra,
+    createMessageUpdateEventExtra,
+    type MessageEmbed,
+    parseMessageExtra,
+    serializeMessageExtra,
+} from "../messageExtra.js";
+
+const imageAttachment = {
+    contentType: "image/svg+xml",
+    fileID: "file-1",
+    fileName: "summary.svg",
+    fileSize: 2048,
+    key: "secret",
+};
+
+describe("message extra", () => {
+    it("serializes and parses an encrypted media embed", () => {
+        const embed: MessageEmbed = {
+            blocks: [
+                {
+                    attachment: imageAttachment,
+                    mediaType: "svg",
+                    title: "Workflow summary",
+                    type: "media",
+                },
+                {
+                    source: "message",
+                    type: "markdown",
+                },
+            ],
+            display: "decorate",
+            iconAttachment: imageAttachment,
+            kind: "git.workflow",
+            title: "CI finished",
+            version: 1,
+        };
+
+        const extra = serializeMessageExtra({ embed, version: 1 });
+        expect(parseMessageExtra(extra).embed).toEqual(embed);
+    });
+
+    it("merges embed metadata with existing reactions", () => {
+        const current = JSON.stringify({
+            reactions: [
+                {
+                    emoji: { kind: "unicode", value: "👍" },
+                    userIDs: ["alice"],
+                },
+            ],
+            version: 1,
+        });
+        const extra = createMessageEmbedExtra(
+            {
+                display: "replace",
+                kind: "voice.transcript",
+                title: "Voice memo transcript",
+                version: 1,
+            },
+            current,
+        );
+        const parsed = parseMessageExtra(extra);
+
+        expect(parsed.embed?.kind).toBe("voice.transcript");
+        expect(parsed.reactions).toEqual([
+            {
+                emoji: { kind: "unicode", value: "👍" },
+                userIDs: ["alice"],
+            },
+        ]);
+    });
+
+    it("drops malformed known fields while preserving unknown metadata", () => {
+        const parsed = parseMessageExtra(
+            JSON.stringify({
+                embed: { display: "replace", kind: 123 },
+                messageDeleteEvent: { action: "delete" },
+                messageUpdateEvent: { action: "update", targetMailID: "m1" },
+                reactionEvent: { action: "toggle", targetMailID: "m1" },
+                vendor: { ok: true },
+                version: 999,
+            }),
+        );
+
+        expect(parsed).toEqual({
+            vendor: { ok: true },
+            version: 1,
+        });
+    });
+
+    it("serializes and parses message update and delete events", () => {
+        const updateExtra = createMessageUpdateEventExtra(
+            "m-target",
+            "edited text",
+        );
+        const deleteExtra = createMessageDeleteEventExtra("m-target");
+
+        expect(parseMessageExtra(updateExtra).messageUpdateEvent).toEqual({
+            action: "update",
+            message: "edited text",
+            targetMailID: "m-target",
+        });
+        expect(parseMessageExtra(deleteExtra).messageDeleteEvent).toEqual({
+            action: "delete",
+            targetMailID: "m-target",
+        });
+    });
+
+    it("serializes and parses batched message delete events", () => {
+        const extra = createMessageDeleteBatchEventExtra([
+            "m-first",
+            "m-second",
+            "m-first",
+            "",
+        ]);
+
+        expect(parseMessageExtra(extra).messageDeleteEvent).toEqual({
+            action: "delete",
+            targetMailIDs: ["m-first", "m-second"],
+        });
+    });
+
+    it("returns null for an empty serialized extra", () => {
+        expect(serializeMessageExtra({ version: 1 })).toBeNull();
+    });
+});

package/src/index.ts

@@ -48,12 +48,45 @@ export type {
     HttpRequestRecord,
     HttpResponse,
 } from "./http.js";
+export {
+    createMessageDeleteBatchEventExtra,
+    createMessageDeleteEventExtra,
+    createMessageEmbedExtra,
+    createMessageUpdateEventExtra,
+    MESSAGE_EXTRA_VERSION,
+    parseMessageExtra,
+    serializeMessageExtra,
+} from "./messageExtra.js";
+export type {
+    EncryptedFileAttachmentReference,
+    MessageDeleteEvent,
+    MessageEmbed,
+    MessageEmbedAction,
+    MessageEmbedBlock,
+    MessageEmbedCodeBlock,
+    MessageEmbedDisplay,
+    MessageEmbedDividerBlock,
+    MessageEmbedField,
+    MessageEmbedFileBlock,
+    MessageEmbedGalleryBlock,
+    MessageEmbedMarkdownBlock,
+    MessageEmbedMediaBlock,
+    MessageEmbedMediaItem,
+    MessageEmbedMediaType,
+    MessageEmbedSource,
+    MessageEmbedTone,
+    MessageEmoji,
+    MessageExtra,
+    MessageReaction,
+    MessageReactionEvent,
+    MessageUpdateEvent,
+} from "./messageExtra.js";
 export {
     clampLocalMessageRetentionDays,
     effectiveMessageRetentionHintDays,
     MAX_LOCAL_MESSAGE_RETENTION_DAYS,
 } from "./retention.js";
-export type { Storage } from "./Storage.js";
+export type { MessageUpdatePatch, Storage } from "./Storage.js";
 export type {
     KeyPair,
     KeyStore,