refactor: 改造 CI/CD 使用阿里云 ACR 镜像仓库

Co-authored-by: Cursor <cursoragent@cursor.com>

.drone.yml

@@ -1,6 +1,6 @@
 kind: pipeline
 type: docker
-name: build-and-deploy
+name: build-and-push
 
 trigger:
   branch:
@@ -10,88 +10,66 @@ trigger:
     - push
 
 steps:
-  # 构建后端镜像
+  # 构建并推送后端镜像
-  - name: build-backend
+  - name: build-push-backend
-    image: docker:dind
-    volumes:
-      - name: docker-sock
-        path: /var/run/docker.sock
-    commands:
-      - docker build -t platform-backend:${DRONE_COMMIT_SHA:0:8} -f deploy/Dockerfile.backend .
-      - docker tag platform-backend:${DRONE_COMMIT_SHA:0:8} platform-backend:latest
-
-  # 构建前端镜像（测试环境）
-  - name: build-frontend-test
-    image: docker:dind
-    volumes:
-      - name: docker-sock
-        path: /var/run/docker.sock
-    commands:
-      - docker build -t platform-frontend-test:${DRONE_COMMIT_SHA:0:8} -f deploy/Dockerfile.frontend --build-arg BACKEND_HOST=platform-backend-test .
-      - docker tag platform-frontend-test:${DRONE_COMMIT_SHA:0:8} platform-frontend-test:latest
-    when:
-      branch:
-        - develop
-
-  # 构建前端镜像（生产环境）
-  - name: build-frontend-prod
-    image: docker:dind
-    volumes:
-      - name: docker-sock
-        path: /var/run/docker.sock
-    commands:
-      - docker build -t platform-frontend-prod:${DRONE_COMMIT_SHA:0:8} -f deploy/Dockerfile.frontend --build-arg BACKEND_HOST=platform-backend-prod .
-      - docker tag platform-frontend-prod:${DRONE_COMMIT_SHA:0:8} platform-frontend-prod:latest
-    when:
-      branch:
-        - main
-
-  # 部署测试环境
-  - name: deploy-test
     image: docker:dind
     volumes:
       - name: docker-sock
         path: /var/run/docker.sock
     environment:
-      DATABASE_URL:
+      DOCKER_REGISTRY:
-        from_secret: database_url
+        from_secret: docker_registry
-      API_KEY:
+      DOCKER_USERNAME:
-        from_secret: api_key
+        from_secret: docker_username
-      JWT_SECRET:
+      DOCKER_PASSWORD:
-        from_secret: jwt_secret
+        from_secret: docker_password
-      CONFIG_ENCRYPT_KEY:
-        from_secret: config_encrypt_key
     commands:
-      - docker network create platform-network 2>/dev/null || true
+      - echo "$DOCKER_PASSWORD" | docker login "$DOCKER_REGISTRY" -u "$DOCKER_USERNAME" --password-stdin
-      - docker stop platform-backend-test platform-frontend-test || true
+      - docker build -t $DOCKER_REGISTRY/ireborn/platform-backend:${DRONE_BRANCH} -f deploy/Dockerfile.backend .
-      - docker rm platform-backend-test platform-frontend-test || true
+      - docker tag $DOCKER_REGISTRY/ireborn/platform-backend:${DRONE_BRANCH} $DOCKER_REGISTRY/ireborn/platform-backend:latest
-      - docker run -d --name platform-backend-test --network platform-network -p 8001:8000 --restart unless-stopped -e DATABASE_URL=$DATABASE_URL -e API_KEY=$API_KEY -e JWT_SECRET=$JWT_SECRET -e CONFIG_ENCRYPT_KEY=$CONFIG_ENCRYPT_KEY platform-backend:latest
+      - docker tag $DOCKER_REGISTRY/ireborn/platform-backend:${DRONE_BRANCH} $DOCKER_REGISTRY/ireborn/platform-backend:${DRONE_COMMIT_SHA:0:8}
-      - docker run -d --name platform-frontend-test --network platform-network -p 3003:80 --restart unless-stopped platform-frontend-test:latest
+      - docker push $DOCKER_REGISTRY/ireborn/platform-backend:${DRONE_BRANCH}
-    when:
+      - docker push $DOCKER_REGISTRY/ireborn/platform-backend:latest
-      branch:
+      - docker push $DOCKER_REGISTRY/ireborn/platform-backend:${DRONE_COMMIT_SHA:0:8}
-        - develop
 
-  # 部署生产环境（使用与测试相同的数据库配置）
+  # 构建并推送前端镜像（测试环境）
-  - name: deploy-prod
+  - name: build-push-frontend-test
     image: docker:dind
     volumes:
       - name: docker-sock
         path: /var/run/docker.sock
     environment:
-      DATABASE_URL:
+      DOCKER_REGISTRY:
-        from_secret: database_url
+        from_secret: docker_registry
-      API_KEY:
+      DOCKER_USERNAME:
-        from_secret: api_key
+        from_secret: docker_username
-      JWT_SECRET:
+      DOCKER_PASSWORD:
-        from_secret: jwt_secret
+        from_secret: docker_password
-      CONFIG_ENCRYPT_KEY:
-        from_secret: config_encrypt_key
     commands:
-      - docker network create platform-network-prod 2>/dev/null || true
+      - echo "$DOCKER_PASSWORD" | docker login "$DOCKER_REGISTRY" -u "$DOCKER_USERNAME" --password-stdin
-      - docker stop platform-backend-prod platform-frontend-prod || true
+      - docker build -t $DOCKER_REGISTRY/ireborn/platform-frontend:develop -f deploy/Dockerfile.frontend --build-arg BACKEND_HOST=platform-backend-test .
-      - docker rm platform-backend-prod platform-frontend-prod || true
+      - docker push $DOCKER_REGISTRY/ireborn/platform-frontend:develop
-      - docker run -d --name platform-backend-prod --network platform-network-prod -p 9001:8000 --restart unless-stopped -e DATABASE_URL=$DATABASE_URL -e API_KEY=$API_KEY -e JWT_SECRET=$JWT_SECRET -e CONFIG_ENCRYPT_KEY=$CONFIG_ENCRYPT_KEY platform-backend:latest
+    when:
-      - docker run -d --name platform-frontend-prod --network platform-network-prod -p 4003:80 --restart unless-stopped platform-frontend-prod:latest
+      branch:
+        - develop
+
+  # 构建并推送前端镜像（生产环境）
+  - name: build-push-frontend-prod
+    image: docker:dind
+    volumes:
+      - name: docker-sock
+        path: /var/run/docker.sock
+    environment:
+      DOCKER_REGISTRY:
+        from_secret: docker_registry
+      DOCKER_USERNAME:
+        from_secret: docker_username
+      DOCKER_PASSWORD:
+        from_secret: docker_password
+    commands:
+      - echo "$DOCKER_PASSWORD" | docker login "$DOCKER_REGISTRY" -u "$DOCKER_USERNAME" --password-stdin
+      - docker build -t $DOCKER_REGISTRY/ireborn/platform-frontend:main -f deploy/Dockerfile.frontend --build-arg BACKEND_HOST=platform-backend-prod .
+      - docker push $DOCKER_REGISTRY/ireborn/platform-frontend:main
     when:
       branch:
         - main

README.md

@@ -67,13 +67,21 @@ AgentWD/
 
 ---
 
-## 测试地址
+## 环境地址
 
-| 服务 | 测试环境 |
+| 服务 | 测试环境 | 生产环境 |
-|------|----------|
+|------|----------|----------|
-| 管理平台 | https://platform.test.ai.ireborn.com.cn/admin |
+| 管理平台 | http://47.107.172.23:3003 | http://47.107.172.23:4003 |
-| 工具集 | https://tools.test.ai.ireborn.com.cn |
+| 后端 API | http://47.107.172.23:8001 | http://47.107.172.23:9001 |
-| AI 面试 | https://interview.test.ai.ireborn.com.cn |
+
+---
+
+## 数据库配置
+
+| 环境 | 数据库 | Drone Secret |
+|------|--------|--------------|
+| 测试 | `new_qiqi` | `database_url` |
+| 生产 | `new_platform_prod` | `database_url_prod` |
 
 ---
 

backend/app/main.py

@@ -14,8 +14,13 @@ from .routers.wechat import router as wechat_router
 from .routers.alerts import router as alerts_router
 from .routers.cost import router as cost_router
 from .routers.quota import router as quota_router
+from .routers.tasks import router as tasks_router
+from .routers.notification_channels import router as notification_channels_router
+from .routers.tool_configs import router as tool_configs_router
+from .routers.ruimeiyun import router as ruimeiyun_router
 from .middleware import TraceMiddleware, setup_exception_handlers, RequestLoggerMiddleware
 from .middleware.trace import setup_logging
+from .services.scheduler import scheduler_service
 
 # 配置日志（包含 TraceID）
 setup_logging(level=logging.INFO, include_trace=True)
@@ -66,6 +71,23 @@ app.include_router(wechat_router, prefix="/api")
 app.include_router(alerts_router, prefix="/api")
 app.include_router(cost_router, prefix="/api")
 app.include_router(quota_router, prefix="/api")
+app.include_router(tasks_router)
+app.include_router(notification_channels_router)
+app.include_router(tool_configs_router, prefix="/api")
+app.include_router(ruimeiyun_router, prefix="/api")
+
+
+# 应用生命周期事件
+@app.on_event("startup")
+async def startup_event():
+    """应用启动时启动调度器"""
+    scheduler_service.start()
+
+
+@app.on_event("shutdown")
+async def shutdown_event():
+    """应用关闭时关闭调度器"""
+    scheduler_service.shutdown()
 
 
 @app.get("/")

backend/app/models/__init__.py

@@ -2,11 +2,14 @@
 from .tenant import Tenant, Subscription, Config
 from .tenant_app import TenantApp
 from .tenant_wechat_app import TenantWechatApp
+from .tool_config import ToolConfig
 from .app import App
 from .stats import AICallEvent, TenantUsageDaily
 from .logs import PlatformLog
 from .alert import AlertRule, AlertRecord, NotificationChannel
 from .pricing import ModelPricing, TenantBilling
+from .scheduled_task import ScheduledTask, TaskLog, ScriptVar, Secret
+from .notification_channel import TaskNotifyChannel
 
 __all__ = [
     "Tenant",
@@ -14,6 +17,7 @@ __all__ = [
     "Config",
     "TenantApp",
     "TenantWechatApp",
+    "ToolConfig",
     "App",
     "AICallEvent",
     "TenantUsageDaily",
@@ -22,5 +26,10 @@ __all__ = [
     "AlertRecord",
     "NotificationChannel",
     "ModelPricing",
-    "TenantBilling"
+    "TenantBilling",
+    "ScheduledTask",
+    "TaskLog",
+    "ScriptVar",
+    "Secret",
+    "TaskNotifyChannel"
 ]

backend/app/models/app.py

@@ -18,6 +18,11 @@ class App(Base):
     # [{"code": "brainstorm", "name": "头脑风暴", "path": "/brainstorm"}, ...]
     tools = Column(Text)
     
+    # 配置项定义（JSON 数组）- 定义租户可配置的参数
+    # [{"key": "industry", "label": "行业类型", "type": "radio", "options": [...], "default": "...", "required": false}, ...]
+    # type: text(文本) | radio(单选) | select(下拉多选) | switch(开关)
+    config_schema = Column(Text)
+    
     # 是否需要企微JS-SDK
     require_jssdk = Column(SmallInteger, default=0)  # 0-不需要 1-需要
     

backend/app/models/notification_channel.py

@@ -0,0 +1,21 @@
+"""任务通知渠道模型"""
+from datetime import datetime
+from sqlalchemy import Column, Integer, String, Enum, Boolean, DateTime
+from ..database import Base
+
+
+class TaskNotifyChannel(Base):
+    """任务通知渠道表（用于定时任务推送）"""
+    __tablename__ = "platform_task_notify_channels"
+    
+    id = Column(Integer, primary_key=True, autoincrement=True)
+    tenant_id = Column(String(50), nullable=False)
+    channel_name = Column(String(100), nullable=False)
+    channel_type = Column(Enum('dingtalk_bot', 'wecom_bot'), nullable=False)
+    webhook_url = Column(String(500), nullable=False)
+    sign_secret = Column(String(200))  # 钉钉加签密钥
+    description = Column(String(255))
+    is_enabled = Column(Boolean, default=True)
+    
+    created_at = Column(DateTime, default=datetime.now)
+    updated_at = Column(DateTime, default=datetime.now, onupdate=datetime.now)

backend/app/models/scheduled_task.py

@@ -0,0 +1,103 @@
+"""定时任务相关模型"""
+from datetime import datetime
+from sqlalchemy import Column, BigInteger, Integer, String, Text, Enum, SmallInteger, TIMESTAMP, DateTime, JSON, Boolean
+from ..database import Base
+
+
+class ScheduledTask(Base):
+    """定时任务表"""
+    __tablename__ = "platform_scheduled_tasks"
+    
+    id = Column(Integer, primary_key=True, autoincrement=True)
+    tenant_id = Column(String(50))
+    task_name = Column(String(100), nullable=False)
+    task_desc = Column(String(500))
+    
+    # 调度配置
+    schedule_type = Column(Enum('simple', 'cron'), nullable=False, default='simple')
+    time_points = Column(JSON)  # JSON数组 ["08:00", "12:00"]
+    cron_expression = Column(String(100))
+    timezone = Column(String(50), default='Asia/Shanghai')
+    
+    # 执行类型
+    execution_type = Column(Enum('webhook', 'script'), nullable=False, default='script')
+    
+    # Webhook配置
+    webhook_url = Column(String(500))
+    
+    # 脚本配置
+    script_content = Column(Text)
+    script_deps = Column(Text)  # 脚本依赖
+    
+    # 输入参数
+    input_params = Column(JSON)  # JSON格式
+    
+    # 重试配置
+    retry_count = Column(Integer, default=0)
+    retry_interval = Column(Integer, default=60)
+    
+    # 告警配置
+    alert_on_failure = Column(Boolean, default=False)
+    alert_webhook = Column(String(500))
+    
+    # 通知配置
+    notify_channels = Column(JSON)  # 通知渠道ID列表
+    notify_wecom_app_id = Column(Integer)  # 企微应用ID
+    
+    # 状态
+    is_enabled = Column(Boolean, default=True)
+    last_run_at = Column(DateTime)
+    last_run_status = Column(Enum('success', 'failed', 'running'))
+    last_run_message = Column(Text)
+    
+    created_at = Column(DateTime, default=datetime.now)
+    updated_at = Column(DateTime, default=datetime.now, onupdate=datetime.now)
+
+
+class TaskLog(Base):
+    """任务执行日志"""
+    __tablename__ = "platform_task_logs"
+    
+    id = Column(BigInteger, primary_key=True, autoincrement=True)
+    task_id = Column(Integer, nullable=False)
+    tenant_id = Column(String(50))
+    trace_id = Column(String(100))
+    
+    status = Column(Enum('running', 'success', 'failed'), nullable=False)
+    started_at = Column(DateTime, nullable=False)
+    finished_at = Column(DateTime)
+    duration_ms = Column(Integer)
+    
+    output = Column(Text)
+    error = Column(Text)
+    retry_count = Column(Integer, default=0)
+    
+    created_at = Column(TIMESTAMP, default=datetime.now)
+
+
+class ScriptVar(Base):
+    """脚本变量存储"""
+    __tablename__ = "platform_script_vars"
+    
+    id = Column(Integer, primary_key=True, autoincrement=True)
+    task_id = Column(Integer, nullable=False)
+    tenant_id = Column(String(50))
+    var_key = Column(String(100), nullable=False)
+    var_value = Column(Text)  # JSON格式
+    
+    created_at = Column(TIMESTAMP, default=datetime.now)
+    updated_at = Column(TIMESTAMP, default=datetime.now, onupdate=datetime.now)
+
+
+class Secret(Base):
+    """密钥管理"""
+    __tablename__ = "platform_secrets"
+    
+    id = Column(Integer, primary_key=True, autoincrement=True)
+    tenant_id = Column(String(50))  # NULL为全局
+    secret_key = Column(String(100), nullable=False)
+    secret_value = Column(Text, nullable=False)
+    description = Column(String(255))
+    
+    created_at = Column(TIMESTAMP, default=datetime.now)
+    updated_at = Column(TIMESTAMP, default=datetime.now, onupdate=datetime.now)

backend/app/models/tenant_app.py

@@ -23,6 +23,10 @@ class TenantApp(Base):
     # 功能权限
     allowed_tools = Column(Text)  # JSON 数组
     
+    # 自定义配置（JSON 数组）
+    # [{"key": "industry", "value": "medical_beauty", "remark": "医美行业"}, ...]
+    custom_configs = Column(Text)
+    
     status = Column(SmallInteger, default=1)
     created_at = Column(TIMESTAMP, default=datetime.now)
     updated_at = Column(TIMESTAMP, default=datetime.now, onupdate=datetime.now)

backend/app/models/tool_config.py

@@ -0,0 +1,21 @@
+"""租户工具配置模型"""
+from datetime import datetime
+from sqlalchemy import Column, Integer, String, Text, SmallInteger, TIMESTAMP
+from ..database import Base
+
+
+class ToolConfig(Base):
+    """租户工具配置表"""
+    __tablename__ = "platform_tool_configs"
+    
+    id = Column(Integer, primary_key=True, autoincrement=True)
+    tenant_id = Column(String(50), nullable=False, comment="租户ID")
+    tool_code = Column(String(50), nullable=True, comment="工具代码（NULL 表示租户级共享配置）")
+    config_type = Column(String(30), nullable=False, comment="配置类型：datasource / jssdk / webhook / params")
+    config_key = Column(String(100), nullable=False, comment="配置键名")
+    config_value = Column(Text, comment="配置值（明文或加密）")
+    is_encrypted = Column(SmallInteger, default=0, comment="是否加密存储")
+    description = Column(String(255), comment="配置说明")
+    status = Column(SmallInteger, default=1)
+    created_at = Column(TIMESTAMP, default=datetime.now)
+    updated_at = Column(TIMESTAMP, default=datetime.now, onupdate=datetime.now)

backend/app/routers/apps.py

@@ -23,6 +23,18 @@ class ToolItem(BaseModel):
     path: str
 
 
+class ConfigSchemaItem(BaseModel):
+    """配置项定义"""
+    key: str  # 配置键
+    label: str  # 显示标签
+    type: str  # text | radio | select | switch
+    options: Optional[List[str]] = None  # radio/select 的选项值
+    option_labels: Optional[dict] = None  # 选项显示名称 {"value": "显示名"}
+    default: Optional[str] = None  # 默认值
+    placeholder: Optional[str] = None  # 输入提示（text类型）
+    required: bool = False  # 是否必填
+
+
 class AppCreate(BaseModel):
     """创建应用"""
     app_code: str
@@ -30,6 +42,7 @@ class AppCreate(BaseModel):
     base_url: Optional[str] = None
     description: Optional[str] = None
     tools: Optional[List[ToolItem]] = None
+    config_schema: Optional[List[ConfigSchemaItem]] = None
     require_jssdk: bool = False
 
 
@@ -39,6 +52,7 @@ class AppUpdate(BaseModel):
     base_url: Optional[str] = None
     description: Optional[str] = None
     tools: Optional[List[ToolItem]] = None
+    config_schema: Optional[List[ConfigSchemaItem]] = None
     require_jssdk: Optional[bool] = None
     status: Optional[int] = None
 
@@ -55,7 +69,7 @@ class GenerateUrlRequest(BaseModel):
 @router.get("")
 async def list_apps(
     page: int = Query(1, ge=1),
-    size: int = Query(20, ge=1, le=100),
+    size: int = Query(20, ge=1, le=1000),
     status: Optional[int] = None,
     user: User = Depends(get_current_user),
     db: Session = Depends(get_db)
@@ -119,6 +133,7 @@ async def create_app(
         base_url=data.base_url,
         description=data.description,
         tools=json.dumps([t.model_dump() for t in data.tools], ensure_ascii=False) if data.tools else None,
+        config_schema=json.dumps([c.model_dump() for c in data.config_schema], ensure_ascii=False) if data.config_schema else None,
         require_jssdk=1 if data.require_jssdk else 0,
         status=1
     )
@@ -150,6 +165,13 @@ async def update_app(
         else:
             update_data['tools'] = None
     
+    # 处理 config_schema JSON
+    if 'config_schema' in update_data:
+        if update_data['config_schema']:
+            update_data['config_schema'] = json.dumps([c.model_dump() if hasattr(c, 'model_dump') else c for c in update_data['config_schema']], ensure_ascii=False)
+        else:
+            update_data['config_schema'] = None
+    
     # 处理 require_jssdk
     if 'require_jssdk' in update_data:
         update_data['require_jssdk'] = 1 if update_data['require_jssdk'] else 0
@@ -259,6 +281,21 @@ async def get_app_tools(
     return tools
 
 
+@router.get("/{app_code}/config-schema")
+async def get_app_config_schema(
+    app_code: str,
+    user: User = Depends(get_current_user),
+    db: Session = Depends(get_db)
+):
+    """获取应用的配置项定义（用于租户订阅时渲染表单）"""
+    app = db.query(App).filter(App.app_code == app_code).first()
+    if not app:
+        raise HTTPException(status_code=404, detail="应用不存在")
+    
+    config_schema = json.loads(app.config_schema) if app.config_schema else []
+    return config_schema
+
+
 def format_app(app: App) -> dict:
     """格式化应用数据"""
     return {
@@ -268,6 +305,7 @@ def format_app(app: App) -> dict:
         "base_url": app.base_url,
         "description": app.description,
         "tools": json.loads(app.tools) if app.tools else [],
+        "config_schema": json.loads(app.config_schema) if app.config_schema else [],
         "require_jssdk": bool(app.require_jssdk),
         "status": app.status,
         "created_at": app.created_at,

backend/app/routers/notification_channels.py

@@ -0,0 +1,211 @@
+"""通知渠道API路由"""
+from typing import Optional, List
+from fastapi import APIRouter, Depends, HTTPException, Query
+from pydantic import BaseModel
+from sqlalchemy.orm import Session
+from sqlalchemy import desc
+
+from ..database import get_db
+from ..models.notification_channel import TaskNotifyChannel
+
+
+router = APIRouter(prefix="/api/notification-channels", tags=["notification-channels"])
+
+
+# ==================== Schemas ====================
+
+class ChannelCreate(BaseModel):
+    tenant_id: str
+    channel_name: str
+    channel_type: str  # dingtalk_bot, wecom_bot
+    webhook_url: str
+    sign_secret: Optional[str] = None  # 钉钉加签密钥
+    description: Optional[str] = None
+
+
+class ChannelUpdate(BaseModel):
+    channel_name: Optional[str] = None
+    channel_type: Optional[str] = None
+    webhook_url: Optional[str] = None
+    sign_secret: Optional[str] = None
+    description: Optional[str] = None
+    is_enabled: Optional[bool] = None
+
+
+# ==================== CRUD ====================
+
+@router.get("")
+async def list_channels(
+    tenant_id: Optional[str] = None,
+    channel_type: Optional[str] = None,
+    is_enabled: Optional[bool] = None,
+    page: int = Query(1, ge=1),
+    size: int = Query(50, ge=1, le=100),
+    db: Session = Depends(get_db)
+):
+    """获取通知渠道列表"""
+    query = db.query(TaskNotifyChannel)
+    
+    if tenant_id:
+        query = query.filter(TaskNotifyChannel.tenant_id == tenant_id)
+    if channel_type:
+        query = query.filter(TaskNotifyChannel.channel_type == channel_type)
+    if is_enabled is not None:
+        query = query.filter(TaskNotifyChannel.is_enabled == is_enabled)
+    
+    total = query.count()
+    items = query.order_by(desc(TaskNotifyChannel.created_at)).offset((page - 1) * size).limit(size).all()
+    
+    return {
+        "total": total,
+        "items": [format_channel(c) for c in items]
+    }
+
+
+@router.get("/{channel_id}")
+async def get_channel(channel_id: int, db: Session = Depends(get_db)):
+    """获取渠道详情"""
+    channel = db.query(TaskNotifyChannel).filter(TaskNotifyChannel.id == channel_id).first()
+    if not channel:
+        raise HTTPException(status_code=404, detail="渠道不存在")
+    return format_channel(channel)
+
+
+@router.post("")
+async def create_channel(data: ChannelCreate, db: Session = Depends(get_db)):
+    """创建通知渠道"""
+    channel = TaskNotifyChannel(
+        tenant_id=data.tenant_id,
+        channel_name=data.channel_name,
+        channel_type=data.channel_type,
+        webhook_url=data.webhook_url,
+        sign_secret=data.sign_secret,
+        description=data.description,
+        is_enabled=True
+    )
+    
+    db.add(channel)
+    db.commit()
+    db.refresh(channel)
+    
+    return {"success": True, "id": channel.id}
+
+
+@router.put("/{channel_id}")
+async def update_channel(channel_id: int, data: ChannelUpdate, db: Session = Depends(get_db)):
+    """更新通知渠道"""
+    channel = db.query(TaskNotifyChannel).filter(TaskNotifyChannel.id == channel_id).first()
+    if not channel:
+        raise HTTPException(status_code=404, detail="渠道不存在")
+    
+    if data.channel_name is not None:
+        channel.channel_name = data.channel_name
+    if data.channel_type is not None:
+        channel.channel_type = data.channel_type
+    if data.webhook_url is not None:
+        channel.webhook_url = data.webhook_url
+    if data.sign_secret is not None:
+        channel.sign_secret = data.sign_secret
+    if data.description is not None:
+        channel.description = data.description
+    if data.is_enabled is not None:
+        channel.is_enabled = data.is_enabled
+    
+    db.commit()
+    return {"success": True}
+
+
+@router.delete("/{channel_id}")
+async def delete_channel(channel_id: int, db: Session = Depends(get_db)):
+    """删除通知渠道"""
+    channel = db.query(TaskNotifyChannel).filter(TaskNotifyChannel.id == channel_id).first()
+    if not channel:
+        raise HTTPException(status_code=404, detail="渠道不存在")
+    
+    db.delete(channel)
+    db.commit()
+    return {"success": True}
+
+
+@router.post("/{channel_id}/test")
+async def test_channel(channel_id: int, db: Session = Depends(get_db)):
+    """测试通知渠道"""
+    import httpx
+    import time
+    import hmac
+    import hashlib
+    import base64
+    import urllib.parse
+    
+    channel = db.query(TaskNotifyChannel).filter(TaskNotifyChannel.id == channel_id).first()
+    if not channel:
+        raise HTTPException(status_code=404, detail="渠道不存在")
+    
+    test_content = f"**测试消息**\n\n渠道名称: {channel.channel_name}\n发送时间: 测试中..."
+    
+    try:
+        url = channel.webhook_url
+        
+        if channel.channel_type == 'dingtalk_bot':
+            # 钉钉加签
+            if channel.sign_secret:
+                timestamp = str(round(time.time() * 1000))
+                string_to_sign = f'{timestamp}\n{channel.sign_secret}'
+                hmac_code = hmac.new(
+                    channel.sign_secret.encode('utf-8'), 
+                    string_to_sign.encode('utf-8'), 
+                    digestmod=hashlib.sha256
+                ).digest()
+                sign = urllib.parse.quote_plus(base64.b64encode(hmac_code))
+                
+                # 拼接签名参数
+                if '?' in url:
+                    url = f"{url}&timestamp={timestamp}&sign={sign}"
+                else:
+                    url = f"{url}?timestamp={timestamp}&sign={sign}"
+            
+            payload = {
+                "msgtype": "markdown",
+                "markdown": {
+                    "title": "渠道测试",
+                    "text": test_content
+                }
+            }
+        else:  # wecom_bot
+            payload = {
+                "msgtype": "markdown",
+                "markdown": {
+                    "content": test_content
+                }
+            }
+        
+        async with httpx.AsyncClient(timeout=10) as client:
+            response = await client.post(url, json=payload)
+            result = response.json()
+            
+            # 钉钉返回 errcode=0，企微返回 errcode=0
+            if result.get('errcode') == 0:
+                return {"success": True, "message": "发送成功"}
+            else:
+                return {"success": False, "message": f"发送失败: {result}"}
+    
+    except Exception as e:
+        return {"success": False, "message": f"发送失败: {str(e)}"}
+
+
+# ==================== Helpers ====================
+
+def format_channel(channel: TaskNotifyChannel) -> dict:
+    """格式化渠道数据"""
+    return {
+        "id": channel.id,
+        "tenant_id": channel.tenant_id,
+        "channel_name": channel.channel_name,
+        "channel_type": channel.channel_type,
+        "webhook_url": channel.webhook_url,
+        "sign_secret": channel.sign_secret,
+        "description": channel.description,
+        "is_enabled": channel.is_enabled,
+        "created_at": channel.created_at,
+        "updated_at": channel.updated_at
+    }

backend/app/routers/ruimeiyun.py

@@ -0,0 +1,287 @@
+"""
+睿美云代理路由
+
+提供统一的睿美云接口代理能力，支持：
+- 多租户配置隔离
+- 接口权限控制
+- 统一日志记录
+- 错误处理
+"""
+
+import logging
+from typing import Optional, Dict, Any, List
+from fastapi import APIRouter, Depends, HTTPException, Query
+from pydantic import BaseModel
+from sqlalchemy.orm import Session
+
+from ..database import get_db
+from ..services.ruimeiyun import RuimeiyunClient, RUIMEIYUN_APIS, get_api_definition
+from ..services.ruimeiyun.client import RuimeiyunError
+from ..services.ruimeiyun.registry import get_all_modules, get_api_list_by_module, get_api_summary
+from .auth import get_current_user
+from ..models.user import User
+
+logger = logging.getLogger(__name__)
+
+router = APIRouter(prefix="/ruimeiyun", tags=["睿美云代理"])
+
+
+# ========================================
+# Schemas
+# ========================================
+
+class RuimeiyunCallRequest(BaseModel):
+    """睿美云接口调用请求"""
+    params: Optional[Dict[str, Any]] = None  # URL 参数
+    body: Optional[Dict[str, Any]] = None    # 请求体
+
+
+class RuimeiyunRawCallRequest(BaseModel):
+    """睿美云原始接口调用请求"""
+    method: str  # HTTP 方法
+    path: str    # API 路径
+    params: Optional[Dict[str, Any]] = None
+    body: Optional[Dict[str, Any]] = None
+
+
+# ========================================
+# API Endpoints
+# ========================================
+
+@router.post("/call/{api_name}")
+async def call_ruimeiyun_api(
+    api_name: str,
+    request: RuimeiyunCallRequest,
+    tenant_id: str = Query(..., description="租户ID"),
+    user: User = Depends(get_current_user),
+    db: Session = Depends(get_db)
+):
+    """
+    调用睿美云接口（通过接口名称）
+    
+    Args:
+        api_name: 接口名称，如 customer.search, order.list
+        request: 请求参数
+        tenant_id: 租户ID
+        
+    Returns:
+        睿美云接口返回的数据
+        
+    示例:
+        POST /api/ruimeiyun/call/customer.search?tenant_id=xxx
+        Body: {"params": {"keyword": "13800138000", "page": 1, "size": 20}}
+    """
+    try:
+        client = RuimeiyunClient(tenant_id, db)
+        result = await client.call(
+            api_name=api_name,
+            params=request.params,
+            body=request.body
+        )
+        
+        if result.success:
+            return {
+                "success": True,
+                "data": result.data
+            }
+        else:
+            return {
+                "success": False,
+                "error": result.error,
+                "raw": result.raw_response
+            }
+            
+    except RuimeiyunError as e:
+        logger.error(f"睿美云调用失败: {api_name}, {e}")
+        raise HTTPException(status_code=e.status_code, detail=str(e))
+    except Exception as e:
+        logger.exception(f"睿美云调用异常: {api_name}")
+        raise HTTPException(status_code=500, detail=f"调用失败: {str(e)}")
+
+
+@router.post("/call-raw")
+async def call_ruimeiyun_raw(
+    request: RuimeiyunRawCallRequest,
+    tenant_id: str = Query(..., description="租户ID"),
+    user: User = Depends(get_current_user),
+    db: Session = Depends(get_db)
+):
+    """
+    直接调用睿美云接口（通过路径）
+    
+    用于调用未在注册表中定义的接口
+    
+    Args:
+        request: 请求参数（包含 method, path, params, body）
+        tenant_id: 租户ID
+        
+    Returns:
+        睿美云接口返回的数据
+        
+    示例:
+        POST /api/ruimeiyun/call-raw?tenant_id=xxx
+        Body: {
+            "method": "GET",
+            "path": "/api/v1/tpos/customer/customer-search",
+            "params": {"keyword": "13800138000"}
+        }
+    """
+    try:
+        client = RuimeiyunClient(tenant_id, db)
+        result = await client.call_raw(
+            method=request.method,
+            path=request.path,
+            params=request.params,
+            body=request.body
+        )
+        
+        if result.success:
+            return {
+                "success": True,
+                "data": result.data
+            }
+        else:
+            return {
+                "success": False,
+                "error": result.error,
+                "raw": result.raw_response
+            }
+            
+    except RuimeiyunError as e:
+        logger.error(f"睿美云调用失败: {request.path}, {e}")
+        raise HTTPException(status_code=e.status_code, detail=str(e))
+    except Exception as e:
+        logger.exception(f"睿美云调用异常: {request.path}")
+        raise HTTPException(status_code=500, detail=f"调用失败: {str(e)}")
+
+
+# ========================================
+# 接口元数据
+# ========================================
+
+@router.get("/apis")
+async def list_apis(
+    module: Optional[str] = None,
+    user: User = Depends(get_current_user)
+):
+    """
+    获取可用的接口列表
+    
+    Args:
+        module: 模块名称（可选），如 customer, order
+        
+    Returns:
+        接口列表
+    """
+    if module:
+        apis = get_api_list_by_module(module)
+        return {
+            "module": module,
+            "count": len(apis),
+            "apis": apis
+        }
+    else:
+        return {
+            "count": len(RUIMEIYUN_APIS),
+            "summary": get_api_summary(),
+            "apis": RUIMEIYUN_APIS
+        }
+
+
+@router.get("/apis/{api_name}")
+async def get_api_info(
+    api_name: str,
+    user: User = Depends(get_current_user)
+):
+    """
+    获取接口详情
+    
+    Args:
+        api_name: 接口名称，如 customer.search
+        
+    Returns:
+        接口定义
+    """
+    api_def = get_api_definition(api_name)
+    if not api_def:
+        raise HTTPException(status_code=404, detail=f"接口不存在: {api_name}")
+    
+    return {
+        "name": api_name,
+        **api_def
+    }
+
+
+@router.get("/modules")
+async def list_modules(
+    user: User = Depends(get_current_user)
+):
+    """
+    获取所有模块列表
+    
+    Returns:
+        模块名称列表和每个模块的接口数量
+    """
+    modules = get_all_modules()
+    summary = get_api_summary()
+    
+    return {
+        "modules": [
+            {"name": m, "count": summary.get(m, 0)}
+            for m in modules
+        ]
+    }
+
+
+# ========================================
+# 健康检查
+# ========================================
+
+@router.get("/health/{tenant_id}")
+async def check_ruimeiyun_health(
+    tenant_id: str,
+    user: User = Depends(get_current_user),
+    db: Session = Depends(get_db)
+):
+    """
+    检查租户的睿美云连接状态
+    
+    Args:
+        tenant_id: 租户ID
+        
+    Returns:
+        连接状态信息
+    """
+    try:
+        client = RuimeiyunClient(tenant_id, db)
+        
+        # 调用门店列表接口测试连接
+        result = await client.call("tenant.list")
+        
+        if result.success:
+            return {
+                "status": "connected",
+                "tenant_id": tenant_id,
+                "base_url": client.config.base_url,
+                "account": client.config.account,
+                "message": "连接正常"
+            }
+        else:
+            return {
+                "status": "error",
+                "tenant_id": tenant_id,
+                "message": result.error
+            }
+            
+    except RuimeiyunError as e:
+        return {
+            "status": "error",
+            "tenant_id": tenant_id,
+            "message": str(e)
+        }
+    except Exception as e:
+        return {
+            "status": "error",
+            "tenant_id": tenant_id,
+            "message": f"检查失败: {str(e)}"
+        }

backend/app/routers/stats.py

@@ -7,7 +7,7 @@ from sqlalchemy import func
 
 from ..database import get_db
 from ..config import get_settings
-from ..models.stats import AICallEvent
+from ..models.stats import AICallEvent, TenantUsageDaily
 from ..schemas.stats import AICallEventCreate, AICallEventResponse, BatchReportRequest
 from ..services.auth import decode_token
 
@@ -131,3 +131,42 @@ async def get_stats_trend(
         current += timedelta(days=1)
     
     return {"trend": trend}
+
+
+@router.get("/daily")
+async def get_daily_stats(
+    tenant_id: Optional[str] = None,
+    app_code: Optional[str] = None,
+    start_date: Optional[str] = None,
+    end_date: Optional[str] = None,
+    db: Session = Depends(get_db),
+    user = Depends(get_current_user_optional)
+):
+    """获取每日统计数据"""
+    query = db.query(TenantUsageDaily)
+    
+    if tenant_id:
+        query = query.filter(TenantUsageDaily.tenant_id == tenant_id)
+    if app_code:
+        query = query.filter(TenantUsageDaily.app_code == app_code)
+    if start_date:
+        query = query.filter(TenantUsageDaily.stat_date >= start_date)
+    if end_date:
+        query = query.filter(TenantUsageDaily.stat_date <= end_date)
+    
+    results = query.order_by(TenantUsageDaily.stat_date.desc()).all()
+    
+    return {
+        "items": [
+            {
+                "id": r.id,
+                "tenant_id": r.tenant_id,
+                "app_code": r.app_code,
+                "stat_date": str(r.stat_date) if r.stat_date else None,
+                "ai_calls": r.ai_calls or 0,
+                "ai_tokens": r.ai_tokens or 0,
+                "ai_cost": float(r.ai_cost) if r.ai_cost else 0.0
+            }
+            for r in results
+        ]
+    }

backend/app/routers/tasks.py

@@ -0,0 +1,559 @@
+"""定时任务API路由"""
+import json
+from datetime import datetime
+from typing import Optional, List
+from fastapi import APIRouter, Depends, HTTPException, Query, BackgroundTasks
+from pydantic import BaseModel
+from sqlalchemy.orm import Session
+from sqlalchemy import desc
+
+from ..database import get_db
+from ..models.scheduled_task import ScheduledTask, TaskLog, Secret
+from ..services.scheduler import scheduler_service
+from ..services.script_executor import ScriptExecutor
+
+
+router = APIRouter(prefix="/api/scheduled-tasks", tags=["scheduled-tasks"])
+
+
+# ==================== Schemas ====================
+
+class TaskCreate(BaseModel):
+    tenant_id: Optional[str] = None
+    task_name: str
+    task_desc: Optional[str] = None
+    execution_type: str = 'script'
+    schedule_type: str = 'simple'
+    time_points: Optional[List[str]] = None
+    cron_expression: Optional[str] = None
+    webhook_url: Optional[str] = None
+    script_content: Optional[str] = None
+    input_params: Optional[dict] = None
+    retry_count: Optional[int] = 0
+    retry_interval: Optional[int] = 60
+    alert_on_failure: Optional[bool] = False
+    alert_webhook: Optional[str] = None
+    notify_channels: Optional[List[int]] = None  # 通知渠道ID列表
+    notify_wecom_app_id: Optional[int] = None  # 企微应用ID
+
+
+class TaskUpdate(BaseModel):
+    tenant_id: Optional[str] = None
+    task_name: Optional[str] = None
+    task_desc: Optional[str] = None
+    execution_type: Optional[str] = None
+    schedule_type: Optional[str] = None
+    time_points: Optional[List[str]] = None
+    cron_expression: Optional[str] = None
+    webhook_url: Optional[str] = None
+    script_content: Optional[str] = None
+    input_params: Optional[dict] = None
+    retry_count: Optional[int] = None
+    retry_interval: Optional[int] = None
+    alert_on_failure: Optional[bool] = None
+    alert_webhook: Optional[str] = None
+    is_enabled: Optional[bool] = None
+    notify_channels: Optional[List[int]] = None
+    notify_wecom_app_id: Optional[int] = None
+
+
+class SecretCreate(BaseModel):
+    tenant_id: Optional[str] = None
+    secret_key: str
+    secret_value: str
+    description: Optional[str] = None
+
+
+class SecretUpdate(BaseModel):
+    secret_value: Optional[str] = None
+    description: Optional[str] = None
+
+
+class TestScriptRequest(BaseModel):
+    script_content: str
+    tenant_id: Optional[str] = None
+    params: Optional[dict] = None
+
+
+# ==================== Static Routes (must be before dynamic routes) ====================
+
+@router.get("/sdk-docs")
+async def get_sdk_docs():
+    """获取SDK文档"""
+    return {
+        "functions": [
+            {
+                "name": "log",
+                "signature": "log(message: str, level: str = 'INFO')",
+                "description": "记录日志",
+                "example": "log('处理完成', 'INFO')"
+            },
+            {
+                "name": "print",
+                "signature": "print(*args)",
+                "description": "打印输出",
+                "example": "print('Hello', 'World')"
+            },
+            {
+                "name": "ai",
+                "signature": "ai(prompt: str, system: str = None, model: str = None, temperature: float = 0.7)",
+                "description": "调用AI模型",
+                "example": "result = ai('生成一段问候语', system='你是友善的助手')"
+            },
+            {
+                "name": "dingtalk",
+                "signature": "dingtalk(webhook: str, content: str, title: str = None, at_all: bool = False)",
+                "description": "发送钉钉消息",
+                "example": "dingtalk(webhook_url, '# 标题\\n内容')"
+            },
+            {
+                "name": "wecom",
+                "signature": "wecom(webhook: str, content: str, msg_type: str = 'markdown')",
+                "description": "发送企微消息",
+                "example": "wecom(webhook_url, '消息内容')"
+            },
+            {
+                "name": "http_get",
+                "signature": "http_get(url: str, headers: dict = None, params: dict = None)",
+                "description": "发起GET请求",
+                "example": "resp = http_get('https://api.example.com/data')"
+            },
+            {
+                "name": "http_post",
+                "signature": "http_post(url: str, data: any = None, headers: dict = None)",
+                "description": "发起POST请求",
+                "example": "resp = http_post('https://api.example.com/submit', {'key': 'value'})"
+            },
+            {
+                "name": "db_query",
+                "signature": "db_query(sql: str, params: dict = None)",
+                "description": "执行只读SQL查询",
+                "example": "rows = db_query('SELECT * FROM users WHERE status = :status', {'status': 1})"
+            },
+            {
+                "name": "get_var",
+                "signature": "get_var(key: str, default: any = None)",
+                "description": "获取持久化变量",
+                "example": "counter = get_var('counter', 0)"
+            },
+            {
+                "name": "set_var",
+                "signature": "set_var(key: str, value: any)",
+                "description": "设置持久化变量",
+                "example": "set_var('counter', counter + 1)"
+            },
+            {
+                "name": "del_var",
+                "signature": "del_var(key: str)",
+                "description": "删除持久化变量",
+                "example": "del_var('temp_data')"
+            },
+            {
+                "name": "get_param",
+                "signature": "get_param(key: str, default: any = None)",
+                "description": "获取任务参数",
+                "example": "prompt = get_param('prompt', '默认提示词')"
+            },
+            {
+                "name": "get_params",
+                "signature": "get_params()",
+                "description": "获取所有任务参数",
+                "example": "params = get_params()"
+            },
+            {
+                "name": "get_tenants",
+                "signature": "get_tenants(app_code: str = None)",
+                "description": "获取租户列表",
+                "example": "tenants = get_tenants('notification-service')"
+            },
+            {
+                "name": "get_tenant_config",
+                "signature": "get_tenant_config(tenant_id: str, app_code: str, key: str = None)",
+                "description": "获取租户的应用配置",
+                "example": "webhook = get_tenant_config('tenant1', 'notification-service', 'dingtalk_webhook')"
+            },
+            {
+                "name": "get_all_tenant_configs",
+                "signature": "get_all_tenant_configs(app_code: str)",
+                "description": "获取所有租户的应用配置",
+                "example": "configs = get_all_tenant_configs('notification-service')"
+            },
+            {
+                "name": "get_secret",
+                "signature": "get_secret(key: str)",
+                "description": "获取密钥（优先租户级）",
+                "example": "api_key = get_secret('api_key')"
+            }
+        ],
+        "variables": [
+            {"name": "task_id", "description": "当前任务ID"},
+            {"name": "tenant_id", "description": "当前租户ID"},
+            {"name": "trace_id", "description": "当前执行追踪ID"}
+        ],
+        "libraries": [
+            {"name": "json", "description": "JSON处理"},
+            {"name": "re", "description": "正则表达式"},
+            {"name": "math", "description": "数学函数"},
+            {"name": "random", "description": "随机数"},
+            {"name": "hashlib", "description": "哈希函数"},
+            {"name": "base64", "description": "Base64编解码"},
+            {"name": "datetime", "description": "日期时间处理"},
+            {"name": "timedelta", "description": "时间差"},
+            {"name": "urlencode/quote/unquote", "description": "URL编码"}
+        ]
+    }
+
+
+@router.post("/test-script")
+async def test_script(data: TestScriptRequest, db: Session = Depends(get_db)):
+    """测试脚本执行"""
+    executor = ScriptExecutor(db)
+    result = executor.test_script(
+        script_content=data.script_content,
+        task_id=0,
+        tenant_id=data.tenant_id,
+        params=data.params
+    )
+    return result
+
+
+@router.get("/secrets")
+async def list_secrets(
+    tenant_id: Optional[str] = None,
+    db: Session = Depends(get_db)
+):
+    """获取密钥列表"""
+    query = db.query(Secret)
+    if tenant_id:
+        query = query.filter(Secret.tenant_id == tenant_id)
+    
+    items = query.order_by(desc(Secret.created_at)).all()
+    
+    return {
+        "items": [
+            {
+                "id": s.id,
+                "tenant_id": s.tenant_id,
+                "secret_key": s.secret_key,
+                "description": s.description,
+                "created_at": s.created_at,
+                "updated_at": s.updated_at
+            }
+            for s in items
+        ]
+    }
+
+
+@router.post("/secrets")
+async def create_secret(data: SecretCreate, db: Session = Depends(get_db)):
+    """创建密钥"""
+    secret = Secret(
+        tenant_id=data.tenant_id,
+        secret_key=data.secret_key,
+        secret_value=data.secret_value,
+        description=data.description
+    )
+    db.add(secret)
+    db.commit()
+    db.refresh(secret)
+    
+    return {"success": True, "id": secret.id}
+
+
+# ==================== Task CRUD ====================
+
+@router.get("")
+async def list_tasks(
+    tenant_id: Optional[str] = None,
+    status: Optional[int] = None,
+    page: int = Query(1, ge=1),
+    size: int = Query(20, ge=1, le=100),
+    db: Session = Depends(get_db)
+):
+    """获取任务列表"""
+    query = db.query(ScheduledTask)
+    
+    if tenant_id:
+        query = query.filter(ScheduledTask.tenant_id == tenant_id)
+    if status is not None:
+        is_enabled = status == 1
+        query = query.filter(ScheduledTask.is_enabled == is_enabled)
+    
+    total = query.count()
+    items = query.order_by(desc(ScheduledTask.created_at)).offset((page - 1) * size).limit(size).all()
+    
+    return {
+        "total": total,
+        "items": [format_task(t) for t in items]
+    }
+
+
+@router.get("/{task_id}")
+async def get_task(task_id: int, db: Session = Depends(get_db)):
+    """获取任务详情"""
+    task = db.query(ScheduledTask).filter(ScheduledTask.id == task_id).first()
+    if not task:
+        raise HTTPException(status_code=404, detail="任务不存在")
+    return format_task(task, include_content=True)
+
+
+@router.post("")
+async def create_task(data: TaskCreate, db: Session = Depends(get_db)):
+    """创建任务"""
+    task = ScheduledTask(
+        tenant_id=data.tenant_id,
+        task_name=data.task_name,
+        task_desc=data.task_desc,
+        execution_type=data.execution_type,
+        schedule_type=data.schedule_type,
+        time_points=data.time_points,
+        cron_expression=data.cron_expression,
+        webhook_url=data.webhook_url,
+        script_content=data.script_content,
+        input_params=data.input_params,
+        retry_count=data.retry_count,
+        retry_interval=data.retry_interval,
+        alert_on_failure=data.alert_on_failure,
+        alert_webhook=data.alert_webhook,
+        notify_channels=data.notify_channels,
+        notify_wecom_app_id=data.notify_wecom_app_id,
+        is_enabled=True
+    )
+    
+    db.add(task)
+    db.commit()
+    db.refresh(task)
+    
+    # 添加到调度器
+    scheduler_service.add_task(task.id)
+    
+    return {"success": True, "id": task.id}
+
+
+@router.put("/{task_id}")
+async def update_task(task_id: int, data: TaskUpdate, db: Session = Depends(get_db)):
+    """更新任务"""
+    task = db.query(ScheduledTask).filter(ScheduledTask.id == task_id).first()
+    if not task:
+        raise HTTPException(status_code=404, detail="任务不存在")
+    
+    # 更新字段
+    if data.tenant_id is not None:
+        task.tenant_id = data.tenant_id
+    if data.task_name is not None:
+        task.task_name = data.task_name
+    if data.task_desc is not None:
+        task.task_desc = data.task_desc
+    if data.execution_type is not None:
+        task.execution_type = data.execution_type
+    if data.schedule_type is not None:
+        task.schedule_type = data.schedule_type
+    if data.time_points is not None:
+        task.time_points = data.time_points
+    if data.cron_expression is not None:
+        task.cron_expression = data.cron_expression
+    if data.webhook_url is not None:
+        task.webhook_url = data.webhook_url
+    if data.script_content is not None:
+        task.script_content = data.script_content
+    if data.input_params is not None:
+        task.input_params = data.input_params
+    if data.retry_count is not None:
+        task.retry_count = data.retry_count
+    if data.retry_interval is not None:
+        task.retry_interval = data.retry_interval
+    if data.alert_on_failure is not None:
+        task.alert_on_failure = data.alert_on_failure
+    if data.alert_webhook is not None:
+        task.alert_webhook = data.alert_webhook
+    if data.notify_channels is not None:
+        task.notify_channels = data.notify_channels
+    if data.notify_wecom_app_id is not None:
+        task.notify_wecom_app_id = data.notify_wecom_app_id
+    if data.is_enabled is not None:
+        task.is_enabled = data.is_enabled
+    
+    db.commit()
+    
+    # 更新调度器
+    if task.is_enabled:
+        scheduler_service.add_task(task.id)
+    else:
+        scheduler_service.remove_task(task.id)
+    
+    return {"success": True}
+
+
+@router.delete("/{task_id}")
+async def delete_task(task_id: int, db: Session = Depends(get_db)):
+    """删除任务"""
+    task = db.query(ScheduledTask).filter(ScheduledTask.id == task_id).first()
+    if not task:
+        raise HTTPException(status_code=404, detail="任务不存在")
+    
+    # 从调度器移除
+    scheduler_service.remove_task(task_id)
+    
+    # 删除相关日志
+    db.query(TaskLog).filter(TaskLog.task_id == task_id).delete()
+    
+    db.delete(task)
+    db.commit()
+    
+    return {"success": True}
+
+
+@router.post("/{task_id}/toggle")
+async def toggle_task(task_id: int, db: Session = Depends(get_db)):
+    """启用/禁用任务"""
+    task = db.query(ScheduledTask).filter(ScheduledTask.id == task_id).first()
+    if not task:
+        raise HTTPException(status_code=404, detail="任务不存在")
+    
+    task.is_enabled = not task.is_enabled
+    db.commit()
+    
+    if task.is_enabled:
+        scheduler_service.add_task(task.id)
+    else:
+        scheduler_service.remove_task(task.id)
+    
+    return {"success": True, "status": 1 if task.is_enabled else 0}
+
+
+@router.post("/{task_id}/run")
+async def run_task(task_id: int, background_tasks: BackgroundTasks, db: Session = Depends(get_db)):
+    """立即执行任务"""
+    task = db.query(ScheduledTask).filter(ScheduledTask.id == task_id).first()
+    if not task:
+        raise HTTPException(status_code=404, detail="任务不存在")
+    
+    result = await scheduler_service.run_task_now(task_id)
+    return result
+
+
+# ==================== Task Logs ====================
+
+@router.get("/{task_id}/logs")
+async def get_task_logs(
+    task_id: int,
+    status: Optional[str] = None,
+    page: int = Query(1, ge=1),
+    size: int = Query(20, ge=1, le=100),
+    db: Session = Depends(get_db)
+):
+    """获取任务执行日志"""
+    query = db.query(TaskLog).filter(TaskLog.task_id == task_id)
+    
+    if status:
+        query = query.filter(TaskLog.status == status)
+    
+    total = query.count()
+    items = query.order_by(desc(TaskLog.started_at)).offset((page - 1) * size).limit(size).all()
+    
+    return {
+        "total": total,
+        "items": [format_log(log) for log in items]
+    }
+
+
+# ==================== Secrets (dynamic routes) ====================
+
+@router.put("/secrets/{secret_id}")
+async def update_secret(secret_id: int, data: SecretUpdate, db: Session = Depends(get_db)):
+    """更新密钥"""
+    secret = db.query(Secret).filter(Secret.id == secret_id).first()
+    if not secret:
+        raise HTTPException(status_code=404, detail="密钥不存在")
+    
+    if data.secret_value is not None:
+        secret.secret_value = data.secret_value
+    if data.description is not None:
+        secret.description = data.description
+    
+    db.commit()
+    return {"success": True}
+
+
+@router.delete("/secrets/{secret_id}")
+async def delete_secret(secret_id: int, db: Session = Depends(get_db)):
+    """删除密钥"""
+    secret = db.query(Secret).filter(Secret.id == secret_id).first()
+    if not secret:
+        raise HTTPException(status_code=404, detail="密钥不存在")
+    
+    db.delete(secret)
+    db.commit()
+    return {"success": True}
+
+
+# ==================== Helpers ====================
+
+def format_task(task: ScheduledTask, include_content: bool = False) -> dict:
+    """格式化任务数据"""
+    time_points = task.time_points
+    if isinstance(time_points, str):
+        try:
+            time_points = json.loads(time_points)
+        except:
+            time_points = []
+    
+    # 处理 notify_channels
+    notify_channels = task.notify_channels
+    if isinstance(notify_channels, str):
+        try:
+            notify_channels = json.loads(notify_channels)
+        except:
+            notify_channels = []
+    
+    data = {
+        "id": task.id,
+        "tenant_id": task.tenant_id,
+        "task_name": task.task_name,
+        "task_type": task.execution_type,  # 前端使用 task_type
+        "schedule_type": task.schedule_type,
+        "time_points": time_points or [],
+        "cron_expression": task.cron_expression,
+        "status": 1 if task.is_enabled else 0,  # 前端使用 status
+        "last_run_at": task.last_run_at,
+        "last_run_status": task.last_run_status,
+        "retry_count": task.retry_count,
+        "retry_interval": task.retry_interval,
+        "alert_on_failure": bool(task.alert_on_failure),
+        "alert_webhook": task.alert_webhook,
+        "notify_channels": notify_channels or [],
+        "notify_wecom_app_id": task.notify_wecom_app_id,
+        "created_at": task.created_at,
+        "updated_at": task.updated_at
+    }
+    
+    if include_content:
+        data["webhook_url"] = task.webhook_url
+        data["script_content"] = task.script_content
+        input_params = task.input_params
+        if isinstance(input_params, str):
+            try:
+                input_params = json.loads(input_params)
+            except:
+                input_params = None
+        data["input_params"] = input_params
+    
+    return data
+
+
+def format_log(log: TaskLog) -> dict:
+    """格式化日志数据"""
+    return {
+        "id": log.id,
+        "task_id": log.task_id,
+        "tenant_id": log.tenant_id,
+        "trace_id": log.trace_id,
+        "status": log.status,
+        "started_at": log.started_at,
+        "finished_at": log.finished_at,
+        "duration_ms": log.duration_ms,
+        "output": log.output,
+        "error": log.error,
+        "retry_count": log.retry_count,
+        "created_at": log.created_at
+    }

backend/app/routers/tenant_apps.py

@@ -17,6 +17,13 @@ router = APIRouter(prefix="/tenant-apps", tags=["应用配置"])
 
 # Schemas
 
+class CustomConfigItem(BaseModel):
+    """自定义配置项"""
+    key: str  # 配置键
+    value: str  # 配置值
+    remark: Optional[str] = None  # 备注说明
+
+
 class TenantAppCreate(BaseModel):
     tenant_id: str
     app_code: str = "tools"
@@ -25,6 +32,7 @@ class TenantAppCreate(BaseModel):
     access_token: Optional[str] = None  # 如果不传则自动生成
     allowed_origins: Optional[List[str]] = None
     allowed_tools: Optional[List[str]] = None
+    custom_configs: Optional[List[CustomConfigItem]] = None  # 自定义配置
 
 
 class TenantAppUpdate(BaseModel):
@@ -33,6 +41,7 @@ class TenantAppUpdate(BaseModel):
     access_token: Optional[str] = None
     allowed_origins: Optional[List[str]] = None
     allowed_tools: Optional[List[str]] = None
+    custom_configs: Optional[List[CustomConfigItem]] = None  # 自定义配置
     status: Optional[int] = None
 
 
@@ -41,7 +50,7 @@ class TenantAppUpdate(BaseModel):
 @router.get("")
 async def list_tenant_apps(
     page: int = Query(1, ge=1),
-    size: int = Query(20, ge=1, le=100),
+    size: int = Query(20, ge=1, le=1000),
     tenant_id: Optional[str] = None,
     app_code: Optional[str] = None,
     user: User = Depends(get_current_user),
@@ -111,6 +120,7 @@ async def create_tenant_app(
         access_token=access_token,
         allowed_origins=json.dumps(data.allowed_origins) if data.allowed_origins else None,
         allowed_tools=json.dumps(data.allowed_tools) if data.allowed_tools else None,
+        custom_configs=json.dumps([c.model_dump() for c in data.custom_configs], ensure_ascii=False) if data.custom_configs else None,
         status=1
     )
     db.add(app)
@@ -139,6 +149,14 @@ async def update_tenant_app(
         update_data['allowed_origins'] = json.dumps(update_data['allowed_origins']) if update_data['allowed_origins'] else None
     if 'allowed_tools' in update_data:
         update_data['allowed_tools'] = json.dumps(update_data['allowed_tools']) if update_data['allowed_tools'] else None
+    if 'custom_configs' in update_data:
+        if update_data['custom_configs']:
+            update_data['custom_configs'] = json.dumps(
+                [c.model_dump() if hasattr(c, 'model_dump') else c for c in update_data['custom_configs']], 
+                ensure_ascii=False
+            )
+        else:
+            update_data['custom_configs'] = None
     
     for key, value in update_data.items():
         setattr(app, key, value)
@@ -164,6 +182,27 @@ async def delete_tenant_app(
     return {"success": True}
 
 
+@router.get("/{app_id}/token")
+async def get_token(
+    app_id: int,
+    user: User = Depends(require_operator),
+    db: Session = Depends(get_db)
+):
+    """获取真实的 access_token（仅管理员可用）"""
+    app = db.query(TenantApp).filter(TenantApp.id == app_id).first()
+    if not app:
+        raise HTTPException(status_code=404, detail="应用配置不存在")
+    
+    # 获取应用的 base_url
+    app_info = db.query(App).filter(App.app_code == app.app_code).first()
+    base_url = app_info.base_url if app_info else ""
+    
+    return {
+        "access_token": app.access_token,
+        "base_url": base_url
+    }
+
+
 @router.post("/{app_id}/regenerate-token")
 async def regenerate_token(
     app_id: int,
@@ -207,6 +246,7 @@ def format_tenant_app(app: TenantApp, mask_secret: bool = True, db: Session = No
         "access_token": "******" if mask_secret and app.access_token else app.access_token,
         "allowed_origins": json.loads(app.allowed_origins) if app.allowed_origins else [],
         "allowed_tools": json.loads(app.allowed_tools) if app.allowed_tools else [],
+        "custom_configs": json.loads(app.custom_configs) if app.custom_configs else [],
         "status": app.status,
         "created_at": app.created_at,
         "updated_at": app.updated_at

backend/app/routers/tenant_wechat_apps.py

@@ -37,7 +37,7 @@ class TenantWechatAppUpdate(BaseModel):
 @router.get("")
 async def list_tenant_wechat_apps(
     page: int = Query(1, ge=1),
-    size: int = Query(20, ge=1, le=100),
+    size: int = Query(20, ge=1, le=1000),
     tenant_id: Optional[str] = None,
     user: User = Depends(get_current_user),
     db: Session = Depends(get_db)

backend/app/routers/tenants.py

@@ -55,7 +55,7 @@ class SubscriptionUpdate(BaseModel):
 @router.get("")
 async def list_tenants(
     page: int = Query(1, ge=1),
-    size: int = Query(20, ge=1, le=100),
+    size: int = Query(20, ge=1, le=1000),
     status: Optional[str] = None,
     keyword: Optional[str] = None,
     user: User = Depends(get_current_user),

backend/app/routers/tool_configs.py

@@ -0,0 +1,398 @@
+"""租户工具配置路由"""
+import json
+from fastapi import APIRouter, Depends, HTTPException, Query
+from pydantic import BaseModel
+from typing import Optional, List, Dict, Any
+from sqlalchemy.orm import Session
+from sqlalchemy import or_
+
+from ..database import get_db
+from ..models.tool_config import ToolConfig
+from .auth import get_current_user
+from ..models.user import User
+
+router = APIRouter(prefix="/tool-configs", tags=["工具配置"])
+
+
+# ========================================
+# Schemas
+# ========================================
+
+class ToolConfigCreate(BaseModel):
+    """创建配置"""
+    tenant_id: str
+    tool_code: Optional[str] = None  # NULL 表示租户级共享配置
+    config_type: str  # datasource / jssdk / webhook / params
+    config_key: str
+    config_value: Optional[str] = None
+    is_encrypted: int = 0
+    description: Optional[str] = None
+
+
+class ToolConfigUpdate(BaseModel):
+    """更新配置"""
+    config_value: Optional[str] = None
+    is_encrypted: Optional[int] = None
+    description: Optional[str] = None
+    status: Optional[int] = None
+
+
+class ToolConfigBatchCreate(BaseModel):
+    """批量创建配置"""
+    tenant_id: str
+    tool_code: Optional[str] = None
+    configs: List[Dict[str, Any]]  # [{config_type, config_key, config_value, description}]
+
+
+# ========================================
+# 工具函数
+# ========================================
+
+def format_config(config: ToolConfig, mask_secret: bool = True) -> dict:
+    """格式化配置输出"""
+    value = config.config_value
+    # 如果需要掩码且是加密字段
+    if mask_secret and config.is_encrypted and value:
+        value = value[:4] + "****" + value[-4:] if len(value) > 8 else "****"
+    
+    return {
+        "id": config.id,
+        "tenant_id": config.tenant_id,
+        "tool_code": config.tool_code,
+        "config_type": config.config_type,
+        "config_key": config.config_key,
+        "config_value": value,
+        "is_encrypted": config.is_encrypted,
+        "description": config.description,
+        "status": config.status,
+        "created_at": config.created_at.isoformat() if config.created_at else None,
+        "updated_at": config.updated_at.isoformat() if config.updated_at else None
+    }
+
+
+# ========================================
+# API Endpoints
+# ========================================
+
+@router.get("")
+async def list_tool_configs(
+    page: int = Query(1, ge=1),
+    size: int = Query(20, ge=1, le=100),
+    tenant_id: Optional[str] = None,
+    tool_code: Optional[str] = None,
+    config_type: Optional[str] = None,
+    keyword: Optional[str] = None,
+    user: User = Depends(get_current_user),
+    db: Session = Depends(get_db)
+):
+    """获取配置列表"""
+    query = db.query(ToolConfig).filter(ToolConfig.status == 1)
+    
+    if tenant_id:
+        query = query.filter(ToolConfig.tenant_id == tenant_id)
+    if tool_code:
+        if tool_code == "__shared__":
+            # 特殊标记：只查租户级共享配置
+            query = query.filter(ToolConfig.tool_code.is_(None))
+        else:
+            query = query.filter(ToolConfig.tool_code == tool_code)
+    if config_type:
+        query = query.filter(ToolConfig.config_type == config_type)
+    if keyword:
+        query = query.filter(
+            or_(
+                ToolConfig.config_key.like(f"%{keyword}%"),
+                ToolConfig.description.like(f"%{keyword}%")
+            )
+        )
+    
+    total = query.count()
+    configs = query.order_by(ToolConfig.tool_code, ToolConfig.config_type, ToolConfig.config_key)\
+        .offset((page - 1) * size).limit(size).all()
+    
+    return {
+        "total": total,
+        "page": page,
+        "size": size,
+        "items": [format_config(c) for c in configs]
+    }
+
+
+@router.get("/tenant/{tenant_id}")
+async def get_tenant_configs(
+    tenant_id: str,
+    tool_code: Optional[str] = None,
+    user: User = Depends(get_current_user),
+    db: Session = Depends(get_db)
+):
+    """
+    获取租户完整配置（合并层级）
+    
+    返回结构：
+    {
+        "__shared__": {"config_key": "value", ...},  # 租户级共享配置
+        "customer-profile": {"config_key": "value", ...},  # 工具级配置
+        ...
+    }
+    """
+    query = db.query(ToolConfig).filter(
+        ToolConfig.tenant_id == tenant_id,
+        ToolConfig.status == 1
+    )
+    
+    if tool_code:
+        # 只查指定工具 + 共享配置
+        query = query.filter(
+            or_(
+                ToolConfig.tool_code == tool_code,
+                ToolConfig.tool_code.is_(None)
+            )
+        )
+    
+    configs = query.all()
+    
+    result = {"__shared__": {}}
+    for config in configs:
+        tool = config.tool_code or "__shared__"
+        if tool not in result:
+            result[tool] = {}
+        result[tool][config.config_key] = {
+            "value": config.config_value,
+            "type": config.config_type,
+            "encrypted": config.is_encrypted == 1,
+            "description": config.description
+        }
+    
+    return result
+
+
+@router.get("/merged/{tenant_id}/{tool_code}")
+async def get_merged_config(
+    tenant_id: str,
+    tool_code: str,
+    user: User = Depends(get_current_user),
+    db: Session = Depends(get_db)
+):
+    """
+    获取合并后的工具配置（工具级 > 租户级 > 默认值）
+    
+    返回扁平化的配置字典：
+    {"config_key": "value", ...}
+    """
+    # 查询租户级配置
+    shared_configs = db.query(ToolConfig).filter(
+        ToolConfig.tenant_id == tenant_id,
+        ToolConfig.tool_code.is_(None),
+        ToolConfig.status == 1
+    ).all()
+    
+    # 查询工具级配置
+    tool_configs = db.query(ToolConfig).filter(
+        ToolConfig.tenant_id == tenant_id,
+        ToolConfig.tool_code == tool_code,
+        ToolConfig.status == 1
+    ).all()
+    
+    # 合并：工具级覆盖租户级
+    result = {}
+    for config in shared_configs:
+        result[config.config_key] = config.config_value
+    for config in tool_configs:
+        result[config.config_key] = config.config_value
+    
+    return result
+
+
+@router.get("/{config_id}")
+async def get_tool_config(
+    config_id: int,
+    user: User = Depends(get_current_user),
+    db: Session = Depends(get_db)
+):
+    """获取配置详情"""
+    config = db.query(ToolConfig).filter(ToolConfig.id == config_id).first()
+    if not config:
+        raise HTTPException(status_code=404, detail="配置不存在")
+    
+    return format_config(config, mask_secret=False)
+
+
+@router.post("")
+async def create_tool_config(
+    data: ToolConfigCreate,
+    user: User = Depends(get_current_user),
+    db: Session = Depends(get_db)
+):
+    """创建配置"""
+    # 检查是否已存在
+    existing = db.query(ToolConfig).filter(
+        ToolConfig.tenant_id == data.tenant_id,
+        ToolConfig.tool_code == data.tool_code if data.tool_code else ToolConfig.tool_code.is_(None),
+        ToolConfig.config_key == data.config_key
+    ).first()
+    
+    if existing:
+        raise HTTPException(status_code=400, detail="配置已存在")
+    
+    config = ToolConfig(
+        tenant_id=data.tenant_id,
+        tool_code=data.tool_code,
+        config_type=data.config_type,
+        config_key=data.config_key,
+        config_value=data.config_value,
+        is_encrypted=data.is_encrypted,
+        description=data.description
+    )
+    
+    db.add(config)
+    db.commit()
+    db.refresh(config)
+    
+    return format_config(config)
+
+
+@router.post("/batch")
+async def batch_create_configs(
+    data: ToolConfigBatchCreate,
+    user: User = Depends(get_current_user),
+    db: Session = Depends(get_db)
+):
+    """批量创建配置"""
+    created = []
+    skipped = []
+    
+    for item in data.configs:
+        config_key = item.get("config_key")
+        if not config_key:
+            continue
+        
+        # 检查是否已存在
+        existing = db.query(ToolConfig).filter(
+            ToolConfig.tenant_id == data.tenant_id,
+            ToolConfig.tool_code == data.tool_code if data.tool_code else ToolConfig.tool_code.is_(None),
+            ToolConfig.config_key == config_key
+        ).first()
+        
+        if existing:
+            skipped.append(config_key)
+            continue
+        
+        config = ToolConfig(
+            tenant_id=data.tenant_id,
+            tool_code=data.tool_code,
+            config_type=item.get("config_type", "params"),
+            config_key=config_key,
+            config_value=item.get("config_value"),
+            is_encrypted=item.get("is_encrypted", 0),
+            description=item.get("description")
+        )
+        db.add(config)
+        created.append(config_key)
+    
+    db.commit()
+    
+    return {
+        "created": created,
+        "skipped": skipped,
+        "message": f"成功创建 {len(created)} 条配置，跳过 {len(skipped)} 条已存在配置"
+    }
+
+
+@router.put("/{config_id}")
+async def update_tool_config(
+    config_id: int,
+    data: ToolConfigUpdate,
+    user: User = Depends(get_current_user),
+    db: Session = Depends(get_db)
+):
+    """更新配置"""
+    config = db.query(ToolConfig).filter(ToolConfig.id == config_id).first()
+    if not config:
+        raise HTTPException(status_code=404, detail="配置不存在")
+    
+    if data.config_value is not None:
+        config.config_value = data.config_value
+    if data.is_encrypted is not None:
+        config.is_encrypted = data.is_encrypted
+    if data.description is not None:
+        config.description = data.description
+    if data.status is not None:
+        config.status = data.status
+    
+    db.commit()
+    db.refresh(config)
+    
+    return format_config(config)
+
+
+@router.delete("/{config_id}")
+async def delete_tool_config(
+    config_id: int,
+    user: User = Depends(get_current_user),
+    db: Session = Depends(get_db)
+):
+    """删除配置（软删除）"""
+    config = db.query(ToolConfig).filter(ToolConfig.id == config_id).first()
+    if not config:
+        raise HTTPException(status_code=404, detail="配置不存在")
+    
+    config.status = 0
+    db.commit()
+    
+    return {"message": "删除成功"}
+
+
+# ========================================
+# 配置类型和键名定义（供前端使用）
+# ========================================
+
+@router.get("/schema/types")
+async def get_config_types():
+    """获取支持的配置类型"""
+    return {
+        "types": [
+            {"code": "datasource", "name": "数据源配置", "description": "数据库连接等"},
+            {"code": "jssdk", "name": "JS-SDK 配置", "description": "企微侧边栏等"},
+            {"code": "webhook", "name": "Webhook 配置", "description": "n8n 工作流地址等"},
+            {"code": "params", "name": "工具参数", "description": "各工具的自定义参数"},
+            {"code": "external_api", "name": "外部API配置", "description": "睿美云等外部系统对接"}
+        ]
+    }
+
+
+@router.get("/schema/keys")
+async def get_config_keys():
+    """获取预定义的配置键（供前端下拉选择）"""
+    return {
+        "datasource": [
+            {"key": "scrm_db_host", "name": "SCRM 数据库地址", "encrypted": False},
+            {"key": "scrm_db_port", "name": "SCRM 数据库端口", "encrypted": False},
+            {"key": "scrm_db_user", "name": "SCRM 数据库用户", "encrypted": False},
+            {"key": "scrm_db_password", "name": "SCRM 数据库密码", "encrypted": True},
+            {"key": "scrm_db_name", "name": "SCRM 数据库名", "encrypted": False}
+        ],
+        "jssdk": [
+            {"key": "corp_id", "name": "企业ID", "encrypted": False},
+            {"key": "agent_id", "name": "应用ID", "encrypted": False},
+            {"key": "secret", "name": "应用密钥", "encrypted": True}
+        ],
+        "webhook": [
+            {"key": "n8n_base_url", "name": "n8n 基础地址", "encrypted": False},
+            {"key": "webhook_brainstorm", "name": "头脑风暴 Webhook", "encrypted": False},
+            {"key": "webhook_high_eq", "name": "高情商回复 Webhook", "encrypted": False},
+            {"key": "webhook_customer_profile", "name": "客户画像 Webhook", "encrypted": False},
+            {"key": "webhook_consultation", "name": "面诊方案 Webhook", "encrypted": False},
+            {"key": "webhook_medical_compliance", "name": "医疗合规 Webhook", "encrypted": False}
+        ],
+        "params": [
+            {"key": "default_data_tenant_id", "name": "默认数据租户ID", "encrypted": False},
+            {"key": "enable_deep_thinking", "name": "启用深度思考", "encrypted": False},
+            {"key": "max_history_rounds", "name": "最大历史轮数", "encrypted": False}
+        ],
+        "external_api": [
+            {"key": "ruimeiyun_base_url", "name": "睿美云 API 地址", "encrypted": False},
+            {"key": "ruimeiyun_account", "name": "睿美云 TPOS 账号", "encrypted": False},
+            {"key": "ruimeiyun_private_key", "name": "睿美云 RSA 私钥", "encrypted": True},
+            {"key": "ruimeiyun_allowed_apis", "name": "允许的接口列表(JSON)", "encrypted": False}
+        ]
+    }

backend/app/services/ruimeiyun/__init__.py

@@ -0,0 +1,10 @@
+"""
+睿美云对接服务
+
+提供睿美云开放接口的代理调用能力，支持多租户配置。
+"""
+
+from .client import RuimeiyunClient
+from .registry import RUIMEIYUN_APIS, get_api_definition
+
+__all__ = ["RuimeiyunClient", "RUIMEIYUN_APIS", "get_api_definition"]

backend/app/services/ruimeiyun/auth.py

@@ -0,0 +1,124 @@
+"""
+睿美云 TPOS 鉴权
+
+实现睿美云开放接口的身份验证机制：
+- tpos-timestamp: 请求时间戳（秒级）
+- tpos-account: 账号
+- tpos-nonce-str: 随机字符串
+- tpos-sign: SHA256WithRSA 签名
+
+签名算法：
+1. 组合待签名字符串: {timestamp}&{nonce_str}
+2. 使用私钥进行 SHA256WithRSA 签名
+3. Base64 编码签名结果
+"""
+
+import time
+import uuid
+import base64
+import logging
+from typing import Dict
+
+from cryptography.hazmat.primitives import hashes, serialization
+from cryptography.hazmat.primitives.asymmetric import padding
+from cryptography.hazmat.backends import default_backend
+
+logger = logging.getLogger(__name__)
+
+
+class TposAuthError(Exception):
+    """TPOS 鉴权错误"""
+    pass
+
+
+def build_tpos_headers(account: str, private_key_pem: str) -> Dict[str, str]:
+    """
+    构建 TPOS 鉴权请求头
+    
+    Args:
+        account: TPOS 账号（由睿美云提供）
+        private_key_pem: RSA 私钥（PEM 格式）
+        
+    Returns:
+        包含鉴权信息的请求头字典
+        
+    Raises:
+        TposAuthError: 签名失败时抛出
+    """
+    try:
+        # 1. 生成时间戳和随机字符串
+        timestamp = str(int(time.time()))
+        nonce_str = uuid.uuid4().hex
+        
+        # 2. 组合待签名字符串
+        sign_content = f"{timestamp}&{nonce_str}"
+        
+        # 3. 加载私钥
+        private_key = serialization.load_pem_private_key(
+            private_key_pem.encode('utf-8'),
+            password=None,
+            backend=default_backend()
+        )
+        
+        # 4. SHA256WithRSA 签名
+        signature = private_key.sign(
+            sign_content.encode('utf-8'),
+            padding.PKCS1v15(),
+            hashes.SHA256()
+        )
+        
+        # 5. Base64 编码
+        sign_base64 = base64.b64encode(signature).decode('utf-8')
+        
+        return {
+            "tpos-timestamp": timestamp,
+            "tpos-account": account,
+            "tpos-nonce-str": nonce_str,
+            "tpos-sign": sign_base64
+        }
+        
+    except Exception as e:
+        logger.error(f"TPOS 签名失败: {e}")
+        raise TposAuthError(f"签名失败: {str(e)}")
+
+
+def validate_private_key(private_key_pem: str) -> bool:
+    """
+    验证私钥格式是否正确
+    
+    Args:
+        private_key_pem: RSA 私钥（PEM 格式）
+        
+    Returns:
+        True 如果私钥有效，否则 False
+    """
+    try:
+        serialization.load_pem_private_key(
+            private_key_pem.encode('utf-8'),
+            password=None,
+            backend=default_backend()
+        )
+        return True
+    except Exception as e:
+        logger.warning(f"私钥验证失败: {e}")
+        return False
+
+
+def mask_private_key(private_key_pem: str, show_chars: int = 50) -> str:
+    """
+    对私钥进行脱敏处理，用于日志显示
+    
+    Args:
+        private_key_pem: RSA 私钥（PEM 格式）
+        show_chars: 显示的字符数
+        
+    Returns:
+        脱敏后的字符串
+    """
+    if not private_key_pem:
+        return ""
+    
+    if len(private_key_pem) <= show_chars * 2:
+        return "****"
+    
+    return f"{private_key_pem[:show_chars]}...****...{private_key_pem[-show_chars:]}"

backend/app/services/ruimeiyun/client.py

@@ -0,0 +1,325 @@
+"""
+睿美云 API 客户端
+
+提供统一的睿美云接口调用能力：
+- 自动加载租户配置
+- 自动构建 TPOS 鉴权头
+- 统一错误处理
+- 请求日志记录
+"""
+
+import json
+import logging
+from typing import Dict, Any, Optional, List
+from dataclasses import dataclass
+
+import httpx
+from sqlalchemy.orm import Session
+
+from .auth import build_tpos_headers, TposAuthError
+from .registry import get_api_definition, RUIMEIYUN_APIS
+from ..crypto import decrypt_value
+
+logger = logging.getLogger(__name__)
+
+# 请求超时设置
+DEFAULT_TIMEOUT = 30.0  # 秒
+LONG_TIMEOUT = 60.0  # 长时间操作
+
+
+@dataclass
+class RuimeiyunConfig:
+    """睿美云配置"""
+    base_url: str
+    account: str
+    private_key: str
+    allowed_apis: Optional[List[str]] = None
+
+
+@dataclass
+class RuimeiyunResponse:
+    """睿美云响应"""
+    success: bool
+    data: Optional[Any] = None
+    error: Optional[str] = None
+    status_code: int = 200
+    raw_response: Optional[Dict] = None
+
+
+class RuimeiyunError(Exception):
+    """睿美云调用错误"""
+    def __init__(self, message: str, status_code: int = 500, response: Any = None):
+        super().__init__(message)
+        self.status_code = status_code
+        self.response = response
+
+
+class RuimeiyunClient:
+    """
+    睿美云 API 客户端
+    
+    使用方式:
+        client = RuimeiyunClient(tenant_id, db)
+        result = await client.call("customer.search", params={"keyword": "13800138000"})
+    """
+    
+    def __init__(self, tenant_id: str, db: Session):
+        """
+        初始化客户端
+        
+        Args:
+            tenant_id: 租户ID
+            db: 数据库会话
+        """
+        self.tenant_id = tenant_id
+        self.db = db
+        self.config = self._load_config()
+    
+    def _load_config(self) -> RuimeiyunConfig:
+        """从数据库加载租户的睿美云配置"""
+        from ...models.tool_config import ToolConfig
+        
+        # 查询租户的睿美云配置
+        configs = self.db.query(ToolConfig).filter(
+            ToolConfig.tenant_id == self.tenant_id,
+            ToolConfig.tool_code == "ruimeiyun",
+            ToolConfig.config_type == "external_api",
+            ToolConfig.status == 1
+        ).all()
+        
+        if not configs:
+            raise RuimeiyunError(
+                f"租户 {self.tenant_id} 未配置睿美云连接信息",
+                status_code=400
+            )
+        
+        # 转换为字典
+        config_dict = {}
+        for c in configs:
+            value = c.config_value
+            # 解密加密字段
+            if c.is_encrypted and value:
+                try:
+                    value = decrypt_value(value)
+                except Exception as e:
+                    logger.error(f"解密配置失败: {c.config_key}, {e}")
+                    raise RuimeiyunError(f"配置解密失败: {c.config_key}")
+            config_dict[c.config_key] = value
+        
+        # 验证必填配置
+        required = ["ruimeiyun_base_url", "ruimeiyun_account", "ruimeiyun_private_key"]
+        for key in required:
+            if not config_dict.get(key):
+                raise RuimeiyunError(f"缺少必填配置: {key}", status_code=400)
+        
+        # 解析允许的接口列表
+        allowed_apis = None
+        if config_dict.get("ruimeiyun_allowed_apis"):
+            try:
+                allowed_apis = json.loads(config_dict["ruimeiyun_allowed_apis"])
+            except json.JSONDecodeError:
+                logger.warning(f"解析 allowed_apis 失败: {config_dict.get('ruimeiyun_allowed_apis')}")
+        
+        return RuimeiyunConfig(
+            base_url=config_dict["ruimeiyun_base_url"].rstrip("/"),
+            account=config_dict["ruimeiyun_account"],
+            private_key=config_dict["ruimeiyun_private_key"],
+            allowed_apis=allowed_apis
+        )
+    
+    def _check_permission(self, api_name: str):
+        """检查是否有权限调用该接口"""
+        if self.config.allowed_apis is not None:
+            if api_name not in self.config.allowed_apis:
+                raise RuimeiyunError(
+                    f"租户无权调用接口: {api_name}",
+                    status_code=403
+                )
+    
+    async def call(
+        self,
+        api_name: str,
+        params: Optional[Dict[str, Any]] = None,
+        body: Optional[Dict[str, Any]] = None,
+        timeout: float = DEFAULT_TIMEOUT
+    ) -> RuimeiyunResponse:
+        """
+        调用睿美云接口
+        
+        Args:
+            api_name: 接口名称，如 customer.search
+            params: URL 查询参数
+            body: 请求体（POST 请求）
+            timeout: 超时时间（秒）
+            
+        Returns:
+            RuimeiyunResponse 对象
+            
+        Raises:
+            RuimeiyunError: 调用失败时抛出
+        """
+        # 1. 获取接口定义
+        api_def = get_api_definition(api_name)
+        if not api_def:
+            raise RuimeiyunError(f"未知接口: {api_name}", status_code=400)
+        
+        # 2. 检查权限
+        self._check_permission(api_name)
+        
+        # 3. 构建请求
+        method = api_def["method"]
+        url = f"{self.config.base_url}{api_def['path']}"
+        
+        # 4. 构建鉴权头
+        try:
+            auth_headers = build_tpos_headers(
+                self.config.account,
+                self.config.private_key
+            )
+        except TposAuthError as e:
+            raise RuimeiyunError(str(e), status_code=500)
+        
+        headers = {
+            **auth_headers,
+            "Content-Type": "application/json"
+        }
+        
+        # 5. 发送请求
+        logger.info(f"调用睿美云接口: {api_name} ({method} {api_def['path']})")
+        
+        try:
+            async with httpx.AsyncClient(timeout=timeout) as client:
+                if method == "GET":
+                    response = await client.get(url, params=params, headers=headers)
+                else:
+                    response = await client.post(url, params=params, json=body, headers=headers)
+                
+                # 6. 处理响应
+                status_code = response.status_code
+                
+                try:
+                    response_data = response.json()
+                except Exception:
+                    response_data = {"raw": response.text}
+                
+                # 睿美云响应格式通常为: {"code": 0, "data": ..., "msg": "success"}
+                if status_code == 200:
+                    # 检查业务状态码
+                    code = response_data.get("code")
+                    if code == 0 or code == "0" or code is None:
+                        return RuimeiyunResponse(
+                            success=True,
+                            data=response_data.get("data", response_data),
+                            status_code=status_code,
+                            raw_response=response_data
+                        )
+                    else:
+                        return RuimeiyunResponse(
+                            success=False,
+                            error=response_data.get("msg", response_data.get("message", "未知错误")),
+                            status_code=status_code,
+                            raw_response=response_data
+                        )
+                else:
+                    return RuimeiyunResponse(
+                        success=False,
+                        error=f"HTTP {status_code}: {response_data}",
+                        status_code=status_code,
+                        raw_response=response_data
+                    )
+                    
+        except httpx.TimeoutException:
+            logger.error(f"睿美云接口超时: {api_name}")
+            raise RuimeiyunError(f"接口超时: {api_name}", status_code=504)
+        except httpx.RequestError as e:
+            logger.error(f"睿美云接口请求错误: {api_name}, {e}")
+            raise RuimeiyunError(f"请求错误: {str(e)}", status_code=502)
+    
+    async def call_raw(
+        self,
+        method: str,
+        path: str,
+        params: Optional[Dict[str, Any]] = None,
+        body: Optional[Dict[str, Any]] = None,
+        timeout: float = DEFAULT_TIMEOUT
+    ) -> RuimeiyunResponse:
+        """
+        直接调用睿美云接口（不经过注册表）
+        
+        用于调用未在注册表中定义的接口
+        
+        Args:
+            method: HTTP 方法
+            path: API 路径
+            params: URL 查询参数
+            body: 请求体
+            timeout: 超时时间
+            
+        Returns:
+            RuimeiyunResponse 对象
+        """
+        url = f"{self.config.base_url}{path}"
+        
+        try:
+            auth_headers = build_tpos_headers(
+                self.config.account,
+                self.config.private_key
+            )
+        except TposAuthError as e:
+            raise RuimeiyunError(str(e), status_code=500)
+        
+        headers = {
+            **auth_headers,
+            "Content-Type": "application/json"
+        }
+        
+        logger.info(f"调用睿美云接口(raw): {method} {path}")
+        
+        try:
+            async with httpx.AsyncClient(timeout=timeout) as client:
+                response = await client.request(
+                    method=method,
+                    url=url,
+                    params=params,
+                    json=body if method != "GET" else None,
+                    headers=headers
+                )
+                
+                try:
+                    response_data = response.json()
+                except Exception:
+                    response_data = {"raw": response.text}
+                
+                if response.status_code == 200:
+                    code = response_data.get("code")
+                    if code == 0 or code == "0" or code is None:
+                        return RuimeiyunResponse(
+                            success=True,
+                            data=response_data.get("data", response_data),
+                            status_code=response.status_code,
+                            raw_response=response_data
+                        )
+                    else:
+                        return RuimeiyunResponse(
+                            success=False,
+                            error=response_data.get("msg", "未知错误"),
+                            status_code=response.status_code,
+                            raw_response=response_data
+                        )
+                else:
+                    return RuimeiyunResponse(
+                        success=False,
+                        error=f"HTTP {response.status_code}",
+                        status_code=response.status_code,
+                        raw_response=response_data
+                    )
+                    
+        except httpx.TimeoutException:
+            raise RuimeiyunError("接口超时", status_code=504)
+        except httpx.RequestError as e:
+            raise RuimeiyunError(f"请求错误: {str(e)}", status_code=502)
+    
+    @staticmethod
+    def get_available_apis() -> Dict[str, Any]:
+        """获取所有可用的接口列表"""
+        return RUIMEIYUN_APIS

backend/app/services/ruimeiyun/registry.py

@@ -0,0 +1,885 @@
+"""
+睿美云接口注册表
+
+定义所有可用的睿美云开放接口，包括：
+- 接口路径
+- 请求方法
+- 参数说明
+- 接口分组
+
+接口命名规则: {模块}.{操作}
+例如: customer.search, order.list, treat.page
+"""
+
+from typing import Dict, Any, Optional, List
+from dataclasses import dataclass
+
+
+@dataclass
+class ApiDefinition:
+    """接口定义"""
+    method: str  # GET / POST
+    path: str  # API 路径
+    description: str  # 接口描述
+    module: str  # 所属模块
+    params: Optional[List[str]] = None  # URL 参数列表
+    body_required: bool = False  # 是否需要请求体
+
+
+# 睿美云开放接口注册表
+RUIMEIYUN_APIS: Dict[str, Dict[str, Any]] = {
+    
+    # ========================================
+    # 客户模块 (customer)
+    # ========================================
+    
+    "customer.sync": {
+        "method": "POST",
+        "path": "/api/v1/tpos/customer/info-sync",
+        "description": "客户档案新增/编辑",
+        "module": "customer",
+        "body_required": True
+    },
+    "customer.search": {
+        "method": "GET",
+        "path": "/api/v1/tpos/customer/customer-search",
+        "description": "获取客户信息列表（支持姓名、电话、档案号模糊查询）",
+        "module": "customer",
+        "params": ["keyword", "createDateStart", "createDateEnd", "tenantId", "page", "size", "lastCustomerId"]
+    },
+    "customer.detail": {
+        "method": "GET",
+        "path": "/api/v1/tpos/customer/customer-by-id",
+        "description": "根据客户ID获取详细信息",
+        "module": "customer",
+        "params": ["customerId"]
+    },
+    "customer.rebate_list": {
+        "method": "POST",
+        "path": "/api/v1/tpos/customer/my-rebate-list",
+        "description": "获取客户返利列表",
+        "module": "customer",
+        "body_required": True
+    },
+    "customer.rebate_detail": {
+        "method": "GET",
+        "path": "/api/v1/tpos/customer/my-rebate-detail",
+        "description": "获取返利详情",
+        "module": "customer",
+        "params": ["rebateId"]
+    },
+    "customer.clue_list": {
+        "method": "POST",
+        "path": "/api/v1/tpos/customer/customer-clue-list",
+        "description": "获取客户线索列表",
+        "module": "customer",
+        "body_required": True
+    },
+    "customer.label_list": {
+        "method": "GET",
+        "path": "/api/v1/tpos/customer/customer-label-list",
+        "description": "获取客户标签列表",
+        "module": "customer",
+        "params": ["tenantId"]
+    },
+    "customer.gold_list": {
+        "method": "POST",
+        "path": "/api/v1/tpos/customer/customer-gold-list",
+        "description": "获取金卡客户列表",
+        "module": "customer",
+        "body_required": True
+    },
+    "customer.plan_list": {
+        "method": "GET",
+        "path": "/api/v1/tpos/customer/get-all-plan",
+        "description": "获取所有客户计划",
+        "module": "customer",
+        "params": ["tenantId"]
+    },
+    "customer.transfer_pool": {
+        "method": "POST",
+        "path": "/api/v1/tpos/customer/transfer-pool",
+        "description": "客户池转移",
+        "module": "customer",
+        "body_required": True
+    },
+    "customer.pool_info": {
+        "method": "GET",
+        "path": "/api/v1/tpos/customer/get-pool-info",
+        "description": "获取客户池信息",
+        "module": "customer",
+        "params": ["customerId"]
+    },
+    "customer.qw_info": {
+        "method": "GET",
+        "path": "/api/v1/tpos/customer/customer-qw-info",
+        "description": "获取客户企微信息",
+        "module": "customer",
+        "params": ["customerId"]
+    },
+    "customer.sign_search": {
+        "method": "POST",
+        "path": "/api/v1/tpos/customer/customer-sign-search",
+        "description": "客户签到搜索",
+        "module": "customer",
+        "body_required": True
+    },
+    
+    # ========================================
+    # 门店模块 (tenant)
+    # ========================================
+    
+    "tenant.list": {
+        "method": "GET",
+        "path": "/api/v1/tpos/common/tenantList",
+        "description": "获取门店信息列表",
+        "module": "tenant",
+        "params": []
+    },
+    
+    # ========================================
+    # 回访模块 (visit)
+    # ========================================
+    
+    "visit.type_list": {
+        "method": "GET",
+        "path": "/api/v1/tpos/visit/get-visit-type",
+        "description": "获取回访类型列表",
+        "module": "visit",
+        "params": ["tenantId"]
+    },
+    "visit.way_type_list": {
+        "method": "GET",
+        "path": "/api/v1/tpos/visit/get-visit-way-type",
+        "description": "获取回访方式类型列表",
+        "module": "visit",
+        "params": ["tenantId"]
+    },
+    "visit.page": {
+        "method": "POST",
+        "path": "/api/v1/tpos/visit/get-visit-page",
+        "description": "分页获取回访记录",
+        "module": "visit",
+        "body_required": True
+    },
+    "visit.create": {
+        "method": "POST",
+        "path": "/api/v1/tpos/visit/create-visit",
+        "description": "新增回访记录",
+        "module": "visit",
+        "body_required": True
+    },
+    "visit.template_type": {
+        "method": "GET",
+        "path": "/api/v1/tpos/visit/visit-template-type",
+        "description": "获取回访模板类型",
+        "module": "visit",
+        "params": ["tenantId"]
+    },
+    
+    # ========================================
+    # 报备模块 (preparation)
+    # ========================================
+    
+    "preparation.add": {
+        "method": "POST",
+        "path": "/api/v1/tpos/preparation/add",
+        "description": "新增报备",
+        "module": "preparation",
+        "body_required": True
+    },
+    "preparation.query": {
+        "method": "POST",
+        "path": "/api/v1/tpos/preparation/get-preparation",
+        "description": "查询报备",
+        "module": "preparation",
+        "body_required": True
+    },
+    
+    # ========================================
+    # 员工模块 (user)
+    # ========================================
+    
+    "user.page": {
+        "method": "GET",
+        "path": "/api/v1/tpos/user/get-page",
+        "description": "分页获取员工列表",
+        "module": "user",
+        "params": ["page", "size", "tenantId", "keyword"]
+    },
+    "user.dept_tree": {
+        "method": "GET",
+        "path": "/api/v1/tpos/basic/dept-tree",
+        "description": "获取部门树结构",
+        "module": "user",
+        "params": ["tenantId"]
+    },
+    "user.role_list": {
+        "method": "GET",
+        "path": "/api/v1/tpos/role/getRoleList",
+        "description": "获取角色列表",
+        "module": "user",
+        "params": ["tenantId"]
+    },
+    
+    # ========================================
+    # 卡券模块 (coupon)
+    # ========================================
+    
+    "coupon.customer_page": {
+        "method": "GET",
+        "path": "/api/v1/tpos/coupon/customer-coupon-page",
+        "description": "分页获取客户卡券",
+        "module": "coupon",
+        "params": ["customerId", "page", "size"]
+    },
+    "coupon.customer_list": {
+        "method": "GET",
+        "path": "/api/v1/tpos/coupon/customer-coupon-list",
+        "description": "获取客户卡券列表",
+        "module": "coupon",
+        "params": ["customerId"]
+    },
+    "coupon.use": {
+        "method": "POST",
+        "path": "/api/v1/tpos/coupon/use-coupon",
+        "description": "使用卡券",
+        "module": "coupon",
+        "body_required": True
+    },
+    "coupon.page": {
+        "method": "GET",
+        "path": "/api/v1/tpos/coupon/coupon-page",
+        "description": "分页获取卡券信息",
+        "module": "coupon",
+        "params": ["page", "size", "tenantId"]
+    },
+    "coupon.send": {
+        "method": "POST",
+        "path": "/api/v1/tpos/coupon/send-coupon",
+        "description": "发送卡券",
+        "module": "coupon",
+        "body_required": True
+    },
+    "coupon.gift": {
+        "method": "POST",
+        "path": "/api/v1/tpos/coupon/gift-coupon",
+        "description": "卡券赠送（小程序分享）",
+        "module": "coupon",
+        "body_required": True
+    },
+    "coupon.receive": {
+        "method": "POST",
+        "path": "/api/v1/tpos/coupon/receive-coupon",
+        "description": "领取卡券（小程序分享）",
+        "module": "coupon",
+        "body_required": True
+    },
+    
+    # ========================================
+    # 营销模块 (marketing)
+    # ========================================
+    
+    "marketing.appoint_card_page": {
+        "method": "GET",
+        "path": "/api/v1/tpos/marketing/appoint-card-page",
+        "description": "线上预约-名片管理",
+        "module": "marketing",
+        "params": ["page", "size", "tenantId"]
+    },
+    "marketing.graphic_message_list": {
+        "method": "GET",
+        "path": "/api/v1/tpos/marketing/graphic-message-list",
+        "description": "内容管理-图文消息",
+        "module": "marketing",
+        "params": ["tenantId"]
+    },
+    
+    # ========================================
+    # 积分模块 (integral)
+    # ========================================
+    
+    "integral.customer": {
+        "method": "GET",
+        "path": "/api/v1/tpos/integral/getCusIntegral",
+        "description": "获取客户积分",
+        "module": "integral",
+        "params": ["customerId"]
+    },
+    "integral.score_record_page": {
+        "method": "GET",
+        "path": "/api/v1/tpos/integral/score-record-page",
+        "description": "获取客户积分/成长值分页信息",
+        "module": "integral",
+        "params": ["customerId", "page", "size"]
+    },
+    "integral.growth_upgrade": {
+        "method": "POST",
+        "path": "/api/v1/tpos/integral/query-customer-growth-upgrade",
+        "description": "查询客户成长升级信息",
+        "module": "integral",
+        "body_required": True
+    },
+    
+    # ========================================
+    # 订单模块 (order)
+    # ========================================
+    
+    "order.billing_page": {
+        "method": "GET",
+        "path": "/api/v1/tpos/order/billing-page",
+        "description": "获取订单信息列表",
+        "module": "order",
+        "params": ["customerId", "page", "size", "startDate", "endDate"]
+    },
+    "order.payment_detail": {
+        "method": "GET",
+        "path": "/api/v1/tpos/order/payment-detail",
+        "description": "获取费用单详细信息",
+        "module": "order",
+        "params": ["billingId"]
+    },
+    "order.add_billing": {
+        "method": "POST",
+        "path": "/api/v1/tpos/order/add-billing",
+        "description": "开单",
+        "module": "order",
+        "body_required": True
+    },
+    "order.add_billing_review": {
+        "method": "POST",
+        "path": "/api/v1/tpos/order/add-billing-review",
+        "description": "开单审核",
+        "module": "order",
+        "body_required": True
+    },
+    "order.enable_billing": {
+        "method": "GET",
+        "path": "/api/v1/tpos/order/enable-billing",
+        "description": "可操作的订单项",
+        "module": "order",
+        "params": ["billingId"]
+    },
+    "order.refund": {
+        "method": "POST",
+        "path": "/api/v1/tpos/order/refund",
+        "description": "订单退款",
+        "module": "order",
+        "body_required": True
+    },
+    "order.gift_project": {
+        "method": "POST",
+        "path": "/api/v1/tpos/order/gift-project",
+        "description": "项目转赠（小程序分享）",
+        "module": "order",
+        "body_required": True
+    },
+    "order.receive_project": {
+        "method": "POST",
+        "path": "/api/v1/tpos/order/receive-project",
+        "description": "领取赠送项目（小程序分享）",
+        "module": "order",
+        "body_required": True
+    },
+    "order.equity_card_page": {
+        "method": "GET",
+        "path": "/api/v1/tpos/order/billing-equity-card-page",
+        "description": "获取客户权益卡列表",
+        "module": "order",
+        "params": ["customerId", "page", "size"]
+    },
+    "order.balance_recharge_page": {
+        "method": "GET",
+        "path": "/api/v1/tpos/order/balance-recharge-page",
+        "description": "储值充值记录",
+        "module": "order",
+        "params": ["customerId", "page", "size"]
+    },
+    "order.balance_deduction_page": {
+        "method": "GET",
+        "path": "/api/v1/tpos/order/balance-deduction-page",
+        "description": "储值抵扣记录",
+        "module": "order",
+        "params": ["customerId", "page", "size"]
+    },
+    "order.balance_refund_page": {
+        "method": "GET",
+        "path": "/api/v1/tpos/order/balance-refund-page",
+        "description": "储值退款记录",
+        "module": "order",
+        "params": ["customerId", "page", "size"]
+    },
+    "order.balance_transfer_page": {
+        "method": "GET",
+        "path": "/api/v1/tpos/order/balance-transfer-page",
+        "description": "储值转赠记录",
+        "module": "order",
+        "params": ["customerId", "page", "size"]
+    },
+    "order.integral_mall_page": {
+        "method": "GET",
+        "path": "/api/v1/tpos/order/integral-mall-exchange-page",
+        "description": "获取积分兑换订单信息列表",
+        "module": "order",
+        "params": ["customerId", "page", "size"]
+    },
+    "order.add_external": {
+        "method": "POST",
+        "path": "/api/v1/tpos/order/add-order-external",
+        "description": "外部订单创建",
+        "module": "order",
+        "body_required": True
+    },
+    "order.refund_external": {
+        "method": "POST",
+        "path": "/api/v1/tpos/order/refund-order-external",
+        "description": "外部订单退款",
+        "module": "order",
+        "body_required": True
+    },
+    "order.customer_billing_list": {
+        "method": "POST",
+        "path": "/api/v1/tpos/order/get-customer-billing-list",
+        "description": "获取客户订单列表",
+        "module": "order",
+        "body_required": True
+    },
+    "order.cashier_record_list": {
+        "method": "POST",
+        "path": "/api/v1/tpos/order/get-cashierRecord-list",
+        "description": "获取收银记录列表",
+        "module": "order",
+        "body_required": True
+    },
+    
+    # ========================================
+    # 治疗模块 (treat)
+    # ========================================
+    
+    "treat.untreated_page": {
+        "method": "GET",
+        "path": "/api/v1/tpos/treat/untreated-page",
+        "description": "查询客户未治疗记录",
+        "module": "treat",
+        "params": ["customerId", "page", "size"]
+    },
+    "treat.already_treated_page": {
+        "method": "GET",
+        "path": "/api/v1/tpos/treat/already-treated-page",
+        "description": "查询客户已治疗记录",
+        "module": "treat",
+        "params": ["customerId", "page", "size"]
+    },
+    "treat.page_review": {
+        "method": "GET",
+        "path": "/api/v1/tpos/treat/treated-page-review",
+        "description": "分页获取治疗数据",
+        "module": "treat",
+        "params": ["page", "size", "tenantId"]
+    },
+    "treat.operating_room_list": {
+        "method": "GET",
+        "path": "/api/v1/tpos/treat/get-operating-room-list",
+        "description": "获取治疗时查询的手术间信息",
+        "module": "treat",
+        "params": ["tenantId"]
+    },
+    "treat.begin_info": {
+        "method": "GET",
+        "path": "/api/v1/tpos/treat/get-begin-treat-info",
+        "description": "获取治疗中和已治疗的数据",
+        "module": "treat",
+        "params": ["treatId"]
+    },
+    "treat.deduct_verify": {
+        "method": "POST",
+        "path": "/api/v1/tpos/treat/treat-deduct-verify",
+        "description": "进行核销和划扣",
+        "module": "treat",
+        "body_required": True
+    },
+    "treat.cancel_deduct": {
+        "method": "POST",
+        "path": "/api/v1/tpos/treat/cancel-deduct",
+        "description": "取消划扣",
+        "module": "treat",
+        "body_required": True
+    },
+    "treat.cancel_verify": {
+        "method": "POST",
+        "path": "/api/v1/tpos/treat/cancel-verify",
+        "description": "取消核销",
+        "module": "treat",
+        "body_required": True
+    },
+    "treat.deduct_verify_detail": {
+        "method": "GET",
+        "path": "/api/v1/tpos/treat/get-treated-deduct-and-verify-detail",
+        "description": "已治疗的核销和划扣详情信息",
+        "module": "treat",
+        "params": ["treatId"]
+    },
+    "treat.roles": {
+        "method": "GET",
+        "path": "/api/v1/tpos/treat/get-treatment-roles",
+        "description": "获取所有的治疗岗位列表",
+        "module": "treat",
+        "params": ["tenantId"]
+    },
+    "treat.scrm_list": {
+        "method": "POST",
+        "path": "/api/v1/tpos/treat/scrmTreatList",
+        "description": "小程序-我的治疗（新版）",
+        "module": "treat",
+        "body_required": True
+    },
+    
+    # ========================================
+    # 照片模块 (photo)
+    # ========================================
+    
+    "photo.add": {
+        "method": "POST",
+        "path": "/api/v1/tpos/common/addPhoto",
+        "description": "外部七牛照片转存至睿美云",
+        "module": "photo",
+        "body_required": True
+    },
+    "photo.add_open": {
+        "method": "POST",
+        "path": "/api/v1/tpos/common/addPhotoOpen",
+        "description": "外部照片路径转存至睿美云",
+        "module": "photo",
+        "body_required": True
+    },
+    "photo.upload": {
+        "method": "POST",
+        "path": "/api/v1/tpos/common/upload_customer_photo",
+        "description": "上传照片到睿美云",
+        "module": "photo",
+        "body_required": True
+    },
+    "photo.page": {
+        "method": "GET",
+        "path": "/api/v1/tpos/common/photoPage",
+        "description": "通过客户id分页查询照片信息",
+        "module": "photo",
+        "params": ["customerId", "page", "size"]
+    },
+    "photo.skin_update": {
+        "method": "POST",
+        "path": "/api/v1/tpos/skin_image/update_skin_file",
+        "description": "皮肤检测类图片上传",
+        "module": "photo",
+        "body_required": True
+    },
+    
+    # ========================================
+    # 基础数据模块 (basic)
+    # ========================================
+    
+    "basic.project_page": {
+        "method": "GET",
+        "path": "/api/v1/tpos/basic/project-page",
+        "description": "分页获取项目列表",
+        "module": "basic",
+        "params": ["page", "size", "tenantId", "keyword"]
+    },
+    "basic.project_type_tree": {
+        "method": "GET",
+        "path": "/api/v1/tpos/basic/project-type-tree",
+        "description": "获取项目分类树",
+        "module": "basic",
+        "params": ["tenantId"]
+    },
+    "basic.project_detail": {
+        "method": "GET",
+        "path": "/api/v1/tpos/basic/project-detail",
+        "description": "获取项目详情",
+        "module": "basic",
+        "params": ["projectId"]
+    },
+    "basic.package_page": {
+        "method": "GET",
+        "path": "/api/v1/tpos/basic/package-page",
+        "description": "分页获取套餐列表",
+        "module": "basic",
+        "params": ["page", "size", "tenantId"]
+    },
+    "basic.package_type_tree": {
+        "method": "GET",
+        "path": "/api/v1/tpos/basic/package-type-tree",
+        "description": "获取套餐分类树",
+        "module": "basic",
+        "params": ["tenantId"]
+    },
+    "basic.package_detail": {
+        "method": "GET",
+        "path": "/api/v1/tpos/basic/package-detail",
+        "description": "获取套餐详情",
+        "module": "basic",
+        "params": ["packageId"]
+    },
+    "basic.annual_card_page": {
+        "method": "GET",
+        "path": "/api/v1/tpos/basic/annual-card-page",
+        "description": "分页获取年卡列表",
+        "module": "basic",
+        "params": ["page", "size", "tenantId"]
+    },
+    "basic.annual_card_type_tree": {
+        "method": "GET",
+        "path": "/api/v1/tpos/basic/annual-card-type-tree",
+        "description": "获取年卡分类树",
+        "module": "basic",
+        "params": ["tenantId"]
+    },
+    "basic.annual_card_detail": {
+        "method": "GET",
+        "path": "/api/v1/tpos/basic/annual-card-detail",
+        "description": "获取年卡详情",
+        "module": "basic",
+        "params": ["cardId"]
+    },
+    "basic.time_card_page": {
+        "method": "GET",
+        "path": "/api/v1/tpos/basic/time-card-page",
+        "description": "分页获取次卡列表",
+        "module": "basic",
+        "params": ["page", "size", "tenantId"]
+    },
+    "basic.time_card_type_tree": {
+        "method": "GET",
+        "path": "/api/v1/tpos/basic/time-card-type-tree",
+        "description": "获取次卡分类树",
+        "module": "basic",
+        "params": ["tenantId"]
+    },
+    "basic.time_card_detail": {
+        "method": "GET",
+        "path": "/api/v1/tpos/basic/time-card-detail",
+        "description": "获取次卡详情",
+        "module": "basic",
+        "params": ["cardId"]
+    },
+    
+    # ========================================
+    # 预约模块 (cusbespeak)
+    # ========================================
+    
+    "appointment.add": {
+        "method": "POST",
+        "path": "/api/v1/tpos/cusbespeak/add",
+        "description": "新增预约",
+        "module": "appointment",
+        "body_required": True
+    },
+    "appointment.update": {
+        "method": "POST",
+        "path": "/api/v1/tpos/cusbespeak/update",
+        "description": "修改预约",
+        "module": "appointment",
+        "body_required": True
+    },
+    "appointment.confirm": {
+        "method": "POST",
+        "path": "/api/v1/tpos/cusbespeak/confirm",
+        "description": "确认预约",
+        "module": "appointment",
+        "body_required": True
+    },
+    "appointment.cancel": {
+        "method": "POST",
+        "path": "/api/v1/tpos/cusbespeak/cancel",
+        "description": "取消预约",
+        "module": "appointment",
+        "body_required": True
+    },
+    "appointment.page": {
+        "method": "POST",
+        "path": "/api/v1/tpos/cusbespeak/page",
+        "description": "预约分页查询",
+        "module": "appointment",
+        "body_required": True
+    },
+    "appointment.doctor_list": {
+        "method": "GET",
+        "path": "/api/v1/tpos/cusbespeak/doctor-list",
+        "description": "获取可选择的预约医生",
+        "module": "appointment",
+        "params": ["tenantId"]
+    },
+    "appointment.schedule": {
+        "method": "GET",
+        "path": "/api/v1/tpos/cusbespeak/schedule",
+        "description": "查询预约专家排班",
+        "module": "appointment",
+        "params": ["doctorId", "date"]
+    },
+    
+    # ========================================
+    # 渠道模块 (channel)
+    # ========================================
+    
+    "channel.type_select": {
+        "method": "GET",
+        "path": "/api/v1/tpos/channel/type-select",
+        "description": "整合渠道类型选择（建档，报备）",
+        "module": "channel",
+        "params": ["tenantId"]
+    },
+    "channel.list_by_type": {
+        "method": "GET",
+        "path": "/api/v1/tpos/channel/list-by-type",
+        "description": "通过渠道类型获取渠道列表",
+        "module": "channel",
+        "params": ["typeId", "tenantId"]
+    },
+    "channel.info": {
+        "method": "GET",
+        "path": "/api/v1/tpos/channel/info",
+        "description": "查询渠道信息",
+        "module": "channel",
+        "params": ["channelId"]
+    },
+    "channel.media_info": {
+        "method": "GET",
+        "path": "/api/v1/tpos/channel/media-info",
+        "description": "查询运营媒体信息",
+        "module": "channel",
+        "params": ["mediaId"]
+    },
+    
+    # ========================================
+    # 接待模块 (reception)
+    # ========================================
+    
+    "reception.triage_list": {
+        "method": "GET",
+        "path": "/api/v1/tpos/reception/triage-list",
+        "description": "可用的接待分诊人列表",
+        "module": "reception",
+        "params": ["tenantId"]
+    },
+    "reception.add": {
+        "method": "POST",
+        "path": "/api/v1/tpos/reception/add",
+        "description": "新增接待",
+        "module": "reception",
+        "body_required": True
+    },
+    "reception.query": {
+        "method": "GET",
+        "path": "/api/v1/tpos/reception/query",
+        "description": "查询客户接待信息",
+        "module": "reception",
+        "params": ["customerId"]
+    },
+    "reception.sign_init": {
+        "method": "GET",
+        "path": "/api/v1/tpos/reception/sign-init",
+        "description": "客户扫码签到初始化数据(小程序)",
+        "module": "reception",
+        "params": ["tenantId"]
+    },
+    "reception.sign": {
+        "method": "POST",
+        "path": "/api/v1/tpos/reception/sign",
+        "description": "客户扫码签到(小程序)",
+        "module": "reception",
+        "body_required": True
+    },
+    
+    # ========================================
+    # 咨询模块 (consult)
+    # ========================================
+    
+    "consult.add": {
+        "method": "POST",
+        "path": "/api/v1/tpos/consult/add",
+        "description": "新增咨询",
+        "module": "consult",
+        "body_required": True
+    },
+    "consult.update": {
+        "method": "POST",
+        "path": "/api/v1/tpos/consult/update",
+        "description": "修改咨询",
+        "module": "consult",
+        "body_required": True
+    },
+    
+    # ========================================
+    # 病历模块 (medical_record)
+    # ========================================
+    
+    "medical_record.add": {
+        "method": "POST",
+        "path": "/api/v1/tpos/medical-record/add",
+        "description": "新增病历",
+        "module": "medical_record",
+        "body_required": True
+    },
+    "medical_record.update": {
+        "method": "POST",
+        "path": "/api/v1/tpos/medical-record/update",
+        "description": "修改病历",
+        "module": "medical_record",
+        "body_required": True
+    },
+    "medical_record.delete": {
+        "method": "POST",
+        "path": "/api/v1/tpos/medical-record/delete",
+        "description": "删除病历",
+        "module": "medical_record",
+        "body_required": True
+    },
+}
+
+
+def get_api_definition(api_name: str) -> Optional[Dict[str, Any]]:
+    """
+    获取接口定义
+    
+    Args:
+        api_name: 接口名称，如 customer.search
+        
+    Returns:
+        接口定义字典，不存在则返回 None
+    """
+    return RUIMEIYUN_APIS.get(api_name)
+
+
+def get_api_list_by_module(module: str) -> List[Dict[str, Any]]:
+    """
+    按模块获取接口列表
+    
+    Args:
+        module: 模块名称，如 customer, order
+        
+    Returns:
+        该模块下的接口列表
+    """
+    result = []
+    for name, definition in RUIMEIYUN_APIS.items():
+        if definition.get("module") == module:
+            result.append({"name": name, **definition})
+    return result
+
+
+def get_all_modules() -> List[str]:
+    """获取所有模块名称"""
+    modules = set()
+    for definition in RUIMEIYUN_APIS.values():
+        if "module" in definition:
+            modules.add(definition["module"])
+    return sorted(list(modules))
+
+
+def get_api_summary() -> Dict[str, int]:
+    """获取接口统计"""
+    summary = {}
+    for definition in RUIMEIYUN_APIS.values():
+        module = definition.get("module", "unknown")
+        summary[module] = summary.get(module, 0) + 1
+    return summary

backend/app/services/scheduler.py

@@ -0,0 +1,609 @@
+"""定时任务调度服务"""
+import json
+import httpx
+import asyncio
+from datetime import datetime
+from typing import Optional
+from apscheduler.schedulers.asyncio import AsyncIOScheduler
+from apscheduler.triggers.cron import CronTrigger
+from sqlalchemy.orm import Session
+
+from ..database import SessionLocal
+from ..models.scheduled_task import ScheduledTask, TaskLog
+from ..models.notification_channel import TaskNotifyChannel
+from .script_executor import ScriptExecutor
+
+
+class SchedulerService:
+    """调度服务 - 管理定时任务的调度和执行"""
+    
+    _instance: Optional['SchedulerService'] = None
+    _scheduler: Optional[AsyncIOScheduler] = None
+    
+    def __new__(cls):
+        if cls._instance is None:
+            cls._instance = super().__new__(cls)
+        return cls._instance
+    
+    def __init__(self):
+        if self._scheduler is None:
+            self._scheduler = AsyncIOScheduler(timezone='Asia/Shanghai')
+    
+    @property
+    def scheduler(self) -> AsyncIOScheduler:
+        return self._scheduler
+    
+    def start(self):
+        """启动调度器并加载所有任务"""
+        if not self._scheduler.running:
+            self._scheduler.start()
+            self._load_all_tasks()
+            print("调度器已启动")
+    
+    def shutdown(self):
+        """关闭调度器"""
+        if self._scheduler.running:
+            self._scheduler.shutdown()
+            print("调度器已关闭")
+    
+    def _load_all_tasks(self):
+        """从数据库加载所有启用的任务"""
+        db = SessionLocal()
+        try:
+            tasks = db.query(ScheduledTask).filter(ScheduledTask.is_enabled == True).all()
+            for task in tasks:
+                self._add_task_to_scheduler(task)
+            print(f"已加载 {len(tasks)} 个定时任务")
+        finally:
+            db.close()
+    
+    def _add_task_to_scheduler(self, task: ScheduledTask):
+        """将任务添加到调度器"""
+        job_id = f"task_{task.id}"
+        
+        # 移除已存在的任务
+        if self._scheduler.get_job(job_id):
+            self._scheduler.remove_job(job_id)
+        
+        if task.schedule_type == 'cron' and task.cron_expression:
+            # CRON模式
+            try:
+                trigger = CronTrigger.from_crontab(task.cron_expression, timezone='Asia/Shanghai')
+                self._scheduler.add_job(
+                    self._execute_task,
+                    trigger,
+                    id=job_id,
+                    args=[task.id],
+                    replace_existing=True
+                )
+            except Exception as e:
+                print(f"任务 {task.id} CRON表达式解析失败: {e}")
+        
+        elif task.schedule_type == 'simple' and task.time_points:
+            # 简单模式 - 多个时间点
+            try:
+                time_points = task.time_points if isinstance(task.time_points, list) else json.loads(task.time_points)
+                for i, time_point in enumerate(time_points):
+                    hour, minute = map(int, time_point.split(':'))
+                    sub_job_id = f"{job_id}_{i}"
+                    self._scheduler.add_job(
+                        self._execute_task,
+                        CronTrigger(hour=hour, minute=minute, timezone='Asia/Shanghai'),
+                        id=sub_job_id,
+                        args=[task.id],
+                        replace_existing=True
+                    )
+            except Exception as e:
+                print(f"任务 {task.id} 时间点解析失败: {e}")
+    
+    def add_task(self, task_id: int):
+        """添加或更新任务调度"""
+        db = SessionLocal()
+        try:
+            task = db.query(ScheduledTask).filter(ScheduledTask.id == task_id).first()
+            if task and task.is_enabled:
+                self._add_task_to_scheduler(task)
+        finally:
+            db.close()
+    
+    def remove_task(self, task_id: int):
+        """移除任务调度"""
+        job_id = f"task_{task_id}"
+        
+        # 移除主任务
+        if self._scheduler.get_job(job_id):
+            self._scheduler.remove_job(job_id)
+        
+        # 移除简单模式的子任务
+        for i in range(24):  # 最多24个时间点
+            sub_job_id = f"{job_id}_{i}"
+            if self._scheduler.get_job(sub_job_id):
+                self._scheduler.remove_job(sub_job_id)
+    
+    async def _execute_task(self, task_id: int):
+        """执行任务（带重试）"""
+        db = SessionLocal()
+        try:
+            task = db.query(ScheduledTask).filter(ScheduledTask.id == task_id).first()
+            if not task:
+                return
+            
+            max_retries = task.retry_count or 0
+            retry_interval = task.retry_interval or 60
+            
+            for attempt in range(max_retries + 1):
+                success, output, error = await self._execute_task_once(db, task)
+                
+                if success:
+                    return
+                
+                # 如果还有重试机会
+                if attempt < max_retries:
+                    print(f"任务 {task_id} 执行失败，{retry_interval}秒后重试 ({attempt + 1}/{max_retries})")
+                    await asyncio.sleep(retry_interval)
+                else:
+                    # 最后一次失败，发送告警
+                    if task.alert_on_failure and task.alert_webhook:
+                        await self._send_alert(task, error)
+        finally:
+            db.close()
+    
+    async def _execute_task_once(self, db: Session, task: ScheduledTask):
+        """执行一次任务"""
+        trace_id = f"{int(datetime.now().timestamp())}-{task.id}"
+        started_at = datetime.now()
+        
+        # 创建日志记录
+        log = TaskLog(
+            task_id=task.id,
+            tenant_id=task.tenant_id,
+            trace_id=trace_id,
+            status='running',
+            started_at=started_at
+        )
+        db.add(log)
+        db.commit()
+        db.refresh(log)
+        
+        success = False
+        output = ''
+        error = ''
+        result = None
+        
+        try:
+            # 解析输入参数
+            params = {}
+            if task.input_params:
+                params = task.input_params if isinstance(task.input_params, dict) else {}
+            
+            if task.execution_type == 'webhook':
+                success, output, error = await self._execute_webhook(task)
+            else:
+                success, output, error, result = await self._execute_script(db, task, trace_id, params)
+            
+            # 如果脚本执行成功且有返回内容，发送通知
+            if success and result and result.get('content'):
+                await self._send_notifications(db, task, result)
+            
+        except Exception as e:
+            error = str(e)
+        
+        # 更新日志
+        finished_at = datetime.now()
+        duration_ms = int((finished_at - started_at).total_seconds() * 1000)
+        
+        log.status = 'success' if success else 'failed'
+        log.finished_at = finished_at
+        log.duration_ms = duration_ms
+        log.output = output[:10000] if output else None  # 限制长度
+        log.error = error[:5000] if error else None
+        
+        # 更新任务状态
+        task.last_run_at = finished_at
+        task.last_run_status = 'success' if success else 'failed'
+        
+        db.commit()
+        
+        return success, output, error
+    
+    async def _execute_webhook(self, task: ScheduledTask):
+        """执行Webhook任务"""
+        try:
+            body = {}
+            if task.input_params:
+                body = task.input_params if isinstance(task.input_params, dict) else {}
+            
+            async with httpx.AsyncClient(timeout=30) as client:
+                response = await client.post(task.webhook_url, json=body)
+                response.raise_for_status()
+                return True, response.text[:5000], ''
+                
+        except Exception as e:
+            return False, '', str(e)
+    
+    async def _execute_script(self, db: Session, task: ScheduledTask, trace_id: str, params: dict):
+        """执行脚本任务"""
+        if not task.script_content:
+            return False, '', '脚本内容为空', None
+        
+        executor = ScriptExecutor(db)
+        success, output, error, result = executor.execute(
+            script_content=task.script_content,
+            task_id=task.id,
+            tenant_id=task.tenant_id,
+            trace_id=trace_id,
+            params=params,
+            timeout=300  # 默认超时
+        )
+        
+        return success, output, error, result
+    
+    async def _send_notifications(self, db: Session, task: ScheduledTask, result: dict):
+        """发送通知到配置的渠道
+        
+        result 格式:
+        - 简单格式: {'content': '内容', 'title': '标题'}
+        - 完整格式: {'msg_type': 'actionCard', 'title': '...', 'content': '...', 'buttons': [...]}
+        
+        支持的 msg_type:
+        - text: 纯文本
+        - markdown: Markdown格式（默认）
+        - link: 链接消息
+        - actionCard: 交互卡片（带按钮）
+        - feedCard: 信息流卡片
+        - news: 图文消息（企微）
+        - template_card: 模板卡片（企微）
+        """
+        content = result.get('content', '')
+        title = result.get('title', task.task_name)
+        
+        if not content and result.get('msg_type') not in ('feedCard', 'news', 'template_card'):
+            return
+        
+        # 获取通知渠道配置
+        channel_ids = task.notify_channels
+        if isinstance(channel_ids, str):
+            try:
+                channel_ids = json.loads(channel_ids)
+            except:
+                channel_ids = []
+        
+        if not channel_ids:
+            channel_ids = []
+        
+        # 发送到通知渠道
+        for channel_id in channel_ids:
+            try:
+                channel = db.query(TaskNotifyChannel).filter(
+                    TaskNotifyChannel.id == channel_id,
+                    TaskNotifyChannel.is_enabled == True
+                ).first()
+                
+                if not channel:
+                    continue
+                
+                await self._send_to_channel(channel, result)
+                
+            except Exception as e:
+                print(f"发送通知到渠道 {channel_id} 失败: {e}")
+        
+        # 发送到企微应用
+        if task.notify_wecom_app_id:
+            try:
+                await self._send_to_wecom_app(db, task.notify_wecom_app_id, result, task.tenant_id)
+            except Exception as e:
+                print(f"发送企微应用消息失败: {e}")
+    
+    async def _send_to_channel(self, channel: TaskNotifyChannel, result: dict):
+        """发送消息到通知渠道
+        
+        钉钉支持: text, markdown, link, actionCard, feedCard
+        企微支持: text, markdown, image, news, template_card
+        """
+        import time
+        import hmac
+        import hashlib
+        import base64
+        import urllib.parse
+        
+        url = channel.webhook_url
+        msg_type = result.get('msg_type', 'markdown')
+        title = result.get('title', '通知')
+        content = result.get('content', '')
+        
+        if channel.channel_type == 'dingtalk_bot':
+            # 钉钉加签
+            if channel.sign_secret:
+                timestamp = str(round(time.time() * 1000))
+                string_to_sign = f'{timestamp}\n{channel.sign_secret}'
+                hmac_code = hmac.new(
+                    channel.sign_secret.encode('utf-8'), 
+                    string_to_sign.encode('utf-8'), 
+                    digestmod=hashlib.sha256
+                ).digest()
+                sign = urllib.parse.quote_plus(base64.b64encode(hmac_code))
+                
+                if '?' in url:
+                    url = f"{url}&timestamp={timestamp}&sign={sign}"
+                else:
+                    url = f"{url}?timestamp={timestamp}&sign={sign}"
+            
+            payload = self._build_dingtalk_payload(msg_type, title, content, result)
+        else:  # wecom_bot
+            payload = self._build_wecom_payload(msg_type, title, content, result)
+        
+        async with httpx.AsyncClient(timeout=10) as client:
+            response = await client.post(url, json=payload)
+            resp = response.json()
+            if resp.get('errcode') != 0:
+                print(f"通知发送失败: {resp}")
+    
+    def _build_dingtalk_payload(self, msg_type: str, title: str, content: str, result: dict) -> dict:
+        """构建钉钉消息体
+        
+        支持类型:
+        - text: 纯文本
+        - markdown: Markdown
+        - link: 链接消息
+        - actionCard: 交互卡片（整体跳转/独立跳转）
+        - feedCard: 信息流卡片
+        """
+        if msg_type == 'text':
+            return {
+                "msgtype": "text",
+                "text": {"content": content},
+                "at": result.get('at', {})
+            }
+        
+        elif msg_type == 'link':
+            return {
+                "msgtype": "link",
+                "link": {
+                    "title": title,
+                    "text": content,
+                    "messageUrl": result.get('url', ''),
+                    "picUrl": result.get('pic_url', '')
+                }
+            }
+        
+        elif msg_type == 'actionCard':
+            buttons = result.get('buttons', [])
+            card = {
+                "title": title,
+                "text": content,
+                "btnOrientation": result.get('btn_orientation', '0')  # 0-竖向 1-横向
+            }
+            
+            if len(buttons) == 1:
+                # 整体跳转
+                card["singleTitle"] = buttons[0].get('title', '查看详情')
+                card["singleURL"] = buttons[0].get('url', '')
+            elif len(buttons) > 1:
+                # 独立跳转
+                card["btns"] = [
+                    {"title": btn.get('title', ''), "actionURL": btn.get('url', '')}
+                    for btn in buttons
+                ]
+            
+            return {"msgtype": "actionCard", "actionCard": card}
+        
+        elif msg_type == 'feedCard':
+            links = result.get('links', [])
+            return {
+                "msgtype": "feedCard",
+                "feedCard": {
+                    "links": [
+                        {
+                            "title": link.get('title', ''),
+                            "messageURL": link.get('url', ''),
+                            "picURL": link.get('pic_url', '')
+                        }
+                        for link in links
+                    ]
+                }
+            }
+        
+        else:  # markdown（默认）
+            return {
+                "msgtype": "markdown",
+                "markdown": {"title": title, "text": content},
+                "at": result.get('at', {})
+            }
+    
+    def _build_wecom_payload(self, msg_type: str, title: str, content: str, result: dict) -> dict:
+        """构建企微消息体
+        
+        支持类型:
+        - text: 纯文本
+        - markdown: Markdown
+        - image: 图片
+        - news: 图文消息
+        - template_card: 模板卡片
+        """
+        if msg_type == 'text':
+            payload = {
+                "msgtype": "text",
+                "text": {"content": content}
+            }
+            if result.get('mentioned_list'):
+                payload["text"]["mentioned_list"] = result.get('mentioned_list')
+            if result.get('mentioned_mobile_list'):
+                payload["text"]["mentioned_mobile_list"] = result.get('mentioned_mobile_list')
+            return payload
+        
+        elif msg_type == 'image':
+            return {
+                "msgtype": "image",
+                "image": {
+                    "base64": result.get('image_base64', ''),
+                    "md5": result.get('image_md5', '')
+                }
+            }
+        
+        elif msg_type == 'news':
+            articles = result.get('articles', [])
+            if not articles and content:
+                articles = [{
+                    "title": title,
+                    "description": content,
+                    "url": result.get('url', ''),
+                    "picurl": result.get('pic_url', '')
+                }]
+            return {
+                "msgtype": "news",
+                "news": {"articles": articles}
+            }
+        
+        elif msg_type == 'template_card':
+            card_type = result.get('card_type', 'text_notice')
+            
+            if card_type == 'text_notice':
+                # 文本通知卡片
+                return {
+                    "msgtype": "template_card",
+                    "template_card": {
+                        "card_type": "text_notice",
+                        "main_title": {"title": title, "desc": result.get('desc', '')},
+                        "sub_title_text": content,
+                        "horizontal_content_list": result.get('horizontal_list', []),
+                        "jump_list": result.get('jump_list', []),
+                        "card_action": result.get('card_action', {"type": 1, "url": ""})
+                    }
+                }
+            
+            elif card_type == 'news_notice':
+                # 图文展示卡片
+                return {
+                    "msgtype": "template_card",
+                    "template_card": {
+                        "card_type": "news_notice",
+                        "main_title": {"title": title, "desc": result.get('desc', '')},
+                        "card_image": {"url": result.get('image_url', ''), "aspect_ratio": result.get('aspect_ratio', 1.3)},
+                        "vertical_content_list": result.get('vertical_list', []),
+                        "horizontal_content_list": result.get('horizontal_list', []),
+                        "jump_list": result.get('jump_list', []),
+                        "card_action": result.get('card_action', {"type": 1, "url": ""})
+                    }
+                }
+            
+            elif card_type == 'button_interaction':
+                # 按钮交互卡片
+                return {
+                    "msgtype": "template_card",
+                    "template_card": {
+                        "card_type": "button_interaction",
+                        "main_title": {"title": title, "desc": result.get('desc', '')},
+                        "sub_title_text": content,
+                        "horizontal_content_list": result.get('horizontal_list', []),
+                        "button_list": result.get('buttons', []),
+                        "card_action": result.get('card_action', {"type": 1, "url": ""})
+                    }
+                }
+        
+        else:  # markdown（默认）
+            return {
+                "msgtype": "markdown",
+                "markdown": {"content": f"**{title}**\n\n{content}"}
+            }
+    
+    async def _send_to_wecom_app(self, db: Session, app_id: int, result: dict, tenant_id: str):
+        """发送消息到企微应用"""
+        from ..models.tenant_wechat_app import TenantWechatApp
+        
+        app = db.query(TenantWechatApp).filter(TenantWechatApp.id == app_id).first()
+        if not app:
+            return
+        
+        # 获取 access_token
+        access_token = await self._get_wecom_access_token(app.corp_id, app.app_secret)
+        if not access_token:
+            return
+        
+        title = result.get('title', '通知')
+        content = result.get('content', '')
+        
+        # 发送消息
+        url = f"https://qyapi.weixin.qq.com/cgi-bin/message/send?access_token={access_token}"
+        payload = {
+            "touser": result.get('touser', '@all'),
+            "msgtype": "markdown",
+            "agentid": app.agent_id,
+            "markdown": {
+                "content": f"**{title}**\n\n{content}"
+            }
+        }
+        
+        async with httpx.AsyncClient(timeout=10) as client:
+            response = await client.post(url, json=payload)
+            result = response.json()
+            if result.get('errcode') != 0:
+                print(f"企微应用消息发送失败: {result}")
+    
+    async def _get_wecom_access_token(self, corp_id: str, app_secret: str) -> Optional[str]:
+        """获取企微 access_token"""
+        url = f"https://qyapi.weixin.qq.com/cgi-bin/gettoken?corpid={corp_id}&corpsecret={app_secret}"
+        
+        async with httpx.AsyncClient(timeout=10) as client:
+            response = await client.get(url)
+            result = response.json()
+            if result.get('errcode') == 0:
+                return result.get('access_token')
+            else:
+                print(f"获取企微 access_token 失败: {result}")
+                return None
+
+    async def _send_alert(self, task: ScheduledTask, error: str):
+        """发送失败告警"""
+        if not task.alert_webhook:
+            return
+        
+        content = f"""### 定时任务执行失败告警
+
+**任务名称**: {task.task_name}
+**任务ID**: {task.id}
+**租户**: {task.tenant_id or '全局'}
+**失败时间**: {datetime.now().strftime('%Y-%m-%d %H:%M:%S')}
+**错误信息**: 
+```
+{error[:500] if error else '未知错误'}
+```"""
+        
+        try:
+            # 判断是钉钉还是企微
+            if 'dingtalk' in task.alert_webhook or 'oapi.dingtalk.com' in task.alert_webhook:
+                payload = {
+                    "msgtype": "markdown",
+                    "markdown": {"title": "任务失败告警", "text": content}
+                }
+            else:
+                payload = {
+                    "msgtype": "markdown", 
+                    "markdown": {"content": content}
+                }
+            
+            async with httpx.AsyncClient(timeout=10) as client:
+                await client.post(task.alert_webhook, json=payload)
+        except Exception as e:
+            print(f"发送告警失败: {e}")
+    
+    async def run_task_now(self, task_id: int) -> dict:
+        """立即执行任务（手动触发）"""
+        db = SessionLocal()
+        try:
+            task = db.query(ScheduledTask).filter(ScheduledTask.id == task_id).first()
+            if not task:
+                return {"success": False, "error": "任务不存在"}
+            
+            success, output, error = await self._execute_task_once(db, task)
+            
+            return {
+                "success": success,
+                "output": output,
+                "error": error
+            }
+        finally:
+            db.close()
+
+
+# 全局调度器实例
+scheduler_service = SchedulerService()

backend/app/services/script_executor.py

@@ -0,0 +1,285 @@
+"""脚本执行器 - 安全执行Python脚本"""
+import sys
+import traceback
+from io import StringIO
+from typing import Any, Dict, Optional, Tuple
+from datetime import datetime
+from sqlalchemy.orm import Session
+
+from .script_sdk import ScriptSDK
+
+
+# 禁止导入的模块
+FORBIDDEN_MODULES = {
+    'os', 'subprocess', 'shutil', 'pathlib',
+    'socket', 'ftplib', 'telnetlib', 'smtplib',
+    'pickle', 'shelve', 'marshal',
+    'ctypes', 'multiprocessing',
+    '__builtins__', 'builtins',
+    'importlib', 'imp',
+    'code', 'codeop', 'compile',
+}
+
+# 允许的内置函数
+ALLOWED_BUILTINS = {
+    'abs', 'all', 'any', 'ascii', 'bin', 'bool', 'bytearray', 'bytes',
+    'callable', 'chr', 'complex', 'dict', 'dir', 'divmod', 'enumerate',
+    'filter', 'float', 'format', 'frozenset', 'getattr', 'hasattr', 'hash',
+    'hex', 'id', 'int', 'isinstance', 'issubclass', 'iter', 'len', 'list',
+    'map', 'max', 'min', 'next', 'object', 'oct', 'ord', 'pow', 'print',
+    'range', 'repr', 'reversed', 'round', 'set', 'setattr', 'slice',
+    'sorted', 'str', 'sum', 'tuple', 'type', 'vars', 'zip',
+    'True', 'False', 'None',
+    'Exception', 'BaseException', 'ValueError', 'TypeError', 'KeyError',
+    'IndexError', 'AttributeError', 'RuntimeError', 'StopIteration',
+}
+
+
+class ScriptExecutor:
+    """脚本执行器"""
+    
+    def __init__(self, db: Session):
+        self.db = db
+    
+    def execute(
+        self,
+        script_content: str,
+        task_id: int,
+        tenant_id: Optional[str] = None,
+        trace_id: Optional[str] = None,
+        params: Optional[Dict[str, Any]] = None,
+        timeout: int = 300
+    ) -> Tuple[bool, str, str, Optional[Dict]]:
+        """执行脚本
+        
+        Args:
+            script_content: Python脚本内容
+            task_id: 任务ID
+            tenant_id: 租户ID
+            trace_id: 追踪ID
+            params: 输入参数
+            timeout: 超时秒数
+            
+        Returns:
+            (success, output, error, result)
+            result: 脚本返回值 {'content': '...', 'title': '...'}
+        """
+        # 创建SDK实例
+        sdk = ScriptSDK(
+            db=self.db,
+            task_id=task_id,
+            tenant_id=tenant_id,
+            trace_id=trace_id,
+            params=params or {}
+        )
+        
+        # 检查脚本安全性
+        check_result = self._check_script_safety(script_content)
+        if check_result:
+            return False, '', f"脚本安全检查失败: {check_result}", None
+        
+        # 准备执行环境
+        safe_globals = self._create_safe_globals(sdk)
+        
+        # 捕获输出
+        old_stdout = sys.stdout
+        old_stderr = sys.stderr
+        stdout_capture = StringIO()
+        stderr_capture = StringIO()
+        
+        try:
+            sys.stdout = stdout_capture
+            sys.stderr = stderr_capture
+            
+            # 编译并执行脚本
+            compiled = compile(script_content, '<script>', 'exec')
+            exec(compiled, safe_globals)
+            
+            # 获取输出
+            stdout_output = stdout_capture.getvalue()
+            sdk_output = sdk.get_output()
+            
+            # 合并输出
+            output = '\n'.join(filter(None, [sdk_output, stdout_output]))
+            
+            # 获取脚本返回值（通过 __result__ 变量）
+            result = safe_globals.get('__result__')
+            if result is None and 'result' in safe_globals:
+                result = safe_globals.get('result')
+            
+            # 如果返回的是字符串，包装成字典
+            if isinstance(result, str):
+                result = {'content': result}
+            elif result is not None and not isinstance(result, dict):
+                result = {'content': str(result)}
+            
+            return True, output, '', result
+            
+        except Exception as e:
+            error_msg = f"{type(e).__name__}: {str(e)}\n{traceback.format_exc()}"
+            return False, sdk.get_output(), error_msg, None
+            
+        finally:
+            sys.stdout = old_stdout
+            sys.stderr = old_stderr
+    
+    def _check_script_safety(self, script_content: str) -> Optional[str]:
+        """检查脚本安全性
+        
+        Returns:
+            错误消息，如果安全则返回None
+        """
+        # 检查危险导入
+        import_patterns = [
+            'import os', 'from os',
+            'import subprocess', 'from subprocess',
+            'import shutil', 'from shutil',
+            'import socket', 'from socket',
+            '__import__',
+            'eval(', 'exec(',
+            'compile(',
+            'open(',  # 禁止文件操作
+        ]
+        
+        script_lower = script_content.lower()
+        for pattern in import_patterns:
+            if pattern.lower() in script_lower:
+                return f"禁止使用: {pattern}"
+        
+        return None
+    
+    def _create_safe_globals(self, sdk: ScriptSDK) -> Dict[str, Any]:
+        """创建安全的执行环境"""
+        import json
+        import re
+        import math
+        import random
+        import hashlib
+        import base64
+        import time
+        import collections
+        from datetime import datetime, date, timedelta
+        from urllib.parse import urlencode, quote, unquote
+        
+        # 允许导入的模块白名单
+        ALLOWED_MODULES = {
+            'json': json,
+            're': re,
+            'math': math,
+            'random': random,
+            'hashlib': hashlib,
+            'base64': base64,
+            'time': time,
+            'datetime': __import__('datetime'),
+            'collections': collections,
+        }
+        
+        def safe_import(name, globals=None, locals=None, fromlist=(), level=0):
+            """受限的 import 函数"""
+            if name in ALLOWED_MODULES:
+                return ALLOWED_MODULES[name]
+            raise ImportError(f"不允许导入模块: {name}。已内置可用: {', '.join(ALLOWED_MODULES.keys())}")
+        
+        # 安全的内置函数
+        safe_builtins = {name: getattr(__builtins__, name, None) 
+                        for name in ALLOWED_BUILTINS 
+                        if hasattr(__builtins__, name) or name in dir(__builtins__)}
+        
+        # 如果 __builtins__ 是字典
+        if isinstance(__builtins__, dict):
+            safe_builtins = {name: __builtins__.get(name) 
+                           for name in ALLOWED_BUILTINS 
+                           if name in __builtins__}
+        
+        # 添加受限的 __import__
+        safe_builtins['__import__'] = safe_import
+        
+        # 添加常用异常
+        safe_builtins['Exception'] = Exception
+        safe_builtins['ValueError'] = ValueError
+        safe_builtins['TypeError'] = TypeError
+        safe_builtins['KeyError'] = KeyError
+        safe_builtins['IndexError'] = IndexError
+        safe_builtins['ImportError'] = ImportError
+        
+        return {
+            '__builtins__': safe_builtins,
+            '__name__': '__main__',
+            
+            # SDK函数（全局可用）
+            'log': sdk.log,
+            'print': sdk.print,
+            'ai': sdk.ai,
+            'dingtalk': sdk.dingtalk,
+            'wecom': sdk.wecom,
+            'http_get': sdk.http_get,
+            'http_post': sdk.http_post,
+            'db_query': sdk.db_query,
+            'get_var': sdk.get_var,
+            'set_var': sdk.set_var,
+            'del_var': sdk.del_var,
+            'get_param': sdk.get_param,
+            'get_params': sdk.get_params,
+            'get_tenants': sdk.get_tenants,
+            'get_tenant_config': sdk.get_tenant_config,
+            'get_all_tenant_configs': sdk.get_all_tenant_configs,
+            'get_secret': sdk.get_secret,
+            
+            # 当前上下文
+            'task_id': sdk.task_id,
+            'tenant_id': sdk.tenant_id,
+            'trace_id': sdk.trace_id,
+            
+            # 安全的标准库
+            'json': json,
+            're': re,
+            'math': math,
+            'random': random,
+            'hashlib': hashlib,
+            'base64': base64,
+            'datetime': datetime,
+            'date': date,
+            'timedelta': timedelta,
+            'time': time,
+            'urlencode': urlencode,
+            'quote': quote,
+            'unquote': unquote,
+        }
+    
+    def test_script(
+        self,
+        script_content: str,
+        task_id: int = 0,
+        tenant_id: Optional[str] = None,
+        params: Optional[Dict[str, Any]] = None
+    ) -> Dict[str, Any]:
+        """测试脚本（用于调试）
+        
+        Returns:
+            {
+                "success": bool,
+                "output": str,
+                "error": str,
+                "duration_ms": int,
+                "result": dict
+            }
+        """
+        start_time = datetime.now()
+        
+        success, output, error, result = self.execute(
+            script_content=script_content,
+            task_id=task_id,
+            tenant_id=tenant_id,
+            trace_id=f"test-{start_time.timestamp()}",
+            params=params
+        )
+        
+        duration_ms = int((datetime.now() - start_time).total_seconds() * 1000)
+        
+        return {
+            "success": success,
+            "output": output,
+            "error": error,
+            "duration_ms": duration_ms,
+            "result": result
+        }

backend/app/services/script_sdk.py

@@ -0,0 +1,479 @@
+"""脚本执行SDK - 为Python脚本提供内置功能"""
+import json
+import os
+import httpx
+from datetime import datetime
+from typing import Any, Dict, List, Optional
+from sqlalchemy.orm import Session
+
+
+class ScriptSDK:
+    """脚本SDK - 提供AI、通知、数据库、HTTP、变量存储等功能"""
+    
+    def __init__(
+        self,
+        db: Session,
+        task_id: int,
+        tenant_id: Optional[str] = None,
+        trace_id: Optional[str] = None,
+        params: Optional[Dict[str, Any]] = None
+    ):
+        self.db = db
+        self.task_id = task_id
+        self.tenant_id = tenant_id
+        self.trace_id = trace_id
+        self.params = params or {}
+        
+        self._logs: List[Dict] = []
+        self._output: List[str] = []
+        self._tenants_cache: Dict = {}
+        
+        # AI 配置
+        self._ai_base_url = os.getenv('OPENAI_BASE_URL', 'https://api.4sapi.net/v1')
+        self._ai_api_key = os.getenv('OPENAI_API_KEY', 'sk-9yMCXjRGANbacz20kJY8doSNy6Rf446aYwmgGIuIXQ7DAyBw')
+        self._ai_model = os.getenv('OPENAI_MODEL', 'gemini-2.5-flash')
+    
+    # ==================== 参数获取 ====================
+    
+    def get_param(self, key: str, default: Any = None) -> Any:
+        """获取任务参数
+        
+        Args:
+            key: 参数名
+            default: 默认值
+            
+        Returns:
+            参数值
+        """
+        return self.params.get(key, default)
+    
+    def get_params(self) -> Dict[str, Any]:
+        """获取所有任务参数
+        
+        Returns:
+            所有参数字典
+        """
+        return self.params.copy()
+    
+    # ==================== 日志 ====================
+    
+    def log(self, message: str, level: str = 'INFO') -> None:
+        """记录日志
+        
+        Args:
+            message: 日志内容
+            level: 日志级别 (INFO, WARN, ERROR)
+        """
+        log_entry = {
+            'time': datetime.now().isoformat(),
+            'level': level.upper(),
+            'message': message
+        }
+        self._logs.append(log_entry)
+        self._output.append(f"[{level.upper()}] {message}")
+    
+    def print(self, *args, **kwargs) -> None:
+        """打印输出（兼容print）"""
+        message = ' '.join(str(arg) for arg in args)
+        self._output.append(message)
+    
+    def get_logs(self) -> List[Dict]:
+        """获取所有日志"""
+        return self._logs
+    
+    def get_output(self) -> str:
+        """获取所有输出"""
+        return '\n'.join(self._output)
+    
+    # ==================== AI 调用 ====================
+    
+    def ai(
+        self,
+        prompt: str,
+        system: Optional[str] = None,
+        model: Optional[str] = None,
+        temperature: float = 0.7,
+        max_tokens: int = 2000
+    ) -> str:
+        """调用AI模型
+        
+        Args:
+            prompt: 用户提示词
+            system: 系统提示词
+            model: 模型名称（默认gemini-2.5-flash）
+            temperature: 温度参数
+            max_tokens: 最大token数
+            
+        Returns:
+            AI响应内容
+        """
+        model = model or self._ai_model
+        
+        messages = []
+        if system:
+            messages.append({"role": "system", "content": system})
+        messages.append({"role": "user", "content": prompt})
+        
+        try:
+            with httpx.Client(timeout=60) as client:
+                response = client.post(
+                    f"{self._ai_base_url}/chat/completions",
+                    headers={
+                        "Authorization": f"Bearer {self._ai_api_key}",
+                        "Content-Type": "application/json"
+                    },
+                    json={
+                        "model": model,
+                        "messages": messages,
+                        "temperature": temperature,
+                        "max_tokens": max_tokens
+                    }
+                )
+                response.raise_for_status()
+                data = response.json()
+                content = data['choices'][0]['message']['content']
+                self.log(f"AI调用成功: {len(content)} 字符")
+                return content
+        except Exception as e:
+            self.log(f"AI调用失败: {str(e)}", 'ERROR')
+            raise
+    
+    # ==================== 通知 ====================
+    
+    def dingtalk(self, webhook: str, content: str, title: Optional[str] = None, at_all: bool = False) -> bool:
+        """发送钉钉消息
+        
+        Args:
+            webhook: 钉钉机器人webhook地址
+            content: 消息内容（支持Markdown）
+            title: 消息标题
+            at_all: 是否@所有人
+            
+        Returns:
+            是否发送成功
+        """
+        try:
+            payload = {
+                "msgtype": "markdown",
+                "markdown": {
+                    "title": title or "通知",
+                    "text": content + ("\n@所有人" if at_all else "")
+                },
+                "at": {"isAtAll": at_all}
+            }
+            
+            with httpx.Client(timeout=10) as client:
+                response = client.post(webhook, json=payload)
+                response.raise_for_status()
+                result = response.json()
+                success = result.get('errcode') == 0
+                self.log(f"钉钉消息发送{'成功' if success else '失败'}")
+                return success
+        except Exception as e:
+            self.log(f"钉钉消息发送失败: {str(e)}", 'ERROR')
+            return False
+    
+    def wecom(self, webhook: str, content: str, msg_type: str = 'markdown') -> bool:
+        """发送企业微信消息
+        
+        Args:
+            webhook: 企微机器人webhook地址
+            content: 消息内容
+            msg_type: 消息类型 (text, markdown)
+            
+        Returns:
+            是否发送成功
+        """
+        try:
+            if msg_type == 'markdown':
+                payload = {
+                    "msgtype": "markdown",
+                    "markdown": {"content": content}
+                }
+            else:
+                payload = {
+                    "msgtype": "text",
+                    "text": {"content": content}
+                }
+            
+            with httpx.Client(timeout=10) as client:
+                response = client.post(webhook, json=payload)
+                response.raise_for_status()
+                result = response.json()
+                success = result.get('errcode') == 0
+                self.log(f"企微消息发送{'成功' if success else '失败'}")
+                return success
+        except Exception as e:
+            self.log(f"企微消息发送失败: {str(e)}", 'ERROR')
+            return False
+    
+    # ==================== HTTP 请求 ====================
+    
+    def http_get(self, url: str, headers: Optional[Dict] = None, params: Optional[Dict] = None, timeout: int = 30) -> Dict:
+        """发起HTTP GET请求
+        
+        Returns:
+            {"status": 200, "data": ..., "text": "..."}
+        """
+        try:
+            with httpx.Client(timeout=timeout) as client:
+                response = client.get(url, headers=headers, params=params)
+                return {
+                    "status": response.status_code,
+                    "data": response.json() if response.headers.get('content-type', '').startswith('application/json') else None,
+                    "text": response.text
+                }
+        except Exception as e:
+            self.log(f"HTTP GET 失败: {str(e)}", 'ERROR')
+            raise
+    
+    def http_post(self, url: str, data: Any = None, headers: Optional[Dict] = None, timeout: int = 30) -> Dict:
+        """发起HTTP POST请求
+        
+        Returns:
+            {"status": 200, "data": ..., "text": "..."}
+        """
+        try:
+            with httpx.Client(timeout=timeout) as client:
+                response = client.post(url, json=data, headers=headers)
+                return {
+                    "status": response.status_code,
+                    "data": response.json() if response.headers.get('content-type', '').startswith('application/json') else None,
+                    "text": response.text
+                }
+        except Exception as e:
+            self.log(f"HTTP POST 失败: {str(e)}", 'ERROR')
+            raise
+    
+    # ==================== 数据库查询（只读）====================
+    
+    def db_query(self, sql: str, params: Optional[Dict] = None) -> List[Dict]:
+        """执行只读SQL查询
+        
+        Args:
+            sql: SQL语句（必须是SELECT）
+            params: 参数字典
+            
+        Returns:
+            查询结果列表
+        """
+        sql_upper = sql.strip().upper()
+        if not sql_upper.startswith('SELECT'):
+            raise ValueError("只允许执行SELECT查询")
+        
+        # 禁止危险操作
+        forbidden = ['INSERT', 'UPDATE', 'DELETE', 'DROP', 'TRUNCATE', 'ALTER', 'CREATE']
+        for word in forbidden:
+            if word in sql_upper:
+                raise ValueError(f"禁止执行 {word} 操作")
+        
+        try:
+            from sqlalchemy import text
+            result = self.db.execute(text(sql), params or {})
+            columns = result.keys()
+            rows = [dict(zip(columns, row)) for row in result.fetchall()]
+            self.log(f"SQL查询返回 {len(rows)} 条记录")
+            return rows
+        except Exception as e:
+            self.log(f"SQL查询失败: {str(e)}", 'ERROR')
+            raise
+    
+    # ==================== 变量存储 ====================
+    
+    def get_var(self, key: str, default: Any = None) -> Any:
+        """获取持久化变量
+        
+        Args:
+            key: 变量名
+            default: 默认值
+            
+        Returns:
+            变量值
+        """
+        from ..models.scheduled_task import ScriptVar
+        
+        var = self.db.query(ScriptVar).filter(
+            ScriptVar.task_id == self.task_id,
+            ScriptVar.tenant_id == self.tenant_id,
+            ScriptVar.var_key == key
+        ).first()
+        
+        if var and var.var_value:
+            try:
+                return json.loads(var.var_value)
+            except:
+                return var.var_value
+        return default
+    
+    def set_var(self, key: str, value: Any) -> None:
+        """设置持久化变量
+        
+        Args:
+            key: 变量名
+            value: 变量值（会JSON序列化）
+        """
+        from ..models.scheduled_task import ScriptVar
+        
+        var = self.db.query(ScriptVar).filter(
+            ScriptVar.task_id == self.task_id,
+            ScriptVar.tenant_id == self.tenant_id,
+            ScriptVar.var_key == key
+        ).first()
+        
+        value_json = json.dumps(value, ensure_ascii=False)
+        
+        if var:
+            var.var_value = value_json
+        else:
+            var = ScriptVar(
+                task_id=self.task_id,
+                tenant_id=self.tenant_id,
+                var_key=key,
+                var_value=value_json
+            )
+            self.db.add(var)
+        
+        self.db.commit()
+        self.log(f"变量 {key} 已保存")
+    
+    def del_var(self, key: str) -> bool:
+        """删除持久化变量"""
+        from ..models.scheduled_task import ScriptVar
+        
+        result = self.db.query(ScriptVar).filter(
+            ScriptVar.task_id == self.task_id,
+            ScriptVar.tenant_id == self.tenant_id,
+            ScriptVar.var_key == key
+        ).delete()
+        
+        self.db.commit()
+        return result > 0
+    
+    # ==================== 租户配置 ====================
+    
+    def get_tenants(self, app_code: Optional[str] = None) -> List[Dict]:
+        """获取租户列表
+        
+        Args:
+            app_code: 可选，按应用代码筛选
+            
+        Returns:
+            租户列表 [{"tenant_id": ..., "tenant_name": ...}, ...]
+        """
+        from ..models.tenant import Tenant
+        from ..models.tenant_app import TenantApp
+        
+        if app_code:
+            # 获取订阅了该应用的租户
+            tenant_ids = self.db.query(TenantApp.tenant_id).filter(
+                TenantApp.app_code == app_code,
+                TenantApp.status == 1
+            ).all()
+            tenant_ids = [t[0] for t in tenant_ids]
+            
+            tenants = self.db.query(Tenant).filter(
+                Tenant.code.in_(tenant_ids),
+                Tenant.status == 'active'
+            ).all()
+        else:
+            tenants = self.db.query(Tenant).filter(Tenant.status == 'active').all()
+        
+        return [{"tenant_id": t.code, "tenant_name": t.name} for t in tenants]
+    
+    def get_tenant_config(self, tenant_id: str, app_code: str, key: Optional[str] = None) -> Any:
+        """获取租户的应用配置
+        
+        Args:
+            tenant_id: 租户ID
+            app_code: 应用代码
+            key: 配置键（可选，不提供则返回所有配置）
+            
+        Returns:
+            配置值或配置字典
+        """
+        from ..models.tenant_app import TenantApp
+        
+        tenant_app = self.db.query(TenantApp).filter(
+            TenantApp.tenant_id == tenant_id,
+            TenantApp.app_code == app_code
+        ).first()
+        
+        if not tenant_app:
+            return None if key else {}
+        
+        # 解析 custom_configs
+        configs = {}
+        if hasattr(tenant_app, 'custom_configs') and tenant_app.custom_configs:
+            try:
+                configs = json.loads(tenant_app.custom_configs) if isinstance(tenant_app.custom_configs, str) else tenant_app.custom_configs
+            except:
+                pass
+        
+        if key:
+            return configs.get(key)
+        return configs
+    
+    def get_all_tenant_configs(self, app_code: str) -> List[Dict]:
+        """获取所有租户的应用配置
+        
+        Args:
+            app_code: 应用代码
+            
+        Returns:
+            [{"tenant_id": ..., "tenant_name": ..., "configs": {...}}, ...]
+        """
+        from ..models.tenant import Tenant
+        from ..models.tenant_app import TenantApp
+        
+        tenant_apps = self.db.query(TenantApp).filter(
+            TenantApp.app_code == app_code,
+            TenantApp.status == 1
+        ).all()
+        
+        result = []
+        for ta in tenant_apps:
+            tenant = self.db.query(Tenant).filter(Tenant.code == ta.tenant_id).first()
+            configs = {}
+            if hasattr(ta, 'custom_configs') and ta.custom_configs:
+                try:
+                    configs = json.loads(ta.custom_configs) if isinstance(ta.custom_configs, str) else ta.custom_configs
+                except:
+                    pass
+            
+            result.append({
+                "tenant_id": ta.tenant_id,
+                "tenant_name": tenant.name if tenant else ta.tenant_id,
+                "configs": configs
+            })
+        
+        return result
+    
+    # ==================== 密钥管理 ====================
+    
+    def get_secret(self, key: str) -> Optional[str]:
+        """获取密钥（优先租户级，其次全局）
+        
+        Args:
+            key: 密钥名
+            
+        Returns:
+            密钥值
+        """
+        from ..models.scheduled_task import Secret
+        
+        # 先查租户级
+        if self.tenant_id:
+            secret = self.db.query(Secret).filter(
+                Secret.tenant_id == self.tenant_id,
+                Secret.secret_key == key
+            ).first()
+            if secret:
+                return secret.secret_value
+        
+        # 再查全局
+        secret = self.db.query(Secret).filter(
+            Secret.tenant_id.is_(None),
+            Secret.secret_key == key
+        ).first()
+        
+        return secret.secret_value if secret else None

backend/requirements.txt

@@ -12,3 +12,4 @@ python-multipart>=0.0.6
 httpx>=0.26.0
 redis>=5.0.0
 openpyxl>=3.1.0
+apscheduler>=3.10.0

deploy/Dockerfile.backend

@@ -1,5 +1,9 @@
 FROM python:3.11-slim
 
+# 设置时区为上海
+ENV TZ=Asia/Shanghai
+RUN ln -snf /usr/share/zoneinfo/$TZ /etc/localtime && echo $TZ > /etc/timezone
+
 WORKDIR /app
 
 # 安装依赖（使用阿里云镜像）

docs/scheduled-tasks.md

@@ -0,0 +1,358 @@
+# 定时任务系统文档
+
+## 功能概述
+
+平台定时任务系统，支持 Python 脚本或 Webhook 定时执行，执行结果可自动推送到钉钉/企微机器人。
+
+**核心能力**：
+- 脚本执行：安全沙箱运行 Python 脚本，内置 AI、HTTP、数据库等 SDK
+- 调度方式：指定时间点（多选）或 CRON 表达式
+- 消息推送：支持钉钉/企微机器人所有消息格式（markdown、actionCard、feedCard 等）
+- 失败处理：支持重试和告警通知
+
+---
+
+## 数据库表
+
+### platform_scheduled_tasks（定时任务表）
+
+```sql
+CREATE TABLE platform_scheduled_tasks (
+    id INT AUTO_INCREMENT PRIMARY KEY,
+    tenant_id VARCHAR(50) COMMENT '租户ID，空为全局任务',
+    task_name VARCHAR(100) NOT NULL COMMENT '任务名称',
+    task_desc VARCHAR(500) COMMENT '任务描述',
+    schedule_type ENUM('simple', 'cron') NOT NULL DEFAULT 'simple',
+    time_points JSON COMMENT '时间点列表 ["08:00", "12:00"]',
+    cron_expression VARCHAR(100) COMMENT 'CRON表达式',
+    timezone VARCHAR(50) DEFAULT 'Asia/Shanghai',
+    execution_type ENUM('webhook', 'script') NOT NULL DEFAULT 'script',
+    webhook_url VARCHAR(500),
+    script_content TEXT COMMENT 'Python脚本内容',
+    script_deps TEXT COMMENT '脚本依赖',
+    input_params JSON COMMENT '输入参数',
+    retry_count INT DEFAULT 0,
+    retry_interval INT DEFAULT 60,
+    alert_on_failure TINYINT(1) DEFAULT 0,
+    alert_webhook VARCHAR(500),
+    notify_channels JSON COMMENT '通知渠道ID列表',
+    notify_wecom_app_id INT COMMENT '企微应用ID',
+    is_enabled TINYINT(1) DEFAULT 1,
+    last_run_at DATETIME,
+    last_run_status ENUM('success', 'failed', 'running'),
+    last_run_message TEXT,
+    created_at DATETIME DEFAULT CURRENT_TIMESTAMP,
+    updated_at DATETIME DEFAULT CURRENT_TIMESTAMP ON UPDATE CURRENT_TIMESTAMP
+);
+```
+
+### platform_task_notify_channels（通知渠道表）
+
+```sql
+CREATE TABLE platform_task_notify_channels (
+    id INT AUTO_INCREMENT PRIMARY KEY,
+    tenant_id VARCHAR(50) NOT NULL COMMENT '租户ID',
+    channel_name VARCHAR(100) NOT NULL COMMENT '渠道名称',
+    channel_type ENUM('dingtalk_bot', 'wecom_bot') NOT NULL,
+    webhook_url VARCHAR(500) NOT NULL,
+    sign_secret VARCHAR(200) COMMENT '钉钉加签密钥',
+    description VARCHAR(255),
+    is_enabled TINYINT(1) DEFAULT 1,
+    created_at DATETIME DEFAULT CURRENT_TIMESTAMP,
+    updated_at DATETIME DEFAULT CURRENT_TIMESTAMP ON UPDATE CURRENT_TIMESTAMP
+);
+```
+
+### platform_task_logs（执行日志表）
+
+```sql
+CREATE TABLE platform_task_logs (
+    id BIGINT AUTO_INCREMENT PRIMARY KEY,
+    task_id INT NOT NULL,
+    tenant_id VARCHAR(50),
+    trace_id VARCHAR(100),
+    status ENUM('running', 'success', 'failed'),
+    started_at DATETIME,
+    finished_at DATETIME,
+    duration_ms INT,
+    output TEXT,
+    error TEXT,
+    retry_count INT DEFAULT 0,
+    created_at DATETIME DEFAULT CURRENT_TIMESTAMP
+);
+```
+
+---
+
+## 后端文件结构
+
+```
+backend/app/
+├── models/
+│   ├── scheduled_task.py      # ScheduledTask, TaskLog, ScriptVar, Secret 模型
+│   └── notification_channel.py # TaskNotifyChannel 模型
+├── routers/
+│   ├── tasks.py               # 定时任务 API (/api/scheduled-tasks)
+│   └── notification_channels.py # 通知渠道 API (/api/notification-channels)
+└── services/
+    ├── scheduler.py           # APScheduler 调度服务
+    ├── script_executor.py     # 脚本执行器（安全沙箱）
+    └── script_sdk.py          # 脚本内置 SDK
+```
+
+---
+
+## 脚本 SDK 文档
+
+### 内置函数
+
+```python
+# 日志
+log(message)                    # 记录日志
+print(message)                  # 打印输出
+
+# AI 调用
+ai(prompt, system=None, model='deepseek-chat')  # 调用 AI
+
+# 通知发送（直接发送，不走 result）
+dingtalk(webhook_url, content, title='通知')
+wecom(webhook_url, content)
+
+# HTTP 请求
+http_get(url, headers=None, params=None)
+http_post(url, data=None, json=None, headers=None)
+
+# 数据库查询（只读）
+db_query(sql, params=None)
+
+# 变量存储（跨执行持久化）
+get_var(key, default=None)
+set_var(key, value)
+del_var(key)
+
+# 任务参数
+get_param(key, default=None)   # 获取单个参数
+get_params()                    # 获取所有参数
+
+# 租户相关
+get_tenants()                   # 获取所有租户
+get_tenant_config(tenant_id, app_code, key)  # 获取租户配置
+get_all_tenant_configs(app_code, key)        # 获取所有租户的配置
+
+# 密钥
+get_secret(key)                 # 获取密钥
+```
+
+### 内置变量
+
+```python
+task_id     # 当前任务ID
+tenant_id   # 当前租户ID（可能为空）
+trace_id    # 追踪ID
+```
+
+### 内置模块（无需 import）
+
+```python
+datetime    # datetime.now(), datetime.strptime()
+date        # date.today()
+timedelta   # timedelta(days=1)
+time        # time.sleep(), time.time()
+json        # json.dumps(), json.loads()
+re          # re.search(), re.match()
+math        # math.ceil(), math.floor()
+random      # random.randint(), random.choice()
+hashlib     # hashlib.md5()
+base64      # base64.b64encode()
+```
+
+---
+
+## 消息格式（result 变量）
+
+### 基础格式（默认 markdown）
+
+```python
+result = {
+    'content': 'Markdown 内容',
+    'title': '消息标题'
+}
+```
+
+### 钉钉 ActionCard（交互卡片）
+
+```python
+result = {
+    'msg_type': 'actionCard',
+    'title': '卡片标题',
+    'content': '''### 正文内容
+| 列1 | 列2 |
+|:---:|:---:|
+| A | B |
+''',
+    'btn_orientation': '1',  # 0-竖向 1-横向
+    'buttons': [
+        {'title': '按钮1', 'url': 'https://...'},
+        {'title': '按钮2', 'url': 'https://...'}
+    ]
+}
+```
+
+### 钉钉 FeedCard（信息流）
+
+```python
+result = {
+    'msg_type': 'feedCard',
+    'links': [
+        {'title': '标题1', 'url': 'https://...', 'pic_url': 'https://...'},
+        {'title': '标题2', 'url': 'https://...', 'pic_url': 'https://...'}
+    ]
+}
+```
+
+### 钉钉 Link（链接消息）
+
+```python
+result = {
+    'msg_type': 'link',
+    'title': '链接标题',
+    'content': '链接描述',
+    'url': 'https://...',
+    'pic_url': 'https://...'
+}
+```
+
+### 企微 News（图文消息）
+
+```python
+result = {
+    'msg_type': 'news',
+    'articles': [
+        {
+            'title': '文章标题',
+            'description': '文章描述',
+            'url': 'https://...',
+            'picurl': 'https://...'
+        }
+    ]
+}
+```
+
+### 企微 Template Card（模板卡片）
+
+```python
+result = {
+    'msg_type': 'template_card',
+    'card_type': 'text_notice',  # text_notice / news_notice / button_interaction
+    'title': '卡片标题',
+    'content': '卡片内容',
+    'horizontal_list': [
+        {'keyname': '申请人', 'value': '张三'},
+        {'keyname': '金额', 'value': '¥5,000'}
+    ],
+    'jump_list': [
+        {'type': 1, 'title': '查看详情', 'url': 'https://...'}
+    ]
+}
+```
+
+---
+
+## API 端点
+
+### 定时任务
+
+| 方法 | 路径 | 说明 |
+|------|------|------|
+| GET | /api/scheduled-tasks | 任务列表 |
+| GET | /api/scheduled-tasks/{id} | 任务详情 |
+| POST | /api/scheduled-tasks | 创建任务 |
+| PUT | /api/scheduled-tasks/{id} | 更新任务 |
+| DELETE | /api/scheduled-tasks/{id} | 删除任务 |
+| POST | /api/scheduled-tasks/{id}/toggle | 启用/禁用 |
+| POST | /api/scheduled-tasks/{id}/run | 立即执行 |
+| GET | /api/scheduled-tasks/{id}/logs | 执行日志 |
+| POST | /api/scheduled-tasks/test-script | 测试脚本 |
+| GET | /api/scheduled-tasks/sdk-docs | SDK 文档 |
+
+### 通知渠道
+
+| 方法 | 路径 | 说明 |
+|------|------|------|
+| GET | /api/notification-channels | 渠道列表 |
+| POST | /api/notification-channels | 创建渠道 |
+| PUT | /api/notification-channels/{id} | 更新渠道 |
+| DELETE | /api/notification-channels/{id} | 删除渠道 |
+| POST | /api/notification-channels/{id}/test | 测试渠道 |
+
+---
+
+## 前端文件
+
+```
+frontend/src/views/
+├── scheduled-tasks/
+│   └── index.vue              # 定时任务管理页面
+└── notification-channels/
+    └── index.vue              # 通知渠道管理页面
+```
+
+---
+
+## 示例脚本
+
+### 基础示例
+
+```python
+# 无需 import，模块已内置
+log('任务开始执行')
+
+now = datetime.now().strftime('%Y-%m-%d %H:%M:%S')
+prompt = get_param('prompt', '默认提示词')
+
+content = ai(prompt, system='你是一个助手')
+
+result = {
+    'title': '每日推送',
+    'content': f'**生成时间**: {now}\n\n{content}'
+}
+
+log('任务执行完成')
+```
+
+### 复杂卡片示例
+
+```python
+log('生成销售日报')
+
+now = datetime.now()
+today = now.strftime('%Y年%m月%d日')
+
+# 模拟数据
+revenue = random.randint(50000, 150000)
+
+result = {
+    'msg_type': 'actionCard',
+    'title': f'销售日报 | {today}',
+    'content': f'''### 今日业绩
+
+| 指标 | 数值 |
+|:---:|:---:|
+| 销售额 | **¥{revenue:,}** |
+| 订单数 | **{random.randint(40, 80)}** |
+
+> 点击查看详情
+''',
+    'buttons': [
+        {'title': '查看详情', 'url': 'https://example.com/report'}
+    ]
+}
+```
+
+---
+
+## 部署信息
+
+- **测试环境**: https://platform.test.ai.ireborn.com.cn
+- **数据库**: new_qiqi (测试) / new_platform_prod (生产)
+- **Docker 容器**: platform-backend-test / platform-frontend-test

frontend/package.json

@@ -16,7 +16,9 @@
     "element-plus": "^2.5.0",
     "@element-plus/icons-vue": "^2.3.0",
     "echarts": "^5.4.0",
-    "dayjs": "^1.11.0"
+    "dayjs": "^1.11.0",
+    "monaco-editor": "^0.45.0",
+    "@monaco-editor/loader": "^1.4.0"
   },
   "devDependencies": {
     "@vitejs/plugin-vue": "^5.0.0",

frontend/src/api/index.js

@@ -18,9 +18,21 @@ function parseApiError(error) {
     status: 500
   }
   
+  // 网络错误（后端未启动、网络断开等）
   if (!error.response) {
+    if (error.code === 'ECONNABORTED') {
+      result.code = 'TIMEOUT_ERROR'
+      result.message = '请求超时，请稍后重试'
+      result.status = 0
+    } else if (error.message?.includes('Network Error')) {
+      result.code = 'SERVICE_UNAVAILABLE'
+      result.message = '服务暂时不可用，请稍后重试'
+      result.status = 503
+    } else {
       result.code = 'NETWORK_ERROR'
       result.message = '网络连接失败，请检查网络后重试'
+      result.status = 0
+    }
     return result
   }
   
@@ -40,18 +52,23 @@ function parseApiError(error) {
 }
 
 /**
- * 跳转到错误页面
+ * 跳转到错误页面（使用 sessionStorage + replace，不影响浏览器历史）
  */
 function navigateToErrorPage(errorInfo) {
-  router.push({
+  // 记录当前页面路径（用于返回）
-    name: 'Error',
+  sessionStorage.setItem('errorFromPath', router.currentRoute.value.fullPath)
-    query: {
+  
+  // 保存错误信息到 sessionStorage（不会显示在 URL 中）
+  sessionStorage.setItem('errorInfo', JSON.stringify({
     code: errorInfo.code,
     message: errorInfo.message,
-      trace_id: errorInfo.traceId,
+    traceId: errorInfo.traceId,
-      status: String(errorInfo.status)
+    status: errorInfo.status,
-    }
+    timestamp: Date.now()
-  })
+  }))
+  
+  // 使用 replace 而不是 push，这样浏览器返回时不会停留在错误页
+  router.replace({ name: 'Error' })
 }
 
 // 请求拦截器
@@ -75,6 +92,15 @@ api.interceptors.response.use(
     
     console.error(`[API Error] ${errorInfo.code}: ${errorInfo.message}${traceLog}`)
     
+    // 严重错误列表（跳转错误页）
+    const criticalErrors = [
+      'INTERNAL_ERROR', 
+      'SERVICE_UNAVAILABLE', 
+      'GATEWAY_ERROR',
+      'NETWORK_ERROR',
+      'TIMEOUT_ERROR'
+    ]
+    
     if (error.response?.status === 401) {
       localStorage.removeItem('token')
       localStorage.removeItem('user')
@@ -82,8 +108,8 @@ api.interceptors.response.use(
       ElMessage.error('登录已过期，请重新登录')
     } else if (error.response?.status === 403) {
       ElMessage.error('没有权限执行此操作')
-    } else if (['INTERNAL_ERROR', 'SERVICE_UNAVAILABLE', 'GATEWAY_ERROR'].includes(errorInfo.code)) {
+    } else if (criticalErrors.includes(errorInfo.code)) {
-      // 严重错误跳转到错误页面
+      // 严重错误（包括网络错误、服务不可用）跳转到错误页面
       navigateToErrorPage(errorInfo)
     } else {
       // 普通错误显示消息

frontend/src/components/Layout.vue

@@ -17,7 +17,9 @@ const menuItems = computed(() => {
     { path: '/tenant-wechat-apps', title: '企微应用', icon: 'ChatDotRound' },
     { path: '/app-config', title: '租户订阅', icon: 'Setting' },
     { path: '/stats', title: '统计分析', icon: 'TrendCharts' },
-    { path: '/logs', title: '日志查看', icon: 'Document' }
+    { path: '/logs', title: '日志查看', icon: 'Document' },
+    { path: '/scheduled-tasks', title: '定时任务', icon: 'Clock' },
+    { path: '/notification-channels', title: '通知渠道', icon: 'Bell' }
   ]
   
   // 管理员才能看到用户管理

frontend/src/router/index.js

@@ -72,6 +72,18 @@ const routes = [
         name: 'Users',
         component: () => import('@/views/users/index.vue'),
         meta: { title: '用户管理', icon: 'User', role: 'admin' }
+      },
+      {
+        path: 'scheduled-tasks',
+        name: 'ScheduledTasks',
+        component: () => import('@/views/scheduled-tasks/index.vue'),
+        meta: { title: '定时任务', icon: 'Clock' }
+      },
+      {
+        path: 'notification-channels',
+        name: 'NotificationChannels',
+        component: () => import('@/views/notification-channels/index.vue'),
+        meta: { title: '通知渠道', icon: 'Bell' }
       }
     ]
   }

frontend/src/views/apps/index.vue

@@ -1,6 +1,7 @@
 <script setup>
 import { ref, reactive, onMounted } from 'vue'
 import { ElMessage, ElMessageBox } from 'element-plus'
+import { Delete, Plus } from '@element-plus/icons-vue'
 import api from '@/api'
 import { useAuthStore } from '@/stores/auth'
 
@@ -14,6 +15,14 @@ const query = reactive({
   size: 20
 })
 
+// 配置项类型选项
+const configTypes = [
+  { value: 'text', label: '文本输入' },
+  { value: 'radio', label: '单选' },
+  { value: 'select', label: '下拉选择' },
+  { value: 'switch', label: '开关' }
+]
+
 // 对话框
 const dialogVisible = ref(false)
 const dialogTitle = ref('')
@@ -24,7 +33,8 @@ const form = reactive({
   app_name: '',
   base_url: '',
   description: '',
-  require_jssdk: false
+  require_jssdk: false,
+  config_schema: []  // 配置项定义
 })
 
 const rules = {
@@ -63,7 +73,8 @@ function handleCreate() {
     app_name: '',
     base_url: '',
     description: '',
-    require_jssdk: false
+    require_jssdk: false,
+    config_schema: []
   })
   dialogVisible.value = true
 }
@@ -76,11 +87,55 @@ function handleEdit(row) {
     app_name: row.app_name,
     base_url: row.base_url || '',
     description: row.description || '',
-    require_jssdk: row.require_jssdk || false
+    require_jssdk: row.require_jssdk || false,
+    config_schema: row.config_schema ? row.config_schema.map(c => ({
+      ...c,
+      options: c.options || [],
+      option_labels: c.option_labels || {}
+    })) : []
   })
   dialogVisible.value = true
 }
 
+// 配置项管理
+function addConfigItem() {
+  form.config_schema.push({
+    key: '',
+    label: '',
+    type: 'text',
+    options: [],
+    option_labels: {},
+    default: '',
+    placeholder: '',
+    required: false
+  })
+}
+
+function removeConfigItem(index) {
+  form.config_schema.splice(index, 1)
+}
+
+// 选项管理（radio/select 类型）
+function addOption(config) {
+  const optionKey = `option_${config.options.length + 1}`
+  config.options.push(optionKey)
+  config.option_labels[optionKey] = ''
+}
+
+function removeOption(config, index) {
+  const optionKey = config.options[index]
+  config.options.splice(index, 1)
+  delete config.option_labels[optionKey]
+}
+
+function updateOptionKey(config, index, newKey) {
+  const oldKey = config.options[index]
+  const oldLabel = config.option_labels[oldKey]
+  delete config.option_labels[oldKey]
+  config.options[index] = newKey
+  config.option_labels[newKey] = oldLabel || ''
+}
+
 async function handleSubmit() {
   await formRef.value.validate()
   
@@ -154,6 +209,14 @@ onMounted(() => {
       <el-table-column prop="app_code" label="应用代码" width="150" />
       <el-table-column prop="app_name" label="应用名称" width="180" />
       <el-table-column prop="base_url" label="访问地址" min-width="300" show-overflow-tooltip />
+      <el-table-column label="配置项" width="90">
+        <template #default="{ row }">
+          <el-tag v-if="row.config_schema && row.config_schema.length > 0" type="primary" size="small">
+            {{ row.config_schema.length }} 项
+          </el-tag>
+          <span v-else style="color: #909399; font-size: 12px">-</span>
+        </template>
+      </el-table-column>
       <el-table-column label="JS-SDK" width="90">
         <template #default="{ row }">
           <el-tag :type="row.require_jssdk ? 'warning' : 'info'" size="small">
@@ -191,7 +254,7 @@ onMounted(() => {
     </div>
     
     <!-- 编辑对话框 -->
-    <el-dialog v-model="dialogVisible" :title="dialogTitle" width="550px">
+    <el-dialog v-model="dialogVisible" :title="dialogTitle" width="800px">
       <el-form ref="formRef" :model="form" :rules="rules" label-width="100px">
         <el-form-item label="应用代码" prop="app_code">
           <el-input v-model="form.app_code" :disabled="!!editingId" placeholder="唯一标识，如: brainstorm" />
@@ -212,6 +275,69 @@ onMounted(() => {
           <el-switch v-model="form.require_jssdk" />
           <span style="margin-left: 12px; color: #909399; font-size: 12px">开启后租户需关联企微应用</span>
         </el-form-item>
+        
+        <!-- 配置项定义 -->
+        <el-divider content-position="left">配置项定义</el-divider>
+        <div class="config-schema-section">
+          <div class="config-schema-tip">
+            定义租户订阅时可配置的参数，如行业类型、提示词等
+          </div>
+          
+          <div v-for="(config, index) in form.config_schema" :key="index" class="config-schema-item">
+            <div class="config-header">
+              <span class="config-index">#{{ index + 1 }}</span>
+              <el-button type="danger" :icon="Delete" circle size="small" @click="removeConfigItem(index)" />
+            </div>
+            
+            <div class="config-row">
+              <el-input v-model="config.key" placeholder="配置键(如:industry)" style="width: 140px" />
+              <el-input v-model="config.label" placeholder="显示标签(如:行业类型)" style="width: 160px" />
+              <el-select v-model="config.type" placeholder="类型" style="width: 120px">
+                <el-option v-for="t in configTypes" :key="t.value" :label="t.label" :value="t.value" />
+              </el-select>
+              <el-checkbox v-model="config.required">必填</el-checkbox>
+            </div>
+            
+            <!-- text 类型：显示 placeholder -->
+            <div v-if="config.type === 'text'" class="config-row" style="margin-top: 8px">
+              <el-input v-model="config.placeholder" placeholder="输入提示文字" style="width: 300px" />
+              <el-input v-model="config.default" placeholder="默认值" style="width: 200px" />
+            </div>
+            
+            <!-- switch 类型：显示默认值 -->
+            <div v-if="config.type === 'switch'" class="config-row" style="margin-top: 8px">
+              <span style="color: #606266; margin-right: 8px">默认值：</span>
+              <el-switch v-model="config.default" active-value="true" inactive-value="false" />
+            </div>
+            
+            <!-- radio/select 类型：显示选项编辑 -->
+            <div v-if="config.type === 'radio' || config.type === 'select'" class="config-options">
+              <div class="options-label">选项列表：</div>
+              <div v-for="(opt, optIndex) in config.options" :key="optIndex" class="option-row">
+                <el-input 
+                  :model-value="opt" 
+                  @update:model-value="v => updateOptionKey(config, optIndex, v)"
+                  placeholder="选项值(如:medical)" 
+                  style="width: 140px" 
+                />
+                <el-input 
+                  v-model="config.option_labels[opt]" 
+                  placeholder="显示名(如:医美)" 
+                  style="width: 140px" 
+                />
+                <el-radio v-model="config.default" :value="opt">默认</el-radio>
+                <el-button type="danger" :icon="Delete" circle size="small" @click="removeOption(config, optIndex)" />
+              </div>
+              <el-button type="primary" plain size="small" @click="addOption(config)">
+                <el-icon><Plus /></el-icon> 添加选项
+              </el-button>
+            </div>
+          </div>
+          
+          <el-button type="primary" plain @click="addConfigItem" style="margin-top: 12px">
+            <el-icon><Plus /></el-icon> 添加配置项
+          </el-button>
+        </div>
       </el-form>
       <template #footer>
         <el-button @click="dialogVisible = false">取消</el-button>
@@ -225,4 +351,61 @@ onMounted(() => {
 .page-tip {
   margin-bottom: 16px;
 }
+
+/* 配置项定义样式 */
+.config-schema-section {
+  padding: 0 10px;
+}
+
+.config-schema-tip {
+  color: #909399;
+  font-size: 13px;
+  margin-bottom: 12px;
+}
+
+.config-schema-item {
+  background: #f5f7fa;
+  border-radius: 8px;
+  padding: 12px;
+  margin-bottom: 12px;
+}
+
+.config-header {
+  display: flex;
+  justify-content: space-between;
+  align-items: center;
+  margin-bottom: 10px;
+}
+
+.config-index {
+  font-weight: 600;
+  color: #409eff;
+}
+
+.config-row {
+  display: flex;
+  align-items: center;
+  gap: 8px;
+  flex-wrap: wrap;
+}
+
+.config-options {
+  margin-top: 10px;
+  padding: 10px;
+  background: #fff;
+  border-radius: 6px;
+}
+
+.options-label {
+  font-size: 13px;
+  color: #606266;
+  margin-bottom: 8px;
+}
+
+.option-row {
+  display: flex;
+  align-items: center;
+  gap: 8px;
+  margin-bottom: 8px;
+}
 </style>

frontend/src/views/error/index.vue

@@ -1,23 +1,27 @@
 <script setup>
 /**
  * 统一错误页面
+ * - 从 sessionStorage 读取错误信息，不污染 URL
+ * - 使用 replace 跳转，支持浏览器返回
  */
-import { computed, ref } from 'vue'
+import { ref, onMounted, onUnmounted } from 'vue'
-import { useRoute, useRouter } from 'vue-router'
+import { useRouter } from 'vue-router'
 import { ElButton, ElMessage } from 'element-plus'
 
-const route = useRoute()
 const router = useRouter()
 
-const errorCode = computed(() => route.query.code || 'UNKNOWN_ERROR')
+// 错误信息
-const errorMessage = computed(() => route.query.message || '发生了未知错误')
+const errorCode = ref('UNKNOWN_ERROR')
-const traceId = computed(() => route.query.trace_id || '')
+const errorMessage = ref('发生了未知错误')
-const statusCode = computed(() => route.query.status || '500')
+const traceId = ref('')
-
+const statusCode = ref('500')
 const copied = ref(false)
 
-const errorConfig = computed(() => {
+// 记录来源页面（用于返回）
-  const configs = {
+const fromPath = ref('')
+
+// 错误类型配置
+const errorConfigs = {
   'UNAUTHORIZED': { icon: 'Lock', title: '访问受限', color: '#e67e22' },
   'FORBIDDEN': { icon: 'CircleClose', title: '权限不足', color: '#e74c3c' },
   'NOT_FOUND': { icon: 'Search', title: '页面未找到', color: '#3498db' },
@@ -25,9 +29,41 @@ const errorConfig = computed(() => {
   'INTERNAL_ERROR': { icon: 'Close', title: '服务器错误', color: '#e74c3c' },
   'SERVICE_UNAVAILABLE': { icon: 'Tools', title: '服务暂时不可用', color: '#9b59b6' },
   'NETWORK_ERROR': { icon: 'Connection', title: '网络连接失败', color: '#95a5a6' },
+  'TIMEOUT_ERROR': { icon: 'Timer', title: '请求超时', color: '#95a5a6' },
   'UNKNOWN_ERROR': { icon: 'QuestionFilled', title: '未知错误', color: '#7f8c8d' }
 }
-  return configs[errorCode.value] || configs['UNKNOWN_ERROR']
+
+const errorConfig = ref(errorConfigs['UNKNOWN_ERROR'])
+
+onMounted(() => {
+  // 从 sessionStorage 读取错误信息
+  const stored = sessionStorage.getItem('errorInfo')
+  if (stored) {
+    try {
+      const info = JSON.parse(stored)
+      // 检查时效性（5分钟内有效）
+      if (Date.now() - info.timestamp < 5 * 60 * 1000) {
+        errorCode.value = info.code || 'UNKNOWN_ERROR'
+        errorMessage.value = info.message || '发生了未知错误'
+        traceId.value = info.traceId || ''
+        statusCode.value = String(info.status || 500)
+        errorConfig.value = errorConfigs[errorCode.value] || errorConfigs['UNKNOWN_ERROR']
+      }
+      // 读取后清除（避免刷新时重复显示旧错误）
+      sessionStorage.removeItem('errorInfo')
+    } catch (e) {
+      console.error('Failed to parse error info', e)
+    }
+  }
+  
+  // 记录来源页面
+  fromPath.value = sessionStorage.getItem('errorFromPath') || '/dashboard'
+  sessionStorage.removeItem('errorFromPath')
+})
+
+onUnmounted(() => {
+  // 确保清理
+  sessionStorage.removeItem('errorInfo')
 })
 
 const copyTraceId = async () => {
@@ -44,7 +80,15 @@ const copyTraceId = async () => {
 }
 
 const goHome = () => router.push('/dashboard')
-const retry = () => router.back()
+
+// 返回之前的页面
+const goBack = () => {
+  if (fromPath.value && fromPath.value !== '/error') {
+    router.push(fromPath.value)
+  } else {
+    router.push('/dashboard')
+  }
+}
 </script>
 
 <template>
@@ -72,7 +116,7 @@ const retry = () => router.back()
       </div>
       
       <div class="action-buttons">
-        <el-button type="primary" @click="retry">重试</el-button>
+        <el-button type="primary" @click="goBack">返回</el-button>
         <el-button @click="goHome">返回首页</el-button>
       </div>
     </div>

frontend/src/views/notification-channels/index.vue

@@ -0,0 +1,317 @@
+<script setup>
+import { ref, reactive, onMounted } from 'vue'
+import { ElMessage, ElMessageBox } from 'element-plus'
+import api from '@/api'
+
+const loading = ref(false)
+const tableData = ref([])
+const total = ref(0)
+const query = reactive({
+  page: 1,
+  size: 50,
+  tenant_id: ''
+})
+
+// 租户列表
+const tenants = ref([])
+
+// 对话框
+const dialogVisible = ref(false)
+const dialogTitle = ref('')
+const editingId = ref(null)
+const formRef = ref(null)
+const form = reactive({
+  tenant_id: '',
+  channel_name: '',
+  channel_type: 'dingtalk_bot',
+  webhook_url: '',
+  sign_secret: '',
+  description: ''
+})
+
+const rules = {
+  tenant_id: [{ required: true, message: '请选择租户', trigger: 'change' }],
+  channel_name: [{ required: true, message: '请输入渠道名称', trigger: 'blur' }],
+  channel_type: [{ required: true, message: '请选择渠道类型', trigger: 'change' }],
+  webhook_url: [{ required: true, message: '请输入 Webhook 地址', trigger: 'blur' }]
+}
+
+const channelTypes = [
+  { value: 'dingtalk_bot', label: '钉钉机器人' },
+  { value: 'wecom_bot', label: '企微机器人' }
+]
+
+async function fetchList() {
+  loading.value = true
+  try {
+    const params = { ...query }
+    if (!params.tenant_id) delete params.tenant_id
+    
+    const res = await api.get('/api/notification-channels', { params })
+    tableData.value = res.data.items || []
+    total.value = res.data.total || 0
+  } catch (e) {
+    console.error(e)
+  } finally {
+    loading.value = false
+  }
+}
+
+async function fetchTenants() {
+  try {
+    const res = await api.get('/api/tenants', { params: { size: 1000 } })
+    tenants.value = res.data.items || []
+  } catch (e) {
+    console.error(e)
+  }
+}
+
+function handleSearch() {
+  query.page = 1
+  fetchList()
+}
+
+function handleCreate() {
+  editingId.value = null
+  dialogTitle.value = '新建通知渠道'
+  Object.assign(form, {
+    tenant_id: '',
+    channel_name: '',
+    channel_type: 'dingtalk_bot',
+    webhook_url: '',
+    sign_secret: '',
+    description: ''
+  })
+  dialogVisible.value = true
+}
+
+function handleEdit(row) {
+  editingId.value = row.id
+  dialogTitle.value = '编辑通知渠道'
+  Object.assign(form, {
+    tenant_id: row.tenant_id,
+    channel_name: row.channel_name,
+    channel_type: row.channel_type,
+    webhook_url: row.webhook_url,
+    sign_secret: row.sign_secret || '',
+    description: row.description || ''
+  })
+  dialogVisible.value = true
+}
+
+async function handleSubmit() {
+  await formRef.value.validate()
+  
+  try {
+    if (editingId.value) {
+      await api.put(`/api/notification-channels/${editingId.value}`, form)
+      ElMessage.success('更新成功')
+    } else {
+      await api.post('/api/notification-channels', form)
+      ElMessage.success('创建成功')
+    }
+    dialogVisible.value = false
+    fetchList()
+  } catch (e) {
+    // 错误已在拦截器处理
+  }
+}
+
+async function handleDelete(row) {
+  await ElMessageBox.confirm(`确定删除渠道 "${row.channel_name}" 吗？`, '提示', {
+    type: 'warning'
+  })
+  
+  try {
+    await api.delete(`/api/notification-channels/${row.id}`)
+    ElMessage.success('删除成功')
+    fetchList()
+  } catch (e) {
+    // 错误已在拦截器处理
+  }
+}
+
+async function handleToggle(row) {
+  try {
+    await api.put(`/api/notification-channels/${row.id}`, {
+      is_enabled: !row.is_enabled
+    })
+    ElMessage.success(row.is_enabled ? '已禁用' : '已启用')
+    fetchList()
+  } catch (e) {
+    // 错误已在拦截器处理
+  }
+}
+
+async function handleTest(row) {
+  try {
+    ElMessage.info('发送测试消息中...')
+    const res = await api.post(`/api/notification-channels/${row.id}/test`)
+    if (res.data.success) {
+      ElMessage.success('测试消息发送成功')
+    } else {
+      ElMessage.error(`发送失败: ${res.data.message}`)
+    }
+  } catch (e) {
+    // 错误已在拦截器处理
+  }
+}
+
+function getTenantName(tenantId) {
+  const tenant = tenants.value.find(t => t.code === tenantId)
+  return tenant ? tenant.name : tenantId
+}
+
+function getChannelTypeName(type) {
+  const item = channelTypes.find(t => t.value === type)
+  return item ? item.label : type
+}
+
+onMounted(() => {
+  fetchList()
+  fetchTenants()
+})
+</script>
+
+<template>
+  <div class="page-container">
+    <div class="page-header">
+      <div class="title">通知渠道管理</div>
+      <el-button type="primary" @click="handleCreate">
+        <el-icon><Plus /></el-icon>
+        新建渠道
+      </el-button>
+    </div>
+    
+    <div class="page-tip">
+      <el-alert type="info" :closable="false">
+        通知渠道用于定时任务执行后发送消息。支持钉钉机器人和企微机器人。
+        脚本中设置 <code>result = {'content': '消息内容', 'title': '标题'}</code> 变量，任务执行后会自动发送到配置的渠道。
+      </el-alert>
+    </div>
+    
+    <!-- 筛选 -->
+    <div class="filter-bar">
+      <el-select v-model="query.tenant_id" placeholder="全部租户" clearable style="width: 180px">
+        <el-option v-for="t in tenants" :key="t.code" :label="t.name" :value="t.code" />
+      </el-select>
+      <el-button type="primary" @click="handleSearch">搜索</el-button>
+    </div>
+    
+    <!-- 表格 -->
+    <el-table v-loading="loading" :data="tableData" style="width: 100%">
+      <el-table-column prop="id" label="ID" width="60" />
+      <el-table-column label="租户" width="120">
+        <template #default="{ row }">
+          {{ getTenantName(row.tenant_id) }}
+        </template>
+      </el-table-column>
+      <el-table-column prop="channel_name" label="渠道名称" min-width="150" />
+      <el-table-column label="类型" width="120">
+        <template #default="{ row }">
+          <el-tag :type="row.channel_type === 'dingtalk_bot' ? 'primary' : 'success'" size="small">
+            {{ getChannelTypeName(row.channel_type) }}
+          </el-tag>
+        </template>
+      </el-table-column>
+      <el-table-column prop="webhook_url" label="Webhook" min-width="200" show-overflow-tooltip />
+      <el-table-column label="状态" width="80">
+        <template #default="{ row }">
+          <el-tag :type="row.is_enabled ? 'success' : 'info'" size="small">
+            {{ row.is_enabled ? '启用' : '禁用' }}
+          </el-tag>
+        </template>
+      </el-table-column>
+      <el-table-column label="操作" width="220" fixed="right">
+        <template #default="{ row }">
+          <el-button type="primary" link size="small" @click="handleEdit(row)">编辑</el-button>
+          <el-button type="info" link size="small" @click="handleTest(row)">测试</el-button>
+          <el-button :type="row.is_enabled ? 'warning' : 'success'" link size="small" @click="handleToggle(row)">
+            {{ row.is_enabled ? '禁用' : '启用' }}
+          </el-button>
+          <el-button type="danger" link size="small" @click="handleDelete(row)">删除</el-button>
+        </template>
+      </el-table-column>
+    </el-table>
+    
+    <!-- 编辑对话框 -->
+    <el-dialog v-model="dialogVisible" :title="dialogTitle" width="550px">
+      <el-form ref="formRef" :model="form" :rules="rules" label-width="100px">
+        <el-form-item label="所属租户" prop="tenant_id">
+          <el-select v-model="form.tenant_id" placeholder="选择租户" style="width: 100%">
+            <el-option v-for="t in tenants" :key="t.code" :label="t.name" :value="t.code" />
+          </el-select>
+        </el-form-item>
+        <el-form-item label="渠道名称" prop="channel_name">
+          <el-input v-model="form.channel_name" placeholder="如: 销售群机器人" />
+        </el-form-item>
+        <el-form-item label="渠道类型" prop="channel_type">
+          <el-select v-model="form.channel_type" style="width: 100%">
+            <el-option v-for="t in channelTypes" :key="t.value" :label="t.label" :value="t.value" />
+          </el-select>
+        </el-form-item>
+        <el-form-item label="Webhook" prop="webhook_url">
+          <el-input v-model="form.webhook_url" placeholder="机器人 Webhook 地址" />
+          <div class="form-tip">
+            <template v-if="form.channel_type === 'dingtalk_bot'">
+              钉钉机器人 Webhook 格式: https://oapi.dingtalk.com/robot/send?access_token=xxx
+            </template>
+            <template v-else>
+              企微机器人 Webhook 格式: https://qyapi.weixin.qq.com/cgi-bin/webhook/send?key=xxx
+            </template>
+          </div>
+        </el-form-item>
+        <el-form-item v-if="form.channel_type === 'dingtalk_bot'" label="加签密钥">
+          <el-input v-model="form.sign_secret" placeholder="SEC开头的密钥（可选）" />
+          <div class="form-tip">
+            如果创建机器人时选择了「加签」安全设置，请填写密钥（以 SEC 开头）
+          </div>
+        </el-form-item>
+        <el-form-item label="描述">
+          <el-input v-model="form.description" type="textarea" :rows="2" placeholder="渠道描述（可选）" />
+        </el-form-item>
+      </el-form>
+      <template #footer>
+        <el-button @click="dialogVisible = false">取消</el-button>
+        <el-button type="primary" @click="handleSubmit">保存</el-button>
+      </template>
+    </el-dialog>
+  </div>
+</template>
+
+<style scoped>
+.page-header {
+  display: flex;
+  justify-content: space-between;
+  align-items: center;
+  margin-bottom: 20px;
+}
+
+.page-header .title {
+  font-size: 20px;
+  font-weight: 600;
+}
+
+.page-tip {
+  margin-bottom: 16px;
+}
+
+.page-tip code {
+  background: #f5f7fa;
+  padding: 2px 6px;
+  border-radius: 4px;
+  font-size: 12px;
+}
+
+.filter-bar {
+  display: flex;
+  gap: 12px;
+  margin-bottom: 20px;
+}
+
+.form-tip {
+  color: #909399;
+  font-size: 12px;
+  margin-top: 4px;
+}
+</style>

frontend/src/views/tenants/detail.vue

@@ -1,15 +1,22 @@
 <script setup>
-import { ref, onMounted } from 'vue'
+import { ref, reactive, onMounted, computed, watch } from 'vue'
 import { useRoute, useRouter } from 'vue-router'
+import { ElMessage, ElMessageBox } from 'element-plus'
 import api from '@/api'
+import { useAuthStore } from '@/stores/auth'
 
+const authStore = useAuthStore()
 const route = useRoute()
 const router = useRouter()
 const tenantId = route.params.id
 
 const loading = ref(false)
 const tenant = ref(null)
+const activeTab = ref('basic')
 
+// ========================================
+// 基本信息
+// ========================================
 async function fetchDetail() {
   loading.value = true
   try {
@@ -32,6 +39,328 @@ function getStatusText(status) {
   return map[status] || status
 }
 
+// ========================================
+// 工具配置
+// ========================================
+const configLoading = ref(false)
+const configList = ref([])
+const configTypes = ref([])
+const configKeyOptions = ref({})
+const selectedTool = ref('__shared__')  // 当前选择的工具
+
+// 工具列表（租户级共享 + 各个工具）
+const toolTabs = computed(() => {
+  const tabs = [{ code: '__shared__', name: '租户通用配置' }]
+  // 从配置列表中提取已有工具
+  const tools = new Set()
+  configList.value.forEach(c => {
+    if (c.tool_code && c.tool_code !== '__shared__') {
+      tools.add(c.tool_code)
+    }
+  })
+  // 预定义的工具列表
+  const predefinedTools = [
+    { code: 'customer-profile', name: '客户画像' },
+    { code: 'high-eq', name: '高情商回复' },
+    { code: 'brainstorm', name: '头脑风暴' },
+    { code: 'consultation-plan', name: '面诊方案' },
+    { code: 'medical-compliance', name: '医疗合规' }
+  ]
+  predefinedTools.forEach(t => {
+    tabs.push(t)
+    tools.delete(t.code)
+  })
+  // 添加其他已有配置的工具
+  tools.forEach(code => {
+    tabs.push({ code, name: code })
+  })
+  return tabs
+})
+
+// 当前工具的配置列表
+const currentToolConfigs = computed(() => {
+  if (selectedTool.value === '__shared__') {
+    return configList.value.filter(c => !c.tool_code)
+  }
+  return configList.value.filter(c => c.tool_code === selectedTool.value)
+})
+
+// 按类型分组的配置
+const groupedConfigs = computed(() => {
+  const groups = {}
+  currentToolConfigs.value.forEach(c => {
+    const type = c.config_type || 'params'
+    if (!groups[type]) {
+      groups[type] = []
+    }
+    groups[type].push(c)
+  })
+  return groups
+})
+
+// 获取类型名称
+function getTypeName(type) {
+  const names = {
+    datasource: '数据源配置',
+    jssdk: 'JS-SDK 配置',
+    webhook: 'Webhook 配置',
+    params: '工具参数'
+  }
+  return names[type] || type
+}
+
+async function fetchToolConfigs() {
+  configLoading.value = true
+  try {
+    const res = await api.get('/api/tool-configs', {
+      params: { tenant_id: tenantId, size: 100 }
+    })
+    configList.value = res.data.items || []
+  } catch (e) {
+    console.error('获取配置失败:', e)
+  } finally {
+    configLoading.value = false
+  }
+}
+
+async function fetchConfigSchema() {
+  try {
+    const [typesRes, keysRes] = await Promise.all([
+      api.get('/api/tool-configs/schema/types'),
+      api.get('/api/tool-configs/schema/keys')
+    ])
+    configTypes.value = typesRes.data.types || []
+    configKeyOptions.value = keysRes.data || {}
+  } catch (e) {
+    console.error('获取配置元数据失败:', e)
+  }
+}
+
+// 配置编辑对话框
+const configDialogVisible = ref(false)
+const configDialogTitle = ref('')
+const editingConfigId = ref(null)
+const configFormRef = ref(null)
+const configForm = reactive({
+  config_type: 'params',
+  config_key: '',
+  config_value: '',
+  is_encrypted: 0,
+  description: ''
+})
+
+const configRules = {
+  config_type: [{ required: true, message: '请选择配置类型', trigger: 'change' }],
+  config_key: [{ required: true, message: '请输入配置键名', trigger: 'blur' }]
+}
+
+function handleAddConfig() {
+  editingConfigId.value = null
+  configDialogTitle.value = '添加配置'
+  Object.assign(configForm, {
+    config_type: 'params',
+    config_key: '',
+    config_value: '',
+    is_encrypted: 0,
+    description: ''
+  })
+  configDialogVisible.value = true
+}
+
+function handleEditConfig(config) {
+  editingConfigId.value = config.id
+  configDialogTitle.value = '编辑配置'
+  Object.assign(configForm, {
+    config_type: config.config_type,
+    config_key: config.config_key,
+    config_value: config.config_value || '',
+    is_encrypted: config.is_encrypted,
+    description: config.description || ''
+  })
+  configDialogVisible.value = true
+}
+
+async function handleConfigSubmit() {
+  await configFormRef.value.validate()
+  
+  try {
+    if (editingConfigId.value) {
+      await api.put(`/api/tool-configs/${editingConfigId.value}`, {
+        config_value: configForm.config_value,
+        is_encrypted: configForm.is_encrypted,
+        description: configForm.description
+      })
+      ElMessage.success('更新成功')
+    } else {
+      await api.post('/api/tool-configs', {
+        tenant_id: tenantId,
+        tool_code: selectedTool.value === '__shared__' ? null : selectedTool.value,
+        config_type: configForm.config_type,
+        config_key: configForm.config_key,
+        config_value: configForm.config_value,
+        is_encrypted: configForm.is_encrypted,
+        description: configForm.description
+      })
+      ElMessage.success('添加成功')
+    }
+    configDialogVisible.value = false
+    fetchToolConfigs()
+  } catch (e) {
+    // 错误已在拦截器处理
+  }
+}
+
+async function handleDeleteConfig(config) {
+  await ElMessageBox.confirm(`确定删除配置「${config.config_key}」吗？`, '提示', {
+    type: 'warning'
+  })
+  
+  try {
+    await api.delete(`/api/tool-configs/${config.id}`)
+    ElMessage.success('删除成功')
+    fetchToolConfigs()
+  } catch (e) {
+    // 错误已在拦截器处理
+  }
+}
+
+// 切换 Tab 时加载配置
+watch(activeTab, (newVal) => {
+  if (newVal === 'config' && configList.value.length === 0) {
+    fetchToolConfigs()
+    fetchConfigSchema()
+  }
+  if (newVal === 'ruimeiyun' && !ruimeiyunLoaded.value) {
+    fetchRuimeiyunConfig()
+  }
+})
+
+// ========================================
+// 瑞美云配置
+// ========================================
+const ruimeiyunLoading = ref(false)
+const ruimeiyunLoaded = ref(false)
+const ruimeiyunTesting = ref(false)
+const ruimeiyunFormRef = ref(null)
+const ruimeiyunForm = reactive({
+  base_url: '',
+  account: '',
+  private_key: '',
+  allowed_apis: ''
+})
+
+const ruimeiyunRules = {
+  base_url: [{ required: true, message: '请输入睿美云 API 地址', trigger: 'blur' }],
+  account: [{ required: true, message: '请输入账号', trigger: 'blur' }],
+  private_key: [{ required: true, message: '请输入私钥', trigger: 'blur' }]
+}
+
+async function fetchRuimeiyunConfig() {
+  ruimeiyunLoading.value = true
+  try {
+    const res = await api.get('/api/tool-configs', {
+      params: { tenant_id: tenantId, tool_code: 'ruimeiyun', size: 100 }
+    })
+    const items = res.data.items || []
+    // 映射配置到表单
+    items.forEach(item => {
+      if (item.config_key === 'ruimeiyun_base_url') {
+        ruimeiyunForm.base_url = item.config_value || ''
+      } else if (item.config_key === 'ruimeiyun_account') {
+        ruimeiyunForm.account = item.config_value || ''
+      } else if (item.config_key === 'ruimeiyun_private_key') {
+        // 加密字段显示占位符
+        ruimeiyunForm.private_key = item.is_encrypted ? '********' : (item.config_value || '')
+      } else if (item.config_key === 'ruimeiyun_allowed_apis') {
+        ruimeiyunForm.allowed_apis = item.config_value || ''
+      }
+    })
+    ruimeiyunLoaded.value = true
+  } catch (e) {
+    console.error('获取瑞美云配置失败:', e)
+  } finally {
+    ruimeiyunLoading.value = false
+  }
+}
+
+async function saveRuimeiyunConfig() {
+  await ruimeiyunFormRef.value.validate()
+  
+  ruimeiyunLoading.value = true
+  try {
+    // 构建配置列表
+    const configs = [
+      {
+        config_type: 'external_api',
+        config_key: 'ruimeiyun_base_url',
+        config_value: ruimeiyunForm.base_url,
+        is_encrypted: 0,
+        description: '睿美云 API 地址'
+      },
+      {
+        config_type: 'external_api',
+        config_key: 'ruimeiyun_account',
+        config_value: ruimeiyunForm.account,
+        is_encrypted: 0,
+        description: '睿美云账号'
+      }
+    ]
+    
+    // 如果私钥不是占位符，则更新
+    if (ruimeiyunForm.private_key && ruimeiyunForm.private_key !== '********') {
+      configs.push({
+        config_type: 'external_api',
+        config_key: 'ruimeiyun_private_key',
+        config_value: ruimeiyunForm.private_key,
+        is_encrypted: 1,
+        description: '睿美云私钥'
+      })
+    }
+    
+    // 如果有接口限制
+    if (ruimeiyunForm.allowed_apis) {
+      configs.push({
+        config_type: 'external_api',
+        config_key: 'ruimeiyun_allowed_apis',
+        config_value: ruimeiyunForm.allowed_apis,
+        is_encrypted: 0,
+        description: '允许调用的接口列表'
+      })
+    }
+    
+    await api.post('/api/tool-configs/batch', {
+      tenant_id: tenantId,
+      tool_code: 'ruimeiyun',
+      configs
+    })
+    
+    ElMessage.success('保存成功')
+    // 重新加载
+    ruimeiyunLoaded.value = false
+    fetchRuimeiyunConfig()
+  } catch (e) {
+    console.error('保存失败:', e)
+  } finally {
+    ruimeiyunLoading.value = false
+  }
+}
+
+async function testRuimeiyunConnection() {
+  ruimeiyunTesting.value = true
+  try {
+    const res = await api.get(`/api/ruimeiyun/health/${tenantId}`)
+    if (res.data.status === 'connected') {
+      ElMessage.success(`连接成功！账号: ${res.data.account}`)
+    } else {
+      ElMessage.error(`连接失败: ${res.data.message}`)
+    }
+  } catch (e) {
+    ElMessage.error(`测试失败: ${e.response?.data?.detail || e.message}`)
+  } finally {
+    ruimeiyunTesting.value = false
+  }
+}
+
 onMounted(() => {
   fetchDetail()
 })
@@ -44,13 +373,15 @@ onMounted(() => {
         <el-button link @click="router.back()">
           <el-icon><ArrowLeft /></el-icon>
         </el-button>
-        租户详情
+        租户详情 <span v-if="tenant" style="color: #909399; margin-left: 8px">{{ tenant.name }}</span>
       </div>
     </div>
     
     <template v-if="tenant">
-      <!-- 基本信息 -->
+      <el-tabs v-model="activeTab">
-      <el-descriptions title="基本信息" :column="2" border style="margin-bottom: 20px">
+        <!-- 基本信息 Tab -->
+        <el-tab-pane label="基本信息" name="basic">
+          <el-descriptions :column="2" border style="margin-bottom: 20px">
             <el-descriptions-item label="租户ID">{{ tenant.id }}</el-descriptions-item>
             <el-descriptions-item label="租户代码">{{ tenant.code }}</el-descriptions-item>
             <el-descriptions-item label="租户名称">{{ tenant.name }}</el-descriptions-item>
@@ -100,6 +431,286 @@ onMounted(() => {
             </el-table>
             <el-empty v-if="!tenant.subscriptions?.length" description="暂无订阅" />
           </div>
+        </el-tab-pane>
+        
+        <!-- 瑞美云配置 Tab -->
+        <el-tab-pane label="瑞美云配置" name="ruimeiyun">
+          <div class="ruimeiyun-container" v-loading="ruimeiyunLoading">
+            <el-alert 
+              type="info" 
+              :closable="false" 
+              style="margin-bottom: 20px"
+            >
+              <template #title>
+                配置租户的睿美云 TPOS 接口连接信息，配置后可通过 Platform 代理调用睿美云接口
               </template>
+            </el-alert>
+            
+            <el-form 
+              ref="ruimeiyunFormRef" 
+              :model="ruimeiyunForm" 
+              :rules="ruimeiyunRules" 
+              label-width="120px"
+              style="max-width: 600px"
+            >
+              <el-form-item label="API 地址" prop="base_url">
+                <el-input 
+                  v-model="ruimeiyunForm.base_url" 
+                  placeholder="例如: https://xxx.ruimeiyun.com"
+                />
+                <div class="form-hint">睿美云 TPOS 接口的基础地址</div>
+              </el-form-item>
+              
+              <el-form-item label="账号" prop="account">
+                <el-input 
+                  v-model="ruimeiyunForm.account" 
+                  placeholder="TPOS 接口账号"
+                />
+              </el-form-item>
+              
+              <el-form-item label="私钥" prop="private_key">
+                <el-input 
+                  v-model="ruimeiyunForm.private_key" 
+                  type="textarea"
+                  :rows="4"
+                  placeholder="RSA 私钥（PEM 格式）"
+                />
+                <div class="form-hint">用于 TPOS 接口签名的 RSA 私钥，将加密存储</div>
+              </el-form-item>
+              
+              <el-form-item label="接口限制">
+                <el-input 
+                  v-model="ruimeiyunForm.allowed_apis" 
+                  type="textarea"
+                  :rows="2"
+                  placeholder='可选，JSON 数组格式，例如: ["customer.search", "order.list"]'
+                />
+                <div class="form-hint">限制租户可调用的接口，留空表示允许所有接口</div>
+              </el-form-item>
+              
+              <el-form-item>
+                <el-button type="primary" @click="saveRuimeiyunConfig" :loading="ruimeiyunLoading">
+                  保存配置
+                </el-button>
+                <el-button @click="testRuimeiyunConnection" :loading="ruimeiyunTesting">
+                  测试连接
+                </el-button>
+              </el-form-item>
+            </el-form>
+          </div>
+        </el-tab-pane>
+        
+        <!-- 工具配置 Tab -->
+        <el-tab-pane label="工具配置" name="config">
+          <div class="config-container" v-loading="configLoading">
+            <!-- 工具选择 Tabs -->
+            <div class="tool-tabs">
+              <el-radio-group v-model="selectedTool" size="small">
+                <el-radio-button 
+                  v-for="tool in toolTabs" 
+                  :key="tool.code" 
+                  :value="tool.code"
+                >
+                  {{ tool.name }}
+                </el-radio-button>
+              </el-radio-group>
+              
+              <el-button 
+                v-if="authStore.isOperator" 
+                type="primary" 
+                size="small" 
+                @click="handleAddConfig"
+                style="margin-left: 16px"
+              >
+                <el-icon><Plus /></el-icon>
+                添加配置
+              </el-button>
+            </div>
+            
+            <!-- 配置列表（按类型分组） -->
+            <div class="config-groups">
+              <template v-if="Object.keys(groupedConfigs).length > 0">
+                <div 
+                  v-for="(configs, type) in groupedConfigs" 
+                  :key="type" 
+                  class="config-group"
+                >
+                  <div class="group-header">
+                    <span class="group-title">{{ getTypeName(type) }}</span>
+                  </div>
+                  <el-table :data="configs" size="small">
+                    <el-table-column prop="config_key" label="配置键" width="200" />
+                    <el-table-column prop="config_value" label="配置值">
+                      <template #default="{ row }">
+                        <span v-if="row.is_encrypted" class="encrypted-value">******</span>
+                        <span v-else>{{ row.config_value || '-' }}</span>
+                      </template>
+                    </el-table-column>
+                    <el-table-column prop="description" label="说明" width="200" />
+                    <el-table-column label="操作" width="150" fixed="right">
+                      <template #default="{ row }">
+                        <el-button 
+                          v-if="authStore.isOperator" 
+                          type="primary" 
+                          link 
+                          size="small" 
+                          @click="handleEditConfig(row)"
+                        >编辑</el-button>
+                        <el-button 
+                          v-if="authStore.isOperator" 
+                          type="danger" 
+                          link 
+                          size="small" 
+                          @click="handleDeleteConfig(row)"
+                        >删除</el-button>
+                      </template>
+                    </el-table-column>
+                  </el-table>
                 </div>
               </template>
+              
+              <el-empty 
+                v-else 
+                :description="`暂无${selectedTool === '__shared__' ? '租户通用' : '该工具'}配置`"
+              >
+                <el-button v-if="authStore.isOperator" type="primary" @click="handleAddConfig">
+                  添加配置
+                </el-button>
+              </el-empty>
+            </div>
+          </div>
+        </el-tab-pane>
+      </el-tabs>
+    </template>
+    
+    <!-- 配置编辑对话框 -->
+    <el-dialog v-model="configDialogVisible" :title="configDialogTitle" width="550px">
+      <el-form ref="configFormRef" :model="configForm" :rules="configRules" label-width="100px">
+        <el-form-item label="配置类型" prop="config_type">
+          <el-select 
+            v-model="configForm.config_type" 
+            :disabled="!!editingConfigId"
+            style="width: 100%"
+          >
+            <el-option 
+              v-for="t in configTypes" 
+              :key="t.code" 
+              :label="t.name" 
+              :value="t.code"
+            >
+              <span>{{ t.name }}</span>
+              <span style="color: #909399; font-size: 12px; margin-left: 8px">{{ t.description }}</span>
+            </el-option>
+          </el-select>
+        </el-form-item>
+        
+        <el-form-item label="配置键" prop="config_key">
+          <el-autocomplete
+            v-model="configForm.config_key"
+            :fetch-suggestions="(query, cb) => {
+              const keys = configKeyOptions[configForm.config_type] || []
+              const results = query 
+                ? keys.filter(k => k.key.includes(query) || k.name.includes(query))
+                : keys
+              cb(results.map(k => ({ value: k.key, name: k.name })))
+            }"
+            :disabled="!!editingConfigId"
+            placeholder="输入或选择配置键"
+            style="width: 100%"
+          >
+            <template #default="{ item }">
+              <span>{{ item.value }}</span>
+              <span style="color: #909399; font-size: 12px; margin-left: 8px">{{ item.name }}</span>
+            </template>
+          </el-autocomplete>
+        </el-form-item>
+        
+        <el-form-item label="配置值">
+          <el-input 
+            v-model="configForm.config_value" 
+            :type="configForm.is_encrypted ? 'password' : 'text'"
+            :show-password="configForm.is_encrypted"
+            placeholder="请输入配置值"
+          />
+        </el-form-item>
+        
+        <el-form-item label="加密存储">
+          <el-switch 
+            v-model="configForm.is_encrypted" 
+            :active-value="1" 
+            :inactive-value="0"
+          />
+          <span style="color: #909399; font-size: 12px; margin-left: 8px">
+            敏感信息（如密码、密钥）建议加密存储
+          </span>
+        </el-form-item>
+        
+        <el-form-item label="说明">
+          <el-input 
+            v-model="configForm.description" 
+            type="textarea" 
+            :rows="2"
+            placeholder="可选，描述此配置的用途"
+          />
+        </el-form-item>
+      </el-form>
+      <template #footer>
+        <el-button @click="configDialogVisible = false">取消</el-button>
+        <el-button type="primary" @click="handleConfigSubmit">确定</el-button>
+      </template>
+    </el-dialog>
+  </div>
+</template>
+
+<style scoped>
+.config-container {
+  padding: 0 4px;
+}
+
+.tool-tabs {
+  display: flex;
+  align-items: center;
+  margin-bottom: 20px;
+  flex-wrap: wrap;
+  gap: 8px;
+}
+
+.config-groups {
+  min-height: 200px;
+}
+
+.config-group {
+  margin-bottom: 24px;
+}
+
+.group-header {
+  display: flex;
+  align-items: center;
+  justify-content: space-between;
+  margin-bottom: 12px;
+  padding-bottom: 8px;
+  border-bottom: 1px solid #ebeef5;
+}
+
+.group-title {
+  font-weight: 600;
+  color: #303133;
+  font-size: 14px;
+}
+
+.encrypted-value {
+  color: #909399;
+  font-family: monospace;
+}
+
+.ruimeiyun-container {
+  padding: 0 4px;
+}
+
+.form-hint {
+  font-size: 12px;
+  color: #909399;
+  line-height: 1.5;
+  margin-top: 4px;
+}
+</style>