feat(teams): add team icon, recommended status and favorites features

- Add icon and is_recommended fields to Team model (CRD spec)
- Create user_team_favorites table for user-team favorite relationships
- Add favorites API endpoints (add/remove/list favorites)
- Add showcase API endpoints (recommended teams, favorite teams)
- Create icon-picker component with Lucide icons
- Create TeamCard and TeamShowcase components for chat page
- Update TeamEdit with icon picker and recommended switch
- Add i18n translations for new features
- Add database migration for user_team_favorites table

Author: qdaxb

backend/alembic/versions/2a3b4c5d6e7f_add_user_team_favorites_table.py

@@ -0,0 +1,46 @@
+# SPDX-FileCopyrightText: 2025 Weibo, Inc.
+#
+# SPDX-License-Identifier: Apache-2.0
+
+"""add_user_team_favorites_table
+
+Revision ID: 2a3b4c5d6e7f
+Revises: 1a2b3c4d5e6f
+Create Date: 2025-07-16 10:00:00.000000
+
+"""
+from alembic import op
+import sqlalchemy as sa
+
+
+# revision identifiers, used by Alembic.
+revision = '2a3b4c5d6e7f'
+down_revision = '1a2b3c4d5e6f'
+branch_labels = None
+depends_on = None
+
+
+def upgrade() -> None:
+    # Create user_team_favorites table
+    op.create_table(
+        'user_team_favorites',
+        sa.Column('id', sa.Integer(), nullable=False),
+        sa.Column('user_id', sa.Integer(), nullable=False),
+        sa.Column('team_id', sa.Integer(), nullable=False),
+        sa.Column('created_at', sa.DateTime(), nullable=True),
+        sa.PrimaryKeyConstraint('id'),
+        mysql_charset='utf8mb4',
+        mysql_collate='utf8mb4_unicode_ci'
+    )
+    op.create_index('ix_user_team_favorites_id', 'user_team_favorites', ['id'], unique=False)
+    op.create_index('ix_user_team_favorites_user_id', 'user_team_favorites', ['user_id'], unique=False)
+    op.create_index('ix_user_team_favorites_team_id', 'user_team_favorites', ['team_id'], unique=False)
+    op.create_index('idx_user_team_favorite', 'user_team_favorites', ['user_id', 'team_id'], unique=True)
+
+
+def downgrade() -> None:
+    op.drop_index('idx_user_team_favorite', table_name='user_team_favorites')
+    op.drop_index('ix_user_team_favorites_team_id', table_name='user_team_favorites')
+    op.drop_index('ix_user_team_favorites_user_id', table_name='user_team_favorites')
+    op.drop_index('ix_user_team_favorites_id', table_name='user_team_favorites')
+    op.drop_table('user_team_favorites')

backend/app/api/endpoints/adapter/teams.py

@@ -4,6 +4,7 @@
 
 from fastapi import APIRouter, Depends, Query, status
 from sqlalchemy.orm import Session
+from typing import List, Dict, Any
 
 from app.api.dependencies import get_db
 from app.core import security
@@ -13,6 +14,7 @@
 from app.schemas.shared_team import TeamShareRequest, TeamShareResponse, JoinSharedTeamRequest, JoinSharedTeamResponse
 from app.services.adapters.team_kinds import team_kinds_service
 from app.services.shared_team import shared_team_service
+from app.services.team_favorite import team_favorite_service
 
 router = APIRouter()
 
@@ -124,4 +126,92 @@ def join_shared_team(
         db=db,
         share_token=request.share_token,
         user_id=current_user.id
-    )
+    )
+
+
+@router.post("/{team_id}/favorite")
+def add_team_to_favorites(
+    team_id: int,
+    current_user: User = Depends(security.get_current_user),
+    db: Session = Depends(get_db)
+):
+    """Add a team to user's favorites"""
+    return team_favorite_service.add_favorite(
+        db=db,
+        team_id=team_id,
+        user_id=current_user.id
+    )
+
+
+@router.delete("/{team_id}/favorite")
+def remove_team_from_favorites(
+    team_id: int,
+    current_user: User = Depends(security.get_current_user),
+    db: Session = Depends(get_db)
+):
+    """Remove a team from user's favorites"""
+    return team_favorite_service.remove_favorite(
+        db=db,
+        team_id=team_id,
+        user_id=current_user.id
+    )
+
+
+@router.get("/showcase/recommended", response_model=List[Dict[str, Any]])
+def get_recommended_teams(
+    limit: int = Query(6, ge=1, le=20, description="Max teams to return"),
+    db: Session = Depends(get_db),
+    current_user: User = Depends(security.get_current_user)
+):
+    """Get recommended teams (is_recommended=true)"""
+    from app.schemas.kind import Team
+
+    # Get all teams where isRecommended is true
+    teams = db.query(Kind).filter(
+        Kind.kind == "Team",
+        Kind.is_active == True
+    ).all()
+
+    recommended_teams = []
+    favorite_team_ids = team_favorite_service.get_user_favorite_team_ids(db=db, user_id=current_user.id)
+
+    for team in teams:
+        team_crd = Team.model_validate(team.json)
+        if team_crd.spec.isRecommended:
+            team_dict = team_kinds_service._convert_to_team_dict(team, db, team.user_id)
+            team_dict["is_favorited"] = team.id in favorite_team_ids
+            recommended_teams.append(team_dict)
+            if len(recommended_teams) >= limit:
+                break
+
+    return recommended_teams
+
+
+@router.get("/showcase/favorites", response_model=List[Dict[str, Any]])
+def get_favorite_teams(
+    limit: int = Query(6, ge=1, le=20, description="Max teams to return"),
+    db: Session = Depends(get_db),
+    current_user: User = Depends(security.get_current_user)
+):
+    """Get user's favorite teams"""
+    from app.models.user_team_favorite import UserTeamFavorite
+
+    # Get user's favorite team IDs
+    favorites = db.query(UserTeamFavorite).filter(
+        UserTeamFavorite.user_id == current_user.id
+    ).order_by(UserTeamFavorite.created_at.desc()).limit(limit).all()
+
+    favorite_teams = []
+    for favorite in favorites:
+        team = db.query(Kind).filter(
+            Kind.id == favorite.team_id,
+            Kind.kind == "Team",
+            Kind.is_active == True
+        ).first()
+
+        if team:
+            team_dict = team_kinds_service._convert_to_team_dict(team, db, team.user_id)
+            team_dict["is_favorited"] = True
+            favorite_teams.append(team_dict)
+
+    return favorite_teams

backend/app/models/__init__.py

@@ -14,11 +14,13 @@
 from app.models.subtask import Subtask
 from app.models.shared_team import SharedTeam
 from app.models.skill_binary import SkillBinary
+from app.models.user_team_favorite import UserTeamFavorite
 
 __all__ = [
     "User",
     "Kind",
     "Subtask",
     "SharedTeam",
-    "SkillBinary"
+    "SkillBinary",
+    "UserTeamFavorite"
 ]

backend/app/models/user_team_favorite.py

@@ -0,0 +1,22 @@
+# SPDX-FileCopyrightText: 2025 Weibo, Inc.
+#
+# SPDX-License-Identifier: Apache-2.0
+
+from datetime import datetime
+from sqlalchemy import Column, Integer, DateTime, Index
+from app.db.base import Base
+
+
+class UserTeamFavorite(Base):
+    """User team favorite model for maintaining user-team favorite relationships"""
+    __tablename__ = "user_team_favorites"
+
+    id = Column(Integer, primary_key=True, index=True)
+    user_id = Column(Integer, nullable=False, index=True)  # User who favorited the team
+    team_id = Column(Integer, nullable=False, index=True)  # Team that was favorited
+    created_at = Column(DateTime, default=datetime.now)
+
+    __table_args__ = (
+        Index('idx_user_team_favorite', 'user_id', 'team_id', unique=True),
+        {'mysql_charset': 'utf8mb4', 'mysql_collate': 'utf8mb4_unicode_ci'},
+    )

backend/app/schemas/kind.py

@@ -177,6 +177,8 @@ class TeamSpec(BaseModel):
     """Team specification"""
     members: List[TeamMember]
     collaborationModel: str  # pipeline、route、coordinate、collaborate
+    icon: Optional[str] = None  # Lucide icon name (e.g., "Users", "Bot", "Zap")
+    isRecommended: bool = False  # Whether this team is recommended
 
 
 class TeamStatus(Status):

backend/app/schemas/team.py

@@ -34,6 +34,8 @@ class TeamBase(BaseModel):
     bots: List[BotInfo]
     workflow: Optional[dict[str, Any]] = None
     is_active: bool = True
+    icon: Optional[str] = None  # Lucide icon name (e.g., "Users", "Bot", "Zap")
+    is_recommended: bool = False  # Whether this team is recommended
 
 class TeamCreate(TeamBase):
     """Team creation model"""
@@ -45,6 +47,8 @@ class TeamUpdate(BaseModel):
     bots: Optional[List[BotInfo]] = None
     workflow: Optional[dict[str, Any]] = None
     is_active: Optional[bool] = None
+    icon: Optional[str] = None  # Lucide icon name
+    is_recommended: Optional[bool] = None  # Whether this team is recommended
 
 class TeamInDB(TeamBase):
     """Database team model"""
@@ -55,6 +59,7 @@ class TeamInDB(TeamBase):
     user: Optional[dict[str, Any]] = None
     share_status: int = 0  # 0-private, 1-sharing, 2-shared from others
     agent_type: Optional[str] = None  # agno, claude, dify, etc.
+    is_favorited: bool = False  # Whether current user has favorited this team
 
     class Config:
         from_attributes = True
@@ -71,6 +76,9 @@ class TeamDetail(BaseModel):
     updated_at: datetime
     user: Optional[UserInDB] = None
     share_status: int = 0  # 0-private, 1-sharing, 2-shared from others
+    icon: Optional[str] = None  # Lucide icon name
+    is_recommended: bool = False  # Whether this team is recommended
+    is_favorited: bool = False  # Whether current user has favorited this team
 
     class Config:
         from_attributes = True

backend/app/services/adapters/team_kinds.py

@@ -125,7 +125,9 @@ def create_with_user(
             "kind": "Team",
             "spec": {
                 "members": members,
-                "collaborationModel": collaboration_model
+                "collaborationModel": collaboration_model,
+                "icon": getattr(obj_in, 'icon', None),
+                "isRecommended": getattr(obj_in, 'is_recommended', False)
             },
             "status": {
                 "state": "Available"
@@ -462,6 +464,14 @@ def update_with_user(
 
             team_crd.spec.collaborationModel = collaboration_model
 
+        # Handle icon update
+        if "icon" in update_data:
+            team_crd.spec.icon = update_data["icon"]
+
+        # Handle is_recommended update
+        if "is_recommended" in update_data:
+            team_crd.spec.isRecommended = update_data["is_recommended"]
+
         # Save the updated team CRD
         team.json = team_crd.model_dump(mode='json')
         team.updated_at = datetime.now()
@@ -779,7 +789,7 @@ def _convert_to_team_dict(self, team: Kind, db: Session, user_id: int) -> Dict[s
 
         # Convert collaboration model to workflow format
         workflow = {"mode": team_crd.spec.collaborationModel}
-        
+
         return {
             "id": team.id,
             "user_id": team.user_id,
@@ -791,6 +801,8 @@ def _convert_to_team_dict(self, team: Kind, db: Session, user_id: int) -> Dict[s
             "created_at": team.created_at,
             "updated_at": team.updated_at,
             "agent_type": agent_type,  # Add agent_type field
+            "icon": team_crd.spec.icon,  # Lucide icon name
+            "is_recommended": team_crd.spec.isRecommended,  # Whether this team is recommended
         }
 
     def _get_bot_summary(self, bot: Kind, db: Session, user_id: int) -> Dict[str, Any]:

backend/app/services/team_favorite.py

@@ -0,0 +1,81 @@
+# SPDX-FileCopyrightText: 2025 Weibo, Inc.
+#
+# SPDX-License-Identifier: Apache-2.0
+
+from typing import List, Dict, Any, Set
+from sqlalchemy.orm import Session
+from fastapi import HTTPException
+
+from app.models.user_team_favorite import UserTeamFavorite
+from app.models.kind import Kind
+
+
+class TeamFavoriteService:
+    """Service for team favorite operations"""
+
+    def add_favorite(self, db: Session, *, team_id: int, user_id: int) -> Dict[str, Any]:
+        """Add a team to user's favorites"""
+        # Check if team exists
+        team = db.query(Kind).filter(
+            Kind.id == team_id,
+            Kind.kind == "Team",
+            Kind.is_active == True
+        ).first()
+
+        if not team:
+            raise HTTPException(
+                status_code=404,
+                detail="Team not found"
+            )
+
+        # Check if already favorited
+        existing = db.query(UserTeamFavorite).filter(
+            UserTeamFavorite.user_id == user_id,
+            UserTeamFavorite.team_id == team_id
+        ).first()
+
+        if existing:
+            return {"message": "Team already in favorites", "is_favorited": True}
+
+        # Create favorite record
+        favorite = UserTeamFavorite(
+            user_id=user_id,
+            team_id=team_id
+        )
+        db.add(favorite)
+        db.commit()
+
+        return {"message": "Team added to favorites", "is_favorited": True}
+
+    def remove_favorite(self, db: Session, *, team_id: int, user_id: int) -> Dict[str, Any]:
+        """Remove a team from user's favorites"""
+        favorite = db.query(UserTeamFavorite).filter(
+            UserTeamFavorite.user_id == user_id,
+            UserTeamFavorite.team_id == team_id
+        ).first()
+
+        if not favorite:
+            return {"message": "Team not in favorites", "is_favorited": False}
+
+        db.delete(favorite)
+        db.commit()
+
+        return {"message": "Team removed from favorites", "is_favorited": False}
+
+    def get_user_favorite_team_ids(self, db: Session, *, user_id: int) -> Set[int]:
+        """Get set of team IDs that user has favorited"""
+        favorites = db.query(UserTeamFavorite.team_id).filter(
+            UserTeamFavorite.user_id == user_id
+        ).all()
+        return {f.team_id for f in favorites}
+
+    def is_team_favorited(self, db: Session, *, team_id: int, user_id: int) -> bool:
+        """Check if a team is in user's favorites"""
+        favorite = db.query(UserTeamFavorite).filter(
+            UserTeamFavorite.user_id == user_id,
+            UserTeamFavorite.team_id == team_id
+        ).first()
+        return favorite is not None
+
+
+team_favorite_service = TeamFavoriteService()

frontend/src/apis/team.ts

@@ -12,6 +12,8 @@ export interface CreateTeamRequest {
   bots?: TeamBot[];
   workflow?: Record<string, unknown>;
   is_active?: boolean;
+  icon?: string; // Lucide icon name
+  is_recommended?: boolean; // Whether this team is recommended
 }
 
 export interface TeamListResponse {
@@ -82,4 +84,16 @@ export const teamApis = {
   async getTeamInputParameters(teamId: number): Promise<TeamInputParametersResponse> {
     return apiClient.get(`/teams/${teamId}/input-parameters`);
   },
+  async addTeamToFavorites(teamId: number): Promise<{ message: string; is_favorited: boolean }> {
+    return apiClient.post(`/teams/${teamId}/favorite`);
+  },
+  async removeTeamFromFavorites(teamId: number): Promise<{ message: string; is_favorited: boolean }> {
+    return apiClient.delete(`/teams/${teamId}/favorite`);
+  },
+  async getRecommendedTeams(limit: number = 6): Promise<Team[]> {
+    return apiClient.get(`/teams/showcase/recommended?limit=${limit}`);
+  },
+  async getFavoriteTeams(limit: number = 6): Promise<Team[]> {
+    return apiClient.get(`/teams/showcase/favorites?limit=${limit}`);
+  },
 };