@vex-chat/libvex 6.8.0 → 7.0.1

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

@@ -6,7 +6,10 @@
 import { describe, expect, it } from "vitest";
 
 import {
+    createMessageDeleteBatchEventExtra,
+    createMessageDeleteEventExtra,
     createMessageEmbedExtra,
+    createMessageUpdateEventExtra,
     type MessageEmbed,
     parseMessageExtra,
     serializeMessageExtra,
@@ -36,6 +39,7 @@ describe("message extra", () => {
                 },
             ],
             display: "decorate",
+            iconAttachment: imageAttachment,
             kind: "git.workflow",
             title: "CI finished",
             version: 1,
@@ -79,6 +83,8 @@ describe("message extra", () => {
         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,
@@ -91,6 +97,38 @@ describe("message extra", () => {
         });
     });
 
+    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

@@ -49,13 +49,17 @@ export type {
     HttpResponse,
 } from "./http.js";
 export {
+    createMessageDeleteBatchEventExtra,
+    createMessageDeleteEventExtra,
     createMessageEmbedExtra,
+    createMessageUpdateEventExtra,
     MESSAGE_EXTRA_VERSION,
     parseMessageExtra,
     serializeMessageExtra,
 } from "./messageExtra.js";
 export type {
     EncryptedFileAttachmentReference,
+    MessageDeleteEvent,
     MessageEmbed,
     MessageEmbedAction,
     MessageEmbedBlock,
@@ -75,13 +79,14 @@ export type {
     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,

package/src/messageExtra.ts

@@ -14,12 +14,20 @@ export interface EncryptedFileAttachmentReference {
     key: string;
 }
 
+export interface MessageDeleteEvent {
+    action: "delete";
+    deletedAt?: string | undefined;
+    targetMailID?: string | undefined;
+    targetMailIDs?: string[] | undefined;
+}
+
 export interface MessageEmbed {
     actions?: MessageEmbedAction[] | undefined;
     blocks?: MessageEmbedBlock[] | undefined;
     display: MessageEmbedDisplay;
     fields?: MessageEmbedField[] | undefined;
     icon?: string | undefined;
+    iconAttachment?: EncryptedFileAttachmentReference | undefined;
     kind: string;
     source?: MessageEmbedSource | undefined;
     subtitle?: string | undefined;
@@ -132,6 +140,8 @@ export type MessageEmoji =
 export interface MessageExtra {
     [key: string]: unknown;
     embed?: MessageEmbed | undefined;
+    messageDeleteEvent?: MessageDeleteEvent | undefined;
+    messageUpdateEvent?: MessageUpdateEvent | undefined;
     reactionEvent?: MessageReactionEvent | undefined;
     reactions?: MessageReaction[] | undefined;
     version: typeof MESSAGE_EXTRA_VERSION;
@@ -148,6 +158,41 @@ export interface MessageReactionEvent {
     targetMailID: string;
 }
 
+export interface MessageUpdateEvent {
+    action: "update";
+    editedAt?: string | undefined;
+    message: string;
+    targetMailID: string;
+}
+
+export function createMessageDeleteBatchEventExtra(
+    targetMailIDs: string[],
+    currentExtra?: null | string,
+): null | string {
+    return serializeMessageExtra({
+        ...parseMessageExtra(currentExtra),
+        messageDeleteEvent: {
+            action: "delete",
+            targetMailIDs,
+        },
+        version: MESSAGE_EXTRA_VERSION,
+    });
+}
+
+export function createMessageDeleteEventExtra(
+    targetMailID: string,
+    currentExtra?: null | string,
+): null | string {
+    return serializeMessageExtra({
+        ...parseMessageExtra(currentExtra),
+        messageDeleteEvent: {
+            action: "delete",
+            targetMailID,
+        },
+        version: MESSAGE_EXTRA_VERSION,
+    });
+}
+
 export function createMessageEmbedExtra(
     embed: MessageEmbed,
     currentExtra?: null | string,
@@ -159,6 +204,22 @@ export function createMessageEmbedExtra(
     });
 }
 
+export function createMessageUpdateEventExtra(
+    targetMailID: string,
+    message: string,
+    currentExtra?: null | string,
+): null | string {
+    return serializeMessageExtra({
+        ...parseMessageExtra(currentExtra),
+        messageUpdateEvent: {
+            action: "update",
+            message,
+            targetMailID,
+        },
+        version: MESSAGE_EXTRA_VERSION,
+    });
+}
+
 export function parseMessageExtra(
     extra: null | string | undefined,
 ): MessageExtra {
@@ -173,17 +234,27 @@ export function parseMessageExtra(
         }
         const rest: Record<string, unknown> = { ...raw };
         delete rest["embed"];
+        delete rest["messageDeleteEvent"];
+        delete rest["messageUpdateEvent"];
         delete rest["reactionEvent"];
         delete rest["reactions"];
         delete rest["version"];
 
         const embed = parseMessageEmbed(raw["embed"]);
+        const messageDeleteEvent = parseMessageDeleteEvent(
+            raw["messageDeleteEvent"],
+        );
+        const messageUpdateEvent = parseMessageUpdateEvent(
+            raw["messageUpdateEvent"],
+        );
         const reactionEvent = parseMessageReactionEvent(raw["reactionEvent"]);
         const reactions = parseMessageReactions(raw["reactions"]);
 
         return {
             ...rest,
             ...(embed ? { embed } : {}),
+            ...(messageDeleteEvent ? { messageDeleteEvent } : {}),
+            ...(messageUpdateEvent ? { messageUpdateEvent } : {}),
             ...(reactionEvent ? { reactionEvent } : {}),
             ...(reactions.length > 0 ? { reactions } : {}),
             version: MESSAGE_EXTRA_VERSION,
@@ -262,6 +333,12 @@ function isRecord(value: unknown): value is Record<string, unknown> {
 
 function normalizeMessageExtra(extra: MessageExtra): MessageExtra {
     const embed = parseMessageEmbed(extra.embed);
+    const messageDeleteEvent = parseMessageDeleteEvent(
+        extra.messageDeleteEvent,
+    );
+    const messageUpdateEvent = parseMessageUpdateEvent(
+        extra.messageUpdateEvent,
+    );
     const reactionEvent = parseMessageReactionEvent(extra.reactionEvent);
     const reactions = parseMessageReactions(extra.reactions);
     const normalized: MessageExtra = {
@@ -274,6 +351,16 @@ function normalizeMessageExtra(extra: MessageExtra): MessageExtra {
     } else {
         delete normalized.embed;
     }
+    if (messageDeleteEvent) {
+        normalized.messageDeleteEvent = messageDeleteEvent;
+    } else {
+        delete normalized.messageDeleteEvent;
+    }
+    if (messageUpdateEvent) {
+        normalized.messageUpdateEvent = messageUpdateEvent;
+    } else {
+        delete normalized.messageUpdateEvent;
+    }
     if (reactionEvent) {
         normalized.reactionEvent = reactionEvent;
     } else {
@@ -311,6 +398,44 @@ function parseAttachment(
     };
 }
 
+function parseMessageDeleteEvent(value: unknown): MessageDeleteEvent | null {
+    if (!isRecord(value) || value["action"] !== "delete") {
+        return null;
+    }
+    const targetMailID =
+        typeof value["targetMailID"] === "string" &&
+        value["targetMailID"].length > 0
+            ? value["targetMailID"]
+            : undefined;
+    const targetMailIDs = parseMessageDeleteTargets(value["targetMailIDs"]);
+    if (!targetMailID && targetMailIDs.length === 0) {
+        return null;
+    }
+    const event: MessageDeleteEvent = {
+        action: "delete",
+        ...(targetMailID ? { targetMailID } : {}),
+        ...(targetMailIDs.length > 0 ? { targetMailIDs } : {}),
+    };
+    copyOptionalString(event, value, "deletedAt");
+    return event;
+}
+
+function parseMessageDeleteTargets(value: unknown): string[] {
+    if (!Array.isArray(value)) {
+        return [];
+    }
+    const targets: string[] = [];
+    const seen = new Set<string>();
+    for (const item of value) {
+        if (typeof item !== "string" || item.length === 0 || seen.has(item)) {
+            continue;
+        }
+        seen.add(item);
+        targets.push(item);
+    }
+    return targets;
+}
+
 function parseMessageEmbed(value: unknown): MessageEmbed | null {
     if (!isRecord(value)) return null;
     const display = value["display"];
@@ -331,6 +456,8 @@ function parseMessageEmbed(value: unknown): MessageEmbed | null {
         version: MESSAGE_EXTRA_VERSION,
     };
     copyOptionalString(embed, value, "icon");
+    const iconAttachment = parseAttachment(value["iconAttachment"]);
+    if (iconAttachment) embed.iconAttachment = iconAttachment;
     copyOptionalString(embed, value, "subtitle");
     copyOptionalBoolean(embed, value, "suppressLinkPreview");
     copyOptionalString(embed, value, "timestamp");
@@ -583,3 +710,21 @@ function parseMessageReactions(value: unknown): MessageReaction[] {
         return reaction ? [reaction] : [];
     });
 }
+
+function parseMessageUpdateEvent(value: unknown): MessageUpdateEvent | null {
+    if (
+        !isRecord(value) ||
+        value["action"] !== "update" ||
+        typeof value["message"] !== "string" ||
+        typeof value["targetMailID"] !== "string"
+    ) {
+        return null;
+    }
+    const event: MessageUpdateEvent = {
+        action: "update",
+        message: value["message"],
+        targetMailID: value["targetMailID"],
+    };
+    copyOptionalString(event, value, "editedAt");
+    return event;
+}

package/src/storage/sqlite.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,
@@ -597,8 +597,6 @@ export class SqliteStorage extends EventEmitter implements Storage {
         }
     }
 
-    // ── Devices ──────────────────────────────────────────────────────────────
-
     async savePreKeys(
         preKeys: UnsavedPreKey[],
         oneTime: boolean,
@@ -637,6 +635,8 @@ export class SqliteStorage extends EventEmitter implements Storage {
         return saved;
     }
 
+    // ── Devices ──────────────────────────────────────────────────────────────
+
     async saveSession(session: SessionSQL): Promise<void> {
         if (this.closing) {
             return;
@@ -703,6 +703,68 @@ export class SqliteStorage extends EventEmitter implements Storage {
         }
     }
 
+    async updateMessage(
+        mailID: string,
+        patch: MessageUpdatePatch,
+    ): Promise<boolean> {
+        if (this.isClosingNow()) {
+            return false;
+        }
+        await this.untilReady();
+        if (
+            patch.message === undefined &&
+            !Object.prototype.hasOwnProperty.call(patch, "extra")
+        ) {
+            return false;
+        }
+
+        const row = await this.db
+            .selectFrom("messages")
+            .selectAll()
+            .where("mailID", "=", mailID)
+            .executeTakeFirst();
+        if (!row) {
+            return false;
+        }
+
+        const current = (await this.decryptMessagesAsync([row]))[0];
+        if (!current) {
+            return false;
+        }
+        const next: Message = {
+            ...current,
+            ...(patch.message !== undefined ? { message: patch.message } : {}),
+            ...(Object.prototype.hasOwnProperty.call(patch, "extra")
+                ? { extra: patch.extra }
+                : {}),
+        };
+        const storedPlaintext = encodeStoredMessagePlaintext(next);
+        const fips = getCryptoProfile() === "fips";
+        const ct = fips
+            ? await xSecretboxAsync(
+                  XUtils.decodeUTF8(storedPlaintext),
+                  XUtils.decodeHex(row.nonce),
+                  this.atRestAesKey,
+              )
+            : xSecretbox(
+                  XUtils.decodeUTF8(storedPlaintext),
+                  XUtils.decodeHex(row.nonce),
+                  this.atRestAesKey,
+              );
+        if (this.isClosingNow()) {
+            return false;
+        }
+        const result = await this.db
+            .updateTable("messages")
+            .set({
+                extra: null,
+                message: XUtils.encodeHex(ct),
+            })
+            .where("mailID", "=", mailID)
+            .executeTakeFirst();
+        return Number(result.numUpdatedRows) > 0;
+    }
+
     // ── Purge ────────────────────────────────────────────────────────────────
 
     private async decryptMessagesAsync(