π End-to-end encrypted cloud for everything.
Dart 2faandroidauthye2eeencryptionend-to-end-encryptionfluttergolanggoogle-photosgoogle-photos-alternativeiosopensourcephotosprivacyprivacy-toolstypescriptzero-knowledge
Add revocable Space profile links
Anand Baburajanf151bffc6e68
diff --git a/rust/bindings/wasm/space/src/space.rs b/rust/bindings/wasm/space/src/space.rsindex 10477560cf..bb90dc1459 100644--- a/rust/bindings/wasm/space/src/space.rs+++ b/rust/bindings/wasm/space/src/space.rs@@ -5,9 +5,9 @@ use std::collections::BTreeMap;use ente_core::{b64, http};use ente_space::{AccountSpaceCtx, CreatedSpace, DecryptedMessage, DecryptedPost, DecryptedSpaceProfile,- MessageConversationActivity, MessageResponse, OpenAccountSpaceCtxInput, PostPhotoAssetOptions,- PostResponse, ProfileAvatarResponse, ProfileCoverResponse, SpaceActorResponse,- SpaceKeyResponse,+ MessageConversationActivity, MessageResponse, OpenAccountSpaceCtxInput, OpenSpaceLinkCtxInput,+ PostPhotoAssetOptions, PostResponse, ProfileAvatarResponse, ProfileCoverResponse,+ SpaceActorResponse, SpaceKeyResponse, SpaceLinkCtx,};use serde::{Deserialize, Serialize};use serde_wasm_bindgen as swb;@@ -93,6 +93,17 @@ struct OpenAccountSpaceCtxJsInput {client_version: Option<String>,}+#[derive(Deserialize)]+#[serde(rename_all = "camelCase")]+struct OpenSpaceLinkCtxJsInput {+ base_url: String,+ space_username: String,+ access_key: String,+ user_agent: Option<String>,+ client_package: Option<String>,+ client_version: Option<String>,+}+#[derive(Serialize)]#[serde(rename_all = "camelCase")]struct CreatedSpaceJs {@@ -100,6 +111,14 @@ struct CreatedSpaceJs {space_slug: String,}+#[derive(Serialize)]+#[serde(rename_all = "camelCase")]+struct CreatedSpaceLinkJs {+ space_id: String,+ space_slug: String,+ access_key: String,+}+#[derive(Serialize)]#[serde(rename_all = "camelCase")]struct SpaceProfileJs {@@ -107,6 +126,8 @@ struct SpaceProfileJs {space_slug: String,version: i32,friends: i64,+ #[serde(skip_serializing_if = "Option::is_none")]+ posts: Option<i64>,profile: String,avatar: Option<ProfileAvatarResponse>,cover: Option<ProfileCoverResponse>,@@ -278,6 +299,7 @@ fn profile_to_js(value: DecryptedSpaceProfile) -> SpaceProfileJs {space_slug: value.space_slug,version: value.version,friends: value.friends,+ posts: None,profile,avatar: value.avatar,cover: value.cover,@@ -392,6 +414,21 @@ async fn account_post_page_to_js(})}+fn link_post_to_js(post: PostResponse, decrypted: DecryptedPost) -> Result<PostJs, WasmSpaceError> {+ Ok(PostJs {+ post_id: post.post_id,+ space_id: post.space_id,+ space_slug: post.space_slug,+ author: public_actor_to_js(post.author)?,+ caption: optional_utf8_field(decrypted.caption_plaintext, "caption").unwrap_or(None),+ encrypted_post_key: post.encrypted_post_key,+ key_version: post.key_version,+ objects: post_objects_to_js(Some(&decrypted.post_key), post.objects),+ created_at: post.created_at,+ viewer_liked: false,+ })+}+async fn account_message_to_js(message: MessageResponse,decrypted: DecryptedMessage,@@ -515,6 +552,95 @@ pub async fn space_open_account_ctx(Ok(SpaceAccountCtxHandle { inner: ctx })}+/// Open a read-only Space context from a username and fragment secret.+#[wasm_bindgen(js_name = spaceOpenLinkCtx)]+pub async fn space_open_link_ctx(input: JsValue) -> Result<SpaceLinkCtxHandle, WasmSpaceError> {+ let input: OpenSpaceLinkCtxJsInput = swb::from_value(input)?;+ let inner = SpaceLinkCtx::open(OpenSpaceLinkCtxInput {+ base_url: input.base_url,+ space_slug: input.space_username,+ access_key: input.access_key,+ user_agent: input.user_agent,+ client_package: input.client_package,+ client_version: input.client_version,+ })+ .await?;+ Ok(SpaceLinkCtxHandle { inner })+}++/// Handle to a read-only Space link.+#[wasm_bindgen]+pub struct SpaceLinkCtxHandle {+ inner: SpaceLinkCtx,+}++#[wasm_bindgen]+impl SpaceLinkCtxHandle {+ /// Return the decrypted profile bundled into this validated link.+ #[wasm_bindgen(js_name = getProfile)]+ pub fn get_profile(&self) -> Result<JsValue, WasmSpaceError> {+ let mut profile = profile_to_js(self.inner.profile().clone());+ profile.posts = Some(self.inner.posts());+ swb::to_value(&profile).map_err(Into::into)+ }++ /// List and decrypt posts exposed by this link.+ #[wasm_bindgen(js_name = listPosts)]+ pub async fn list_posts(&self) -> Result<JsValue, WasmSpaceError> {+ let page = self.inner.list_posts().await?;+ let mut items = Vec::with_capacity(page.items.len());+ for post in page.items {+ let decrypted = self.inner.decrypt_post(&post)?;+ items.push(link_post_to_js(post, decrypted)?);+ }+ swb::to_value(&PostPageJs {+ items,+ next_cursor: page.next_cursor,+ })+ .map_err(Into::into)+ }++ /// Download and decrypt one post photo.+ #[wasm_bindgen(js_name = downloadPostAsset)]+ pub async fn download_post_asset(+ &self,+ encrypted_post_key: String,+ key_version: i32,+ object_key: String,+ ) -> Result<Vec<u8>, WasmSpaceError> {+ self.inner+ .download_post_asset(&encrypted_post_key, key_version, &object_key)+ .await+ .map_err(Into::into)+ }++ /// Download and decrypt the linked Space avatar.+ #[wasm_bindgen(js_name = downloadAvatar)]+ pub async fn download_avatar(+ &self,+ object_id: String,+ key_version: i32,+ ) -> Result<Vec<u8>, WasmSpaceError> {+ self.inner+ .download_profile_asset("avatar", &object_id, key_version)+ .await+ .map_err(Into::into)+ }++ /// Download and decrypt the linked Space cover.+ #[wasm_bindgen(js_name = downloadCover)]+ pub async fn download_cover(+ &self,+ object_id: String,+ key_version: i32,+ ) -> Result<Vec<u8>, WasmSpaceError> {+ self.inner+ .download_profile_asset("cover", &object_id, key_version)+ .await+ .map_err(Into::into)+ }+}+/// Handle to an authenticated space context.#[wasm_bindgen]pub struct SpaceAccountCtxHandle {@@ -523,6 +649,33 @@ pub struct SpaceAccountCtxHandle {#[wasm_bindgen]impl SpaceAccountCtxHandle {+ /// Return the active Space link or create it lazily.+ #[wasm_bindgen(js_name = getOrCreateSpaceLink)]+ pub async fn get_or_create_space_link(+ &self,+ space_id: String,+ ) -> Result<JsValue, WasmSpaceError> {+ let value = self.inner.get_or_create_space_link(&space_id).await?;+ swb::to_value(&CreatedSpaceLinkJs {+ space_id: value.space_id,+ space_slug: value.space_slug,+ access_key: value.access_key,+ })+ .map_err(Into::into)+ }++ /// Replace the current Space link with a new fragment secret.+ #[wasm_bindgen(js_name = rotateSpaceLink)]+ pub async fn rotate_space_link(&self, space_id: String) -> Result<JsValue, WasmSpaceError> {+ let value = self.inner.rotate_space_link(&space_id).await?;+ swb::to_value(&CreatedSpaceLinkJs {+ space_id: value.space_id,+ space_slug: value.space_slug,+ access_key: value.access_key,+ })+ .map_err(Into::into)+ }+/// Create a space with an encrypted JSON profile payload.#[wasm_bindgen(js_name = createSpace)]pub async fn create_space(diff --git a/rust/space/src/client/keys.rs b/rust/space/src/client/keys.rsindex 373ec497aa..c30cb932f5 100644--- a/rust/space/src/client/keys.rs+++ b/rust/space/src/client/keys.rs@@ -105,6 +105,7 @@ impl AccountSpaceCtx {};let next_space_key = generate_key();let space_root_key = self.get_or_create_space_root_key().await?;+ let link_encrypted_space_key = self.active_link_wrapper(space_id, &next_space_key).await?;let request = RotateSpaceKeyRequest {key_version: current.key_version,root_wrapped_space_key: b64::encode(&encrypt_secretbox_payload(@@ -119,6 +120,7 @@ impl AccountSpaceCtx {&next_space_key,&next_profile,)?),+ link_encrypted_space_key,};let path = format!("/spaces/{space_id}/rotate");let response = selfdiff --git a/rust/space/src/client/links.rs b/rust/space/src/client/links.rsnew file mode 100644index 0000000000..8bf15d89c7--- /dev/null+++ b/rust/space/src/client/links.rs@@ -0,0 +1,514 @@+use std::collections::BTreeMap;++use ente_core::{+ b64,+ crypto::{self, Key, Salt, argon, kdf},+ http::Api,+};++use super::{AccountSpaceCtx, build_api, build_space_key_history_map, decrypt_space_profile};+use crate::{+ crypto::{decrypt_asset_payload, decrypt_secretbox_payload, encrypt_secretbox_payload},+ error::{Result, SpaceError},+ models::{CreatedSpaceLink, DecryptedPost, DecryptedSpaceProfile, OpenSpaceLinkCtxInput},+ transport::{+ AssetDownloadResponse, PostPage, PostResponse, SpaceKeyVersionResponse,+ SpaceLinkBootstrapResponse, SpaceLinkProfileResponse, SpaceLinkStatusResponse,+ SpaceLinkWriteRequest,+ },+};++const ACCESS_KEY_LENGTH: usize = 12;+const ACCESS_KEY_ALPHABET: &[u8] =+ b"0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz";+const AUTH_HEADER: &str = "X-Ente-Space-Link-Auth";+const AUTH_CONTEXT: &[u8; 8] = b"spacauth";+const WRAP_CONTEXT: &[u8; 8] = b"spacwrap";++struct DerivedLinkKeys {+ auth: Vec<u8>,+ wrap: Vec<u8>,+}++pub struct SpaceLinkCtx {+ api: Api,+ space_slug: String,+ auth_key: String,+ profile: DecryptedSpaceProfile,+ posts: i64,+ key_history: BTreeMap<i32, Vec<u8>>,+}++impl AccountSpaceCtx {+ pub async fn get_or_create_space_link(&self, space_id: &str) -> Result<CreatedSpaceLink> {+ let status = self.get_space_link_status(space_id).await?;+ if status.active {+ return self.created_link_from_status(status);+ }+ self.write_space_link(space_id, false).await+ }++ pub async fn rotate_space_link(&self, space_id: &str) -> Result<CreatedSpaceLink> {+ self.write_space_link(space_id, true).await+ }++ pub(crate) async fn active_link_wrapper(+ &self,+ space_id: &str,+ next_space_key: &[u8],+ ) -> Result<Option<String>> {+ let status = self.get_space_link_status(space_id).await?;+ if !status.active {+ return Ok(None);+ }+ let access_key = self.decrypt_link_access_key(&status)?;+ let keys = derive_link_keys(+ &access_key,+ &status.kdf_salt,+ status.kdf_mem_limit,+ status.kdf_ops_limit,+ )?;+ Ok(Some(b64::encode(&encrypt_secretbox_payload(+ &keys.wrap,+ next_space_key,+ )?)))+ }++ async fn get_space_link_status(&self, space_id: &str) -> Result<SpaceLinkStatusResponse> {+ let path = format!("/spaces/{space_id}/link");+ Ok(self+ .api()+ .get(&path)+ .send()+ .await?+ .error_for_status()?+ .json()+ .await?)+ }++ async fn write_space_link(&self, space_id: &str, rotate: bool) -> Result<CreatedSpaceLink> {+ let access = self+ .resolve_owned_space_access(space_id)+ .await?+ .ok_or_else(|| {+ SpaceError::InvalidInput(format!("space {space_id} is not owned by the account"))+ })?;+ let access_key = generate_access_key();+ let salt = Salt::generate();+ let keys = derive_link_keys_with_salt(&access_key, &salt, argon::Params::INTERACTIVE)?;+ let request = SpaceLinkWriteRequest {+ auth_key: b64::encode(&keys.auth),+ kdf_salt: b64::encode(salt.as_bytes()),+ kdf_mem_limit: argon::Params::INTERACTIVE.mem_limit,+ kdf_ops_limit: argon::Params::INTERACTIVE.ops_limit,+ key_version: access.key_version,+ encrypted_space_key: b64::encode(&encrypt_secretbox_payload(+ &keys.wrap,+ &access.space_key,+ )?),+ encrypted_access_key: b64::encode(&encrypt_secretbox_payload(+ self.space_root_key(),+ access_key.as_bytes(),+ )?),+ };+ let path = if rotate {+ format!("/spaces/{space_id}/link/rotate")+ } else {+ format!("/spaces/{space_id}/link")+ };+ let status: SpaceLinkStatusResponse = self+ .api()+ .post(&path)+ .json(&request)+ .send()+ .await?+ .error_for_status()?+ .json()+ .await?;+ if status.encrypted_access_key == request.encrypted_access_key {+ Ok(CreatedSpaceLink {+ space_id: status.space_id,+ space_slug: status.space_slug,+ access_key,+ })+ } else {+ self.created_link_from_status(status)+ }+ }++ fn created_link_from_status(+ &self,+ status: SpaceLinkStatusResponse,+ ) -> Result<CreatedSpaceLink> {+ let access_key = self.decrypt_link_access_key(&status)?;+ Ok(CreatedSpaceLink {+ space_id: status.space_id,+ space_slug: status.space_slug,+ access_key,+ })+ }++ fn decrypt_link_access_key(&self, status: &SpaceLinkStatusResponse) -> Result<String> {+ let encrypted = b64::decode(&status.encrypted_access_key)?;+ let plaintext = decrypt_secretbox_payload(self.space_root_key(), &encrypted)?;+ let access_key = String::from_utf8(plaintext).map_err(|error| {+ SpaceError::InvalidInput(format!("invalid link access key: {error}"))+ })?;+ validate_access_key(&access_key)?;+ Ok(access_key)+ }+}++impl SpaceLinkCtx {+ pub async fn open(input: OpenSpaceLinkCtxInput) -> Result<Self> {+ validate_access_key(&input.access_key)?;+ let space_slug = input.space_slug.trim().to_lowercase();+ if space_slug.is_empty() {+ return Err(SpaceError::InvalidInput(+ "space username is required".into(),+ ));+ }+ let api = build_api(+ &input.base_url,+ None,+ input.user_agent,+ input.client_package,+ input.client_version,+ )?;+ let prefix = format!("/space/public/by-slug/{space_slug}/link");+ let bootstrap: SpaceLinkBootstrapResponse = api+ .get(&format!("{prefix}/bootstrap"))+ .send()+ .await?+ .error_for_status()?+ .json()+ .await?;+ let keys = derive_link_keys(+ &input.access_key,+ &bootstrap.kdf_salt,+ bootstrap.kdf_mem_limit,+ bootstrap.kdf_ops_limit,+ )?;+ let auth_key = b64::encode(&keys.auth);+ let fetch_profile = async {+ Ok::<SpaceLinkProfileResponse, SpaceError>(+ api.get(&format!("{prefix}/profile"))+ .header(AUTH_HEADER, &auth_key)+ .send()+ .await?+ .error_for_status()?+ .json()+ .await?,+ )+ };+ let fetch_versions = async {+ Ok::<Vec<SpaceKeyVersionResponse>, SpaceError>(+ api.get(&format!("{prefix}/versions"))+ .header(AUTH_HEADER, &auth_key)+ .send()+ .await?+ .error_for_status()?+ .json()+ .await?,+ )+ };+ let (profile_response, versions): (SpaceLinkProfileResponse, Vec<SpaceKeyVersionResponse>) =+ futures_util::try_join!(fetch_profile, fetch_versions)?;+ let encrypted_space_key = b64::decode(&profile_response.encrypted_space_key)?;+ let space_key = decrypt_secretbox_payload(&keys.wrap, &encrypted_space_key)?;+ let profile = decrypt_space_profile(&profile_response.profile, &space_key)?;+ let key_history =+ build_space_key_history_map(profile_response.key_version, &space_key, &versions)?;+ Ok(Self {+ api,+ space_slug,+ auth_key,+ profile,+ posts: profile_response.posts,+ key_history,+ })+ }++ pub fn profile(&self) -> &DecryptedSpaceProfile {+ &self.profile+ }++ pub fn posts(&self) -> i64 {+ self.posts+ }++ pub async fn list_posts(&self) -> Result<PostPage> {+ Ok(self+ .api+ .get(&format!("{}/posts", self.prefix()))+ .header(AUTH_HEADER, &self.auth_key)+ .send()+ .await?+ .error_for_status()?+ .json()+ .await?)+ }++ pub fn decrypt_post(&self, post: &PostResponse) -> Result<DecryptedPost> {+ let space_key = self+ .key_history+ .get(&post.key_version)+ .ok_or_else(|| SpaceError::InvalidInput("missing space key for post".into()))?;+ let post_key =+ decrypt_secretbox_payload(space_key, &b64::decode(&post.encrypted_post_key)?)?;+ let caption_plaintext = if post.caption_cipher.is_empty() {+ None+ } else {+ Some(decrypt_secretbox_payload(+ &post_key,+ &b64::decode(&post.caption_cipher)?,+ )?)+ };+ Ok(DecryptedPost {+ post_key,+ caption_plaintext,+ })+ }++ pub async fn download_post_asset(+ &self,+ encrypted_post_key: &str,+ key_version: i32,+ object_key: &str,+ ) -> Result<Vec<u8>> {+ let space_key = self+ .key_history+ .get(&key_version)+ .ok_or_else(|| SpaceError::InvalidInput("missing space key for post".into()))?;+ let post_key = decrypt_secretbox_payload(space_key, &b64::decode(encrypted_post_key)?)?;+ self.download_asset(vec![("objectKey", object_key.to_owned())], &post_key)+ .await+ }++ pub async fn download_profile_asset(+ &self,+ asset_type: &str,+ object_id: &str,+ key_version: i32,+ ) -> Result<Vec<u8>> {+ let space_key = self+ .key_history+ .get(&key_version)+ .ok_or_else(|| SpaceError::InvalidInput("missing space key for profile".into()))?;+ self.download_asset(+ vec![+ ("assetType", asset_type.to_owned()),+ ("objectID", object_id.to_owned()),+ ],+ space_key,+ )+ .await+ }++ async fn download_asset(&self, query: Vec<(&str, String)>, key: &[u8]) -> Result<Vec<u8>> {+ let download: AssetDownloadResponse = self+ .api+ .get(&format!("{}/assets/redirect", self.prefix()))+ .query(&query)+ .header(AUTH_HEADER, &self.auth_key)+ .send()+ .await?+ .error_for_status()?+ .json()+ .await?;+ let encrypted = self+ .api+ .http()+ .get(&download.url)+ .send()+ .await?+ .error_for_status()?+ .bytes()+ .await?;+ decrypt_asset_payload(key, &encrypted)+ }++ fn prefix(&self) -> String {+ format!("/space/public/by-slug/{}/link", self.space_slug)+ }+}++fn validate_access_key(access_key: &str) -> Result<()> {+ if access_key.len() == ACCESS_KEY_LENGTH+ && access_key.bytes().all(|byte| byte.is_ascii_alphanumeric())+ {+ Ok(())+ } else {+ Err(SpaceError::InvalidInput(+ "space link access key must be 12 alphanumeric characters".into(),+ ))+ }+}++fn generate_access_key() -> String {+ let threshold = 256 - (256 % ACCESS_KEY_ALPHABET.len());+ let mut access_key = String::with_capacity(ACCESS_KEY_LENGTH);+ while access_key.len() < ACCESS_KEY_LENGTH {+ for byte in crypto::random_bytes(ACCESS_KEY_LENGTH) {+ let byte = usize::from(byte);+ if byte >= threshold {+ continue;+ }+ access_key.push(char::from(+ ACCESS_KEY_ALPHABET[byte % ACCESS_KEY_ALPHABET.len()],+ ));+ if access_key.len() == ACCESS_KEY_LENGTH {+ break;+ }+ }+ }+ access_key+}++fn derive_link_keys(+ access_key: &str,+ encoded_salt: &str,+ mem_limit: u32,+ ops_limit: u32,+) -> Result<DerivedLinkKeys> {+ if mem_limit != argon::Params::INTERACTIVE.mem_limit+ || ops_limit != argon::Params::INTERACTIVE.ops_limit+ {+ return Err(SpaceError::InvalidInput(+ "unsupported space link KDF parameters".into(),+ ));+ }+ let salt_bytes = b64::decode(encoded_salt)?;+ let salt = Salt::try_from_slice(&salt_bytes)?;+ derive_link_keys_with_salt(+ access_key,+ &salt,+ argon::Params {+ mem_limit,+ ops_limit,+ },+ )+}++fn derive_link_keys_with_salt(+ access_key: &str,+ salt: &Salt,+ params: argon::Params,+) -> Result<DerivedLinkKeys> {+ validate_access_key(access_key)?;+ let root = argon::derive_key(access_key, salt, params)?;+ Ok(DerivedLinkKeys {+ auth: kdf::derive_subkey(&root, Key::BYTES, 1, AUTH_CONTEXT)?.to_vec(),+ wrap: kdf::derive_subkey(&root, Key::BYTES, 2, WRAP_CONTEXT)?.to_vec(),+ })+}++#[cfg(test)]+mod tests {+ use super::*;+ use mockito::Server;+ use serde_json::json;++ #[test]+ fn generated_access_keys_are_valid() {+ for _ in 0..100 {+ validate_access_key(&generate_access_key()).unwrap();+ }+ }++ #[test]+ fn auth_and_wrap_keys_are_separate_and_stable() {+ let salt = Salt::from_bytes([7; Salt::BYTES]);+ let first =+ derive_link_keys_with_salt("5d2a9WhmD2NU", &salt, argon::Params::INTERACTIVE).unwrap();+ let second =+ derive_link_keys_with_salt("5d2a9WhmD2NU", &salt, argon::Params::INTERACTIVE).unwrap();+ assert_eq!(first.auth, second.auth);+ assert_eq!(first.wrap, second.wrap);+ assert_ne!(first.auth, first.wrap);+ }++ #[tokio::test]+ async fn public_link_opens_with_derived_auth_and_decrypts_profile() {+ let mut server = Server::new_async().await;+ let access_key = "5d2a9WhmD2NU";+ let salt = Salt::from_bytes([9; Salt::BYTES]);+ let keys =+ derive_link_keys_with_salt(access_key, &salt, argon::Params::INTERACTIVE).unwrap();+ let space_key = vec![4; Key::BYTES];+ let encrypted_space_key =+ b64::encode(&encrypt_secretbox_payload(&keys.wrap, &space_key).unwrap());+ let profile = br#"{"fullName":"Alice"}"#;+ let encrypted_profile =+ b64::encode(&encrypt_secretbox_payload(&space_key, profile).unwrap());+ let auth = b64::encode(&keys.auth);+ let prefix = "/space/public/by-slug/alice/link";++ let bootstrap = server+ .mock("GET", format!("{prefix}/bootstrap").as_str())+ .with_status(200)+ .with_body(+ json!({+ "kdfSalt": b64::encode(salt.as_bytes()),+ "kdfMemLimit": argon::Params::INTERACTIVE.mem_limit,+ "kdfOpsLimit": argon::Params::INTERACTIVE.ops_limit,+ })+ .to_string(),+ )+ .create_async()+ .await;+ let profile_request = server+ .mock("GET", format!("{prefix}/profile").as_str())+ .match_header("x-ente-space-link-auth", auth.as_str())+ .with_status(200)+ .with_body(+ json!({+ "encryptedSpaceKey": encrypted_space_key,+ "keyVersion": 1,+ "posts": 3,+ "profile": {+ "spaceId": "space-alice",+ "spaceSlug": "alice",+ "version": 1,+ "friends": 2,+ "encryptedProfile": encrypted_profile,+ "updatedAt": "2026-07-26T00:00:00Z"+ }+ })+ .to_string(),+ )+ .create_async()+ .await;+ let versions = server+ .mock("GET", format!("{prefix}/versions").as_str())+ .match_header("x-ente-space-link-auth", auth.as_str())+ .with_status(200)+ .with_body(+ json!([{+ "version": 1,+ "createdAt": "2026-07-26T00:00:00Z"+ }])+ .to_string(),+ )+ .create_async()+ .await;++ let ctx = SpaceLinkCtx::open(OpenSpaceLinkCtxInput {+ base_url: server.url(),+ space_slug: "Alice".to_owned(),+ access_key: access_key.to_owned(),+ user_agent: None,+ client_package: None,+ client_version: None,+ })+ .await+ .unwrap();++ assert_eq!(ctx.profile().profile, profile);+ assert_eq!(ctx.profile().friends, 2);+ assert_eq!(ctx.posts(), 3);+ bootstrap.assert_async().await;+ profile_request.assert_async().await;+ versions.assert_async().await;+ }+}diff --git a/rust/space/src/client/mod.rs b/rust/space/src/client/mod.rsindex e7a91e88e3..f80568ddf0 100644--- a/rust/space/src/client/mod.rs+++ b/rust/space/src/client/mod.rs@@ -2,6 +2,7 @@ mod assets;mod entity_keys;mod friends;mod keys;+mod links;mod media;mod messages;mod posts;@@ -18,6 +19,7 @@ use std::{sync::{Mutex, MutexGuard},};+pub use links::SpaceLinkCtx;use media::{ensure_supported_photo_bytes, ensure_supported_photo_media_type};use crate::crypto::{diff --git a/rust/space/src/lib.rs b/rust/space/src/lib.rsindex 6cc4e45baf..816651932e 100644--- a/rust/space/src/lib.rs+++ b/rust/space/src/lib.rs@@ -9,12 +9,13 @@ pub use client::{MAX_SPACE_COVER_PLAINTEXT_BYTES, MAX_SPACE_COVER_UPLOAD_BYTES,MAX_SPACE_MESSAGE_CIPHER_DECODED_BYTES, MAX_SPACE_MESSAGE_PAYLOAD_BYTES,MAX_SPACE_MESSAGE_TEXT_BYTES, MAX_SPACE_MESSAGE_TEXT_CHARS, MAX_SPACE_POST_PLAINTEXT_BYTES,- MAX_SPACE_POST_UPLOAD_BYTES, PostPhotoAssetOptions,+ MAX_SPACE_POST_UPLOAD_BYTES, PostPhotoAssetOptions, SpaceLinkCtx,};pub use error::{Result, SpaceError};pub use models::{- CreatedSpace, DecryptedFriendShare, DecryptedMessage, DecryptedPost, DecryptedSpaceProfile,- FeedItem, FeedPage, HydratedKeys, MessagePayload, OpenAccountSpaceCtxInput, PostObjectMetadata,+ CreatedSpace, CreatedSpaceLink, DecryptedFriendShare, DecryptedMessage, DecryptedPost,+ DecryptedSpaceProfile, FeedItem, FeedPage, HydratedKeys, MessagePayload,+ OpenAccountSpaceCtxInput, OpenSpaceLinkCtxInput, PostObjectMetadata,};pub use transport::{ConversationChatSummaryResponse, ConversationsResponse, EntityKeyPayload,diff --git a/rust/space/src/models.rs b/rust/space/src/models.rsindex 8aee7ac0e4..55a1e9367e 100644--- a/rust/space/src/models.rs+++ b/rust/space/src/models.rs@@ -17,6 +17,23 @@ pub struct OpenAccountSpaceCtxInput {pub client_version: Option<String>,}+#[derive(Clone)]+pub struct OpenSpaceLinkCtxInput {+ pub base_url: String,+ pub space_slug: String,+ pub access_key: String,+ pub user_agent: Option<String>,+ pub client_package: Option<String>,+ pub client_version: Option<String>,+}++#[derive(Debug, Clone, PartialEq, Eq)]+pub struct CreatedSpaceLink {+ pub space_id: String,+ pub space_slug: String,+ pub access_key: String,+}+#[derive(Clone)]pub struct CreatedSpace {pub space_id: String,diff --git a/rust/space/src/transport.rs b/rust/space/src/transport.rsindex 9b85ce82e1..739be5ddd2 100644--- a/rust/space/src/transport.rs+++ b/rust/space/src/transport.rs@@ -342,6 +342,8 @@ pub struct RotateSpaceKeyRequest {pub key_version: i32,pub wrapped_prev_key: String,pub encrypted_profile: String,+ #[serde(skip_serializing_if = "Option::is_none")]+ pub link_encrypted_space_key: Option<String>,}#[derive(Debug, Clone, Serialize, Deserialize)]@@ -353,6 +355,53 @@ pub struct SpaceKeyVersionResponse {pub created_at: String,}+#[derive(Debug, Clone, Serialize)]+#[serde(rename_all = "camelCase")]+pub struct SpaceLinkWriteRequest {+ pub auth_key: String,+ pub kdf_salt: String,+ pub kdf_mem_limit: u32,+ pub kdf_ops_limit: u32,+ pub key_version: i32,+ pub encrypted_space_key: String,+ pub encrypted_access_key: String,+}++#[derive(Debug, Clone, Serialize, Deserialize)]+#[serde(rename_all = "camelCase")]+pub struct SpaceLinkStatusResponse {+ pub space_id: String,+ pub space_slug: String,+ pub active: bool,+ #[serde(default)]+ pub kdf_salt: String,+ #[serde(default)]+ pub kdf_mem_limit: u32,+ #[serde(default)]+ pub kdf_ops_limit: u32,+ #[serde(default)]+ pub key_version: i32,+ #[serde(default)]+ pub encrypted_access_key: String,+}++#[derive(Debug, Clone, Deserialize)]+#[serde(rename_all = "camelCase")]+pub struct SpaceLinkBootstrapResponse {+ pub kdf_salt: String,+ pub kdf_mem_limit: u32,+ pub kdf_ops_limit: u32,+}++#[derive(Debug, Clone, Deserialize)]+#[serde(rename_all = "camelCase")]+pub struct SpaceLinkProfileResponse {+ pub encrypted_space_key: String,+ pub key_version: i32,+ pub posts: i64,+ pub profile: SpaceProfileResponse,+}+#[cfg(test)]mod tests {use super::{diff --git a/server/cmd/museum/main.go b/server/cmd/museum/main.goindex 286dc01af8..4f836c4afa 100644--- a/server/cmd/museum/main.go+++ b/server/cmd/museum/main.go@@ -1405,7 +1405,7 @@ func cors() gin.HandlerFunc {return func(c *gin.Context) {c.Writer.Header().Set("Access-Control-Allow-Origin", c.GetHeader("Origin"))c.Writer.Header().Set("Access-Control-Allow-Credentials", "true")- c.Writer.Header().Set("Access-Control-Allow-Headers", "Content-Type, Content-Length, Accept-Encoding, X-CSRF-Token, X-Auth-Token, X-Space-Session-Token, X-Auth-Access-Token, X-Cast-Access-Token, X-Auth-Access-Token-JWT, X-Auth-Link-Device-Token, X-Client-Package, X-Client-Version, X-Paste-Consume, Authorization, accept, origin, Cache-Control, X-Requested-With, upgrade-insecure-requests, Range")+ c.Writer.Header().Set("Access-Control-Allow-Headers", "Content-Type, Content-Length, Accept-Encoding, X-CSRF-Token, X-Auth-Token, X-Space-Session-Token, X-Ente-Space-Link-Auth, X-Auth-Access-Token, X-Cast-Access-Token, X-Auth-Access-Token-JWT, X-Auth-Link-Device-Token, X-Client-Package, X-Client-Version, X-Paste-Consume, Authorization, accept, origin, Cache-Control, X-Requested-With, upgrade-insecure-requests, Range")c.Writer.Header().Set("Access-Control-Expose-Headers", "X-Request-Id, X-Ente-Link-Device-Token")c.Writer.Header().Set("Access-Control-Allow-Methods", "POST, OPTIONS, GET, PUT, PATCH, DELETE")c.Writer.Header().Set("Access-Control-Max-Age", "1728000")diff --git a/server/migrations/129_space_links.down.sql b/server/migrations/129_space_links.down.sqlnew file mode 100644index 0000000000..2d16da6746--- /dev/null+++ b/server/migrations/129_space_links.down.sql@@ -0,0 +1,2 @@+DROP TRIGGER IF EXISTS update_space_links_updated_at ON space_links;+DROP TABLE IF EXISTS space_links;diff --git a/server/migrations/129_space_links.up.sql b/server/migrations/129_space_links.up.sqlnew file mode 100644index 0000000000..5a9011b8f9--- /dev/null+++ b/server/migrations/129_space_links.up.sql@@ -0,0 +1,33 @@+CREATE TABLE IF NOT EXISTS space_links (+ link_id BIGSERIAL PRIMARY KEY,+ space_id TEXT NOT NULL REFERENCES spaces (space_id) ON DELETE CASCADE,+ auth_key_hash BYTEA NOT NULL UNIQUE,+ kdf_salt BYTEA NOT NULL,+ kdf_mem_limit BIGINT NOT NULL,+ kdf_ops_limit BIGINT NOT NULL,+ key_version INTEGER NOT NULL,+ encrypted_space_key BYTEA NOT NULL,+ encrypted_access_key BYTEA NOT NULL,+ active BOOLEAN NOT NULL DEFAULT TRUE,+ created_at BIGINT NOT NULL DEFAULT now_utc_micro_seconds(),+ updated_at BIGINT NOT NULL DEFAULT now_utc_micro_seconds(),+ CONSTRAINT chk_space_links_auth_key_hash CHECK (octet_length(auth_key_hash) = 32),+ CONSTRAINT chk_space_links_kdf_salt CHECK (octet_length(kdf_salt) = 16),+ CONSTRAINT chk_space_links_kdf_mem_limit CHECK (kdf_mem_limit = 67108864),+ CONSTRAINT chk_space_links_kdf_ops_limit CHECK (kdf_ops_limit = 2),+ CONSTRAINT chk_space_links_key_version CHECK (key_version > 0),+ CONSTRAINT chk_space_links_encrypted_space_key CHECK (octet_length(encrypted_space_key) > 0),+ CONSTRAINT chk_space_links_encrypted_access_key CHECK (octet_length(encrypted_access_key) > 0)+);++CREATE UNIQUE INDEX IF NOT EXISTS uq_space_links_active_space+ ON space_links (space_id)+ WHERE active = TRUE;++CREATE INDEX IF NOT EXISTS idx_space_links_space_created+ ON space_links (space_id, created_at DESC);++CREATE TRIGGER update_space_links_updated_at+ BEFORE UPDATE ON space_links+ FOR EACH ROW+EXECUTE PROCEDURE trigger_updated_at_microseconds_column();diff --git a/server/pkg/middleware/event_test.go b/server/pkg/middleware/event_test.goindex 3b1d7290b6..0c754e7f54 100644--- a/server/pkg/middleware/event_test.go+++ b/server/pkg/middleware/event_test.go@@ -58,6 +58,11 @@ func TestSpaceRoutesUseRouteSpecificRateLimits(t *testing.T) {require.Same(t, limit200ReqPerMin, rateLimiter.getLimiter("/space/public/by-slug/:spaceSlug", http.MethodGet))require.Same(t, limit200ReqPerMin, rateLimiter.getLimiter("/space/public/slug-availability/:spaceSlug", http.MethodGet))+ require.Same(t, limit200ReqPerMin, rateLimiter.getLimiter("/space/public/by-slug/:spaceSlug/link/bootstrap", http.MethodGet))+ require.Same(t, limit200ReqPerMin, rateLimiter.getLimiter("/space/public/by-slug/:spaceSlug/link/profile", http.MethodGet))+ require.Same(t, limit200ReqPerMin, rateLimiter.getLimiter("/space/public/by-slug/:spaceSlug/link/posts", http.MethodGet))+ require.Same(t, limit200ReqPerMin, rateLimiter.getLimiter("/space/public/by-slug/:spaceSlug/link/versions", http.MethodGet))+ require.Same(t, limit500ReqPerMin, rateLimiter.getLimiter("/space/public/by-slug/:spaceSlug/link/assets/redirect", http.MethodGet))require.Same(t, limit10ReqPerMin, rateLimiter.getLimiter("/spaces/:spaceID/uploads/presign", http.MethodPost))require.Same(t, limit200ReqPerMin, rateLimiter.getLimiter("/spaces/:spaceID/profile", http.MethodGet))require.Same(t, limit500ReqPerMin, rateLimiter.getLimiter("/spaces/:spaceID/assets/redirect", http.MethodGet))diff --git a/server/pkg/middleware/rate_limit.go b/server/pkg/middleware/rate_limit.goindex 34266d911f..4ea370811a 100644--- a/server/pkg/middleware/rate_limit.go+++ b/server/pkg/middleware/rate_limit.go@@ -217,9 +217,16 @@ func (r *RateLimitMiddleware) getLimiter(reqPath string, reqMethod string) *limireturn r.limit700ReqPerSec}if reqPath == "/space/public/by-slug/:spaceSlug" ||- reqPath == "/space/public/slug-availability/:spaceSlug" {+ reqPath == "/space/public/slug-availability/:spaceSlug" ||+ reqPath == "/space/public/by-slug/:spaceSlug/link/bootstrap" ||+ reqPath == "/space/public/by-slug/:spaceSlug/link/profile" ||+ reqPath == "/space/public/by-slug/:spaceSlug/link/posts" ||+ reqPath == "/space/public/by-slug/:spaceSlug/link/versions" {return r.limit200ReqPerMin}+ if reqPath == "/space/public/by-slug/:spaceSlug/link/assets/redirect" {+ return r.limit500ReqPerMin+ }if reqPath == "/spaces/:spaceID/uploads/presign" && reqMethod == http.MethodPost {return r.limit10ReqPerMin}diff --git a/server/pkg/middleware/recover.go b/server/pkg/middleware/recover.goindex e253423876..2f432aab16 100644--- a/server/pkg/middleware/recover.go+++ b/server/pkg/middleware/recover.go@@ -53,7 +53,7 @@ func PanicRecover() gin.HandlerFunc {requestData := strings.Split(string(httpRequest), "\r\n")for idx, header := range requestData {current := strings.Split(header, ":")- if current[0] == "Authorization" || current[0] == "X-Auth-Token" || current[0] == "X-Space-Session-Token" {+ if current[0] == "Authorization" || current[0] == "X-Auth-Token" || current[0] == "X-Space-Session-Token" || current[0] == "X-Ente-Space-Link-Auth" {requestData[idx] = current[0] + ": *"}}diff --git a/server/space/api/links.go b/server/space/api/links.gonew file mode 100644index 0000000000..20ba2ba377--- /dev/null+++ b/server/space/api/links.go@@ -0,0 +1,59 @@+package api++import (+ "github.com/ente/museum/space/models"+ spacerepo "github.com/ente/museum/space/repo"+ "github.com/gin-gonic/gin"+)++func (h *Handlers) GetSpaceLink(c *gin.Context, space *spacerepo.SpaceRecord) {+ resp, err := h.Module.Links.Get(c, space)+ respondJSON(c, resp, err)+}++func (h *Handlers) CreateSpaceLink(c *gin.Context, space *spacerepo.SpaceRecord) {+ var req models.SpaceLinkWriteRequest+ if !bindJSON(c, &req) {+ return+ }+ resp, err := h.Module.Links.Create(c, space, req)+ respondJSON(c, resp, err)+}++func (h *Handlers) RotateSpaceLink(c *gin.Context, space *spacerepo.SpaceRecord) {+ var req models.SpaceLinkWriteRequest+ if !bindJSON(c, &req) {+ return+ }+ resp, err := h.Module.Links.Rotate(c, space, req)+ respondJSON(c, resp, err)+}++func (h *Handlers) SpaceLinkBootstrap(c *gin.Context) {+ resp, err := h.Module.Links.Bootstrap(c, c.Param("spaceSlug"))+ respondJSON(c, resp, err)+}++func (h *Handlers) SpaceLinkProfile(c *gin.Context) {+ resp, err := h.Module.Links.Profile(c, c.Param("spaceSlug"))+ respondJSON(c, resp, err)+}++func (h *Handlers) SpaceLinkPosts(c *gin.Context) {+ resp, err := h.Module.Links.RecentPosts(c, c.Param("spaceSlug"))+ respondJSON(c, resp, err)+}++func (h *Handlers) SpaceLinkVersions(c *gin.Context) {+ resp, err := h.Module.Links.Versions(c, c.Param("spaceSlug"))+ respondJSON(c, resp, err)+}++func (h *Handlers) SpaceLinkAssetRedirect(c *gin.Context) {+ var req models.AssetRedirectRequest+ if !bindQuery(c, &req) {+ return+ }+ resp, err := h.Module.Links.AssetRedirect(c, c.Param("spaceSlug"), req)+ respondJSON(c, resp, err)+}diff --git a/server/space/api/register.go b/server/space/api/register.goindex 29af99dc44..a88cc5e0b0 100644--- a/server/space/api/register.go+++ b/server/space/api/register.go@@ -38,6 +38,9 @@ func Register(privateAPI, publicAPI gin.IRouter, handlers *Handlers) {spaceAPI.GET("/friends/relationship", selected(handlers.FriendRelationship))spaceAPI.POST("/friends/shares/refresh", selected(handlers.RefreshFriendShares))spaceAPI.GET("/friends/shares", selected(handlers.ListFriendShares))+ spaceAPI.GET("/link", selected(handlers.GetSpaceLink))+ spaceAPI.POST("/link", selected(handlers.CreateSpaceLink))+ spaceAPI.POST("/link/rotate", selected(handlers.RotateSpaceLink))publicAPI.GET("/spaces/:spaceID/profile", handlers.GetSpaceProfile)publicAPI.GET("/spaces/:spaceID/assets/redirect", handlers.AssetRedirect)@@ -46,6 +49,11 @@ func Register(privateAPI, publicAPI gin.IRouter, handlers *Handlers) {publicAPI.GET("/spaces/:spaceID/versions", handlers.ListSpaceKeyVersions)publicAPI.GET("/space/public/by-slug/:spaceSlug", handlers.LookupSpaceBySlug)publicAPI.GET("/space/public/slug-availability/:spaceSlug", handlers.SpaceSlugAvailability)+ publicAPI.GET("/space/public/by-slug/:spaceSlug/link/bootstrap", handlers.SpaceLinkBootstrap)+ publicAPI.GET("/space/public/by-slug/:spaceSlug/link/profile", handlers.SpaceLinkProfile)+ publicAPI.GET("/space/public/by-slug/:spaceSlug/link/posts", handlers.SpaceLinkPosts)+ publicAPI.GET("/space/public/by-slug/:spaceSlug/link/versions", handlers.SpaceLinkVersions)+ publicAPI.GET("/space/public/by-slug/:spaceSlug/link/assets/redirect", handlers.SpaceLinkAssetRedirect)publicAPI.POST("/account/space/sessions/bootstrap", handlers.BootstrapBrowserSession)publicAPI.DELETE("/account/space/sessions/current", handlers.DeleteBrowserSession)}diff --git a/server/space/controller/assets.go b/server/space/controller/assets.goindex 299ea5615a..c57a23fd6f 100644--- a/server/space/controller/assets.go+++ b/server/space/controller/assets.go@@ -192,8 +192,13 @@ func (c *AssetsController) Redirect(ctx *gin.Context, req models.AssetRedirectReif err := c.auth.canViewSpace(ctx, viewer, space); err != nil {return nil, err}+ return c.redirectForSpace(ctx, space, req)+}++func (c *AssetsController) redirectForSpace(ctx context.Context, space *spacerepo.SpaceRecord, req models.AssetRedirectRequest) (*models.AssetDownloadResponse, error) {objectKey := strings.TrimSpace(req.ObjectKey)var bucketID string+ var err errorif objectKey == "" {assetType := strings.TrimSpace(req.AssetType)objectID := strings.TrimSpace(req.ObjectID)diff --git a/server/space/controller/links.go b/server/space/controller/links.gonew file mode 100644index 0000000000..d74c32dc90--- /dev/null+++ b/server/space/controller/links.go@@ -0,0 +1,269 @@+package controller++import (+ "context"+ "crypto/sha256"+ "database/sql"+ "errors"+ "strings"++ "github.com/ente/museum/ente"+ "github.com/ente/museum/space/models"+ "github.com/ente/museum/space/repo"+ "github.com/ente/stacktrace"+ "github.com/gin-gonic/gin"+)++const (+ SpaceLinkAuthHeader = "X-Ente-Space-Link-Auth"+ spaceLinkAuthKeyBytes = 32+ spaceLinkKDFSaltBytes = 16+ spaceLinkKDFMemLimit = 67_108_864+ spaceLinkKDFOpsLimit = 2+ spaceLinkPostLimit = 60+)++type LinksController struct {+ LinksRepo *repo.LinksRepository+ SpacesRepo *repo.SpacesRepository+ FriendsRepo *repo.FriendsRepository+ Posts *PostsController+ Assets *AssetsController+}++func spaceLinkStatus(link *repo.SpaceLinkRecord) *models.SpaceLinkStatusResponse {+ return &models.SpaceLinkStatusResponse{+ SpaceID: link.SpaceID,+ SpaceSlug: link.SpaceSlug,+ Active: link.Active,+ KDFSalt: encodeSpaceField(link.KDFSalt),+ KDFMemLimit: link.KDFMemLimit,+ KDFOpsLimit: link.KDFOpsLimit,+ KeyVersion: link.KeyVersion,+ EncryptedAccessKey: encodeSpaceField(link.EncryptedAccessKey),+ CreatedAt: formatMicros(link.CreatedAt),+ UpdatedAt: formatMicros(link.UpdatedAt),+ }+}++func (c *LinksController) Get(ctx context.Context, space *repo.SpaceRecord) (*models.SpaceLinkStatusResponse, error) {+ link, err := c.LinksRepo.GetActive(ctx, space.SpaceID)+ if err != nil {+ if errors.Is(stacktrace.RootCause(err), sql.ErrNoRows) {+ return &models.SpaceLinkStatusResponse{+ SpaceID: space.SpaceID,+ SpaceSlug: space.SpaceSlug,+ Active: false,+ }, nil+ }+ return nil, err+ }+ return spaceLinkStatus(link), nil+}++func decodeSpaceLinkWriteRequest(req models.SpaceLinkWriteRequest) (authKey, kdfSalt, encryptedSpaceKey, encryptedAccessKey []byte, err error) {+ authKey, err = decodeEncodedSpaceField("authKey", req.AuthKey, maxSpaceEncryptedKeyEncodedBytes, maxSpaceEncryptedKeyDecodedBytes)+ if err != nil {+ return+ }+ if len(authKey) != spaceLinkAuthKeyBytes {+ err = ente.NewBadRequestWithMessage("authKey must be 32 bytes")+ return+ }+ kdfSalt, err = decodeEncodedSpaceField("kdfSalt", req.KDFSalt, maxSpaceLinkKDFSaltEncodedBytes, maxSpaceLinkKDFSaltDecodedBytes)+ if err != nil {+ return+ }+ if len(kdfSalt) != spaceLinkKDFSaltBytes {+ err = ente.NewBadRequestWithMessage("kdfSalt must be 16 bytes")+ return+ }+ if req.KDFMemLimit != spaceLinkKDFMemLimit || req.KDFOpsLimit != spaceLinkKDFOpsLimit {+ err = ente.NewBadRequestWithMessage("unsupported space link KDF parameters")+ return+ }+ encryptedSpaceKey, err = decodeEncodedSpaceField("encryptedSpaceKey", req.EncryptedSpaceKey, maxSpaceEncryptedKeyEncodedBytes, maxSpaceEncryptedKeyDecodedBytes)+ if err != nil {+ return+ }+ encryptedAccessKey, err = decodeEncodedSpaceField("encryptedAccessKey", req.EncryptedAccessKey, maxSpaceEncryptedKeyEncodedBytes, maxSpaceEncryptedKeyDecodedBytes)+ return+}++func (c *LinksController) Create(ctx context.Context, space *repo.SpaceRecord, req models.SpaceLinkWriteRequest) (*models.SpaceLinkStatusResponse, error) {+ authKey, kdfSalt, encryptedSpaceKey, encryptedAccessKey, err := decodeSpaceLinkWriteRequest(req)+ if err != nil {+ return nil, err+ }+ if req.KeyVersion != space.CurrentVersion {+ return nil, ente.NewBadRequestWithMessage("keyVersion does not match current space version")+ }+ sum := sha256.Sum256(authKey)+ link, err := c.LinksRepo.Create(+ ctx,+ space.SpaceID,+ sum[:],+ kdfSalt,+ req.KDFMemLimit,+ req.KDFOpsLimit,+ req.KeyVersion,+ encryptedSpaceKey,+ encryptedAccessKey,+ )+ if err != nil {+ if errors.Is(stacktrace.RootCause(err), sql.ErrNoRows) {+ return nil, ente.NewBadRequestWithMessage("keyVersion does not match current space version")+ }+ if errors.Is(err, repo.ErrSpaceLinkSecretReused) {+ return nil, ente.NewBadRequestWithMessage("space link secret has already been used")+ }+ return nil, err+ }+ return spaceLinkStatus(link), nil+}++func (c *LinksController) Rotate(ctx context.Context, space *repo.SpaceRecord, req models.SpaceLinkWriteRequest) (*models.SpaceLinkStatusResponse, error) {+ authKey, kdfSalt, encryptedSpaceKey, encryptedAccessKey, err := decodeSpaceLinkWriteRequest(req)+ if err != nil {+ return nil, err+ }+ if req.KeyVersion != space.CurrentVersion {+ return nil, ente.NewBadRequestWithMessage("keyVersion does not match current space version")+ }+ sum := sha256.Sum256(authKey)+ link, err := c.LinksRepo.Rotate(+ ctx,+ space.SpaceID,+ sum[:],+ kdfSalt,+ req.KDFMemLimit,+ req.KDFOpsLimit,+ req.KeyVersion,+ encryptedSpaceKey,+ encryptedAccessKey,+ )+ if err != nil {+ if errors.Is(stacktrace.RootCause(err), sql.ErrNoRows) {+ return nil, ente.NewBadRequestWithMessage("keyVersion does not match current space version")+ }+ if errors.Is(err, repo.ErrSpaceLinkSecretReused) {+ return nil, ente.NewBadRequestWithMessage("space link secret has already been used")+ }+ return nil, err+ }+ return spaceLinkStatus(link), nil+}++func (c *LinksController) Bootstrap(ctx context.Context, slug string) (*models.SpaceLinkBootstrapResponse, error) {+ link, err := c.LinksRepo.GetActiveBootstrap(ctx, strings.TrimSpace(slug))+ if err != nil {+ if errors.Is(stacktrace.RootCause(err), sql.ErrNoRows) {+ return nil, ente.ErrNotFound+ }+ return nil, err+ }+ return &models.SpaceLinkBootstrapResponse{+ KDFSalt: encodeSpaceField(link.KDFSalt),+ KDFMemLimit: link.KDFMemLimit,+ KDFOpsLimit: link.KDFOpsLimit,+ }, nil+}++func (c *LinksController) authorize(ctx *gin.Context, slug string) (*repo.SpaceLinkRecord, *repo.SpaceRecord, error) {+ encodedAuth := strings.TrimSpace(ctx.GetHeader(SpaceLinkAuthHeader))+ authKey, err := decodeOptionalEncodedSpaceField("space link auth", encodedAuth, maxSpaceEncryptedKeyEncodedBytes, maxSpaceEncryptedKeyDecodedBytes)+ if err != nil || len(authKey) != spaceLinkAuthKeyBytes {+ return nil, nil, ente.ErrNotFound+ }+ sum := sha256.Sum256(authKey)+ link, err := c.LinksRepo.GetActiveBySlugAndAuthHash(ctx, strings.TrimSpace(slug), sum[:])+ if err != nil {+ if errors.Is(stacktrace.RootCause(err), sql.ErrNoRows) {+ return nil, nil, ente.ErrNotFound+ }+ return nil, nil, err+ }+ space, err := c.SpacesRepo.GetSpaceByID(ctx, link.SpaceID)+ if err != nil {+ return nil, nil, err+ }+ return link, space, nil+}++func (c *LinksController) Profile(ctx *gin.Context, slug string) (*models.SpaceLinkProfileResponse, error) {+ link, space, err := c.authorize(ctx, slug)+ if err != nil {+ return nil, err+ }+ friends, err := c.FriendsRepo.CountFriendsForSpace(ctx, space.SpaceID)+ if err != nil {+ return nil, err+ }+ posts, err := c.Posts.PostsRepo.CountPosts(ctx, space.SpaceID)+ if err != nil {+ return nil, err+ }+ return &models.SpaceLinkProfileResponse{+ EncryptedSpaceKey: encodeSpaceField(link.EncryptedSpaceKey),+ KeyVersion: link.KeyVersion,+ Posts: posts,+ Profile: models.SpaceProfileResponse{+ SpaceID: space.SpaceID,+ SpaceSlug: space.SpaceSlug,+ Version: space.CurrentVersion,+ EncryptedProfile: encodeSpaceField(space.EncryptedProfile),+ UpdatedAt: formatMicros(space.UpdatedAt),+ Avatar: toAvatarResponse(space),+ Cover: toCoverResponse(space),+ Friends: friends,+ },+ }, nil+}++func (c *LinksController) RecentPosts(ctx *gin.Context, slug string) (*models.PostPage, error) {+ _, space, err := c.authorize(ctx, slug)+ if err != nil {+ return nil, err+ }+ posts, _, err := c.Posts.PostsRepo.ListPostsBySpace(ctx, space.SpaceID, "", "", spaceLinkPostLimit)+ if err != nil {+ return nil, err+ }+ items, err := c.Posts.postResponses(ctx, posts, true)+ if err != nil {+ return nil, err+ }+ return &models.PostPage{Items: items}, nil+}++func (c *LinksController) Versions(ctx *gin.Context, slug string) ([]models.SpaceKeyVersionResponse, error) {+ _, space, err := c.authorize(ctx, slug)+ if err != nil {+ return nil, err+ }+ versions, err := c.SpacesRepo.ListVersions(ctx, space.SpaceID)+ if err != nil {+ return nil, err+ }+ resp := make([]models.SpaceKeyVersionResponse, 0, len(versions))+ for _, version := range versions {+ item := models.SpaceKeyVersionResponse{+ Version: version.Version,+ CreatedAt: formatMicros(version.CreatedAt),+ }+ if len(version.WrappedPrevKey) > 0 {+ item.WrappedPrevKey = encodeSpaceField(version.WrappedPrevKey)+ }+ resp = append(resp, item)+ }+ return resp, nil+}++func (c *LinksController) AssetRedirect(ctx *gin.Context, slug string, req models.AssetRedirectRequest) (*models.AssetDownloadResponse, error) {+ _, space, err := c.authorize(ctx, slug)+ if err != nil {+ return nil, err+ }+ req.SpaceID = space.SpaceID+ return c.Assets.redirectForSpace(ctx, space, req)+}diff --git a/server/space/controller/links_test.go b/server/space/controller/links_test.gonew file mode 100644index 0000000000..a697bcf17f--- /dev/null+++ b/server/space/controller/links_test.go@@ -0,0 +1,31 @@+package controller++import (+ "testing"++ "github.com/ente/museum/space/models"+ "github.com/stretchr/testify/require"+)++func TestDecodeSpaceLinkWriteRequestValidatesWireParameters(t *testing.T) {+ request := models.SpaceLinkWriteRequest{+ AuthKey: encodeSpaceField(make([]byte, spaceLinkAuthKeyBytes)),+ KDFSalt: encodeSpaceField(make([]byte, spaceLinkKDFSaltBytes)),+ KDFMemLimit: spaceLinkKDFMemLimit,+ KDFOpsLimit: spaceLinkKDFOpsLimit,+ KeyVersion: 1,+ EncryptedSpaceKey: encodeSpaceField([]byte("encrypted-space-key")),+ EncryptedAccessKey: encodeSpaceField([]byte("encrypted-access-key")),+ }+ _, _, _, _, err := decodeSpaceLinkWriteRequest(request)+ require.NoError(t, err)++ request.KDFSalt = encodeSpaceField(make([]byte, spaceLinkKDFSaltBytes-1))+ _, _, _, _, err = decodeSpaceLinkWriteRequest(request)+ require.ErrorContains(t, err, "kdfSalt must be 16 bytes")++ request.KDFSalt = encodeSpaceField(make([]byte, spaceLinkKDFSaltBytes))+ request.KDFOpsLimit+++ _, _, _, _, err = decodeSpaceLinkWriteRequest(request)+ require.ErrorContains(t, err, "unsupported space link KDF parameters")+}diff --git a/server/space/controller/module.go b/server/space/controller/module.goindex 6ff4b29a5f..3c09e29ee2 100644--- a/server/space/controller/module.go+++ b/server/space/controller/module.go@@ -15,6 +15,7 @@ type Module struct {Read *ReadMarkersControllerSessions *SessionsControllerCleanup *CleanupController+ Links *LinksControllerUserTokens UserTokenTerminatorauth authDeps}@@ -34,15 +35,19 @@ func NewModule(repos *repo.Module, userAuthRepo *baserepo.UserAuthRepository, emFriendsRepo: repos.Friends,SessionsRepo: repos.Sessions,}+ spaces := &SpacesController{SpacesRepo: repos.Spaces, AssetsRepo: repos.Assets, auth: authDeps}+ posts := &PostsController{PostsRepo: repos.Posts, SpacesRepo: repos.Spaces, FriendsRepo: repos.Friends, AssetsRepo: repos.Assets, EmailNotifier: emailNotifier, auth: authDeps}+ assets := &AssetsController{AssetsRepo: repos.Assets, SpacesRepo: repos.Spaces, auth: authDeps}return &Module{- Spaces: &SpacesController{SpacesRepo: repos.Spaces, AssetsRepo: repos.Assets, auth: authDeps},- Posts: &PostsController{PostsRepo: repos.Posts, SpacesRepo: repos.Spaces, FriendsRepo: repos.Friends, AssetsRepo: repos.Assets, EmailNotifier: emailNotifier, auth: authDeps},+ Spaces: spaces,+ Posts: posts,Friends: &FriendsController{FriendsRepo: repos.Friends, SpacesRepo: repos.Spaces, EmailNotifier: emailNotifier},Messages: &MessagesController{MessagesRepo: repos.Messages, PostsRepo: repos.Posts, SpacesRepo: repos.Spaces, FriendsRepo: repos.Friends, ReadMarkersRepo: repos.Read, EmailNotifier: emailNotifier, auth: authDeps},- Assets: &AssetsController{AssetsRepo: repos.Assets, SpacesRepo: repos.Spaces, auth: authDeps},+ Assets: assets,Read: &ReadMarkersController{ReadMarkersRepo: repos.Read},Sessions: &SessionsController{SessionsRepo: repos.Sessions},Cleanup: &CleanupController{AssetsRepo: repos.Assets},+ Links: &LinksController{LinksRepo: repos.Links, SpacesRepo: repos.Spaces, FriendsRepo: repos.Friends, Posts: posts, Assets: assets},auth: authDeps,}}diff --git a/server/space/controller/spaces.go b/server/space/controller/spaces.goindex 11d6d5be6f..df4f52a6b0 100644--- a/server/space/controller/spaces.go+++ b/server/space/controller/spaces.go@@ -267,10 +267,14 @@ func (c *SpacesController) RotateKey(ctx context.Context, current *repo.SpaceRecif err != nil {return nil, err}+ linkEncryptedSpaceKey, err := decodeOptionalEncodedSpaceField("linkEncryptedSpaceKey", req.LinkEncryptedSpaceKey, maxSpaceEncryptedKeyEncodedBytes, maxSpaceEncryptedKeyDecodedBytes)+ if err != nil {+ return nil, err+ }if req.KeyVersion != current.CurrentVersion {return nil, ente.NewBadRequestWithMessage("keyVersion does not match current space version")}- space, err := c.SpacesRepo.RotateKey(ctx, current.SpaceID, req.KeyVersion, rootWrappedSpaceKey, wrappedPrevKey, encryptedProfile)+ space, err := c.SpacesRepo.RotateKey(ctx, current.SpaceID, req.KeyVersion, rootWrappedSpaceKey, wrappedPrevKey, encryptedProfile, linkEncryptedSpaceKey)if err != nil {if errors.Is(stacktrace.RootCause(err), sql.ErrNoRows) {return nil, ente.NewBadRequestWithMessage("keyVersion does not match current space version")diff --git a/server/space/controller/test_helpers_test.go b/server/space/controller/test_helpers_test.goindex 5b93a8d994..01a58f19db 100644--- a/server/space/controller/test_helpers_test.go+++ b/server/space/controller/test_helpers_test.go@@ -39,7 +39,7 @@ func testUpdateProfile(ctx context.Context, module *spacerepo.Module, _ int64, s}func testRotateKey(ctx context.Context, module *spacerepo.Module, _ int64, spaceID string, keyVersion int, rootWrappedSpaceKey string, wrappedPrevKey string, encryptedProfile string) (*spacerepo.SpaceRecord, error) {- return module.Spaces.RotateKey(ctx, spaceID, keyVersion, testSpaceBytes(rootWrappedSpaceKey), testSpaceBytes(wrappedPrevKey), testSpaceBytes(encryptedProfile))+ return module.Spaces.RotateKey(ctx, spaceID, keyVersion, testSpaceBytes(rootWrappedSpaceKey), testSpaceBytes(wrappedPrevKey), testSpaceBytes(encryptedProfile), nil)}func testAddFriend(ctx context.Context, module *spacerepo.Module, requesterID int64, requesterSpaceID string, targetSpaceID string, targetFriendSealedSpaceKey string, targetKeyVersion int, requesterFriendSealedSpaceKey string, requesterKeyVersion int) error {diff --git a/server/space/controller/validation.go b/server/space/controller/validation.goindex b418c440cb..6b04dc6f3b 100644--- a/server/space/controller/validation.go+++ b/server/space/controller/validation.go@@ -20,6 +20,8 @@ const (maxSpacePostObjects = 1maxSpaceFriendSharesPerRefresh = 500maxSpaceObjectKeyBytes = 512+ maxSpaceLinkKDFSaltEncodedBytes = 128+ maxSpaceLinkKDFSaltDecodedBytes = 64)func validateSpaceSlug(input string) (string, error) {diff --git a/server/space/models/models.go b/server/space/models/models.goindex 9623eb6919..1f5e885b5c 100644--- a/server/space/models/models.go+++ b/server/space/models/models.go@@ -81,6 +81,42 @@ type AssetDownloadResponse struct {ExpiresIn int `json:"expiresIn"`}+type SpaceLinkWriteRequest struct {+ AuthKey string `json:"authKey" binding:"required"`+ KDFSalt string `json:"kdfSalt" binding:"required"`+ KDFMemLimit int64 `json:"kdfMemLimit" binding:"required,gt=0"`+ KDFOpsLimit int64 `json:"kdfOpsLimit" binding:"required,gt=0"`+ KeyVersion int `json:"keyVersion" binding:"required,gt=0"`+ EncryptedSpaceKey string `json:"encryptedSpaceKey" binding:"required"`+ EncryptedAccessKey string `json:"encryptedAccessKey" binding:"required"`+}++type SpaceLinkStatusResponse struct {+ SpaceID string `json:"spaceId"`+ SpaceSlug string `json:"spaceSlug"`+ Active bool `json:"active"`+ KDFSalt string `json:"kdfSalt,omitempty"`+ KDFMemLimit int64 `json:"kdfMemLimit,omitempty"`+ KDFOpsLimit int64 `json:"kdfOpsLimit,omitempty"`+ KeyVersion int `json:"keyVersion,omitempty"`+ EncryptedAccessKey string `json:"encryptedAccessKey,omitempty"`+ CreatedAt string `json:"createdAt,omitempty"`+ UpdatedAt string `json:"updatedAt,omitempty"`+}++type SpaceLinkBootstrapResponse struct {+ KDFSalt string `json:"kdfSalt"`+ KDFMemLimit int64 `json:"kdfMemLimit"`+ KDFOpsLimit int64 `json:"kdfOpsLimit"`+}++type SpaceLinkProfileResponse struct {+ EncryptedSpaceKey string `json:"encryptedSpaceKey"`+ KeyVersion int `json:"keyVersion"`+ Posts int64 `json:"posts"`+ Profile SpaceProfileResponse `json:"profile"`+}+type ProfileAvatarPayload struct {ObjectID string `json:"objectID" binding:"required"`Size int64 `json:"size,omitempty" binding:"omitempty,gt=0"`@@ -201,10 +237,11 @@ type SpaceSlugAvailabilityResponse struct {}type RotateSpaceKeyRequest struct {- KeyVersion int `json:"keyVersion" binding:"required,gt=0"`- RootWrappedSpaceKey string `json:"rootWrappedSpaceKey" binding:"required"`- WrappedPrevKey string `json:"wrappedPrevKey" binding:"required"`- EncryptedProfile string `json:"encryptedProfile" binding:"required"`+ KeyVersion int `json:"keyVersion" binding:"required,gt=0"`+ RootWrappedSpaceKey string `json:"rootWrappedSpaceKey" binding:"required"`+ WrappedPrevKey string `json:"wrappedPrevKey" binding:"required"`+ EncryptedProfile string `json:"encryptedProfile" binding:"required"`+ LinkEncryptedSpaceKey string `json:"linkEncryptedSpaceKey,omitempty"`}type SpaceKeyVersionResponse struct {diff --git a/server/space/repo/links.go b/server/space/repo/links.gonew file mode 100644index 0000000000..890dceda15--- /dev/null+++ b/server/space/repo/links.go@@ -0,0 +1,194 @@+package repo++import (+ "context"+ "database/sql"+ "errors"++ "github.com/ente/stacktrace"+ "github.com/lib/pq"+)++var (+ ErrSpaceLinkSecretReused = errors.New("space link secret reused")+)++func isSpaceLinkUniqueViolation(err error, constraint string) bool {+ var pgErr *pq.Error+ return errors.As(err, &pgErr) &&+ pgErr.Code == "23505" &&+ pgErr.Constraint == constraint+}++func scanSpaceLink(scanner interface{ Scan(dest ...any) error }) (*SpaceLinkRecord, error) {+ var rec SpaceLinkRecord+ if err := scanner.Scan(+ &rec.LinkID,+ &rec.SpaceID,+ &rec.SpaceSlug,+ &rec.AuthKeyHash,+ &rec.KDFSalt,+ &rec.KDFMemLimit,+ &rec.KDFOpsLimit,+ &rec.KeyVersion,+ &rec.EncryptedSpaceKey,+ &rec.EncryptedAccessKey,+ &rec.Active,+ &rec.CreatedAt,+ &rec.UpdatedAt,+ ); err != nil {+ return nil, stacktrace.Propagate(err, "")+ }+ return &rec, nil+}++const spaceLinkSelect = `+ SELECT l.link_id, l.space_id, s.space_slug, l.auth_key_hash,+ l.kdf_salt, l.kdf_mem_limit, l.kdf_ops_limit, l.key_version,+ l.encrypted_space_key, l.encrypted_access_key, l.active,+ l.created_at, l.updated_at+ FROM space_links l+ JOIN spaces s ON s.space_id = l.space_id+`++func (r *LinksRepository) GetActive(ctx context.Context, spaceID string) (*SpaceLinkRecord, error) {+ return scanSpaceLink(r.DB.QueryRowContext(ctx, spaceLinkSelect+`+ WHERE l.space_id = $1 AND l.active = TRUE+ `, spaceID))+}++func (r *LinksRepository) GetActiveBySlugAndAuthHash(ctx context.Context, slug string, authKeyHash []byte) (*SpaceLinkRecord, error) {+ return scanSpaceLink(r.DB.QueryRowContext(ctx, spaceLinkSelect+`+ JOIN users u ON u.user_id = s.owner_id AND u.encrypted_email IS NOT NULL+ WHERE s.space_slug = LOWER($1)+ AND l.auth_key_hash = $2+ AND l.active = TRUE+ `, slug, authKeyHash))+}++func (r *LinksRepository) GetActiveBootstrap(ctx context.Context, slug string) (*SpaceLinkRecord, error) {+ return scanSpaceLink(r.DB.QueryRowContext(ctx, spaceLinkSelect+`+ JOIN users u ON u.user_id = s.owner_id AND u.encrypted_email IS NOT NULL+ WHERE s.space_slug = LOWER($1) AND l.active = TRUE+ `, slug))+}++func (r *LinksRepository) Create(+ ctx context.Context,+ spaceID string,+ authKeyHash, kdfSalt []byte,+ kdfMemLimit, kdfOpsLimit int64,+ keyVersion int,+ encryptedSpaceKey, encryptedAccessKey []byte,+) (*SpaceLinkRecord, error) {+ tx, err := r.DB.BeginTx(ctx, nil)+ if err != nil {+ return nil, stacktrace.Propagate(err, "")+ }+ defer tx.Rollback()++ var currentVersion int+ if err := tx.QueryRowContext(ctx, `+ SELECT current_version+ FROM spaces+ WHERE space_id = $1+ FOR UPDATE+ `, spaceID).Scan(¤tVersion); err != nil {+ return nil, stacktrace.Propagate(err, "")+ }+ if currentVersion != keyVersion {+ return nil, sql.ErrNoRows+ }+ if existing, err := scanSpaceLink(tx.QueryRowContext(ctx, spaceLinkSelect+`+ WHERE l.space_id = $1 AND l.active = TRUE+ `, spaceID)); err == nil {+ return existing, nil+ } else if !errors.Is(stacktrace.RootCause(err), sql.ErrNoRows) {+ return nil, err+ }++ var linkID int64+ err = tx.QueryRowContext(ctx, `+ INSERT INTO space_links (+ space_id, auth_key_hash, kdf_salt, kdf_mem_limit, kdf_ops_limit,+ key_version, encrypted_space_key, encrypted_access_key+ )+ VALUES ($1, $2, $3, $4, $5, $6, $7, $8)+ RETURNING link_id+ `, spaceID, authKeyHash, kdfSalt, kdfMemLimit, kdfOpsLimit, keyVersion, encryptedSpaceKey, encryptedAccessKey).Scan(&linkID)+ if err != nil {+ if isSpaceLinkUniqueViolation(err, "space_links_auth_key_hash_key") {+ return nil, ErrSpaceLinkSecretReused+ }+ return nil, stacktrace.Propagate(err, "")+ }+ link, err := scanSpaceLink(tx.QueryRowContext(ctx, spaceLinkSelect+`+ WHERE l.link_id = $1+ `, linkID))+ if err != nil {+ return nil, err+ }+ if err := tx.Commit(); err != nil {+ return nil, stacktrace.Propagate(err, "")+ }+ return link, nil+}++func (r *LinksRepository) Rotate(+ ctx context.Context,+ spaceID string,+ authKeyHash, kdfSalt []byte,+ kdfMemLimit, kdfOpsLimit int64,+ keyVersion int,+ encryptedSpaceKey, encryptedAccessKey []byte,+) (*SpaceLinkRecord, error) {+ tx, err := r.DB.BeginTx(ctx, nil)+ if err != nil {+ return nil, stacktrace.Propagate(err, "")+ }+ defer tx.Rollback()+ var currentVersion int+ if err := tx.QueryRowContext(ctx, `+ SELECT current_version+ FROM spaces+ WHERE space_id = $1+ FOR UPDATE+ `, spaceID).Scan(¤tVersion); err != nil {+ return nil, stacktrace.Propagate(err, "")+ }+ if currentVersion != keyVersion {+ return nil, sql.ErrNoRows+ }+ if _, err := tx.ExecContext(ctx, `+ UPDATE space_links+ SET active = FALSE+ WHERE space_id = $1 AND active = TRUE+ `, spaceID); err != nil {+ return nil, stacktrace.Propagate(err, "")+ }+ var linkID int64+ err = tx.QueryRowContext(ctx, `+ INSERT INTO space_links (+ space_id, auth_key_hash, kdf_salt, kdf_mem_limit, kdf_ops_limit,+ key_version, encrypted_space_key, encrypted_access_key+ )+ VALUES ($1, $2, $3, $4, $5, $6, $7, $8)+ RETURNING link_id+ `, spaceID, authKeyHash, kdfSalt, kdfMemLimit, kdfOpsLimit, keyVersion, encryptedSpaceKey, encryptedAccessKey).Scan(&linkID)+ if err != nil {+ if isSpaceLinkUniqueViolation(err, "space_links_auth_key_hash_key") {+ return nil, ErrSpaceLinkSecretReused+ }+ return nil, stacktrace.Propagate(err, "")+ }+ link, err := scanSpaceLink(tx.QueryRowContext(ctx, spaceLinkSelect+`+ WHERE l.link_id = $1+ `, linkID))+ if err != nil {+ return nil, err+ }+ if err := tx.Commit(); err != nil {+ return nil, stacktrace.Propagate(err, "")+ }+ return link, nil+}diff --git a/server/space/repo/links_test.go b/server/space/repo/links_test.gonew file mode 100644index 0000000000..2052d0cdea--- /dev/null+++ b/server/space/repo/links_test.go@@ -0,0 +1,124 @@+package repo++import (+ "context"+ "crypto/sha256"+ "database/sql"+ "errors"+ "testing"++ "github.com/ente/stacktrace"+ "github.com/stretchr/testify/require"+)++func TestSpaceLinkLifecycle(t *testing.T) {+ module := newSpaceTestModule(t)+ ctx := context.Background()+ ownerID := insertSpaceUser(t, module, "[email protected]", "space-link-public")+ space, err := testCreateSpace(ctx, module, ownerID, "space_link", "root", "public", "secret", "nonce", "profile")+ require.NoError(t, err)++ auth := sha256.Sum256([]byte("first-auth-key"))+ link, err := module.Links.Create(+ ctx,+ space.SpaceID,+ auth[:],+ make([]byte, 16),+ 67_108_864,+ 2,+ space.CurrentVersion,+ []byte("first-encrypted-space-key"),+ []byte("first-encrypted-access-key"),+ )+ require.NoError(t, err)+ require.True(t, link.Active)+ require.Equal(t, "space_link", link.SpaceSlug)++ existing, err := module.Links.Create(+ ctx,+ space.SpaceID,+ []byte("different-auth-key"),+ make([]byte, 16),+ 67_108_864,+ 2,+ space.CurrentVersion,+ []byte("different-space-key"),+ []byte("different-access-key"),+ )+ require.NoError(t, err)+ require.Equal(t, link.LinkID, existing.LinkID)++ authorized, err := module.Links.GetActiveBySlugAndAuthHash(ctx, space.SpaceSlug, auth[:])+ require.NoError(t, err)+ require.Equal(t, link.LinkID, authorized.LinkID)++ nextAuth := sha256.Sum256([]byte("second-auth-key"))+ rotated, err := module.Links.Rotate(+ ctx,+ space.SpaceID,+ nextAuth[:],+ make([]byte, 16),+ 67_108_864,+ 2,+ space.CurrentVersion,+ []byte("second-encrypted-space-key"),+ []byte("second-encrypted-access-key"),+ )+ require.NoError(t, err)+ require.NotEqual(t, link.LinkID, rotated.LinkID)+ _, err = module.Links.GetActiveBySlugAndAuthHash(ctx, space.SpaceSlug, auth[:])+ require.True(t, errors.Is(stacktrace.RootCause(err), sql.ErrNoRows))+ authorized, err = module.Links.GetActiveBySlugAndAuthHash(ctx, space.SpaceSlug, nextAuth[:])+ require.NoError(t, err)+ require.Equal(t, rotated.LinkID, authorized.LinkID)+}++func TestSpaceKeyRotationRewrapsOrDisablesActiveLink(t *testing.T) {+ module := newSpaceTestModule(t)+ ctx := context.Background()+ ownerID := insertSpaceUser(t, module, "[email protected]", "space-link-rotation-public")+ space, err := testCreateSpace(ctx, module, ownerID, "space_link_rotation", "root", "public", "secret", "nonce", "profile")+ require.NoError(t, err)++ auth := sha256.Sum256([]byte("rotation-auth-key"))+ _, err = module.Links.Create(+ ctx,+ space.SpaceID,+ auth[:],+ make([]byte, 16),+ 67_108_864,+ 2,+ space.CurrentVersion,+ []byte("encrypted-space-key-v1"),+ []byte("encrypted-access-key"),+ )+ require.NoError(t, err)++ rotated, err := module.Spaces.RotateKey(+ ctx,+ space.SpaceID,+ space.CurrentVersion,+ []byte("root-v2"),+ []byte("wrapped-v1"),+ []byte("profile-v2"),+ []byte("encrypted-space-key-v2"),+ )+ require.NoError(t, err)+ link, err := module.Links.GetActive(ctx, space.SpaceID)+ require.NoError(t, err)+ require.Equal(t, rotated.CurrentVersion, link.KeyVersion)+ require.Equal(t, []byte("encrypted-space-key-v2"), link.EncryptedSpaceKey)++ _, err = module.Spaces.RotateKey(+ ctx,+ space.SpaceID,+ rotated.CurrentVersion,+ []byte("root-v3"),+ []byte("wrapped-v2"),+ []byte("profile-v3"),+ nil,+ )+ require.NoError(t, err)+ _, err = module.Links.GetActive(ctx, space.SpaceID)+ require.True(t, errors.Is(stacktrace.RootCause(err), sql.ErrNoRows))+}diff --git a/server/space/repo/module.go b/server/space/repo/module.goindex 59dfbb27cf..8d23c627a8 100644--- a/server/space/repo/module.go+++ b/server/space/repo/module.go@@ -15,6 +15,7 @@ type Module struct {Read *ReadMarkersRepositorySessions *SessionsRepositoryDrips *DripsRepository+ Links *LinksRepository}type SpacesRepository struct {@@ -50,6 +51,10 @@ type DripsRepository struct {DB *sql.DB}+type LinksRepository struct {+ DB *sql.DB+}+type SpaceRecord struct {SpaceID stringOwnerID int64@@ -225,6 +230,22 @@ type SpaceBrowserSessionRecord struct {LastUsedAt int64}+type SpaceLinkRecord struct {+ LinkID int64+ SpaceID string+ SpaceSlug string+ AuthKeyHash []byte+ KDFSalt []byte+ KDFMemLimit int64+ KDFOpsLimit int64+ KeyVersion int+ EncryptedSpaceKey []byte+ EncryptedAccessKey []byte+ Active bool+ CreatedAt int64+ UpdatedAt int64+}+func NewModule(db *sql.DB, s3Config *s3config.S3Config) *Module {return &Module{Spaces: &SpacesRepository{DB: db},@@ -235,5 +256,6 @@ func NewModule(db *sql.DB, s3Config *s3config.S3Config) *Module {Read: &ReadMarkersRepository{DB: db},Sessions: &SessionsRepository{DB: db},Drips: &DripsRepository{DB: db},+ Links: &LinksRepository{DB: db},}}diff --git a/server/space/repo/module_test.go b/server/space/repo/module_test.goindex e2d4289d42..67af56d039 100644--- a/server/space/repo/module_test.go+++ b/server/space/repo/module_test.go@@ -125,7 +125,7 @@ func testUpdateProfile(ctx context.Context, module *Module, _ int64, spaceID str}func testRotateKey(ctx context.Context, module *Module, _ int64, spaceID string, keyVersion int, rootWrappedSpaceKey string, wrappedPrevKey string, encryptedProfile string) (*SpaceRecord, error) {- return module.Spaces.RotateKey(ctx, spaceID, keyVersion, testSpaceBytes(rootWrappedSpaceKey), testSpaceBytes(wrappedPrevKey), testSpaceBytes(encryptedProfile))+ return module.Spaces.RotateKey(ctx, spaceID, keyVersion, testSpaceBytes(rootWrappedSpaceKey), testSpaceBytes(wrappedPrevKey), testSpaceBytes(encryptedProfile), nil)}func testAddFriend(ctx context.Context, module *Module, requesterID int64, requesterSpaceID string, targetSpaceID string, targetFriendSealedSpaceKey string, targetKeyVersion int, requesterFriendSealedSpaceKey string, requesterKeyVersion int) error {diff --git a/server/space/repo/posts.go b/server/space/repo/posts.goindex 95893ba51c..4badc52ce6 100644--- a/server/space/repo/posts.go+++ b/server/space/repo/posts.go@@ -15,6 +15,18 @@ const MaxPostsPerSpace = 250var ErrSpacePostLimitReached = errors.New("space post limit reached")+func (r *PostsRepository) CountPosts(ctx context.Context, spaceID string) (int64, error) {+ var count int64+ if err := r.DB.QueryRowContext(ctx, `+ SELECT COUNT(*)+ FROM space_posts+ WHERE space_id = $1 AND is_deleted = FALSE+ `, spaceID).Scan(&count); err != nil {+ return 0, stacktrace.Propagate(err, "")+ }+ return count, nil+}+func postRecordSelectSQL(viewerLikedExpr string) string {return `SELECT p.post_id, p.space_id, w.space_slug, w.owner_id,diff --git a/server/space/repo/spaces.go b/server/space/repo/spaces.goindex f9cb0a933f..02a65c29ff 100644--- a/server/space/repo/spaces.go+++ b/server/space/repo/spaces.go@@ -227,7 +227,7 @@ func (r *SpacesRepository) UpdateSlug(ctx context.Context, spaceID, spaceSlug streturn rec, nil}-func (r *SpacesRepository) RotateKey(ctx context.Context, spaceID string, keyVersion int, rootWrappedSpaceKey, wrappedPrevKey, encryptedProfile []byte) (*SpaceRecord, error) {+func (r *SpacesRepository) RotateKey(ctx context.Context, spaceID string, keyVersion int, rootWrappedSpaceKey, wrappedPrevKey, encryptedProfile, linkEncryptedSpaceKey []byte) (*SpaceRecord, error) {tx, err := r.DB.BeginTx(ctx, nil)if err != nil {return nil, stacktrace.Propagate(err, "")@@ -263,6 +263,23 @@ func (r *SpacesRepository) RotateKey(ctx context.Context, spaceID string, keyVer`, rootWrappedSpaceKey, encryptedProfile, newVersion, spaceID); err != nil {return nil, stacktrace.Propagate(err, "")}+ if len(linkEncryptedSpaceKey) > 0 {+ if _, err := tx.ExecContext(ctx, `+ UPDATE space_links+ SET key_version = $2, encrypted_space_key = $3+ WHERE space_id = $1 AND active = TRUE+ `, spaceID, newVersion, linkEncryptedSpaceKey); err != nil {+ return nil, stacktrace.Propagate(err, "")+ }+ } else {+ if _, err := tx.ExecContext(ctx, `+ UPDATE space_links+ SET active = FALSE+ WHERE space_id = $1 AND active = TRUE+ `, spaceID); err != nil {+ return nil, stacktrace.Propagate(err, "")+ }+ }rec, err := scanSpaceRecord(tx.QueryRowContext(ctx, `SELECT `+spaceRecordSelectColumns+`FROM spaces sdiff --git a/web/apps/space/public/_redirects b/web/apps/space/public/_redirectsindex 46215c87d6..24c7495c74 100644--- a/web/apps/space/public/_redirects+++ b/web/apps/space/public/_redirects@@ -1,6 +1,5 @@/app /app 200/app/friends /app/friends 200-/app/friends/* /app/friends/[spaceId] 200/app/messages /app/messages 200/app/messages/* /app/messages/[spaceId] 200/app/posts/* /app/posts/[spaceId]/[postId] 200diff --git a/web/apps/space/src/components/AuthenticatedFriendProfile.tsx b/web/apps/space/src/components/AuthenticatedFriendProfile.tsxnew file mode 100644index 0000000000..e45e39c058--- /dev/null+++ b/web/apps/space/src/components/AuthenticatedFriendProfile.tsx@@ -0,0 +1,214 @@+import { spaceDefaultProfilePicPath } from "components/SpaceAvatarImage";+import { SpacePageMeta } from "components/SpacePageMeta";+import { SpaceRouteFallback } from "components/SpaceRouteFallback";+import { useBrowserBackClose } from "hooks/useBrowserBackClose";+import React from "react";+import { friendsBackground } from "screens/FriendsScreen";+import {+ FriendProfileImageViewerScreen,+ friendProfileImageViewerBackground,+} from "screens/ProfileImageViewerScreen";+import { ProfileScreen } from "screens/ProfileScreen";+import {+ loadCurrentSpacePostAssetURL,+ loadCurrentSpaceProfile,+ loadCurrentSpaceProfilePostsPage,+ removeCurrentSpaceFriend,+ replyToCurrentPost,+ setCurrentPostLiked,+ type SpaceProfilePost,+} from "services/space";+import {+ patchCachedSpaceFeedPost,+ removeCachedSpaceFeedPostsBySpace,+} from "services/spaceFeedCache";+import { useSpaceAppState } from "state/spaceAppState";+import { profilePostGroupsFromPosts } from "utils/spacePostDisplay";+import { spaceDefaultCoverImagePath } from "utils/spacePostImage";+import { spaceRoutes } from "utils/spaceRoutes";+import {+ hasPreviousSpaceRoute,+ useSpaceRouter,+} from "utils/spaceRouteTransitions";++interface AuthenticatedFriendProfileProps {+ friendSpaceId: string;+ username: string;+}++export const AuthenticatedFriendProfile: React.FC<+ AuthenticatedFriendProfileProps+> = ({ friendSpaceId, username }) => {+ const router = useSpaceRouter();+ const { friends, profile, profileLoadError, profileLoadStatus } =+ useSpaceAppState();+ const [friendProfile, setFriendProfile] =+ React.useState<Awaited<ReturnType<typeof loadCurrentSpaceProfile>>>();+ const [posts, setPosts] = React.useState<SpaceProfilePost[]>([]);+ const [isProfileLoading, setIsProfileLoading] = React.useState(true);+ const [isPostsLoading, setIsPostsLoading] = React.useState(true);+ const [openProfileImage, setOpenProfileImage] = React.useState<+ "avatar" | "cover" | null+ >(null);+ const postGroups = React.useMemo(+ () => profilePostGroupsFromPosts(posts),+ [posts],+ );+ const cachedFriendProfile = friends.find(+ (friend) =>+ friend.spaceId == friendSpaceId ||+ friend.id == friendSpaceId ||+ friend.username == username,+ );+ const hadCachedFriendProfileOnMount = React.useRef(+ Boolean(cachedFriendProfile),+ );+ const immediateFriendProfile = friendProfile ?? cachedFriendProfile;+ const displayedProfile = immediateFriendProfile+ ? {+ ...immediateFriendProfile,+ avatarUrl: immediateFriendProfile.avatarUrl ?? null,+ }+ : {+ avatarUrl: null,+ friendsCount: 0,+ fullName: username,+ id: friendSpaceId,+ spaceId: friendSpaceId,+ spaceSlug: username,+ username,+ };+ const friendAvatarUrl =+ displayedProfile.avatarUrl || spaceDefaultProfilePicPath;+ const friendCoverUrl =+ displayedProfile.coverUrl || spaceDefaultCoverImagePath;+ const friendDisplayName =+ displayedProfile.fullName.trim() ||+ displayedProfile.username.trim() ||+ "Friend";++ useBrowserBackClose({+ open: Boolean(openProfileImage),+ onClose: () => setOpenProfileImage(null),+ stateKey: "space-friend-profile-image",+ });++ React.useEffect(() => {+ const viewerSpaceId = profile?.spaceId;+ if (!viewerSpaceId) return;++ let cancelled = false;+ setFriendProfile(undefined);+ setPosts([]);+ setIsProfileLoading(true);+ setIsPostsLoading(true);+ void loadCurrentSpaceProfile(friendSpaceId, viewerSpaceId)+ .then((nextProfile) => {+ if (!cancelled) setFriendProfile(nextProfile);+ })+ .catch((error: unknown) =>+ console.error("Failed to load friend profile", error),+ )+ .finally(() => {+ if (!cancelled) setIsProfileLoading(false);+ });+ void loadCurrentSpaceProfilePostsPage(friendSpaceId, viewerSpaceId)+ .then((page) => {+ if (!cancelled) setPosts(page.items);+ })+ .catch((error: unknown) =>+ console.error("Failed to load friend posts", error),+ )+ .finally(() => {+ if (!cancelled) setIsPostsLoading(false);+ });++ return () => {+ cancelled = true;+ };+ }, [friendSpaceId, profile?.spaceId]);++ const goBack = () => {+ if (hasPreviousSpaceRoute()) {+ router.back();+ } else {+ void router.push(spaceRoutes.home);+ }+ };++ const unfriend = React.useCallback(async () => {+ const actorSpaceId = profile?.spaceId;+ if (!actorSpaceId) return;++ await removeCurrentSpaceFriend(actorSpaceId, friendSpaceId);+ await removeCachedSpaceFeedPostsBySpace(actorSpaceId, friendSpaceId);+ }, [friendSpaceId, profile?.spaceId]);++ if (profileLoadStatus != "ready" || !profile?.spaceId) {+ return (+ <SpaceRouteFallback+ background={friendsBackground}+ message={profileLoadError}+ />+ );+ }+ if (+ !hadCachedFriendProfileOnMount.current &&+ (isProfileLoading || isPostsLoading)+ ) {+ return <SpaceRouteFallback background={friendsBackground} />;+ }+ const actorSpaceId = profile.spaceId;++ return (+ <>+ <SpacePageMeta themeColor={friendsBackground} />+ <ProfileScreen+ friendsCount={displayedProfile.friendsCount}+ headerVariant="friend"+ isCoverLoading={isProfileLoading}+ isNameLoading={isProfileLoading && !immediateFriendProfile}+ isPostsLoading={isPostsLoading}+ isStatsLoading={isProfileLoading || isPostsLoading}+ onBack={goBack}+ onLoadPostImage={loadCurrentSpacePostAssetURL}+ onMessageFriend={() =>+ void router.push(spaceRoutes.message(friendSpaceId))+ }+ onOpenProfileCover={() => setOpenProfileImage("cover")}+ onOpenProfilePhoto={() => setOpenProfileImage("avatar")}+ onReplyToPost={(postSpaceId, postId, text) =>+ replyToCurrentPost(actorSpaceId, postSpaceId, postId, text)+ }+ onSetPostLiked={async (postId, liked) => {+ await setCurrentPostLiked(actorSpaceId, postId, liked);+ void patchCachedSpaceFeedPost(actorSpaceId, postId, {+ viewerLiked: liked,+ });+ }}+ onUnfriend={unfriend}+ onUnfriendComplete={() => window.location.reload()}+ postGroups={postGroups}+ profile={displayedProfile}+ showPostLoadingIndicator={false}+ />+ {openProfileImage && (+ <>+ <SpacePageMeta+ themeColor={friendProfileImageViewerBackground}+ />+ <FriendProfileImageViewerScreen+ displayName={friendDisplayName}+ imageUrl={+ openProfileImage == "cover"+ ? friendCoverUrl+ : friendAvatarUrl+ }+ onClose={() => setOpenProfileImage(null)}+ variant={openProfileImage}+ />+ </>+ )}+ </>+ );+};diff --git a/web/apps/space/src/components/SpaceFileViewer.tsx b/web/apps/space/src/components/SpaceFileViewer.tsxindex 192b90847d..d7d3e6b9ef 100644--- a/web/apps/space/src/components/SpaceFileViewer.tsx+++ b/web/apps/space/src/components/SpaceFileViewer.tsx@@ -25,6 +25,7 @@ import {} from "components/SpacePostLikeAnimation";import type PhotoSwipe from "photoswipe";import React from "react";+import type { SpaceInviteIntent } from "services/spaceInvite";import { spaceTouchTargetSize } from "styles/touchTargets";import { firstNameFrom, formatSpaceDate } from "utils/spaceDisplay";import { clampSpaceMessageText } from "utils/spaceMessageLimits";@@ -136,6 +137,7 @@ export interface SpaceViewerPhoto {postId?: number;spaceId?: string;timestampMs: number;+ username?: string;viewerLiked?: boolean;width?: number;}@@ -153,6 +155,7 @@ interface SpaceFileViewerProps {onDeletePost?: () => Promise<void> | void;onDraftPostExitStart?: () => void;onDraftPostPublished?: () => void;+ onAddFriendForPostAction?: (intent: SpaceInviteIntent) => void;onOpenProfile?: () => void;onPublishDraftPost?: (caption: string,@@ -307,6 +310,7 @@ export const SpaceFileViewer: React.FC<SpaceFileViewerProps> = ({onDeletePost,onDraftPostExitStart,onDraftPostPublished,+ onAddFriendForPostAction,onOpenProfile,onPublishDraftPost,onReplyToPost,@@ -387,6 +391,9 @@ export const SpaceFileViewer: React.FC<SpaceFileViewerProps> = ({React.useState(focusReplyOnOpen);const [replyActionPhase, setReplyActionPhase] =React.useState<SpaceActionPhase | null>(null);+ const [addFriendSheetOpen, setAddFriendSheetOpen] = React.useState(false);+ const [addFriendIntent, setAddFriendIntent] =+ React.useState<SpaceInviteIntent>("like");const [draftPostActionPhase, setDraftPostActionPhase] =React.useState<SpaceActionPhase | null>(null);const [isDraftPostExit, setIsDraftPostExit] = React.useState(false);@@ -435,11 +442,13 @@ export const SpaceFileViewer: React.FC<SpaceFileViewerProps> = ({hasDraftPostPreparationError ||(!onPublishDraftPost && !canQueueDraftPostPublish);const isReplyActionRunning = replyActionPhase != null;+ const canAddFriendForPostAction = Boolean(+ !isDraftPost && onAddFriendForPostAction,+ );const canReplyToPost = Boolean(!isDraftPost &&- activePhoto.spaceId &&- activePhoto.postId &&- onReplyToPost,+ (canAddFriendForPostAction ||+ (activePhoto.spaceId && activePhoto.postId && onReplyToPost)),);const isReplyMode =canReplyToPost &&@@ -448,13 +457,16 @@ export const SpaceFileViewer: React.FC<SpaceFileViewerProps> = ({!isReplyMode && isPhotoLiked && photoLikePopID > 0;const usePhotoSwipeViewer = !isDraftPost || isDesktopViewer;const canSendReply =- canReplyToPost && !isReplyActionRunning && replyText.trim().length > 0;+ canReplyToPost &&+ !isReplyActionRunning &&+ (canAddFriendForPostAction || replyText.trim().length > 0);const swipeGestureRef = React.useRef<ViewerSwipeGesture | null>(null);const swipeActionsRef = React.useRef({ onSwipeLeft, onSwipeRight });swipeActionsRef.current = { onSwipeLeft, onSwipeRight };const isSwipeBlockedRef = React.useRef(false);isSwipeBlockedRef.current =isActionsOpen ||+ addFriendSheetOpen ||(canDeletePost && deleteSheetOpen) ||isDeleteExit ||isDraftPostExit ||@@ -478,7 +490,18 @@ export const SpaceFileViewer: React.FC<SpaceFileViewerProps> = ({return nextSize;}, []);+ const requestAddFriendForPostAction = (intent: SpaceInviteIntent) => {+ if (!onAddFriendForPostAction) return;+ setAddFriendIntent(intent);+ setAddFriendSheetOpen(true);+ };+const handlePhotoLikeClick = () => {+ if (canAddFriendForPostAction) {+ requestAddFriendForPostAction("like");+ return;+ }+const nextLiked = !isPhotoLiked;if (!activePhoto.postId || !onSetPostLiked) {setIsPhotoLiked(nextLiked);@@ -641,6 +664,11 @@ export const SpaceFileViewer: React.FC<SpaceFileViewerProps> = ({};const sendReply = () => {+ if (canAddFriendForPostAction) {+ requestAddFriendForPostAction("reply");+ return;+ }+const text = replyText.trim();if (!canSendReply ||@@ -669,6 +697,15 @@ export const SpaceFileViewer: React.FC<SpaceFileViewerProps> = ({};const handleReplyKeyDown = (event: React.KeyboardEvent) => {+ if (+ canAddFriendForPostAction &&+ (event.key == "Enter" || event.key == " ")+ ) {+ event.preventDefault();+ requestAddFriendForPostAction("reply");+ return;+ }+if (event.key != "Enter" || event.shiftKey) return;event.preventDefault();@@ -679,6 +716,17 @@ export const SpaceFileViewer: React.FC<SpaceFileViewerProps> = ({event.preventDefault();};+ const handleReplyInputPointerDown = (event: React.PointerEvent) => {+ if (!canAddFriendForPostAction) return;+ event.preventDefault();+ requestAddFriendForPostAction("reply");+ };++ const confirmAddFriendForPostAction = () => {+ setAddFriendSheetOpen(false);+ onAddFriendForPostAction?.(addFriendIntent);+ };+React.useLayoutEffect(() => {resizeCaptionInput(captionInputRef.current, replyInputMinHeight);}, [caption, captionEditValue, isCaptionEditing]);@@ -1052,7 +1100,8 @@ export const SpaceFileViewer: React.FC<SpaceFileViewerProps> = ({React.useEffect(() => {const closeOnEscape = (event: KeyboardEvent) => {- if (deleteSheetOpen || isDraftPostExit) return;+ if (addFriendSheetOpen || deleteSheetOpen || isDraftPostExit)+ return;if (event.key != "Escape") return;if (isCaptionEditing && !isCaptionUpdateActionRunning) {@@ -1066,6 +1115,7 @@ export const SpaceFileViewer: React.FC<SpaceFileViewerProps> = ({return () => window.removeEventListener("keydown", closeOnEscape);}, [cancelCaptionEdit,+ addFriendSheetOpen,deleteSheetOpen,isDraftPostExit,isCaptionEditing,@@ -1965,7 +2015,9 @@ export const SpaceFileViewer: React.FC<SpaceFileViewerProps> = ({}}onFocus={() => setIsReplyFocused(true)}onKeyDown={handleReplyKeyDown}+ onPointerDown={handleReplyInputPointerDown}placeholder={`Reply privately to ${displayName}...`}+ readOnly={canAddFriendForPostAction}rows={1}value={replyText}sx={{@@ -2149,6 +2201,21 @@ export const SpaceFileViewer: React.FC<SpaceFileViewerProps> = ({onExited={handleDeleteSheetExited}/>)}+ {canAddFriendForPostAction && (+ <ConfirmationActionSheet+ appearance="dark"+ open={addFriendSheetOpen}+ title={+ addFriendIntent == "like"+ ? `Add ${displayName} as a friend to like this post?`+ : `Add ${displayName} as a friend to reply privately?`+ }+ confirmLabel="Add friend"+ confirmBackgroundColor={green}+ onCancel={() => setAddFriendSheetOpen(false)}+ onConfirm={confirmAddFriendForPostAction}+ />+ )}</Box>);};diff --git a/web/apps/space/src/components/SpaceMessagesPage.tsx b/web/apps/space/src/components/SpaceMessagesPage.tsxindex 9e05b06fdf..2cc9b3cc19 100644--- a/web/apps/space/src/components/SpaceMessagesPage.tsx+++ b/web/apps/space/src/components/SpaceMessagesPage.tsx@@ -587,9 +587,14 @@ export const SpaceMessagesPage: React.FC<SpaceMessagesPageProps> = ({onCloseThread={closeConversation}onConfirmFriendRequest={confirmFriendRequest}onDeleteFriendRequest={deleteFriendRequest}- onOpenSelectedFriendProfile={(friend) =>- void router.push(spaceRoutes.friend(friendSpaceId(friend)))- }+ onOpenSelectedFriendProfile={(friend) => {+ const username = friend.username || friend.spaceSlug;+ if (username)+ void router.push(+ spaceRoutes.friendPage,+ spaceRoutes.friend(username),+ );+ }}onOpenQuotePost={(quote) =>void router.push(spaceRoutes.post(quote.spaceId, quote.postId),diff --git a/web/apps/space/src/components/SpaceShareInviteButton.tsx b/web/apps/space/src/components/SpaceShareInviteButton.tsxindex 2d598b0131..49cd126653 100644--- a/web/apps/space/src/components/SpaceShareInviteButton.tsx+++ b/web/apps/space/src/components/SpaceShareInviteButton.tsx@@ -2,30 +2,7 @@ import { Share08Icon } from "@hugeicons/core-free-icons";import { HugeiconsIcon } from "@hugeicons/react";import { Box, type SxProps, type Theme } from "@mui/material";import React from "react";--type ShareInviteResult = "shared" | "copied" | "dismissed";-type ShareInvitePhase = "idle" | "sharing" | "copied";--const copiedLabelDurationMs = 1400;--const shareSpaceInviteLink = async (- profileLink: string,-): Promise<ShareInviteResult> => {- if (typeof navigator.share == "function") {- try {- await navigator.share({ url: profileLink });- return "shared";- } catch (error) {- if (error instanceof DOMException && error.name == "AbortError") {- return "dismissed";- }- throw error;- }- }-- await navigator.clipboard.writeText(profileLink);- return "copied";-};+import { openSpaceShareLinkDialog } from "services/spaceShareLink";export const SpaceShareIcon: React.FC<{ strokeWidth?: number }> = ({strokeWidth = 1.8,@@ -58,66 +35,21 @@ export const SpaceShareInviteButton: React.FC<SpaceShareInviteButtonProps> = ({onShareStart,onSharingChange,}) => {- const [phase, setPhase] = React.useState<ShareInvitePhase>("idle");- const copiedResetTimeoutRef = React.useRef<number | undefined>(undefined);- const shareInFlightRef = React.useRef(false);- const isSharing = sharing ?? phase == "sharing";+ const isSharing = sharing ?? false;const isDisabled = isSharing || !profileLink;- const buttonLabel =- label ??- (phase == "copied"- ? "Invite link copied"- : isSharing- ? "Sharing invite..."- : "Share invite");+ const buttonLabel = label ?? "Share invite";- const setSharing = (nextSharing: boolean) => {- if (sharing === undefined) setPhase(nextSharing ? "sharing" : "idle");- onSharingChange?.(nextSharing);- };-- const clearCopiedResetTimeout = React.useCallback(() => {- if (copiedResetTimeoutRef.current === undefined) return;- window.clearTimeout(copiedResetTimeoutRef.current);- copiedResetTimeoutRef.current = undefined;- }, []);-- React.useEffect(- () => () => {- clearCopiedResetTimeout();- },- [clearCopiedResetTimeout],- );-- const shareInvite = async () => {- if (isDisabled || shareInFlightRef.current || !profileLink) return;-- shareInFlightRef.current = true;- clearCopiedResetTimeout();- setPhase("idle");+ const shareInvite = () => {+ if (isDisabled || !profileLink) return;onShareStart?.();-try {- if (typeof navigator.share == "function") setSharing(true);- const result = await shareSpaceInviteLink(profileLink);- if (result == "shared") onShareComplete?.();- if (result == "copied") {- setPhase("copied");- copiedResetTimeoutRef.current = window.setTimeout(() => {- setPhase("idle");- copiedResetTimeoutRef.current = undefined;- onShareComplete?.();- }, copiedLabelDurationMs);- }+ onSharingChange?.(true);+ openSpaceShareLinkDialog();+ onShareComplete?.();} catch (error) {- if (onShareError) {- onShareError(error);- } else {- throw error;- }+ onShareError?.(error);} finally {- shareInFlightRef.current = false;- if (typeof navigator.share == "function") setSharing(false);+ onSharingChange?.(false);}};@@ -127,7 +59,7 @@ export const SpaceShareInviteButton: React.FC<SpaceShareInviteButtonProps> = ({component="button"type="button"disabled={isDisabled}- onClick={() => void shareInvite()}+ onClick={shareInvite}sx={sx}>{showIcon && <SpaceShareIcon strokeWidth={iconStrokeWidth} />}diff --git a/web/apps/space/src/components/SpaceShareLinkDialog.tsx b/web/apps/space/src/components/SpaceShareLinkDialog.tsxnew file mode 100644index 0000000000..52fb22f4d3--- /dev/null+++ b/web/apps/space/src/components/SpaceShareLinkDialog.tsx@@ -0,0 +1,304 @@+import { Box, Dialog, Skeleton, useMediaQuery } from "@mui/material";+import { ConfirmationActionSheet } from "components/ConfirmationActionSheet";+import { SpaceBottomSheetTransition } from "components/SpaceBottomSheetTransition";+import React from "react";+import {+ getOrCreateCurrentSpaceLink,+ rotateCurrentSpaceLink,+ type CurrentSpaceLink,+} from "services/space";+import { spaceInviteURL } from "services/spaceInvite";+import { onOpenSpaceShareLinkDialog } from "services/spaceShareLink";++const green = "#08C225";+const dangerColor = "#F63A3A";++export const SpaceShareLinkDialogHost: React.FC = () => {+ const isBottomSheet = useMediaQuery("(max-width: 599px)");+ const linkRequestID = React.useRef(0);+ const [open, setOpen] = React.useState(false);+ const [link, setLink] = React.useState<CurrentSpaceLink>();+ const [loading, setLoading] = React.useState(false);+ const [error, setError] = React.useState<string>();+ const [copied, setCopied] = React.useState(false);+ const [isChangeConfirmationOpen, setIsChangeConfirmationOpen] =+ React.useState(false);+ const [confirming, setConfirming] = React.useState(false);++ const loadLink = React.useCallback(() => {+ const requestID = ++linkRequestID.current;+ setOpen(true);+ setLink(undefined);+ setLoading(true);+ setError(undefined);+ setCopied(false);+ void getOrCreateCurrentSpaceLink()+ .then((nextLink) => {+ if (linkRequestID.current == requestID) setLink(nextLink);+ })+ .catch((error: unknown) => {+ if (linkRequestID.current != requestID) return;+ console.error("Failed to create Space link", error);+ setError("Couldn't create the link. Please try again.");+ })+ .finally(() => {+ if (linkRequestID.current == requestID) setLoading(false);+ });+ }, []);++ React.useEffect(() => {+ return onOpenSpaceShareLinkDialog(loadLink);+ }, [loadLink]);++ const close = () => {+ linkRequestID.current++;+ setLink(undefined);+ setLoading(false);+ setOpen(false);+ };++ const url = link+ ? spaceInviteURL({+ accessKey: link.accessKey,+ spaceUsername: link.spaceSlug,+ })+ : "";++ const copy = async () => {+ if (!url) return;+ try {+ await navigator.clipboard.writeText(url);+ setCopied(true);+ } catch (error) {+ console.error("Failed to copy Space link", error);+ setError("Couldn't copy the link.");+ }+ };++ const share = async () => {+ if (!url) return;+ if (typeof navigator.share != "function") {+ await copy();+ return;+ }+ try {+ await navigator.share({ url });+ } catch (error) {+ if (+ !(error instanceof DOMException && error.name == "AbortError")+ ) {+ console.error("Failed to share Space link", error);+ setError("Couldn't share the link.");+ }+ }+ };++ const confirm = () => {+ if (confirming) return;+ setConfirming(true);+ setError(undefined);+ void rotateCurrentSpaceLink()+ .then((nextLink) => {+ setIsChangeConfirmationOpen(false);+ setLink(nextLink);+ setCopied(false);+ })+ .catch((error: unknown) => {+ console.error("Failed to change Space link", error);+ setIsChangeConfirmationOpen(false);+ setError("Couldn't change the link.");+ })+ .finally(() => setConfirming(false));+ };++ return (+ <>+ <Dialog+ open={open}+ onClose={close}+ maxWidth={false}+ slots={+ isBottomSheet+ ? { transition: SpaceBottomSheetTransition }+ : undefined+ }+ slotProps={{+ backdrop: {+ sx: { backgroundColor: "rgba(0, 0, 0, 0.48)" },+ },+ paper: {+ sx: {+ bgcolor: "#FAFAFA",+ borderRadius: "28px 28px 0 0",+ bottom: 0,+ boxShadow: "none",+ boxSizing: "border-box",+ left: 0,+ m: 0,+ maxWidth: "none",+ p: "26px 20px 24px",+ position: "fixed",+ width: "100vw",+ "@media (min-width: 600px)": {+ borderRadius: "20px",+ bottom: "auto",+ left: "50%",+ maxWidth: 420,+ top: "50%",+ transform: "translate(-50%, -50%)",+ width: 420,+ },+ },+ },+ }}+ >+ <Box+ component="h2"+ sx={{+ fontFamily: '"Inter Variable", Inter, sans-serif',+ fontSize: 17,+ fontWeight: 700,+ lineHeight: "24px",+ m: 0,+ textAlign: "center",+ }}+ >+ Share+ </Box>+ <Box+ sx={{+ color: "#666",+ fontFamily: '"Inter Variable", Inter, sans-serif',+ fontSize: 13,+ lineHeight: "18px",+ mt: "6px",+ }}+ >+ This link allows anyone who receives it to view your profile+ and all current and future posts. You can remove their+ access at any time by changing the link.+ </Box>+ {loading ? (+ <Skeleton+ variant="rounded"+ sx={{ borderRadius: "14px", height: 52, mt: "22px" }}+ />+ ) : (+ <Box+ sx={{+ alignItems: "center",+ bgcolor: "#FFF",+ border: "1px solid #E7E7E7",+ borderRadius: "14px",+ display: "flex",+ gap: "10px",+ mt: "22px",+ p: "6px 6px 6px 14px",+ }}+ >+ <Box+ sx={{+ flex: 1,+ fontFamily:+ '"Inter Variable", Inter, sans-serif',+ fontSize: 13,+ overflow: "hidden",+ textOverflow: "ellipsis",+ whiteSpace: "nowrap",+ }}+ >+ {url}+ </Box>+ <ActionButton+ label={copied ? "Copied" : "Copy"}+ onClick={copy}+ />+ </Box>+ )}+ {error && (+ <Box+ role="alert"+ sx={{+ color: dangerColor,+ fontSize: 13,+ mt: "10px",+ textAlign: "center",+ }}+ >+ {error}+ </Box>+ )}+ <Box+ sx={{+ display: "flex",+ flexDirection: "column",+ gap: "10px",+ mt: "18px",+ }}+ >+ <ActionButton+ disabled={!link || loading}+ label="Share link"+ primary+ onClick={share}+ />+ <ActionButton+ disabled={!link || loading}+ label="Change link"+ onClick={() => setIsChangeConfirmationOpen(true)}+ />+ </Box>+ </Dialog>+ <ConfirmationActionSheet+ open={isChangeConfirmationOpen}+ title="Change this link?"+ description="A new link will replace this one. People with the current link will no longer be able to load your Space. Anything already downloaded stays with them."+ confirmLabel="Change link"+ confirmBackgroundColor={green}+ confirmDisabled={confirming}+ confirmActionPhase={confirming ? "busy" : null}+ cancelDisabled={confirming}+ onCancel={() => {+ if (!confirming) setIsChangeConfirmationOpen(false);+ }}+ onConfirm={confirm}+ />+ </>+ );+};++interface ActionButtonProps {+ disabled?: boolean;+ label: string;+ onClick: () => void | Promise<void>;+ primary?: boolean;+}++const ActionButton: React.FC<ActionButtonProps> = ({+ disabled,+ label,+ onClick,+ primary,+}) => (+ <Box+ component="button"+ type="button"+ disabled={disabled}+ onClick={() => void onClick()}+ sx={{+ bgcolor: primary ? "#000" : "#F0F0F0",+ border: 0,+ borderRadius: "14px",+ color: primary ? "#FFF" : "#111",+ cursor: disabled ? "default" : "pointer",+ fontFamily: '"Inter Variable", Inter, sans-serif',+ fontSize: 14,+ fontWeight: 650,+ minHeight: 46,+ opacity: disabled ? 0.5 : 1,+ px: "18px",+ }}+ >+ {label}+ </Box>+);diff --git a/web/apps/space/src/pages/_app.tsx b/web/apps/space/src/pages/_app.tsxindex 25b0bc6e34..366fdc926d 100644--- a/web/apps/space/src/pages/_app.tsx+++ b/web/apps/space/src/pages/_app.tsx@@ -3,6 +3,7 @@ import "@fontsource/nunito/800.css";import { CssBaseline } from "@mui/material";import { ThemeProvider } from "@mui/material/styles";import { SpaceRouteTransitionBoundary } from "components/SpaceRouteTransitionBoundary";+import { SpaceShareLinkDialogHost } from "components/SpaceShareLinkDialog";import "configureZod";import { CustomHead } from "ente-base/components/Head";import { useSetupLogs } from "ente-base/components/utils/hooks-app";@@ -46,6 +47,7 @@ const App: React.FC<AppProps> = ({ Component, pageProps }) => {<SpaceRouteTransitionBoundary><SpaceAppStateProvider><Component {...pageProps} />+ <SpaceShareLinkDialogHost /></SpaceAppStateProvider></SpaceRouteTransitionBoundary></ThemeProvider>diff --git a/web/apps/space/src/pages/app/friends/[spaceId].tsx b/web/apps/space/src/pages/app/friends/[spaceId].tsxdeleted file mode 100644index 548312c7e7..0000000000--- a/web/apps/space/src/pages/app/friends/[spaceId].tsx+++ /dev/null@@ -1,333 +0,0 @@-import { spaceDefaultProfilePicPath } from "components/SpaceAvatarImage";-import { SpacePageMeta } from "components/SpacePageMeta";-import { SpaceRouteFallback } from "components/SpaceRouteFallback";-import { useBrowserBackClose } from "hooks/useBrowserBackClose";-import React, { useEffect, useMemo, useState } from "react";-import { friendsBackground } from "screens/FriendsScreen";-import {- FriendProfileImageViewerScreen,- friendProfileImageViewerBackground,-} from "screens/ProfileImageViewerScreen";-import { ProfileScreen } from "screens/ProfileScreen";-import {- loadCurrentSpaceFriends,- loadCurrentSpacePostAssetURL,- loadCurrentSpaceProfile,- loadCurrentSpaceProfilePostsPage,- removeCurrentSpaceFriend,- replyToCurrentPost,- setCurrentPostLiked,- type SpaceProfilePost,-} from "services/space";-import {- patchCachedSpaceFeedPost,- removeCachedSpaceFeedPostsBySpace,-} from "services/spaceFeedCache";-import { useSpaceAppState } from "state/spaceAppState";-import { profilePostGroupsFromPosts } from "utils/spacePostDisplay";-import { spaceDefaultCoverImagePath } from "utils/spacePostImage";-import { friendSpaceIdFromQuery, spaceRoutes } from "utils/spaceRoutes";-import { useSpaceRouter } from "utils/spaceRouteTransitions";--const friendSpaceIdFromPath = () => {- if (typeof window == "undefined") return "";- const match = /^\/app\/friends\/([^/?#]+)/.exec(window.location.pathname);- if (!match?.[1]) return "";-- try {- return decodeURIComponent(match[1]);- } catch {- return "";- }-};--const Page: React.FC = () => {- const router = useSpaceRouter();- const {- friends,- profile,- profileLoadError,- profileLoadStatus,- setFriends,- } = useSpaceAppState();- const friendSpaceId =- friendSpaceIdFromQuery(router.query.spaceId) || friendSpaceIdFromPath();- const selectedFriend = friends.find(- (friend) =>- friend.spaceId == friendSpaceId || friend.id == friendSpaceId,- );- const [friendsLoadAttempted, setFriendsLoadAttempted] = useState(false);- const [isProfileLoading, setIsProfileLoading] = useState(false);- const [isPostsLoading, setIsPostsLoading] = useState(false);- const [openProfileImage, setOpenProfileImage] = useState<- "avatar" | "cover" | null- >(null);- const [loadedProfileSpaceId, setLoadedProfileSpaceId] = useState<string>();- const [loadedPostsSpaceId, setLoadedPostsSpaceId] = useState<string>();- const [selectedProfile, setSelectedProfile] = useState(selectedFriend);- const [posts, setPosts] = useState<SpaceProfilePost[]>([]);- const selectedFriendSpaceId = selectedFriend?.spaceId;- const hasLoadedPostsForSelectedFriend =- loadedPostsSpaceId == selectedFriendSpaceId;- const postGroups = useMemo(- () =>- hasLoadedPostsForSelectedFriend- ? profilePostGroupsFromPosts(posts)- : [],- [hasLoadedPostsForSelectedFriend, posts],- );- const showProfileLoading = Boolean(- selectedFriendSpaceId &&- (isProfileLoading || loadedProfileSpaceId != selectedFriendSpaceId),- );- const showPostsLoading = Boolean(- selectedFriendSpaceId &&- (isPostsLoading || !hasLoadedPostsForSelectedFriend),- );- const currentSelectedProfile =- selectedProfile?.spaceId == selectedFriendSpaceId- ? selectedProfile- : undefined;- const friendAvatarUrl =- (currentSelectedProfile- ? currentSelectedProfile.avatarUrl- : selectedFriend?.avatarUrl) || spaceDefaultProfilePicPath;- const friendCoverUrl =- currentSelectedProfile?.coverUrl || spaceDefaultCoverImagePath;- const friendDisplayName =- currentSelectedProfile?.fullName.trim() ||- selectedFriend?.fullName.trim() ||- currentSelectedProfile?.username.trim() ||- selectedFriend?.username.trim() ||- "Friend";-- useBrowserBackClose({- open: Boolean(openProfileImage),- onClose: () => setOpenProfileImage(null),- stateKey: "space-friend-profile-image",- });-- useEffect(() => {- if (!router.isReady) return;- if (profileLoadStatus == "ready" && !profile) {- void router.replace(spaceRoutes.onboarding);- return;- }- if (- profileLoadStatus == "ready" &&- friendsLoadAttempted &&- !selectedFriend- ) {- void router.replace(spaceRoutes.friends);- }- }, [- friendsLoadAttempted,- profile,- profileLoadStatus,- router,- selectedFriend,- ]);-- useEffect(() => {- if (!profile?.spaceId) return;-- void loadCurrentSpaceFriends(profile.spaceId)- .then(setFriends)- .catch((error: unknown) =>- console.error("Failed to load space friends", error),- )- .finally(() => setFriendsLoadAttempted(true));- }, [profile?.spaceId, setFriends]);-- useEffect(() => {- const viewerSpaceId = profile?.spaceId;- if (!viewerSpaceId || !selectedFriendSpaceId) {- setIsProfileLoading(false);- setIsPostsLoading(false);- setLoadedProfileSpaceId(undefined);- setLoadedPostsSpaceId(undefined);- setSelectedProfile(undefined);- setPosts([]);- return;- }-- let cancelled = false;- setSelectedProfile(undefined);- setPosts([]);- setIsProfileLoading(true);- setIsPostsLoading(true);- void loadCurrentSpaceProfile(selectedFriendSpaceId, viewerSpaceId)- .then((nextProfile) => {- if (cancelled) return;- setSelectedProfile(nextProfile);- })- .catch((error: unknown) =>- console.error("Failed to load friend profile", error),- )- .finally(() => {- if (!cancelled) {- setLoadedProfileSpaceId(selectedFriendSpaceId);- setIsProfileLoading(false);- }- });- void loadCurrentSpaceProfilePostsPage(- selectedFriendSpaceId,- viewerSpaceId,- )- .then((page) => {- if (!cancelled) setPosts(page.items);- })- .catch((error: unknown) =>- console.error("Failed to load friend posts", error),- )- .finally(() => {- if (!cancelled) {- setLoadedPostsSpaceId(selectedFriendSpaceId);- setIsPostsLoading(false);- }- });-- return () => {- cancelled = true;- };- }, [profile?.spaceId, selectedFriendSpaceId]);-- const goBack = () => {- if (typeof window != "undefined" && window.history.length > 1) {- router.back();- return;- }- void router.push(spaceRoutes.friends);- };-- const unfriend = React.useCallback(async () => {- const actorSpaceId = profile?.spaceId;- if (!actorSpaceId || !selectedFriendSpaceId) return;-- await removeCurrentSpaceFriend(actorSpaceId, selectedFriendSpaceId);- await removeCachedSpaceFeedPostsBySpace(- actorSpaceId,- selectedFriendSpaceId,- );- }, [profile?.spaceId, selectedFriendSpaceId]);-- const finishUnfriend = React.useCallback(() => {- window.location.replace(spaceRoutes.friends);- }, []);-- if (- !router.isReady ||- profileLoadStatus != "ready" ||- !profile ||- !selectedFriend- ) {- return (- <SpaceRouteFallback- background={friendsBackground}- message={profileLoadError}- />- );- }- const actorSpaceId = profile.spaceId;- if (!actorSpaceId) {- return (- <SpaceRouteFallback- background={friendsBackground}- message={profileLoadError}- />- );- }-- return (- <>- <SpacePageMeta themeColor={friendsBackground} />- <ProfileScreen- friendsCount={- currentSelectedProfile?.friendsCount ??- selectedFriend.friendsCount- }- headerVariant="friend"- isCoverLoading={showProfileLoading}- isPostsLoading={showPostsLoading}- isStatsLoading={showProfileLoading || showPostsLoading}- postGroups={postGroups}- profile={{- avatarKeyVersion:- currentSelectedProfile?.avatarKeyVersion ??- selectedFriend.avatarKeyVersion,- avatarObjectID:- currentSelectedProfile?.avatarObjectID ??- selectedFriend.avatarObjectID,- avatarUpdatedAt:- currentSelectedProfile?.avatarUpdatedAt ??- selectedFriend.avatarUpdatedAt,- avatarUrl:- currentSelectedProfile?.avatarUrl ??- selectedFriend.avatarUrl ??- null,- coverUrl: currentSelectedProfile?.coverUrl ?? null,- coverKeyVersion: currentSelectedProfile?.coverKeyVersion,- coverObjectID: currentSelectedProfile?.coverObjectID,- coverUpdatedAt: currentSelectedProfile?.coverUpdatedAt,- fullName:- currentSelectedProfile?.fullName ??- selectedFriend.fullName,- username:- currentSelectedProfile?.username ??- selectedFriend.username,- spaceId:- currentSelectedProfile?.spaceId ??- selectedFriend.spaceId,- spaceSlug:- currentSelectedProfile?.spaceSlug ??- selectedFriend.spaceSlug,- }}- onBack={goBack}- onLoadPostImage={loadCurrentSpacePostAssetURL}- onMessageFriend={- selectedFriendSpaceId- ? () =>- void router.push(- spaceRoutes.message(selectedFriendSpaceId),- )- : undefined- }- onOpenProfileCover={() => setOpenProfileImage("cover")}- onOpenProfilePhoto={() => setOpenProfileImage("avatar")}- onReplyToPost={(postSpaceId, postId, text) =>- replyToCurrentPost(actorSpaceId, postSpaceId, postId, text)- }- onSetPostLiked={async (postId, liked) => {- await setCurrentPostLiked(actorSpaceId, postId, liked);- void patchCachedSpaceFeedPost(actorSpaceId, postId, {- viewerLiked: liked,- });- }}- onUnfriend={selectedFriendSpaceId ? unfriend : undefined}- onUnfriendComplete={- selectedFriendSpaceId ? finishUnfriend : undefined- }- showPostLoadingIndicator={false}- />- {openProfileImage && (- <>- <SpacePageMeta- themeColor={friendProfileImageViewerBackground}- />- <FriendProfileImageViewerScreen- displayName={friendDisplayName}- imageUrl={- openProfileImage == "cover"- ? friendCoverUrl- : friendAvatarUrl- }- onClose={() => setOpenProfileImage(null)}- variant={openProfileImage}- />- </>- )}- </>- );-};--export default Page;diff --git a/web/apps/space/src/pages/app/friends/index.tsx b/web/apps/space/src/pages/app/friends/index.tsxindex 3ea737c521..6f7a46968c 100644--- a/web/apps/space/src/pages/app/friends/index.tsx+++ b/web/apps/space/src/pages/app/friends/index.tsx@@ -100,9 +100,18 @@ const Page: React.FC = () => {void router.push(spaceRoutes.message(friend.spaceId));}}}- onOpenFriend={(friendID) =>- void router.push(spaceRoutes.friend(friendID))- }+ onOpenFriend={(friendID) => {+ const friend = friends.find(+ (candidate) =>+ candidate.id == friendID ||+ candidate.spaceId == friendID,+ );+ if (friend)+ void router.push(+ spaceRoutes.friendPage,+ spaceRoutes.friend(friend.username),+ );+ }}profileLink={spaceInviteURL({spaceUsername: profile.username,})}diff --git a/web/apps/space/src/pages/app/index.tsx b/web/apps/space/src/pages/app/index.tsxindex cbd72df1fe..68ee089743 100644--- a/web/apps/space/src/pages/app/index.tsx+++ b/web/apps/space/src/pages/app/index.tsx@@ -419,9 +419,20 @@ const Page: React.FC = () => {),);}}- onOpenFriend={(friendID) =>- void router.push(spaceRoutes.friend(friendID))- }+ onOpenFriend={(friendID, username) => {+ const friend = friends.find(+ (candidate) =>+ candidate.id == friendID ||+ candidate.spaceId == friendID,+ );+ const friendUsername = username || friend?.username;+ if (friendUsername) {+ void router.push(+ spaceRoutes.friendPage,+ spaceRoutes.friend(friendUsername),+ );+ }+ }}onLoadMoreFeedItems={loadMoreFeedItems}onLoadPostAvatar={loadCurrentSpacePostAvatarURL}onLoadPostImage={loadCurrentSpacePostAssetURL}diff --git a/web/apps/space/src/pages/app/posts/[spaceId]/[postId].tsx b/web/apps/space/src/pages/app/posts/[spaceId]/[postId].tsxindex 4630c7bfb3..c17b4cd09f 100644--- a/web/apps/space/src/pages/app/posts/[spaceId]/[postId].tsx+++ b/web/apps/space/src/pages/app/posts/[spaceId]/[postId].tsx@@ -115,20 +115,27 @@ const Page: React.FC = () => {};}, [postRouteKey, profile?.spaceId, profileLoadStatus, spaceId, postId]);- const ownerProfileRoute = React.useCallback(() => {+ const openOwnerProfile = React.useCallback(() => {const ownerSpaceId = post?.spaceId ?? spaceId;- return ownerSpaceId == profile?.spaceId- ? spaceRoutes.profile- : spaceRoutes.friend(ownerSpaceId);- }, [post?.spaceId, profile?.spaceId, spaceId]);+ if (ownerSpaceId == profile?.spaceId) {+ void router.push(spaceRoutes.profile);+ } else if (post?.username) {+ void router.push(+ spaceRoutes.friendPage,+ spaceRoutes.friend(post.username),+ );+ } else {+ void router.push(spaceRoutes.home);+ }+ }, [post?.spaceId, post?.username, profile?.spaceId, router, spaceId]);const closePost = React.useCallback(() => {if (typeof window != "undefined" && window.history.length > 1) {router.back();return;}- void router.push(ownerProfileRoute());- }, [ownerProfileRoute, router]);+ openOwnerProfile();+ }, [openOwnerProfile, router]);if (!router.isReady ||@@ -163,7 +170,7 @@ const Page: React.FC = () => {photo={viewerPhotoFromPost(post)}postActionMode={isOwnPost ? "hidden" : "like-only"}onClose={closePost}- onOpenProfile={() => void router.push(ownerProfileRoute())}+ onOpenProfile={openOwnerProfile}onReplyToPost={isOwnPost? undefineddiff --git a/web/apps/space/src/pages/index.tsx b/web/apps/space/src/pages/index.tsxindex 261fbdd7ba..ef94171d47 100644--- a/web/apps/space/src/pages/index.tsx+++ b/web/apps/space/src/pages/index.tsx@@ -1,46 +1,71 @@import { Box } from "@mui/material";+import { AuthenticatedFriendProfile } from "components/AuthenticatedFriendProfile";import { SpaceButtonSpinner } from "components/SpaceButtonSpinner";import { SpaceMobileBestToast } from "components/SpaceMobileBestToast";import { SpacePageMeta } from "components/SpacePageMeta";import { SpaceRouteFallback } from "components/SpaceRouteFallback";-import React, { useEffect, useState } from "react";+import React, { useEffect, useMemo, useState } from "react";import {OnboardingScreen,addFriendOnboardingTitle,onboardingGreen,} from "screens/OnboardingScreen";-import { profileBackground } from "screens/ProfileScreen";+import { ProfileScreen, profileBackground } from "screens/ProfileScreen";import {joinSpaceInvite,+ loadCurrentSpaceRelationship,loadPublicSpaceIdentity,+ openPublicSpaceLink,type PublicSpaceIdentity,+ type PublicSpaceLinkSession,+ type SpaceProfilePost,} from "services/space";import {clearPendingSpaceInvite,clearPendingSpaceInviteFriend,+ clearPendingSpaceInviteIntent,savePendingSpaceInvite,savePendingSpaceInviteFriend,+ savePendingSpaceInviteIntent,saveSentSpaceInviteFriend,savedPendingSpaceInvite,+ savedPendingSpaceInviteIntent,spaceInviteFromLocation,type PendingSpaceInvite,+ type SpaceInviteIntent,+ type SpaceInviteRoute,} from "services/spaceInvite";import {useSpaceAppState,type OnboardingEntrySource,} from "state/spaceAppState";+import { profilePostGroupsFromPosts } from "utils/spacePostDisplay";import { spaceRoutes } from "utils/spaceRoutes";import { useSpaceRouter } from "utils/spaceRouteTransitions";type RouteMode =| { kind: "checking" }| { kind: "app" }- | ({ kind: "public-profile" } & PendingSpaceInvite);+ | ({ kind: "public-profile" } & SpaceInviteRoute);++type AuthenticatedProfileRoute = "friend" | "self";+type AuthenticatedProfileRouteStatus = "idle" | "loading" | "complete";interface PageProps {invitePreview?: boolean;}+const addFriendPostActionOnboardingTitle = (+ username: string,+ intent: SpaceInviteIntent,+) => (+ <>+ {`Add @${username} as a friend`}+ <br />+ {intent == "like" ? "to like their posts" : "to reply privately"}+ </>+);+const PublicProfileUnavailable: React.FC = () => (<BoxclassName="green-bg"@@ -85,12 +110,14 @@ interface PublicFriendRequestScreenProps {identity: PublicSpaceIdentity;isAddingFriend: boolean;onAddFriend: () => void;+ showAddingFriendSpinner: boolean;}const PublicFriendRequestScreen: React.FC<PublicFriendRequestScreenProps> = ({identity,isAddingFriend,onAddFriend,+ showAddingFriendSpinner,}) => (<Boxcomponent="main"@@ -259,7 +286,11 @@ const PublicFriendRequestScreen: React.FC<PublicFriendRequestScreenProps> = ({},}}>- {isAddingFriend ? <SpaceButtonSpinner /> : "Add Friend"}+ {showAddingFriendSpinner ? (+ <SpaceButtonSpinner />+ ) : (+ "Add Friend"+ )}</Box></Box></Box>@@ -281,8 +312,25 @@ export const Page: React.FC<PageProps> = ({ invitePreview }) => {const [publicIdentity, setPublicIdentity] =useState<PublicSpaceIdentity | null>(null);const [publicError, setPublicError] = useState<string>();+ const [publicLink, setPublicLink] = useState<PublicSpaceLinkSession | null>(+ null,+ );+ const [authenticatedProfileRoute, setAuthenticatedProfileRoute] =+ useState<AuthenticatedProfileRoute>();+ const [+ authenticatedProfileRouteStatus,+ setAuthenticatedProfileRouteStatus,+ ] = useState<AuthenticatedProfileRouteStatus>("idle");+ const [publicPosts, setPublicPosts] = useState<SpaceProfilePost[]>([]);+ const [arePublicPostsLoading, setArePublicPostsLoading] = useState(false);const [pendingInviteUsername, setPendingInviteUsername] = useState("");+ const [pendingInviteIntent, setPendingInviteIntent] =+ useState<SpaceInviteIntent>();const [isAddingFriend, setIsAddingFriend] = useState(false);+ const publicPostGroups = useMemo(+ () => profilePostGroupsFromPosts(publicPosts),+ [publicPosts],+ );useEffect(() => {const publicInvite = spaceInviteFromLocation();@@ -293,6 +341,7 @@ export const Page: React.FC<PageProps> = ({ invitePreview }) => {);if (pendingInvite) {setPendingInviteUsername(pendingInvite.spaceUsername);+ setPendingInviteIntent(savedPendingSpaceInviteIntent());}}setRouteMode(@@ -305,22 +354,152 @@ export const Page: React.FC<PageProps> = ({ invitePreview }) => {useEffect(() => {if (routeMode.kind != "public-profile") return;- let cancelled = false;+ const abortController = new AbortController();+ const isAborted = () => abortController.signal.aborted;+ setAuthenticatedProfileRoute(undefined);+ setAuthenticatedProfileRouteStatus("idle");setPublicError(undefined);setPublicIdentity(null);- void loadPublicSpaceIdentity(routeMode.spaceUsername)- .then((identity) => {- if (!cancelled) setPublicIdentity(identity);- })- .catch(() => {- if (!cancelled) setPublicError("This profile is unavailable.");- });+ setPublicLink(null);+ setPublicPosts([]);+ setArePublicPostsLoading(false);++ let openedLink: PublicSpaceLinkSession | undefined;+ let settled = false;+ void (async () => {+ try {+ if (!routeMode.accessKey) {+ const identity = await loadPublicSpaceIdentity(+ routeMode.spaceUsername,+ );+ if (isAborted()) return;+ setPublicIdentity(identity);+ return;+ }++ try {+ openedLink = await openPublicSpaceLink(+ routeMode.spaceUsername,+ routeMode.accessKey,+ );+ } catch {+ const identity = await loadPublicSpaceIdentity(+ routeMode.spaceUsername,+ );+ if (isAborted()) return;+ setPublicIdentity(identity);+ return;+ }+ if (isAborted()) {+ openedLink.close();+ openedLink = undefined;+ return;+ }+ const link = openedLink;+ if (!link.profile.spaceId) {+ throw new Error("Public Space profile is missing its ID.");+ }+ setPublicLink(link);+ setPublicIdentity({+ spaceId: link.profile.spaceId,+ username: link.profile.username,+ });+ setArePublicPostsLoading(true);+ const loadPosts = link+ .loadPosts()+ .then((posts) => {+ if (!isAborted()) setPublicPosts(posts);+ })+ .catch((error: unknown) =>+ console.error(+ "Failed to load public Space posts",+ error,+ ),+ )+ .finally(() => {+ if (!isAborted()) setArePublicPostsLoading(false);+ });+ const loadProfileMedia = link+ .loadProfileMedia()+ .then((media) => {+ if (isAborted()) return;+ setPublicLink((currentLink) =>+ currentLink == link+ ? {+ ...link,+ profile: { ...link.profile, ...media },+ }+ : currentLink,+ );+ })+ .catch((error: unknown) =>+ console.error(+ "Failed to load public Space profile media",+ error,+ ),+ );+ await Promise.allSettled([loadPosts, loadProfileMedia]);+ } catch {+ if (!isAborted())+ setPublicError("This profile is unavailable.");+ } finally {+ settled = true;+ if (isAborted()) {+ openedLink?.close();+ openedLink = undefined;+ }+ }+ })();return () => {- cancelled = true;+ abortController.abort();+ if (settled) {+ openedLink?.close();+ openedLink = undefined;+ }};}, [routeMode]);+ useEffect(() => {+ setAuthenticatedProfileRoute(undefined);+ if (+ routeMode.kind != "public-profile" ||+ !publicIdentity ||+ profileLoadStatus == "loading"+ ) {+ setAuthenticatedProfileRouteStatus("idle");+ return;+ }+ if (profileLoadStatus != "ready" || !profile?.spaceId) {+ setAuthenticatedProfileRouteStatus("complete");+ return;+ }++ const abortController = new AbortController();+ setAuthenticatedProfileRouteStatus("loading");+ void (async () => {+ let relationship: AuthenticatedProfileRoute | null = null;+ if (publicIdentity.spaceId == profile.spaceId) {+ relationship = "self";+ } else {+ try {+ relationship = await loadCurrentSpaceRelationship(+ publicIdentity.spaceId,+ );+ } catch (error) {+ console.error("Failed to load Space relationship", error);+ }+ }+ if (abortController.signal.aborted) return;+ setAuthenticatedProfileRoute(relationship ?? undefined);+ setAuthenticatedProfileRouteStatus("complete");+ })();++ return () => {+ abortController.abort();+ };+ }, [profile?.spaceId, profileLoadStatus, publicIdentity, routeMode.kind]);+useEffect(() => {if (routeMode.kind == "app" &&@@ -331,6 +510,12 @@ export const Page: React.FC<PageProps> = ({ invitePreview }) => {}}, [profile, profileLoadStatus, routeMode.kind, router]);+ useEffect(() => {+ if (authenticatedProfileRoute == "self") {+ void router.replace(spaceRoutes.profile);+ }+ }, [authenticatedProfileRoute, router]);+const hasProfileLoadError =routeMode.kind == "app" && profileLoadStatus == "error";@@ -357,6 +542,26 @@ export const Page: React.FC<PageProps> = ({ invitePreview }) => {}if (routeMode.kind == "public-profile") {+ if (+ profileLoadStatus == "loading" ||+ (profile && authenticatedProfileRouteStatus != "complete")+ ) {+ return <SpaceRouteFallback background={profileBackground} />;+ }++ if (authenticatedProfileRoute == "friend" && publicIdentity) {+ return (+ <AuthenticatedFriendProfile+ friendSpaceId={publicIdentity.spaceId}+ username={publicIdentity.username}+ />+ );+ }++ if (authenticatedProfileRoute == "self") {+ return <SpaceRouteFallback background={profileBackground} />;+ }+if (!publicIdentity && !publicError) {return <SpaceRouteFallback background={profileBackground} />;}@@ -374,16 +579,21 @@ export const Page: React.FC<PageProps> = ({ invitePreview }) => {}const inviteFriend = {- fullName: "",+ fullName: publicLink?.profile.fullName ?? "",username: publicIdentity.username,};- const addFriend = async () => {+ const addFriend = async (intent?: SpaceInviteIntent) => {const invite = {spaceId: publicIdentity.spaceId,spaceUsername: publicIdentity.username,};savePendingSpaceInvite(invite);savePendingSpaceInviteFriend(inviteFriend);+ if (intent) {+ savePendingSpaceInviteIntent(intent);+ } else {+ clearPendingSpaceInviteIntent();+ }setOnboardingEntrySource("add-friend-link");setIsAddingFriend(true);try {@@ -399,6 +609,7 @@ export const Page: React.FC<PageProps> = ({ invitePreview }) => {const status = await joinSpaceInvite(invite);clearPendingSpaceInvite();clearPendingSpaceInviteFriend();+ clearPendingSpaceInviteIntent();if (status == "requested") {saveSentSpaceInviteFriend(inviteFriend);}@@ -415,11 +626,41 @@ export const Page: React.FC<PageProps> = ({ invitePreview }) => {themeColor={profileBackground}preview="invite"/>- <PublicFriendRequestScreen- identity={publicIdentity}- isAddingFriend={isAddingFriend}- onAddFriend={() => void addFriend()}- />+ {publicLink ? (+ <>+ <ProfileScreen+ friendsCount={publicLink.profile.friendsCount}+ headerVariant={+ profile ? "public" : "public-anonymous"+ }+ isAddingFriend={isAddingFriend}+ isPostsLoading={arePublicPostsLoading}+ isStatsLoading={false}+ onAddFriend={() => void addFriend()}+ onAddFriendForPostAction={(intent) =>+ void addFriend(intent)+ }+ onBack={() => window.location.assign("/")}+ onLoadPostImage={publicLink.loadPostImage}+ postGroups={publicPostGroups}+ postsCount={publicLink.postsCount}+ profile={publicLink.profile}+ showAddingFriendSpinner={+ isAddingFriend && Boolean(profile)+ }+ />+ {!profile && <SpaceMobileBestToast />}+ </>+ ) : (+ <PublicFriendRequestScreen+ identity={publicIdentity}+ isAddingFriend={isAddingFriend}+ onAddFriend={() => void addFriend()}+ showAddingFriendSpinner={+ isAddingFriend && Boolean(profile)+ }+ />+ )}</>);}@@ -435,7 +676,12 @@ export const Page: React.FC<PageProps> = ({ invitePreview }) => {onLogin={() => void router.push(spaceRoutes.login)}title={isAddFriendLinkOnboarding- ? addFriendOnboardingTitle(pendingInviteUsername)+ ? pendingInviteIntent+ ? addFriendPostActionOnboardingTitle(+ pendingInviteUsername,+ pendingInviteIntent,+ )+ : addFriendOnboardingTitle(pendingInviteUsername): undefined}/>diff --git a/web/apps/space/src/screens/HomeScreen.tsx b/web/apps/space/src/screens/HomeScreen.tsxindex 08e47168f5..45bd83e6d5 100644--- a/web/apps/space/src/screens/HomeScreen.tsx+++ b/web/apps/space/src/screens/HomeScreen.tsx@@ -135,7 +135,7 @@ interface HomeScreenProps {onLoadPostImage?: SpacePostAssetURLLoader;onFriendRequestSentToastClose?: () => void;onInviteFriendsToastClose?: () => void;- onOpenFriend?: (friendID: string) => void;+ onOpenFriend?: (friendID: string, username?: string) => void;onOpenMessages?: () => void;onOpenProfile?: () => void;onReplyToPost?: (@@ -407,7 +407,7 @@ interface FeedItemProps {name: string;onLoadAvatar?: () => Promise<string | null | undefined>;onLoadImage?: () => Promise<string | undefined>;- onOpenFriend?: (friendID: string) => void;+ onOpenFriend?: (friendID: string, username?: string) => void;onOpenPhoto?: (photo: SpaceViewerPhoto, focusReplyOnOpen?: boolean) => void;onOpenProfile?: () => void;onSetPostLiked?: (postId: number, liked: boolean) => Promise<void>;@@ -416,6 +416,7 @@ interface FeedItemProps {thumbHash?: string;timestampStatus?: FeedTimestampStatus;timestampMs: number;+ username?: string;viewerLiked: boolean;}@@ -710,6 +711,7 @@ const FeedItem: React.FC<FeedItemProps> = ({thumbHash,timestampStatus,timestampMs,+ username,viewerLiked,}) => {const [isLiked, setIsLiked] = useState(viewerLiked);@@ -738,7 +740,7 @@ const FeedItem: React.FC<FeedItemProps> = ({onOpenProfile?.();return;}- onOpenFriend?.(friendID);+ onOpenFriend?.(friendID, username);};const [loadedPhotoDimensions, setLoadedPhotoDimensions] =useState<LoadedFeedPhotoDimensions | null>(null);@@ -799,6 +801,7 @@ const FeedItem: React.FC<FeedItemProps> = ({postId,spaceId,timestampMs,+ username,viewerLiked: isLiked,width: photoDimensions.width,},@@ -1768,6 +1771,7 @@ export const HomeScreen: React.FC<HomeScreenProps> = ({thumbHash={item.thumbHash}timestampStatus={timestampStatus}timestampMs={item.timestampMs}+ username={item.username}viewerLiked={item.viewerLiked}/>);@@ -2460,7 +2464,10 @@ export const HomeScreen: React.FC<HomeScreenProps> = ({"back",).finally(() => {closeSelectedPhoto();- onOpenFriend(selectedPhotoFriendID);+ onOpenFriend(+ selectedPhotoFriendID,+ selectedViewer.photo.username,+ );});}: undefineddiff --git a/web/apps/space/src/screens/ProfileScreen.tsx b/web/apps/space/src/screens/ProfileScreen.tsxindex 371fd68996..e9122a6f40 100644--- a/web/apps/space/src/screens/ProfileScreen.tsx+++ b/web/apps/space/src/screens/ProfileScreen.tsx@@ -4,7 +4,6 @@ import {BubbleChatIcon,Menu01Icon,MoreHorizontalIcon,- MultiplicationSignIcon,UserRemove01Icon,} from "@hugeicons/core-free-icons";import { HugeiconsIcon } from "@hugeicons/react";@@ -15,6 +14,7 @@ import {type SpaceActionPhase,} from "components/SpaceActionFeedback";import { SpaceAvatarImage } from "components/SpaceAvatarImage";+import { SpaceButtonSpinner } from "components/SpaceButtonSpinner";import {SpaceFileViewer,SpaceViewerFeedBackdrop,@@ -29,6 +29,8 @@ import { useBrowserBackClose } from "hooks/useBrowserBackClose";import React, { useState } from "react";import type { SetupProfile } from "screens/SetupProfileScreen";import type { SpacePostAsset } from "services/space";+import type { SpaceInviteIntent } from "services/spaceInvite";+import { openSpaceShareLinkDialog } from "services/spaceShareLink";import { spaceTouchTargetSize } from "styles/touchTargets";import { createLoadedLocalPostPhoto } from "utils/localPostPhoto";import { firstNameFrom } from "utils/spaceDisplay";@@ -59,11 +61,10 @@ const profileAvatarSize = 120;const profileCoverHeight =profileHeaderHeight + profileAvatarTopOffset + profileAvatarSize / 2;const photoMasonryGap = "3px";-const profileHorizontalPadding = "16px";const photoMasonryPlaceholderBackground = "#F2F2F2";const photoMasonryRadius = "12px";const photoMasonryLoadRootMargin = "800px 0px";-const profileToastTransition = "opacity 160ms ease, transform 160ms ease";+const publicPhotoMasonryLoadRootMargin = "400px 0px";interface ProfilePhotoDimensions {height: number;width: number;@@ -126,18 +127,6 @@ interface PostMasonryRow {tiles: PostMasonryTile[];}-interface ProfileToastProps {- message: string;- open: boolean;- onClose?: () => void;- onExited?: () => void;-}--interface ProfileToastState {- message: string;- open: boolean;-}-const buildPostMasonryRows = (items: ProfilePostItem[],loadedDimensionsByID: Record<string, ProfilePhotoDimensions>,@@ -231,6 +220,49 @@ const ProfileStatsSkeleton: React.FC = () => (</Box>);+interface PublicProfileAddFriendButtonProps {+ isAddingFriend: boolean;+ onAddFriend: () => void;+ showSpinner: boolean;+}++const PublicProfileAddFriendButton: React.FC<+ PublicProfileAddFriendButtonProps+> = ({ isAddingFriend, onAddFriend, showSpinner }) => (+ <Box+ component="button"+ type="button"+ disabled={isAddingFriend}+ onClick={onAddFriend}+ sx={{+ alignItems: "center",+ appearance: "none",+ bgcolor: "#FFF",+ border: 0,+ borderRadius: "14px",+ color: "#000",+ cursor: isAddingFriend ? "default" : "pointer",+ display: "flex",+ flexShrink: 0,+ fontFamily: '"Inter Variable", Inter, sans-serif',+ fontSize: 14,+ fontWeight: 600,+ justifyContent: "center",+ justifySelf: "end",+ lineHeight: "18px",+ px: "14px",+ py: "8px",+ "&:hover": { bgcolor: isAddingFriend ? "#FFF" : "#F4F4F4" },+ "&:focus-visible": {+ outline: `2px solid ${green}`,+ outlineOffset: 2,+ },+ }}+ >+ {showSpinner ? <SpaceButtonSpinner /> : "Add Friend"}+ </Box>+);+const ProfilePostLoadingIndicator: React.FC = () => (<Boxsx={{@@ -258,6 +290,7 @@ interface ProfilePostTileProps {index: number;isSingleItemRow: boolean;item: ProfilePostItem;+ loadRootMargin: string;onLoadImage: () => Promise<string | undefined>;onOpen: (imageUrl: string) => void;onRememberDimensions: (itemID: string, image: HTMLImageElement) => void;@@ -272,6 +305,7 @@ const ProfilePostTile: React.FC<ProfilePostTileProps> = ({index,isSingleItemRow,item,+ loadRootMargin,onLoadImage,onOpen,onRememberDimensions,@@ -308,11 +342,11 @@ const ProfilePostTile: React.FC<ProfilePostTileProps> = ({observer.disconnect();}},- { rootMargin: photoMasonryLoadRootMargin },+ { rootMargin: loadRootMargin },);observer.observe(element);return () => observer.disconnect();- }, [imageUrl, shouldLoad]);+ }, [imageUrl, loadRootMargin, shouldLoad]);React.useEffect(() => {if (!shouldLoad || imageUrl) return;@@ -405,133 +439,19 @@ const ProfilePostTile: React.FC<ProfilePostTileProps> = ({);};-const CopyIcon: React.FC = () => (- <svg- width="14"- height="14"- viewBox="0 0 14 14"- fill="none"- xmlns="http://www.w3.org/2000/svg"- >- <path- d="M4.5 4.5V2.5C4.5 1.39543 5.39543 0.5 6.5 0.5H11.5C12.6046 0.5 13.5 1.39543 13.5 2.5V7.5C13.5 8.60457 12.6046 9.5 11.5 9.5H9.5M2.5 4.5H7.5C8.60457 4.5 9.5 5.39543 9.5 6.5V11.5C9.5 12.6046 8.60457 13.5 7.5 13.5H2.5C1.39543 13.5 0.5 12.6046 0.5 11.5V6.5C0.5 5.39543 1.39543 4.5 2.5 4.5Z"- stroke="currentColor"- strokeLinecap="round"- strokeLinejoin="round"- />- </svg>-);--const ProfileToast: React.FC<ProfileToastProps> = ({- message,- open,- onClose,- onExited,-}) => (- <Box- onTransitionEnd={(event) => {- if (event.currentTarget != event.target || open) return;- onExited?.();- }}- sx={{- boxSizing: "border-box",- left: "50%",- opacity: open ? 1 : 0,- px: profileHorizontalPadding,- pointerEvents: "none",- position: "fixed",- top: "calc(env(safe-area-inset-top) + 10px)",- transform: open- ? "translateX(-50%) translateY(0)"- : "translateX(-50%) translateY(-8px)",- transition: profileToastTransition,- width: "100%",- zIndex: 20,- "@media (min-width: 600px)": { maxWidth: 390 },- }}- >- <Box- role="status"- aria-live="polite"- sx={{- alignItems: "center",- bgcolor: "#FFFFFF",- borderRadius: "18px",- boxShadow: "0 12px 32px rgba(0, 0, 0, 0.18)",- boxSizing: "border-box",- color: textBase,- display: "flex",- fontFamily: '"Inter Variable", Inter, sans-serif',- fontSize: 14,- fontWeight: 650,- gap: "10px",- lineHeight: "20px",- minHeight: 50,- pointerEvents: "auto",- pl: "16px",- pr: "6px",- py: "3px",- width: "100%",- }}- >- <Box component="span" sx={{ display: "flex", flexShrink: 0 }}>- <CopyIcon />- </Box>- <Box- component="span"- sx={{- flex: "1 1 auto",- minWidth: 0,- overflow: "hidden",- textOverflow: "ellipsis",- whiteSpace: "nowrap",- }}- >- {message}- </Box>- <Box- component="button"- type="button"- aria-label="Close"- onClick={onClose}- sx={{- alignItems: "center",- appearance: "none",- bgcolor: "transparent",- border: 0,- color: textBase,- cursor: onClose ? "pointer" : "default",- display: "flex",- flexShrink: 0,- height: spaceTouchTargetSize,- justifyContent: "center",- opacity: 0.9,- p: 0,- width: spaceTouchTargetSize,- "&:focus-visible": {- outline: "2px solid rgba(0 0 0 / 0.72)",- outlineOffset: 2,- },- }}- >- <HugeiconsIcon- icon={MultiplicationSignIcon}- size={16}- strokeWidth={2}- />- </Box>- </Box>- </Box>-);-interface ProfileScreenProps {friendsCount?: number;- headerVariant?: "friend" | "owner";+ headerVariant?: "friend" | "owner" | "public" | "public-anonymous";+ isAddingFriend?: boolean;+ showAddingFriendSpinner?: boolean;isCoverLoading?: boolean;+ isNameLoading?: boolean;isPostsLoading?: boolean;isStatsLoading?: boolean;showPostLoadingIndicator?: boolean;onBack?: () => void;+ onAddFriend?: () => void;+ onAddFriendForPostAction?: (intent: SpaceInviteIntent) => void;onCreatePost?: (image: DraftSpacePostImage,caption: string,@@ -554,6 +474,7 @@ interface ProfileScreenProps {onUnfriendComplete?: () => void;onUpdatePostCaption?: (postId: number, caption: string) => Promise<void>;postGroups?: ProfilePostGroup[];+ postsCount?: number;profile: SetupProfile;profileLink?: string;}@@ -561,10 +482,14 @@ interface ProfileScreenProps {export const ProfileScreen: React.FC<ProfileScreenProps> = ({friendsCount = 0,headerVariant = "owner",+ isAddingFriend = false,isCoverLoading = false,+ isNameLoading = false,isPostsLoading = false,isStatsLoading = false,onBack,+ onAddFriend,+ onAddFriendForPostAction,onCreatePost,onDeletePost,onDraftPostPublished,@@ -580,8 +505,10 @@ export const ProfileScreen: React.FC<ProfileScreenProps> = ({onUnfriendComplete,onUpdatePostCaption,postGroups = [],+ postsCount,profile,profileLink,+ showAddingFriendSpinner = isAddingFriend,showPostLoadingIndicator,}) => {const [selectedPost, setSelectedPost] =@@ -591,8 +518,6 @@ export const ProfileScreen: React.FC<ProfileScreenProps> = ({const [deletedPostIDs, setDeletedPostIDs] = useState<Set<string>>(() => new Set(),);- const [profileShareToast, setProfileShareToast] =- useState<ProfileToastState | null>(null);const [friendActionsAnchor, setFriendActionsAnchor] =useState<HTMLElement | null>(null);const [isUnfriendSheetOpen, setIsUnfriendSheetOpen] = useState(false);@@ -614,14 +539,11 @@ export const ProfileScreen: React.FC<ProfileScreenProps> = ({>(new Map());const localPostObjectUrlsRef = React.useRef<Set<string>>(new Set());const activeLocalPostObjectUrlRef = React.useRef<string | null>(null);- const profileShareToastTimeoutRef = React.useRef<number | undefined>(- undefined,- );- const profileShareToastFrameRef = React.useRef<number | undefined>(- undefined,- );const isOwnerProfile = headerVariant == "owner";const isFriendProfile = headerVariant == "friend";+ const isAnonymousPublicProfile = headerVariant == "public-anonymous";+ const isPublicProfile =+ headerVariant == "public" || isAnonymousPublicProfile;const friendActionsButtonID = React.useId();const friendActionsMenuID = React.useId();const isFriendActionsOpen = Boolean(friendActionsAnchor);@@ -651,6 +573,7 @@ export const ProfileScreen: React.FC<ProfileScreenProps> = ({(count, group) => count + group.items.length,0,);+ const displayedPostsCount = postsCount ?? postsSharedCount;const canOpenFriends = isOwnerProfile && Boolean(onOpenFriends);const canOpenProfileCover = Boolean(onOpenProfileCover);const canOpenProfilePhoto = Boolean(onOpenProfilePhoto);@@ -662,55 +585,13 @@ export const ProfileScreen: React.FC<ProfileScreenProps> = ({);const shouldShowCoverSkeleton =isCoverLoading || isCoverURLPending || isCoverImageLoading;- const selectedPostActionMode: SpaceViewerPostActionMode = isOwnerProfile- ? "hidden"- : "like-only";-- const clearProfileShareToastTimers = React.useCallback(() => {- if (profileShareToastTimeoutRef.current !== undefined) {- window.clearTimeout(profileShareToastTimeoutRef.current);- profileShareToastTimeoutRef.current = undefined;- }- if (profileShareToastFrameRef.current !== undefined) {- window.cancelAnimationFrame(profileShareToastFrameRef.current);- profileShareToastFrameRef.current = undefined;- }- }, []);-- const hideProfileShareToast = React.useCallback(() => {- clearProfileShareToastTimers();- setProfileShareToast((currentToast) =>- currentToast ? { ...currentToast, open: false } : currentToast,- );- }, [clearProfileShareToastTimers]);-- const showProfileShareToast = React.useCallback(- (message: string) => {- clearProfileShareToastTimers();- setProfileShareToast({ message, open: false });- profileShareToastFrameRef.current = window.requestAnimationFrame(- () => {- setProfileShareToast((currentToast) =>- currentToast- ? { ...currentToast, open: true }- : currentToast,- );- profileShareToastFrameRef.current = undefined;- },- );- profileShareToastTimeoutRef.current = window.setTimeout(() => {- profileShareToastTimeoutRef.current = undefined;- hideProfileShareToast();- }, 1800);- },- [clearProfileShareToastTimers, hideProfileShareToast],- );-- const clearClosedProfileShareToast = React.useCallback(() => {- setProfileShareToast((currentToast) =>- currentToast?.open ? currentToast : null,- );- }, []);+ const selectedPostActionMode: SpaceViewerPostActionMode =+ isOwnerProfile || (isPublicProfile && !onAddFriendForPostAction)+ ? "hidden"+ : "like-only";+ const postImageLoadRootMargin = isAnonymousPublicProfile+ ? publicPhotoMasonryLoadRootMargin+ : photoMasonryLoadRootMargin;const closeFriendActions = () => setFriendActionsAnchor(null);@@ -1074,26 +955,9 @@ export const ProfileScreen: React.FC<ProfileScreenProps> = ({});};- const shareProfile = async () => {+ const shareProfile = () => {if (!profileLink) return;-- if (typeof navigator.share == "function") {- try {- await navigator.share({ url: profileLink });- return;- } catch (error) {- if (error instanceof DOMException && error.name == "AbortError")- return;- }- }-- try {- await navigator.clipboard.writeText(profileLink);- showProfileShareToast("Invite link copied");- } catch (error) {- console.error("Failed to copy profile link", error);- showProfileShareToast("Couldn't copy link. Please try again.");- }+ openSpaceShareLinkDialog();};const deleteSelectedPost = async () => {@@ -1117,13 +981,6 @@ export const ProfileScreen: React.FC<ProfileScreenProps> = ({[revokeLocalPostObjectUrls],);- React.useEffect(- () => () => {- clearProfileShareToastTimers();- },- [clearProfileShareToastTimers],- );-return (<Boxcomponent="main"@@ -1255,9 +1112,14 @@ export const ProfileScreen: React.FC<ProfileScreenProps> = ({sx={{alignItems: "center",color: coverForeground,- display: "grid",- gridTemplateColumns: `${spaceTouchTargetSize}px 1fr ${spaceTouchTargetSize}px`,+ display: isPublicProfile ? "flex" : "grid",+ gridTemplateColumns: isPublicProfile+ ? undefined+ : `${spaceTouchTargetSize}px 1fr ${spaceTouchTargetSize}px`,height: profileHeaderHeight,+ justifyContent: isPublicProfile+ ? "space-between"+ : undefined,position: "relative",px: 2,py: 0,@@ -1265,89 +1127,132 @@ export const ProfileScreen: React.FC<ProfileScreenProps> = ({zIndex: 3,}}>- <Box- component="button"- type="button"- aria-label={- isFriendProfile ? "Back to friends" : "Back to home"- }- onClick={onBack}- sx={{- alignItems: "center",- bgcolor: "transparent",- border: 0,- color: "inherit",- cursor: "pointer",- display: "flex",- height: spaceTouchTargetSize,- justifyContent: "flex-start",- ml: "-2px",- p: 0,- width: spaceTouchTargetSize,- "&:focus-visible": {- borderRadius: "50%",- outline: `2px solid ${green}`,- outlineOffset: 2,- },- }}- >- <HugeiconsIcon- icon={ArrowLeft02Icon}- size={24}- strokeWidth={1.8}- />- </Box>- <Box- component="h1"- sx={{- color: "inherit",- fontFamily: '"Inter Variable", Inter, sans-serif',- fontSize: 18,- fontWeight: 700,- justifySelf: "center",- lineHeight: "24px",- m: 0,- maxWidth: "100%",- overflow: "hidden",- px: "4px",- textOverflow: "ellipsis",- whiteSpace: "nowrap",- }}- >- {profile.username}- </Box>- {isOwnerProfile ? (- <Box- component="button"- type="button"- aria-label="Settings"- onClick={onOpenSettings}- sx={{- alignItems: "center",- bgcolor: "transparent",- border: 0,- color: "inherit",- cursor: onOpenSettings ? "pointer" : "default",- display: "flex",- height: spaceTouchTargetSize,- justifyContent: "flex-end",- p: 0,- width: spaceTouchTargetSize,- "&:focus-visible": {- borderRadius: "50%",- outline: `2px solid ${green}`,- outlineOffset: 2,- },- }}- >- <HugeiconsIcon- icon={Menu01Icon}- size={20}- strokeWidth={2.4}- />- </Box>+ {isPublicProfile ? (+ <>+ <Box+ component="a"+ href="/"+ aria-label="Go to Space"+ sx={{+ display: "block",+ flexShrink: 0,+ lineHeight: 0,+ }}+ >+ <Box+ component="img"+ alt="Space"+ src="/images/space.svg"+ sx={{+ display: "block",+ height: 17,+ width: "auto",+ }}+ />+ </Box>+ {onAddFriend && (+ <PublicProfileAddFriendButton+ isAddingFriend={isAddingFriend}+ onAddFriend={onAddFriend}+ showSpinner={showAddingFriendSpinner}+ />+ )}+ </>) : (- <Box aria-hidden sx={{ width: spaceTouchTargetSize }} />+ <>+ <Box+ component="button"+ type="button"+ aria-label={+ isFriendProfile+ ? "Back to friends"+ : "Back to home"+ }+ onClick={onBack}+ sx={{+ alignItems: "center",+ bgcolor: "transparent",+ border: 0,+ color: "inherit",+ cursor: "pointer",+ display: "flex",+ height: spaceTouchTargetSize,+ justifyContent: "flex-start",+ ml: "-2px",+ p: 0,+ width: spaceTouchTargetSize,+ "&:focus-visible": {+ borderRadius: "50%",+ outline: `2px solid ${green}`,+ outlineOffset: 2,+ },+ }}+ >+ <HugeiconsIcon+ icon={ArrowLeft02Icon}+ size={24}+ strokeWidth={1.8}+ />+ </Box>+ <Box+ component="h1"+ sx={{+ color: "inherit",+ fontFamily:+ '"Inter Variable", Inter, sans-serif',+ fontSize: 18,+ fontWeight: 700,+ justifySelf: "center",+ lineHeight: "24px",+ m: 0,+ maxWidth: "100%",+ overflow: "hidden",+ px: "4px",+ textOverflow: "ellipsis",+ whiteSpace: "nowrap",+ }}+ >+ {profile.username}+ </Box>+ {isOwnerProfile ? (+ <Box+ component="button"+ type="button"+ aria-label="Settings"+ onClick={onOpenSettings}+ sx={{+ alignItems: "center",+ bgcolor: "transparent",+ border: 0,+ color: "inherit",+ cursor: onOpenSettings+ ? "pointer"+ : "default",+ display: "flex",+ height: spaceTouchTargetSize,+ justifyContent: "flex-end",+ p: 0,+ width: spaceTouchTargetSize,+ "&:focus-visible": {+ borderRadius: "50%",+ outline: `2px solid ${green}`,+ outlineOffset: 2,+ },+ }}+ >+ <HugeiconsIcon+ icon={Menu01Icon}+ size={20}+ strokeWidth={2.4}+ />+ </Box>+ ) : (+ <Box+ aria-hidden+ sx={{ width: spaceTouchTargetSize }}+ />+ )}+ </>)}</Box><Box@@ -1429,7 +1334,9 @@ export const ProfileScreen: React.FC<ProfileScreenProps> = ({display: "grid",gridTemplateColumns:"minmax(0, 1fr) minmax(0, max-content) minmax(0, 1fr)",- height: "32px",+ height: isOwnerProfile+ ? spaceTouchTargetSize+ : "32px",minWidth: 0,position: "relative",width: "100%",@@ -1453,14 +1360,27 @@ export const ProfileScreen: React.FC<ProfileScreenProps> = ({whiteSpace: "nowrap",}}>- {displayName}+ {isNameLoading ? (+ <Skeleton+ variant="rounded"+ sx={{+ bgcolor:+ photoMasonryPlaceholderBackground,+ height: 26,+ transform: "none",+ width: 112,+ }}+ />+ ) : (+ displayName+ )}</Box>{isOwnerProfile ? (<Boxcomponent="button"type="button"aria-label="Share profile"- onClick={() => void shareProfile()}+ onClick={shareProfile}sx={{alignItems: "center",bgcolor: "transparent",@@ -1476,9 +1396,6 @@ export const ProfileScreen: React.FC<ProfileScreenProps> = ({justifySelf: "start",ml: "8px",p: 0,- position: "absolute",- top: "50%",- transform: "translateY(-50%)",width: spaceTouchTargetSize,"&:focus-visible": {borderRadius: "50%",@@ -1520,15 +1437,12 @@ export const ProfileScreen: React.FC<ProfileScreenProps> = ({cursor: "pointer",display: "flex",gridColumn: 3,- height: spaceTouchTargetSize,+ height: 24,justifyContent: "flex-start",justifySelf: "start",ml: "8px",p: 0,- position: "absolute",- top: "50%",- transform: "translateY(-50%)",- width: spaceTouchTargetSize,+ width: 24,"&:focus-visible": {borderRadius: "50%",outline: `2px solid ${green}`,@@ -1551,11 +1465,11 @@ export const ProfileScreen: React.FC<ProfileScreenProps> = ({open={isFriendActionsOpen}onClose={closeFriendActions}anchorOrigin={{- horizontal: "right",+ horizontal: "left",vertical: "bottom",}}transformOrigin={{- horizontal: "right",+ horizontal: "left",vertical: "top",}}slotProps={{@@ -1701,10 +1615,12 @@ export const ProfileScreen: React.FC<ProfileScreenProps> = ({}}><Box component="span" sx={{ color: textBase }}>- {postsSharedCount}+ {displayedPostsCount}</Box><Box component="span">- {postsSharedCount == 1 ? "post" : "posts"}+ {displayedPostsCount == 1+ ? "post"+ : "posts"}</Box><Box component="span">Β·</Box><Box@@ -1873,6 +1789,9 @@ export const ProfileScreen: React.FC<ProfileScreenProps> = ({isSingleItemRow}item={item}+ loadRootMargin={+ postImageLoadRootMargin+ }onLoadImage={() =>loadPostImage(item,@@ -2007,14 +1926,6 @@ export const ProfileScreen: React.FC<ProfileScreenProps> = ({onClick={openPostPhotoPicker}/>)}- {profileShareToast && (- <ProfileToast- message={profileShareToast.message}- open={profileShareToast.open}- onClose={hideProfileShareToast}- onExited={clearClosedProfileShareToast}- />- )}{selectedPost && (<SpaceFileViewerphoto={selectedPost.photo}@@ -2038,6 +1949,11 @@ export const ProfileScreen: React.FC<ProfileScreenProps> = ({: handleSelectedPostIndexChange}onClose={closeSelectedPost}+ onAddFriendForPostAction={+ isPublicProfile+ ? onAddFriendForPostAction+ : undefined+ }onDraftPostExitStart={() => setIsDraftPostExiting(true)}onDeletePost={isOwnerProfile ? deleteSelectedPost : undefineddiff --git a/web/apps/space/src/services/space.ts b/web/apps/space/src/services/space.tsindex 527cc2f40a..fa4cd0cd66 100644--- a/web/apps/space/src/services/space.ts+++ b/web/apps/space/src/services/space.ts@@ -1,6 +1,10 @@import type { FriendProfile } from "data/friends";+import { clientPackageName, desktopAppVersion, isDesktop } from "ente-base/app";import { apiOrigin } from "ente-base/origins";-import type { SpaceAccountCtxHandle } from "ente-space-wasm";+import type {+ SpaceAccountCtxHandle,+ SpaceLinkCtxHandle,+} from "ente-space-wasm";import type { PendingSpaceInvite } from "services/spaceInvite";import {cachedSpaceMediaBlobURL,@@ -38,6 +42,7 @@ interface SpaceProfileResponse {avatar?: SpaceAvatar;cover?: SpaceCover;friends?: number;+ posts?: number;profile: string;updatedAt?: string;version?: number;@@ -173,6 +178,7 @@ interface SpacePostBase {postId: number;timestampMs: number;thumbHash?: string;+ username?: string;viewerLiked: boolean;spaceId: string;width?: number;@@ -207,6 +213,24 @@ export interface SpaceProfilePostPage {nextCursor?: string;}+export interface PublicSpaceLinkSession {+ close: () => void;+ loadPostImage: SpacePostAssetURLLoader;+ loadProfileMedia: () => Promise<{+ avatarUrl: string | null;+ coverUrl: string | null;+ }>;+ loadPosts: () => Promise<SpaceProfilePost[]>;+ profile: FriendProfile & { avatarUrl: string | null };+ postsCount: number;+}++export interface CurrentSpaceLink {+ accessKey: string;+ spaceId: string;+ spaceSlug: string;+}+export type SpacePostAssetURLLoader = (asset: SpacePostAsset,) => Promise<string>;@@ -576,6 +600,7 @@ const postFromAccountPost = async (postId: post.postId,timestampMs: timestampMsFromSpaceDate(post.createdAt),thumbHash: object.thumbHash,+ username: author.username,viewerLiked: post.viewerLiked,spaceId: post.spaceId,width: object.width,@@ -603,6 +628,7 @@ const profilePostFromPost = (postId: post.postId,timestampMs: timestampMsFromSpaceDate(post.createdAt),thumbHash: object.thumbHash,+ username: author.username,viewerLiked: post.viewerLiked,spaceId: post.spaceId,width: object.width,@@ -634,6 +660,118 @@ const profilePostPageFromPage = (nextCursor: page.nextCursor || undefined,});+const publicLinkProfileMediaURL = async (+ ctx: SpaceLinkCtxHandle,+ spaceId: string,+ assetType: "avatar" | "cover",+ asset?: SpaceAvatar,+) => {+ if (!asset?.objectID) return null;+ try {+ return await cachedSpaceMediaBlobURL(+ spaceProfileMediaCacheKey(+ spaceId,+ assetType,+ asset.objectID,+ asset.keyVersion,+ ),+ () =>+ assetType == "avatar"+ ? ctx.downloadAvatar(asset.objectID, asset.keyVersion)+ : ctx.downloadCover(asset.objectID, asset.keyVersion),+ );+ } catch (error) {+ console.warn(`Failed to load public Space ${assetType}`, error);+ return null;+ }+};++export const openPublicSpaceLink = async (+ spaceUsername: string,+ accessKey: string,+): Promise<PublicSpaceLinkSession> => {+ const [{ spaceOpenLinkCtx }, baseUrl] = await Promise.all([+ import("ente-space-wasm"),+ apiOrigin(),+ ]);+ const ctx = await spaceOpenLinkCtx({+ accessKey,+ baseUrl,+ clientPackage: clientPackageName,+ clientVersion: isDesktop ? desktopAppVersion : undefined,+ spaceUsername,+ });+ try {+ const response = ctx.getProfile() as SpaceProfileResponse;+ const profile = profileFromSpaceProfile(response);+ return {+ close: () => ctx.free(),+ loadPostImage: (asset) =>+ cachedSpaceMediaBlobURL(+ postAssetCacheKey(asset),+ () =>+ ctx.downloadPostAsset(+ asset.encryptedPostKey,+ asset.keyVersion,+ asset.objectKey,+ ),+ asset.mediaType,+ ),+ loadProfileMedia: async () => {+ const [avatarUrl, coverUrl] = await Promise.all([+ publicLinkProfileMediaURL(+ ctx,+ response.spaceId,+ "avatar",+ response.avatar,+ ),+ publicLinkProfileMediaURL(+ ctx,+ response.spaceId,+ "cover",+ response.cover,+ ),+ ]);+ return { avatarUrl, coverUrl };+ },+ loadPosts: async () =>+ profilePostPageFromPage(+ (await ctx.listPosts()) as SpacePostPageResponse,+ ).items,+ profile: { ...profile, avatarUrl: profile.avatarUrl ?? null },+ postsCount: response.posts ?? 0,+ };+ } catch (error) {+ ctx.free();+ throw error;+ }+};++const withCurrentSpaceContext = async <T>(+ run: (ctx: SpaceAccountCtxHandle, spaceId: string) => Promise<T>,+) => {+ const profile = await loadExistingSpaceProfile();+ if (!profile?.spaceId) throw new Error("Space profile is unavailable.");+ const ctx = await ensureCurrentSpaceContext();+ try {+ return await run(ctx, profile.spaceId);+ } finally {+ releaseCurrentSpaceContext(ctx);+ }+};++export const getOrCreateCurrentSpaceLink = () =>+ withCurrentSpaceContext(+ async (ctx, spaceId) =>+ (await ctx.getOrCreateSpaceLink(spaceId)) as CurrentSpaceLink,+ );++export const rotateCurrentSpaceLink = () =>+ withCurrentSpaceContext(+ async (ctx, spaceId) =>+ (await ctx.rotateSpaceLink(spaceId)) as CurrentSpaceLink,+ );+const messageQuoteFromPostResponse = async (ctx: SpaceAccountCtxHandle,post: SpacePostResponse,@@ -825,6 +963,19 @@ export const joinSpaceInvite = async ({}};+export const loadCurrentSpaceRelationship = (targetSpaceId: string) =>+ withCurrentSpaceContext(async (ctx, spaceId) => {+ const response = (await ctx.getRelationship(+ spaceId,+ targetSpaceId,+ )) as { relationship?: string };+ return response.relationship == "self"+ ? "self"+ : response.relationship == "friend"+ ? "friend"+ : null;+ });+export const loadPublicSpaceIdentity = async (username: string,): Promise<PublicSpaceIdentity> => {diff --git a/web/apps/space/src/services/spaceFeedCache.ts b/web/apps/space/src/services/spaceFeedCache.tsindex 86fa6d800d..3a86edac53 100644--- a/web/apps/space/src/services/spaceFeedCache.ts+++ b/web/apps/space/src/services/spaceFeedCache.ts@@ -30,6 +30,7 @@ const CachedSpacePost = z.object({spaceId: z.string(),thumbHash: z.string().optional(),timestampMs: z.number(),+ username: z.string().optional(),viewerLiked: z.boolean(),width: z.number().optional(),});diff --git a/web/apps/space/src/services/spaceInvite.ts b/web/apps/space/src/services/spaceInvite.tsindex 08acd7e7bc..e76d51e20f 100644--- a/web/apps/space/src/services/spaceInvite.ts+++ b/web/apps/space/src/services/spaceInvite.ts@@ -3,12 +3,19 @@ export interface PendingSpaceInvite {spaceUsername: string;}+export interface SpaceInviteRoute extends PendingSpaceInvite {+ accessKey?: string;+}+export interface SpaceInviteFriendSummary {fullName: string;username: string;}+export type SpaceInviteIntent = "like" | "reply";+const pendingSpaceInviteFriendKey = "spacePendingInviteFriend";+const pendingSpaceInviteIntentKey = "spacePendingInviteIntent";const pendingSpaceInviteKey = "spacePendingInvite";let sentSpaceInviteFriend: SpaceInviteFriendSummary | undefined;@@ -78,6 +85,21 @@ export const clearPendingSpaceInvite = () => {sessionStorage.removeItem(pendingSpaceInviteKey);};+export const savePendingSpaceInviteIntent = (intent: SpaceInviteIntent) => {+ sessionStorage.setItem(pendingSpaceInviteIntentKey, intent);+};++export const savedPendingSpaceInviteIntent = ():+ | SpaceInviteIntent+ | undefined => {+ const intent = sessionStorage.getItem(pendingSpaceInviteIntentKey);+ return intent == "like" || intent == "reply" ? intent : undefined;+};++export const clearPendingSpaceInviteIntent = () => {+ sessionStorage.removeItem(pendingSpaceInviteIntentKey);+};+export const savePendingSpaceInviteFriend = (friend: SpaceInviteFriendSummary,) => saveSpaceInviteFriendSummary(pendingSpaceInviteFriendKey, friend);@@ -99,17 +121,29 @@ export const consumeSentSpaceInviteFriend = () => {return friend;};-export const spaceInviteFromLocation = (): PendingSpaceInvite | null => {+export const spaceInviteFromLocation = (): SpaceInviteRoute | null => {const match = /^\/([^/]+)\/?$/.exec(window.location.pathname);- if (!match || window.location.hash.trim()) return null;+ if (!match) return null;try {const spaceUsername = decodeURIComponent(match[1] ?? "").trim();- return spaceUsername ? { spaceUsername } : null;+ if (!spaceUsername) return null;+ const fragment = window.location.hash.slice(1);+ return {+ spaceUsername,+ accessKey: /^[A-Za-z0-9]{12}$/.test(fragment)+ ? fragment+ : undefined,+ };} catch {return null;}};-export const spaceInviteURL = ({ spaceUsername }: PendingSpaceInvite) =>- `${window.location.origin}/${encodeURIComponent(spaceUsername)}`;+export const spaceInviteURL = ({+ accessKey,+ spaceUsername,+}: SpaceInviteRoute) =>+ `${window.location.origin}/${encodeURIComponent(spaceUsername)}${+ accessKey ? `#${accessKey}` : ""+ }`;diff --git a/web/apps/space/src/services/spaceShareLink.ts b/web/apps/space/src/services/spaceShareLink.tsnew file mode 100644index 0000000000..d75ecffbb5--- /dev/null+++ b/web/apps/space/src/services/spaceShareLink.ts@@ -0,0 +1,10 @@+const openEvent = "ente-space-open-share-link";++export const openSpaceShareLinkDialog = () => {+ window.dispatchEvent(new Event(openEvent));+};++export const onOpenSpaceShareLinkDialog = (listener: () => void) => {+ window.addEventListener(openEvent, listener);+ return () => window.removeEventListener(openEvent, listener);+};diff --git a/web/apps/space/src/utils/spacePendingInvite.ts b/web/apps/space/src/utils/spacePendingInvite.tsindex 9fed10aa3b..9404c17dec 100644--- a/web/apps/space/src/utils/spacePendingInvite.ts+++ b/web/apps/space/src/utils/spacePendingInvite.ts@@ -2,6 +2,7 @@ import { joinSpaceInvite } from "services/space";import {clearPendingSpaceInvite,clearPendingSpaceInviteFriend,+ clearPendingSpaceInviteIntent,saveSentSpaceInviteFriend,savedPendingSpaceInvite,savedPendingSpaceInviteFriend,@@ -18,6 +19,7 @@ export const acceptPendingSpaceInvite = async () => {const status = await joinSpaceInvite(pendingInvite);clearPendingSpaceInvite();clearPendingSpaceInviteFriend();+ clearPendingSpaceInviteIntent();if (status == "requested") saveSentSpaceInviteFriend(pendingFriend);return true;};diff --git a/web/apps/space/src/utils/spaceRouteTransitions.tsx b/web/apps/space/src/utils/spaceRouteTransitions.tsxindex 1e30d7282b..71b68f64b4 100644--- a/web/apps/space/src/utils/spaceRouteTransitions.tsx+++ b/web/apps/space/src/utils/spaceRouteTransitions.tsx@@ -27,7 +27,6 @@ const routePath = (route: SpaceRouteURL | SpaceRouteAs): string => {};const parentRoutePaths = (path: string) => {- if (/^\/app\/friends\/[^/]+$/.test(path)) return ["/app/friends"];if (/^\/app\/messages\/[^/]+$/.test(path)) return ["/app/messages"];if (/^\/app\/posts\/[^/]+\/[^/]+$/.test(path)) {return ["/app"];@@ -61,6 +60,8 @@ const parentRoutePaths = (path: string) => {const previousStackRoute = () =>routeStack.length > 1 ? routeStack[routeStack.length - 2] : undefined;+export const hasPreviousSpaceRoute = () => Boolean(previousStackRoute());+const ensureRouteStack = (currentPath: string) => {if (routeStack.length == 0 && currentPath) routeStack = [currentPath];};diff --git a/web/apps/space/src/utils/spaceRoutes.ts b/web/apps/space/src/utils/spaceRoutes.tsindex 47f7cc3b24..87b8f6cf8b 100644--- a/web/apps/space/src/utils/spaceRoutes.ts+++ b/web/apps/space/src/utils/spaceRoutes.ts@@ -11,7 +11,8 @@ const routeWithProfileImageFlowSource = () => (source == "settings" ? `${route}?from=settings` : route);export const spaceRoutes = {- friend: (spaceId: string) => `/app/friends/${encodeURIComponent(spaceId)}`,+ friend: (username: string) => `/${encodeURIComponent(username)}`,+ friendPage: "/profile-link",friends: "/app/friends",home: "/app",invite: "/invite",