Skip to content

armgit / ente

Public Imported from GitHub
0

πŸ’š End-to-end encrypted cloud for everything.

Move Space message handling into ente-space

Manav Rathifcf3674e1cec
diff --git a/rust/bindings/wasm/space/src/space.rs b/rust/bindings/wasm/space/src/space.rs
index e92bd42fe8..a6f960ffc2 100644
--- a/rust/bindings/wasm/space/src/space.rs
+++ b/rust/bindings/wasm/space/src/space.rs
@@ -1,7 +1,7 @@
use std::collections::BTreeMap;
use ente_core::b64;
-use ente_space::{AccountSpaceCtx, DecryptedMessage, MessagePayload, SpaceLinkCtx};
+use ente_space::{AccountSpaceCtx, SpaceLinkCtx};
use serde::{Deserialize, Serialize};
use serde_wasm_bindgen as swb;
use tsify::Tsify;
@@ -627,17 +627,19 @@ fn post_page_to_js(page: ente_space::PostPage) -> PostPage {
}
}
-fn account_message_to_js(
- mut message: ente_space::MessageResponse,
- decrypted: DecryptedMessage,
-) -> Result<MessageResponse, Error> {
- message.kind = decrypted.payload.kind;
- let mut response = message_to_js(message, decrypted.payload.text);
- response.reply_object_key = decrypted.payload.reply_object_key;
- Ok(response)
-}
-
-fn message_to_js(message: ente_space::MessageResponse, text: String) -> MessageResponse {
+fn message_to_js(message: ente_space::Message) -> MessageResponse {
+ let (text, reply_object_key, is_deleted, is_unavailable) = match message.content {
+ Ok(Some(content)) => (content.text, content.reply_object_key, false, false),
+ Ok(None) => (String::new(), None, true, false),
+ Err(error) => {
+ log::warn!(
+ "Space message {} is unavailable: {}",
+ message.message_id,
+ ente_core::error::chain(&error)
+ );
+ (String::new(), None, false, true)
+ }
+ };
MessageResponse {
message_id: message.message_id,
kind: message.kind,
@@ -645,141 +647,32 @@ fn message_to_js(message: ente_space::MessageResponse, text: String) -> MessageR
recipient_space_id: message.recipient_space_id,
text,
reply_post_id: message.reply_post_id,
- reply_object_key: None,
- reply_message_id: message.reply_message_id,
- liked: message.liked,
- viewer_liked: message.viewer_liked,
- is_deleted: message.is_deleted,
- created_at: message.created_at,
- updated_at: message.updated_at,
- is_unavailable: false,
- }
-}
-
-fn unavailable_message_to_js(message: ente_space::MessageResponse) -> MessageResponse {
- MessageResponse {
- message_id: message.message_id,
- kind: message.kind,
- sender_space_id: message.sender_space_id,
- recipient_space_id: message.recipient_space_id,
- text: String::new(),
- reply_post_id: message.reply_post_id,
- reply_object_key: None,
+ reply_object_key,
reply_message_id: message.reply_message_id,
liked: message.liked,
viewer_liked: message.viewer_liked,
- is_deleted: message.is_deleted,
+ is_deleted,
created_at: message.created_at,
updated_at: message.updated_at,
- is_unavailable: true,
- }
-}
-
-async fn account_message_response_to_js(
- ctx: &AccountSpaceCtx,
- viewer_space_id: &str,
- message: ente_space::MessageResponse,
-) -> Result<MessageResponse, Error> {
- if message.is_deleted {
- return Ok(message_to_js(message, String::new()));
- }
- if message.kind != "post_like" && message.kind != "friend_added" {
- let decrypted = ctx.decrypt_message(viewer_space_id, &message).await?;
- return account_message_to_js(message, decrypted);
+ is_unavailable,
}
-
- let text = message.text.clone();
- Ok(message_to_js(message, text))
}
-async fn resilient_account_message_response_to_js(
- ctx: &AccountSpaceCtx,
- viewer_space_id: &str,
- message: ente_space::MessageResponse,
-) -> Result<MessageResponse, Error> {
- let fallback = message.clone();
- match account_message_response_to_js(ctx, viewer_space_id, message).await {
- Ok(message) => Ok(message),
- Err(error) if error.is_content_error() => {
+fn message_activity_to_js(
+ activity: ente_space::MessageActivity,
+) -> MessageConversationActivity {
+ let (text, reply_object_key, is_unavailable) = match activity.content {
+ Ok(Some(content)) => (Some(content.text), content.reply_object_key, false),
+ Ok(None) => (None, None, false),
+ Err(error) => {
log::warn!(
- "Space message {} is unavailable: {}",
- fallback.message_id,
- error.message()
+ "Space conversation activity {} is unavailable: {}",
+ activity.id,
+ ente_core::error::chain(&error)
);
- Ok(unavailable_message_to_js(fallback))
+ (None, None, true)
}
- Err(error) => Err(error),
- }
-}
-
-async fn message_conversation_activity_payload(
- ctx: &AccountSpaceCtx,
- viewer_space_id: &str,
- activity: &ente_space::MessageConversationActivity,
-) -> Result<Option<MessagePayload>, Error> {
- if activity.message_cipher.trim().is_empty()
- || activity.encrypted_message_key.trim().is_empty()
- || activity.message_id.is_none()
- {
- return Ok(None);
- }
-
- let message = ente_space::MessageResponse {
- message_id: activity.message_id.clone().unwrap_or_default(),
- kind: if activity.kind.trim().is_empty() {
- "regular".to_owned()
- } else {
- activity.kind.clone()
- },
- sender_space_id: activity.sender_space_id.clone(),
- recipient_space_id: activity.recipient_space_id.clone(),
- message_cipher: activity.message_cipher.clone(),
- encrypted_message_key: activity.encrypted_message_key.clone(),
- text: String::new(),
- reply_post_id: activity.post_id,
- reply_message_id: activity.reply_message_id.clone(),
- liked: false,
- viewer_liked: false,
- is_deleted: false,
- created_at: activity.created_at.clone(),
- updated_at: activity.created_at.clone(),
};
- let decrypted = ctx.decrypt_message(viewer_space_id, &message).await?;
- Ok(Some(decrypted.payload))
-}
-
-async fn message_conversation_activity_to_js(
- ctx: &AccountSpaceCtx,
- viewer_space_id: &str,
- activity: ente_space::MessageConversationActivity,
-) -> Result<MessageConversationActivity, Error> {
- let payload = message_conversation_activity_payload(ctx, viewer_space_id, &activity).await?;
- let kind = payload
- .as_ref()
- .map(|payload| payload.kind.clone())
- .unwrap_or_else(|| activity.kind.clone());
- let reply_object_key = payload
- .as_ref()
- .and_then(|payload| payload.reply_object_key.clone());
- let text = payload.map(|payload| payload.text);
- Ok(MessageConversationActivity {
- id: activity.id,
- activity_type: activity.activity_type,
- kind,
- created_at: activity.created_at,
- outgoing: activity.outgoing,
- message_id: activity.message_id,
- text,
- post_id: activity.post_id,
- reply_object_key,
- post_space_id: activity.post_space_id,
- is_unavailable: false,
- })
-}
-
-fn unavailable_message_conversation_activity_to_js(
- activity: ente_space::MessageConversationActivity,
-) -> MessageConversationActivity {
MessageConversationActivity {
id: activity.id,
activity_type: activity.activity_type,
@@ -787,31 +680,11 @@ fn unavailable_message_conversation_activity_to_js(
created_at: activity.created_at,
outgoing: activity.outgoing,
message_id: activity.message_id,
- text: None,
+ text,
post_id: activity.post_id,
- reply_object_key: None,
+ reply_object_key,
post_space_id: activity.post_space_id,
- is_unavailable: true,
- }
-}
-
-async fn resilient_message_conversation_activity_to_js(
- ctx: &AccountSpaceCtx,
- viewer_space_id: &str,
- activity: ente_space::MessageConversationActivity,
-) -> Result<MessageConversationActivity, Error> {
- let fallback = activity.clone();
- match message_conversation_activity_to_js(ctx, viewer_space_id, activity).await {
- Ok(activity) => Ok(activity),
- Err(error) if error.is_content_error() => {
- log::warn!(
- "Space conversation activity {} is unavailable: {}",
- fallback.id,
- error.message()
- );
- Ok(unavailable_message_conversation_activity_to_js(fallback))
- }
- Err(error) => Err(error),
+ is_unavailable,
}
}
@@ -1300,13 +1173,7 @@ impl SpaceAccountCtxHandle {
.inner
.send_message(&sender_space_id, &space_id, &text)
.await?;
- let decrypted = self
- .inner
- .decrypt_message(&sender_space_id, &message)
- .await?;
- account_message_to_js(message, decrypted)?
- .into_js()
- .map_err(Into::into)
+ message_to_js(message).into_js().map_err(Into::into)
}
#[wasm_bindgen(js_name = sendPoke)]
@@ -1316,13 +1183,7 @@ impl SpaceAccountCtxHandle {
space_id: String,
) -> Result<<MessageResponse as Tsify>::JsType, Error> {
let message = self.inner.send_poke(&sender_space_id, &space_id).await?;
- let decrypted = self
- .inner
- .decrypt_message(&sender_space_id, &message)
- .await?;
- account_message_to_js(message, decrypted)?
- .into_js()
- .map_err(Into::into)
+ message_to_js(message).into_js().map_err(Into::into)
}
#[wasm_bindgen(js_name = replyToMessage)]
@@ -1337,13 +1198,7 @@ impl SpaceAccountCtxHandle {
.inner
.reply_to_message(&sender_space_id, &space_id, &message_id, &text)
.await?;
- let decrypted = self
- .inner
- .decrypt_message(&sender_space_id, &message)
- .await?;
- account_message_to_js(message, decrypted)?
- .into_js()
- .map_err(Into::into)
+ message_to_js(message).into_js().map_err(Into::into)
}
#[wasm_bindgen(js_name = replyToPost)]
@@ -1365,13 +1220,7 @@ impl SpaceAccountCtxHandle {
object_key.as_deref(),
)
.await?;
- let decrypted = self
- .inner
- .decrypt_message(&sender_space_id, &message)
- .await?;
- account_message_to_js(message, decrypted)?
- .into_js()
- .map_err(Into::into)
+ message_to_js(message).into_js().map_err(Into::into)
}
#[wasm_bindgen(js_name = likeMessage)]
@@ -1424,23 +1273,15 @@ impl SpaceAccountCtxHandle {
let mut chat_summaries = BTreeMap::new();
for (friend_space_id, summary) in response.chat_summaries {
- let mut unread_activities = Vec::with_capacity(summary.unread_activities.len());
- for activity in summary.unread_activities {
- unread_activities.push(
- resilient_message_conversation_activity_to_js(&self.inner, &space_id, activity)
- .await?,
- );
- }
chat_summaries.insert(
friend_space_id,
ConversationChatSummaryResponse {
- latest_activity: resilient_message_conversation_activity_to_js(
- &self.inner,
- &space_id,
- summary.latest_activity,
- )
- .await?,
- unread_activities,
+ latest_activity: message_activity_to_js(summary.latest_activity),
+ unread_activities: summary
+ .unread_activities
+ .into_iter()
+ .map(message_activity_to_js)
+ .collect(),
},
);
}
@@ -1467,15 +1308,8 @@ impl SpaceAccountCtxHandle {
.inner
.list_message_thread(&viewer_space_id, &space_id, cursor, limit)
.await?;
- let mut items = Vec::with_capacity(page.items.len());
- for message in page.items {
- items.push(
- resilient_account_message_response_to_js(&self.inner, &viewer_space_id, message)
- .await?,
- );
- }
MessagePage {
- items,
+ items: page.items.into_iter().map(message_to_js).collect(),
next_cursor: page.next_cursor,
}
.into_js()
@@ -1605,204 +1439,8 @@ impl SpaceAccountCtxHandle {
#[cfg(test)]
mod tests {
- use ente_core::crypto::{Key, SecretKey, sealed, secretbox};
-
use super::*;
- fn message(
- message_id: &str,
- encrypted_message_key: &str,
- message_cipher: &str,
- ) -> ente_space::MessageResponse {
- ente_space::MessageResponse {
- message_id: message_id.into(),
- kind: "regular".into(),
- sender_space_id: "space-2".into(),
- recipient_space_id: "space-1".into(),
- message_cipher: message_cipher.into(),
- encrypted_message_key: encrypted_message_key.into(),
- text: String::new(),
- reply_post_id: None,
- reply_message_id: None,
- liked: false,
- viewer_liked: false,
- is_deleted: false,
- created_at: "2026-08-01T00:00:00Z".into(),
- updated_at: "2026-08-01T00:00:00Z".into(),
- }
- }
-
- fn message_context() -> (AccountSpaceCtx, Key, String) {
- let root_key = Key::generate();
- let secret_key = SecretKey::generate();
- let public_key = secret_key.public_key();
- let encrypted_secret_key = secretbox::encrypt_combined(secret_key.as_bytes(), &root_key);
- let ctx = AccountSpaceCtx::open(ente_space::OpenAccountSpaceCtxInput {
- base_url: "http://localhost".into(),
- space_session_token: None,
- space_root_key: root_key.as_bytes().to_vec(),
- initial_owned_spaces: Some(vec![ente_space::SpaceKeyResponse {
- space_id: "space-1".into(),
- space_slug: "alice".into(),
- root_wrapped_space_key: String::new(),
- public_key: b64::encode(public_key.as_bytes()),
- encrypted_secret_key: b64::encode(&encrypted_secret_key),
- encrypted_profile: String::new(),
- key_version: 1,
- }]),
- user_agent: None,
- client_package: None,
- client_version: None,
- })
- .unwrap();
- let message_key = Key::generate();
- let sealed_message_key = sealed::seal(message_key.as_bytes(), &public_key).unwrap();
- let encrypted_message_key = b64::encode(&sealed_message_key);
- (ctx, message_key, encrypted_message_key)
- }
-
- #[tokio::test]
- async fn encrypted_message_kinds_preserve_server_events_and_allow_pokes() {
- let (ctx, message_key, encrypted_message_key) = message_context();
-
- for reply_object_key in [None, Some("first"), Some("second")] {
- for (server_kind, payload_kind, expected_kind) in [
- ("regular", "regular", "regular"),
- ("regular", "poke", "poke"),
- ("regular", "post_like", "regular"),
- ("regular", "post_reply", "regular"),
- ("regular", "friend_added", "regular"),
- ("regular", "unknown", "regular"),
- ("post_reply", "post_reply", "post_reply"),
- ("post_reply", "regular", "post_reply"),
- ("post_reply", "poke", "post_reply"),
- ("post_reply", "post_like", "post_reply"),
- ("post_reply", "friend_added", "post_reply"),
- ] {
- let photo_field = reply_object_key
- .map(|key| format!(r#","replyObjectKey":"{key}""#))
- .unwrap_or_default();
- let plaintext = format!(
- r#"{{"version":1,"kind":"{payload_kind}","text":"hello"{photo_field}}}"#
- );
- let cipher = b64::encode(&secretbox::encrypt_combined(
- plaintext.as_bytes(),
- &message_key,
- ));
- let mut response = message("message-1", &encrypted_message_key, &cipher);
- response.kind = server_kind.into();
- response.reply_post_id = (server_kind == "post_reply").then_some(42);
- let activity = ente_space::MessageConversationActivity {
- id: "activity-1".into(),
- activity_type: if server_kind == "post_reply" {
- "post_reply".into()
- } else {
- "message".into()
- },
- kind: response.kind.clone(),
- created_at: response.created_at.clone(),
- outgoing: false,
- message_id: Some(response.message_id.clone()),
- sender_space_id: response.sender_space_id.clone(),
- recipient_space_id: response.recipient_space_id.clone(),
- message_cipher: response.message_cipher.clone(),
- encrypted_message_key: response.encrypted_message_key.clone(),
- reply_message_id: None,
- post_id: response.reply_post_id,
- post_space_id: response.reply_post_id.map(|_| "space-1".into()),
- };
- let converted = resilient_account_message_response_to_js(&ctx, "space-1", response)
- .await
- .unwrap_or_else(|error| panic!("{error}"));
- let converted_activity = resilient_message_conversation_activity_to_js(
- &ctx,
- "space-1",
- activity.clone(),
- )
- .await
- .unwrap_or_else(|error| panic!("{error}"));
-
- assert_eq!(
- converted.kind, expected_kind,
- "message: server={server_kind}, payload={payload_kind}"
- );
- assert_eq!(
- converted_activity.kind, expected_kind,
- "activity: server={server_kind}, payload={payload_kind}"
- );
- assert_eq!(converted.reply_object_key.as_deref(), reply_object_key);
- assert_eq!(
- converted_activity.reply_object_key.as_deref(),
- reply_object_key
- );
- assert_eq!(converted.text, "hello");
- assert_eq!(converted.reply_post_id, activity.post_id);
- assert!(!converted.is_unavailable);
- assert_eq!(converted_activity.text.as_deref(), Some("hello"));
- assert_eq!(converted_activity.activity_type, activity.activity_type);
- assert_eq!(converted_activity.post_id, activity.post_id);
- assert!(!converted_activity.is_unavailable);
- }
- }
- }
-
- #[tokio::test]
- async fn corrupt_message_and_activity_become_unavailable() {
- let (ctx, message_key, encrypted_message_key) = message_context();
- let valid_cipher = b64::encode(&secretbox::encrypt_combined(
- br#"{"version":1,"kind":"regular","text":"hello"}"#,
- &message_key,
- ));
- let corrupt_cipher = b64::encode(&secretbox::encrypt_combined(b"not-json", &message_key));
-
- let first = resilient_account_message_response_to_js(
- &ctx,
- "space-1",
- message("message-1", &encrypted_message_key, &valid_cipher),
- )
- .await
- .unwrap_or_else(|error| panic!("{error}"));
- let corrupt = resilient_account_message_response_to_js(
- &ctx,
- "space-1",
- message("message-2", &encrypted_message_key, &corrupt_cipher),
- )
- .await
- .unwrap_or_else(|error| panic!("{error}"));
- let last = resilient_account_message_response_to_js(
- &ctx,
- "space-1",
- message("message-3", &encrypted_message_key, &valid_cipher),
- )
- .await
- .unwrap_or_else(|error| panic!("{error}"));
-
- assert!(!first.is_unavailable);
- assert!(corrupt.is_unavailable);
- assert!(!last.is_unavailable);
-
- let activity = ente_space::MessageConversationActivity {
- id: "activity-1".into(),
- activity_type: "message".into(),
- kind: "regular".into(),
- created_at: "2026-08-01T00:00:00Z".into(),
- outgoing: false,
- message_id: Some("message-2".into()),
- sender_space_id: "space-2".into(),
- recipient_space_id: "space-1".into(),
- message_cipher: corrupt_cipher,
- encrypted_message_key,
- reply_message_id: None,
- post_id: None,
- post_space_id: None,
- };
- let activity = resilient_message_conversation_activity_to_js(&ctx, "space-1", activity)
- .await
- .unwrap_or_else(|error| panic!("{error}"));
-
- assert!(activity.is_unavailable);
- }
-
#[test]
fn http_errors_are_not_content_errors() {
let error = Error::from(ente_space::Error::Http(ente_core::http::Error::Http {
diff --git a/rust/crates/space/src/client/messages.rs b/rust/crates/space/src/client/messages.rs
index 04bf5ee0c3..1f28376882 100644
--- a/rust/crates/space/src/client/messages.rs
+++ b/rust/crates/space/src/client/messages.rs
@@ -7,9 +7,13 @@ use crate::crypto::{
seal_with_public_key,
};
use crate::error::{Error, Result};
-use crate::models::{DecryptedMessage, MessagePayload};
+use crate::models::{
+ ConversationChatSummary, Conversations, Message, MessageActivity, MessageContent, MessagePage,
+ MessagePayload,
+};
use crate::transport::{
- ConversationsResponse, CreateMessageRequest, LikeMessageResponse, MessagePage, MessageResponse,
+ ConversationChatSummaryResponse, ConversationsResponse, CreateMessageRequest,
+ LikeMessageResponse, MessageConversationActivity, MessagePageResponse, MessageResponse,
SpaceActorResponse,
};
use ente_core::b64;
@@ -18,16 +22,29 @@ const MESSAGE_NOTIFICATION_KIND_POKE: &str = "poke";
const POKE_MESSAGE_TEXT: &str = "Poked";
impl AccountSpaceCtx {
- pub async fn list_conversations(&self, space_id: &str) -> Result<ConversationsResponse> {
+ pub async fn list_conversations(&self, space_id: &str) -> Result<Conversations> {
let path = format!("/spaces/{space_id}/conversations");
- Ok(self
+ let response: ConversationsResponse = self
.api()
.get(&path)
.send()
.await?
.error_for_status()?
.json()
- .await?)
+ .await?;
+ let mut chat_summaries = std::collections::BTreeMap::new();
+ for (friend_space_id, summary) in response.chat_summaries {
+ chat_summaries.insert(
+ friend_space_id,
+ self.open_conversation_summary(space_id, summary).await?,
+ );
+ }
+ Ok(Conversations {
+ friends: response.friends,
+ pending_requests: response.pending_requests,
+ chat_summaries,
+ latest_post_created_at: response.latest_post_created_at,
+ })
}
pub async fn list_message_thread(
@@ -45,7 +62,7 @@ impl AccountSpaceCtx {
query.push(("limit", value.to_string()));
}
let path = format!("/spaces/{viewer_space_id}/friends/{space_id}/messages");
- Ok(self
+ let page: MessagePageResponse = self
.api()
.get(&path)
.query(&query)
@@ -53,7 +70,149 @@ impl AccountSpaceCtx {
.await?
.error_for_status()?
.json()
- .await?)
+ .await?;
+ let mut items = Vec::with_capacity(page.items.len());
+ for message in page.items {
+ items.push(self.open_message(viewer_space_id, message).await?);
+ }
+ Ok(MessagePage {
+ items,
+ next_cursor: page.next_cursor,
+ })
+ }
+
+ async fn open_message(
+ &self,
+ viewer_space_id: &str,
+ message: MessageResponse,
+ ) -> Result<Message> {
+ let mut kind = message.kind.clone();
+ let content = if message.is_deleted {
+ Ok(None)
+ } else if kind == "post_like" || kind == "friend_added" {
+ Ok(Some(MessageContent {
+ text: message.text.clone(),
+ reply_object_key: None,
+ }))
+ } else {
+ self.decrypt_message(viewer_space_id, &message)
+ .await
+ .map(|payload| {
+ kind = payload.kind;
+ Some(MessageContent {
+ text: payload.text,
+ reply_object_key: payload.reply_object_key,
+ })
+ })
+ };
+ let content = match content {
+ Err(error) if !error.is_content_error() => return Err(error),
+ content => content,
+ };
+ Ok(Message {
+ message_id: message.message_id,
+ kind,
+ sender_space_id: message.sender_space_id,
+ recipient_space_id: message.recipient_space_id,
+ content,
+ reply_post_id: message.reply_post_id,
+ reply_message_id: message.reply_message_id,
+ liked: message.liked,
+ viewer_liked: message.viewer_liked,
+ created_at: message.created_at,
+ updated_at: message.updated_at,
+ })
+ }
+
+ async fn open_sent_message(
+ &self,
+ space_id: &str,
+ response: MessageResponse,
+ ) -> Result<Message> {
+ let message = self.open_message(space_id, response).await?;
+ let content = message.content?;
+ if content.is_none() {
+ return Err(Error::InvalidInput("sent message is deleted".into()));
+ }
+ Ok(Message {
+ content: Ok(content),
+ ..message
+ })
+ }
+
+ pub(super) async fn open_conversation_summary(
+ &self,
+ viewer_space_id: &str,
+ summary: ConversationChatSummaryResponse,
+ ) -> Result<ConversationChatSummary> {
+ let mut unread_activities = Vec::with_capacity(summary.unread_activities.len());
+ for activity in summary.unread_activities {
+ unread_activities.push(
+ self.open_message_activity(viewer_space_id, activity)
+ .await?,
+ );
+ }
+ let latest_activity = self
+ .open_message_activity(viewer_space_id, summary.latest_activity)
+ .await?;
+ for activity in &mut unread_activities {
+ if activity.id == latest_activity.id && latest_activity.kind == MESSAGE_KIND_POKE {
+ activity.kind = MESSAGE_KIND_POKE.to_owned();
+ }
+ }
+ Ok(ConversationChatSummary {
+ latest_activity,
+ unread_activities,
+ })
+ }
+
+ async fn open_message_activity(
+ &self,
+ viewer_space_id: &str,
+ activity: MessageConversationActivity,
+ ) -> Result<MessageActivity> {
+ let mut kind = activity.kind.clone();
+ let content = if activity.message_cipher.trim().is_empty()
+ || activity.encrypted_message_key.trim().is_empty()
+ || activity.message_id.is_none()
+ {
+ Ok(None)
+ } else {
+ let server_kind = if kind.trim().is_empty() {
+ MESSAGE_KIND_REGULAR
+ } else {
+ &kind
+ };
+ self.decrypt_message_fields(
+ viewer_space_id,
+ server_kind,
+ &activity.encrypted_message_key,
+ &activity.message_cipher,
+ )
+ .await
+ .map(|payload| {
+ kind = payload.kind;
+ Some(MessageContent {
+ text: payload.text,
+ reply_object_key: payload.reply_object_key,
+ })
+ })
+ };
+ let content = match content {
+ Err(error) if !error.is_content_error() => return Err(error),
+ content => content,
+ };
+ Ok(MessageActivity {
+ id: activity.id,
+ activity_type: activity.activity_type,
+ kind,
+ created_at: activity.created_at,
+ outgoing: activity.outgoing,
+ message_id: activity.message_id,
+ content,
+ post_id: activity.post_id,
+ post_space_id: activity.post_space_id,
+ })
}
pub async fn send_message(
@@ -61,7 +220,7 @@ impl AccountSpaceCtx {
sender_space_id: &str,
space_id: &str,
text: &str,
- ) -> Result<MessageResponse> {
+ ) -> Result<Message> {
self.send_direct_message(
sender_space_id,
space_id,
@@ -76,11 +235,7 @@ impl AccountSpaceCtx {
.await
}
- pub async fn send_poke(
- &self,
- sender_space_id: &str,
- space_id: &str,
- ) -> Result<MessageResponse> {
+ pub async fn send_poke(&self, sender_space_id: &str, space_id: &str) -> Result<Message> {
self.send_direct_message(
sender_space_id,
space_id,
@@ -101,7 +256,7 @@ impl AccountSpaceCtx {
space_id: &str,
payload: MessagePayload,
notification_kind: Option<&str>,
- ) -> Result<MessageResponse> {
+ ) -> Result<Message> {
let friend = self
.friend_actor_for_space(sender_space_id, space_id)
.await?;
@@ -115,7 +270,7 @@ impl AccountSpaceCtx {
)
.await?;
let path = format!("/spaces/{sender_space_id}/friends/{space_id}/messages");
- Ok(self
+ let response = self
.api()
.post(&path)
.json(&request)
@@ -123,7 +278,8 @@ impl AccountSpaceCtx {
.await?
.error_for_status()?
.json()
- .await?)
+ .await?;
+ self.open_sent_message(sender_space_id, response).await
}
pub async fn reply_to_message(
@@ -132,7 +288,7 @@ impl AccountSpaceCtx {
space_id: &str,
message_id: &str,
text: &str,
- ) -> Result<MessageResponse> {
+ ) -> Result<Message> {
let reply_message_id = message_id.trim();
if reply_message_id.is_empty() {
return Err(Error::InvalidInput("message id is required".into()));
@@ -156,7 +312,7 @@ impl AccountSpaceCtx {
)
.await?;
let path = format!("/spaces/{sender_space_id}/friends/{space_id}/messages");
- Ok(self
+ let response = self
.api()
.post(&path)
.json(&request)
@@ -164,7 +320,8 @@ impl AccountSpaceCtx {
.await?
.error_for_status()?
.json()
- .await?)
+ .await?;
+ self.open_sent_message(sender_space_id, response).await
}
pub async fn reply_to_post(
@@ -174,7 +331,7 @@ impl AccountSpaceCtx {
post_id: i64,
text: &str,
object_key: Option<&str>,
- ) -> Result<MessageResponse> {
+ ) -> Result<Message> {
let post = self
.get_post_raw(post_space_id, post_id, Some(sender_space_id))
.await?;
@@ -214,7 +371,7 @@ impl AccountSpaceCtx {
)
.await?;
let path = format!("/spaces/{sender_space_id}/posts/{post_id}/reply");
- Ok(self
+ let response = self
.api()
.post(&path)
.json(&request)
@@ -222,32 +379,46 @@ impl AccountSpaceCtx {
.await?
.error_for_status()?
.json()
- .await?)
+ .await?;
+ self.open_sent_message(sender_space_id, response).await
}
- pub async fn decrypt_message(
+ async fn decrypt_message(
&self,
space_id: &str,
message: &MessageResponse,
- ) -> Result<DecryptedMessage> {
+ ) -> Result<MessagePayload> {
if message.is_deleted {
return Err(Error::InvalidInput("message is deleted".into()));
}
+ self.decrypt_message_fields(
+ space_id,
+ &message.kind,
+ &message.encrypted_message_key,
+ &message.message_cipher,
+ )
+ .await
+ }
+
+ async fn decrypt_message_fields(
+ &self,
+ space_id: &str,
+ kind: &str,
+ encrypted_message_key: &str,
+ message_cipher: &str,
+ ) -> Result<MessagePayload> {
let identity = self.space_identity_for(space_id).await?;
- let sealed_key = b64::decode(&message.encrypted_message_key)?;
+ let sealed_key = b64::decode(encrypted_message_key)?;
let message_key =
open_with_keypair(&sealed_key, &identity.public_key, &identity.secret_key)?;
- let packed_message = b64::decode(&message.message_cipher)?;
+ let packed_message = b64::decode(message_cipher)?;
let plaintext = decrypt_secretbox_payload(&message_key, &packed_message)?;
let mut payload: MessagePayload = serde_json::from_slice(&plaintext)
.map_err(|err| Error::InvalidInput(format!("invalid message payload: {err}")))?;
- if message.kind != MESSAGE_KIND_REGULAR || payload.kind != MESSAGE_KIND_POKE {
- payload.kind = message.kind.clone();
+ if kind != MESSAGE_KIND_REGULAR || payload.kind != MESSAGE_KIND_POKE {
+ payload.kind = kind.to_owned();
}
- Ok(DecryptedMessage {
- message_key,
- payload,
- })
+ Ok(payload)
}
pub async fn like_message(
diff --git a/rust/crates/space/src/client/tests.rs b/rust/crates/space/src/client/tests.rs
index ba227f36ee..d556ff7da2 100644
--- a/rust/crates/space/src/client/tests.rs
+++ b/rust/crates/space/src/client/tests.rs
@@ -2,7 +2,9 @@ use super::test_support::*;
use super::*;
use crate::crypto::{encrypt_asset_payload, seal_with_public_key};
use crate::transport::{
- EntityKeyPayload, ProfileAvatarPayload, ProfileCoverPayload, SpaceActorResponse,
+ ConversationChatSummaryResponse, EntityKeyPayload, MessageConversationActivity,
+ MessagePageResponse, MessageResponse, ProfileAvatarPayload, ProfileCoverPayload,
+ SpaceActorResponse,
};
use mockito::{Matcher, Server};
@@ -41,6 +43,200 @@ async fn account_api_sends_space_session_token_header() {
request.assert_async().await;
}
+#[tokio::test]
+async fn message_thread_keeps_content_failures_local_to_each_message() {
+ fn content(message: &crate::Message) -> &crate::MessageContent {
+ message.content.as_ref().unwrap().as_ref().unwrap()
+ }
+
+ let mut server = Server::new_async().await;
+ let ctx = test_account_ctx(&server.url());
+ let key = generate_key();
+ let encrypted_key =
+ b64::encode(&seal_with_public_key(&key, &test_public_key(&ctx)).expect("message key seal"));
+ let message = |id: &str, kind: &str, plaintext: &[u8]| MessageResponse {
+ message_id: id.into(),
+ kind: kind.into(),
+ sender_space_id: "space_friend".into(),
+ recipient_space_id: "space_owner_main".into(),
+ message_cipher: b64::encode(&encrypt_secretbox_payload(&key, plaintext).unwrap()),
+ encrypted_message_key: encrypted_key.clone(),
+ text: String::new(),
+ reply_post_id: None,
+ reply_message_id: None,
+ liked: false,
+ viewer_liked: false,
+ is_deleted: false,
+ created_at: "2026-09-23T00:00:00Z".into(),
+ updated_at: "2026-09-23T00:00:00Z".into(),
+ };
+ let readable = message(
+ "readable",
+ "regular",
+ br#"{"version":1,"kind":"regular","text":"hello","replyObjectKey":"photo"}"#,
+ );
+ let poke = message(
+ "poke",
+ "regular",
+ br#"{"version":1,"kind":"poke","text":"Poked"}"#,
+ );
+ let mut event = message("event", "post_like", b"");
+ event.text = "Liked your post".into();
+ let mut deleted = message("deleted", "regular", b"");
+ deleted.is_deleted = true;
+ let corrupt = message("corrupt", "regular", b"not-json");
+ let page = MessagePageResponse {
+ items: vec![readable.clone(), poke, event, deleted, corrupt, readable],
+ next_cursor: "next".into(),
+ };
+ let request = server
+ .mock(
+ "GET",
+ "/spaces/space_owner_main/friends/space_friend/messages",
+ )
+ .with_body(serde_json::to_string(&page).unwrap())
+ .create_async()
+ .await;
+
+ let opened = ctx
+ .list_message_thread("space_owner_main", "space_friend", None, None)
+ .await
+ .unwrap();
+ assert_eq!(opened.next_cursor, "next");
+ assert_eq!(opened.items.len(), 6);
+ assert_eq!(content(&opened.items[0]).text, "hello");
+ assert_eq!(
+ content(&opened.items[0]).reply_object_key.as_deref(),
+ Some("photo")
+ );
+ assert_eq!(opened.items[1].kind, "poke");
+ assert_eq!(content(&opened.items[1]).text, "Poked");
+ assert_eq!(opened.items[2].kind, "post_like");
+ assert_eq!(content(&opened.items[2]).text, "Liked your post");
+ assert!(opened.items[3].content.as_ref().unwrap().is_none());
+ assert!(matches!(
+ &opened.items[4].content,
+ Err(Error::InvalidInput(_))
+ ));
+ assert_eq!(content(&opened.items[5]).text, "hello");
+ request.assert_async().await;
+}
+
+#[tokio::test]
+async fn unread_poke_uses_latest_activity_kind() {
+ let server = Server::new_async().await;
+ let ctx = test_account_ctx(&server.url());
+ let activity = MessageConversationActivity {
+ id: "activity-1".into(),
+ activity_type: "message".into(),
+ kind: "poke".into(),
+ created_at: "2026-08-01T00:00:00Z".into(),
+ outgoing: false,
+ message_id: Some("message-1".into()),
+ sender_space_id: "space_friend".into(),
+ recipient_space_id: "space_owner_main".into(),
+ message_cipher: String::new(),
+ encrypted_message_key: String::new(),
+ reply_message_id: None,
+ post_id: None,
+ post_space_id: None,
+ };
+ let mut unread = activity.clone();
+ unread.kind = "regular".into();
+ let summary = ctx
+ .open_conversation_summary(
+ "space_owner_main",
+ ConversationChatSummaryResponse {
+ latest_activity: activity,
+ unread_activities: vec![unread],
+ },
+ )
+ .await
+ .unwrap();
+
+ assert_eq!(summary.unread_activities[0].kind, "poke");
+}
+
+#[tokio::test]
+async fn conversation_activities_open_content_and_preserve_server_kind() {
+ let server = Server::new_async().await;
+ let ctx = test_account_ctx(&server.url());
+ let key = generate_key();
+ let encrypted_key = b64::encode(&seal_with_public_key(&key, &test_public_key(&ctx)).unwrap());
+ for (server_kind, payload_kind, expected_kind) in [
+ ("regular", "poke", "poke"),
+ ("regular", "post_like", "regular"),
+ ("post_reply", "poke", "post_reply"),
+ ] {
+ let plaintext = serde_json::to_vec(&json!({
+ "version": 1,
+ "kind": payload_kind,
+ "text": "hello",
+ "replyObjectKey": "photo",
+ }))
+ .unwrap();
+ let activity = MessageConversationActivity {
+ id: "activity-1".into(),
+ activity_type: "message".into(),
+ kind: server_kind.into(),
+ created_at: "2026-08-01T00:00:00Z".into(),
+ outgoing: false,
+ message_id: Some("message-1".into()),
+ sender_space_id: "space_friend".into(),
+ recipient_space_id: "space_owner_main".into(),
+ message_cipher: b64::encode(&encrypt_secretbox_payload(&key, &plaintext).unwrap()),
+ encrypted_message_key: encrypted_key.clone(),
+ reply_message_id: None,
+ post_id: None,
+ post_space_id: None,
+ };
+ let summary = ctx
+ .open_conversation_summary(
+ "space_owner_main",
+ ConversationChatSummaryResponse {
+ latest_activity: activity,
+ unread_activities: vec![],
+ },
+ )
+ .await
+ .unwrap();
+ assert_eq!(summary.latest_activity.kind, expected_kind);
+ let content = summary.latest_activity.content.unwrap().unwrap();
+ assert_eq!(content.text, "hello");
+ assert_eq!(content.reply_object_key.as_deref(), Some("photo"));
+ }
+
+ let activity = MessageConversationActivity {
+ id: "corrupt".into(),
+ activity_type: "message".into(),
+ kind: "regular".into(),
+ created_at: "2026-08-01T00:00:00Z".into(),
+ outgoing: false,
+ message_id: Some("message-2".into()),
+ sender_space_id: "space_friend".into(),
+ recipient_space_id: "space_owner_main".into(),
+ message_cipher: b64::encode(&encrypt_secretbox_payload(&key, b"not-json").unwrap()),
+ encrypted_message_key: encrypted_key,
+ reply_message_id: None,
+ post_id: None,
+ post_space_id: None,
+ };
+ let summary = ctx
+ .open_conversation_summary(
+ "space_owner_main",
+ ConversationChatSummaryResponse {
+ latest_activity: activity,
+ unread_activities: vec![],
+ },
+ )
+ .await
+ .unwrap();
+ assert!(matches!(
+ summary.latest_activity.content,
+ Err(Error::InvalidInput(_))
+ ));
+}
+
#[tokio::test]
async fn get_space_root_key_returns_context_space_root_key() {
let server = Server::new_async().await;
@@ -1485,14 +1681,15 @@ async fn message_actions_use_message_endpoints() {
Matcher::Regex("\"recipientEncryptedMessageKey\":\"[^\"]+\"".into()),
]))
.with_status(200)
- .with_body(
+ .with_body_from_request(|request| {
+ let body: serde_json::Value = serde_json::from_slice(request.body().unwrap()).unwrap();
json!({
"messageId": "wmsg_reply",
"kind": "regular",
"senderSpaceId": "space_owner_main",
"recipientSpaceId": "space_friend",
- "messageCipher": "cipher",
- "encryptedMessageKey": "key",
+ "messageCipher": body["messageCipher"],
+ "encryptedMessageKey": body["senderEncryptedMessageKey"],
"replyMessageId": "wmsg_parent",
"liked": false,
"viewerLiked": false,
@@ -1500,8 +1697,9 @@ async fn message_actions_use_message_endpoints() {
"createdAt": "2026-04-16T00:00:00Z",
"updatedAt": "2026-04-16T00:00:00Z"
})
- .to_string(),
- )
+ .to_string()
+ .into_bytes()
+ })
.create_async()
.await;
let like = server
@@ -1577,20 +1775,24 @@ async fn poke_message_requests_special_notification() {
Matcher::Regex("\"recipientEncryptedMessageKey\":\"[^\"]+\"".into()),
]))
.with_status(200)
- .with_body(
+ .with_body_from_request(|request| {
+ let body: serde_json::Value = serde_json::from_slice(request.body().unwrap()).unwrap();
json!({
"messageId": "wmsg_poke",
"kind": "regular",
"senderSpaceId": "space_owner_main",
"recipientSpaceId": "space_friend",
+ "messageCipher": body["messageCipher"],
+ "encryptedMessageKey": body["senderEncryptedMessageKey"],
"liked": false,
"viewerLiked": false,
"isDeleted": false,
"createdAt": "2026-04-16T00:00:00Z",
"updatedAt": "2026-04-16T00:00:00Z"
})
- .to_string(),
- )
+ .to_string()
+ .into_bytes()
+ })
.create_async()
.await;
@@ -1600,6 +1802,7 @@ async fn poke_message_requests_special_notification() {
.expect("poke should be sent");
assert_eq!(message.message_id, "wmsg_poke");
+ assert_eq!(message.kind, "poke");
friends.assert_async().await;
poke.assert_async().await;
}
@@ -1684,12 +1887,9 @@ async fn post_replies_encrypt_photo_references_and_reject_other_photos() {
.reply_to_post("space_owner_main", "space_friend", 42, "Coo", object_key)
.await
.unwrap();
- let decrypted = ctx
- .decrypt_message("space_owner_main", &response)
- .await
- .unwrap();
- assert_eq!(decrypted.payload.text, "Coo");
- assert_eq!(decrypted.payload.reply_object_key.as_deref(), object_key);
+ let content = response.content.unwrap().unwrap();
+ assert_eq!(content.text, "Coo");
+ assert_eq!(content.reply_object_key.as_deref(), object_key);
}
let error = ctx
.reply_to_post(
@@ -1700,7 +1900,8 @@ async fn post_replies_encrypt_photo_references_and_reject_other_photos() {
Some("unrelated"),
)
.await
- .unwrap_err();
+ .err()
+ .unwrap();
assert!(matches!(error, Error::InvalidInput(_)));
owned.assert_async().await;
post.assert_async().await;
diff --git a/rust/crates/space/src/lib.rs b/rust/crates/space/src/lib.rs
index d90a72f5e6..3b2918f2c6 100644
--- a/rust/crates/space/src/lib.rs
+++ b/rust/crates/space/src/lib.rs
@@ -13,16 +13,17 @@ pub use client::{
};
pub use error::{Error, Result};
pub use models::{
- CreatedSpace, CreatedSpaceLink, DecryptedFriendShare, DecryptedMessage, DecryptedSpaceProfile,
- HydratedKeys, MessagePayload, OpenAccountSpaceCtxInput, OpenSpaceLinkCtxInput, Post, PostAsset,
- PostContent, PostObjectMetadata, PostPage, PostPhoto, SpaceActor, SpaceProfile,
+ ConversationChatSummary, Conversations, CreatedSpace, CreatedSpaceLink, DecryptedFriendShare,
+ DecryptedSpaceProfile, HydratedKeys, Message, MessageActivity, MessageContent, MessagePage,
+ MessagePayload, OpenAccountSpaceCtxInput, OpenSpaceLinkCtxInput, Post, PostAsset, PostContent,
+ PostObjectMetadata, PostPage, PostPhoto, SpaceActor, SpaceProfile,
};
pub use transport::{
ConversationChatSummaryResponse, ConversationsResponse, EntityKeyPayload,
FriendRelationshipResponse, FriendShareResponse, FriendStatusResponse, LikeMessageResponse,
- LikePostResponse, MessageConversationActivity, MessagePage, MessageResponse, PostObjectPayload,
- PresignUploadResponse, ProfileAvatarPayload, ProfileAvatarResponse, ProfileCoverPayload,
- ProfileCoverResponse, SpaceActorResponse, SpaceFriendRequestResponse, SpaceFriendResponse,
- SpaceKeyResponse, SpaceKeyVersionResponse, SpaceLookupResponse, SpaceProfileResponse,
- SpaceSentFriendRequestResponse, SpaceUnreadStatusResponse,
+ LikePostResponse, MessageConversationActivity, MessagePageResponse, MessageResponse,
+ PostObjectPayload, PresignUploadResponse, ProfileAvatarPayload, ProfileAvatarResponse,
+ ProfileCoverPayload, ProfileCoverResponse, SpaceActorResponse, SpaceFriendRequestResponse,
+ SpaceFriendResponse, SpaceKeyResponse, SpaceKeyVersionResponse, SpaceLookupResponse,
+ SpaceProfileResponse, SpaceSentFriendRequestResponse, SpaceUnreadStatusResponse,
};
diff --git a/rust/crates/space/src/models.rs b/rust/crates/space/src/models.rs
index 19bbe5e15d..b8f52e9d82 100644
--- a/rust/crates/space/src/models.rs
+++ b/rust/crates/space/src/models.rs
@@ -1,8 +1,13 @@
+use std::collections::BTreeMap;
+
use serde::{Deserialize, Serialize};
use zeroize::ZeroizeOnDrop;
use crate::Result;
-use crate::transport::{ProfileAvatarResponse, ProfileCoverResponse, SpaceKeyResponse};
+use crate::transport::{
+ ProfileAvatarResponse, ProfileCoverResponse, SpaceFriendRequestResponse, SpaceFriendResponse,
+ SpaceKeyResponse,
+};
#[derive(Clone)]
pub struct OpenAccountSpaceCtxInput {
@@ -130,6 +135,54 @@ pub struct PostPage {
pub next_cursor: String,
}
+pub struct Message {
+ pub message_id: String,
+ pub kind: String,
+ pub sender_space_id: String,
+ pub recipient_space_id: String,
+ pub content: Result<Option<MessageContent>>,
+ pub reply_post_id: Option<i64>,
+ pub reply_message_id: Option<String>,
+ pub liked: bool,
+ pub viewer_liked: bool,
+ pub created_at: String,
+ pub updated_at: String,
+}
+
+pub struct MessageContent {
+ pub text: String,
+ pub reply_object_key: Option<String>,
+}
+
+pub struct MessagePage {
+ pub items: Vec<Message>,
+ pub next_cursor: String,
+}
+
+pub struct MessageActivity {
+ pub id: String,
+ pub activity_type: String,
+ pub kind: String,
+ pub created_at: String,
+ pub outgoing: bool,
+ pub message_id: Option<String>,
+ pub content: Result<Option<MessageContent>>,
+ pub post_id: Option<i64>,
+ pub post_space_id: Option<String>,
+}
+
+pub struct ConversationChatSummary {
+ pub latest_activity: MessageActivity,
+ pub unread_activities: Vec<MessageActivity>,
+}
+
+pub struct Conversations {
+ pub friends: Vec<SpaceFriendResponse>,
+ pub pending_requests: Vec<SpaceFriendRequestResponse>,
+ pub chat_summaries: BTreeMap<String, ConversationChatSummary>,
+ pub latest_post_created_at: Option<String>,
+}
+
#[derive(Debug, Clone, Default, Serialize, Deserialize, PartialEq, Eq)]
#[serde(rename_all = "camelCase")]
pub struct PostObjectMetadata {
@@ -157,12 +210,6 @@ pub struct MessagePayload {
pub reply_object_key: Option<String>,
}
-#[derive(Clone)]
-pub struct DecryptedMessage {
- pub message_key: Vec<u8>,
- pub payload: MessagePayload,
-}
-
#[derive(Clone, ZeroizeOnDrop)]
pub struct DecryptedFriendShare {
pub friend: String,
diff --git a/rust/crates/space/src/transport.rs b/rust/crates/space/src/transport.rs
index 995d8b1311..e20441789f 100644
--- a/rust/crates/space/src/transport.rs
+++ b/rust/crates/space/src/transport.rs
@@ -173,7 +173,7 @@ pub struct MessageResponse {
#[derive(Debug, Clone, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
-pub struct MessagePage {
+pub struct MessagePageResponse {
pub items: Vec<MessageResponse>,
#[serde(default)]
pub next_cursor: String,
diff --git a/rust/crates/space/tests/space.rs b/rust/crates/space/tests/space.rs
index 2e6886e2fb..25d24be207 100644
--- a/rust/crates/space/tests/space.rs
+++ b/rust/crates/space/tests/space.rs
@@ -388,11 +388,10 @@ async fn space_unfriend_revokes_reciprocal_account_access_suite(endpoint: &str)
.iter()
.find(|message| message.message_id == direct_message.message_id)
.expect("direct message should be in owner thread before unfriend");
- let decrypted_message = owner_ctx
- .decrypt_message(&owner_space.space_id, owner_thread_message)
- .await
- .expect("owner should decrypt direct message before unfriend");
- assert_eq!(decrypted_message.payload.text, "hello before unfriend");
+ assert!(matches!(
+ &owner_thread_message.content,
+ Ok(Some(content)) if content.text == "hello before unfriend"
+ ));
owner_ctx
.like_message(&owner_space.space_id, &direct_message.message_id, true)
.await
@@ -465,11 +464,10 @@ async fn space_unfriend_revokes_reciprocal_account_access_suite(endpoint: &str)
.iter()
.find(|message| message.message_id == direct_message.message_id)
.expect("direct message should remain in owner thread after unfriend");
- let decrypted_message = owner_ctx
- .decrypt_message(&owner_space.space_id, owner_thread_message)
- .await
- .expect("owner should still decrypt old direct message after unfriend");
- assert_eq!(decrypted_message.payload.text, "hello before unfriend");
+ assert!(matches!(
+ &owner_thread_message.content,
+ Ok(Some(content)) if content.text == "hello before unfriend"
+ ));
space::assert_invalid_input_contains(
friend_ctx
.send_message(&friend_space.space_id, &owner_space.space_id, "should fail")
diff --git a/web/apps/space/src/services/space.ts b/web/apps/space/src/services/space.ts
index 9f6ed59ca5..0f1cf498ed 100644
--- a/web/apps/space/src/services/space.ts
+++ b/web/apps/space/src/services/space.ts
@@ -1300,14 +1300,7 @@ export const loadCurrentMessageConversations = async (
? messageActivityFromSpaceActivity(summary.latestActivity)
: undefined;
const unreadActivities = summary
- ? summary.unreadActivities
- .map(messageActivityFromSpaceActivity)
- .map((activity) =>
- activity.id == latestActivity?.id &&
- isPokeMessageActivity(latestActivity)
- ? { ...activity, kind: "poke" as const }
- : activity,
- )
+ ? summary.unreadActivities.map(messageActivityFromSpaceActivity)
: [];
const unreadCount =
messageConversationUnreadCount(unreadActivities);