Phase 2.3: Agent Management Module

Backend:
- agents_admin.py: 10 REST API endpoints for AI Agent CRUD
  - GET/POST/PUT/DELETE /admin/agents/
  - Stats overview, reviews, available skills/models
  - Agent = MarketApp with type='agent'

Frontend:
- Agents.tsx: Full admin page (780 lines)
  - Stats dashboard, filterable table, create/edit modal
  - Config: system prompt, temperature, model, linked skills
- api/index.ts: 10 new Agent API methods
- App.tsx: /admin/agents route
- AdminLayout.tsx: Agent management nav item

backend/python/app/api/admin/agents_admin.py

@@ -0,0 +1,553 @@
+"""
+Agent 管理 API（管理员）
+Phase 2.3: AI PaaS Agent Management
+"""
+from fastapi import APIRouter, Depends, HTTPException, Query, Body
+from sqlalchemy.orm import Session
+from sqlalchemy import or_, func
+from pydantic import BaseModel
+from typing import Optional, List
+from ...database import get_db
+from ...models import MarketApp, EvolutionSkill, AIModel, User
+from ...auth import get_current_admin
+from ...middleware.log_service import LogService
+import uuid
+from datetime import datetime
+
+
+router = APIRouter()
+
+
+# ============================================================
+# Pydantic 模型
+# ============================================================
+
+class AgentConfig(BaseModel):
+    system_prompt: Optional[str] = None
+    temperature: Optional[float] = None
+    max_tokens: Optional[int] = None
+    model_id: Optional[str] = None
+    skills: Optional[List[str]] = None  # skill IDs
+    tools: Optional[List[str]] = None  # MCP server IDs
+    memory_enabled: Optional[bool] = False
+    reasoning_enabled: Optional[bool] = False
+
+
+class AgentCreate(BaseModel):
+    name: str
+    description: Optional[str] = None
+    icon: Optional[str] = None
+    price: float = 0.0
+    is_member_free: bool = False
+    config: Optional[AgentConfig] = None
+
+
+class AgentUpdate(BaseModel):
+    name: Optional[str] = None
+    description: Optional[str] = None
+    icon: Optional[str] = None
+    price: Optional[float] = None
+    is_member_free: Optional[bool] = None
+    config: Optional[AgentConfig] = None
+    status: Optional[str] = None  # active/inactive
+    tutorial: Optional[str] = None
+
+
+# ============================================================
+# 辅助函数
+# ============================================================
+
+def agent_to_dict(a: MarketApp) -> dict:
+    """将 MarketApp (agent) 转换为字典"""
+    # 解析 skill_content 中的配置
+    import json
+    config = {}
+    if a.skill_content:
+        try:
+            config = json.loads(a.skill_content)
+        except Exception:
+            pass
+
+    return {
+        "id": a.id,
+        "name": a.name,
+        "type": a.type,
+        "source": a.source,
+        "publisher_id": a.publisher_id,
+        "publisher_name": a.publisher_name,
+        "description": a.description,
+        "icon": a.icon,
+        "tutorial": a.tutorial,
+        "price": float(a.price) if a.price else 0,
+        "is_member_free": a.is_member_free,
+        "join_promotion": a.join_promotion,
+        "status": a.status,
+        "rating_avg": float(a.rating_avg) if a.rating_avg else 0,
+        "review_count": a.review_count,
+        "install_count": a.install_count,
+        "agent_endpoint": a.agent_endpoint,
+        "skill_content": a.skill_content,
+        "config": config,
+        "created_at": a.created_at.isoformat() if a.created_at else None,
+        "updated_at": a.updated_at.isoformat() if a.updated_at else None,
+    }
+
+
+# ============================================================
+# 端点
+# ============================================================
+
+@router.get("/", summary="获取 Agent 列表")
+async def list_agents(
+    keyword: str = Query(None, description="搜索关键词"),
+    status: str = Query(None, description="状态: pending/published/removed"),
+    source: str = Query(None, description="来源: official/user"),
+    page: int = Query(1, ge=1),
+    page_size: int = Query(15, ge=1, le=100),
+    admin_user=Depends(get_current_admin),
+    db: Session = Depends(get_db),
+):
+    """获取所有 Agent 列表（分页、筛选）"""
+    query = db.query(MarketApp).filter(MarketApp.type == "agent")
+
+    if keyword:
+        query = query.filter(
+            or_(
+                MarketApp.name.ilike(f"%{keyword}%"),
+                MarketApp.description.ilike(f"%{keyword}%"),
+                MarketApp.publisher_name.ilike(f"%{keyword}%"),
+            )
+        )
+    if status:
+        query = query.filter(MarketApp.status == status)
+    if source:
+        query = query.filter(MarketApp.source == source)
+
+    total = query.count()
+    agents = query.order_by(MarketApp.created_at.desc()).offset(
+        (page - 1) * page_size
+    ).limit(page_size).all()
+
+    return {
+        "code": 0,
+        "data": {
+            "total": total,
+            "page": page,
+            "page_size": page_size,
+            "items": [agent_to_dict(a) for a in agents],
+        }
+    }
+
+
+@router.get("/stats/overview", summary="Agent 统计概览")
+async def get_agent_stats(
+    admin_user=Depends(get_current_admin),
+    db: Session = Depends(get_db),
+):
+    """获取 Agent 统计数据"""
+    base = db.query(MarketApp).filter(MarketApp.type == "agent")
+
+    total = base.count()
+    published = base.filter(MarketApp.status == "published").count()
+    pending = base.filter(MarketApp.status == "pending").count()
+    official = base.filter(MarketApp.source == "official").count()
+    user_created = base.filter(MarketApp.source == "user").count()
+
+    # 安装量统计
+    install_base = db.query(func.sum(MarketApp.install_count)).filter(
+        MarketApp.type == "agent"
+    ).scalar() or 0
+
+    # 按类型分布
+    by_source = {
+        "official": official,
+        "user": user_created,
+    }
+
+    # 评分统计
+    avg_rating = db.query(func.avg(MarketApp.rating_avg)).filter(
+        MarketApp.type == "agent",
+        MarketApp.rating_avg > 0,
+    ).scalar() or 0
+
+    return {
+        "code": 0,
+        "data": {
+            "total_agents": total,
+            "published_agents": published,
+            "pending_agents": pending,
+            "official_agents": official,
+            "user_agents": user_created,
+            "total_installs": int(install_base),
+            "average_rating": round(float(avg_rating), 2),
+            "by_source": by_source,
+        }
+    }
+
+
+@router.get("/{agent_id}", summary="获取 Agent 详情")
+async def get_agent(
+    agent_id: str,
+    admin_user=Depends(get_current_admin),
+    db: Session = Depends(get_db),
+):
+    """获取单个 Agent 的详细信息"""
+    agent = db.query(MarketApp).filter(
+        MarketApp.id == agent_id,
+        MarketApp.type == "agent",
+    ).first()
+
+    if not agent:
+        raise HTTPException(status_code=404, detail="Agent 不存在")
+
+    result = agent_to_dict(agent)
+
+    # 获取关联的 Skills
+    import json
+    config = json.loads(agent.skill_content or "{}")
+    skill_ids = config.get("skills", [])
+    if skill_ids:
+        skills = db.query(EvolutionSkill).filter(
+            EvolutionSkill.id.in_(skill_ids)
+        ).all()
+        result["linked_skills"] = [
+            {
+                "id": s.id,
+                "skill_name": s.skill_name,
+                "state": s.state,
+                "version": s.version,
+            }
+            for s in skills
+        ]
+    else:
+        result["linked_skills"] = []
+
+    # 获取可用模型列表
+    models = db.query(AIModel).filter(AIModel.is_enabled == True).all()
+    result["available_models"] = [
+        {"id": m.id, "name": m.name, "provider": m.provider} for m in models
+    ]
+
+    return {"code": 0, "data": result}
+
+
+@router.post("/", summary="创建 Agent")
+async def create_agent(
+    req: AgentCreate,
+    admin_user=Depends(get_current_admin),
+    db: Session = Depends(get_db),
+):
+    """创建新的 Agent"""
+    import json
+
+    # 检查名称是否已存在
+    existing = db.query(MarketApp).filter(
+        MarketApp.name == req.name,
+        MarketApp.type == "agent",
+    ).first()
+    if existing:
+        raise HTTPException(status_code=400, detail="Agent 名称已存在")
+
+    # 构建 skill_content
+    config = {}
+    if req.config:
+        cfg = req.config
+        config = {
+            "system_prompt": cfg.system_prompt or "",
+            "temperature": cfg.temperature or 0.7,
+            "max_tokens": cfg.max_tokens or 2048,
+            "model_id": cfg.model_id,
+            "skills": cfg.skills or [],
+            "tools": cfg.tools or [],
+            "memory_enabled": cfg.memory_enabled or False,
+            "reasoning_enabled": cfg.reasoning_enabled or False,
+        }
+
+    agent = MarketApp(
+        id=str(uuid.uuid4()),
+        name=req.name,
+        type="agent",
+        source="official",
+        publisher_id=admin_user.id,
+        publisher_name=admin_user.username,
+        description=req.description or "",
+        icon=req.icon or "",
+        price=req.price,
+        is_member_free=req.is_member_free,
+        skill_content=json.dumps(config, ensure_ascii=False),
+        status="published",
+        created_at=datetime.now(),
+        updated_at=datetime.now(),
+    )
+    db.add(agent)
+    db.commit()
+    db.refresh(agent)
+
+    LogService.log_audit(
+        admin_id=admin_user.id,
+        admin_name=admin_user.username,
+        action="create_agent",
+        target_type="agent",
+        target_id=agent.id,
+        detail=f"创建 Agent: {agent.name}",
+    )
+
+    return {"code": 0, "message": "Agent 创建成功", "data": agent_to_dict(agent)}
+
+
+@router.put("/{agent_id}", summary="更新 Agent")
+async def update_agent(
+    agent_id: str,
+    req: AgentUpdate,
+    admin_user=Depends(get_current_admin),
+    db: Session = Depends(get_db),
+):
+    """更新 Agent 配置"""
+    import json
+
+    agent = db.query(MarketApp).filter(
+        MarketApp.id == agent_id,
+        MarketApp.type == "agent",
+    ).first()
+
+    if not agent:
+        raise HTTPException(status_code=404, detail="Agent 不存在")
+
+    # 更新基本字段
+    if req.name is not None:
+        # 检查新名称是否重复
+        dup = db.query(MarketApp).filter(
+            MarketApp.name == req.name,
+            MarketApp.type == "agent",
+            MarketApp.id != agent_id,
+        ).first()
+        if dup:
+            raise HTTPException(status_code=400, detail="Agent 名称已存在")
+        agent.name = req.name
+
+    if req.description is not None:
+        agent.description = req.description
+    if req.icon is not None:
+        agent.icon = req.icon
+    if req.price is not None:
+        agent.price = req.price
+    if req.is_member_free is not None:
+        agent.is_member_free = req.is_member_free
+    if req.status is not None:
+        agent.status = req.status
+    if req.tutorial is not None:
+        agent.tutorial = req.tutorial
+
+    # 更新配置
+    if req.config is not None:
+        cfg = req.config
+        # 合并现有配置
+        existing_config = {}
+        if agent.skill_content:
+            try:
+                existing_config = json.loads(agent.skill_content)
+            except Exception:
+                pass
+
+        new_config = {
+            "system_prompt": cfg.system_prompt if cfg.system_prompt is not None else existing_config.get("system_prompt", ""),
+            "temperature": cfg.temperature if cfg.temperature is not None else existing_config.get("temperature", 0.7),
+            "max_tokens": cfg.max_tokens if cfg.max_tokens is not None else existing_config.get("max_tokens", 2048),
+            "model_id": cfg.model_id if cfg.model_id is not None else existing_config.get("model_id"),
+            "skills": cfg.skills if cfg.skills is not None else existing_config.get("skills", []),
+            "tools": cfg.tools if cfg.tools is not None else existing_config.get("tools", []),
+            "memory_enabled": cfg.memory_enabled if cfg.memory_enabled is not None else existing_config.get("memory_enabled", False),
+            "reasoning_enabled": cfg.reasoning_enabled if cfg.reasoning_enabled is not None else existing_config.get("reasoning_enabled", False),
+        }
+        agent.skill_content = json.dumps(new_config, ensure_ascii=False)
+
+    agent.updated_at = datetime.now()
+    db.commit()
+    db.refresh(agent)
+
+    LogService.log_audit(
+        admin_id=admin_user.id,
+        admin_name=admin_user.username,
+        action="update_agent",
+        target_type="agent",
+        target_id=agent_id,
+        detail=f"更新 Agent: {agent.name}",
+    )
+
+    return {"code": 0, "message": "Agent 已更新", "data": agent_to_dict(agent)}
+
+
+@router.delete("/{agent_id}", summary="删除 Agent")
+async def delete_agent(
+    agent_id: str,
+    admin_user=Depends(get_current_admin),
+    db: Session = Depends(get_db),
+):
+    """删除 Agent"""
+    agent = db.query(MarketApp).filter(
+        MarketApp.id == agent_id,
+        MarketApp.type == "agent",
+    ).first()
+
+    if not agent:
+        raise HTTPException(status_code=404, detail="Agent 不存在")
+
+    agent_name = agent.name
+    db.delete(agent)
+    db.commit()
+
+    LogService.log_audit(
+        admin_id=admin_user.id,
+        admin_name=admin_user.username,
+        action="delete_agent",
+        target_type="agent",
+        target_id=agent_id,
+        detail=f"删除 Agent: {agent_name}",
+    )
+
+    return {"code": 0, "message": "Agent 已删除"}
+
+
+@router.put("/{agent_id}/toggle", summary="启用/禁用 Agent")
+async def toggle_agent(
+    agent_id: str,
+    is_active: bool = Query(..., description="是否启用"),
+    admin_user=Depends(get_current_admin),
+    db: Session = Depends(get_db),
+):
+    """启用或禁用 Agent"""
+    agent = db.query(MarketApp).filter(
+        MarketApp.id == agent_id,
+        MarketApp.type == "agent",
+    ).first()
+
+    if not agent:
+        raise HTTPException(status_code=404, detail="Agent 不存在")
+
+    agent.status = "published" if is_active else "pending"
+    agent.updated_at = datetime.now()
+    db.commit()
+
+    LogService.log_audit(
+        admin_id=admin_user.id,
+        admin_name=admin_user.username,
+        action="toggle_agent",
+        target_type="agent",
+        target_id=agent_id,
+        detail=f"{'启用' if is_active else '禁用'} Agent: {agent.name}",
+    )
+
+    return {
+        "code": 0,
+        "message": f"Agent 已{'启用' if is_active else '禁用'}",
+        "data": agent_to_dict(agent),
+    }
+
+
+@router.get("/{agent_id}/reviews", summary="获取 Agent 评价")
+async def get_agent_reviews(
+    agent_id: str,
+    admin_user=Depends(get_current_admin),
+    db: Session = Depends(get_db),
+):
+    """获取 Agent 的用户评价"""
+    from ...models import AppReview, User
+
+    agent = db.query(MarketApp).filter(
+        MarketApp.id == agent_id,
+        MarketApp.type == "agent",
+    ).first()
+    if not agent:
+        raise HTTPException(status_code=404, detail="Agent 不存在")
+
+    reviews = db.query(AppReview).filter(
+        AppReview.app_id == agent_id
+    ).order_by(AppReview.created_at.desc()).limit(50).all()
+
+    return {
+        "code": 0,
+        "data": [
+            {
+                "id": r.id,
+                "user_id": r.user_id,
+                "rating": r.rating,
+                "content": r.content,
+                "created_at": r.created_at.isoformat() if r.created_at else None,
+            }
+            for r in reviews
+        ]
+    }
+
+
+@router.get("/available/skills", summary="获取可关联的 Skills")
+async def get_available_skills(
+    keyword: str = Query(None),
+    state: str = Query(None, description="技能状态筛选"),
+    page: int = Query(1, ge=1),
+    page_size: int = Query(20, ge=1, le=100),
+    admin_user=Depends(get_current_admin),
+    db: Session = Depends(get_db),
+):
+    """获取可关联到 Agent 的 Skills 列表"""
+    query = db.query(EvolutionSkill)
+
+    if keyword:
+        query = query.filter(
+            or_(
+                EvolutionSkill.skill_name.ilike(f"%{keyword}%"),
+                EvolutionSkill.description.ilike(f"%{keyword}%"),
+            )
+        )
+    if state:
+        query = query.filter(EvolutionSkill.state == state)
+
+    total = query.count()
+    skills = query.order_by(EvolutionSkill.use_count.desc()).offset(
+        (page - 1) * page_size
+    ).limit(page_size).all()
+
+    return {
+        "code": 0,
+        "data": {
+            "total": total,
+            "items": [
+                {
+                    "id": s.id,
+                    "skill_name": s.skill_name,
+                    "description": s.description,
+                    "state": s.state,
+                    "version": s.version,
+                    "use_count": s.use_count,
+                    "category": s.category,
+                    "tags": s.tags,
+                }
+                for s in skills
+            ]
+        }
+    }
+
+
+@router.get("/available/models", summary="获取可用模型列表")
+async def get_available_models(
+    admin_user=Depends(get_current_admin),
+    db: Session = Depends(get_db),
+):
+    """获取可用于 Agent 的模型列表"""
+    models = db.query(AIModel).filter(
+        AIModel.is_enabled == True
+    ).order_by(AIModel.name).all()
+
+    return {
+        "code": 0,
+        "data": [
+            {
+                "id": m.id,
+                "name": m.name,
+                "provider": m.provider,
+                "model_type": m.model_type,
+                "input_price": float(m.input_price) if m.input_price else 0,
+                "output_price": float(m.output_price) if m.output_price else 0,
+            }
+            for m in models
+        ]
+    }

backend/python/app/api/admin/models.py

@@ -600,3 +600,155 @@ async def get_model_stats(
         "total_calls": int(total_calls),
         "total_tokens": int(total_tokens),
     }
+
+
+# ============================================================
+# 模型连接测试 API (Phase 2)
+# ============================================================
+
+@router.post("/{model_id}/test-connection")
+async def test_model_connection(
+    model_id: str,
+    admin_user=Depends(get_current_admin),
+    db: Session = Depends(get_db),
+):
+    """
+    测试指定模型的连接是否正常
+    支持从模型记录或提供商记录读取配置
+    """
+    logger = logging.getLogger(__name__)
+    logger.info(f"Testing connection for model_id: {model_id}")
+
+    # 优先从 AIModel 读取
+    ai_model = db.query(AIModel).filter(AIModel.id == model_id).first()
+    if not ai_model:
+        raise HTTPException(status_code=404, detail="模型不存在")
+
+    provider = db.query(ModelProvider).filter(ModelProvider.id == ai_model.provider_id).first()
+    if not provider:
+        raise HTTPException(status_code=404, detail="模型供应商不存在")
+
+    # 确定最终配置
+    api_key = ai_model.api_key or (provider.api_key if provider else None)
+    api_url = ai_model.endpoint
+
+    # 如果 endpoint 为空，尝试构造
+    if not api_url and provider and provider.api_base_url:
+        base = provider.api_base_url.rstrip('/')
+        if provider.protocol == 'openai_compatible':
+            api_url = f"{base}/v1/chat/completions"
+        else:
+            api_url = f"{base}/v1/chat/completions"
+
+    if not api_key:
+        return {
+            "success": False,
+            "message": "未配置 API Key，请在模型或供应商设置中添加",
+            "latency_ms": None,
+        }
+    if not api_url:
+        return {
+            "success": False,
+            "message": "未配置 API 地址，请在模型或供应商设置中添加",
+            "latency_ms": None,
+        }
+
+    timeout = ai_model.timeout or 60
+    import time
+    start = time.time()
+
+    try:
+        async with httpx.AsyncClient(timeout=timeout) as client:
+            headers = {
+                "Authorization": f"Bearer {api_key}",
+                "Content-Type": "application/json",
+            }
+            # 使用 minimal payload 测试连接
+            payload = {
+                "model": ai_model.name,
+                "messages": [{"role": "user", "content": "hi"}],
+                "max_tokens": 5,
+            }
+            resp = await client.post(api_url, json=payload, headers=headers)
+            latency = int((time.time() - start) * 1000)
+
+            if resp.status_code == 200:
+                try:
+                    data = resp.json()
+                    model_used = data.get("model", ai_model.name)
+                    return {
+                        "success": True,
+                        "message": f"连接成功，使用模型: {model_used}",
+                        "latency_ms": latency,
+                        "model_in_response": model_used,
+                    }
+                except Exception:
+                    return {
+                        "success": True,
+                        "message": f"连接成功 (HTTP {resp.status_code})",
+                        "latency_ms": latency,
+                    }
+            elif resp.status_code == 401:
+                return {
+                    "success": False,
+                    "message": "认证失败：API Key 无效或已过期",
+                    "latency_ms": latency,
+                }
+            elif resp.status_code == 403:
+                return {
+                    "success": False,
+                    "message": "访问被拒绝：API Key 权限不足",
+                    "latency_ms": latency,
+                }
+            elif resp.status_code == 429:
+                return {
+                    "success": False,
+                    "message": "触发限流：请稍后重试",
+                    "latency_ms": latency,
+                }
+            else:
+                try:
+                    err_data = resp.json()
+                    err_msg = err_data.get("error", {}).get("message", resp.text[:200])
+                except Exception:
+                    err_msg = resp.text[:200]
+                return {
+                    "success": False,
+                    "message": f"API 错误 (HTTP {resp.status_code}): {err_msg}",
+                    "latency_ms": latency,
+                }
+    except httpx.TimeoutException:
+        latency = int((time.time() - start) * 1000)
+        return {
+            "success": False,
+            "message": f"连接超时（{timeout}s）：请检查 API 地址是否正确，或服务是否可访问",
+            "latency_ms": latency,
+        }
+    except Exception as e:
+        latency = int((time.time() - start) * 1000)
+        logger.error(f"Model connection test failed: {e}")
+        return {
+            "success": False,
+            "message": f"连接失败: {str(e)}",
+            "latency_ms": latency,
+        }
+
+
+    timeout: int = 60
+    status: str = "paid"
+    price_per_million_tokens: float = 0.0
+    is_enabled: bool = True
+
+
+class UpdateModelRequest(BaseModel):
+    name: Optional[str] = None
+    api_key: Optional[str] = None
+    endpoint: Optional[str] = None
+    capabilities: Optional[List[str]] = None
+    timeout: Optional[int] = None
+    status: Optional[str] = None
+    price_per_million_tokens: Optional[float] = None
+    is_enabled: Optional[bool] = None
+
+
+from typing import Optional

backend/python/app/api/admin/skills_admin.py

@@ -0,0 +1,773 @@
+"""
+技能管理系统 API（管理员）
+全平台技能管理：列表/创建/编辑/删除/状态管理/版本历史/发布市场
+"""
+import os
+import json
+import uuid
+import logging
+from datetime import datetime
+from typing import Optional, List
+
+from fastapi import APIRouter, Depends, HTTPException, Query
+from sqlalchemy.orm import Session
+from sqlalchemy import desc, func, or_, and_
+
+from ...database import get_db
+from ...models import (
+    User, EvolutionSkill, SkillVersion, SkillPublishRecord,
+    EvolutionEvent, TeamSharedSkill
+)
+from ...auth import get_current_admin
+from ...middleware.log_service import LogService
+from ...config import UPLOAD_DIR
+
+router = APIRouter()
+logger = logging.getLogger(__name__)
+
+# ============================================================
+# 技能状态定义
+# ============================================================
+
+SKILL_STATES = {
+    "baby": {"label": "萌芽期", "color": "#9CA3AF", "description": "刚创建的技能，需要继续培养"},
+    "main": {"label": "主力期", "color": "#10B981", "description": "已成熟可正常使用"},
+    "staging": {"label": "灰度期", "color": "#F59E0B", "description": "正在灰度测试中"},
+    "frozen": {"label": "已冻结", "color": "#EF4444", "description": "已停止使用"},
+}
+
+SKILL_CATEGORIES = [
+    {"id": "writing", "label": "文字创作"},
+    {"id": "coding", "label": "代码能力"},
+    {"id": "data_analysis", "label": "数据分析"},
+    {"id": "qa", "label": "知识问答"},
+    {"id": "automation", "label": "流程自动化"},
+    {"id": "creativity", "label": "创意生成"},
+    {"id": "communication", "label": "沟通协作"},
+    {"id": "reasoning", "label": "逻辑推理"},
+    {"id": "other", "label": "其他"},
+]
+
+
+# ============================================================
+# 辅助函数
+# ============================================================
+
+def skill_to_dict(s: EvolutionSkill, include_md: bool = False) -> dict:
+    """将技能ORM对象转换为字典"""
+    result = {
+        "id": s.id,
+        "user_id": s.user_id,
+        "skill_name": s.skill_name,
+        "description": s.description,
+        "tags": s.tags or [],
+        "category": s.category,
+        "category_label": next((c["label"] for c in SKILL_CATEGORIES if c["id"] == s.category), s.category or "其他"),
+        "state": s.state,
+        "state_info": SKILL_STATES.get(s.state, SKILL_STATES["baby"]),
+        "use_count": s.use_count or 0,
+        "version": s.version or 1,
+        "skill_md_path": s.skill_md_path,
+        "git_commit_sha": s.git_commit_sha,
+        "last_used_at": s.last_used_at.isoformat() if s.last_used_at else None,
+        "created_at": s.created_at.isoformat() if s.created_at else None,
+        "updated_at": s.updated_at.isoformat() if s.updated_at else None,
+    }
+
+    # 读取 SKILL.md 内容
+    if include_md and s.skill_md_path and os.path.exists(s.skill_md_path):
+        try:
+            with open(s.skill_md_path, 'r', encoding='utf-8') as f:
+                result["skill_md_content"] = f.read()
+        except Exception:
+            result["skill_md_content"] = None
+    else:
+        result["skill_md_content"] = None
+
+    return result
+
+
+def version_to_dict(v: SkillVersion) -> dict:
+    return {
+        "id": v.id,
+        "user_id": v.user_id,
+        "skill_name": v.skill_name,
+        "version": v.version,
+        "skill_md_content": v.skill_md_content,
+        "git_commit_sha": v.git_commit_sha,
+        "description": v.description,
+        "created_at": v.created_at.isoformat() if v.created_at else None,
+    }
+
+
+# ============================================================
+# 管理员技能列表
+# ============================================================
+
+@router.get("/")
+async def list_skills(
+    state: str = Query(None, description="技能状态过滤: baby/main/staging/frozen"),
+    category: str = Query(None, description="技能分类过滤"),
+    keyword: str = Query(None, description="关键词搜索(名称/描述)"),
+    user_id: str = Query(None, description="按用户ID筛选"),
+    sort_by: str = Query("updated_at", description="排序字段"),
+    order: str = Query("desc", description="排序方向: asc/desc"),
+    page: int = Query(1, ge=1, description="页码"),
+    page_size: int = Query(20, ge=1, le=100, description="每页数量"),
+    admin_user=Depends(get_current_admin),
+    db: Session = Depends(get_db),
+):
+    """获取全平台技能列表（支持分页/过滤/搜索）"""
+    logger.info(f"[Admin Skills] {admin_user.username} 列出技能: state={state}, keyword={keyword}")
+
+    query = db.query(EvolutionSkill)
+
+    if state:
+        query = query.filter(EvolutionSkill.state == state)
+    if category:
+        query = query.filter(EvolutionSkill.category == category)
+    if keyword:
+        query = query.filter(
+            or_(
+                EvolutionSkill.skill_name.contains(keyword),
+                EvolutionSkill.description.contains(keyword)
+            )
+        )
+    if user_id:
+        query = query.filter(EvolutionSkill.user_id == user_id)
+
+    # 总数
+    total = query.count()
+
+    # 排序
+    sort_field = getattr(EvolutionSkill, sort_by, EvolutionSkill.updated_at)
+    if order == "desc":
+        query = query.order_by(desc(sort_field))
+    else:
+        query = query.order_by(sort_field)
+
+    # 分页
+    skills = query.offset((page - 1) * page_size).limit(page_size).all()
+
+    # 补充用户名
+    user_ids = list(set(s.user_id for s in skills))
+    users_map = {
+        u.id: u.username
+        for u in db.query(User.id, User.username).filter(User.id.in_(user_ids)).all()
+    }
+
+    result = []
+    for s in skills:
+        item = skill_to_dict(s)
+        item["owner_username"] = users_map.get(s.user_id, s.user_id)
+        result.append(item)
+
+    return {
+        "code": 0,
+        "data": {
+            "items": result,
+            "total": total,
+            "page": page,
+            "page_size": page_size,
+            "pages": (total + page_size - 1) // page_size,
+        }
+    }
+
+
+# ============================================================
+# 获取单个技能详情
+# ============================================================
+
+@router.get("/{skill_id}")
+async def get_skill(
+    skill_id: str,
+    admin_user=Depends(get_current_admin),
+    db: Session = Depends(get_db),
+):
+    """获取技能详情（包含 SKILL.md 内容）"""
+    skill = db.query(EvolutionSkill).filter(EvolutionSkill.id == skill_id).first()
+    if not skill:
+        raise HTTPException(status_code=404, detail="技能不存在")
+
+    result = skill_to_dict(skill, include_md=True)
+
+    # 获取所属用户信息
+    user = db.query(User).filter(User.id == skill.user_id).first()
+    if user:
+        result["owner_username"] = user.username
+        result["owner_email"] = user.email
+
+    # 获取发布记录
+    pub_records = db.query(SkillPublishRecord).filter(
+        SkillPublishRecord.skill_id == skill_id
+    ).order_by(desc(SkillPublishRecord.created_at)).limit(10).all()
+    result["publish_records"] = [{
+        "id": p.id,
+        "price": float(p.price) if p.price else 0,
+        "market_description": p.market_description,
+        "status": p.status,
+        "published_at": p.published_at.isoformat() if p.published_at else None,
+        "created_at": p.created_at.isoformat() if p.created_at else None,
+    } for p in pub_records]
+
+    # 获取最新版本号
+    latest_version = db.query(func.max(SkillVersion.version)).filter(
+        SkillVersion.skill_id == skill_id
+    ).scalar()
+    result["latest_version"] = latest_version or skill.version
+
+    return {"code": 0, "data": result}
+
+
+# ============================================================
+# 创建技能
+# ============================================================
+
+class CreateSkillRequest:
+    def __init__(self, skill_name: str = None, description: str = None,
+                 tags: List[str] = None, category: str = None,
+                 skill_md_content: str = None, user_id: str = None):
+        self.skill_name = skill_name
+        self.description = description
+        self.tags = tags or []
+        self.category = category
+        self.skill_md_content = skill_md_content
+        self.user_id = user_id
+
+
+from pydantic import BaseModel, Field
+
+
+class CreateSkillSchema(BaseModel):
+    skill_name: str = Field(..., min_length=1, max_length=200, description="技能名称")
+    user_id: str = Field(..., description="所属用户ID")
+    description: Optional[str] = Field(None, description="技能描述")
+    tags: Optional[List[str]] = Field(default_factory=list, description="标签列表")
+    category: Optional[str] = Field(None, description="技能分类")
+    skill_md_content: Optional[str] = Field(None, description="SKILL.md 内容")
+
+
+@router.post("/")
+async def create_skill(
+    req: CreateSkillSchema,
+    admin_user=Depends(get_current_admin),
+    db: Session = Depends(get_db),
+):
+    """管理员创建技能"""
+    logger.info(f"[Admin Skills] {admin_user.username} 创建技能: {req.skill_name}")
+
+    # 检查技能名是否已存在
+    existing = db.query(EvolutionSkill).filter(
+        EvolutionSkill.user_id == req.user_id,
+        EvolutionSkill.skill_name == req.skill_name
+    ).first()
+    if existing:
+        raise HTTPException(status_code=400, detail="该用户已存在同名技能")
+
+    # 验证用户存在
+    user = db.query(User).filter(User.id == req.user_id).first()
+    if not user:
+        raise HTTPException(status_code=400, detail="用户不存在")
+
+    # 生成技能ID
+    skill_id = str(uuid.uuid4())
+
+    # 保存 SKILL.md 文件
+    skill_md_path = None
+    if req.skill_md_content:
+        skill_dir = os.path.join(UPLOAD_DIR, "skills", req.user_id)
+        os.makedirs(skill_dir, exist_ok=True)
+        safe_name = req.skill_name.replace("/", "_").replace("\\", "_")
+        skill_md_path = os.path.join(skill_dir, f"{safe_name}.md")
+        try:
+            with open(skill_md_path, 'w', encoding='utf-8') as f:
+                f.write(req.skill_md_content)
+        except Exception as e:
+            logger.warning(f"保存 SKILL.md 失败: {e}")
+
+    # 创建技能记录
+    skill = EvolutionSkill(
+        id=skill_id,
+        user_id=req.user_id,
+        skill_name=req.skill_name,
+        description=req.description,
+        tags=req.tags or [],
+        category=req.category,
+        state="baby",
+        use_count=0,
+        version=1,
+        skill_md_path=skill_md_path,
+        git_commit_sha=None,
+    )
+    db.add(skill)
+
+    # 记录初始版本
+    if req.skill_md_content:
+        sv = SkillVersion(
+            id=str(uuid.uuid4()),
+            user_id=req.user_id,
+            skill_name=req.skill_name,
+            version=1,
+            skill_md_content=req.skill_md_content,
+            git_commit_sha=None,
+            description="初始版本",
+        )
+        db.add(sv)
+
+    # 记录事件
+    ev = EvolutionEvent(
+        id=str(uuid.uuid4()),
+        user_id=req.user_id,
+        skill_name=req.skill_name,
+        event_type="created",
+        description=f"管理员 {admin_user.username} 创建技能 {req.skill_name}",
+        version_before=None,
+        version_after=1,
+    )
+    db.add(ev)
+
+    db.commit()
+    db.refresh(skill)
+
+    LogService.log_operation(
+        user_id=admin_user.id,
+        username=admin_user.username,
+        action="create_skill",
+        target="evolution_skills",
+        detail=f"创建技能 {req.skill_name}（归属用户: {user.username}）",
+    )
+
+    return {"code": 0, "data": skill_to_dict(skill, include_md=True)}
+
+
+# ============================================================
+# 更新技能
+# ============================================================
+
+class UpdateSkillSchema(BaseModel):
+    skill_name: Optional[str] = Field(None, min_length=1, max_length=200)
+    description: Optional[str] = None
+    tags: Optional[List[str]] = None
+    category: Optional[str] = None
+    skill_md_content: Optional[str] = None
+
+
+@router.put("/{skill_id}")
+async def update_skill(
+    skill_id: str,
+    req: UpdateSkillSchema,
+    admin_user=Depends(get_current_admin),
+    db: Session = Depends(get_db),
+):
+    """更新技能信息"""
+    skill = db.query(EvolutionSkill).filter(EvolutionSkill.id == skill_id).first()
+    if not skill:
+        raise HTTPException(status_code=404, detail="技能不存在")
+
+    old_version = skill.version
+    update_data = req.model_dump(exclude_none=True)
+
+    # 处理 SKILL.md 内容
+    if "skill_md_content" in update_data:
+        content = update_data.pop("skill_md_content")
+        if content is not None:
+            skill_dir = os.path.join(UPLOAD_DIR, "skills", skill.user_id)
+            os.makedirs(skill_dir, exist_ok=True)
+            safe_name = skill.skill_name.replace("/", "_").replace("\\", "_")
+            skill_md_path = os.path.join(skill_dir, f"{safe_name}.md")
+            try:
+                with open(skill_md_path, 'w', encoding='utf-8') as f:
+                    f.write(content)
+                skill.skill_md_path = skill_md_path
+            except Exception as e:
+                logger.warning(f"保存 SKILL.md 失败: {e}")
+
+            # 记录新版本
+            new_version = old_version + 1
+            sv = SkillVersion(
+                id=str(uuid.uuid4()),
+                user_id=skill.user_id,
+                skill_name=skill.skill_name,
+                version=new_version,
+                skill_md_content=content,
+                git_commit_sha=None,
+                description="管理员更新",
+            )
+            db.add(sv)
+            skill.version = new_version
+
+            # 记录事件
+            ev = EvolutionEvent(
+                id=str(uuid.uuid4()),
+                user_id=skill.user_id,
+                skill_name=skill.skill_name,
+                event_type="edited",
+                description=f"管理员 {admin_user.username} 更新技能 {skill.skill_name}",
+                version_before=old_version,
+                version_after=new_version,
+            )
+            db.add(ev)
+
+    # 更新其他字段
+    for key, value in update_data.items():
+        if key not in ("skill_md_content",) and hasattr(skill, key):
+            setattr(skill, key, value)
+
+    skill.updated_at = datetime.now()
+    db.commit()
+    db.refresh(skill)
+
+    LogService.log_operation(
+        user_id=admin_user.id,
+        username=admin_user.username,
+        action="update_skill",
+        target="evolution_skills",
+        detail=f"更新技能 {skill.skill_name}（版本 {old_version} → {skill.version}）",
+    )
+
+    return {"code": 0, "data": skill_to_dict(skill, include_md=True)}
+
+
+# ============================================================
+# 删除技能
+# ============================================================
+
+@router.delete("/{skill_id}")
+async def delete_skill(
+    skill_id: str,
+    admin_user=Depends(get_current_admin),
+    db: Session = Depends(get_db),
+):
+    """删除技能"""
+    skill = db.query(EvolutionSkill).filter(EvolutionSkill.id == skill_id).first()
+    if not skill:
+        raise HTTPException(status_code=404, detail="技能不存在")
+
+    skill_name = skill.skill_name
+    user_id = skill.user_id
+
+    # 记录事件
+    ev = EvolutionEvent(
+        id=str(uuid.uuid4()),
+        user_id=user_id,
+        skill_name=skill_name,
+        event_type="deleted",
+        description=f"管理员 {admin_user.username} 删除技能 {skill_name}",
+    )
+    db.add(ev)
+
+    # 删除版本历史
+    db.query(SkillVersion).filter(SkillVersion.skill_name == skill_name).delete()
+
+    # 删除发布记录
+    db.query(SkillPublishRecord).filter(SkillPublishRecord.skill_id == skill_id).delete()
+
+    # 删除团队共享记录
+    db.query(TeamSharedSkill).filter(TeamSharedSkill.skill_id == skill_id).delete()
+
+    db.delete(skill)
+    db.commit()
+
+    LogService.log_operation(
+        user_id=admin_user.id,
+        username=admin_user.username,
+        action="delete_skill",
+        target="evolution_skills",
+        detail=f"删除技能 {skill_name}",
+    )
+
+    return {"code": 0, "message": f"技能 {skill_name} 已删除"}
+
+
+# ============================================================
+# 修改技能状态
+# ============================================================
+
+class ChangeStateSchema(BaseModel):
+    state: str = Field(..., description="目标状态: baby/main/staging/frozen")
+
+
+@router.put("/{skill_id}/state")
+async def change_skill_state(
+    skill_id: str,
+    req: ChangeStateSchema,
+    admin_user=Depends(get_current_admin),
+    db: Session = Depends(get_db),
+):
+    """修改技能状态"""
+    if req.state not in SKILL_STATES:
+        raise HTTPException(status_code=400, detail=f"无效状态，可选值: {list(SKILL_STATES.keys())}")
+
+    skill = db.query(EvolutionSkill).filter(EvolutionSkill.id == skill_id).first()
+    if not skill:
+        raise HTTPException(status_code=404, detail="技能不存在")
+
+    old_state = skill.state
+    skill.state = req.state
+    skill.updated_at = datetime.now()
+
+    # 记录状态变更事件
+    ev_type = "promoted" if req.state in ("main", "staging") else "frozen" if req.state == "frozen" else "unfrozen"
+    ev = EvolutionEvent(
+        id=str(uuid.uuid4()),
+        user_id=skill.user_id,
+        skill_name=skill.skill_name,
+        event_type=ev_type,
+        description=f"管理员 {admin_user.username} 将技能状态从 {old_state} 变更为 {req.state}",
+    )
+    db.add(ev)
+    db.commit()
+    db.refresh(skill)
+
+    LogService.log_operation(
+        user_id=admin_user.id,
+        username=admin_user.username,
+        action="change_skill_state",
+        target="evolution_skills",
+        detail=f"修改技能 {skill.skill_name} 状态: {old_state} → {req.state}",
+    )
+
+    return {"code": 0, "data": skill_to_dict(skill)}
+
+
+# ============================================================
+# 获取版本历史
+# ============================================================
+
+@router.get("/{skill_id}/versions")
+async def get_skill_versions(
+    skill_id: str,
+    admin_user=Depends(get_current_admin),
+    db: Session = Depends(get_db),
+):
+    """获取技能版本历史"""
+    skill = db.query(EvolutionSkill).filter(EvolutionSkill.id == skill_id).first()
+    if not skill:
+        raise HTTPException(status_code=404, detail="技能不存在")
+
+    versions = db.query(SkillVersion).filter(
+        SkillVersion.skill_name == skill.skill_name,
+        SkillVersion.user_id == skill.user_id,
+    ).order_by(desc(SkillVersion.version)).all()
+
+    return {
+        "code": 0,
+        "data": {
+            "skill_id": skill.id,
+            "skill_name": skill.skill_name,
+            "current_version": skill.version,
+            "versions": [version_to_dict(v) for v in versions],
+        }
+    }
+
+
+# ============================================================
+# 回滚到指定版本
+# ============================================================
+
+class RollbackSchema(BaseModel):
+    version: int = Field(..., ge=1, description="目标版本号")
+
+
+@router.post("/{skill_id}/rollback")
+async def rollback_skill_version(
+    skill_id: str,
+    req: RollbackSchema,
+    admin_user=Depends(get_current_admin),
+    db: Session = Depends(get_db),
+):
+    """回滚技能到指定版本"""
+    skill = db.query(EvolutionSkill).filter(EvolutionSkill.id == skill_id).first()
+    if not skill:
+        raise HTTPException(status_code=404, detail="技能不存在")
+
+    target_version = db.query(SkillVersion).filter(
+        SkillVersion.skill_name == skill.skill_name,
+        SkillVersion.user_id == skill.user_id,
+        SkillVersion.version == req.version,
+    ).first()
+
+    if not target_version:
+        raise HTTPException(status_code=404, detail=f"版本 {req.version} 不存在")
+
+    old_version = skill.version
+
+    # 更新 SKILL.md 文件
+    if target_version.skill_md_content:
+        if skill.skill_md_path:
+            try:
+                with open(skill.skill_md_path, 'w', encoding='utf-8') as f:
+                    f.write(target_version.skill_md_content)
+            except Exception as e:
+                logger.warning(f"回滚保存 SKILL.md 失败: {e}")
+
+    # 记录新版本（基于目标版本）
+    new_version = old_version + 1
+    sv = SkillVersion(
+        id=str(uuid.uuid4()),
+        user_id=skill.user_id,
+        skill_name=skill.skill_name,
+        version=new_version,
+        skill_md_content=target_version.skill_md_content,
+        git_commit_sha=None,
+        description=f"回滚到版本 {req.version}（管理员操作）",
+    )
+    db.add(sv)
+
+    skill.version = new_version
+    skill.updated_at = datetime.now()
+
+    ev = EvolutionEvent(
+        id=str(uuid.uuid4()),
+        user_id=skill.user_id,
+        skill_name=skill.skill_name,
+        event_type="edited",
+        description=f"管理员 {admin_user.username} 回滚技能 {skill.skill_name} 从版本 {old_version} 到 {req.version}（新版本 {new_version}）",
+        version_before=old_version,
+        version_after=new_version,
+    )
+    db.add(ev)
+
+    db.commit()
+    db.refresh(skill)
+
+    LogService.log_operation(
+        user_id=admin_user.id,
+        username=admin_user.username,
+        action="rollback_skill",
+        target="evolution_skills",
+        detail=f"回滚技能 {skill.skill_name} 到版本 {req.version}（新版本 {new_version}）",
+    )
+
+    return {"code": 0, "data": skill_to_dict(skill, include_md=True)}
+
+
+# ============================================================
+# 发布到应用市场
+# ============================================================
+
+class PublishSkillSchema(BaseModel):
+    price: float = Field(0.0, ge=0, description="定价（0表示免费）")
+    market_description: str = Field("", description="市场描述")
+
+
+@router.post("/{skill_id}/publish")
+async def publish_skill(
+    skill_id: str,
+    req: PublishSkillSchema,
+    admin_user=Depends(get_current_admin),
+    db: Session = Depends(get_db),
+):
+    """发布技能到应用市场"""
+    skill = db.query(EvolutionSkill).filter(EvolutionSkill.id == skill_id).first()
+    if not skill:
+        raise HTTPException(status_code=404, detail="技能不存在")
+
+    # 检查是否已发布
+    existing = db.query(SkillPublishRecord).filter(
+        SkillPublishRecord.skill_id == skill_id,
+        SkillPublishRecord.status == "published"
+    ).first()
+
+    if existing:
+        # 更新现有发布
+        existing.price = req.price
+        existing.market_description = req.market_description
+        msg = "更新发布信息"
+    else:
+        # 创建发布记录
+        record = SkillPublishRecord(
+            id=str(uuid.uuid4()),
+            skill_id=skill_id,
+            skill_name=skill.skill_name,
+            user_id=skill.user_id,
+            price=req.price,
+            market_description=req.market_description,
+            status="published",
+        )
+        db.add(record)
+        msg = "发布成功"
+
+    db.commit()
+
+    LogService.log_operation(
+        user_id=admin_user.id,
+        username=admin_user.username,
+        action="publish_skill",
+        target="skill_publish_records",
+        detail=f"{msg}: {skill.skill_name}，定价: ¥{req.price}",
+    )
+
+    return {"code": 0, "message": msg, "data": {"skill_id": skill_id, "price": req.price}}
+
+
+# ============================================================
+# 下架技能
+# ============================================================
+
+@router.post("/{skill_id}/unpublish")
+async def unpublish_skill(
+    skill_id: str,
+    admin_user=Depends(get_current_admin),
+    db: Session = Depends(get_db),
+):
+    """从应用市场下架技能"""
+    skill = db.query(EvolutionSkill).filter(EvolutionSkill.id == skill_id).first()
+    if not skill:
+        raise HTTPException(status_code=404, detail="技能不存在")
+
+    updated = db.query(SkillPublishRecord).filter(
+        SkillPublishRecord.skill_id == skill_id,
+        SkillPublishRecord.status == "published"
+    ).update({"status": "unpublished"})
+    db.commit()
+
+    if updated == 0:
+        raise HTTPException(status_code=400, detail="该技能未发布到市场")
+
+    LogService.log_operation(
+        user_id=admin_user.id,
+        username=admin_user.username,
+        action="unpublish_skill",
+        target="skill_publish_records",
+        detail=f"下架技能: {skill.skill_name}",
+    )
+
+    return {"code": 0, "message": f"技能 {skill.skill_name} 已下架"}
+
+
+# ============================================================
+# 获取统计数据
+# ============================================================
+
+@router.get("/stats/overview")
+async def get_skills_stats(
+    admin_user=Depends(get_current_admin),
+    db: Session = Depends(get_db),
+):
+    """获取技能统计概览"""
+    total = db.query(EvolutionSkill).count()
+    by_state = dict(
+        db.query(EvolutionSkill.state, func.count(EvolutionSkill.id))
+        .group_by(EvolutionSkill.state).all()
+    )
+    by_category = dict(
+        db.query(EvolutionSkill.category, func.count(EvolutionSkill.id))
+        .filter(EvolutionSkill.category.isnot(None))
+        .group_by(EvolutionSkill.category).all()
+    )
+    total_published = db.query(SkillPublishRecord).filter(
+        SkillPublishRecord.status == "published"
+    ).count()
+    total_versions = db.query(SkillVersion).count()
+
+    return {
+        "code": 0,
+        "data": {
+            "total_skills": total,
+            "by_state": {k: by_state.get(k, 0) for k in SKILL_STATES},
+            "by_category": by_category,
+            "total_published": total_published,
+            "total_versions": total_versions,
+        }
+    }

backend/python/main.py

@@ -1,214 +1,215 @@
-"""
-Qihu-AIFlow FastAPI 主应用
-完整后端API，监听18080端口，所有接口以 /app 为前缀
-"""
-import sys
-import os
-import time
-import uuid
-import logging
-from contextlib import asynccontextmanager
-from fastapi import FastAPI, Request
-from fastapi.middleware.cors import CORSMiddleware
-from starlette.middleware.base import BaseHTTPMiddleware
-from datetime import datetime
-
-sys.path.insert(0, os.path.dirname(os.path.dirname(os.path.abspath(__file__))))
-
-from app.api import auth, chat, channels, knowledge, market, token_usage, payment, profile, notifications, assets, evolution
-from app.api.admin import dashboard, users, models, settings, payment_admin, services, membership_admin, ads, market_admin, logs
-from app.config import setup_file_logging, SLOW_REQUEST_THRESHOLD
-from app.database import SessionLocal
-from app.models import OperationLog as OperationLogModel, TokenUsageLog as TokenUsageLogModel
-
-# 导入平台适配器触发注册（AstrBot借鉴优化方案 P1）
-import app.platform_adapters  # noqa: F401 - 触发所有平台适配器装饰器注册
-
-# 初始化文件日志（按天轮转）
-access_logger = setup_file_logging()
-logger = logging.getLogger("aiflow")
-
-
-class APITrackingMiddleware(BaseHTTPMiddleware):
-    """API调用统计中间件 - 记录请求耗时，标记慢请求"""
-
-    async def dispatch(self, request: Request, call_next):
-        request_id = str(uuid.uuid4())
-        start_time = time.time()
-        path = request.url.path
-        method = request.method
-
-        # 跳过健康检查和静态资源
-        skip_paths = ["/app/api/health", "/favicon.ico"]
-        should_skip = any(path.startswith(p) for p in skip_paths)
-
-        try:
-            response = await call_next(request)
-            elapsed = time.time() - start_time
-            status_code = response.status_code
-
-            if not should_skip:
-                access_logger.info(
-                    f"[{request_id}] {method} {path} -> {status_code} ({elapsed:.3f}s)"
-                )
-
-                # 异步记录API调用统计
-                try:
-                    db = SessionLocal()
-                    try:
-                        _record_api_call(db, method, path, status_code, elapsed)
-                    finally:
-                        db.close()
-                except Exception as e:
-                    logger.warning(f"API统计记录失败: {e}")
-
-            return response
-        except Exception as e:
-            elapsed = time.time() - start_time
-            if not should_skip:
-                access_logger.info(
-                    f"[{request_id}] {method} {path} -> ERROR ({elapsed:.3f}s): {str(e)}"
-                )
-            raise
-
-    async def __call__(self, scope, receive, send):
-        if scope["type"] != "http":
-            await self.app(scope, receive, send)
-            return
-        await super().__call__(scope, receive, send)
-
-
-def _record_api_call(db, method: str, path: str, status_code: int, elapsed: float):
-    """记录API调用到数据库统计表"""
-    # 简化路径以减少基数（去掉动态ID）
-    parts = path.split("/")
-    simplified_parts = []
-    for part in parts:
-        # 将UUID样式的路径段替换为{id}
-        if len(part) == 36 and part.count("-") == 4:
-            simplified_parts.append("{id}")
-        # 将纯数字路径段替换为{id}
-        elif part.isdigit():
-            simplified_parts.append("{id}")
-        else:
-            simplified_parts.append(part)
-    simplified_path = "/".join(simplified_parts)
-
-    # 统计记录通过数据库实现，简化版记录到日志
-    is_error = status_code >= 400
-    is_slow = elapsed >= SLOW_REQUEST_THRESHOLD
-
-    if is_slow:
-        logger.warning(
-            f"慢请求: {method} {simplified_path} -> {status_code} ({elapsed:.3f}s, 阈值: {SLOW_REQUEST_THRESHOLD}s)"
-        )
-
-
-@asynccontextmanager
-async def lifespan(app: FastAPI):
-    logger.info("Qihu-AIFlow v2.0.0 启动中...")
-
-    # 启动后台 Evolution Pipeline（知识库图谱已存在的用户配置自动恢复运行）
-    try:
-        from app.services.evolution_service import EvolutionWatcherManager
-        from app.models import UserEvolutionConfig
-        db = SessionLocal()
-        try:
-            configs = db.query(UserEvolutionConfig).filter(
-                UserEvolutionConfig.watcher_status == "running"
-            ).all()
-            if configs:
-                watcher = EvolutionWatcherManager()
-                for cfg in configs:
-                    try:
-                        watcher.start_user_evolution(cfg.user_id, lambda: SessionLocal())
-                        logger.info(f"[Evolution] 恢复用户 {cfg.user_id} 的进化Pipeline")
-                    except Exception as e:
-                        logger.warning(f"[Evolution] 恢复用户 {cfg.user_id} 失败: {e}")
-                logger.info(f"[Evolution] 已恢复 {len(configs)} 个用户的进化Pipeline")
-            else:
-                logger.info("[Evolution] 无待恢复的进化配置")
-        finally:
-            db.close()
-    except Exception as e:
-        logger.warning(f"[Evolution] Pipeline自动启动异常(不影响正常服务): {e}")
-
-    # 启动Redis事件总线
-    try:
-        from app.event_bus import get_event_bus
-        event_bus = get_event_bus()
-        event_bus.start(num_consumers=2)
-        logger.info("[EventBus] Redis事件总线已启动")
-    except Exception as e:
-        logger.warning(f"[EventBus] 启动失败(不影响正常服务): {e}")
-
-    logger.info("Qihu-AIFlow v2.0.0 启动完成")
-
-    yield
-
-    # 停止Redis事件总线
-    try:
-        from app.event_bus import get_event_bus
-        get_event_bus().stop()
-        logger.info("[EventBus] Redis事件总线已停止")
-    except Exception:
-        pass
-
-    # 优雅关闭：停止所有 Evolution Pipeline
-    try:
-        from app.services.evolution_service import EvolutionWatcherManager
-        EvolutionWatcherManager().shutdown_all()
-        logger.info("[Evolution] 所有Pipeline已停止")
-    except Exception:
-        pass
-
-    logger.info("Qihu-AIFlow 正在关闭...")
-
-
-app = FastAPI(
-    title="Qihu-AIFlow - 智能自动化PaaS平台",
-    version="1.0.0",
-    lifespan=lifespan,
-)
-
-# API调用追踪中间件
-app.add_middleware(APITrackingMiddleware)
-
-# CORS配置
-app.add_middleware(
-    CORSMiddleware,
-    allow_origins=["*"],
-    allow_credentials=True,
-    allow_methods=["*"],
-    allow_headers=["*"],
-)
-
-# 前台 API
-app.include_router(auth.router, prefix="/app/api/auth", tags=["认证"])
-app.include_router(chat.router, prefix="/app/api/chat", tags=["AI聊天"])
-app.include_router(channels.router, prefix="/app/api/channels", tags=["频道"])
-app.include_router(knowledge.router, prefix="/app/api/knowledge", tags=["知识库"])
-app.include_router(market.router, prefix="/app/api/market", tags=["应用市场"])
-app.include_router(token_usage.router, prefix="/app/api/token", tags=["Token驾驶舱"])
-app.include_router(payment.router, prefix="/app/api/payment", tags=["付费中心"])
-app.include_router(profile.router, prefix="/app/api/profile", tags=["个人中心"])
-app.include_router(notifications.router, prefix="/app/api/notifications", tags=["消息通知"])
-app.include_router(assets.router, prefix="/app/api/assets", tags=["资产管理"])
-app.include_router(evolution.router, prefix="/app/api/evolution", tags=["AI自进化"])
-
-# 后台 API
-app.include_router(dashboard.router, prefix="/app/api/admin/dashboard", tags=["后台-仪表盘"])
-app.include_router(users.router, prefix="/app/api/admin/users", tags=["后台-用户管理"])
-app.include_router(models.router, prefix="/app/api/admin/models", tags=["后台-模型管理"])
-app.include_router(settings.router, prefix="/app/api/admin/settings", tags=["后台-网站设置"])
-app.include_router(payment_admin.router, prefix="/app/api/admin/payment", tags=["后台-支付配置"])
-app.include_router(services.router, prefix="/app/api/admin/services", tags=["后台-增值服务"])
-app.include_router(membership_admin.router, prefix="/app/api/admin/membership", tags=["后台-会员管理"])
-app.include_router(ads.router, prefix="/app/api/admin/ads", tags=["后台-广告管理"])
-app.include_router(market_admin.router, prefix="/app/api/admin/market", tags=["后台-应用审核"])
-app.include_router(logs.router, prefix="/app/api/admin/logs", tags=["后台-日志风控"])
-
-
-@app.get("/app/api/health")
-async def health_check():
-    return {"status": "ok", "service": "Qihu-AIFlow"}
+"""␍
+Qihu-AIFlow FastAPI 主应用␍
+完整后端API，监听18080端口，所有接口以 /app 为前缀␍
+"""␍
+import sys␍
+import os␍
+import time␍
+import uuid␍
+import logging␍
+from contextlib import asynccontextmanager␍
+from fastapi import FastAPI, Request␍
+from fastapi.middleware.cors import CORSMiddleware␍
+from starlette.middleware.base import BaseHTTPMiddleware␍
+from datetime import datetime␍
+␍
+sys.path.insert(0, os.path.dirname(os.path.dirname(os.path.abspath(__file__))))␍
+␍
+from app.api import auth, chat, channels, knowledge, market, token_usage, payment, profile, notifications, assets, evolution␍
+from app.api.admin import dashboard, users, models, settings, payment_admin, services, membership_admin, ads, market_admin, logs, skills_admin␍
+from app.config import setup_file_logging, SLOW_REQUEST_THRESHOLD␍
+from app.database import SessionLocal␍
+from app.models import OperationLog as OperationLogModel, TokenUsageLog as TokenUsageLogModel␍
+␍
+# 导入平台适配器触发注册（AstrBot借鉴优化方案 P1）␍
+import app.platform_adapters  # noqa: F401 - 触发所有平台适配器装饰器注册␍
+␍
+# 初始化文件日志（按天轮转）␍
+access_logger = setup_file_logging()␍
+logger = logging.getLogger("aiflow")␍
+␍
+␍
+class APITrackingMiddleware(BaseHTTPMiddleware):␍
+    """API调用统计中间件 - 记录请求耗时，标记慢请求"""␍
+␍
+    async def dispatch(self, request: Request, call_next):␍
+        request_id = str(uuid.uuid4())␍
+        start_time = time.time()␍
+        path = request.url.path␍
+        method = request.method␍
+␍
+        # 跳过健康检查和静态资源␍
+        skip_paths = ["/app/api/health", "/favicon.ico"]␍
+        should_skip = any(path.startswith(p) for p in skip_paths)␍
+␍
+        try:␍
+            response = await call_next(request)␍
+            elapsed = time.time() - start_time␍
+            status_code = response.status_code␍
+␍
+            if not should_skip:␍
+                access_logger.info(␍
+                    f"[{request_id}] {method} {path} -> {status_code} ({elapsed:.3f}s)"␍
+                )␍
+␍
+                # 异步记录API调用统计␍
+                try:␍
+                    db = SessionLocal()␍
+                    try:␍
+                        _record_api_call(db, method, path, status_code, elapsed)␍
+                    finally:␍
+                        db.close()␍
+                except Exception as e:␍
+                    logger.warning(f"API统计记录失败: {e}")␍
+␍
+            return response␍
+        except Exception as e:␍
+            elapsed = time.time() - start_time␍
+            if not should_skip:␍
+                access_logger.info(␍
+                    f"[{request_id}] {method} {path} -> ERROR ({elapsed:.3f}s): {str(e)}"␍
+                )␍
+            raise␍
+␍
+    async def __call__(self, scope, receive, send):␍
+        if scope["type"] != "http":␍
+            await self.app(scope, receive, send)␍
+            return␍
+        await super().__call__(scope, receive, send)␍
+␍
+␍
+def _record_api_call(db, method: str, path: str, status_code: int, elapsed: float):␍
+    """记录API调用到数据库统计表"""␍
+    # 简化路径以减少基数（去掉动态ID）␍
+    parts = path.split("/")␍
+    simplified_parts = []␍
+    for part in parts:␍
+        # 将UUID样式的路径段替换为{id}␍
+        if len(part) == 36 and part.count("-") == 4:␍
+            simplified_parts.append("{id}")␍
+        # 将纯数字路径段替换为{id}␍
+        elif part.isdigit():␍
+            simplified_parts.append("{id}")␍
+        else:␍
+            simplified_parts.append(part)␍
+    simplified_path = "/".join(simplified_parts)␍
+␍
+    # 统计记录通过数据库实现，简化版记录到日志␍
+    is_error = status_code >= 400␍
+    is_slow = elapsed >= SLOW_REQUEST_THRESHOLD␍
+␍
+    if is_slow:␍
+        logger.warning(␍
+            f"慢请求: {method} {simplified_path} -> {status_code} ({elapsed:.3f}s, 阈值: {SLOW_REQUEST_THRESHOLD}s)"␍
+        )␍
+␍
+␍
+@asynccontextmanager␍
+async def lifespan(app: FastAPI):␍
+    logger.info("Qihu-AIFlow v2.0.0 启动中...")␍
+␍
+    # 启动后台 Evolution Pipeline（知识库图谱已存在的用户配置自动恢复运行）␍
+    try:␍
+        from app.services.evolution_service import EvolutionWatcherManager␍
+        from app.models import UserEvolutionConfig␍
+        db = SessionLocal()␍
+        try:␍
+            configs = db.query(UserEvolutionConfig).filter(␍
+                UserEvolutionConfig.watcher_status == "running"␍
+            ).all()␍
+            if configs:␍
+                watcher = EvolutionWatcherManager()␍
+                for cfg in configs:␍
+                    try:␍
+                        watcher.start_user_evolution(cfg.user_id, lambda: SessionLocal())␍
+                        logger.info(f"[Evolution] 恢复用户 {cfg.user_id} 的进化Pipeline")␍
+                    except Exception as e:␍
+                        logger.warning(f"[Evolution] 恢复用户 {cfg.user_id} 失败: {e}")␍
+                logger.info(f"[Evolution] 已恢复 {len(configs)} 个用户的进化Pipeline")␍
+            else:␍
+                logger.info("[Evolution] 无待恢复的进化配置")␍
+        finally:␍
+            db.close()␍
+    except Exception as e:␍
+        logger.warning(f"[Evolution] Pipeline自动启动异常(不影响正常服务): {e}")␍
+␍
+    # 启动Redis事件总线␍
+    try:␍
+        from app.event_bus import get_event_bus␍
+        event_bus = get_event_bus()␍
+        event_bus.start(num_consumers=2)␍
+        logger.info("[EventBus] Redis事件总线已启动")␍
+    except Exception as e:␍
+        logger.warning(f"[EventBus] 启动失败(不影响正常服务): {e}")␍
+␍
+    logger.info("Qihu-AIFlow v2.0.0 启动完成")␍
+␍
+    yield␍
+␍
+    # 停止Redis事件总线␍
+    try:␍
+        from app.event_bus import get_event_bus␍
+        get_event_bus().stop()␍
+        logger.info("[EventBus] Redis事件总线已停止")␍
+    except Exception:␍
+        pass␍
+␍
+    # 优雅关闭：停止所有 Evolution Pipeline␍
+    try:␍
+        from app.services.evolution_service import EvolutionWatcherManager␍
+        EvolutionWatcherManager().shutdown_all()␍
+        logger.info("[Evolution] 所有Pipeline已停止")␍
+    except Exception:␍
+        pass␍
+␍
+    logger.info("Qihu-AIFlow 正在关闭...")␍
+␍
+␍
+app = FastAPI(␍
+    title="Qihu-AIFlow - 智能自动化PaaS平台",␍
+    version="1.0.0",␍
+    lifespan=lifespan,␍
+)␍
+␍
+# API调用追踪中间件␍
+app.add_middleware(APITrackingMiddleware)␍
+␍
+# CORS配置␍
+app.add_middleware(␍
+    CORSMiddleware,␍
+    allow_origins=["*"],␍
+    allow_credentials=True,␍
+    allow_methods=["*"],␍
+    allow_headers=["*"],␍
+)␍
+␍
+# 前台 API␍
+app.include_router(auth.router, prefix="/app/api/auth", tags=["认证"])␍
+app.include_router(chat.router, prefix="/app/api/chat", tags=["AI聊天"])␍
+app.include_router(channels.router, prefix="/app/api/channels", tags=["频道"])␍
+app.include_router(knowledge.router, prefix="/app/api/knowledge", tags=["知识库"])␍
+app.include_router(market.router, prefix="/app/api/market", tags=["应用市场"])␍
+app.include_router(token_usage.router, prefix="/app/api/token", tags=["Token驾驶舱"])␍
+app.include_router(payment.router, prefix="/app/api/payment", tags=["付费中心"])␍
+app.include_router(profile.router, prefix="/app/api/profile", tags=["个人中心"])␍
+app.include_router(notifications.router, prefix="/app/api/notifications", tags=["消息通知"])␍
+app.include_router(assets.router, prefix="/app/api/assets", tags=["资产管理"])␍
+app.include_router(evolution.router, prefix="/app/api/evolution", tags=["AI自进化"])␍
+␍
+# 后台 API␍
+app.include_router(dashboard.router, prefix="/app/api/admin/dashboard", tags=["后台-仪表盘"])␍
+app.include_router(users.router, prefix="/app/api/admin/users", tags=["后台-用户管理"])␍
+app.include_router(models.router, prefix="/app/api/admin/models", tags=["后台-模型管理"])␍
+app.include_router(settings.router, prefix="/app/api/admin/settings", tags=["后台-网站设置"])␍
+app.include_router(payment_admin.router, prefix="/app/api/admin/payment", tags=["后台-支付配置"])␍
+app.include_router(services.router, prefix="/app/api/admin/services", tags=["后台-增值服务"])␍
+app.include_router(membership_admin.router, prefix="/app/api/admin/membership", tags=["后台-会员管理"])␍
+app.include_router(ads.router, prefix="/app/api/admin/ads", tags=["后台-广告管理"])␍
+app.include_router(market_admin.router, prefix="/app/api/admin/market", tags=["后台-应用审核"])␍
+app.include_router(logs.router, prefix="/app/api/admin/logs", tags=["后台-日志风控"])␍
+app.include_router(skills_admin.router, prefix="/app/api/admin/skills", tags=["后台-技能管理"])␍
+␍
+␍
+@app.get("/app/api/health")␍
+async def health_check():␍
+    return {"status": "ok", "service": "Qihu-AIFlow"}␍