π End-to-end encrypted cloud for everything.
Dart 2faandroidauthye2eeencryptionend-to-end-encryptionfluttergolanggoogle-photosgoogle-photos-alternativeiosopensourcephotosprivacyprivacy-toolstypescriptzero-knowledge
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.rsindex 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) -> MessageRrecipient_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.rsindex 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.rsindex 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.rsindex 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.rsindex 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.rsindex 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.rsindex 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.tsindex 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);