feat: Added a shared task model and updated user relationships and configurations.

Author: feifei325

backend/alembic/versions/2b3c4d5e6f7g_add_shared_tasks_table.py

@@ -0,0 +1,48 @@
+"""add shared_tasks table for task sharing
+
+Revision ID: 2b3c4d5e6f7g
+Revises: add_subtask_attachments
+Create Date: 2025-12-04 12:00:00.000000+08:00
+
+"""
+from typing import Sequence, Union
+
+from alembic import op
+import sqlalchemy as sa
+
+
+# revision identifiers, used by Alembic.
+revision: str = '2b3c4d5e6f7g'
+down_revision: Union[str, Sequence[str], None] = 'add_subtask_attachments'
+branch_labels: Union[str, Sequence[str], None] = None
+depends_on: Union[str, Sequence[str], None] = None
+
+
+def upgrade() -> None:
+    """Add shared_tasks table for task sharing functionality."""
+
+    # Create shared_tasks table
+    op.execute("""
+    CREATE TABLE IF NOT EXISTS shared_tasks (
+        id INT NOT NULL AUTO_INCREMENT COMMENT '主键ID',
+        user_id INT NOT NULL DEFAULT 0 COMMENT '当前用户ID',
+        original_user_id INT NOT NULL DEFAULT 0 COMMENT '原始任务所有者用户ID',
+        original_task_id INT NOT NULL DEFAULT 0 COMMENT '原始任务ID',
+        copied_task_id INT NOT NULL DEFAULT 0 COMMENT '复制后的任务ID',
+        is_active BOOLEAN NOT NULL DEFAULT TRUE COMMENT '是否激活',
+        created_at DATETIME NOT NULL DEFAULT CURRENT_TIMESTAMP COMMENT '创建时间',
+        updated_at DATETIME NOT NULL DEFAULT CURRENT_TIMESTAMP ON UPDATE CURRENT_TIMESTAMP COMMENT '更新时间',
+        PRIMARY KEY (id),
+        KEY idx_shared_tasks_id (id),
+        KEY idx_shared_tasks_user_id (user_id),
+        KEY idx_shared_tasks_original_user_id (original_user_id),
+        KEY idx_shared_tasks_original_task_id (original_task_id),
+        KEY idx_shared_tasks_copied_task_id (copied_task_id),
+        UNIQUE KEY uniq_user_original_task (user_id, original_task_id)
+    ) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4
+    """)
+
+
+def downgrade() -> None:
+    """Remove shared_tasks table."""
+    op.execute("DROP TABLE IF EXISTS shared_tasks")

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

@@ -130,7 +130,7 @@ def _should_use_direct_chat(db: Session, team: Kind, user_id: int) -> bool:
     return True
 
 
-def _create_task_and_subtasks(
+async def _create_task_and_subtasks(
     db: Session,
     user: User,
     team: Kind,
@@ -336,7 +336,48 @@ def _create_task_and_subtasks(
     db.commit()
     db.refresh(task)
     db.refresh(assistant_subtask)
-    
+
+    # Initialize Redis chat history from existing subtasks if needed
+    # This is crucial for shared tasks that were copied with historical messages
+    if existing_subtasks:
+        from app.services.chat.session_manager import session_manager
+
+        # Check if history exists in Redis
+        redis_history = await session_manager.get_chat_history(task_id)
+
+        # If Redis history is empty but we have subtasks, rebuild history from DB
+        if not redis_history:
+            logger.info(f"Initializing chat history from DB for task {task_id} with {len(existing_subtasks)} existing subtasks")
+            history_messages = []
+
+            # Sort subtasks by message_id to ensure correct order
+            sorted_subtasks = sorted(existing_subtasks, key=lambda s: s.message_id)
+
+            for subtask in sorted_subtasks:
+                # Only include completed subtasks with results
+                if subtask.status == SubtaskStatus.COMPLETED:
+                    if subtask.role == SubtaskRole.USER:
+                        # User message - use prompt field
+                        if subtask.prompt:
+                            history_messages.append({
+                                "role": "user",
+                                "content": subtask.prompt
+                            })
+                    elif subtask.role == SubtaskRole.ASSISTANT:
+                        # Assistant message - use result.value field
+                        if subtask.result and isinstance(subtask.result, dict):
+                            content = subtask.result.get("value", "")
+                            if content:
+                                history_messages.append({
+                                    "role": "assistant",
+                                    "content": content
+                                })
+
+            # Save to Redis if we found any history
+            if history_messages:
+                await session_manager.save_chat_history(task_id, history_messages)
+                logger.info(f"Initialized {len(history_messages)} messages in Redis for task {task_id}")
+
     return task, assistant_subtask
 
 
@@ -427,9 +468,9 @@ async def stream_chat(
         final_message = attachment_service.build_message_with_attachment(
             request.message, attachment
         )
-    
+
     # Create task and subtasks (use original message for storage, final_message for LLM)
-    task, assistant_subtask = _create_task_and_subtasks(
+    task, assistant_subtask = await _create_task_and_subtasks(
         db, current_user, team, request.message, request, request.task_id
     )
 

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

@@ -14,6 +14,13 @@
 from app.core.config import settings
 from app.models.subtask import Subtask, SubtaskRole, SubtaskStatus
 from app.models.user import User
+from app.schemas.shared_task import (
+    JoinSharedTaskRequest,
+    JoinSharedTaskResponse,
+    PublicSharedTaskResponse,
+    TaskShareInfo,
+    TaskShareResponse,
+)
 from app.schemas.task import (
     TaskCreate,
     TaskDetail,
@@ -23,6 +30,7 @@
     TaskUpdate,
 )
 from app.services.adapters.task_kinds import task_kinds_service
+from app.services.shared_task import shared_task_service
 
 router = APIRouter()
 logger = logging.getLogger(__name__)
@@ -49,7 +57,7 @@ async def call_chat_shell_cancel(subtask_id: int, partial_content: str = ""):
     """Background task to cancel Chat Shell streaming via session manager"""
     try:
         from app.services.chat.session_manager import session_manager
-        
+
         success = await session_manager.cancel_stream(subtask_id)
         if success:
             logger.info(f"Chat Shell stream cancelled successfully for subtask {subtask_id}")
@@ -190,7 +198,7 @@ async def cancel_task(
     """Cancel a running task by calling executor_manager or Chat Shell cancel"""
     from app.models.kind import Kind
     from app.schemas.kind import Task
-    
+
     # Verify user owns this task
     task = task_kinds_service.get_task_detail(
         db=db, task_id=task_id, user_id=current_user.id
@@ -228,13 +236,13 @@ async def cancel_task(
         )
         .first()
     )
-    
+
     if task_kind and task_kind.json:
         task_crd = Task.model_validate(task_kind.json)
         if task_crd.metadata.labels:
             source = task_crd.metadata.labels.get("source", "")
             is_chat_shell = source == "chat_shell"
-    
+
     logger.info(f"Task {task_id} is_chat_shell={is_chat_shell}")
 
     if is_chat_shell:
@@ -249,11 +257,11 @@ async def cancel_task(
             )
             .first()
         )
-        
+
         if running_subtask:
             # Cancel the Chat Shell stream
             background_tasks.add_task(call_chat_shell_cancel, running_subtask.id)
-            
+
             # Update subtask status to COMPLETED (not CANCELLED, to show partial content)
             from datetime import datetime
             running_subtask.status = SubtaskStatus.COMPLETED
@@ -262,7 +270,7 @@ async def cancel_task(
             running_subtask.updated_at = datetime.now()
             running_subtask.error_message = ""
             db.commit()
-            
+
             # Update task status to COMPLETED (not CANCELLING, for Chat Shell)
             try:
                 task_kinds_service.update_task(
@@ -276,7 +284,7 @@ async def cancel_task(
                 )
             except Exception as e:
                 logger.error(f"Failed to update Chat Shell task {task_id} status: {str(e)}")
-            
+
             return {"message": "Chat stopped successfully", "status": "COMPLETED"}
         else:
             # No running subtask found, just mark task as completed
@@ -289,7 +297,7 @@ async def cancel_task(
                 )
             except Exception as e:
                 logger.error(f"Failed to update task {task_id} status: {str(e)}")
-            
+
             return {"message": "No running stream to cancel", "status": "COMPLETED"}
     else:
         # For non-Chat Shell tasks, use executor_manager
@@ -314,3 +322,110 @@ async def cancel_task(
         background_tasks.add_task(call_executor_cancel, task_id)
 
         return {"message": "Cancel request accepted", "status": "CANCELLING"}
+
+
+@router.post("/{task_id}/share", response_model=TaskShareResponse)
+def share_task(
+    task_id: int,
+    current_user: User = Depends(security.get_current_user),
+    db: Session = Depends(get_db),
+):
+    """
+    Generate a share link for a task.
+    The share link allows others to view the task history and copy it to their task list.
+    """
+    # Validate that the task belongs to the current user
+    if not shared_task_service.validate_task_exists(
+        db=db, task_id=task_id, user_id=current_user.id
+    ):
+        raise HTTPException(
+            status_code=404, detail="Task not found or you don't have permission"
+        )
+
+    return shared_task_service.share_task(
+        db=db, task_id=task_id, user_id=current_user.id
+    )
+
+
+@router.get("/share/info", response_model=TaskShareInfo)
+def get_task_share_info(
+    share_token: str = Query(..., description="Share token from URL"),
+    db: Session = Depends(get_db),
+):
+    """
+    Get task share information from share token.
+    This endpoint doesn't require authentication, so anyone with the link can view.
+    """
+    return shared_task_service.get_share_info(db=db, share_token=share_token)
+
+
+@router.get("/share/public", response_model=PublicSharedTaskResponse)
+def get_public_shared_task(
+    token: str = Query(..., description="Share token from URL"),
+    db: Session = Depends(get_db),
+):
+    """
+    Get public shared task data for read-only viewing.
+    This endpoint doesn't require authentication - anyone with the link can view.
+    Only returns public data (no sensitive information like team config, bot details, etc.)
+    """
+    return shared_task_service.get_public_shared_task(db=db, share_token=token)
+
+
+@router.post("/share/join", response_model=JoinSharedTaskResponse)
+def join_shared_task(
+    request: JoinSharedTaskRequest,
+    current_user: User = Depends(security.get_current_user),
+    db: Session = Depends(get_db),
+):
+    """
+    Copy a shared task to the current user's task list.
+    This creates a new task with all the subtasks (messages) from the shared task.
+    """
+    from app.models.kind import Kind
+
+    # If team_id is provided, validate it belongs to the user
+    if request.team_id:
+        user_team = (
+            db.query(Kind)
+            .filter(
+                Kind.user_id == current_user.id,
+                Kind.kind == "Team",
+                Kind.id == request.team_id,
+                Kind.is_active == True,
+            )
+            .first()
+        )
+
+        if not user_team:
+            raise HTTPException(
+                status_code=400,
+                detail="Invalid team_id or team does not belong to you",
+            )
+    else:
+        # Get user's first active team if not specified
+        user_team = (
+            db.query(Kind)
+            .filter(
+                Kind.user_id == current_user.id,
+                Kind.kind == "Team",
+                Kind.is_active == True,
+            )
+            .first()
+        )
+
+        if not user_team:
+            raise HTTPException(
+                status_code=400,
+                detail="You need to have at least one team to copy a shared task",
+            )
+
+    return shared_task_service.join_shared_task(
+        db=db,
+        share_token=request.share_token,
+        user_id=current_user.id,
+        team_id=user_team.id,
+        model_id=request.model_id,
+        force_override_bot_model=request.force_override_bot_model or False,
+    )
+

backend/app/core/config.py

@@ -84,7 +84,7 @@ class Settings(BaseSettings):
     REDIS_URL: str = "redis://127.0.0.1:6379/0"
 
     # Team sharing configuration
-    TEAM_SHARE_BASE_URL: str = "http://localhost:3000"
+    TEAM_SHARE_BASE_URL: str = "http://localhost:3000/chat"
     TEAM_SHARE_QUERY_PARAM: str = "teamShare"
 
     # AES encryption configuration for share tokens

backend/app/models/shared_task.py

@@ -0,0 +1,49 @@
+from sqlalchemy import Column, Integer, String, Boolean, DateTime, ForeignKey, UniqueConstraint
+from sqlalchemy.orm import relationship
+from datetime import datetime
+from app.db.base import Base
+
+
+class SharedTask(Base):
+    """
+    Shared Task model - Records task sharing relationships
+
+    When a user shares a task, the task's content (including subtasks/messages)
+    can be copied to another user's task list.
+    """
+    __tablename__ = "shared_tasks"
+
+    id = Column(Integer, primary_key=True, index=True, autoincrement=True)
+
+    # User who joined/copied the shared task
+    user_id = Column(Integer, ForeignKey("users.id", ondelete="CASCADE"), nullable=False, index=True)
+
+    # Original user who created/shared the task
+    original_user_id = Column(Integer, ForeignKey("users.id", ondelete="CASCADE"), nullable=False, index=True)
+
+    # Original task ID that was shared
+    original_task_id = Column(Integer, ForeignKey("kinds.id", ondelete="CASCADE"), nullable=False, index=True)
+
+    # New task ID created for the user who joined (copied task)
+    copied_task_id = Column(Integer, ForeignKey("kinds.id", ondelete="CASCADE"), nullable=True, index=True)
+
+    # Whether this share relationship is active
+    is_active = Column(Boolean, default=True, nullable=False)
+
+    # Timestamps
+    created_at = Column(DateTime, default=datetime.utcnow, nullable=False)
+    updated_at = Column(DateTime, default=datetime.utcnow, onupdate=datetime.utcnow, nullable=False)
+
+    # Relationships
+    user = relationship("User", foreign_keys=[user_id], back_populates="shared_tasks")
+    original_user = relationship("User", foreign_keys=[original_user_id])
+    original_task = relationship("Kind", foreign_keys=[original_task_id])
+    copied_task = relationship("Kind", foreign_keys=[copied_task_id])
+
+    # Unique constraint: one user can only copy the same original task once
+    __table_args__ = (
+        UniqueConstraint('user_id', 'original_task_id', name='uq_user_original_task'),
+    )
+
+    def __repr__(self):
+        return f"<SharedTask(id={self.id}, user_id={self.user_id}, original_task_id={self.original_task_id})>"

backend/app/models/user.py

@@ -25,6 +25,9 @@ class User(Base):
     created_at = Column(DateTime, default=func.now())
     updated_at = Column(DateTime, default=func.now(), onupdate=func.now())
 
+    # Relationships
+    shared_tasks = relationship("SharedTask", foreign_keys="[SharedTask.user_id]", back_populates="user")
+
     __table_args__ = (
         {
             "sqlite_autoincrement": True,