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

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

@@ -2,6 +2,8 @@
 #
 # SPDX-License-Identifier: Apache-2.0
 
+from typing import Any, Dict, List
+
 from fastapi import APIRouter, Depends, Query, status
 from sqlalchemy.orm import Session
 
@@ -24,6 +26,7 @@
 )
 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()
 
@@ -40,6 +43,14 @@ def list_teams(
     items = team_kinds_service.get_user_teams(
         db=db, user_id=current_user.id, skip=skip, limit=limit
     )
+
+    # Add is_favorited field to each team
+    favorite_team_ids = team_favorite_service.get_user_favorite_team_ids(
+        db=db, user_id=current_user.id
+    )
+    for item in items:
+        item["is_favorited"] = item["id"] in favorite_team_ids
+
     if page == 1 and len(items) < limit:
         total = len(items)
     else:
@@ -139,3 +150,94 @@ def join_shared_team(
     return shared_team_service.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

@@ -13,5 +13,6 @@
 # Do NOT import Base here to avoid conflicts with app.db.base.Base
 # All models should import Base directly from app.db.base
 from app.models.user import User
+from app.models.user_team_favorite import UserTeamFavorite
 
-__all__ = ["User", "Kind", "Subtask", "SharedTeam", "SkillBinary"]
+__all__ = ["User", "Kind", "Subtask", "SharedTeam", "SkillBinary", "UserTeamFavorite"]

backend/app/models/user_team_favorite.py

@@ -0,0 +1,25 @@
+# SPDX-FileCopyrightText: 2025 Weibo, Inc.
+#
+# SPDX-License-Identifier: Apache-2.0
+
+from datetime import datetime
+
+from sqlalchemy import Column, DateTime, Index, Integer
+
+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

@@ -206,6 +206,8 @@ class TeamSpec(BaseModel):
 
     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

@@ -42,6 +42,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):
@@ -57,6 +59,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):
@@ -69,6 +73,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
@@ -86,6 +91,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

@@ -136,7 +136,12 @@ def create_with_user(
         # Create Team JSON
         team_json = {
             "kind": "Team",
-            "spec": {"members": members, "collaborationModel": collaboration_model},
+            "spec": {
+                "members": members,
+                "collaborationModel": collaboration_model,
+                "icon": getattr(obj_in, "icon", None),
+                "isRecommended": getattr(obj_in, "is_recommended", False),
+            },
             "status": {"state": "Available"},
             "metadata": {"name": obj_in.name, "namespace": "default"},
             "apiVersion": "agent.wecode.io/v1",
@@ -511,6 +516,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()
@@ -886,6 +899,8 @@ def _convert_to_team_dict(
             "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,91 @@
+# SPDX-FileCopyrightText: 2025 Weibo, Inc.
+#
+# SPDX-License-Identifier: Apache-2.0
+
+from typing import Any, Dict, List, Set
+
+from fastapi import HTTPException
+from sqlalchemy.orm import Session
+
+from app.models.kind import Kind
+from app.models.user_team_favorite import UserTeamFavorite
+
+
+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()