merge: 合并 main 分支到 docker，保留 docker-compose.yml 和分页接口

routes/admin/__init__.py

@@ -1,20 +0,0 @@
-# -*- coding: utf-8 -*-
-"""Admin 路由模块 - 合并所有子模块路由"""
-from fastapi import APIRouter
-
-from .auth import router as auth_router, verify_admin, ADMIN_KEY
-from .config import router as config_router
-from .accounts import router as accounts_router
-from .vercel import router as vercel_router
-
-# 创建主路由
-router = APIRouter(prefix="/admin", tags=["admin"])
-
-# 包含所有子路由
-router.include_router(auth_router)
-router.include_router(config_router)
-router.include_router(accounts_router)
-router.include_router(vercel_router)
-
-# 导出常用依赖
-__all__ = ["router", "verify_admin", "ADMIN_KEY"]

routes/admin/accounts.py

@@ -1,342 +0,0 @@
-# -*- coding: utf-8 -*-
-"""Admin 账号管理模块 - 账号测试与导入"""
-import asyncio
-import json
-import base64
-
-from fastapi import APIRouter, HTTPException, Request, Depends
-from fastapi.responses import JSONResponse
-
-from core.config import CONFIG, save_config, logger, WASM_PATH
-from core.auth import init_account_queue, get_account_identifier
-from core.deepseek import (
-    login_deepseek_via_account, 
-    DEEPSEEK_CREATE_SESSION_URL, 
-    DEEPSEEK_COMPLETION_URL, 
-    BASE_HEADERS,
-)
-from core.pow import compute_pow_answer
-from core.models import get_model_config
-from core.sse_parser import parse_sse_chunk_for_content
-
-from .auth import verify_admin
-
-router = APIRouter()
-
-
-# ----------------------------------------------------------------------
-# 账号 API 测试
-# ----------------------------------------------------------------------
-async def test_account_api(account: dict, model: str = "deepseek-chat", message: str = "") -> dict:
-    """测试单个账号的 API 调用能力
-    
-    如果提供 message，会发送实际请求并返回 AI 回复；
-    否则只快速测试创建会话。
-    """
-    from curl_cffi import requests as cffi_requests
-    import time
-    
-    acc_id = get_account_identifier(account)
-    result = {
-        "account": acc_id,
-        "success": False,
-        "response_time": 0,
-        "message": "",
-        "model": model,
-    }
-    
-    start_time = time.time()
-    
-    def _is_token_invalid(status_code: int, data: dict) -> bool:
-        msg = (data.get("msg") or data.get("message") or "").lower()
-        code = data.get("code")
-        return status_code in {401, 403} or code in {40001, 40002, 40003} or "token" in msg or "unauthorized" in msg
-
-    def _create_session(token: str) -> dict:
-        headers = {**BASE_HEADERS, "authorization": f"Bearer {token}"}
-        try:
-            session_resp = cffi_requests.post(
-                DEEPSEEK_CREATE_SESSION_URL,
-                headers=headers,
-                json={"agent": "chat"},
-                impersonate="safari15_3",
-                timeout=15,
-            )
-        except Exception as e:
-            return {"success": False, "message": f"请求异常: {e}", "status_code": 0, "data": {}}
-
-        try:
-            session_data = session_resp.json()
-        except Exception:
-            session_data = {}
-        finally:
-            session_resp.close()
-
-        if session_resp.status_code == 200 and session_data.get("code") == 0:
-            return {
-                "success": True,
-                "session_id": session_data.get("data", {}).get("biz_data", {}).get("id"),
-                "status_code": session_resp.status_code,
-                "data": session_data,
-            }
-        return {
-            "success": False,
-            "message": session_data.get("msg") or f"HTTP {session_resp.status_code}",
-            "status_code": session_resp.status_code,
-            "data": session_data,
-        }
-
-    try:
-        token = account.get("token", "").strip()
-        session_result = None
-        if token:
-            session_result = _create_session(token)
-
-        if not token or (session_result and not session_result["success"] and _is_token_invalid(session_result["status_code"], session_result["data"])):
-            try:
-                account["token"] = ""
-                login_deepseek_via_account(account)
-                token = account.get("token", "")
-                session_result = _create_session(token)
-            except Exception as e:
-                result["message"] = f"登录失败: {str(e)}"
-                return result
-
-        if not session_result or not session_result["success"]:
-            result["message"] = f"创建会话失败: {session_result['message'] if session_result else 'Unknown error'}"
-            return result
-
-        session_id = session_result["session_id"]
-        headers = {**BASE_HEADERS, "authorization": f"Bearer {token}"}
-        
-        if not message.strip():
-            result["success"] = True
-            result["message"] = "API 测试成功（仅会话创建）"
-            result["response_time"] = round((time.time() - start_time) * 1000)
-            return result
-        
-        pow_url = "https://chat.deepseek.com/api/v0/chat/create_pow_challenge"
-        pow_resp = cffi_requests.post(
-            pow_url,
-            headers=headers,
-            json={"target_path": "/api/v0/chat/completion"},
-            timeout=30,
-            impersonate="safari15_3",
-        )
-        
-        pow_data = pow_resp.json()
-        if pow_data.get("code") != 0:
-            result["message"] = f"获取 PoW 失败: {pow_data.get('msg')}"
-            return result
-        
-        challenge = pow_data["data"]["biz_data"]["challenge"]
-        try:
-            answer = compute_pow_answer(
-                challenge["algorithm"],
-                challenge["challenge"],
-                challenge["salt"],
-                challenge.get("difficulty", 144000),
-                challenge.get("expire_at", 1680000000),
-                challenge["signature"],
-                challenge["target_path"],
-                WASM_PATH,
-            )
-        except Exception as e:
-            result["message"] = f"PoW 计算失败: {str(e)}"
-            return result
-        
-        pow_dict = {
-            "algorithm": challenge["algorithm"],
-            "challenge": challenge["challenge"],
-            "salt": challenge["salt"],
-            "answer": answer,
-            "signature": challenge["signature"],
-            "target_path": challenge["target_path"],
-        }
-        pow_str = json.dumps(pow_dict, separators=(",", ":"), ensure_ascii=False)
-        pow_header = base64.b64encode(pow_str.encode("utf-8")).decode("utf-8").rstrip()
-        
-        thinking_enabled, search_enabled = get_model_config(model)
-        if thinking_enabled is None:
-            thinking_enabled = False
-            search_enabled = False
-        
-        payload = {
-            "chat_session_id": session_id,
-            "prompt": f"<｜User｜>{message}",
-            "ref_file_ids": [],
-            "thinking_enabled": thinking_enabled,
-            "search_enabled": search_enabled,
-        }
-        
-        completion_headers = {**headers, "x-ds-pow-response": pow_header}
-        
-        completion_resp = cffi_requests.post(
-            DEEPSEEK_COMPLETION_URL,
-            headers=completion_headers,
-            json=payload,
-            impersonate="safari15_3",
-            timeout=60,
-            stream=True,
-        )
-        
-        if completion_resp.status_code != 200:
-            result["message"] = f"请求失败: HTTP {completion_resp.status_code}"
-            return result
-        
-        thinking_parts = []
-        content_parts = []
-        current_fragment_type = "thinking" if thinking_enabled else "text"
-        
-        for line in completion_resp.iter_lines():
-            if not line:
-                continue
-            try:
-                line_str = line.decode("utf-8")
-            except:
-                continue
-            
-            if not line_str.startswith("data:"):
-                continue
-            
-            data_str = line_str[5:].strip()
-            if data_str == "[DONE]":
-                break
-            
-            try:
-                chunk = json.loads(data_str)
-                # 使用共享的解析函数
-                contents, is_finished, current_fragment_type = parse_sse_chunk_for_content(
-                    chunk, thinking_enabled, current_fragment_type
-                )
-                
-                if is_finished:
-                    break
-                
-                for content, ctype in contents:
-                    if ctype == "thinking":
-                        thinking_parts.append(content)
-                    else:
-                        content_parts.append(content)
-            except:
-                continue
-        
-        completion_resp.close()
-        
-        result["success"] = True
-        result["response_time"] = round((time.time() - start_time) * 1000)
-        result["message"] = "".join(content_parts) or "（无回复内容）"
-        if thinking_parts:
-            result["thinking"] = "".join(thinking_parts)
-        
-    except Exception as e:
-        result["message"] = f"测试失败: {str(e)}"
-    
-    return result
-
-
-@router.post("/accounts/test")
-async def test_single_account(request: Request, _: bool = Depends(verify_admin)):
-    """测试单个账号的 API 调用"""
-    data = await request.json()
-    identifier = data.get("identifier", "")
-    model = data.get("model", "deepseek-chat")
-    message = data.get("message", "")
-    
-    if not identifier:
-        raise HTTPException(status_code=400, detail="需要账号标识（email 或 mobile）")
-    
-    account = None
-    for acc in CONFIG.get("accounts", []):
-        if acc.get("email") == identifier or acc.get("mobile") == identifier:
-            account = acc
-            break
-    
-    if not account:
-        raise HTTPException(status_code=404, detail="账号不存在")
-    
-    result = await test_account_api(account, model, message)
-    save_config(CONFIG)
-    
-    return JSONResponse(content=result)
-
-
-@router.post("/accounts/test-all")
-async def test_all_accounts(request: Request, _: bool = Depends(verify_admin)):
-    """批量测试所有账号的 API 调用"""
-    data = await request.json()
-    model = data.get("model", "deepseek-chat")
-    
-    accounts = CONFIG.get("accounts", [])
-    if not accounts:
-        return JSONResponse(content={
-            "total": 0, "success": 0, "failed": 0, "results": [],
-        })
-    
-    results = []
-    success_count = 0
-    
-    for acc in accounts:
-        result = await test_account_api(acc, model)
-        results.append(result)
-        if result["success"]:
-            success_count += 1
-        await asyncio.sleep(1)
-    
-    save_config(CONFIG)
-    
-    return JSONResponse(content={
-        "total": len(accounts),
-        "success": success_count,
-        "failed": len(accounts) - success_count,
-        "results": results,
-    })
-
-
-# ----------------------------------------------------------------------
-# 批量导入
-# ----------------------------------------------------------------------
-@router.post("/import")
-async def batch_import(request: Request, _: bool = Depends(verify_admin)):
-    """批量导入 keys 和 accounts"""
-    try:
-        data = await request.json()
-        imported_keys = 0
-        imported_accounts = 0
-        
-        if "keys" in data:
-            for key in data["keys"]:
-                if key not in CONFIG.get("keys", []):
-                    if "keys" not in CONFIG:
-                        CONFIG["keys"] = []
-                    CONFIG["keys"].append(key)
-                    imported_keys += 1
-        
-        if "accounts" in data:
-            existing_ids = set()
-            for acc in CONFIG.get("accounts", []):
-                existing_ids.add(acc.get("email", ""))
-                existing_ids.add(acc.get("mobile", ""))
-            
-            for acc in data["accounts"]:
-                acc_id = acc.get("email", "") or acc.get("mobile", "")
-                if acc_id and acc_id not in existing_ids:
-                    if "accounts" not in CONFIG:
-                        CONFIG["accounts"] = []
-                    CONFIG["accounts"].append(acc)
-                    existing_ids.add(acc_id)
-                    imported_accounts += 1
-        
-        init_account_queue()
-        save_config(CONFIG)
-        
-        return JSONResponse(content={
-            "success": True,
-            "imported_keys": imported_keys,
-            "imported_accounts": imported_accounts,
-        })
-    except json.JSONDecodeError:
-        raise HTTPException(status_code=400, detail="无效的 JSON 格式")
-    except Exception as e:
-        logger.error(f"[batch_import] 错误: {e}")
-        raise HTTPException(status_code=500, detail=str(e))

routes/admin/auth.py

@@ -1,155 +0,0 @@
-# -*- coding: utf-8 -*-
-"""Admin 认证模块 - JWT 和登录相关"""
-import base64
-import os
-import time
-import hashlib
-import hmac
-
-from fastapi import APIRouter, HTTPException, Request, Depends
-from fastapi.responses import JSONResponse
-from fastapi.security import HTTPBearer, HTTPAuthorizationCredentials
-
-from core.config import logger
-
-router = APIRouter()
-security = HTTPBearer(auto_error=False)
-
-# Admin Key 验证（默认值适用于开发/演示环境，生产环境请务必修改）
-ADMIN_KEY = os.getenv("DS2API_ADMIN_KEY", "your-admin-secret-key")
-
-# JWT 配置
-JWT_SECRET = os.getenv("DS2API_JWT_SECRET", ADMIN_KEY or "ds2api-default-secret")
-JWT_EXPIRE_HOURS = int(os.getenv("DS2API_JWT_EXPIRE_HOURS", "24"))
-
-
-# ----------------------------------------------------------------------
-# JWT 工具函数（轻量实现，无需额外依赖）
-# ----------------------------------------------------------------------
-def _b64_encode(data: bytes) -> str:
-    """Base64 URL 安全编码"""
-    return base64.urlsafe_b64encode(data).rstrip(b"=").decode("ascii")
-
-def _b64_decode(data: str) -> bytes:
-    """Base64 URL 安全解码"""
-    padding = 4 - len(data) % 4
-    if padding != 4:
-        data += "=" * padding
-    return base64.urlsafe_b64decode(data)
-
-def create_jwt_token(expire_hours: int = None) -> str:
-    """创建 JWT Token"""
-    import json
-    
-    if expire_hours is None:
-        expire_hours = JWT_EXPIRE_HOURS
-    
-    header = {"alg": "HS256", "typ": "JWT"}
-    payload = {
-        "iat": int(time.time()),
-        "exp": int(time.time()) + (expire_hours * 3600),
-        "role": "admin"
-    }
-    
-    header_b64 = _b64_encode(json.dumps(header, separators=(",", ":")).encode())
-    payload_b64 = _b64_encode(json.dumps(payload, separators=(",", ":")).encode())
-    
-    message = f"{header_b64}.{payload_b64}"
-    signature = hmac.new(JWT_SECRET.encode(), message.encode(), hashlib.sha256).digest()
-    signature_b64 = _b64_encode(signature)
-    
-    return f"{message}.{signature_b64}"
-
-def verify_jwt_token(token: str) -> dict:
-    """验证 JWT Token，返回 payload 或抛出异常"""
-    import json
-    
-    try:
-        parts = token.split(".")
-        if len(parts) != 3:
-            raise ValueError("Invalid token format")
-        
-        header_b64, payload_b64, signature_b64 = parts
-        
-        # 验证签名
-        message = f"{header_b64}.{payload_b64}"
-        expected_sig = hmac.new(JWT_SECRET.encode(), message.encode(), hashlib.sha256).digest()
-        actual_sig = _b64_decode(signature_b64)
-        
-        if not hmac.compare_digest(expected_sig, actual_sig):
-            raise ValueError("Invalid signature")
-        
-        # 解析 payload
-        payload = json.loads(_b64_decode(payload_b64))
-        
-        # 验证过期时间
-        if payload.get("exp", 0) < time.time():
-            raise ValueError("Token expired")
-        
-        return payload
-    except Exception as e:
-        raise ValueError(f"Token verification failed: {str(e)}")
-
-
-# ----------------------------------------------------------------------
-# 登录端点
-# ----------------------------------------------------------------------
-@router.post("/login")
-async def admin_login(request: Request):
-    """管理员登录，返回 JWT Token"""
-    try:
-        data = await request.json()
-    except:
-        data = {}
-    
-    admin_key = data.get("admin_key", "")
-    expire_hours = data.get("expire_hours", JWT_EXPIRE_HOURS)
-    
-    if admin_key != ADMIN_KEY:
-        raise HTTPException(status_code=401, detail="Invalid admin key")
-    
-    token = create_jwt_token(expire_hours)
-    return JSONResponse(content={
-        "success": True,
-        "token": token,
-        "expires_in": expire_hours * 3600
-    })
-
-
-@router.get("/verify")
-async def verify_token(credentials: HTTPAuthorizationCredentials = Depends(security)):
-    """验证当前 Token 是否有效"""
-    if not credentials:
-        raise HTTPException(status_code=401, detail="No credentials provided")
-    
-    token = credentials.credentials
-    try:
-        payload = verify_jwt_token(token)
-        return JSONResponse(content={
-            "valid": True,
-            "expires_at": payload.get("exp"),
-            "remaining_seconds": max(0, payload.get("exp", 0) - int(time.time()))
-        })
-    except ValueError as e:
-        raise HTTPException(status_code=401, detail=str(e))
-
-
-def verify_admin(credentials: HTTPAuthorizationCredentials = Depends(security)):
-    """验证 Admin 权限（支持 JWT 和直接 admin key）"""
-    if not credentials:
-        raise HTTPException(status_code=401, detail="Authentication required")
-    
-    token = credentials.credentials
-    
-    # 尝试 JWT 验证
-    try:
-        verify_jwt_token(token)
-        return True
-    except ValueError:
-        pass
-    
-    # 尝试直接 admin key
-    if token == ADMIN_KEY:
-        return True
-    
-    raise HTTPException(status_code=401, detail="Invalid credentials")

routes/admin/vercel.py

@@ -1,274 +0,0 @@
-# -*- coding: utf-8 -*-
-"""Admin Vercel 模块 - Vercel 同步和部署"""
-import asyncio
-import base64
-import json
-import os
-
-import httpx
-from fastapi import APIRouter, HTTPException, Request, Depends
-from fastapi.responses import JSONResponse
-
-from core.config import CONFIG, save_config, logger
-from core.auth import get_account_identifier, init_account_queue
-from core.deepseek import login_deepseek_via_account
-
-from .auth import verify_admin
-
-router = APIRouter()
-
-# Vercel 预配置
-VERCEL_TOKEN = os.getenv("VERCEL_TOKEN", "")
-VERCEL_PROJECT_ID = os.getenv("VERCEL_PROJECT_ID", "")
-VERCEL_TEAM_ID = os.getenv("VERCEL_TEAM_ID", "")
-
-
-# ----------------------------------------------------------------------
-# API 测试（通过本地 API）
-# ----------------------------------------------------------------------
-@router.post("/test")
-async def test_api(request: Request, _: bool = Depends(verify_admin)):
-    """测试 API 调用"""
-    try:
-        data = await request.json()
-        model = data.get("model", "deepseek-chat")
-        message = data.get("message", "你好")
-        api_key = data.get("api_key", "")
-        
-        if not api_key:
-            keys = CONFIG.get("keys", [])
-            if not keys:
-                raise HTTPException(status_code=400, detail="没有可用的 API Key")
-            api_key = keys[0]
-        
-        host = request.headers.get("host", "localhost:5001")
-        scheme = "https" if "vercel" in host.lower() else "http"
-        base_url = f"{scheme}://{host}"
-        
-        async with httpx.AsyncClient(timeout=60.0) as client:
-            response = await client.post(
-                f"{base_url}/v1/chat/completions",
-                headers={"Authorization": f"Bearer {api_key}"},
-                json={
-                    "model": model,
-                    "messages": [{"role": "user", "content": message}],
-                    "stream": False,
-                },
-            )
-            
-            return JSONResponse(content={
-                "success": response.status_code == 200,
-                "status_code": response.status_code,
-                "response": response.json() if response.status_code == 200 else response.text,
-            })
-    except Exception as e:
-        logger.error(f"[test_api] 错误: {e}")
-        return JSONResponse(content={"success": False, "error": str(e)})
-
-
-# ----------------------------------------------------------------------
-# Vercel 同步
-# ----------------------------------------------------------------------
-@router.post("/vercel/sync")
-async def sync_to_vercel(request: Request, _: bool = Depends(verify_admin)):
-    """同步配置到 Vercel 并触发重新部署"""
-    try:
-        data = await request.json()
-        vercel_token = data.get("vercel_token", "")
-        project_id = data.get("project_id", "")
-        team_id = data.get("team_id", "")
-        auto_validate = data.get("auto_validate", True)
-        save_vercel_credentials = data.get("save_credentials", True)
-        
-        use_preconfig = vercel_token == "__USE_PRECONFIG__" or not vercel_token
-        if use_preconfig:
-            vercel_token = VERCEL_TOKEN
-        if not project_id:
-            project_id = VERCEL_PROJECT_ID
-        if not team_id:
-            team_id = VERCEL_TEAM_ID
-        
-        if not vercel_token or not project_id:
-            raise HTTPException(status_code=400, detail="需要 Vercel Token 和 Project ID")
-        
-        # 自动验证账号
-        validated_count = 0
-        failed_accounts = []
-        if auto_validate:
-            accounts = CONFIG.get("accounts", [])
-            for acc in accounts:
-                acc_id = get_account_identifier(acc)
-                if not acc.get("token", "").strip():
-                    try:
-                        logger.info(f"[sync_to_vercel] 自动验证账号: {acc_id}")
-                        login_deepseek_via_account(acc)
-                        validated_count += 1
-                    except Exception as e:
-                        logger.warning(f"[sync_to_vercel] 账号 {acc_id} 验证失败: {e}")
-                        failed_accounts.append(acc_id)
-                    await asyncio.sleep(0.5)
-        
-        config_json = json.dumps(CONFIG, ensure_ascii=False, separators=(",", ":"))
-        config_b64 = base64.b64encode(config_json.encode("utf-8")).decode("utf-8")
-        
-        headers = {"Authorization": f"Bearer {vercel_token}"}
-        base_url = "https://api.vercel.com"
-        
-        async with httpx.AsyncClient(timeout=30.0) as client:
-            params = {"teamId": team_id} if team_id else {}
-            env_resp = await client.get(
-                f"{base_url}/v9/projects/{project_id}/env",
-                headers=headers,
-                params=params,
-            )
-            
-            if env_resp.status_code != 200:
-                raise HTTPException(status_code=env_resp.status_code, detail=f"获取环境变量失败: {env_resp.text}")
-            
-            env_vars = env_resp.json().get("envs", [])
-            existing_env = None
-            for env in env_vars:
-                if env.get("key") == "DS2API_CONFIG_JSON":
-                    existing_env = env
-                    break
-            
-            if existing_env:
-                env_id = existing_env["id"]
-                update_resp = await client.patch(
-                    f"{base_url}/v9/projects/{project_id}/env/{env_id}",
-                    headers=headers,
-                    params=params,
-                    json={"value": config_b64},
-                )
-                if update_resp.status_code not in [200, 201]:
-                    raise HTTPException(status_code=update_resp.status_code, detail=f"更新环境变量失败: {update_resp.text}")
-            else:
-                create_resp = await client.post(
-                    f"{base_url}/v10/projects/{project_id}/env",
-                    headers=headers,
-                    params=params,
-                    json={
-                        "key": "DS2API_CONFIG_JSON",
-                        "value": config_b64,
-                        "type": "encrypted",
-                        "target": ["production", "preview"],
-                    },
-                )
-                if create_resp.status_code not in [200, 201]:
-                    raise HTTPException(status_code=create_resp.status_code, detail=f"创建环境变量失败: {create_resp.text}")
-            
-            # 保存 Vercel 凭证
-            saved_credentials = []
-            if save_vercel_credentials and not use_preconfig:
-                creds_to_save = [
-                    ("VERCEL_TOKEN", vercel_token),
-                    ("VERCEL_PROJECT_ID", project_id),
-                ]
-                if team_id:
-                    creds_to_save.append(("VERCEL_TEAM_ID", team_id))
-                
-                for key, value in creds_to_save:
-                    existing = None
-                    for env in env_vars:
-                        if env.get("key") == key:
-                            existing = env
-                            break
-                    
-                    if existing:
-                        upd_resp = await client.patch(
-                            f"{base_url}/v9/projects/{project_id}/env/{existing['id']}",
-                            headers=headers,
-                            params=params,
-                            json={"value": value},
-                        )
-                        if upd_resp.status_code in [200, 201]:
-                            saved_credentials.append(key)
-                    else:
-                        crt_resp = await client.post(
-                            f"{base_url}/v10/projects/{project_id}/env",
-                            headers=headers,
-                            params=params,
-                            json={
-                                "key": key,
-                                "value": value,
-                                "type": "encrypted",
-                                "target": ["production", "preview"],
-                            },
-                        )
-                        if crt_resp.status_code in [200, 201]:
-                            saved_credentials.append(key)
-            
-            # 触发重新部署
-            project_resp = await client.get(
-                f"{base_url}/v9/projects/{project_id}",
-                headers=headers,
-                params=params,
-            )
-            
-            if project_resp.status_code == 200:
-                project_data = project_resp.json()
-                repo = project_data.get("link", {})
-                
-                if repo.get("type") == "github":
-                    deploy_resp = await client.post(
-                        f"{base_url}/v13/deployments",
-                        headers=headers,
-                        params=params,
-                        json={
-                            "name": project_id,
-                            "project": project_id,
-                            "target": "production",
-                            "gitSource": {
-                                "type": "github",
-                                "repoId": repo.get("repoId"),
-                                "ref": repo.get("productionBranch", "main"),
-                            },
-                        },
-                    )
-                    
-                    if deploy_resp.status_code in [200, 201]:
-                        deploy_data = deploy_resp.json()
-                        result = {
-                            "success": True,
-                            "message": "配置已同步，正在重新部署...",
-                            "deployment_url": deploy_data.get("url"),
-                            "validated_accounts": validated_count,
-                        }
-                        if failed_accounts:
-                            result["failed_accounts"] = failed_accounts
-                        if saved_credentials:
-                            result["saved_credentials"] = saved_credentials
-                        return JSONResponse(content=result)
-            
-            result = {
-                "success": True,
-                "message": "配置已同步到 Vercel，请手动触发重新部署",
-                "manual_deploy_required": True,
-                "validated_accounts": validated_count,
-            }
-            if failed_accounts:
-                result["failed_accounts"] = failed_accounts
-            if saved_credentials:
-                result["saved_credentials"] = saved_credentials
-            return JSONResponse(content=result)
-            
-    except HTTPException:
-        raise
-    except Exception as e:
-        logger.error(f"[sync_to_vercel] 错误: {e}")
-        raise HTTPException(status_code=500, detail=str(e))
-
-
-# ----------------------------------------------------------------------
-# 导出配置
-# ----------------------------------------------------------------------
-@router.get("/export")
-async def export_config(_: bool = Depends(verify_admin)):
-    """导出完整配置（JSON 和 Base64）"""
-    config_json = json.dumps(CONFIG, ensure_ascii=False, separators=(",", ":"))
-    config_b64 = base64.b64encode(config_json.encode("utf-8")).decode("utf-8")
-    
-    return JSONResponse(content={
-        "json": config_json,
-        "base64": config_b64,
-    })