refactor(backend): two-phase synchronous cloning

surfsense_backend/app/routes/new_chat_routes.py

@@ -37,6 +37,7 @@ from app.db import (
     get_async_session,
 )
 from app.schemas.new_chat import (
+    CompleteCloneResponse,
     NewChatMessageAppend,
     NewChatMessageRead,
     NewChatRequest,
@@ -669,6 +670,62 @@ async def delete_thread(
         ) from None
 
 
+@router.post("/threads/{thread_id}/complete-clone", response_model=CompleteCloneResponse)
+async def complete_clone(
+    thread_id: int,
+    session: AsyncSession = Depends(get_async_session),
+    user: User = Depends(current_active_user),
+):
+    """
+    Complete the cloning process for a thread.
+
+    Copies messages and podcasts from the source thread.
+    Sets clone_pending=False and needs_history_bootstrap=True when done.
+
+    Requires authentication and ownership of the thread.
+    """
+    from app.services.public_chat_service import complete_clone_content
+
+    try:
+        result = await session.execute(
+            select(NewChatThread).filter(NewChatThread.id == thread_id)
+        )
+        thread = result.scalars().first()
+
+        if not thread:
+            raise HTTPException(status_code=404, detail="Thread not found")
+
+        if thread.created_by_id != user.id:
+            raise HTTPException(status_code=403, detail="Not authorized")
+
+        if not thread.clone_pending:
+            raise HTTPException(status_code=400, detail="Clone already completed")
+
+        if not thread.cloned_from_thread_id:
+            raise HTTPException(status_code=400, detail="No source thread to clone from")
+
+        message_count = await complete_clone_content(
+            session=session,
+            target_thread=thread,
+            source_thread_id=thread.cloned_from_thread_id,
+            target_search_space_id=thread.search_space_id,
+        )
+
+        return CompleteCloneResponse(
+            status="success",
+            message_count=message_count,
+        )
+
+    except HTTPException:
+        raise
+    except Exception as e:
+        await session.rollback()
+        raise HTTPException(
+            status_code=500,
+            detail=f"An unexpected error occurred while completing clone: {e!s}",
+        ) from None
+
+
 @router.patch("/threads/{thread_id}/visibility", response_model=NewChatThreadRead)
 async def update_thread_visibility(
     thread_id: int,

surfsense_backend/app/routes/public_chat_routes.py

@@ -2,17 +2,20 @@
 Routes for public chat access (unauthenticated and mixed-auth endpoints).
 """
 
+from datetime import UTC, datetime
+
 from fastapi import APIRouter, Depends, HTTPException
 from sqlalchemy.ext.asyncio import AsyncSession
 
-from app.db import User, get_async_session
+from app.db import ChatVisibility, NewChatThread, User, get_async_session
 from app.schemas.new_chat import (
-    CloneInitiatedResponse,
+    CloneInitResponse,
     PublicChatResponse,
 )
 from app.services.public_chat_service import (
     get_public_chat,
     get_thread_by_share_token,
+    get_user_default_search_space,
 )
 from app.users import current_active_user
 
@@ -33,32 +36,47 @@ async def read_public_chat(
     return await get_public_chat(session, share_token)
 
 
-@router.post("/{share_token}/clone", response_model=CloneInitiatedResponse)
+@router.post("/{share_token}/clone", response_model=CloneInitResponse)
 async def clone_public_chat_endpoint(
     share_token: str,
     session: AsyncSession = Depends(get_async_session),
     user: User = Depends(current_active_user),
 ):
     """
-    Clone a public chat to the user's account.
+    Initialize cloning a public chat to the user's account.
+
+    Creates an empty thread with clone_pending=True.
+    Frontend should redirect to the new thread and call /complete-clone.
 
     Requires authentication.
-    Initiates a background job to copy the chat.
     """
-    from app.tasks.celery_tasks.clone_chat_tasks import clone_public_chat_task
+    source_thread = await get_thread_by_share_token(session, share_token)
 
-    thread = await get_thread_by_share_token(session, share_token)
+    if not source_thread:
+        raise HTTPException(status_code=404, detail="Chat not found or no longer public")
 
-    if not thread:
-        raise HTTPException(status_code=404, detail="Not found")
+    target_search_space_id = await get_user_default_search_space(session, user.id)
 
-    task_result = clone_public_chat_task.delay(
+    if target_search_space_id is None:
+        raise HTTPException(status_code=400, detail="No search space found for user")
+
+    new_thread = NewChatThread(
+        title=source_thread.title,
+        archived=False,
+        visibility=ChatVisibility.PRIVATE,
+        search_space_id=target_search_space_id,
+        created_by_id=user.id,
+        public_share_enabled=False,
+        cloned_from_thread_id=source_thread.id,
+        cloned_at=datetime.now(UTC),
+        clone_pending=True,
+    )
+    session.add(new_thread)
+    await session.commit()
+    await session.refresh(new_thread)
+
+    return CloneInitResponse(
+        thread_id=new_thread.id,
+        search_space_id=target_search_space_id,
         share_token=share_token,
-        user_id=str(user.id),
-    )
-
-    return CloneInitiatedResponse(
-        status="processing",
-        task_id=task_result.id,
-        message="Copying chat to your account...",
     )