feat: allow sending webxdc update from broadcase subscribers

Author: r10s

src/chat.rs

@@ -2691,7 +2691,9 @@ async fn prepare_send_msg(
         CantSendReason::InBroadcast => {
             matches!(
                 msg.param.get_cmd(),
-                SystemMessage::MemberRemovedFromGroup | SystemMessage::SecurejoinMessage
+                SystemMessage::MemberRemovedFromGroup
+                    | SystemMessage::SecurejoinMessage
+                    | SystemMessage::WebxdcStatusUpdate
             )
         }
         CantSendReason::MissingKey => msg
@@ -2701,7 +2703,7 @@ async fn prepare_send_msg(
         _ => false,
     };
     if let Some(reason) = chat.why_cant_send_ex(context, &skip_fn).await? {
-        bail!("Cannot send to {chat_id}: {reason}");
+        bail!("Cannot prepare sending to {chat_id}: {reason}");
     }
 
     // Check a quote reply is not leaking data from other chats.

src/webxdc.rs

@@ -34,7 +34,7 @@ use serde_json::Value;
 use sha2::{Digest, Sha256};
 use tokio::{fs::File, io::BufReader};
 
-use crate::chat::{self, Chat};
+use crate::chat::{self, CantSendReason, Chat};
 use crate::constants::Chattype;
 use crate::contact::ContactId;
 use crate::context::Context;
@@ -542,10 +542,16 @@ impl Context {
         let chat = Chat::load_from_db(self, chat_id)
             .await
             .with_context(|| format!("Failed to load chat {chat_id} from the database"))?;
-        if let Some(reason) = chat.why_cant_send(self).await.with_context(|| {
-            format!("Failed to check if webxdc update can be sent to chat {chat_id}")
-        })? {
-            bail!("Cannot send to {chat_id}: {reason}.");
+
+        let skip_fn = |reason: &CantSendReason| matches!(reason, CantSendReason::InBroadcast);
+        if let Some(reason) = chat
+            .why_cant_send_ex(self, &skip_fn)
+            .await
+            .with_context(|| {
+                format!("Failed to check if webxdc update can be sent to chat {chat_id}")
+            })?
+        {
+            bail!("Cannot send update to {chat_id}: {reason}.");
         }
 
         let send_now = !matches!(

src/webxdc/webxdc_tests.rs

@@ -2235,3 +2235,88 @@ async fn test_webxdc_info_app_sender() -> Result<()> {
 
     Ok(())
 }
+
+#[tokio::test(flavor = "multi_thread", worker_threads = 2)]
+async fn test_webxdc_broadcast_channel_updates() -> Result<()> {
+    let mut tcm = TestContextManager::new();
+    let alice = &tcm.alice().await;
+    let bob = &tcm.bob().await;
+    let claire = &tcm.charlie().await;
+
+    // Alice creates a broadcast channel
+    let alice_broadcast_id = create_broadcast(alice, "Channel".to_string()).await?;
+
+    // Bob and Claire join via securejoin QR
+    let qr = get_securejoin_qr(alice, Some(alice_broadcast_id)).await?;
+    tcm.exec_securejoin_qr(bob, alice, &qr).await;
+    let qr = get_securejoin_qr(alice, Some(alice_broadcast_id)).await?;
+    tcm.exec_securejoin_qr(claire, alice, &qr).await;
+
+    // Alice sends a webxdc app to the channel
+    let alice_instance = send_webxdc_instance(alice, alice_broadcast_id).await?;
+    let sent_instance = alice.pop_sent_msg().await;
+
+    // Bob and Claire receive the webxdc app
+    let bob_instance = bob.recv_msg(&sent_instance).await;
+    let claire_instance = claire.recv_msg(&sent_instance).await;
+    assert_eq!(bob_instance.viewtype, Viewtype::Webxdc);
+    assert_eq!(claire_instance.viewtype, Viewtype::Webxdc);
+
+    // Verify broadcast context flags
+    assert!(alice_instance.get_webxdc_info(alice).await?.is_app_sender);
+    assert!(alice_instance.get_webxdc_info(alice).await?.is_broadcast);
+    assert!(!bob_instance.get_webxdc_info(bob).await?.is_app_sender);
+    assert!(bob_instance.get_webxdc_info(bob).await?.is_broadcast);
+    assert!(!claire_instance.get_webxdc_info(claire).await?.is_app_sender);
+    assert!(claire_instance.get_webxdc_info(claire).await?.is_broadcast);
+
+    // Alice sends a webxdc update, Bob and Claire both receive it
+    alice
+        .send_webxdc_status_update(alice_instance.id, r#"{"payload": "hello from alice"}"#)
+        .await?;
+    alice.flush_status_updates().await?;
+    let sent_alice_update = alice.pop_sent_msg().await;
+
+    bob.recv_msg_trash(&sent_alice_update).await;
+    claire.recv_msg_trash(&sent_alice_update).await;
+
+    assert_eq!(
+        bob.get_webxdc_status_updates(bob_instance.id, StatusUpdateSerial(0))
+            .await?,
+        r#"[{"payload":"hello from alice","serial":1,"max_serial":1}]"#
+    );
+    assert_eq!(
+        claire
+            .get_webxdc_status_updates(claire_instance.id, StatusUpdateSerial(0))
+            .await?,
+        r#"[{"payload":"hello from alice","serial":1,"max_serial":1}]"#
+    );
+
+    // Bob sends a webxdc update — Alice should receive it, but Claire should NOT
+    bob.send_webxdc_status_update(bob_instance.id, r#"{"payload": "hello from bob"}"#)
+        .await?;
+    bob.flush_status_updates().await?;
+
+    let sent_bob_update = bob.pop_sent_msg().await;
+
+    // Alice receives Bob's update
+    alice.recv_msg_trash(&sent_bob_update).await;
+    assert_eq!(
+        alice
+            .get_webxdc_status_updates(alice_instance.id, StatusUpdateSerial(0))
+            .await?,
+        r#"[{"payload":"hello from alice","serial":1,"max_serial":2},
+{"payload":"hello from bob","serial":2,"max_serial":2}]"#
+    );
+
+    // Claire does NOT receive Bob's update;
+    // in a broadcast channel, subscriber updates are sent back to the owner only
+    assert_eq!(
+        claire
+            .get_webxdc_status_updates(claire_instance.id, StatusUpdateSerial(0))
+            .await?,
+        r#"[{"payload":"hello from alice","serial":1,"max_serial":1}]"#
+    );
+
+    Ok(())
+}