feat(project-space): link local tasks to project spaces

backend/app/api/endpoints/cloud_projects.py

@@ -27,8 +27,6 @@
     CloudProjectMemberUpdate,
     CloudProjectResponse,
     CloudProjectUpdate,
-    LocalBindingCreate,
-    LocalBindingResponse,
 )
 from app.services.cloud_files import cloud_file_service
 from app.services.cloud_projects import cloud_project_service
@@ -104,35 +102,6 @@ def archive_cloud_project(
     cloud_project_service.archive(db, project_id, current_user.id, version)
 
 
-@router.post(
-    "/{project_id}/local-bindings",
-    response_model=LocalBindingResponse,
-    status_code=status.HTTP_201_CREATED,
-)
-def add_local_binding(
-    project_id: int,
-    values: LocalBindingCreate,
-    db: Session = Depends(get_db),
-    current_user: User = Depends(get_current_user),
-) -> LocalBindingResponse:
-    binding = cloud_project_service.add_local_binding(
-        db, project_id, current_user.id, values
-    )
-    return LocalBindingResponse.model_validate(binding)
-
-
-@router.get("/{project_id}/local-bindings", response_model=list[LocalBindingResponse])
-def list_local_bindings(
-    project_id: int,
-    db: Session = Depends(get_db),
-    current_user: User = Depends(get_current_user),
-) -> list[LocalBindingResponse]:
-    bindings = cloud_project_service.list_local_bindings(
-        db, project_id, current_user.id
-    )
-    return [LocalBindingResponse.model_validate(binding) for binding in bindings]
-
-
 @router.get("/{project_id}/members", response_model=list[CloudProjectMemberResponse])
 def list_cloud_project_members(
     project_id: int,

backend/app/api/endpoints/deliveries.py

@@ -45,6 +45,9 @@
     LoopItemUpdate,
     MyWorkItemResponse,
     MyWorkListResponse,
+    RuntimeTaskTrack,
+    RuntimeTaskTrackingStatusUpdate,
+    RuntimeTaskTrackResponse,
 )
 from app.services.cloud_projects import cloud_project_service
 from app.services.delivery import delivery_service
@@ -194,6 +197,109 @@ def bind_cloud_project_task(
     return LoopItemTaskBindingResponse.model_validate(binding)
 
 
+def _tracked_item_response(
+    db: Session,
+    item_id: str,
+    current_user: User,
+) -> LoopItemResponse:
+    if external_loop_item_provider.is_external_item(db, item_id):
+        return LoopItemResponse.model_validate(
+            external_loop_item_provider.get(db, item_id, current_user.id)
+        )
+    item = loop_item_service.get(db, item_id, current_user.id)
+    return _loop_item_response(db, item, current_user)
+
+
+@router.post(
+    "/cloud-projects/{project_id}/tasks/track",
+    response_model=RuntimeTaskTrackResponse,
+    status_code=status.HTTP_201_CREATED,
+)
+def track_cloud_project_task(
+    project_id: int,
+    values: RuntimeTaskTrack,
+    db: Session = Depends(get_db),
+    current_user: User = Depends(get_current_user),
+) -> RuntimeTaskTrackResponse:
+    existing = loop_item_service.find_active_task_binding(
+        db, current_user.id, values.device_id, values.task_id
+    )
+    if existing is not None and existing.loop_item_id:
+        if str(existing.cloud_project_id) != str(project_id):
+            raise HTTPException(
+                status.HTTP_409_CONFLICT,
+                "Runtime task is already tracked by another project",
+            )
+        return RuntimeTaskTrackResponse(
+            item=_tracked_item_response(db, existing.loop_item_id, current_user),
+            binding=LoopItemTaskBindingResponse.model_validate(existing),
+        )
+
+    project = cloud_project_service.get(db, project_id, current_user.id)
+    created = loop_item_provider_router.create(
+        db,
+        project,
+        current_user,
+        LoopItemCreate(
+            title=values.task_title,
+            description=values.description,
+            status="in_progress",
+        ),
+    )
+    item_id = str(created.values["id"])
+    external_loop_item_provider.ensure_shadow(db, item_id, current_user.id)
+    binding = loop_item_service.bind_task(
+        db, item_id, values.binding(), current_user.id
+    )
+    return RuntimeTaskTrackResponse(
+        item=LoopItemResponse.model_validate(created.values),
+        binding=LoopItemTaskBindingResponse.model_validate(binding),
+    )
+
+
+@router.patch(
+    "/runtime-tasks/cloud-context/tracking-status",
+    response_model=LoopItemResponse | None,
+)
+def update_runtime_task_tracking_status(
+    values: RuntimeTaskTrackingStatusUpdate,
+    db: Session = Depends(get_db),
+    current_user: User = Depends(get_current_user),
+) -> LoopItemResponse | None:
+    binding = loop_item_service.find_active_task_binding(
+        db, current_user.id, values.device_id, values.task_id
+    )
+    if binding is None or not binding.loop_item_id:
+        return None
+    item = _tracked_item_response(db, binding.loop_item_id, current_user)
+    next_status: str | None = None
+    if values.execution_status == "running" and item.status in {
+        "inbox",
+        "pending",
+        "in_review",
+    }:
+        next_status = "in_progress"
+    elif values.execution_status == "succeeded" and item.status == "in_progress":
+        next_status = "in_review"
+    if next_status is None:
+        return item
+    if external_loop_item_provider.is_external_item(db, item.id):
+        updated = external_loop_item_provider.update(
+            db,
+            item.id,
+            current_user.id,
+            LoopItemUpdate(version=item.version, status=next_status),
+        )
+        return LoopItemResponse.model_validate(updated)
+    stored = loop_item_service.update(
+        db,
+        item.id,
+        current_user.id,
+        LoopItemUpdate(version=item.version, status=next_status),
+    )
+    return _loop_item_response(db, stored, current_user)
+
+
 @router.delete("/runtime-tasks/cloud-context", status_code=status.HTTP_204_NO_CONTENT)
 def unbind_runtime_task_cloud_context(
     values: LoopItemTaskBind,

backend/app/models/__init__.py

@@ -15,7 +15,6 @@
 from app.models.cloud_project import (
     CloudProject,
     CloudProjectFile,
-    CloudProjectLocalBinding,
     LoopItemTaskBinding,
 )
 from app.models.delivery import (
@@ -67,7 +66,6 @@
     "DingtalkSyncedNode",
     "CloudProject",
     "CloudProjectFile",
-    "CloudProjectLocalBinding",
     "LoopItemTaskBinding",
     "LoopItem",
     "LoopItemAttachment",

backend/app/models/cloud_project.py

@@ -6,13 +6,11 @@
 from app.models.delivery import (
     CloudProject,
     CloudProjectFile,
-    CloudProjectLocalBinding,
     LoopItemTaskBinding,
 )
 
 __all__ = [
     "CloudProject",
     "CloudProjectFile",
-    "CloudProjectLocalBinding",
     "LoopItemTaskBinding",
 ]

backend/app/models/delivery.py

@@ -198,14 +198,6 @@ def tags(self) -> list[str]:
         return [str(tag) for tag in tags]
 
 
-class CloudProjectLocalBinding(LoopNode):
-    __mapper_args__ = {"polymorphic_identity": "local_binding"}
-
-    def __init__(self, **kwargs: object) -> None:
-        kwargs.setdefault("is_default", False)
-        super().__init__(**kwargs)
-
-
 class LoopItemTaskBinding(LoopNode):
     __mapper_args__ = {"polymorphic_identity": "execution"}
 

backend/app/schemas/cloud_project.py

@@ -222,30 +222,6 @@ class CloudProjectListResponse(BaseModel):
     items: list[CloudProjectResponse]
 
 
-class LocalBindingCreate(BaseModel):
-    local_project_id: int
-    device_id: str | None = Field(default=None, max_length=100)
-    is_default: bool = False
-
-
-class LocalBindingResponse(BaseModel):
-    model_config = ConfigDict(from_attributes=True)
-
-    id: SnowflakeId
-    cloud_project_id: SnowflakeId
-    local_project_id: int
-    user_id: int
-    device_id: str | None
-    is_default: bool
-    created_at: datetime
-    updated_at: datetime
-
-    @field_validator("device_id", mode="before")
-    @classmethod
-    def normalize_empty_device_id(cls, value: object) -> object:
-        return None if value == "" else value
-
-
 class CloudProjectMemberCreate(BaseModel):
     user_id: int = Field(ge=1)
     role: BaseRole = BaseRole.Developer

backend/app/schemas/delivery.py

@@ -234,6 +234,39 @@ def normalize_unlinked_at(cls, value: object) -> object:
         return LoopItemResponse.normalize_unset_datetime(value)
 
 
+class RuntimeTaskTrack(BaseModel):
+    model_config = ConfigDict(populate_by_name=True)
+
+    device_id: str = Field(alias="deviceId", min_length=1, max_length=100)
+    task_id: str = Field(alias="taskId", min_length=1, max_length=255)
+    task_title: str = Field(alias="taskTitle", min_length=1, max_length=255)
+    description: str = ""
+    backend_task_id: int | None = Field(default=None, alias="backendTaskId")
+
+    def binding(self) -> LoopItemTaskBind:
+        return LoopItemTaskBind(
+            deviceId=self.device_id,
+            taskId=self.task_id,
+            taskTitle=self.task_title,
+            backendTaskId=self.backend_task_id,
+        )
+
+
+class RuntimeTaskTrackingStatusUpdate(BaseModel):
+    model_config = ConfigDict(populate_by_name=True)
+
+    device_id: str = Field(alias="deviceId", min_length=1, max_length=100)
+    task_id: str = Field(alias="taskId", min_length=1, max_length=255)
+    execution_status: Literal["running", "succeeded", "failed", "cancelled"] = Field(
+        alias="executionStatus"
+    )
+
+
+class RuntimeTaskTrackResponse(BaseModel):
+    item: LoopItemResponse
+    binding: LoopItemTaskBindingResponse
+
+
 class CloudTaskContextResponse(LoopItemTaskBindingResponse):
     project: CloudProjectResponse
     loop_item: LoopItemResponse | None = None

backend/app/services/cloud_projects/service.py

@@ -14,9 +14,8 @@
 from sqlalchemy.orm import Session
 
 from app.core.provider_credentials import store_provider_config
-from app.models.cloud_project import CloudProject, CloudProjectLocalBinding
+from app.models.cloud_project import CloudProject
 from app.models.delivery import LoopItem, loop_datetime_is_unset
-from app.models.project import Project
 from app.models.resource_member import MemberStatus, ResourceMember
 from app.models.share_link import ResourceType
 from app.models.user import User
@@ -26,7 +25,6 @@
     CloudProjectMemberCreate,
     CloudProjectMemberUpdate,
     CloudProjectUpdate,
-    LocalBindingCreate,
     default_board_statuses,
     normalize_provider_config,
 )
@@ -270,64 +268,6 @@ def archive(self, db: Session, project_id: int, user_id: int, version: int) -> N
             raise HTTPException(status.HTTP_409_CONFLICT, "Cloud project changed")
         db.commit()
 
-    def add_local_binding(
-        self,
-        db: Session,
-        cloud_project_id: int,
-        user_id: int,
-        values: LocalBindingCreate,
-    ) -> CloudProjectLocalBinding:
-        require_cloud_project_role(db, cloud_project_id, user_id, BaseRole.Developer)
-        local_project = (
-            db.query(Project)
-            .filter(
-                Project.id == values.local_project_id,
-                Project.user_id == user_id,
-                Project.is_active.is_(True),
-            )
-            .first()
-        )
-        if local_project is None:
-            raise HTTPException(status.HTTP_404_NOT_FOUND, "Local project not found")
-        if values.is_default:
-            db.query(CloudProjectLocalBinding).filter(
-                CloudProjectLocalBinding.cloud_project_id == cloud_project_id,
-                CloudProjectLocalBinding.user_id == user_id,
-                CloudProjectLocalBinding.device_id == values.device_id,
-            ).update({"is_default": False})
-        binding = CloudProjectLocalBinding(
-            cloud_project_id=cloud_project_id,
-            user_id=user_id,
-            **values.model_dump(),
-        )
-        db.add(binding)
-        try:
-            db.commit()
-        except IntegrityError as exc:
-            db.rollback()
-            raise HTTPException(
-                status.HTTP_409_CONFLICT, "Local project is already linked"
-            ) from exc
-        db.refresh(binding)
-        return binding
-
-    def list_local_bindings(
-        self, db: Session, cloud_project_id: int, user_id: int
-    ) -> list[CloudProjectLocalBinding]:
-        require_cloud_project_role(db, cloud_project_id, user_id)
-        return (
-            db.query(CloudProjectLocalBinding)
-            .filter(
-                CloudProjectLocalBinding.cloud_project_id == cloud_project_id,
-                CloudProjectLocalBinding.user_id == user_id,
-            )
-            .order_by(
-                CloudProjectLocalBinding.is_default.desc(),
-                CloudProjectLocalBinding.updated_at.desc(),
-            )
-            .all()
-        )
-
     def list_members(
         self, db: Session, cloud_project_id: int, user_id: int
     ) -> list[dict[str, object]]:

backend/app/services/loop_items/service.py

@@ -788,6 +788,24 @@ def find_cloud_context(
         item = db.get(LoopItem, binding.loop_item_id) if binding.loop_item_id else None
         return binding, project, item
 
+    def find_active_task_binding(
+        self,
+        db: Session,
+        user_id: int,
+        device_id: str,
+        task_id: str,
+    ) -> LoopItemTaskBinding | None:
+        return (
+            db.query(LoopItemTaskBinding)
+            .filter(
+                LoopItemTaskBinding.task_user_id == user_id,
+                LoopItemTaskBinding.device_id == device_id,
+                LoopItemTaskBinding.task_id == task_id,
+                loop_datetime_is_unset(LoopItemTaskBinding.unlinked_at),
+            )
+            .first()
+        )
+
     def unbind_cloud_context(
         self, db: Session, values: LoopItemTaskBind, user_id: int
     ) -> None: