macltok

public

Star0

Fork 0

Watch0

43 commits 3 branches 0 tags 0 releases3.0 MiB

Commit `0827ad2d24e9`

tarball

atagen <boss@atagen.co>2026-10-23 07:30 UTC

5 files changed+88-27

uploads: carry replies, rich captions and mentions on attachments

malice had to send a reply's text and its files as separate events, so an image-only reply lost its relation and captions dropped their formatting and m.mentions. A reply in a thread is resolved before queueing because the send queue builds the relation itself and the timeline's wrong-thread check never sees it.

Modified file: src/engine/media.rs+57 additions−9 deletions@@ -23,18 +23,20 @@ use matrix_sdk::{
         },
         events::room::{
             EncryptedFileHash, EncryptedFileHashAlgorithm, EncryptedFileInfo, MediaSource,
-            message::{AddMentions, ReplyWithinThread},
+            message::{
+                AddMentions, Relation, ReplyWithinThread, RoomMessageEventContentWithoutRelation,
+            },
         },
     },
 };
 use matrix_sdk_crypto::{AttachmentDecryptor, MediaEncryptionInfo};
-use ruma::MxcUri;
+use ruma::{MxcUri, OwnedEventId};
 use tokio::sync::Mutex;
 
 use super::{executor::EngineBoxFuture, url_preview::UrlPreviews};
 use crate::{
     AttachmentEncryption, AttachmentUpload, Error, ErrorKind, LinkPreview, Media, MediaFile,
-    MediaId, MediaKind, MediaLocation, MediaSize, TimelineId,
+    MediaId, MediaKind, MediaLocation, MediaSize,
     normalise::{MediaRegistration, MediaScope, MediaSourceInfo},
     upload::prepare_upload,
 };
@@ -655,14 +657,35 @@ pub(crate) async fn queue_upload(
     upload: AttachmentUpload,
     max_bytes: usize,
 ) -> Result<(), Error> {
-    let (upload, mime, mut config) = prepare_upload(upload, max_bytes)?;
-    if let TimelineId::Thread { root_event_id, .. } = &upload.timeline_id {
-        config.reply = Some(SdkReply {
-            event_id: root_event_id.clone(),
+    let (mut upload, mime, mut config) = prepare_upload(upload, max_bytes)?;
+    let thread_root = upload.timeline_id.thread_root().cloned();
+    config.reply = match (upload.reply_to.take(), thread_root) {
+        (Some(event_id), thread_root) => {
+            let reply = || SdkReply {
+                event_id: event_id.clone(),
+                enforce_thread: if thread_root.is_some() {
+                    EnforceThread::Threaded(ReplyWithinThread::Yes)
+                } else {
+                    EnforceThread::MaybeThreaded
+                },
+                add_mentions: if upload.notify_replied_to {
+                    AddMentions::Yes
+                } else {
+                    AddMentions::No
+                },
+            };
+            if let Some(thread_root) = &thread_root {
+                check_reply_thread(&room, reply(), thread_root).await?;
+            }
+            Some(reply())
+        }
+        (None, Some(root_event_id)) => Some(SdkReply {
+            event_id: root_event_id,
             enforce_thread: EnforceThread::Threaded(ReplyWithinThread::No),
             add_mentions: AddMentions::No,
-        });
-    }
+        }),
+        (None, None) => None,
+    };
     room.send_queue()
         .send_attachment(upload.filename, mime, upload.bytes, config)
         .await
@@ -680,6 +703,31 @@ pub(crate) async fn queue_upload(
         })
 }
 
+/// the send queue builds the relation itself, so a reply that would land in another thread has to be caught before it is queued
+async fn check_reply_thread(
+    room: &Room,
+    reply: SdkReply,
+    thread_root: &OwnedEventId,
+) -> Result<(), Error> {
+    let content = room
+        .make_reply_event(RoomMessageEventContentWithoutRelation::text_plain(""), reply)
+        .await
+        .map_err(|source| {
+            Error::with_source(ErrorKind::Timeline, "reply operation failed", source)
+        })?;
+    if matches!(
+        content.relates_to.as_ref(),
+        Some(Relation::Thread(thread)) if &thread.event_id == thread_root
+    ) {
+        Ok(())
+    } else {
+        Err(Error::new(
+            ErrorKind::Invalid,
+            "reply target does not belong to the selected thread",
+        ))
+    }
+}
+
 /// least recently seen goes first. stale order slots are skipped by stamp rather than hunted down
 struct MediaRegistry {
     entries: HashMap<MediaId, (MediaRegistration, u64)>,

Modified file: src/engine/timeline.rs+4 additions−11 deletions@@ -7,11 +7,8 @@ use matrix_sdk::{
     room::reply::{EnforceThread, Reply as SdkReply},
     ruma::{
         api::client::receipt::create_receipt::v3::ReceiptType,
-        events::{
-            Mentions,
-            room::message::{
-                AddMentions, Relation, ReplyWithinThread, RoomMessageEventContentWithoutRelation,
-            },
+        events::room::message::{
+            AddMentions, Relation, ReplyWithinThread, RoomMessageEventContentWithoutRelation,
         },
     },
 };
@@ -26,6 +23,7 @@ use crate::{
     engine::MediaService,
     normalise::{MediaScope, normalise_timeline, normalise_timeline_diffs},
     transport::{EventSender, Responder, SendEventError},
+    upload::sdk_mentions,
 };
 
 const PAGINATION_QUEUE: usize = 32;
@@ -455,12 +453,7 @@ fn message_content(
         None if emote => RoomMessageEventContentWithoutRelation::emote_plain(content.body),
         None => RoomMessageEventContentWithoutRelation::text_plain(content.body),
     };
-    let content = content.add_mentions(Mentions::with_user_ids(mentions.user_ids));
-    if mentions.room {
-        content.add_mentions(Mentions::with_room_mention())
-    } else {
-        content
-    }
+    content.add_mentions(sdk_mentions(mentions))
 }
 
 pub(super) fn timeline_error(source: matrix_sdk_ui::timeline::Error) -> Error {

Modified file: src/model.rs+7 additions−1 deletions@@ -334,7 +334,10 @@ pub struct AttachmentUpload {
     pub filename: String,
     pub mimetype: String,
     pub bytes: Vec<u8>,
-    pub caption: Option<String>,
+    pub caption: Option<RichText>,
+    pub mentions: MessageMentions,
+    pub reply_to: Option<OwnedEventId>,
+    pub notify_replied_to: bool,
     pub details: Option<UploadDetails>,
     pub thumbnail: Option<UploadThumbnail>,
 }
@@ -353,6 +356,9 @@ impl AttachmentUpload {
             mimetype: mimetype.into(),
             bytes,
             caption: None,
+            mentions: MessageMentions::default(),
+            reply_to: None,
+            notify_replied_to: true,
             details: None,
             thumbnail: None,
         }

Modified file: src/upload.rs+17 additions−3 deletions@@ -5,10 +5,23 @@ use matrix_sdk::{
         AttachmentConfig, AttachmentInfo, BaseAudioInfo, BaseFileInfo, BaseImageInfo,
         BaseVideoInfo, Thumbnail,
     },
-    ruma::events::room::message::TextMessageEventContent,
+    ruma::events::{Mentions, room::message::TextMessageEventContent},
 };
 
-use crate::{AttachmentUpload, Error, ErrorKind, UploadDetails};
+use crate::{AttachmentUpload, Error, ErrorKind, MessageMentions, RichText, UploadDetails};
+
+pub(crate) fn sdk_mentions(mentions: MessageMentions) -> Mentions {
+    let mut sdk = Mentions::with_user_ids(mentions.user_ids);
+    sdk.room = mentions.room;
+    sdk
+}
+
+fn caption_content(caption: RichText) -> TextMessageEventContent {
+    match caption.formatted_body {
+        Some(formatted_body) => TextMessageEventContent::html(caption.body, formatted_body),
+        None => TextMessageEventContent::plain(caption.body),
+    }
+}
 
 pub(crate) fn prepare_upload(
     mut upload: AttachmentUpload,
@@ -163,6 +176,7 @@ pub(crate) fn prepare_upload(
     let config = AttachmentConfig::new()
         .info(info)
         .thumbnail(thumbnail)
-        .caption(upload.caption.clone().map(TextMessageEventContent::plain));
+        .caption(upload.caption.take().map(caption_content))
+        .mentions(Some(sdk_mentions(std::mem::take(&mut upload.mentions))));
     Ok((upload, mimetype, config))
 }

Modified file: tests/media.rs+3 additions−3 deletions@@ -4,8 +4,8 @@ use std::{sync::Arc, time::Duration};
 
 use macltok::{
     AttachmentUpload, ClientHandle, Engine, EngineConfig, EngineError, ErrorKind, Event,
-    EventStream, MediaFile, MediaId, MediaLocation, MediaSize, UploadDetails, UploadOutcome,
-    UploadThumbnail,
+    EventStream, MediaFile, MediaId, MediaLocation, MediaSize, RichText, UploadDetails,
+    UploadOutcome, UploadThumbnail,
 };
 use matrix_sdk::{
     media::{MediaFormat, MediaRequestParameters},
@@ -397,7 +397,7 @@ async fn media_upload_is_queued_and_sent() {
         "image/jpeg",
         b"photo data".to_vec(),
     );
-    upload.caption = Some("holiday".to_owned());
+    upload.caption = Some(RichText::plain("holiday"));
     harness.handle.upload(upload).await.unwrap();
 
     tokio::time::timeout(Duration::from_secs(5), async {

macltok

Commit 0827ad2d24e9

Commit `0827ad2d24e9`