fix: upload failure, share dialog, shared view styling, dark mode fixes

- Fix 'folder_id is required' upload error by adding create_home_folder
  through the full hexagonal architecture (trait, service, repository, auth)
- Fix double upload issue with _isUploading concurrency guard
- Fix Share context menu doing nothing (ID collision between sharedView
  and main share dialog resolved with sv- prefix)
- Fix Compartidos tab duplicate headers and broken layout
- Add missing .shared-dialog CSS with dark mode support
- Fix dark mode white backgrounds on empty-state, shared-filters,
  trash-actions, action-btn, and header
- Fix i18n key mismatches in sharedView
- Bump version to 0.4.1

Closes #120

src/application/services/auth_application_service.rs

@@ -1,4 +1,3 @@
-use crate::application::dtos::folder_dto::CreateFolderDto;
 use crate::application::dtos::user_dto::{
     AuthResponseDto, ChangePasswordDto, LoginDto, RefreshTokenDto, RegisterDto, UserDto,
 };
@@ -318,43 +317,7 @@ impl AuthApplicationService {
         let created_user = self.user_storage.create_user(user).await?;
 
         // Create personal folder for the user
-        if let Some(folder_service) = &self.folder_service {
-            let folder_name = format!("My Folder - {}", dto.username);
-
-            match folder_service
-                .create_folder(CreateFolderDto {
-                    name: folder_name,
-                    parent_id: None,
-                })
-                .await
-            {
-                Ok(folder) => {
-                    tracing::info!(
-                        "Personal folder created for user {}: {} (ID: {})",
-                        created_user.id(),
-                        folder.name,
-                        folder.id
-                    );
-
-                    // Here we could save the folder-to-user association,
-                    // for example, in a folder-user relationship table
-                }
-                Err(e) => {
-                    // We don't fail registration due to a folder creation error,
-                    // but we log it for investigation
-                    tracing::error!(
-                        "Could not create personal folder for user {}: {}",
-                        created_user.id(),
-                        e
-                    );
-                }
-            }
-        } else {
-            tracing::warn!(
-                "Folder service not configured, cannot create personal folder for user: {}",
-                created_user.id()
-            );
-        }
+        self.create_personal_folder(&dto.username, created_user.id()).await;
 
         tracing::info!("User registered: {}", created_user.id());
         Ok(UserDto::from(created_user))
@@ -695,34 +658,8 @@ impl AuthApplicationService {
         // 4. Save the new admin user
         let created_user = self.user_storage.create_user(user).await?;
 
-        // 5. Create personal folder for the new admin if folder service is available
-        if let Some(folder_service) = &self.folder_service {
-            let folder_name = format!("My Folder - {}", dto.username);
-
-            match folder_service
-                .create_folder(CreateFolderDto {
-                    name: folder_name,
-                    parent_id: None,
-                })
-                .await
-            {
-                Ok(folder) => {
-                    tracing::info!(
-                        "Personal folder created for admin {}: {} (ID: {})",
-                        created_user.id(),
-                        folder.name,
-                        folder.id
-                    );
-                }
-                Err(e) => {
-                    tracing::error!(
-                        "Could not create personal folder for admin {}: {}",
-                        created_user.id(),
-                        e
-                    );
-                }
-            }
-        }
+        // 5. Create personal folder for the new admin
+        self.create_personal_folder(&dto.username, created_user.id()).await;
 
         tracing::info!("Custom admin created: {}", created_user.id());
         Ok(UserDto::from(created_user))
@@ -828,32 +765,7 @@ impl AuthApplicationService {
         }
 
         // Create personal folder
-        if let Some(folder_service) = &self.folder_service {
-            let folder_name = format!("My Folder - {}", dto.username);
-            match folder_service
-                .create_folder(CreateFolderDto {
-                    name: folder_name,
-                    parent_id: None,
-                })
-                .await
-            {
-                Ok(folder) => {
-                    tracing::info!(
-                        "Personal folder created for admin-created user {}: {} (ID: {})",
-                        created.id(),
-                        folder.name,
-                        folder.id
-                    );
-                }
-                Err(e) => {
-                    tracing::error!(
-                        "Could not create personal folder for user {}: {}",
-                        created.id(),
-                        e
-                    );
-                }
-            }
-        }
+        self.create_personal_folder(&dto.username, created.id()).await;
 
         tracing::info!("Admin created user: {} ({})", dto.username, created.id());
         Ok(UserDto::from(created))
@@ -1290,10 +1202,7 @@ impl AuthApplicationService {
         if let Some(folder_service) = &self.folder_service {
             let folder_name = format!("My Folder - {}", username);
             match folder_service
-                .create_folder(CreateFolderDto {
-                    name: folder_name.clone(),
-                    parent_id: None,
-                })
+                .create_home_folder(user_id, folder_name.clone())
                 .await
             {
                 Ok(folder) => {

src/application/services/folder_service.rs

@@ -111,6 +111,10 @@ impl FolderService {
             async fn delete_folder(&self, _id: &str, _caller_id: &str) -> Result<(), DomainError> {
                 Ok(())
             }
+
+            async fn create_home_folder(&self, _user_id: &str, _name: String) -> Result<FolderDto, DomainError> {
+                Ok(FolderDto::empty())
+            }
         }
 
         FolderServiceStub
@@ -154,6 +158,22 @@ impl FolderUseCase for FolderService {
         Ok(FolderDto::from(folder))
     }
 
+    /// Creates a root-level home folder for a user during registration.
+    async fn create_home_folder(&self, user_id: &str, name: String) -> Result<FolderDto, DomainError> {
+        let folder = self
+            .folder_storage
+            .create_home_folder(user_id, name)
+            .await
+            .map_err(|e| {
+                DomainError::internal_error(
+                    "FolderStorage",
+                    format!("Failed to create home folder: {}", e),
+                )
+            })?;
+
+        Ok(FolderDto::from(folder))
+    }
+
     /// Gets a folder by its ID
     async fn get_folder(&self, id: &str) -> Result<FolderDto, DomainError> {
         let folder = self.folder_storage.get_folder(id).await.map_err(|e| {

src/application/services/share_service.rs

@@ -609,6 +609,14 @@ mod tests {
         async fn delete_folder_permanently(&self, _folder_id: &str) -> Result<(), DomainError> {
             unimplemented!()
         }
+
+        async fn create_home_folder(
+            &self,
+            _user_id: &str,
+            _name: String,
+        ) -> Result<crate::domain::entities::folder::Folder, DomainError> {
+            unimplemented!()
+        }
     }
 
     struct MockShareRepository {

src/application/services/trash_service_test.rs

@@ -461,6 +461,14 @@ impl FolderRepository for MockFolderRepository {
             ))
         }
     }
+
+    async fn create_home_folder(
+        &self,
+        _user_id: &str,
+        _name: String,
+    ) -> std::result::Result<Folder, DomainError> {
+        Ok(Folder::default())
+    }
 }
 
 #[cfg(test)]