246 lines
9.2 KiB
Python
246 lines
9.2 KiB
Python
"""Admin-only metadata migration for agent/skill folders copied in place."""
|
|
|
|
from __future__ import annotations
|
|
|
|
import asyncio
|
|
import logging
|
|
from pathlib import Path
|
|
|
|
from fastapi import APIRouter, Depends, HTTPException, Request
|
|
from pydantic import BaseModel, Field
|
|
|
|
from app.gateway.agent_skill_migration import (
|
|
MigrationApplyResult,
|
|
MigrationManifest,
|
|
MigrationPreflight,
|
|
apply_migration_manifest,
|
|
build_agent_migration_manifest,
|
|
build_skill_migration_manifest,
|
|
preflight_manifest,
|
|
prepare_manifest_for_apply,
|
|
)
|
|
from app.gateway.deps import (
|
|
get_agent_store,
|
|
get_local_provider,
|
|
get_optional_user_from_request,
|
|
get_skill_store,
|
|
get_tag_store,
|
|
)
|
|
from deerflow.agents.lead_agent.prompt import refresh_skills_system_prompt_cache_async
|
|
from deerflow.config.extensions_config import ExtensionsConfig
|
|
from deerflow.config.paths import get_paths
|
|
from deerflow.config.system_settings import load_system_settings
|
|
from deerflow.persistence.agents import AgentStore
|
|
from deerflow.persistence.skills import SkillStore
|
|
from deerflow.persistence.tags import TagStore
|
|
from deerflow.runtime.user_context import get_effective_user_id
|
|
from deerflow.sandbox.skill_view import refresh_skill_sandbox_view
|
|
from deerflow.skills.storage import get_or_new_skill_storage
|
|
from deerflow.skills.usage import all_entries as get_skill_usage_entries
|
|
|
|
logger = logging.getLogger(__name__)
|
|
|
|
router = APIRouter(prefix="/api/admin/agent-skill-migrations", tags=["agent-skill-migrations"])
|
|
|
|
|
|
class MigrationExportRequest(BaseModel):
|
|
agent_ids: list[str] = Field(min_length=1, max_length=1000)
|
|
|
|
|
|
class SkillMigrationExportRequest(BaseModel):
|
|
skill_names: list[str] = Field(min_length=1, max_length=5000)
|
|
|
|
|
|
class MigrationApplyRequest(BaseModel):
|
|
manifest: MigrationManifest
|
|
use_current_admin_for_unresolved_owners: bool = False
|
|
skip_invalid_skills: bool = False
|
|
|
|
|
|
class MigrationRootsResponse(BaseModel):
|
|
agents_root: str
|
|
skills_root: str
|
|
extensions_config_path: str | None
|
|
|
|
|
|
async def _require_admin(request: Request):
|
|
user = await get_optional_user_from_request(request)
|
|
if user is not None and getattr(user, "system_role", None) != "admin":
|
|
raise HTTPException(status_code=403, detail="智能体与技能迁移仅限管理员")
|
|
return user
|
|
|
|
|
|
def _require_migration_enabled() -> None:
|
|
if not load_system_settings().agent_skill_migration.enabled:
|
|
raise HTTPException(status_code=403, detail="智能体与技能迁移功能未开启")
|
|
|
|
|
|
async def _users() -> tuple[dict[str, str], dict[str, str]]:
|
|
"""Return ``(id -> email, normalized email -> id)`` without auth secrets."""
|
|
|
|
try:
|
|
users = await get_local_provider().list_users()
|
|
except Exception: # noqa: BLE001 - metadata migration degrades to manual owner fallback
|
|
logger.warning("Could not load users for migration owner mapping", exc_info=True)
|
|
return {}, {}
|
|
by_id = {str(user.id): str(user.email) for user in users}
|
|
by_email = {str(user.email).strip().casefold(): str(user.id) for user in users}
|
|
return by_id, by_email
|
|
|
|
|
|
def _roots() -> tuple[Path, Path]:
|
|
storage = get_or_new_skill_storage()
|
|
return get_paths().agents_dir.resolve(), Path(storage.get_skills_root_path()).resolve()
|
|
|
|
|
|
@router.get("/roots", response_model=MigrationRootsResponse)
|
|
async def migration_roots(request: Request) -> MigrationRootsResponse:
|
|
await _require_admin(request)
|
|
_require_migration_enabled()
|
|
agents_root, skills_root = _roots()
|
|
extensions_path = ExtensionsConfig.resolve_config_path()
|
|
return MigrationRootsResponse(
|
|
agents_root=str(agents_root),
|
|
skills_root=str(skills_root),
|
|
extensions_config_path=str(extensions_path.resolve()) if extensions_path else None,
|
|
)
|
|
|
|
|
|
@router.post("/export", response_model=MigrationManifest)
|
|
async def export_migration_manifest(
|
|
body: MigrationExportRequest,
|
|
request: Request,
|
|
agent_store: AgentStore = Depends(get_agent_store),
|
|
tag_store: TagStore = Depends(get_tag_store),
|
|
) -> MigrationManifest:
|
|
await _require_admin(request)
|
|
_require_migration_enabled()
|
|
agents_root, _ = _roots()
|
|
users_by_id, _ = await _users()
|
|
try:
|
|
return await build_agent_migration_manifest(
|
|
body.agent_ids,
|
|
agent_store=agent_store,
|
|
tag_store=tag_store,
|
|
agents_root=agents_root,
|
|
users_by_id=users_by_id,
|
|
)
|
|
except (FileNotFoundError, ValueError) as exc:
|
|
raise HTTPException(status_code=409, detail=str(exc)) from exc
|
|
|
|
|
|
@router.post("/export-skills", response_model=MigrationManifest)
|
|
async def export_skill_migration_manifest(
|
|
body: SkillMigrationExportRequest,
|
|
request: Request,
|
|
skill_store: SkillStore = Depends(get_skill_store),
|
|
tag_store: TagStore = Depends(get_tag_store),
|
|
) -> MigrationManifest:
|
|
await _require_admin(request)
|
|
_require_migration_enabled()
|
|
_, skills_root = _roots()
|
|
storage = get_or_new_skill_storage()
|
|
users_by_id, _ = await _users()
|
|
discovered_skills = await asyncio.to_thread(storage.load_skills, enabled_only=False)
|
|
try:
|
|
return await build_skill_migration_manifest(
|
|
body.skill_names,
|
|
skill_store=skill_store,
|
|
tag_store=tag_store,
|
|
skills_root=skills_root,
|
|
discovered_skills=discovered_skills,
|
|
users_by_id=users_by_id,
|
|
usage_entries=get_skill_usage_entries(),
|
|
)
|
|
except (FileNotFoundError, ValueError) as exc:
|
|
raise HTTPException(status_code=409, detail=str(exc)) from exc
|
|
|
|
|
|
@router.post("/preflight", response_model=MigrationPreflight)
|
|
async def preflight_migration_manifest(
|
|
manifest: MigrationManifest,
|
|
request: Request,
|
|
) -> MigrationPreflight:
|
|
await _require_admin(request)
|
|
_require_migration_enabled()
|
|
agents_root, skills_root = _roots()
|
|
_, users_by_email = await _users()
|
|
return await asyncio.to_thread(
|
|
preflight_manifest,
|
|
manifest,
|
|
agents_root=agents_root,
|
|
skills_root=skills_root,
|
|
users_by_email=users_by_email,
|
|
)
|
|
|
|
|
|
@router.post("/apply", response_model=MigrationApplyResult)
|
|
async def apply_migration(
|
|
body: MigrationApplyRequest,
|
|
request: Request,
|
|
agent_store: AgentStore = Depends(get_agent_store),
|
|
skill_store: SkillStore = Depends(get_skill_store),
|
|
tag_store: TagStore = Depends(get_tag_store),
|
|
) -> MigrationApplyResult:
|
|
user = await _require_admin(request)
|
|
_require_migration_enabled()
|
|
agents_root, skills_root = _roots()
|
|
_, users_by_email = await _users()
|
|
# Re-scan at apply time. The browser's earlier preflight is informative,
|
|
# never an authorization or integrity token.
|
|
preflight = await asyncio.to_thread(
|
|
preflight_manifest,
|
|
body.manifest,
|
|
agents_root=agents_root,
|
|
skills_root=skills_root,
|
|
users_by_email=users_by_email,
|
|
)
|
|
try:
|
|
effective_manifest, effective_preflight, _ = prepare_manifest_for_apply(
|
|
body.manifest,
|
|
preflight,
|
|
skip_invalid_skills=body.skip_invalid_skills,
|
|
)
|
|
except ValueError as exc:
|
|
raise HTTPException(status_code=409, detail=str(exc)) from exc
|
|
if body.manifest.skills and not effective_manifest.skills:
|
|
raise HTTPException(status_code=409, detail="所有技能均未通过预检,没有可导入的技能")
|
|
resource_failures = [item.model_dump(mode="json") for item in [*effective_preflight.agents, *effective_preflight.skills, *effective_preflight.support_directories] if item.status != "matched"]
|
|
unresolved = [item for item in effective_preflight.owner_mappings if item.status == "unresolved"]
|
|
if resource_failures or (unresolved and not body.use_current_admin_for_unresolved_owners):
|
|
raise HTTPException(
|
|
status_code=409,
|
|
detail={
|
|
"message": "迁移预检未通过,未写入任何元数据",
|
|
"preflight": effective_preflight.model_dump(mode="json"),
|
|
},
|
|
)
|
|
|
|
extensions_path = ExtensionsConfig.resolve_config_path() if effective_manifest.skills else None
|
|
if effective_manifest.skills and extensions_path is None:
|
|
raise HTTPException(status_code=503, detail="目标运行环境未找到 extensions_config.json")
|
|
fallback_owner_user_id = None
|
|
if unresolved and body.use_current_admin_for_unresolved_owners:
|
|
fallback_owner_user_id = str(user.id) if user is not None else get_effective_user_id()
|
|
|
|
try:
|
|
result = await apply_migration_manifest(
|
|
body.manifest,
|
|
preflight=preflight,
|
|
agent_store=agent_store,
|
|
skill_store=skill_store,
|
|
tag_store=tag_store,
|
|
agents_root=agents_root,
|
|
users_by_email=users_by_email,
|
|
fallback_owner_user_id=fallback_owner_user_id,
|
|
extensions_config_path=extensions_path,
|
|
skip_invalid_skills=body.skip_invalid_skills,
|
|
)
|
|
if result.skills_applied:
|
|
await refresh_skills_system_prompt_cache_async()
|
|
storage = get_or_new_skill_storage()
|
|
await asyncio.to_thread(refresh_skill_sandbox_view, storage=storage, force=True)
|
|
return result
|
|
except ValueError as exc:
|
|
raise HTTPException(status_code=409, detail=str(exc)) from exc
|