feat: 定时任务管理 + 会话只读分享
定时任务: - 管理员可查看/编辑/删除/触发全部用户的定时任务(新增 /api/scheduled-tasks/admin/* 接口与管理页) - 卡死任务恢复:单次执行超 30 分钟超时重试(最多 3 次),耗尽后标记 failed;看门狗回收服务重启遗留的「执行中」任务 会话分享: - 新增「只读链接」分享模式,生成公开免登录的只读对话快照页(/share/:code) - 公开接口 /api/public/shares/* 提供对话快照与图片附件 Co-Authored-By: Claude Opus 4.7 (1M context) <noreply@anthropic.com>
This commit is contained in:
1 parent
4761677676
commit
e0c1cb6581
45 files changed
+3235
-434
No files matched your search
@@ -41,6 +41,7 @@ from app.gateway.routers import (
|
||||
system_settings,
|
||||
tags,
|
||||
thread_runs,
|
||||
thread_shares,
|
||||
threads,
|
||||
uploads,
|
||||
)
|
||||
@@ -701,6 +702,10 @@ This gateway provides custom endpoints for models, MCP configuration, skills, an
|
||||
# Thread Runs API (LangGraph Platform-compatible runs lifecycle)
|
||||
app.include_router(thread_runs.router)
|
||||
|
||||
app.include_router(thread_shares.router)
|
||||
# Public, unauthenticated read-only share snapshots (/api/public/shares/*).
|
||||
app.include_router(thread_shares.public_router)
|
||||
|
||||
# Stateless Runs API (stream/wait without a pre-existing thread)
|
||||
app.include_router(runs.router)
|
||||
|
||||
|
||||
@@ -23,11 +23,16 @@ from app.gateway.internal_auth import INTERNAL_AUTH_HEADER_NAME, get_internal_us
|
||||
from deerflow.runtime.user_context import reset_current_user, set_current_user
|
||||
|
||||
# Paths that never require authentication.
|
||||
#
|
||||
# ``/api/public/`` is a namespace reserved for intentionally world-readable,
|
||||
# read-only endpoints (e.g. public conversation share snapshots). Only mount
|
||||
# safe read-only routes under it — everything there bypasses auth entirely.
|
||||
_PUBLIC_PATH_PREFIXES: tuple[str, ...] = (
|
||||
"/health",
|
||||
"/docs",
|
||||
"/redoc",
|
||||
"/openapi.json",
|
||||
"/api/public/",
|
||||
)
|
||||
|
||||
# Exact auth paths that are public (login/register/status check).
|
||||
|
||||
@@ -122,6 +122,10 @@ async def langgraph_runtime(app: FastAPI) -> AsyncGenerator[None, None]:
|
||||
|
||||
app.state.tag_store = make_tag_store(sf)
|
||||
|
||||
from deerflow.persistence.thread_shares import make_thread_share_store
|
||||
|
||||
app.state.thread_share_store = make_thread_share_store(sf)
|
||||
|
||||
# Run event store (has its own factory with config-driven backend selection)
|
||||
run_events_config = getattr(config, "run_events", None)
|
||||
app.state.run_event_store = make_run_event_store(run_events_config)
|
||||
@@ -222,6 +226,14 @@ def get_tag_store(request: Request) -> TagStore:
|
||||
return val
|
||||
|
||||
|
||||
def get_thread_share_store(request: Request):
|
||||
"""Return the conversation share-link store."""
|
||||
val = getattr(request.app.state, "thread_share_store", None)
|
||||
if val is None:
|
||||
raise HTTPException(status_code=503, detail="Thread share store not available")
|
||||
return val
|
||||
|
||||
|
||||
def get_run_context(request: Request) -> RunContext:
|
||||
"""Build a :class:`RunContext` from ``app.state`` singletons.
|
||||
|
||||
|
||||
@@ -14,7 +14,7 @@ from fastapi import APIRouter, HTTPException, Query, Request
|
||||
from fastapi.responses import FileResponse, Response, StreamingResponse
|
||||
from pydantic import BaseModel, Field
|
||||
|
||||
from app.gateway.deps import get_current_user, get_local_provider, get_tag_store
|
||||
from app.gateway.deps import get_current_user, get_local_provider, get_optional_user_from_request, get_tag_store
|
||||
from deerflow.runtime.scheduler import get_scheduled_task_service
|
||||
|
||||
router = APIRouter(prefix="/api/scheduled-tasks", tags=["scheduled-tasks"])
|
||||
@@ -61,6 +61,26 @@ async def _user_id(request: Request) -> str:
|
||||
return user_id
|
||||
|
||||
|
||||
async def _is_admin(request: Request) -> bool:
|
||||
"""True when the caller is an admin (or auth is disabled entirely)."""
|
||||
user = await get_optional_user_from_request(request)
|
||||
if user is None:
|
||||
return True
|
||||
return getattr(user, "system_role", None) == "admin"
|
||||
|
||||
|
||||
async def _load_run(service, request: Request, run_id: str, user_id: str) -> dict[str, Any] | None:
|
||||
"""Owner/subscriber run lookup, with an admin fallback to any run.
|
||||
|
||||
Lets admins open run results for tasks they do not own (the admin
|
||||
management view links into the shared run-detail page).
|
||||
"""
|
||||
run = await _load_run(service, request, run_id, user_id)
|
||||
if run is None and await _is_admin(request):
|
||||
run = await service.admin_get_run(run_id)
|
||||
return run
|
||||
|
||||
|
||||
async def _enrich_with_creator(tasks: list[dict[str, Any]] | dict[str, Any] | None) -> Any:
|
||||
"""Attach ``creator_email`` / ``creator_user_id`` to one or many task dicts.
|
||||
|
||||
@@ -208,7 +228,7 @@ async def list_scheduled_task_runs(task_id: str, request: Request, limit: int =
|
||||
async def get_scheduled_task_run(run_id: str, request: Request) -> dict:
|
||||
service = get_scheduled_task_service()
|
||||
user_id = await _user_id(request)
|
||||
run = await service.get_run(user_id, run_id)
|
||||
run = await _load_run(service, request, run_id, user_id)
|
||||
if run is None:
|
||||
raise HTTPException(status_code=404, detail=f"Run {run_id} not found")
|
||||
return run
|
||||
@@ -231,7 +251,7 @@ async def delete_scheduled_task_run(run_id: str, request: Request) -> dict:
|
||||
async def get_scheduled_task_run_file(run_id: str, file_index: int, request: Request) -> dict:
|
||||
service = get_scheduled_task_service()
|
||||
user_id = await _user_id(request)
|
||||
run = await service.get_run(user_id, run_id)
|
||||
run = await _load_run(service, request, run_id, user_id)
|
||||
if run is None:
|
||||
raise HTTPException(status_code=404, detail=f"Run {run_id} not found")
|
||||
item, path = _run_file_path(run, file_index)
|
||||
@@ -279,7 +299,7 @@ async def update_scheduled_task_run_file(
|
||||
async def download_scheduled_task_run(run_id: str, request: Request):
|
||||
service = get_scheduled_task_service()
|
||||
user_id = await _user_id(request)
|
||||
run = await service.get_run(user_id, run_id)
|
||||
run = await _load_run(service, request, run_id, user_id)
|
||||
if run is None:
|
||||
raise HTTPException(status_code=404, detail=f"Run {run_id} not found")
|
||||
|
||||
@@ -328,7 +348,7 @@ async def download_scheduled_task_run(run_id: str, request: Request):
|
||||
async def download_scheduled_task_run_file(run_id: str, file_index: int, request: Request):
|
||||
service = get_scheduled_task_service()
|
||||
user_id = await _user_id(request)
|
||||
run = await service.get_run(user_id, run_id)
|
||||
run = await _load_run(service, request, run_id, user_id)
|
||||
if run is None:
|
||||
raise HTTPException(status_code=404, detail=f"Run {run_id} not found")
|
||||
item, path = _run_file_path(run, file_index)
|
||||
@@ -497,3 +517,82 @@ async def delete_scheduled_task_subscription(task_id: str, request: Request) ->
|
||||
if not deleted:
|
||||
raise HTTPException(status_code=404, detail="Subscription not found")
|
||||
return {"success": True}
|
||||
|
||||
|
||||
# --- Admin (cross-user management) ---
|
||||
|
||||
|
||||
async def _require_admin(request: Request) -> None:
|
||||
"""Reject non-admins. Lets the call through when auth is disabled."""
|
||||
user = await get_optional_user_from_request(request)
|
||||
if user is None:
|
||||
return
|
||||
if getattr(user, "system_role", None) != "admin":
|
||||
raise HTTPException(status_code=403, detail="定时任务管理仅限管理员")
|
||||
|
||||
|
||||
@router.get("/admin/all")
|
||||
async def admin_list_scheduled_tasks(
|
||||
request: Request,
|
||||
search: str | None = Query(default=None, description="Case-insensitive fuzzy match on task name"),
|
||||
) -> list[dict]:
|
||||
"""List every scheduled task across all users. Admin-only."""
|
||||
await _require_admin(request)
|
||||
service = get_scheduled_task_service()
|
||||
tasks = await service.admin_list_tasks()
|
||||
await _enrich_with_creator(tasks)
|
||||
|
||||
tag_store = get_tag_store(request)
|
||||
assignments = await tag_store.list_assignments("scheduled_task", [str(t.get("task_id")) for t in tasks])
|
||||
for task in tasks:
|
||||
task["tags"] = assignments.get(str(task.get("task_id")), [])
|
||||
if search:
|
||||
needle = search.strip().lower()
|
||||
tasks = [t for t in tasks if needle in str(t.get("name", "")).lower()]
|
||||
return tasks
|
||||
|
||||
|
||||
@router.get("/admin/{task_id}/runs")
|
||||
async def admin_list_scheduled_task_runs(task_id: str, request: Request, limit: int = 50) -> list[dict]:
|
||||
"""List runs for any task regardless of owner. Admin-only."""
|
||||
await _require_admin(request)
|
||||
service = get_scheduled_task_service()
|
||||
return await service.admin_list_runs(task_id, limit=max(1, min(limit, 200)))
|
||||
|
||||
|
||||
@router.patch("/admin/{task_id}")
|
||||
async def admin_update_scheduled_task(task_id: str, body: ScheduledTaskUpdateRequest, request: Request) -> dict:
|
||||
"""Update any task regardless of owner. Admin-only."""
|
||||
await _require_admin(request)
|
||||
service = get_scheduled_task_service()
|
||||
task = await service.admin_update_task(task_id, body.model_dump(exclude_unset=True))
|
||||
if task is None:
|
||||
raise HTTPException(status_code=404, detail=f"Task {task_id} not found")
|
||||
await _enrich_with_creator(task)
|
||||
return task
|
||||
|
||||
|
||||
@router.delete("/admin/{task_id}")
|
||||
async def admin_delete_scheduled_task(task_id: str, request: Request) -> dict:
|
||||
"""Delete any task regardless of owner. Admin-only."""
|
||||
await _require_admin(request)
|
||||
service = get_scheduled_task_service()
|
||||
deleted = await service.admin_delete_task(task_id)
|
||||
if not deleted:
|
||||
raise HTTPException(status_code=404, detail=f"Task {task_id} not found")
|
||||
try:
|
||||
await get_tag_store(request).unassign_all("scheduled_task", task_id)
|
||||
except Exception: # noqa: BLE001 — tag cleanup must not block deletion
|
||||
pass
|
||||
return {"success": True}
|
||||
|
||||
|
||||
@router.post("/admin/{task_id}/trigger")
|
||||
async def admin_trigger_scheduled_task(task_id: str, request: Request) -> dict:
|
||||
"""Trigger an immediate run of any task regardless of owner. Admin-only."""
|
||||
await _require_admin(request)
|
||||
service = get_scheduled_task_service()
|
||||
task = await service.admin_trigger_task(task_id)
|
||||
if task is None:
|
||||
raise HTTPException(status_code=404, detail=f"Task {task_id} not found")
|
||||
return {"success": True, "task": task}
|
||||
@@ -45,6 +45,24 @@ def _is_admin_user(request: Request) -> bool:
|
||||
return getattr(user, "system_role", None) == "admin"
|
||||
|
||||
|
||||
def _can_view_skill_source(
|
||||
category: SkillCategory,
|
||||
owner_user_id: str | None,
|
||||
user_id: str,
|
||||
*,
|
||||
is_admin: bool,
|
||||
) -> bool:
|
||||
"""Whether the raw SKILL.md source is visible to a user.
|
||||
|
||||
Admins may view any skill's source; otherwise only the publisher (the
|
||||
owner of a custom skill) qualifies. Built-in / public skills have no human
|
||||
owner, so for non-admins they are never source-visible.
|
||||
"""
|
||||
if is_admin:
|
||||
return True
|
||||
return category == SkillCategory.CUSTOM and owner_user_id is not None and owner_user_id == user_id
|
||||
|
||||
|
||||
async def _get_owned_skill_or_raise(store: SkillStore, name: str, user_id: str) -> dict[str, Any]:
|
||||
owned = await store.get_owned(name, user_id)
|
||||
if owned is not None:
|
||||
@@ -870,15 +888,27 @@ class SkillContentResponse(BaseModel):
|
||||
"/skills/{skill_name}/content",
|
||||
response_model=SkillContentResponse,
|
||||
summary="Get Skill Markdown Content",
|
||||
description="Retrieve the raw SKILL.md content of a specific skill (public or custom).",
|
||||
description="Retrieve the raw SKILL.md content of a skill. Only an admin or the skill's publisher (owner of a custom skill) may read it; other users see only the description and detail.",
|
||||
)
|
||||
async def get_skill_content(skill_name: str, config: AppConfig = Depends(get_config)) -> SkillContentResponse:
|
||||
async def get_skill_content(
|
||||
skill_name: str,
|
||||
request: Request,
|
||||
config: AppConfig = Depends(get_config),
|
||||
skill_store: SkillStore = Depends(get_skill_store),
|
||||
) -> SkillContentResponse:
|
||||
try:
|
||||
skill_name = skill_name.replace("\r\n", "").replace("\n", "")
|
||||
skills = get_or_new_skill_storage(app_config=config).load_skills(enabled_only=False)
|
||||
skill = next((s for s in skills if s.name == skill_name), None)
|
||||
if skill is None:
|
||||
raise HTTPException(status_code=404, detail=f"Skill '{skill_name}' not found")
|
||||
# The raw SKILL.md is implementation detail — only an admin or the
|
||||
# publisher (owner of a custom skill) may view it. Everyone else is
|
||||
# limited to the description + detail surfaced by the list/detail APIs.
|
||||
record = await skill_store.get_any(skill_name)
|
||||
owner_user_id = record.get("owner_user_id") if record else None
|
||||
if not _can_view_skill_source(skill.category, owner_user_id, _current_user_id(request), is_admin=_is_admin_user(request)):
|
||||
raise HTTPException(status_code=403, detail="Only the skill publisher or an admin can view the SKILL.md source")
|
||||
content = skill.skill_file.read_text(encoding="utf-8")
|
||||
return SkillContentResponse(name=skill.name, category=skill.category, content=content)
|
||||
except HTTPException:
|
||||
|
||||
@@ -0,0 +1,340 @@
|
||||
"""Conversation sharing API.
|
||||
|
||||
A user creates a share code for *one* of their conversations; redeeming the
|
||||
code copies that conversation into the redeemer's account as an independent
|
||||
copy they fully own and can keep chatting in. See ``app/gateway/thread_copy.py``
|
||||
for the checkpoint duplication.
|
||||
"""
|
||||
|
||||
from __future__ import annotations
|
||||
|
||||
import logging
|
||||
import mimetypes
|
||||
import shutil
|
||||
import uuid
|
||||
from pathlib import Path
|
||||
|
||||
from fastapi import APIRouter, Depends, HTTPException, Request
|
||||
from fastapi.responses import FileResponse
|
||||
from pydantic import BaseModel, Field
|
||||
|
||||
from app.gateway.deps import get_checkpointer, get_thread_share_store, get_thread_store
|
||||
from app.gateway.thread_copy import copy_thread_state
|
||||
from deerflow.config.paths import get_paths
|
||||
from deerflow.persistence.thread_meta.base import ThreadMetaStore
|
||||
from deerflow.persistence.thread_shares.base import ThreadShareStore
|
||||
from deerflow.runtime import serialize_channel_values
|
||||
from deerflow.runtime.user_context import get_effective_user_id
|
||||
|
||||
logger = logging.getLogger(__name__)
|
||||
|
||||
router = APIRouter(prefix="/api/thread-shares", tags=["thread-shares"])
|
||||
|
||||
# Public, unauthenticated router. Its prefix is whitelisted in
|
||||
# ``auth_middleware._PUBLIC_PATH_PREFIXES`` — only mount read-only endpoints
|
||||
# that are intentionally world-readable here.
|
||||
public_router = APIRouter(prefix="/api/public/shares", tags=["thread-shares-public"])
|
||||
|
||||
_UNTITLED = "未命名对话"
|
||||
|
||||
# Valid share modes. "import" copies the conversation into the recipient's
|
||||
# account; "view" is a public read-only static page anyone can open.
|
||||
_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()
|
||||
|
||||
|
||||
# ---------------------------------------------------------------------------
|
||||
# Request / response models
|
||||
# ---------------------------------------------------------------------------
|
||||
|
||||
|
||||
class CreateShareRequest(BaseModel):
|
||||
thread_id: str = Field(..., description="The conversation to share")
|
||||
mode: str = Field(
|
||||
default="import",
|
||||
description='"import" — recipient copies the conversation; "view" — public read-only 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")
|
||||
thread_id: str = Field(..., description="The shared conversation")
|
||||
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 PublicShareSnapshotResponse(BaseModel):
|
||||
"""Read-only conversation snapshot served to anonymous viewers."""
|
||||
|
||||
share_code: str
|
||||
title: str = Field(..., description="Conversation title")
|
||||
mode: str = Field(default="view")
|
||||
messages: list[dict] = Field(default_factory=list, description="Serialized conversation messages")
|
||||
artifacts: list[str] = Field(default_factory=list, description="Artifact virtual paths produced in the conversation")
|
||||
created_at: str | None = Field(default=None, description="When the share was created (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 conversation")
|
||||
title: str = Field(..., description="Title of the shared conversation")
|
||||
|
||||
|
||||
class ImportResultResponse(BaseModel):
|
||||
imported: int = Field(..., description="1 when the conversation was copied, else 0")
|
||||
skipped: int = Field(..., description="1 when it was already imported, else 0")
|
||||
|
||||
|
||||
# ---------------------------------------------------------------------------
|
||||
# Owner side — create / list / revoke
|
||||
# ---------------------------------------------------------------------------
|
||||
|
||||
|
||||
@router.post("", response_model=ShareResponse, summary="Create a share code for one conversation")
|
||||
async def create_share(
|
||||
body: CreateShareRequest,
|
||||
request: Request,
|
||||
share_store: ThreadShareStore = Depends(get_thread_share_store),
|
||||
thread_store: ThreadMetaStore = Depends(get_thread_store),
|
||||
) -> ShareResponse:
|
||||
me = _current_user_id(request)
|
||||
mode = body.mode if body.mode in _SHARE_MODES else "import"
|
||||
# Only the conversation's owner may share it.
|
||||
meta = await thread_store.get(body.thread_id, user_id=me)
|
||||
if meta is None:
|
||||
raise HTTPException(status_code=404, detail="Conversation not found")
|
||||
# Reuse an existing active code (of the same mode) so re-sharing is idempotent.
|
||||
existing = await share_store.get_active_for_thread(me, body.thread_id, mode=mode)
|
||||
if existing is not None:
|
||||
return ShareResponse(**existing)
|
||||
record = await share_store.create(me, body.thread_id, mode=mode)
|
||||
return ShareResponse(**record)
|
||||
|
||||
|
||||
@router.get("", response_model=SharesListResponse, summary="List my conversation share codes")
|
||||
async def list_shares(
|
||||
request: Request,
|
||||
share_store: ThreadShareStore = Depends(get_thread_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 conversation share code")
|
||||
async def revoke_share(
|
||||
share_code: str,
|
||||
request: Request,
|
||||
share_store: ThreadShareStore = Depends(get_thread_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: ThreadShareStore) -> 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 conversation")
|
||||
async def preview_share(
|
||||
share_code: str,
|
||||
share_store: ThreadShareStore = Depends(get_thread_share_store),
|
||||
thread_store: ThreadMetaStore = Depends(get_thread_store),
|
||||
) -> SharePreviewResponse:
|
||||
share = await _resolve_active_share(share_code, share_store)
|
||||
owner = share["owner_user_id"]
|
||||
meta = await thread_store.get(share["thread_id"], user_id=owner)
|
||||
if meta is None:
|
||||
raise HTTPException(status_code=404, detail="The shared conversation no longer exists")
|
||||
return SharePreviewResponse(
|
||||
share_code=share_code,
|
||||
shared_by=owner,
|
||||
title=meta.get("display_name") or _UNTITLED,
|
||||
)
|
||||
|
||||
|
||||
def _copy_thread_files(origin_thread_id: str, owner_user_id: str, new_thread_id: str, recipient_user_id: str) -> None:
|
||||
"""Copy a thread's user-data directory (uploads + outputs/artifacts)."""
|
||||
paths = get_paths()
|
||||
src_data = paths.thread_dir(origin_thread_id, user_id=owner_user_id) / "user-data"
|
||||
if not src_data.is_dir():
|
||||
return
|
||||
dst_data = paths.thread_dir(new_thread_id, user_id=recipient_user_id) / "user-data"
|
||||
shutil.copytree(src_data, dst_data, dirs_exist_ok=True)
|
||||
|
||||
|
||||
@router.post("/{share_code}/import", response_model=ImportResultResponse, summary="Import a shared conversation")
|
||||
async def import_share(
|
||||
share_code: str,
|
||||
request: Request,
|
||||
share_store: ThreadShareStore = Depends(get_thread_share_store),
|
||||
thread_store: ThreadMetaStore = Depends(get_thread_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["thread_id"]
|
||||
recipient = _current_user_id(request)
|
||||
if owner == recipient:
|
||||
raise HTTPException(status_code=400, detail="You cannot import your own share code")
|
||||
|
||||
src = await thread_store.get(origin_id, user_id=owner)
|
||||
if src is None:
|
||||
raise HTTPException(status_code=404, detail="The shared conversation no longer exists")
|
||||
|
||||
# Dedup: skip if this user already imported this conversation.
|
||||
mine = await thread_store.search(user_id=recipient, limit=2000)
|
||||
already = {(t.get("metadata") or {}).get("shared_origin") for t in mine}
|
||||
if origin_id in already:
|
||||
return ImportResultResponse(imported=0, skipped=1)
|
||||
|
||||
new_id = str(uuid.uuid4())
|
||||
checkpointer = get_checkpointer(request)
|
||||
await copy_thread_state(checkpointer, origin_id, new_id)
|
||||
|
||||
metadata = dict(src.get("metadata") or {})
|
||||
metadata.update({"shared_from_code": share_code, "shared_origin": origin_id, "shared_by": owner})
|
||||
await thread_store.create(
|
||||
new_id,
|
||||
assistant_id=src.get("assistant_id"),
|
||||
user_id=recipient,
|
||||
display_name=src.get("display_name"),
|
||||
metadata=metadata,
|
||||
)
|
||||
try:
|
||||
_copy_thread_files(origin_id, owner, new_id, recipient)
|
||||
except Exception as exc: # noqa: BLE001 — file copy failure must not lose the conversation
|
||||
logger.warning("Failed to copy files for thread %s -> %s: %s", origin_id, new_id, exc)
|
||||
|
||||
logger.info("Share %s imported by %s as thread %s", share_code, recipient, new_id)
|
||||
return ImportResultResponse(imported=1, skipped=0)
|
||||
|
||||
|
||||
# ---------------------------------------------------------------------------
|
||||
# Public read-only view — no authentication required
|
||||
# ---------------------------------------------------------------------------
|
||||
|
||||
|
||||
async def _load_thread_snapshot(checkpointer, thread_id: str) -> tuple[list[dict], list[str]]:
|
||||
"""Return (messages, artifacts) from a thread's latest checkpoint.
|
||||
|
||||
Reads straight from the checkpointer — the same source the live chat
|
||||
streams from — so the static snapshot matches the conversation exactly.
|
||||
"""
|
||||
config = {"configurable": {"thread_id": thread_id, "checkpoint_ns": ""}}
|
||||
checkpoint_tuple = await checkpointer.aget_tuple(config)
|
||||
if checkpoint_tuple is None:
|
||||
return [], []
|
||||
checkpoint = getattr(checkpoint_tuple, "checkpoint", {}) or {}
|
||||
values = serialize_channel_values(checkpoint.get("channel_values", {}) or {})
|
||||
messages = values.get("messages")
|
||||
artifacts = values.get("artifacts")
|
||||
return (
|
||||
[m for m in messages if isinstance(m, dict)] if isinstance(messages, list) else [],
|
||||
[a for a in artifacts if isinstance(a, str)] if isinstance(artifacts, list) else [],
|
||||
)
|
||||
|
||||
|
||||
@public_router.get(
|
||||
"/{share_code}",
|
||||
response_model=PublicShareSnapshotResponse,
|
||||
summary="Public read-only snapshot of a view-shared conversation",
|
||||
)
|
||||
async def get_public_share_snapshot(
|
||||
share_code: str,
|
||||
share_store: ThreadShareStore = Depends(get_thread_share_store),
|
||||
thread_store: ThreadMetaStore = Depends(get_thread_store),
|
||||
checkpointer=Depends(get_checkpointer),
|
||||
) -> PublicShareSnapshotResponse:
|
||||
"""Serve a frozen, read-only conversation. 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")
|
||||
|
||||
meta = await thread_store.get(share["thread_id"], user_id=share["owner_user_id"])
|
||||
if meta is None:
|
||||
raise HTTPException(status_code=404, detail="The shared conversation no longer exists")
|
||||
|
||||
messages, artifacts = await _load_thread_snapshot(checkpointer, share["thread_id"])
|
||||
return PublicShareSnapshotResponse(
|
||||
share_code=share_code,
|
||||
title=meta.get("display_name") or _UNTITLED,
|
||||
mode="view",
|
||||
messages=messages,
|
||||
artifacts=artifacts,
|
||||
created_at=share.get("created_at"),
|
||||
)
|
||||
|
||||
|
||||
@public_router.get(
|
||||
"/{share_code}/files/{path:path}",
|
||||
summary="Public image attachment from a view-shared conversation",
|
||||
)
|
||||
async def get_public_share_file(
|
||||
share_code: str,
|
||||
path: str,
|
||||
share_store: ThreadShareStore = Depends(get_thread_share_store),
|
||||
) -> FileResponse:
|
||||
"""Serve an image referenced by a view-shared conversation.
|
||||
|
||||
Restricted to images only — the public share page renders inline images,
|
||||
but the endpoint must not become a way to read arbitrary thread files.
|
||||
Non-image paths return 404 just like a missing file.
|
||||
"""
|
||||
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")
|
||||
|
||||
# Resolve the virtual path inside the *owner's* thread directory.
|
||||
try:
|
||||
actual = get_paths().resolve_virtual_path(share["thread_id"], path, user_id=share["owner_user_id"])
|
||||
except ValueError as exc:
|
||||
status = 403 if "traversal" in str(exc) else 400
|
||||
raise HTTPException(status_code=status, detail=str(exc))
|
||||
|
||||
actual_path = Path(actual)
|
||||
if not actual_path.exists() or not actual_path.is_file():
|
||||
raise HTTPException(status_code=404, detail="File not found")
|
||||
|
||||
mime_type, _ = mimetypes.guess_type(actual_path.name)
|
||||
if not mime_type or not mime_type.startswith("image/"):
|
||||
# Only images are public; everything else is treated as not found.
|
||||
raise HTTPException(status_code=404, detail="File not found")
|
||||
|
||||
# SVG can carry scripts — serve it as a download so it can never execute
|
||||
# as a top-level document in the app origin. Raster images render inline.
|
||||
is_svg = mime_type == "image/svg+xml"
|
||||
return FileResponse(
|
||||
actual_path,
|
||||
media_type=mime_type,
|
||||
content_disposition_type="attachment" if is_svg else "inline",
|
||||
headers={"Cache-Control": "public, max-age=300"},
|
||||
)
|
||||
@@ -0,0 +1,67 @@
|
||||
"""Copy a conversation's LangGraph checkpoint state from one thread to another.
|
||||
|
||||
Used by the conversation-sharing feature: redeeming a share link duplicates the
|
||||
sharer's threads into the redeemer's account. Each duplicated thread needs its
|
||||
full checkpoint history copied under a fresh ``thread_id``.
|
||||
|
||||
The copy goes through the checkpointer's public API (``alist`` / ``aput`` /
|
||||
``aput_writes``) rather than raw SQL, so it is independent of the checkpoint
|
||||
table schema and works for every backend (SQLite, Postgres, in-memory).
|
||||
"""
|
||||
|
||||
from __future__ import annotations
|
||||
|
||||
import logging
|
||||
|
||||
logger = logging.getLogger(__name__)
|
||||
|
||||
|
||||
async def copy_thread_state(checkpointer, src_thread_id: str, dst_thread_id: str) -> bool:
|
||||
"""Duplicate every checkpoint of ``src_thread_id`` under ``dst_thread_id``.
|
||||
|
||||
Returns True when at least one checkpoint was copied, False when the source
|
||||
thread has no checkpoints (e.g. a thread that was never run).
|
||||
|
||||
The destination keeps the source's checkpoint ids — they only need to be
|
||||
unique within a ``thread_id``, and reusing them preserves the parent chain.
|
||||
"""
|
||||
src_config = {"configurable": {"thread_id": src_thread_id}}
|
||||
# alist yields newest-first; reverse so parents are written before children.
|
||||
tuples = [t async for t in checkpointer.alist(src_config)]
|
||||
if not tuples:
|
||||
return False
|
||||
|
||||
copied = 0
|
||||
for tup in reversed(tuples):
|
||||
configurable = (tup.config or {}).get("configurable", {})
|
||||
checkpoint_ns = configurable.get("checkpoint_ns", "") or ""
|
||||
parent_id = ((tup.parent_config or {}).get("configurable", {}) or {}).get("checkpoint_id")
|
||||
|
||||
put_config: dict = {"configurable": {"thread_id": dst_thread_id, "checkpoint_ns": checkpoint_ns}}
|
||||
if parent_id:
|
||||
# aput reads the parent checkpoint id from the incoming config.
|
||||
put_config["configurable"]["checkpoint_id"] = parent_id
|
||||
|
||||
new_versions = tup.checkpoint.get("channel_versions", {}) or {}
|
||||
await checkpointer.aput(put_config, tup.checkpoint, tup.metadata or {}, new_versions)
|
||||
|
||||
# pending_writes is a list of (task_id, channel, value); aput_writes
|
||||
# wants them grouped per task as (channel, value) pairs.
|
||||
if tup.pending_writes:
|
||||
by_task: dict[str, list] = {}
|
||||
for task_id, channel, value in tup.pending_writes:
|
||||
by_task.setdefault(task_id, []).append((channel, value))
|
||||
checkpoint_id = tup.checkpoint.get("id")
|
||||
for task_id, writes in by_task.items():
|
||||
writes_config = {
|
||||
"configurable": {
|
||||
"thread_id": dst_thread_id,
|
||||
"checkpoint_ns": checkpoint_ns,
|
||||
"checkpoint_id": checkpoint_id,
|
||||
}
|
||||
}
|
||||
await checkpointer.aput_writes(writes_config, writes, task_id)
|
||||
copied += 1
|
||||
|
||||
logger.info("Copied %d checkpoint(s) from thread %s to %s", copied, src_thread_id, dst_thread_id)
|
||||
return copied > 0
|
||||
Reference in new issue
Block a user