macltok

public

Star0

Fork 0

Watch0

103 commits 3 branches 0 tags 0 releases3.0 MiB

Commit `038cc6faeb14`

tarball

atagen <boss@atagen.co>2026-10-26 02:10 UTC

4 files changed+85-25

mentions: keep direct rooms out of the inbox

DMs have their own list and badges, so a ping there showed up twice. Malice can't drop them itself, because unread_count, coverage, paging and the read boundaries are all worked out here. The filter reads the room's m.direct targets each tick rather than at classify time, so entries already saved come back when a room stops being direct, and a room that turns direct drops out with a revision bump. Captures wait while a room is direct.

Modified file: src/mentions/service.rs+31 additions−11 deletions@@ -107,6 +107,9 @@ pub(crate) struct Service {
     unpublished: bool,
     flush_after: u64,
     ignored: BTreeSet<OwnedUserId>,
+    /// kept out of everything the inbox shows, while their entries stay saved for when the
+    /// room stops being direct
+    direct: BTreeSet<OwnedRoomId>,
     leaving: BTreeSet<OwnedRoomId>,
     timed_out: Arc<AtomicBool>,
     config: EngineConfig,
@@ -282,7 +285,8 @@ impl Service {
         for reason in &loaded.gaps {
             loaded.data.gap(None, *reason, None);
         }
-        let page = loaded.data.page(&account, None, 50)?;
+        let direct = direct_rooms(&client);
+        let page = loaded.data.page(&account, None, 50, &direct)?;
         let media_scope = MediaScope::bounded(config.max_mention_context_events);
         media
             .register(
@@ -313,6 +317,7 @@ impl Service {
             unpublished: false,
             flush_after: 0,
             ignored: BTreeSet::new(),
+            direct,
             leaving: BTreeSet::new(),
             timed_out: timed_out.clone(),
             config,
@@ -347,7 +352,7 @@ impl Service {
 
     async fn publish(&mut self) {
         self.unpublished = false;
-        let Ok(page) = self.data.page(&self.account, None, 50) else {
+        let Ok(page) = self.data.page(&self.account, None, 50, &self.direct) else {
             return;
         };
         self.media
@@ -518,7 +523,9 @@ impl Service {
     async fn command(&mut self, command: MentionsCommand) -> Result<CommandOutput, Error> {
         match command {
             MentionsCommand::Page { cursor, limit } => {
-                let page = self.data.page(&self.account, cursor.as_deref(), limit)?;
+                let page = self
+                    .data
+                    .page(&self.account, cursor.as_deref(), limit, &self.direct)?;
                 self.media
                     .register(
                         &self.media_scope,
@@ -569,8 +576,11 @@ impl Service {
             }
             MentionsCommand::SetRead { keys, read } => {
                 let mut next = self.data.clone();
-                for key in keys {
-                    if let Some(entry) = next.entries.get_mut(&id(&key)) {
+                for key in keys
+                    .iter()
+                    .filter(|key| !self.direct.contains(&key.room_id))
+                {
+                    if let Some(entry) = next.entries.get_mut(&id(key)) {
                         entry.read = read;
                         entry.revision = self.data.revision + 1;
                     }
@@ -583,11 +593,10 @@ impl Service {
                     return Err(invalid("invalid mentions read boundary"));
                 }
                 let mut next = self.data.clone();
-                for entry in next
-                    .entries
-                    .values_mut()
-                    .filter(|entry| entry.discovery_revision <= boundary.revision)
-                {
+                for entry in next.entries.values_mut().filter(|entry| {
+                    entry.discovery_revision <= boundary.revision
+                        && !self.direct.contains(&entry.key.room_id)
+                }) {
                     entry.read = true;
                     entry.revision = self.data.revision + 1;
                 }
@@ -1200,6 +1209,8 @@ impl Service {
                 () = &mut tick => {
                     tick = Box::pin(matrix_sdk::sleep::sleep(Duration::from_secs(1)));
                     if now() >= next_scan && !history { self.recovery_budget = 20; self.latest_scan = true; next_scan = now() + 60_000; }
+                    let direct = direct_rooms(&self.client);
+                    if direct != self.direct { self.direct = direct; self.dirty = true; self.unpublished = true; }
                     if now() >= next_expiry { let expired = self.data.expire_candidates(now()); self.dirty |= expired; self.unpublished |= expired; next_expiry = now() + 60_000; }
                     #[cfg(any(feature = "sqlite", feature = "indexeddb"))]
                     if self.store.is_none() && self.reopen.is_some() && now() >= self.flush_after { self.reopen().await; }
@@ -1385,7 +1396,7 @@ impl Service {
     ) {
         for (key, entry) in self.data.entries.iter().filter(|(_, entry)| matches!(entry.capture, MentionCaptureState::Pending) || matches!(entry.capture, MentionCaptureState::Failed {retry_at_ms, ..} if retry_at_ms <= now())).take(128) {
             if captures.len() >= 2 { break; }
-            if captures.contains(key) { continue; }
+            if captures.contains(key) || self.direct.contains(&entry.key.room_id) { continue; }
             let Some(room) = self.client.get_room(&entry.key.room_id).filter(|room| room.state() == RoomState::Joined) else { continue; };
             captures.insert(key.clone());
             let key = key.clone(); let event_id = entry.key.event_id.clone(); let account = self.account.clone(); let revision = entry.revision;
@@ -1649,6 +1660,15 @@ impl Service {
     }
 }
 
+fn direct_rooms(client: &Client) -> BTreeSet<OwnedRoomId> {
+    client
+        .rooms()
+        .into_iter()
+        .filter(|room| room.direct_targets_length() > 0)
+        .map(|room| room.room_id().to_owned())
+        .collect()
+}
+
 fn edited(mut original: Value, edit: &Value) -> Value {
     original["content"] = edit["content"]["m.new_content"].clone();
     original["unsigned"]["macltok_edited"] = Value::Bool(true);

Modified file: src/mentions/service_tests.rs+10 additions−3 deletions@@ -707,7 +707,9 @@ async fn observing_again_keeps_the_profiles_a_capture_fetched() {
         value["origin_server_ts"] = json!(timestamp);
         value
     };
-    let factory = EventFactory::new().room(room_id).sender(user_id!("@bob:localhost"));
+    let factory = EventFactory::new()
+        .room(room_id)
+        .sender(user_id!("@bob:localhost"));
     let mention = raw(
         factory
             .text_msg("ping")
@@ -738,7 +740,9 @@ async fn observing_again_keeps_the_profiles_a_capture_fetched() {
         item
     };
     let target = profiled(&data.entries[&ping].event);
-    let mut neighbour = normalise_observed(&following, None, &following_id).unwrap().0;
+    let mut neighbour = normalise_observed(&following, None, &following_id)
+        .unwrap()
+        .0;
     neighbour = profiled(&neighbour);
     let revision = data.entries[&ping].revision;
     service.captured(
@@ -768,6 +772,9 @@ async fn observing_again_keeps_the_profiles_a_capture_fetched() {
     };
     assert_eq!(name(&data.entries[&ping].event).as_deref(), Some("Bob"));
     assert_eq!(name(&data.events[&ping].item).as_deref(), Some("Bob"));
-    assert_eq!(name(&data.events[&following_id].item).as_deref(), Some("Bob"));
+    assert_eq!(
+        name(&data.events[&following_id].item).as_deref(),
+        Some("Bob")
+    );
     assert_eq!(data.entries[&ping].capture, capture);
 }

Modified file: src/mentions/state.rs+19 additions−4 deletions@@ -1,6 +1,6 @@
 use std::collections::{BTreeMap, BTreeSet};
 
-use ruma::OwnedUserId;
+use ruma::{OwnedRoomId, OwnedUserId};
 use serde_json::Value;
 
 use crate::{
@@ -304,6 +304,7 @@ impl Data {
         account: &OwnedUserId,
         cursor: Option<&str>,
         limit: u16,
+        hidden: &BTreeSet<OwnedRoomId>,
     ) -> Result<MentionsPage, Error> {
         let (boundary, last) = if let Some(cursor) = cursor {
             let value: Value =
@@ -332,7 +333,8 @@ impl Data {
             .entries
             .iter()
             .filter(|(key, entry)| {
-                entry.discovery_revision <= boundary
+                !hidden.contains(&entry.key.room_id)
+                    && entry.discovery_revision <= boundary
                     && last.as_ref().is_none_or(|last| {
                         (entry.timestamp_ms, key.as_str()) < (last.0, last.1.as_str())
                     })
@@ -351,13 +353,26 @@ impl Data {
         }).to_string())
         };
         let mut coverage = self.coverage.clone();
-        coverage.unresolved_candidates = self.candidates.len();
+        coverage.gaps.retain(|gap| {
+            gap.room_id
+                .as_ref()
+                .is_none_or(|room_id| !hidden.contains(room_id))
+        });
+        coverage.unresolved_candidates = self
+            .candidates
+            .values()
+            .filter(|candidate| !hidden.contains(&candidate.room_id))
+            .count();
         Ok(MentionsPage {
             entries,
             next_cursor,
             end_reached,
             coverage,
-            unread_count: self.entries.values().filter(|entry| !entry.read).count(),
+            unread_count: self
+                .entries
+                .values()
+                .filter(|entry| !entry.read && !hidden.contains(&entry.key.room_id))
+                .count(),
             revision: self.revision,
             boundary: MentionsBoundary {
                 account: account.clone(),

Modified file: src/mentions/state_tests.rs+25 additions−7 deletions@@ -1,3 +1,5 @@
+use std::collections::BTreeSet;
+
 use ruma::{event_id, user_id};
 
 use super::state::{Data, SavedEvent, Window, id};
@@ -90,7 +92,7 @@ async fn pagination_keeps_its_discovery_boundary_and_stable_ties() {
             .insert(id(&mention), entry(mention, timestamp, 1, false));
     }
 
-    let first = data.page(&account, None, 2).unwrap();
+    let first = data.page(&account, None, 2, &BTreeSet::new()).unwrap();
     assert_eq!(
         first
             .entries
@@ -111,7 +113,9 @@ async fn pagination_keeps_its_discovery_boundary_and_stable_ties() {
         .map(|entry| entry.key)
         .collect::<Vec<_>>();
     loop {
-        let page = data.page(&account, Some(&cursor), 2).unwrap();
+        let page = data
+            .page(&account, Some(&cursor), 2, &BTreeSet::new())
+            .unwrap();
         paged.extend(page.entries.into_iter().map(|entry| entry.key));
         match page.next_cursor {
             Some(next) => cursor = next,
@@ -134,20 +138,34 @@ async fn pagination_rejects_a_forged_account_and_a_future_revision() {
         data.entries
             .insert(id(&mention), entry(mention, 10, 1, false));
     }
-    let cursor = data.page(&account, None, 1).unwrap().next_cursor.unwrap();
+    let cursor = data
+        .page(&account, None, 1, &BTreeSet::new())
+        .unwrap()
+        .next_cursor
+        .unwrap();
 
     let mut forged_account: serde_json::Value = serde_json::from_str(&cursor).unwrap();
     forged_account["account"] = serde_json::Value::String("@mallory:mentions.example".to_owned());
     assert!(
-        data.page(&account, Some(&forged_account.to_string()), 1)
-            .is_err()
+        data.page(
+            &account,
+            Some(&forged_account.to_string()),
+            1,
+            &BTreeSet::new()
+        )
+        .is_err()
     );
 
     let mut future_revision: serde_json::Value = serde_json::from_str(&cursor).unwrap();
     future_revision["revision"] = serde_json::json!(data.revision + 1);
     assert!(
-        data.page(&account, Some(&future_revision.to_string()), 1)
-            .is_err()
+        data.page(
+            &account,
+            Some(&future_revision.to_string()),
+            1,
+            &BTreeSet::new()
+        )
+        .is_err()
     );
 }

macltok

Commit 038cc6faeb14

Commit `038cc6faeb14`