"""Roundtable-draft sharing API. A user creates a share code for *one* of their roundtable-planning drafts (a full 会商 session). Two modes: - ``import`` — redeeming the code copies the draft into the redeemer's account as an independent copy they fully own (fresh draft id, deduped per recipient). - ``view`` — a public, read-only page that renders the draft's Step 3 result report (the self-contained 方案总览 HTML). Anyone with the link can open it without logging in. Mirrors ``app/gateway/routers/thread_shares.py`` but the shared resource is a ``roundtable_drafts`` row (read via ``app.state.roundtable_draft_store``) rather than a conversation thread. """ from __future__ import annotations import hashlib import logging from fastapi import APIRouter, Depends, HTTPException, Request from pydantic import BaseModel, Field from app.gateway.deps import get_roundtable_draft_share_store from deerflow.persistence.roundtable_draft_shares.base import RoundtableDraftShareStore from deerflow.runtime.user_context import get_effective_user_id logger = logging.getLogger(__name__) router = APIRouter(prefix="/api/roundtable-draft-shares", tags=["roundtable-draft-shares"]) # Public, unauthenticated router. Its prefix is whitelisted in # ``auth_middleware._PUBLIC_PATH_PREFIXES`` (``/api/public/``) — only read-only, # intentionally world-readable endpoints belong here. public_router = APIRouter(prefix="/api/public/roundtable-shares", tags=["roundtable-draft-shares-public"]) _UNTITLED = "未命名会商" _SHARE_MODES = ("import", "view") def _current_user_id(request: Request) -> str: user = getattr(request.state, "user", None) if user is not None: return str(user.id) return get_effective_user_id() def _get_draft_store(request: Request): store = getattr(request.app.state, "roundtable_draft_store", None) if store is None: raise HTTPException(status_code=503, detail="Roundtable draft store not available") return store # --------------------------------------------------------------------------- # Request / response models # --------------------------------------------------------------------------- class CreateShareRequest(BaseModel): draft_id: str = Field(..., description="The roundtable draft to share") mode: str = Field( default="import", description='"import" — recipient copies the draft; "view" — public read-only result page', ) class ShareResponse(BaseModel): share_code: str = Field(..., description="Short code that recipients enter to import") owner_user_id: str = Field(..., description="User who created the share") draft_id: str = Field(..., description="The shared draft") revoked: bool = Field(default=False, description="Whether the code has been revoked") mode: str = Field(default="import", description='"import" or "view"') created_at: str | None = Field(default=None, description="Creation timestamp (ISO-8601)") class SharesListResponse(BaseModel): shares: list[ShareResponse] class SharePreviewResponse(BaseModel): share_code: str shared_by: str = Field(..., description="Owner user id of the shared draft") title: str = Field(..., description="Title of the shared draft") class ImportResultResponse(BaseModel): imported: int = Field(..., description="1 when the draft was copied, else 0") skipped: int = Field(..., description="1 when it was already imported, else 0") draft_id: str | None = Field(default=None, description="The new local draft id (when imported)") class SeatDeliveryItem(BaseModel): """One sub-agent's final delivery from the Step 2 roundtable.""" sender: str = "" content: str = "" class PublicDraftShareSnapshotResponse(BaseModel): """Read-only roundtable-result snapshot served to anonymous viewers. Mirrors what the in-app Step 3「最终方案展示」(`HighFidelityReport`) shows, minus the live per-seat output files (those need authenticated thread access): 总控最终结论 + 各席位最终交付 + the generated 结果绘制 report. """ share_code: str title: str = Field(..., description="Draft title") mode: str = Field(default="view") # 总控最终结论 —— the coordinator's final consensus text (Step 2 lastLeaderContent). consensus_text: str = Field(default="", description="Coordinator's final consensus (markdown)") # 各席位最终交付 —— each sub-agent's final delivery, filtered from Step 2 dialogues. seat_deliveries: list[SeatDeliveryItem] = Field(default_factory=list) # The Step 3「结果绘制」report — a self-contained HTML document. Empty when the # shared draft never reached / generated a result report. html: str = Field(default="", description="Self-contained Step 3 result report HTML (经典 HTML 看板)") summary: str | None = Field(default=None, description="The report's closing one-liner") generated_at: str | None = Field(default=None, description="When the report was generated (ISO-8601)") has_report: bool = Field(default=False, description="Whether a Step 3 HTML report exists") # Step 3「方案总结报告」—— the Markdown report from roundtable-summary (step3.summaryReport.md). summary_report_md: str = Field(default="", description="Step 3 Markdown 方案总结报告") has_summary_report: bool = Field(default=False, description="Whether a Step 3 Markdown summary report exists") # Step 3「大屏多页」(模式二) —— structured dashboard data (step3.dashboardJson); the # frontend renders it to self-contained HTML via renderDashboardHtml at view time. dashboard_json: str | None = Field(default=None, description="Step 3 大屏多页 structured data (report-json)") has_dashboard: bool = Field(default=False, description="Whether a Step 3 大屏多页 dashboard exists") created_at: str | None = Field(default=None, description="When the share was created (ISO-8601)") # --------------------------------------------------------------------------- # Owner side — create / list / revoke # --------------------------------------------------------------------------- @router.post("", response_model=ShareResponse, summary="Create a share code for one roundtable draft") async def create_share( body: CreateShareRequest, request: Request, share_store: RoundtableDraftShareStore = Depends(get_roundtable_draft_share_store), ) -> ShareResponse: me = _current_user_id(request) mode = body.mode if body.mode in _SHARE_MODES else "import" # Only the draft's owner may share it. draft = await _get_draft_store(request).get_draft(body.draft_id, me) if draft is None: raise HTTPException(status_code=404, detail="Draft not found") # Reuse an existing active code (of the same mode) so re-sharing is idempotent. existing = await share_store.get_active_for_draft(me, body.draft_id, mode=mode) if existing is not None: return ShareResponse(**existing) record = await share_store.create(me, body.draft_id, mode=mode) return ShareResponse(**record) @router.get("", response_model=SharesListResponse, summary="List my roundtable-draft share codes") async def list_shares( request: Request, share_store: RoundtableDraftShareStore = Depends(get_roundtable_draft_share_store), ) -> SharesListResponse: records = await share_store.list_for_owner(_current_user_id(request)) return SharesListResponse(shares=[ShareResponse(**r) for r in records]) @router.delete("/{share_code}", summary="Revoke a roundtable-draft share code") async def revoke_share( share_code: str, request: Request, share_store: RoundtableDraftShareStore = Depends(get_roundtable_draft_share_store), ) -> dict[str, bool]: ok = await share_store.revoke(share_code, _current_user_id(request)) if not ok: raise HTTPException(status_code=404, detail="Share code not found") return {"success": True} # --------------------------------------------------------------------------- # Recipient side — preview / import # --------------------------------------------------------------------------- async def _resolve_active_share(share_code: str, share_store: RoundtableDraftShareStore) -> dict: share = await share_store.get(share_code) if share is None: raise HTTPException(status_code=404, detail="Share code not found") if share.get("revoked"): raise HTTPException(status_code=410, detail="This share code has been revoked") return share @router.get("/{share_code}/preview", response_model=SharePreviewResponse, summary="Preview a shared roundtable draft") async def preview_share( share_code: str, request: Request, share_store: RoundtableDraftShareStore = Depends(get_roundtable_draft_share_store), ) -> SharePreviewResponse: share = await _resolve_active_share(share_code, share_store) owner = share["owner_user_id"] draft = await _get_draft_store(request).get_draft(share["draft_id"], owner) if draft is None: raise HTTPException(status_code=404, detail="The shared draft no longer exists") return SharePreviewResponse( share_code=share_code, shared_by=owner, title=draft.get("title") or _UNTITLED, ) def _imported_draft_id(share_code: str, recipient: str) -> str: """Deterministic per-(code, recipient) draft id so re-import is idempotent. ``roundtable_drafts.id`` is a global PK, so the id must be unique across users — hence the recipient is folded into the hash rather than reusing a code-only id (which would collide when two people import the same code). """ digest = hashlib.sha1(f"{share_code}:{recipient}".encode()).hexdigest() return f"imp_{digest[:40]}" @router.post("/{share_code}/import", response_model=ImportResultResponse, summary="Import a shared roundtable draft") async def import_share( share_code: str, request: Request, share_store: RoundtableDraftShareStore = Depends(get_roundtable_draft_share_store), ) -> ImportResultResponse: share = await _resolve_active_share(share_code, share_store) if share.get("mode") == "view": raise HTTPException(status_code=400, detail="This is a view-only share — open its link to read it instead of importing") owner = share["owner_user_id"] origin_id = share["draft_id"] recipient = _current_user_id(request) if owner == recipient: raise HTTPException(status_code=400, detail="You cannot import your own share code") draft_store = _get_draft_store(request) src = await draft_store.get_draft(origin_id, owner) if src is None: raise HTTPException(status_code=404, detail="The shared draft no longer exists") # Dedup: a deterministic id per (code, recipient) makes re-import a no-op. new_id = _imported_draft_id(share_code, recipient) if await draft_store.get_draft(new_id, recipient) is not None: return ImportResultResponse(imported=0, skipped=1, draft_id=new_id) await draft_store.create_draft( recipient, { "id": new_id, "title": src.get("title") or _UNTITLED, "furthest_step": src.get("furthest_step") or 1, "step1": src.get("step1"), "step2": src.get("step2"), "step3": src.get("step3"), }, ) logger.info("Roundtable share %s imported by %s as draft %s", share_code, recipient, new_id) return ImportResultResponse(imported=1, skipped=0, draft_id=new_id) # --------------------------------------------------------------------------- # Public read-only view — no authentication required # --------------------------------------------------------------------------- def _result_sections(draft: dict) -> tuple[str, list[dict[str, str]]]: """Derive (总控最终结论, 各席位最终交付) from a draft's Step 2 snapshot. Mirrors the frontend draft hydration (`RoundtablePlanningPage.normalizeStep2Runs`): when the draft has ``runs[]`` the rendered content is the **active run** (``activeRunId``), NOT the top-level ``step2`` fields — those can be a stale foreground seed (e.g. only the 系统消息/开场 2 条气泡) left over after a later background job wrote its results into ``runs[]``. Reading the top level there yields an empty consensus and no deliveries (the reported bug). Only drafts with no ``runs[]`` (legacy/foreground-only) fall back to the top-level fields. The consensus is ``lastLeaderContent`` and each seat delivery is a dialogue bubble tagged ``confidence == "子智能体交付"``. """ step2 = draft.get("step2") if isinstance(draft.get("step2"), dict) else {} step2 = step2 or {} runs = [r for r in step2.get("runs", []) if isinstance(r, dict)] if isinstance(step2.get("runs"), list) else [] if runs: active_id = step2.get("activeRunId") source = next((r for r in runs if r.get("id") == active_id), None) or runs[0] else: source = step2 consensus = source.get("lastLeaderContent") or "" dialogues = source.get("step2RoundtableDialogues") if not isinstance(dialogues, list): dialogues = [] seat_deliveries = [ {"sender": str(d.get("sender") or ""), "content": str(d.get("content") or "")} for d in dialogues if isinstance(d, dict) and d.get("confidence") == "子智能体交付" ] return consensus, seat_deliveries @public_router.get( "/{share_code}", response_model=PublicDraftShareSnapshotResponse, summary="Public read-only snapshot of a view-shared roundtable draft", ) async def get_public_draft_share_snapshot( share_code: str, request: Request, share_store: RoundtableDraftShareStore = Depends(get_roundtable_draft_share_store), ) -> PublicDraftShareSnapshotResponse: """Serve a frozen, read-only roundtable result. Anyone with the link can read it. Only ``mode="view"`` shares are exposed; missing, revoked, or import-mode codes all return 404 so the endpoint never reveals which case applies. """ share = await share_store.get(share_code) if share is None or share.get("revoked") or share.get("mode") != "view": raise HTTPException(status_code=404, detail="Share not found") draft = await _get_draft_store(request).get_draft(share["draft_id"], share["owner_user_id"]) if draft is None: raise HTTPException(status_code=404, detail="The shared draft no longer exists") step3 = draft.get("step3") if isinstance(draft.get("step3"), dict) else {} step3 = step3 or {} html = step3.get("html") or "" # 方案总结报告（Markdown，模式：roundtable-summary）—— 嵌在 step3.summaryReport.md。 summary_report = step3.get("summaryReport") if isinstance(step3.get("summaryReport"), dict) else {} summary_report_md = (summary_report or {}).get("md") or "" # 大屏多页（模式二）—— 只存结构化数据 step3.dashboardJson，前端按主题渲染成自包含 HTML。 dashboard_json = step3.get("dashboardJson") or None consensus_text, seat_deliveries = _result_sections(draft) return PublicDraftShareSnapshotResponse( share_code=share_code, title=draft.get("title") or _UNTITLED, mode="view", consensus_text=consensus_text, seat_deliveries=[SeatDeliveryItem(**s) for s in seat_deliveries], html=html, summary=step3.get("summary"), generated_at=step3.get("generatedAt"), has_report=bool(html), summary_report_md=summary_report_md, has_summary_report=bool(summary_report_md), dashboard_json=dashboard_json, has_dashboard=bool(dashboard_json), created_at=share.get("created_at"), )