feat: Add Chat UX improvements with notifications and @mention support

- Add ActionBar component with expandable toolbar for mobile
- Add @mention functionality with autocomplete dropdown
- Add browser notification system (push, sound, vibration)
- Add NotificationSettings modal for user preferences
- Add mention badges on room list cards
- Add ReportPreview with Markdown rendering and copy/download
- Add message copy functionality with hover actions
- Add backend mentions field to messages with Alembic migration
- Add lots field to rooms, remove templates
- Optimize WebSocket database session handling
- Various UX polish (animations, accessibility)

🤖 Generated with [Claude Code](https://claude.com/claude-code)

Co-Authored-By: Claude <noreply@anthropic.com>

app/modules/realtime/services/message_service.py

@@ -1,9 +1,12 @@
 """Message service layer for database operations"""
 from sqlalchemy.orm import Session
-from sqlalchemy import desc, and_, func
-from typing import List, Optional, Dict, Any
+from sqlalchemy import desc, and_, func, text
+from sqlalchemy.exc import IntegrityError
+from typing import List, Optional, Dict, Any, Tuple
 from datetime import datetime, timedelta
 import uuid
+import logging
+import re
 
 from app.core.config import get_settings
 from app.modules.realtime.models import Message, MessageType, MessageReaction, MessageEditHistory
@@ -13,13 +16,48 @@ from app.modules.realtime.schemas import (
     MessageListResponse,
     ReactionSummary
 )
+from app.modules.auth.models import User
 
 settings = get_settings()
+logger = logging.getLogger(__name__)
 
 
 class MessageService:
     """Service for message operations"""
 
+    @staticmethod
+    def parse_mentions(content: str, room_members: List[Dict[str, str]]) -> List[str]:
+        """
+        Parse @mentions from message content and resolve to user IDs
+
+        Args:
+            content: Message content that may contain @mentions
+            room_members: List of room members with user_id and display_name
+
+        Returns:
+            List of mentioned user_ids
+        """
+        # Pattern matches @displayname (alphanumeric, spaces, Chinese chars, etc.)
+        # Captures text after @ until we hit a character that's not part of a name
+        mention_pattern = r'@(\S+)'
+        matches = re.findall(mention_pattern, content)
+
+        mentioned_ids = []
+        for mention_text in matches:
+            # Try to match against display names or user IDs
+            for member in room_members:
+                display_name = member.get('display_name', '') or member.get('user_id', '')
+                user_id = member.get('user_id', '')
+
+                # Match against display_name or user_id (case-insensitive)
+                if (mention_text.lower() == display_name.lower() or
+                    mention_text.lower() == user_id.lower()):
+                    if user_id not in mentioned_ids:
+                        mentioned_ids.append(user_id)
+                    break
+
+        return mentioned_ids
+
     @staticmethod
     def create_message(
         db: Session,
@@ -27,10 +65,16 @@ class MessageService:
         sender_id: str,
         content: str,
         message_type: MessageType = MessageType.TEXT,
-        metadata: Optional[Dict[str, Any]] = None
+        metadata: Optional[Dict[str, Any]] = None,
+        mentions: Optional[List[str]] = None,
+        max_retries: int = 3
     ) -> Message:
         """
-        Create a new message
+        Create a new message with race condition protection
+
+        Uses SELECT ... FOR UPDATE to lock the sequence number calculation,
+        preventing duplicate sequence numbers when multiple users send
+        messages simultaneously.
 
         Args:
             db: Database session
@@ -38,34 +82,72 @@ class MessageService:
             sender_id: User ID who sent the message
             content: Message content
             message_type: Type of message
-            metadata: Optional metadata (mentions, file refs, etc.)
+            metadata: Optional metadata (file refs, etc.)
+            mentions: List of mentioned user_ids (parsed from @mentions)
+            max_retries: Maximum retry attempts for deadlock handling
 
         Returns:
             Created Message object
+
+        Raises:
+            IntegrityError: If max retries exceeded
         """
-        # Get next sequence number for this room
-        max_seq = db.query(func.max(Message.sequence_number)).filter(
-            Message.room_id == room_id
-        ).scalar()
-        next_seq = (max_seq or 0) + 1
+        last_error = None
 
-        message = Message(
-            message_id=str(uuid.uuid4()),
-            room_id=room_id,
-            sender_id=sender_id,
-            content=content,
-            message_type=message_type,
-            message_metadata=metadata or {},
-            created_at=datetime.utcnow(),
-            sequence_number=next_seq
+        for attempt in range(max_retries):
+            try:
+                # Use FOR UPDATE to lock rows while calculating next sequence
+                # This prevents race conditions where two transactions read
+                # the same max_seq and try to insert duplicate sequence numbers
+                result = db.execute(
+                    text("""
+                        SELECT COALESCE(MAX(sequence_number), 0)
+                        FROM tr_messages
+                        WHERE room_id = :room_id
+                        FOR UPDATE
+                    """),
+                    {"room_id": room_id}
+                )
+                max_seq = result.scalar()
+                next_seq = (max_seq or 0) + 1
+
+                message = Message(
+                    message_id=str(uuid.uuid4()),
+                    room_id=room_id,
+                    sender_id=sender_id,
+                    content=content,
+                    message_type=message_type,
+                    message_metadata=metadata or {},
+                    mentions=mentions or [],
+                    created_at=datetime.utcnow(),
+                    sequence_number=next_seq
+                )
+
+                db.add(message)
+                db.commit()
+                db.refresh(message)
+
+                return message
+
+            except IntegrityError as e:
+                last_error = e
+                db.rollback()
+                logger.warning(
+                    f"Sequence number conflict on attempt {attempt + 1}/{max_retries} "
+                    f"for room {room_id}: {e}"
+                )
+                if attempt == max_retries - 1:
+                    logger.error(
+                        f"Failed to create message after {max_retries} attempts "
+                        f"for room {room_id}"
+                    )
+                    raise
+
+        # Should not reach here, but just in case
+        raise last_error if last_error else IntegrityError(
+            "Failed to create message", None, None
         )
 
-        db.add(message)
-        db.commit()
-        db.refresh(message)
-
-        return message
-
     @staticmethod
     def get_message(db: Session, message_id: str) -> Optional[Message]:
         """
@@ -83,6 +165,21 @@ class MessageService:
             Message.deleted_at.is_(None)
         ).first()
 
+    @staticmethod
+    def get_display_name(db: Session, sender_id: str) -> Optional[str]:
+        """
+        Get display name for a sender from users table
+
+        Args:
+            db: Database session
+            sender_id: User ID (email)
+
+        Returns:
+            Display name or None if not found
+        """
+        user = db.query(User.display_name).filter(User.user_id == sender_id).first()
+        return user[0] if user else None
+
     @staticmethod
     def get_messages(
         db: Session,
@@ -106,7 +203,10 @@ class MessageService:
         Returns:
             MessageListResponse with messages and pagination info
         """
-        query = db.query(Message).filter(Message.room_id == room_id)
+        # Build base query with LEFT JOIN to users table for display names
+        query = db.query(Message, User.display_name).outerjoin(
+            User, Message.sender_id == User.user_id
+        ).filter(Message.room_id == room_id)
 
         if not include_deleted:
             query = query.filter(Message.deleted_at.is_(None))
@@ -114,18 +214,24 @@ class MessageService:
         if before_timestamp:
             query = query.filter(Message.created_at < before_timestamp)
 
-        # Get total count
-        total = query.count()
+        # Get total count (need separate query without join for accurate count)
+        count_query = db.query(Message).filter(Message.room_id == room_id)
+        if not include_deleted:
+            count_query = count_query.filter(Message.deleted_at.is_(None))
+        if before_timestamp:
+            count_query = count_query.filter(Message.created_at < before_timestamp)
+        total = count_query.count()
 
-        # Get messages in reverse chronological order
-        messages = query.order_by(desc(Message.created_at)).offset(offset).limit(limit).all()
+        # Get messages with display names in reverse chronological order
+        results = query.order_by(desc(Message.created_at)).offset(offset).limit(limit).all()
 
-        # Get reaction counts for each message
+        # Get reaction counts for each message and build responses
         message_responses = []
-        for msg in messages:
+        for msg, display_name in results:
             reaction_counts = MessageService._get_reaction_counts(db, msg.message_id)
             msg_response = MessageResponse.from_orm(msg)
             msg_response.reaction_counts = reaction_counts
+            msg_response.sender_display_name = display_name or msg.sender_id
             message_responses.append(msg_response)
 
         return MessageListResponse(
@@ -133,7 +239,7 @@ class MessageService:
             total=total,
             limit=limit,
             offset=offset,
-            has_more=(offset + len(messages)) < total
+            has_more=(offset + len(results)) < total
         )
 
     @staticmethod
@@ -253,8 +359,10 @@ class MessageService:
 
         total = db.query(Message).filter(search_filter).count()
 
-        messages = (
-            db.query(Message)
+        # Query with LEFT JOIN for display names
+        results = (
+            db.query(Message, User.display_name)
+            .outerjoin(User, Message.sender_id == User.user_id)
             .filter(search_filter)
             .order_by(desc(Message.created_at))
             .offset(offset)
@@ -263,10 +371,11 @@ class MessageService:
         )
 
         message_responses = []
-        for msg in messages:
+        for msg, display_name in results:
             reaction_counts = MessageService._get_reaction_counts(db, msg.message_id)
             msg_response = MessageResponse.from_orm(msg)
             msg_response.reaction_counts = reaction_counts
+            msg_response.sender_display_name = display_name or msg.sender_id
             message_responses.append(msg_response)
 
         return MessageListResponse(
@@ -274,7 +383,7 @@ class MessageService:
             total=total,
             limit=limit,
             offset=offset,
-            has_more=(offset + len(messages)) < total
+            has_more=(offset + len(results)) < total
         )
 
     @staticmethod