Upload 13 files

Dockerfile

@@ -0,0 +1,17 @@
+FROM python:3.10-slim
+
+# 设置工作目录
+WORKDIR /app
+
+# 复制requirements.txt并安装Python依赖
+COPY requirements.txt .
+RUN pip install --no-cache-dir --user -r requirements.txt
+
+# 复制项目文件
+COPY . .
+
+# 暴露端口
+EXPOSE 7860
+
+# 启动命令
+CMD ["python", "warp_api_server.py"] 

api_service.py

@@ -0,0 +1,297 @@
+"""
+API服务模块
+处理所有API请求逻辑，包括聊天完成和Token管理
+"""
+import json
+import time
+from datetime import datetime
+from typing import List, Dict, Any, Generator
+from loguru import logger
+
+from config import Config
+from utils import Utils
+from token_manager import MultiTokenManager
+from warp_client import WarpClient
+from request_converter import RequestConverter
+from model_mapper import ModelMapper
+
+
+class ApiService:
+    """API服务类，处理所有业务逻辑"""
+    
+    def __init__(self):
+        # 初始化Token管理器
+        self.token_manager = MultiTokenManager()
+        
+        # 初始化Warp客户端
+        self.warp_client = WarpClient(self.token_manager)
+        
+        logger.info("🚀 ApiService初始化完成")
+    
+    def authenticate_request(self, auth_header: str) -> bool:
+        """验证API请求"""
+        if not auth_header:
+            return False
+            
+        token = Utils.extract_bearer_token(auth_header)
+        if not token:
+            return False
+            
+        return Utils.validate_api_key(token)
+    
+    def get_models(self) -> Dict[str, Any]:
+        """获取支持的模型列表"""
+        return ModelMapper.get_openai_models()
+    
+    def chat_completion(self, request_data: Dict[str, Any], stream: bool = False) -> Generator[str, None, None]:
+        """处理聊天完成请求"""
+        request_id = Utils.generate_request_id()
+        # 解析请求
+        openai_request = RequestConverter.parse_openai_request(request_data)
+        model = openai_request.model
+        messages = openai_request.messages
+        
+        logger.info(f"🎯 开始处理聊天请求 [ID: {request_id[:8]}] [模型: {model}] [流式: {stream}]")
+        start_time = time.time()
+        
+        try:
+            # 创建protobuf数据
+            protobuf_data = self.warp_client.create_protobuf_data(messages, model)
+            if not protobuf_data:
+                error_msg = "创建请求数据失败"
+                logger.error(f"❌ {error_msg} [ID: {request_id[:8]}]")
+                yield self._create_error_response(error_msg, request_id)
+                return
+            
+            # 发送请求并处理响应
+            response_chunks = 0
+            total_content = ""
+            
+            logger.success(f"🚀 开始接收响应 [ID: {request_id[:8]}]")
+            
+            for chunk_text in self.warp_client.send_request(protobuf_data):
+                if chunk_text:
+                    response_chunks += 1
+                    total_content += chunk_text
+                    
+                    logger.debug(f"📦 响应块 #{response_chunks} [ID: {request_id[:8]}] [长度: {len(chunk_text)}]")
+                    
+                    if stream:
+                        # 流式响应
+                        chunk_response = self._create_stream_chunk(chunk_text, request_id)
+                        yield f"data: {json.dumps(chunk_response)}\n\n"
+                    else:
+                        # 非流式响应 - 等待完整内容
+                        continue
+            
+            # 处理响应结束
+            end_time = time.time()
+            duration = end_time - start_time
+            
+            if stream:
+                # 发送结束标记
+                final_chunk = self._create_stream_end_chunk(request_id)
+                yield f"data: {json.dumps(final_chunk)}\n\n"
+                yield "data: [DONE]\n\n"
+                
+                logger.success(f"✅ 流式响应完成 [ID: {request_id[:8]}] [块数: {response_chunks}] [耗时: {duration:.2f}s]")
+            else:
+                # 返回完整响应
+                response = self._create_complete_response(total_content, request_id)
+                yield response
+                
+                logger.success(f"✅ 完整响应完成 [ID: {request_id[:8]}] [长度: {len(total_content)}] [耗时: {duration:.2f}s]")
+                
+        except Exception as e:
+            logger.error(f"❌ 聊天请求处理失败 [ID: {request_id[:8]}]: {e}")
+            yield self._create_error_response(f"服务器内部错误: {str(e)}", request_id)
+    
+    def _create_stream_chunk(self, content: str, request_id: str) -> Dict[str, Any]:
+        """创建流式响应块"""
+        return {
+            "id": f"chatcmpl-{request_id}",
+            "object": "chat.completion.chunk",
+            "created": int(time.time()),
+            "model": "gemini-2.0-flash",
+            "choices": [{
+                "index": 0,
+                "delta": {"content": content},
+                "finish_reason": None
+            }]
+        }
+    
+    def _create_stream_end_chunk(self, request_id: str) -> Dict[str, Any]:
+        """创建流式响应结束块"""
+        return {
+            "id": f"chatcmpl-{request_id}",
+            "object": "chat.completion.chunk", 
+            "created": int(time.time()),
+            "model": "gemini-2.0-flash",
+            "choices": [{
+                "index": 0,
+                "delta": {},
+                "finish_reason": "stop"
+            }]
+        }
+    
+    def _create_complete_response(self, content: str, request_id: str) -> Dict[str, Any]:
+        """创建完整响应"""
+        return {
+            "id": f"chatcmpl-{request_id}",
+            "object": "chat.completion",
+            "created": int(time.time()),
+            "model": "gemini-2.0-flash",
+            "choices": [{
+                "index": 0,
+                "message": {
+                    "role": "assistant",
+                    "content": content
+                },
+                "finish_reason": "stop"
+            }],
+            "usage": {
+                "prompt_tokens": 0,
+                "completion_tokens": 0,
+                "total_tokens": 0
+            }
+        }
+    
+    def _create_error_response(self, error_message: str, request_id: str) -> Dict[str, Any]:
+        """创建错误响应"""
+        return {
+            "error": {
+                "message": error_message,
+                "type": "api_error",
+                "code": "internal_error"
+            },
+            "id": request_id
+        }
+    
+    def get_token_status(self) -> Dict[str, Any]:
+        """获取Token状态"""
+        try:
+            status = self.token_manager.get_token_status()
+            return {"success": True, **status}
+        except Exception as e:
+            logger.error(f"❌ 获取Token状态失败: {e}")
+            return {"success": False, "message": str(e)}
+    
+    def add_tokens(self, tokens: List[str]) -> Dict[str, Any]:
+        """添加Token"""
+        try:
+            success = self.token_manager.add_refresh_tokens(tokens)
+            if success:
+                valid_tokens = [t for t in tokens if Utils.validate_refresh_token_format(t)]
+                return {
+                    "success": True, 
+                    "message": "Token添加成功", 
+                    "added_tokens": len(valid_tokens)
+                }
+            else:
+                return {"success": False, "message": "没有有效的Token可添加"}
+        except Exception as e:
+            logger.error(f"❌ 添加Token失败: {e}")
+            return {"success": False, "message": str(e)}
+    
+    def remove_refresh_token(self, refresh_token: str) -> Dict[str, Any]:
+        """删除refresh token"""
+        try:
+            success = self.token_manager.remove_refresh_token(refresh_token)
+            if success:
+                return {"success": True, "message": "Token删除成功"}
+            else:
+                return {"success": False, "message": "Token不存在"}
+        except Exception as e:
+            logger.error(f"❌ 删除Token失败: {e}")
+            return {"success": False, "message": str(e)}
+    
+    def refresh_all_tokens(self) -> Dict[str, Any]:
+        """刷新所有Token"""
+        try:
+            self.token_manager.refresh_all_tokens()
+            return {"success": True, "message": "Token刷新已开始"}
+        except Exception as e:
+            logger.error(f"❌ 刷新Token失败: {e}")
+            return {"success": False, "message": str(e)}
+    
+    def export_refresh_tokens(self, super_admin_key: str) -> Dict[str, Any]:
+        """导出refresh token内容（需要超级管理员密钥验证）"""
+        try:
+            # 验证超级管理员密钥
+            if Config.require_super_admin_auth():
+                if not super_admin_key or super_admin_key != Config.get_super_admin_key():
+                    return {"success": False, "message": "超级管理员密钥验证失败"}
+            
+            # 获取所有refresh token
+            with self.token_manager.token_lock:
+                refresh_tokens = list(self.token_manager.tokens.keys())
+            
+            if not refresh_tokens:
+                return {"success": False, "message": "没有可导出的token"}
+            
+            # 创建分号分割的token字符串
+            token_string = ";".join(refresh_tokens)
+            
+            # 生成建议的文件名（带时间戳）
+            timestamp = datetime.now().strftime("%Y%m%d_%H%M%S")
+            suggested_filename = f"refresh_tokens_export_{timestamp}.txt"
+            
+            logger.info(f"🔒 超级管理员请求导出 {len(refresh_tokens)} 个refresh token")
+            
+            return {
+                "success": True,
+                "message": f"准备导出 {len(refresh_tokens)} 个token",
+                "content": token_string,
+                "suggested_filename": suggested_filename,
+                "token_count": len(refresh_tokens)
+            }
+            
+        except Exception as e:
+            logger.error(f"❌ 准备导出refresh token失败: {e}")
+            return {"success": False, "message": f"导出失败: {str(e)}"}
+    
+    def batch_get_refresh_tokens(self, email_url_dict: Dict[str, str], max_workers: int = 5) -> Dict[str, Any]:
+        """批量获取refresh token并自动创建用户"""
+        try:
+            from login_client import LoginClient
+            login_client = LoginClient()
+            
+            # 传递token_manager参数，这样在获取refresh_token后会立即尝试创建用户
+            results = login_client.batch_process_emails(email_url_dict, max_workers, self.token_manager)
+            
+            # 提取有效的token并添加到管理器
+            valid_tokens = []
+            for email, result in results.items():
+                if result.get('refresh_token'):
+                    valid_tokens.append(result['refresh_token'])
+            
+            if valid_tokens:
+                self.token_manager.add_refresh_tokens(valid_tokens)
+                logger.info(f"✅ 批量获取并添加了 {len(valid_tokens)} 个有效token")
+            
+            return {
+                'success': True,
+                'results': results,
+                'total_count': len(email_url_dict),
+                'success_count': len(valid_tokens)
+            }
+            
+        except Exception as e:
+            logger.error(f"❌ 批量获取refresh token失败: {e}")
+            return {'success': False, 'message': str(e)}
+    
+    def start_services(self):
+        """启动后台服务"""
+        try:
+            self.token_manager.start_auto_refresh()
+            logger.success("✅ 后台服务启动成功")
+        except Exception as e:
+            logger.error(f"❌ 启动后台服务失败: {e}")
+    
+    def stop_services(self):
+        """停止后台服务"""
+        try:
+            self.token_manager.stop_auto_refresh()
+            logger.info("⏹️ 后台服务已停止")
+        except Exception as e:
+            logger.error(f"❌ 停止后台服务失败: {e}") 

config.py

@@ -0,0 +1,105 @@
+"""
+配置管理模块
+包含所有全局配置常量和设置
+"""
+import os
+
+
+class Config:
+    """全局配置管理"""
+    
+    # 服务器配置
+    SERVER_HOST = "0.0.0.0"
+    SERVER_PORT = 7860
+    
+    # Warp API 配置
+    WARP_BASE_URL = "https://app.warp.dev"
+    WARP_AI_ENDPOINT = "/ai/multi-agent"
+    WARP_CLIENT_VERSION = "v0.2025.06.20.22.47.stable_07"
+    WARP_OS_CATEGORY = "Windows"
+    WARP_OS_NAME = "Windows" 
+    WARP_OS_VERSION = "10 (19045)"
+    
+    # Google Token相关配置
+    GOOGLE_TOKEN_URL = "https://securetoken.googleapis.com/v1/token?key=AIzaSyBdy3O3S9hrdayLJxJ7mriBR4qgUaUygAs"
+    TOKEN_REFRESH_INTERVAL = 50 * 60  # 50分钟，单位：秒
+    
+    # 登录相关配置
+    OPTIMIZATION_GUIDE_URL = "https://optimizationguide-pa.googleapis.com/v1:GetHints"
+    FIREBASE_LOGIN_URL = "https://identitytoolkit.googleapis.com/v1/accounts:signInWithEmailLink?key=AIzaSyBdy3O3S9hrdayLJxJ7mriBR4qgUaUygAs"
+    
+    # OpenAI API配置
+    OPENAI_API_VERSION = "v1"
+    
+    # 请求超时设置
+    REQUEST_TIMEOUT = 360
+    
+    # API密钥配置（从环境变量获取，默认为sk-123456）
+    @classmethod
+    def get_api_key(cls) -> str:
+        """获取API密钥"""
+        return os.environ.get('AUTH_API_KEY', 'sk-123456')
+    
+    @property
+    def VALID_API_KEYS(self) -> list:
+        """有效的API密钥列表"""
+        return [self.get_api_key()]
+    
+    # 管理员密钥配置
+    @classmethod
+    def get_admin_key(cls) -> str:
+        """获取管理员密钥（用于访问Web界面）"""
+        return os.environ.get('ADMIN_KEY', '')
+    
+    @classmethod
+    def get_super_admin_key(cls) -> str:
+        """获取超级管理员密钥（用于敏感操作如导出token）"""
+        return os.environ.get('SUPER_ADMIN_KEY', '')
+    
+    @classmethod
+    def require_admin_auth(cls) -> bool:
+        """是否需要管理员认证"""
+        return bool(cls.get_admin_key())
+    
+    @classmethod
+    def require_super_admin_auth(cls) -> bool:
+        """是否需要超级管理员认证"""
+        return bool(cls.get_super_admin_key())
+    
+    # refresh token环境变量配置（支持分号分割的多个token）
+    @classmethod
+    def get_refresh_tokens(cls) -> list:
+        """从环境变量获取refresh token列表（支持分号分割）"""
+        env_token = os.environ.get('WARP_REFRESH_TOKEN', '')
+        if not env_token:
+            return []
+        
+        # 使用分号分割多个token
+        tokens = [token.strip() for token in env_token.split(';') if token.strip()]
+        return tokens
+    
+    @classmethod
+    def get_refresh_token(cls) -> str:
+        """获取第一个refresh token（向后兼容）"""
+        tokens = cls.get_refresh_tokens()
+        return tokens[0] if tokens else ''
+    
+    # 日志配置
+    @classmethod
+    def enable_file_logging(cls) -> bool:
+        """是否启用文件日志"""
+        return os.environ.get('ENABLE_FILE_LOGGING', 'false').lower() in ('true', '1', 'yes', 'on','True')
+
+
+class LogConfig:
+    """日志配置"""
+    
+    LOG_LEVEL = "INFO"
+    LOG_FORMAT = '%(asctime)s - %(name)s - %(levelname)s - %(message)s'
+    
+
+class ProtobufConfig:
+    """Protobuf相关配置"""
+    
+    PROTO_FILE = "warp_unified.proto"
+    PROTO_PACKAGE = "warp_unified" 

login_client.py

@@ -0,0 +1,375 @@
+"""
+登录客户端模块
+处理Warp登录相关功能，包括获取refresh token
+"""
+import re
+import requests
+import urllib.parse
+from typing import Optional, Dict, List, Tuple
+from concurrent.futures import ThreadPoolExecutor
+from loguru import logger
+
+from config import Config
+from protobuf_manager import ProtobufManager
+
+
+class LoginClient:
+    """Warp登录客户端"""
+    
+    def __init__(self):
+        self.session = requests.Session()
+        
+    def create_protobuf_data(self, login_url: str) -> Optional[bytes]:
+        """创建登录请求的protobuf数据"""
+        return ProtobufManager.create_login_request(login_url)
+
+    def get_oob_code(self, login_url: str) -> Optional[str]:
+        """获取oob_code"""
+        logger.debug(f"🔄 开始获取oob_code，URL: {login_url[:50]}...")
+        
+        protobuf_data = self.create_protobuf_data(login_url)
+        if not protobuf_data:
+            return None
+            
+        headers = {
+            "User-Agent": "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/137.0.0.0 Safari/537.36",
+            "Connection": "keep-alive",
+            "Accept": "*/*",
+            "Accept-Encoding": "gzip, deflate, br, zstd",
+            "Content-Type": "application/octet-stream",
+            "x-goog-api-key": "AIzaSyA2KlwBX3mkFo30om9LUFYQhpqLoa_BNhE",
+            "content-type": "application/x-protobuf",
+            "x-client-data": "CK+1yQEIjLbJAQimtskBCKmdygEI74zLAQiVocsBCJKjywEIhaDNAQjY7c4BCOLwzgEIpfLOAQi88s4BCJP2zgEYnPPOAQ==",
+            "sec-fetch-site": "none",
+            "sec-fetch-mode": "no-cors",
+            "sec-fetch-dest": "empty",
+            "accept-language": "zh-CN,zh;q=0.9",
+            "priority": "u=4, i"
+        }
+        
+        try:
+            response = self.session.post(
+                Config.OPTIMIZATION_GUIDE_URL,
+                headers=headers,
+                data=protobuf_data,
+                timeout=60
+            )
+            
+            if response.status_code == 200:
+                logger.info(f"🔄 响应内容: {response.text}")
+                
+                # 使用ProtobufManager解析响应
+                decoded_url = ProtobufManager.parse_login_response(response.content)
+                logger.info(f"🔄 解码后的URL: {decoded_url}")
+                if decoded_url == "":
+                    logger.error("❌ 解码后的URL为空")
+                    decoded_url = response.text
+                
+                # 提取oob_code
+                pattern = r'oobCode=([^&]+)'
+                match = re.search(pattern, decoded_url)
+                if match:
+                    oob_code = match.group(1)
+                    logger.success(f"✅ 获取到oob_code: {oob_code[:20]}...")
+                    return oob_code
+                else:
+                    logger.error("❌ 未能从响应中提取oob_code")
+                    return None
+            else:
+                logger.error(f"❌ 请求失败: {response.status_code}")
+                return None
+                
+        except Exception as e:
+            logger.error(f"❌ 获取oob_code时出错: {e}")
+            return None
+
+    def verify_id_token(self, id_token: str) -> bool:
+        """验证idToken并使refresh_token生效"""
+        logger.debug(f"🔍 开始验证idToken: {id_token[:20]}...")
+        
+        headers = {
+            'User-Agent': 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/138.0.0.0 Safari/537.36',
+            'Accept-Encoding': 'gzip, deflate, br, zstd',
+            'Content-Type': 'application/json',
+            'sec-ch-ua-platform': '"Windows"',
+            'x-client-version': 'Chrome/JsCore/11.3.1/FirebaseCore-web',
+            'sec-ch-ua': '"Not)A;Brand";v="8", "Chromium";v="138", "Google Chrome";v="138"',
+            'sec-ch-ua-mobile': '?0',
+            'x-firebase-gmpid': '1:13153726198:web:1cc16bca7287752f8e06d7',
+            'origin': 'https://app.warp.dev',
+            'x-browser-channel': 'stable',
+            'x-browser-year': '2025',
+            'x-browser-validation': '6h3XF8YcD8syi2FF2BbuE2KllQo=',
+            'x-browser-copyright': 'Copyright 2025 Google LLC. All rights reserved.',
+            'x-client-data': 'CK+1yQEIjLbJAQimtskBCKmdygEI74zLAQiWocsBCJKjywEIhaDNAQji8M4BCJP2zgE=',
+            'sec-fetch-site': 'cross-site',
+            'sec-fetch-mode': 'cors',
+            'sec-fetch-dest': 'empty',
+            'accept-language': 'zh-CN,zh;q=0.9',
+            'priority': 'u=1, i'
+        }
+        
+        payload = {
+            'idToken': id_token
+        }
+        
+        try:
+            response = self.session.post(
+                'https://identitytoolkit.googleapis.com/v1/accounts:lookup?key=AIzaSyBdy3O3S9hrdayLJxJ7mriBR4qgUaUygAs',
+                headers=headers,
+                json=payload,
+                timeout=30
+            )
+            
+            if response.status_code == 200:
+                logger.success("✅ idToken验证成功，refresh_token已生效")
+                return True
+            else:
+                logger.error(f"❌ idToken验证失败，状态码: {response.status_code}")
+                logger.debug(f"❌ 响应内容: {response.text}")
+                return False
+                
+        except Exception as e:
+            logger.error(f"❌ 验证idToken时出错: {e}")
+            return False
+
+    def create_user_with_access_token(self, access_token: str) -> bool:
+        """使用access_token创建用户"""
+        logger.info(f"👤 开始创建用户，access_token: {access_token[:20]}...")
+        
+        headers = {
+            'User-Agent': 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/138.0.0.0 Safari/537.36',
+            'Accept-Encoding': 'gzip, deflate, br, zstd',
+            'Content-Type': 'application/json',
+            'sec-ch-ua-platform': '"Windows"',
+            'authorization': f'Bearer {access_token}',
+            'sec-ch-ua': '"Not)A;Brand";v="8", "Chromium";v="138", "Google Chrome";v="138"',
+            'sec-ch-ua-mobile': '?0',
+            'origin': 'https://app.warp.dev',
+            'sec-fetch-site': 'same-origin',
+            'sec-fetch-mode': 'cors',
+            'sec-fetch-dest': 'empty',
+            'accept-language': 'zh-CN,zh;q=0.9',
+            'priority': 'u=1, i',
+            'Cookie': 'rl_anonymous_id=8b178568-76c6-4e9f-8c72-461bd1909c1c'
+        }
+        
+        payload = {
+            "operationName": "GetOrCreateUser",
+            "variables": {
+                "input": {},
+                "requestContext": {
+                    "osContext": {},
+                    "clientContext": {}
+                }
+            },
+            "query": "mutation GetOrCreateUser($input: GetOrCreateUserInput!, $requestContext: RequestContext!) {\n  getOrCreateUser(requestContext: $requestContext, input: $input) {\n    ... on GetOrCreateUserOutput {\n      uid\n      isOnboarded\n      anonymousUserInfo {\n        anonymousUserType\n        linkedAt\n        __typename\n      }\n      workspaces {\n        joinableTeams {\n          teamUid\n          numMembers\n          name\n          teamAcceptingInvites\n          __typename\n        }\n        __typename\n      }\n      deletedAnonymousUser\n      __typename\n    }\n    ... on UserFacingError {\n      error {\n        message\n        __typename\n      }\n      __typename\n    }\n    __typename\n  }\n}\n"
+        }
+        
+        try:
+            response = self.session.post(
+                'https://app.warp.dev/graphql/v2?op=GetOrCreateUser',
+                headers=headers,
+                json=payload,
+                timeout=30
+            )
+            
+            if response.status_code == 200:
+                response_data = response.json()
+                # 检查是否有错误
+                if 'errors' in response_data:
+                    logger.error(f"❌ 创建用户失败，GraphQL错误: {response_data['errors']}")
+                    return False
+                
+                # 检查响应数据
+                data = response_data.get('data', {})
+                get_or_create_user = data.get('getOrCreateUser', {})
+                
+                if 'uid' in get_or_create_user:
+                    logger.success(f"✅ 用户创建成功，UID: {get_or_create_user['uid']}")
+                    return True
+                elif 'error' in get_or_create_user:
+                    logger.error(f"❌ 创建用户失败: {get_or_create_user['error']}")
+                    return False
+                else:
+                    logger.success("✅ 用户创建请求已发送")
+                    return True
+                    
+            else:
+                logger.error(f"❌ 创建用户失败，状态码: {response.status_code}")
+                logger.debug(f"❌ 响应内容: {response.text}")
+                return False
+                
+        except Exception as e:
+            logger.error(f"❌ 创建用户时出错: {e}")
+            return False
+
+    def get_refresh_token(self, email: str, oob_code: str) -> Optional[str]:
+        """使用email和oob_code获取refresh token，并验证idToken"""
+        logger.info(f"🔄 开始获取refresh token for {email}")
+        
+        headers = {
+            'User-Agent': 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/137.0.0.0 Safari/537.36',
+            'Accept-Encoding': 'gzip, deflate, br, zstd',
+            'Content-Type': 'application/json',
+            'sec-ch-ua-platform': 'Windows',
+            'x-client-version': 'Chrome/JsCore/11.3.1/FirebaseCore-web',
+            'sec-ch-ua': '"Google Chrome";v="137", "Chromium";v="137", "Not/A)Brand";v="24"',
+            'sec-ch-ua-mobile': '?0',
+            'x-firebase-gmpid': '1:13153726198:web:1cc16bca7287752f8e06d7',
+            'origin': 'https://app.warp.dev',
+            'x-client-data': 'CK+1yQEIjLbJAQimtskBCKmdygEI74zLAQiVocsBCJKjywEIhaDNAQji8M0BCKXyzgEIk/bOAQ==',
+            'sec-fetch-site': 'cross-site',
+            'sec-fetch-mode': 'cors',
+            'sec-fetch-dest': 'empty',
+            'accept-language': 'zh-CN,zh;q=0.9',
+            'priority': 'u=1, i'
+        }
+
+        payload = {
+            'email': email,
+            'oobCode': oob_code
+        }
+
+        try:
+            response = self.session.post(Config.FIREBASE_LOGIN_URL, headers=headers, json=payload, timeout=30)
+            
+            if response.status_code == 200:
+                response_data = response.json()
+                refresh_token = response_data.get("refreshToken")
+                id_token = response_data.get("idToken")
+                
+                if not refresh_token:
+                    logger.error(f"❌ 响应中未找到refreshToken字段 for {email}")
+                    return None
+                
+                if not id_token:
+                    logger.error(f"❌ 响应中未找到idToken字段 for {email}")
+                    return None
+                
+                logger.success(f"✅ 获取到refresh token和idToken for {email}")
+                
+                # 验证idToken使refresh_token生效
+                if self.verify_id_token(id_token):
+                    logger.success(f"🎉 refresh token验证成功并已生效 for {email}")
+                    return refresh_token
+                else:
+                    logger.error(f"❌ refresh token验证失败，设置为无效 for {email}")
+                    return None
+                    
+            else:
+                logger.error(f"❌ 获取refresh token失败 for {email}: {response.status_code}")
+                logger.debug(f"❌ 响应内容: {response.text}")
+                return None
+                
+        except Exception as e:
+            logger.error(f"❌ 获取refresh token时出错 for {email}: {e}")
+            return None
+
+    def process_single_email_with_user_creation(self, email: str, login_url: str, token_manager=None) -> Tuple[str, Optional[str], str]:
+        """处理单个email，返回(email, refresh_token, status)，并在获取refresh_token后创建用户"""
+        logger.info(f"🚀 开始处理邮箱: {email}")
+        
+        try:
+            # 获取oob_code
+            oob_code = self.get_oob_code(login_url)
+            if not oob_code:
+                return email, None, "获取oob_code失败"
+            
+            # 获取refresh token并验证
+            refresh_token = self.get_refresh_token(email, oob_code)
+            if refresh_token:
+                logger.success(f"✅ 邮箱 {email} refresh_token获取成功")
+                
+                # 如果有token_manager，立即获取access_token并创建用户
+                if token_manager:
+                    logger.info(f"🔄 正在为 {email} 获取access_token并创建用户...")
+                    access_token = token_manager.get_access_token(refresh_token)
+                    if access_token:
+                        logger.info(f"✅ 为 {email} 获取到access_token")
+                        if self.create_user_with_access_token(access_token):
+                            logger.success(f"🎉 为 {email} 创建用户成功")
+                            return email, refresh_token, "成功并已创建用户"
+                        else:
+                            logger.warning(f"⚠️ 为 {email} 创建用户失败，但refresh_token有效")
+                            return email, refresh_token, "成功，但创建用户失败"
+                    else:
+                        logger.warning(f"⚠️ 为 {email} 获取access_token失败")
+                        return email, refresh_token, "成功，但获取access_token失败"
+                else:
+                    return email, refresh_token, "成功"
+            else:
+                logger.error(f"❌ 邮箱 {email} 处理失败")
+                return email, None, "获取refresh_token失败或验证失败"
+                
+        except Exception as e:
+            logger.error(f"❌ 处理邮箱 {email} 时异常: {e}")
+            return email, None, f"处理异常: {str(e)}"
+
+    def process_single_email(self, email: str, login_url: str) -> Tuple[str, Optional[str], str]:
+        """处理单个email，返回(email, refresh_token, status)"""
+        logger.info(f"🚀 开始处理邮箱: {email}")
+        
+        try:
+            # 获取oob_code
+            oob_code = self.get_oob_code(login_url)
+            if not oob_code:
+                return email, None, "获取oob_code失败"
+            
+            # 获取refresh token并验证
+            refresh_token = self.get_refresh_token(email, oob_code)
+            if refresh_token:
+                logger.success(f"✅ 邮箱 {email} 处理成功")
+                return email, refresh_token, "成功"
+            else:
+                logger.error(f"❌ 邮箱 {email} 处理失败")
+                return email, None, "获取refresh_token失败或验证失败"
+                
+        except Exception as e:
+            logger.error(f"❌ 处理邮箱 {email} 时异常: {e}")
+            return email, None, f"处理异常: {str(e)}"
+
+    def batch_process_emails(self, email_url_dict: Dict[str, str], max_workers: int = 5, token_manager=None) -> Dict[str, Dict]:
+        """批量处理emails，返回结果字典"""
+        logger.info(f"🚀 开始批量处理 {len(email_url_dict)} 个邮箱，并发数: {max_workers}")
+        results = {}
+        
+        with ThreadPoolExecutor(max_workers=max_workers) as executor:
+            # 提交所有任务
+            if token_manager:
+                future_to_email = {
+                    executor.submit(self.process_single_email_with_user_creation, email, url, token_manager): email 
+                    for email, url in email_url_dict.items()
+                }
+            else:
+                future_to_email = {
+                    executor.submit(self.process_single_email, email, url): email 
+                    for email, url in email_url_dict.items()
+                }
+            
+            # 收集结果
+            for future in future_to_email:
+                email = future_to_email[future]
+                try:
+                    email, refresh_token, status = future.result()
+                    results[email] = {
+                        'refresh_token': refresh_token,
+                        'status': status
+                    }
+                    
+                    if refresh_token:
+                        logger.success(f"✅ {email}: {status}")
+                    else:
+                        logger.error(f"❌ {email}: {status}")
+                        
+                except Exception as e:
+                    logger.error(f"❌ {email}: 处理异常: {str(e)}")
+                    results[email] = {
+                        'refresh_token': None,
+                        'status': f"处理异常: {str(e)}"
+                    }
+        
+        success_count = sum(1 for result in results.values() if result['refresh_token'])
+        logger.info(f"📊 批量处理完成: {success_count}/{len(email_url_dict)} 成功")
+        
+        return results

model_mapper.py

@@ -0,0 +1,51 @@
+"""
+模型映射模块
+管理OpenAI模型名称到Warp模型名称的映射
+"""
+from typing import List
+
+
+class ModelMapper:
+    """模型名称映射管理"""
+    
+    MODEL_MAPPING = {
+        "claude-4-sonnet": "claude-4-sonnet",
+        "claude-3-7-sonnet": "claude-3-7-sonnet", 
+        "claude-3-5-sonnet": "claude-3-5-sonnet",
+        "claude-3-5-haiku": "claude-3-5-haiku",
+        "gpt-4o": "gpt-4o",
+        "gpt-4.1": "gpt-4.1",
+        "o4-mini": "o4-mini", 
+        "o3": "o3",
+        "o3-mini": "o3-mini",
+        "gemini-2.0-flash": "gemini-2.0-flash",
+        "gemini-2.5-pro": "gemini-2.5-pro"
+    }
+    
+    DEFAULT_MODEL = "gemini-2.0-flash"
+    
+    @classmethod
+    def get_warp_model(cls, openai_model: str) -> str:
+        """将OpenAI模型名转换为Warp模型名"""
+        return cls.MODEL_MAPPING.get(openai_model, cls.DEFAULT_MODEL)
+    
+    @classmethod
+    def get_available_models(cls) -> List[str]:
+        """获取所有可用模型列表"""
+        return list(cls.MODEL_MAPPING.keys())
+    
+    @classmethod
+    def is_valid_model(cls, model: str) -> bool:
+        """检查模型是否有效"""
+        return model in cls.MODEL_MAPPING
+    
+    @classmethod
+    def add_model_mapping(cls, openai_model: str, warp_model: str):
+        """添加新的模型映射"""
+        cls.MODEL_MAPPING[openai_model] = warp_model
+    
+    @classmethod
+    def remove_model_mapping(cls, openai_model: str):
+        """移除模型映射"""
+        if openai_model in cls.MODEL_MAPPING:
+            del cls.MODEL_MAPPING[openai_model] 

protobuf_manager.py

@@ -0,0 +1,317 @@
+"""
+Protobuf管理模块
+提供统一的protobuf操作接口，直接使用已编译的pb2文件
+"""
+import base64
+from typing import List, Optional, Dict, Any
+from utils import Utils, logger
+
+# 直接导入已编译的protobuf模块
+try:
+    import warp_unified_pb2
+    logger.success("✅ 成功导入已编译的protobuf模块")
+except ImportError as e:
+    logger.error(f"❌ 无法导入protobuf模块: {e}")
+    logger.error("请确保 warp_unified_pb2.py 文件存在且可访问")
+    raise
+
+
+class ProtobufManager:
+    """Protobuf操作管理器"""
+    
+    @staticmethod
+    def create_chat_request(messages: List[Dict], model: str = "gemini-2.0-flash") -> Optional[bytes]:
+        """
+        创建聊天请求的protobuf数据
+        
+        Args:
+            messages: OpenAI格式的消息列表
+            model: 模型名称
+            
+        Returns:
+            序列化的protobuf数据，如果失败返回None
+        """
+        try:
+            from request_converter import RequestConverter
+            
+            # 处理消息历史
+            merged_groups, current_message = RequestConverter.process_message_history(messages)
+            logger.debug(f"🔄 处理消息历史: {len(merged_groups)} 组历史消息, 当前消息: {current_message[:50]}...")
+            
+            # 创建主请求
+            request = warp_unified_pb2.ChatRequest()
+            session_id = Utils.generate_request_id()
+
+            # 如果只有一条消息，只设置当前消息
+            if len(messages) == 1:
+                # 字段1: 会话信息
+                request.session.session_id = session_id
+                
+                # 字段2: 系统信息
+                request.system.environment.timestamp.time = Utils.get_current_timestamp()
+                
+                # 当前请求信息
+                request.system.request.content.message.text = current_message
+                logger.debug("📝 创建单消息请求")
+            else:
+                # 有历史消息时，设置第一个消息组作为历史数据
+                if merged_groups:
+                    first_content = merged_groups[0].get("content", "")
+                    request.session.history.first_message_id = session_id
+                    request.session.history.first_message_content = first_content
+
+                    # 添加系统消息 (固定格式)
+                    entry_a = request.session.history.entries.add()
+                    entry_a.message_id = Utils.generate_request_id()
+                    entry_a.system_msg.content_id = Utils.generate_request_id()
+                    entry_a.system_msg.metadata.data = "IgIQAQ=="
+
+                    # 处理剩余的消息组
+                    for message in merged_groups:
+                        if message.get("role", "") == "user":
+                            # 添加用户消息
+                            entry_b = request.session.history.entries.add()
+                            entry_b.message_id = Utils.generate_request_id()
+                            entry_b.user_msg.content = message.get("content", "")
+                        elif message.get("role", "") == "assistant":
+                            # 添加助手消息
+                            entry_c = request.session.history.entries.add()
+                            entry_c.message_id = Utils.generate_request_id()
+                            entry_c.assistant_msg.content = message.get("content", "")
+                    
+                    logger.debug(f"📚 创建多消息请求: {len(merged_groups)} 条历史消息")
+                
+                # 字段1: 会话信息
+                request.session.session_id = session_id
+                
+                # 字段2: 系统信息
+                request.system.environment.timestamp.time = Utils.get_current_timestamp()
+                
+                # 当前请求信息
+                request.system.request.content.message.text = current_message
+            
+            # 字段3: AI配置
+            request.ai_config.model.model_name = model
+            request.ai_config.model.variant = "o3"
+            request.ai_config.model.mode = "auto"
+            request.ai_config.priority_level_1 = 1
+            request.ai_config.priority_level_2 = 1
+            request.ai_config.priority_level_3 = 1
+            request.ai_config.priority_level_4 = 1
+            request.ai_config.config_data = bytes([0x04, 0x05, 0x06, 0x07, 0x08, 0x09, 0x00, 0x02, 0x03, 0x01]).decode('utf-8')
+        
+            serialized = request.SerializeToString()
+            logger.success(f"✅ 聊天请求protobuf数据序列化成功，大小: {len(serialized)} 字节")
+            
+            return serialized
+            
+        except Exception as e:
+            logger.error(f"❌ 创建聊天请求protobuf数据时出错: {e}")
+            import traceback
+            traceback.print_exc()
+            return None
+
+    @staticmethod
+    def create_login_request(login_url: str) -> Optional[bytes]:
+        """
+        创建登录请求的protobuf数据
+        
+        Args:
+            login_url: 登录URL
+            
+        Returns:
+            序列化的protobuf数据，如果失败返回None
+        """
+        try:
+            # 创建登录请求
+            request = warp_unified_pb2.LoginRequest()
+
+            # 设置请求标志
+            request.request_flags.extend([9, 18, 20, 21, 31, 35])
+            request.request_type = 2
+            
+            # 设置登录URL
+            request.login_data.url = login_url
+            
+            # 设置配置标志
+            request.config_flags.extend([3, 2])
+            
+            # 设置语言
+            request.language = "zh-CN"
+            
+            # 设置请求设置
+            request.settings.setting_value = 6
+            
+            # 序列化
+            serialized = request.SerializeToString()
+            logger.debug(f"🔄 登录请求protobuf序列化成功，数据长度: {len(serialized)} 字节")
+            return serialized
+            
+        except Exception as e:
+            logger.error(f"❌ 创建登录请求protobuf数据时出错: {e}")
+            return None
+
+    @staticmethod
+    def parse_chat_response(base64_data: str) -> str:
+        """
+        解析聊天响应的protobuf数据
+        
+        Args:
+            base64_data: base64编码的响应数据
+            
+        Returns:
+            解析后的文本内容
+        """
+        try:
+            response = warp_unified_pb2.ChatResponse()
+            b64_data = base64.urlsafe_b64decode(base64_data)
+            response.ParseFromString(b64_data)
+            
+            # 尝试从主要响应中获取文本
+            if hasattr(response.metadata.content, 'primary') and response.metadata.content.primary.text.content.text:
+                text = response.metadata.content.primary.text.content.text
+                logger.debug(f"📥 解析主响应文本: {len(text)} 字符")
+                return text
+            
+            # 尝试从备用响应中获取文本
+            if hasattr(response.metadata.content, 'secondary') and response.metadata.content.secondary.alternative.final_content.text:
+                text = response.metadata.content.secondary.alternative.final_content.text
+                logger.debug(f"📥 解析备用响应文本: {len(text)} 字符")
+                return text
+                
+            logger.debug("⚠️ 响应中未找到文本内容")
+            return ""
+            
+        except Exception as e:
+            logger.error(f"❌ 解析聊天响应protobuf数据时出错: {e}")
+            return ""
+
+    @staticmethod
+    def parse_login_response(response_content: bytes) -> str:
+        """
+        解析登录响应的protobuf数据
+        
+        Args:
+            response_content: 响应的二进制内容
+            
+        Returns:
+            解析后的登录URL
+        """
+        try:
+            import urllib.parse
+            
+            parsed_data = warp_unified_pb2.LoginRequest()
+            parsed_data.ParseFromString(response_content)
+            
+            # 提取嵌套的URL
+            parsed_data_url = parsed_data.url_chain.container_2.container_3.container_4.container_5.container_6.url_container.final_url.login_url
+            logger.info(f"🔄 解析后的URL: {parsed_data_url}")
+            
+            decoded_url = urllib.parse.unquote(parsed_data_url)
+            logger.info(f"🔄 解码后的URL: {decoded_url}")
+            
+            return decoded_url
+            
+        except Exception as e:
+            logger.error(f"❌ 解析登录响应protobuf数据时出错: {e}")
+            return ""
+
+    @staticmethod
+    def get_protobuf_classes() -> Dict[str, Any]:
+        """
+        获取所有可用的protobuf类
+        
+        Returns:
+            包含所有protobuf类的字典
+        """
+        return {
+            'ChatRequest': warp_unified_pb2.ChatRequest,
+            'ChatResponse': warp_unified_pb2.ChatResponse,
+            'LoginRequest': warp_unified_pb2.LoginRequest,
+            'SessionInfo': warp_unified_pb2.SessionInfo,
+            'MessageHistory': warp_unified_pb2.MessageHistory,
+            'MessageEntry': warp_unified_pb2.MessageEntry,
+            'SystemInfo': warp_unified_pb2.SystemInfo,
+            'AIConfig': warp_unified_pb2.AIConfig,
+            'ModelConfig': warp_unified_pb2.ModelConfig,
+            'LoginData': warp_unified_pb2.LoginData,
+            'RequestSettings': warp_unified_pb2.RequestSettings,
+        }
+
+    @staticmethod
+    def create_empty_request(request_type: str) -> Optional[Any]:
+        """
+        创建空的protobuf请求对象
+        
+        Args:
+            request_type: 请求类型 ('chat' 或 'login')
+            
+        Returns:
+            对应的protobuf请求对象
+        """
+        try:
+            if request_type.lower() == 'chat':
+                return warp_unified_pb2.ChatRequest()
+            elif request_type.lower() == 'login':
+                return warp_unified_pb2.LoginRequest()
+            else:
+                logger.error(f"❌ 不支持的请求类型: {request_type}")
+                return None
+        except Exception as e:
+            logger.error(f"❌ 创建空请求对象时出错: {e}")
+            return None
+
+    @staticmethod
+    def validate_protobuf_module() -> bool:
+        """
+        验证protobuf模块是否正确加载
+        
+        Returns:
+            如果模块正确加载返回True，否则返回False
+        """
+        try:
+            # 测试创建基本对象
+            chat_request = warp_unified_pb2.ChatRequest()
+            login_request = warp_unified_pb2.LoginRequest()
+            
+            # 测试基本序列化
+            chat_request.session.session_id = "test"
+            serialized = chat_request.SerializeToString()
+            
+            if len(serialized) > 0:
+                logger.success("✅ Protobuf模块验证通过")
+                return True
+            else:
+                logger.error("❌ Protobuf模块验证失败：序列化结果为空")
+                return False
+                
+        except Exception as e:
+            logger.error(f"❌ Protobuf模块验证失败: {e}")
+            return False
+
+
+# 模块级别的便捷函数
+def create_chat_protobuf(messages: List[Dict], model: str = "gemini-2.0-flash") -> Optional[bytes]:
+    """便捷函数：创建聊天请求protobuf数据"""
+    return ProtobufManager.create_chat_request(messages, model)
+
+
+def create_login_protobuf(login_url: str) -> Optional[bytes]:
+    """便捷函数：创建登录请求protobuf数据"""
+    return ProtobufManager.create_login_request(login_url)
+
+
+def parse_chat_protobuf(base64_data: str) -> str:
+    """便捷函数：解析聊天响应protobuf数据"""
+    return ProtobufManager.parse_chat_response(base64_data)
+
+
+def parse_login_protobuf(response_content: bytes) -> str:
+    """便捷函数：解析登录响应protobuf数据"""
+    return ProtobufManager.parse_login_response(response_content)
+
+
+# 在模块加载时验证protobuf模块
+if __name__ != "__main__":
+    if not ProtobufManager.validate_protobuf_module():
+        logger.warning("⚠️ Protobuf模块验证失败，某些功能可能不可用") 

request_converter.py

@@ -0,0 +1,185 @@
+"""
+请求转换器模块
+处理OpenAI格式和Warp格式之间的转换
+"""
+from typing import List, Dict, Any, Optional, Tuple
+from dataclasses import dataclass
+
+from utils import Utils
+
+
+@dataclass
+class OpenAIMessage:
+    """OpenAI消息格式"""
+    role: str
+    content: str
+
+
+@dataclass 
+class OpenAIRequest:
+    """OpenAI请求格式"""
+    model: str
+    messages: List[OpenAIMessage]
+    stream: bool = False
+    temperature: float = 1.0
+    max_tokens: Optional[int] = None
+
+
+@dataclass
+class OpenAIChoice:
+    """OpenAI响应选择"""
+    index: int
+    message: Optional[OpenAIMessage] = None
+    delta: Optional[Dict[str, Any]] = None
+    finish_reason: Optional[str] = None
+
+
+@dataclass
+class OpenAIResponse:
+    """OpenAI响应格式"""
+    id: str
+    object: str
+    created: int
+    model: str
+    choices: List[OpenAIChoice]
+    usage: Optional[Dict[str, int]] = None
+
+
+class RequestConverter:
+    """OpenAI请求到Warp请求的转换器"""
+    
+    @staticmethod
+    def parse_openai_request(request_data: dict) -> OpenAIRequest:
+        """解析OpenAI请求格式"""
+        messages = []
+        for msg in request_data.get("messages", []):
+            content = msg.get("content", "")
+            
+            # 处理可能的列表格式内容
+            if isinstance(content, list):
+                text_content = ""
+                for item in content:
+                    if isinstance(item, dict) and item.get("type") == "text":
+                        text_content += item.get("text", "")
+                content = text_content
+            
+            messages.append(OpenAIMessage(
+                role=msg.get("role", "user"),
+                content=str(content)
+            ))
+        
+        return OpenAIRequest(
+            model=request_data.get("model", "gemini-2.0-flash"),
+            messages=messages,
+            stream=request_data.get("stream", False),
+            temperature=request_data.get("temperature", 1.0),
+            max_tokens=request_data.get("max_tokens")
+        )
+    
+    @staticmethod 
+    def process_message_history(messages: List[Dict]) -> Tuple[List[Dict], str]:
+        """处理消息历史，返回(合并后的消息组列表, 当前消息)"""
+        if not messages:
+            return [], "Hello"
+        
+        # 确保最后一句话是user  
+        if messages[-1].role != "user":
+            raise ValueError("最后一句话必须是user消息")
+
+        # 当前消息（最后一句）
+        current_message = messages[-1].content
+
+        if len(messages) == 1:
+            return [], current_message
+
+        # 处理除最后一句之外的所有消息，合并连续相同的role
+        merged_groups = []
+        i = 0
+        
+        while i < len(messages) - 1:  # 排除最后一句
+            current_role = messages[i].role
+            
+            # 如果是system，转换为user
+            if current_role == "system":
+                current_role = "user"
+            
+            # 收集当前内容
+            current_content = messages[i].content
+            
+            # 合并连续相同的role
+            j = i + 1
+            while j < len(messages) - 1:  # 排除最后一句
+                next_role = messages[j].role
+                if next_role == "system":
+                    next_role = "user"
+                
+                if next_role == current_role:
+                    # 合并内容
+                    current_content += "\n" + messages[j].content
+                    j += 1
+                else:
+                    break
+            
+            # 添加合并后的消息组
+            merged_groups.append({"role": current_role, "content": current_content})
+            i = j
+        
+        return merged_groups, current_message
+    
+    @staticmethod
+    def create_openai_response(content: str, model: str, request_id: str, 
+                             is_stream: bool = False, finish_reason: str = None) -> dict:
+        """创建OpenAI格式的响应"""
+        if is_stream:
+            choice = {
+                "index": 0,
+                "delta": {"content": content} if content else {},
+                "finish_reason": finish_reason
+            }
+            
+            return {
+                "id": request_id,
+                "object": "chat.completion.chunk",
+                "created": Utils.get_current_timestamp(),
+                "model": model,
+                "choices": [choice]
+            }
+        else:
+            choice = {
+                "index": 0,
+                "message": {
+                    "role": "assistant",
+                    "content": content
+                },
+                "finish_reason": "stop"
+            }
+            
+            return {
+                "id": request_id,
+                "object": "chat.completion",
+                "created": Utils.get_current_timestamp(),
+                "model": model,
+                "choices": [choice],
+                "usage": {
+                    "prompt_tokens": 100,
+                    "completion_tokens": len(content.split()) if content else 0,
+                    "total_tokens": 100 + (len(content.split()) if content else 0)
+                }
+            }
+    
+    @staticmethod
+    def create_error_response(error_message: str, model: str, request_id: str = None) -> dict:
+        """创建错误响应"""
+        if not request_id:
+            request_id = Utils.generate_request_id()
+            
+        return {
+            "id": request_id,
+            "object": "error",
+            "created": Utils.get_current_timestamp(),
+            "model": model,
+            "error": {
+                "message": error_message,
+                "type": "invalid_request_error"
+            }
+        } 

token_manager.py

@@ -0,0 +1,344 @@
+"""
+多Token管理器模块
+支持多个refresh token的管理、负载均衡和自动刷新
+"""
+import time
+import threading
+import requests
+from typing import List, Optional, Dict, Any
+from dataclasses import dataclass
+from collections import defaultdict
+from concurrent.futures import ThreadPoolExecutor, as_completed
+from loguru import logger
+
+from config import Config
+from utils import Utils
+
+
+@dataclass
+class TokenInfo:
+    """Token信息数据类"""
+    refresh_token: str
+    token_id: str  # token标识符
+    access_token: Optional[str] = None
+    last_refresh_time: Optional[float] = None
+    refresh_count: int = 0
+    error_count: int = 0
+    is_active: bool = True
+    
+
+class MultiTokenManager:
+    """多Token管理器，支持负载均衡和自动刷新"""
+    
+    def __init__(self):
+        # Token存储
+        self.tokens: Dict[str, TokenInfo] = {}
+        self.token_lock = threading.RLock()
+        
+        # 负载均衡相关
+        self.current_index = 0
+        self.usage_count = defaultdict(int)
+        
+        # 自动刷新相关
+        self.refresh_timer = None
+        self.refresh_executor = ThreadPoolExecutor(max_workers=5, thread_name_prefix="token-refresh")
+        self.session = requests.Session()
+        
+        # 初始化
+        self._initialize_tokens()
+    
+    def _initialize_tokens(self):
+        """初始化token列表"""
+        # 从环境变量获取refresh token列表（支持分号分割）
+        env_tokens = Config.get_refresh_tokens()
+        
+        if env_tokens:
+            # 过滤有效的token
+            valid_tokens = [token for token in env_tokens if Utils.validate_refresh_token_format(token)]
+            
+            if valid_tokens:
+                self.add_refresh_tokens(valid_tokens)
+                logger.info(f"✅ 从环境变量初始化了 {len(valid_tokens)} 个有效token")
+                
+                if len(env_tokens) > len(valid_tokens):
+                    invalid_count = len(env_tokens) - len(valid_tokens)
+                    logger.warning(f"⚠️ 跳过了 {invalid_count} 个格式无效的token")
+            else:
+                logger.warning("⚠️ 环境变量中的所有token格式都无效")
+        else:
+            logger.warning("⚠️ 未找到有效的refresh token，请通过环境变量 WARP_REFRESH_TOKEN 设置或在管理界面添加")
+            logger.info("💡 环境变量支持多个token，使用分号(;)分割：token1;token2;token3")
+    
+    def add_refresh_token(self, refresh_token: str) -> bool:
+        """添加单个refresh token"""
+        return self.add_refresh_tokens([refresh_token])
+    
+    def add_refresh_tokens(self, refresh_tokens: List[str]) -> bool:
+        """添加多个refresh token"""
+        with self.token_lock:
+            added_count = 0
+            
+            for token in refresh_tokens:
+                if not Utils.validate_refresh_token_format(token):
+                    logger.warning(f"⚠️ Token格式无效: {token[:20]}...")
+                    continue
+                
+                if token in self.tokens:
+                    logger.info(f"⚠️ Token已存在，跳过: {self.tokens[token].token_id}")
+                    continue
+                
+                token_id = Utils.generate_token_id(token)
+                self.tokens[token] = TokenInfo(
+                    refresh_token=token,
+                    token_id=token_id
+                )
+                added_count += 1
+                logger.info(f"✅ 添加新token: {token_id}")
+            
+            logger.info(f"📊 成功添加 {added_count} 个新token，当前总数: {len(self.tokens)}")
+            return added_count > 0
+    
+    def remove_refresh_token(self, refresh_token: str) -> bool:
+        """移除refresh token"""
+        with self.token_lock:
+            if refresh_token in self.tokens:
+                token_id = self.tokens[refresh_token].token_id
+                del self.tokens[refresh_token]
+                logger.info(f"🗑️ 移除token: {token_id}")
+                return True
+            return False
+    
+    def get_refresh_token_from_env(self, refresh_token: str) -> bool:
+        """检查token是否来自环境变量"""
+        env_tokens = Config.get_refresh_tokens()
+        return refresh_token in env_tokens
+    
+    def remove_duplicate_tokens(self, new_tokens: List[str]) -> List[str]:
+        """移除重复的token，优先保留环境变量中的token"""
+        with self.token_lock:
+            unique_tokens = []
+            
+            for token in new_tokens:
+                # 检查是否与现有token重复
+                if token in self.tokens:
+                    # 如果现有token来自环境变量，跳过新token
+                    if self.get_refresh_token_from_env(token):
+                        logger.info(f"⚠️ 跳过重复token（环境变量优先）: {self.tokens[token].token_id}")
+                        continue
+                    else:
+                        # 如果新token优先级更高，移除旧token
+                        self.remove_refresh_token(token)
+                
+                unique_tokens.append(token)
+            
+            return unique_tokens
+    
+    def get_access_token(self, refresh_token: str) -> Optional[str]:
+        """通过refresh token获取新的access token"""
+        token_id = self.tokens.get(refresh_token, TokenInfo("", "")).token_id
+        
+        try:
+            headers = {
+                'Accept-Encoding': 'gzip, br',
+                'Content-Type': 'application/x-www-form-urlencoded',
+                'x-warp-client-version': Config.WARP_CLIENT_VERSION,
+                'x-warp-os-category': Config.WARP_OS_CATEGORY,
+                'x-warp-os-name': Config.WARP_OS_NAME,
+                'x-warp-os-version': Config.WARP_OS_VERSION
+            }
+            
+            data = {
+                'grant_type': 'refresh_token',
+                'refresh_token': refresh_token
+            }
+            
+            logger.debug(f"🔄 正在刷新access token: {token_id}")
+            
+            response = self.session.post(
+                Config.GOOGLE_TOKEN_URL,
+                headers=headers,
+                data=data,
+                timeout=30
+            )
+            
+            if response.status_code == 200:
+                token_data = response.json()
+                access_token = token_data.get('access_token')
+                if access_token:
+                    logger.success(f"✅ Access token获取成功: {token_id}")
+                    return access_token
+                else:
+                    logger.error(f"❌ 响应中未找到access_token字段: {token_id}")
+            else:
+                logger.error(f"❌ 获取token失败，状态码 {response.status_code}: {token_id}")
+                
+        except Exception as e:
+            logger.error(f"❌ 获取access token时出错: {token_id} - {e}")
+        
+        return None
+    
+    def refresh_single_token(self, refresh_token: str) -> bool:
+        """刷新单个token"""
+        with self.token_lock:
+            if refresh_token not in self.tokens:
+                return False
+            
+            token_info = self.tokens[refresh_token]
+        
+        try:
+            access_token = self.get_access_token(refresh_token)
+            
+            with self.token_lock:
+                if access_token:
+                    token_info.access_token = access_token
+                    token_info.last_refresh_time = time.time()
+                    token_info.refresh_count += 1
+                    token_info.error_count = 0  # 重置错误计数
+                    token_info.is_active = True
+                    
+                    logger.success(f"🔄 Token刷新成功: {token_info.token_id} (第{token_info.refresh_count}次)")
+                    return True
+                else:
+                    token_info.error_count += 1
+                    if token_info.error_count >= 3:
+                        token_info.is_active = False
+                        logger.warning(f"⚠️ Token连续失败3次，标记为不可用: {token_info.token_id}")
+                    
+                    return False
+                    
+        except Exception as e:
+            with self.token_lock:
+                token_info.error_count += 1
+                
+            logger.error(f"❌ 刷新token时出错: {token_info.token_id} - {e}")
+            return False
+    
+    def refresh_all_tokens(self):
+        """并发刷新所有token"""
+        with self.token_lock:
+            refresh_tokens = list(self.tokens.keys())
+        
+        if not refresh_tokens:
+            logger.warning("⚠️ 没有可刷新的token")
+            return
+        
+        logger.info(f"🔄 开始并发刷新 {len(refresh_tokens)} 个token")
+        
+        # 使用线程池并发刷新
+        futures = {
+            self.refresh_executor.submit(self.refresh_single_token, token): token 
+            for token in refresh_tokens
+        }
+        
+        success_count = 0
+        for future in as_completed(futures):
+            token = futures[future]
+            try:
+                success = future.result(timeout=30)
+                if success:
+                    success_count += 1
+            except Exception as e:
+                token_id = self.tokens.get(token, TokenInfo("", "")).token_id
+                logger.error(f"❌ 刷新token时出错: {token_id} - {e}")
+        
+        logger.info(f"📊 Token刷新完成: {success_count}/{len(refresh_tokens)} 成功")
+    
+    def get_current_access_token(self) -> Optional[str]:
+        """获取当前可用的access token（负��均衡）"""
+        with self.token_lock:
+            # 获取所有活跃token
+            active_tokens = [
+                (token, info) for token, info in self.tokens.items() 
+                if info.is_active and info.access_token
+            ]
+            
+            if not active_tokens:
+                logger.warning("⚠️ 没有可用的access token！")
+                logger.warning("💡 请确保：")
+                logger.warning("   1. 设置了有效的 WARP_REFRESH_TOKEN 环境变量")
+                logger.warning("   2. 或通过管理界面添加有效的 refresh token")
+                logger.warning("   3. refresh token 已成功刷新获得 access token")
+                return None
+            
+            # 简单的轮询负载均衡
+            if self.current_index >= len(active_tokens):
+                self.current_index = 0
+            
+            selected_token, token_info = active_tokens[self.current_index]
+            self.current_index = (self.current_index + 1) % len(active_tokens)
+            
+            # 更新使用计数
+            self.usage_count[selected_token] += 1
+            
+            logger.info(f"🎯 轮询选择token: {token_info.token_id} (使用次数: {self.usage_count[selected_token]})")
+            return token_info.access_token
+    
+    def get_token_status(self) -> Dict[str, Any]:
+        """获取所有token的状态信息"""
+        with self.token_lock:
+            status = {
+                'total_tokens': len(self.tokens),
+                'active_tokens': sum(1 for info in self.tokens.values() if info.is_active),
+                'tokens_with_access': sum(1 for info in self.tokens.values() if info.access_token),
+                'tokens': []
+            }
+            
+            for token, info in self.tokens.items():
+                token_status = {
+                    'refresh_token': info.token_id,  # 使用token_id而不是实际token
+                    'has_access_token': bool(info.access_token),
+                    'is_active': info.is_active,
+                    'refresh_count': info.refresh_count,
+                    'error_count': info.error_count,
+                    'last_refresh_time': info.last_refresh_time,
+                    'usage_count': self.usage_count.get(token, 0)
+                }
+                status['tokens'].append(token_status)
+            
+            return status
+    
+    def start_auto_refresh(self):
+        """启动自动刷新服务"""
+        logger.info(f"🚀 启动Token自动刷新服务，间隔: {Config.TOKEN_REFRESH_INTERVAL // 60} 分钟")
+        
+        # 立即进行一次刷新
+        refresh_thread = threading.Thread(target=self._initial_refresh, daemon=True)
+        refresh_thread.start()
+    
+    def _initial_refresh(self):
+        """初始刷新（在后台线程中执行）"""
+        logger.info("🔄 正在后台执行初始token刷新...")
+        self.refresh_all_tokens()
+        self._schedule_next_refresh()
+    
+    def _schedule_next_refresh(self):
+        """安排下次刷新"""
+        if self.refresh_timer:
+            self.refresh_timer.cancel()
+        
+        self.refresh_timer = threading.Timer(
+            Config.TOKEN_REFRESH_INTERVAL,
+            self._auto_refresh_callback
+        )
+        self.refresh_timer.daemon = True
+        self.refresh_timer.start()
+        
+        # 计算下次刷新时间
+        next_refresh_time = time.time() + Config.TOKEN_REFRESH_INTERVAL
+        next_refresh_str = time.strftime('%Y-%m-%d %H:%M:%S', time.localtime(next_refresh_time))
+        logger.info(f"⏰ 下次token刷新时间: {next_refresh_str}")
+    
+    def _auto_refresh_callback(self):
+        """自动刷新回调"""
+        logger.info("🔄 开始定时自动刷新所有token...")
+        self.refresh_all_tokens()
+        self._schedule_next_refresh()
+    
+    def stop_auto_refresh(self):
+        """停止自动刷新"""
+        if self.refresh_timer:
+            self.refresh_timer.cancel()
+            self.refresh_timer = None
+        
+        self.refresh_executor.shutdown(wait=False)
+        logger.info("⏹️ Token自动刷新服务已停止")

utils.py

@@ -0,0 +1,131 @@
+"""
+工具函数模块
+包含通用的工具函数和辅助方法
+"""
+import uuid
+import time
+import logging
+from typing import Optional
+from loguru import logger
+from config import Config
+
+
+class Utils:
+    """工具函数集合"""
+    
+    @staticmethod
+    def generate_request_id() -> str:
+        """生成请求ID"""
+        return str(uuid.uuid4())
+    
+    @staticmethod
+    def generate_token_id(refresh_token: str) -> str:
+        """生成token的唯一标识符（用于日志显示）"""
+        # 使用token的前8位和后8位作为标识符
+        if len(refresh_token) >= 16:
+            return f"TOKEN_{refresh_token[:8]}...{refresh_token[-8:]}"
+        else:
+            return f"TOKEN_{refresh_token[:8]}..."
+    
+    @staticmethod
+    def get_current_timestamp() -> int:
+        """获取当前时间戳"""
+        return int(time.time())
+    
+    @staticmethod
+    def validate_api_key(api_key: str) -> bool:
+        """验证API密钥"""
+        config = Config()
+        return api_key in config.VALID_API_KEYS
+    
+    @staticmethod
+    def extract_bearer_token(auth_header: str) -> Optional[str]:
+        """从Authorization头中提取Bearer token"""
+        if not auth_header:
+            return None
+        
+        parts = auth_header.split(" ")
+        if len(parts) != 2 or parts[0].lower() != "bearer":
+            return None
+            
+        return parts[1]
+    
+    @staticmethod
+    def setup_logging():
+        """设置loguru日志配置"""
+        # 移除默认的日志处理器
+        logger.remove()
+        
+        # 添加控制台日志输出，带颜色和格式
+        logger.add(
+            sink=lambda x: print(x, end=""),
+            format="<green>{time:YYYY-MM-DD HH:mm:ss}</green> | <level>{level: <8}</level> | <cyan>{name}</cyan>:<cyan>{function}</cyan>:<cyan>{line}</cyan> - <level>{message}</level>",
+            level="INFO",
+            colorize=True
+        )
+        
+        # 根据环境变量决定是否启用文件日志
+        if Config.enable_file_logging():
+            logger.add(
+                "warp_api_server.log",
+                rotation="10 MB",
+                retention="7 days",
+                level="DEBUG",
+                format="{time:YYYY-MM-DD HH:mm:ss} | {level: <8} | {name}:{function}:{line} - {message}",
+                encoding="utf-8"
+            )
+            logger.info("📝 文件日志已启用: warp_api_server.log")
+        else:
+            logger.info("📝 文件日志已禁用 (可通过环境变量 ENABLE_FILE_LOGGING=true 启用)")
+        
+        # 配置标准logging的loguru处理器
+        class InterceptHandler(logging.Handler):
+            def emit(self, record):
+                # 获取对应的loguru级别
+                try:
+                    level = logger.level(record.levelname).name
+                except ValueError:
+                    level = record.levelno
+                
+                # 查找调用者位置
+                frame, depth = logging.currentframe(), 2
+                while frame.f_code.co_filename == logging.__file__:
+                    frame = frame.f_back
+                    depth += 1
+                
+                logger.opt(depth=depth, exception=record.exc_info).log(
+                    level, record.getMessage()
+                )
+        
+        # 替换所有标准logging处理器
+        logging.basicConfig(handlers=[InterceptHandler()], level=0, force=True)
+        logging.getLogger("urllib3").setLevel(logging.WARNING)
+        
+        logger.info("🚀 Loguru日志系统初始化完成")
+    
+    @staticmethod
+    def deduplicate_tokens(tokens: list) -> list:
+        """去重token列表，保持顺序"""
+        seen = set()
+        result = []
+        for token in tokens:
+            if token and token not in seen:
+                seen.add(token)
+                result.append(token)
+        return result
+    
+    @staticmethod
+    def validate_refresh_token_format(token: str) -> bool:
+        """验证refresh token格式是否有效"""
+        if not token or not isinstance(token, str):
+            return False
+        
+        # 基本长度检查
+        if len(token) < 100:
+            return False
+            
+        # 检查是否包含必要的字符
+        if not any(c.isalnum() for c in token):
+            return False
+            
+        return True 

warp_api_server.py

@@ -0,0 +1,341 @@
+#!/usr/bin/env python3
+"""
+Warp API 服务器
+整合所有模块，提供OpenAI兼容的API接口和Token管理Web界面
+"""
+import json
+import threading
+from flask import Flask, request, jsonify, Response, stream_with_context, render_template_string, session, redirect, url_for
+from loguru import logger
+
+from config import Config
+from utils import Utils
+from api_service import ApiService
+
+# 初始化日志
+Utils.setup_logging()
+
+# 创建Flask应用
+app = Flask(__name__)
+app.secret_key = 'warp-api-server-secret-key-2024'  # 用于session管理
+
+# 创建API服务
+api_service = ApiService()
+
+def check_admin_auth():
+    """检查管理员认证"""
+    if not Config.require_admin_auth():
+        return True
+    
+    # 检查session中的管理员认证状态
+    return session.get('admin_authenticated', False)
+
+def verify_admin_key(admin_key: str) -> bool:
+    """验证管理员密钥"""
+    if not Config.require_admin_auth():
+        return True
+    
+    return admin_key == Config.get_admin_key()
+
+@app.before_request
+def check_auth():
+    """请求前鉴权检查"""
+    # 跳过管理员认证的端点
+    admin_auth_endpoints = ['admin_login', 'admin_auth']
+    if request.endpoint in admin_auth_endpoints:
+        return
+    
+    # 管理界面相关端点需要管理员认证
+    admin_endpoints = ['index', 'token_status', 'add_tokens', 'batch_login', 'refresh_tokens', 'remove_tokens', 'export_tokens']
+    if request.endpoint in admin_endpoints:
+        if not check_admin_auth():
+            if request.endpoint == 'index':
+                return redirect(url_for('admin_login'))
+            else:
+                return jsonify({"error": "需要管理员认证"}), 401
+    
+    # API端点需要API密钥认证
+    api_endpoints = ['get_models', 'chat_completions']
+    if request.endpoint in api_endpoints:
+        auth_header = request.headers.get('Authorization')
+        if not api_service.authenticate_request(auth_header):
+            return jsonify({"error": "未授权访问"}), 401
+
+@app.route('/admin/login')
+def admin_login():
+    """管理员登录页面"""
+    if not Config.require_admin_auth():
+        return redirect(url_for('index'))
+    
+    if check_admin_auth():
+        return redirect(url_for('index'))
+    
+    from web_template import get_admin_login_template
+    return render_template_string(get_admin_login_template())
+
+@app.route('/admin/auth', methods=['POST'])
+def admin_auth():
+    """管理员认证处理"""
+    if not Config.require_admin_auth():
+        return jsonify({"success": True, "redirect": "/"})
+    
+    try:
+        data = request.get_json()
+        admin_key = data.get('admin_key', '')
+        
+        if verify_admin_key(admin_key):
+            session['admin_authenticated'] = True
+            logger.info("🔐 管理员认证成功")
+            return jsonify({"success": True, "message": "认证成功", "redirect": "/"})
+        else:
+            logger.warning("⚠️ 管理员认证失败")
+            return jsonify({"success": False, "message": "管理员密钥错误"})
+            
+    except Exception as e:
+        logger.error(f"❌ 管理员认证出错: {e}")
+        return jsonify({"success": False, "message": "认证失败"}), 500
+
+@app.route('/admin/logout', methods=['POST'])
+def admin_logout():
+    """管理员登出"""
+    session.pop('admin_authenticated', None)
+    return jsonify({"success": True, "message": "已登出"})
+
+@app.route('/')
+def index():
+    """管理页面"""
+    from web_template import get_html_template
+    return render_template_string(get_html_template())
+
+@app.route(f"/{Config.OPENAI_API_VERSION}/models", methods=['GET'])
+def get_models():
+    """获取模型列表"""
+    return jsonify(api_service.get_models())
+
+@app.route(f"/{Config.OPENAI_API_VERSION}/chat/completions", methods=['POST'])
+def chat_completions():
+    """聊天完成端点"""
+    try:
+        request_data = request.get_json()
+        if not request_data:
+            return jsonify({"error": "无效的请求数据"}), 400
+        
+        # 检查模型是否有效
+        model = request_data.get("model")
+        from model_mapper import ModelMapper
+        if not ModelMapper.is_valid_model(model):
+            return jsonify({"error": f"不支持的模型: {model}"}), 400
+        
+        stream = request_data.get("stream", False)
+        
+        if stream:
+            # 流式响应
+            def generate():
+                for chunk in api_service.chat_completion(request_data, stream=True):
+                    yield chunk
+            
+            return Response(
+                stream_with_context(generate()),
+                content_type='text/event-stream',
+                headers={
+                    'Cache-Control': 'no-cache',
+                    'Connection': 'keep-alive',
+                    'Access-Control-Allow-Origin': '*'
+                }
+            )
+        else:
+            # 非流式响应
+            response_text = ""
+            for chunk in api_service.chat_completion(request_data, stream=False):
+                response_text = chunk
+                break
+            
+            return Response(
+                json.dumps(response_text) if isinstance(response_text, dict) else response_text,
+                content_type='application/json'
+            )
+    
+    except Exception as e:
+        logger.error(f"❌ 处理聊天请求时出错: {e}")
+        return jsonify({"error": f"服务器内部错误: {str(e)}"}), 500
+
+@app.route('/token/status', methods=['GET'])
+def token_status():
+    """获取token状态"""
+    try:
+        status = api_service.get_token_status()
+        return jsonify(status)
+    except Exception as e:
+        return jsonify({"success": False, "message": str(e)}), 500
+
+@app.route('/token/add', methods=['POST'])
+def add_tokens():
+    """添加token"""
+    try:
+        data = request.get_json()
+        tokens = data.get('tokens', [])
+        
+        result = api_service.add_tokens(tokens)
+        return jsonify(result)
+        
+    except Exception as e:
+        return jsonify({"success": False, "message": str(e)}), 500
+
+@app.route('/token/remove', methods=['POST'])
+def remove_tokens():
+    """删除token"""
+    try:
+        data = request.get_json()
+        refresh_token = data.get('refresh_token')
+        
+        result = api_service.remove_refresh_token(refresh_token=refresh_token)
+        return jsonify(result)
+        
+    except Exception as e:
+        return jsonify({"success": False, "message": str(e)}), 500
+
+@app.route('/token/refresh', methods=['POST'])
+def refresh_tokens():
+    """刷新所有token"""
+    try:
+        result = api_service.refresh_all_tokens()
+        return jsonify(result)
+    except Exception as e:
+        return jsonify({"success": False, "message": str(e)}), 500
+
+@app.route('/token/export', methods=['POST'])
+def export_tokens():
+    """导出refresh token（需要超级管理员密钥验证）"""
+    try:
+        data = request.get_json()
+        super_admin_key = data.get('super_admin_key', '')
+        
+        result = api_service.export_refresh_tokens(super_admin_key)
+        return jsonify(result)
+        
+    except Exception as e:
+        logger.error(f"❌ 导出token时出错: {e}")
+        return jsonify({"success": False, "message": str(e)}), 500
+
+@app.route('/login/batch', methods=['POST'])
+def batch_login():
+    """批量获取refresh token"""
+    try:
+        data = request.get_json()
+        email_url_pairs = data.get('email_url_pairs', [])
+        max_workers = data.get('max_workers', 5)
+        
+        # 转换为字典格式
+        email_url_dict = {}
+        for pair in email_url_pairs:
+            email = pair.get('email', '').strip()
+            url = pair.get('url', '').strip()
+            
+            if email and url:
+                email_url_dict[email] = url
+        
+        if not email_url_dict:
+            return jsonify({'success': False, 'message': '没有有效的邮箱和URL对'}), 400
+        
+        result = api_service.batch_get_refresh_tokens(email_url_dict, max_workers)
+        return jsonify(result)
+        
+    except Exception as e:
+        logger.error(f"❌ 批量登录时出错: {e}")
+        return jsonify({'success': False, 'message': f'服务器错误: {str(e)}'}), 500
+
+@app.route('/health', methods=['GET'])
+def health_check():
+    """健康检查端点"""
+    return jsonify({
+        "status": "healthy", 
+        "timestamp": Utils.get_current_timestamp(),
+        "version": "2.0.0"
+    })
+
+def compile_protobuf_at_startup():
+    """启动时编译protobuf"""
+    logger.info("🔧 开始编译Protobuf文件...")
+    try:
+        from protobuf_manager import ProtobufManager
+        success = ProtobufManager.validate_protobuf_module()
+        if success:
+            logger.success("✅ Protobuf模块验证成功")
+        else:
+            logger.warning("⚠️ Protobuf模块验证失败，但服务仍将启动")
+    except Exception as e:
+        logger.error(f"❌ 编译Protobuf时出错: {e}")
+
+def main():
+    """主函数"""
+    config = Config()
+    
+    print("=" * 80)
+    print("🚀 启动 Warp API 服务器 v2.0")
+    print("=" * 80)
+    print(f"📡 服务器地址: http://localhost:{Config.SERVER_PORT}")
+    print(f"🔧 管理界面: http://localhost:{Config.SERVER_PORT}")
+    print(f"📚 模型端点: http://localhost:{Config.SERVER_PORT}/{Config.OPENAI_API_VERSION}/models")
+    print(f"💬 聊天端点: http://localhost:{Config.SERVER_PORT}/{Config.OPENAI_API_VERSION}/chat/completions")
+    print(f"❤️  健康检查: http://localhost:{Config.SERVER_PORT}/health")
+    print(f"📝 文件日志: {'启��' if Config.enable_file_logging() else '禁用'}")
+    
+    # 显示安全配置信息
+    if Config.require_admin_auth():
+        print(f"🔐 管理员认证: 已启用 (需要 ADMIN_KEY)")
+    else:
+        print("⚠️  管理员认证: 未启用 (可通过 ADMIN_KEY 环境变量启用)")
+    
+    if Config.require_super_admin_auth():
+        print(f"🔒 超级管理员认证: 已启用 (导出功能需要 SUPER_ADMIN_KEY)")
+    else:
+        print("⚠️  超级管理员认证: 未启用 (可通过 SUPER_ADMIN_KEY 环境变量启用)")
+    
+    # 显示环境变量token信息
+    env_tokens = Config.get_refresh_tokens()
+    if env_tokens:
+        print(f"🎯 环境变量Token: 已设置 {len(env_tokens)} 个")
+        for i, token in enumerate(env_tokens, 1):
+            print(f"   #{i}: {token[:20]}...{token[-8:] if len(token) > 28 else ''}")
+    else:
+        print("⚠️  环境变量Token: 未设置 (请设置 WARP_REFRESH_TOKEN)")
+        print("💡 支持多个token，使用分号(;)分割：token1;token2;token3")
+    
+    print("-" * 80)
+    
+    try:
+        # 编译protobuf
+        compile_protobuf_at_startup()
+        
+        # 启动后台服务
+        logger.info("🔄 启动后台服务...")
+        api_service.start_services()
+        logger.success("✅ 后台服务启动完成")
+        
+        logger.info("-" * 80)
+        logger.success("🌟 服务器启动完成！")
+        if Config.require_admin_auth():
+            logger.info(f"🔐 访问管理界面需要管理员密钥: http://localhost:{Config.SERVER_PORT}")
+        else:
+            logger.info(f"🌐 访问管理界面: http://localhost:{Config.SERVER_PORT}")
+        logger.info("-" * 80)
+        
+        # 启动Flask服务器
+        app.run(
+            host=Config.SERVER_HOST,
+            port=Config.SERVER_PORT,
+            debug=False,
+            threaded=True
+        )
+        
+    except KeyboardInterrupt:
+        logger.info("🛑 接收到停止信号")
+    except Exception as e:
+        logger.error(f"❌ 服务器启动失败: {e}")
+    finally:
+        logger.info("🧹 清理资源...")
+        api_service.stop_services()
+        logger.info("👋 服务器已停止")
+
+if __name__ == "__main__":
+    main()

warp_client.py

@@ -0,0 +1,192 @@
+"""
+Warp客户端模块
+处理与Warp API的通信，包括protobuf数据处理和HTTP请求
+"""
+import requests
+import json
+from typing import Generator, List, Optional
+from loguru import logger
+
+from config import Config
+from request_converter import OpenAIMessage
+from utils import Utils
+from protobuf_manager import ProtobufManager
+
+
+class WarpClient:
+    """Warp API客户端"""
+    
+    def __init__(self, token_manager=None):
+        self.token_manager = token_manager
+        self.session = requests.Session()
+    
+    def get_auth_token(self) -> Optional[str]:
+        """获取当前认证token"""
+        if self.token_manager:
+            token = self.token_manager.get_current_access_token()
+            if token:
+                return token
+            else:
+                logger.error("❌ 无法获取有效的认证token")
+                return None
+        else:
+            logger.error("❌ Token管理器未初始化")
+            return None
+    
+
+
+    def create_protobuf_data(self, messages: List[OpenAIMessage], model: str = "gemini-2.0-flash") -> Optional[bytes]:
+        """创建protobuf数据"""
+        return ProtobufManager.create_chat_request(messages, model)
+
+    def parse_protobuf_response(self, base64_data: str) -> str:
+        """解析protobuf响应数据"""
+        return ProtobufManager.parse_chat_response(base64_data)
+
+    def _check_and_handle_401_error(self, response_text: str, current_access_token: str = None, current_refresh_token: str = None) -> bool:
+        """检查并处理401错误，返回True表示需要重试"""
+        try:
+            # 尝试解析响应为JSON
+            error_data = json.loads(response_text)
+            error_message = error_data.get("error", "")
+            
+            # 检查是否是目标错误消息
+            if "Unauthorized: User not in context: Not found: no rows in result set" in error_message:
+                logger.warning("⚠️ 检测到用户未创建错误，尝试用当前token创建用户")
+                
+                if self.token_manager and current_access_token:
+                    # 使用当前的access_token尝试创建用户
+                    logger.info(f"🔄 使用当前access_token创建用户: {current_access_token[:20]}...")
+                    
+                    # 尝试创建用户
+                    from login_client import LoginClient
+                    login_client = LoginClient()
+                    
+                    if login_client.create_user_with_access_token(current_access_token):
+                        logger.success("✅ 用户创建成功，可以重试请求")
+                        return True
+                    else:
+                        logger.error("❌ 当前token创建用户失败")
+                        # 如果用当前token创建用户失败，移除这个refresh_token
+                        if current_refresh_token:
+                            logger.info(f"🗑️ 移除创建用户失败的refresh_token")
+                            self.token_manager.remove_refresh_token(current_refresh_token)
+                        
+                        # 尝试获取下一个token
+                        logger.info("🔄 尝试获取下一个access_token...")
+                        next_token = self.token_manager.get_current_access_token()
+                        if next_token and next_token != current_access_token:
+                            logger.info(f"🔄 获取到下一个access_token: {next_token[:20]}...")
+                            return True  # 返回True表示可以用新token重试
+                        else:
+                            logger.error("❌ 无法获取下一个有效的access_token")
+                            return False
+                else:
+                    logger.error("❌ Token管理器未初始化或当前access_token为空")
+                    return False
+            
+            return False
+            
+        except (json.JSONDecodeError, KeyError, TypeError):
+            # 如果不是JSON格式或没有error字段，则不是目标错误
+            return False
+
+    def send_request(self, protobuf_data: bytes) -> Generator[str, None, None]:
+        """发送请求到Warp API并返回流式响应"""
+        url = f"{Config.WARP_BASE_URL}{Config.WARP_AI_ENDPOINT}"
+        
+        max_retries = 2  # 最多重试2次
+        retry_count = 0
+        
+        while retry_count <= max_retries:
+            # 获取认证token
+            auth_token = self.get_auth_token()
+            if not auth_token:
+                logger.error("❌ 无法获取认证token，请求终止")
+                return
+            
+            # 获取当前使用的refresh_token（用于错误时移除）
+            current_refresh_token = None
+            if self.token_manager:
+                with self.token_manager.token_lock:
+                    for refresh_token, token_info in self.token_manager.tokens.items():
+                        if token_info.access_token == auth_token:
+                            current_refresh_token = refresh_token
+                            break
+            
+            headers = {
+                'Accept': 'text/event-stream',
+                'Accept-Encoding': 'gzip, br',
+                'Content-Type': 'application/x-protobuf',
+                'x-warp-client-version': Config.WARP_CLIENT_VERSION,
+                'x-warp-os-category': Config.WARP_OS_CATEGORY,
+                'x-warp-os-name': Config.WARP_OS_NAME,
+                'x-warp-os-version': Config.WARP_OS_VERSION,
+                'authorization': f'Bearer {auth_token}'
+            }
+            
+            if retry_count > 0:
+                logger.info(f"🔄 第{retry_count}次重试请求到Warp API: {url}")
+            else:
+                logger.info(f"🌐 发送请求到Warp API: {url}")
+            
+            logger.debug(f"📦 Protobuf数据大小: {len(protobuf_data)} 字节")
+            
+            try:
+                response = self.session.post(
+                    url,
+                    headers=headers,
+                    data=protobuf_data,
+                    stream=True,
+                    timeout=Config.REQUEST_TIMEOUT,
+                    verify=False
+                )
+                
+                if response.status_code == 200:
+                    logger.success("✅ 请求成功，开始接收流式响应")
+                    chunk_count = 0
+                    
+                    for line in response.iter_lines(decode_unicode=True):
+                        if line and line.startswith('data:'):
+                            data = line[5:].strip()
+                            text = self.parse_protobuf_response(data)
+                            if text:
+                                chunk_count += 1
+                                logger.debug(f"📨 接收到响应块 #{chunk_count}: {len(text)} 字符")
+                                yield text
+                    
+                    logger.success(f"🎉 流式响应接收完成，总共 {chunk_count} 个块")
+                    return  # 成功，退出重试循环
+                    
+                elif response.status_code == 401:
+                    logger.error(f"❌ Warp API请求失败，状态码: {response.status_code}")
+                    if response.text:
+                        logger.error(f"❌ 错误详情: {response.text}")
+                        
+                        # 检查并处理特定的401错误
+                        should_retry = self._check_and_handle_401_error(response.text, auth_token, current_refresh_token)
+                        
+                        if should_retry and retry_count < max_retries:
+                            retry_count += 1
+                            logger.info(f"🔄 准备第{retry_count}次重试...")
+                            continue
+                        else:
+                            logger.error(f"❌ 401错误处理失败或已达到最大重试次数")
+                            return
+                    else:
+                        logger.error("❌ 401错误，但无响应内容")
+                        return
+                else:
+                    logger.error(f"❌ Warp API请求失败，状态码: {response.status_code}")
+                    if response.text:
+                        logger.error(f"❌ 错误详情: {response.text}")
+                    return
+                    
+            except requests.Timeout:
+                logger.error(f"❌ 请求超时 ({Config.REQUEST_TIMEOUT}秒)")
+                return
+            except Exception as e:
+                logger.error(f"❌ 发送请求时出错: {e}")
+                import traceback
+                traceback.print_exc()
+                return 

warp_unified_pb2.py

@@ -0,0 +1,108 @@
+# -*- coding: utf-8 -*-
+# Generated by the protocol buffer compiler.  DO NOT EDIT!
+# NO CHECKED-IN PROTOBUF GENCODE
+# source: warp_unified.proto
+# Protobuf Python Version: 6.31.0
+"""Generated protocol buffer code."""
+from google.protobuf import descriptor as _descriptor
+from google.protobuf import descriptor_pool as _descriptor_pool
+from google.protobuf import runtime_version as _runtime_version
+from google.protobuf import symbol_database as _symbol_database
+from google.protobuf.internal import builder as _builder
+_runtime_version.ValidateProtobufRuntimeVersion(
+    _runtime_version.Domain.PUBLIC,
+    6,
+    31,
+    0,
+    '',
+    'warp_unified.proto'
+)
+# @@protoc_insertion_point(imports)
+
+_sym_db = _symbol_database.Default()
+
+
+
+
+DESCRIPTOR = _descriptor_pool.Default().AddSerializedFile(b'\n\x12warp_unified.proto\x12\x0cwarp_unified\"\x8e\x01\n\x0b\x43hatRequest\x12*\n\x07session\x18\x01 \x01(\x0b\x32\x19.warp_unified.SessionInfo\x12(\n\x06system\x18\x02 \x01(\x0b\x32\x18.warp_unified.SystemInfo\x12)\n\tai_config\x18\x03 \x01(\x0b\x32\x16.warp_unified.AIConfig\"P\n\x0bSessionInfo\x12-\n\x07history\x18\x01 \x01(\x0b\x32\x1c.warp_unified.MessageHistory\x12\x12\n\nsession_id\x18\x02 \x01(\t\"v\n\x0eMessageHistory\x12\x18\n\x10\x66irst_message_id\x18\x01 \x01(\t\x12\x1d\n\x15\x66irst_message_content\x18\x02 \x01(\t\x12+\n\x07\x65ntries\x18\x05 \x03(\x0b\x32\x1a.warp_unified.MessageEntry\"\xbc\x03\n\x0cMessageEntry\x12\x12\n\nmessage_id\x18\x01 \x01(\t\x12<\n\nsystem_msg\x18\x04 \x01(\x0b\x32(.warp_unified.MessageEntry.SystemMessage\x12\x38\n\x08user_msg\x18\x02 \x01(\x0b\x32&.warp_unified.MessageEntry.UserMessage\x12\x42\n\rassistant_msg\x18\x03 \x01(\x0b\x32+.warp_unified.MessageEntry.AssistantMessage\x12\x12\n\nextra_data\x18\x07 \x01(\t\x1a\x82\x01\n\rSystemMessage\x12\x12\n\ncontent_id\x18\x01 \x01(\t\x12\x43\n\x08metadata\x18\x04 \x01(\x0b\x32\x31.warp_unified.MessageEntry.SystemMessage.Metadata\x1a\x18\n\x08Metadata\x12\x0c\n\x04\x64\x61ta\x18\x01 \x01(\t\x1a\x1e\n\x0bUserMessage\x12\x0f\n\x07\x63ontent\x18\x01 \x01(\t\x1a#\n\x10\x41ssistantMessage\x12\x0f\n\x07\x63ontent\x18\x01 \x01(\t\"l\n\nSystemInfo\x12\x32\n\x0b\x65nvironment\x18\x01 \x01(\x0b\x32\x1d.warp_unified.EnvironmentInfo\x12*\n\x07request\x18\x06 \x01(\x0b\x32\x19.warp_unified.RequestInfo\"=\n\x0f\x45nvironmentInfo\x12*\n\ttimestamp\x18\x04 \x01(\x0b\x32\x17.warp_unified.TimeStamp\"\x19\n\tTimeStamp\x12\x0c\n\x04time\x18\x01 \x01(\x05\"9\n\x0bRequestInfo\x12*\n\x07\x63ontent\x18\x01 \x01(\x0b\x32\x19.warp_unified.ContentData\"<\n\x0b\x43ontentData\x12-\n\x07message\x18\x01 \x01(\x0b\x32\x1c.warp_unified.MessageContent\"\x1e\n\x0eMessageContent\x12\x0c\n\x04text\x18\x01 \x01(\t\"\xb1\x01\n\x08\x41IConfig\x12(\n\x05model\x18\x01 \x01(\x0b\x32\x19.warp_unified.ModelConfig\x12\x18\n\x10priority_level_1\x18\x02 \x01(\x05\x12\x18\n\x10priority_level_2\x18\x03 \x01(\x05\x12\x18\n\x10priority_level_3\x18\x07 \x01(\x05\x12\x18\n\x10priority_level_4\x18\x08 \x01(\x05\x12\x13\n\x0b\x63onfig_data\x18\t \x01(\t\"@\n\x0bModelConfig\x12\x12\n\nmodel_name\x18\x01 \x01(\t\x12\x0f\n\x07variant\x18\x02 \x01(\t\x12\x0c\n\x04mode\x18\x03 \x01(\t\"@\n\x0c\x43hatResponse\x12\x30\n\x08metadata\x18\x02 \x01(\x0b\x32\x1e.warp_unified.ResponseMetadata\"B\n\x10ResponseMetadata\x12.\n\x07\x63ontent\x18\x01 \x01(\x0b\x32\x1d.warp_unified.ResponseContent\"u\n\x0fResponseContent\x12.\n\x07primary\x18\x03 \x01(\x0b\x32\x1d.warp_unified.PrimaryResponse\x12\x32\n\tsecondary\x18\x05 \x01(\x0b\x32\x1f.warp_unified.SecondaryResponse\"P\n\x0fPrimaryResponse\x12\x13\n\x0bresponse_id\x18\x01 \x01(\t\x12(\n\x04text\x18\x02 \x01(\x0b\x32\x1a.warp_unified.ResponseText\"T\n\x0cResponseText\x12\x0b\n\x03id1\x18\x01 \x01(\t\x12\x0b\n\x03id2\x18\x07 \x01(\t\x12*\n\x07\x63ontent\x18\x03 \x01(\x0b\x32\x19.warp_unified.TextContent\"\x1b\n\x0bTextContent\x12\x0c\n\x04text\x18\x01 \x01(\t\"\x88\x01\n\x11SecondaryResponse\x12\x35\n\x0b\x61lternative\x18\x01 \x01(\x0b\x32 .warp_unified.AlternativeContent\x12\'\n\x04\x66ile\x18\x02 \x01(\x0b\x32\x19.warp_unified.FileContent\x12\x13\n\x0bresponse_id\x18\x03 \x01(\t\"\x1b\n\x0b\x46ileContent\x12\x0c\n\x04text\x18\x01 \x01(\t\"W\n\x12\x41lternativeContent\x12\n\n\x02id\x18\x01 \x01(\t\x12\x35\n\rfinal_content\x18\x03 \x01(\x0b\x32\x1e.warp_unified.FinalTextContent\" \n\x10\x46inalTextContent\x12\x0c\n\x04text\x18\x01 \x01(\t\"\xf1\x01\n\x0cLoginRequest\x12.\n\turl_chain\x18\x01 \x01(\x0b\x32\x1b.warp_unified.LoginUrlChain\x12\x15\n\rrequest_flags\x18\x02 \x03(\x05\x12\x14\n\x0crequest_type\x18\x03 \x01(\x05\x12+\n\nlogin_data\x18\x04 \x01(\x0b\x32\x17.warp_unified.LoginData\x12\x14\n\x0c\x63onfig_flags\x18\x05 \x03(\x05\x12\x10\n\x08language\x18\x07 \x01(\t\x12/\n\x08settings\x18\t \x01(\x0b\x32\x1d.warp_unified.RequestSettings\"\xd9\x07\n\rLoginUrlChain\x12@\n\x0b\x63ontainer_2\x18\x01 \x01(\x0b\x32+.warp_unified.LoginUrlChain.Level2Container\x1a\x85\x07\n\x0fLevel2Container\x12P\n\x0b\x63ontainer_3\x18\x04 \x01(\x0b\x32;.warp_unified.LoginUrlChain.Level2Container.Level3Container\x1a\x9f\x06\n\x0fLevel3Container\x12`\n\x0b\x63ontainer_4\x18\x03 \x01(\x0b\x32K.warp_unified.LoginUrlChain.Level2Container.Level3Container.Level4Container\x1a\xa9\x05\n\x0fLevel4Container\x12p\n\x0b\x63ontainer_5\x18\x0f \x01(\x0b\x32[.warp_unified.LoginUrlChain.Level2Container.Level3Container.Level4Container.Level5Container\x1a\xa3\x04\n\x0fLevel5Container\x12\x80\x01\n\x0b\x63ontainer_6\x18\x02 \x01(\x0b\x32k.warp_unified.LoginUrlChain.Level2Container.Level3Container.Level4Container.Level5Container.Level6Container\x1a\x8c\x03\n\x0fLevel6Container\x12\x92\x01\n\rurl_container\x18\x01 \x01(\x0b\x32{.warp_unified.LoginUrlChain.Level2Container.Level3Container.Level4Container.Level5Container.Level6Container.Level7Container\x1a\xe3\x01\n\x0fLevel7Container\x12\xa4\x01\n\tfinal_url\x18\x03 \x01(\x0b\x32\x90\x01.warp_unified.LoginUrlChain.Level2Container.Level3Container.Level4Container.Level5Container.Level6Container.Level7Container.Level8FinalContainer\x1a)\n\x14Level8FinalContainer\x12\x11\n\tlogin_url\x18\x01 \x01(\t\"\x18\n\tLoginData\x12\x0b\n\x03url\x18\x01 \x01(\t\"(\n\x0fRequestSettings\x12\x15\n\rsetting_value\x18\x01 \x01(\x05\x62\x06proto3')
+
+_globals = globals()
+_builder.BuildMessageAndEnumDescriptors(DESCRIPTOR, _globals)
+_builder.BuildTopDescriptorsAndMessages(DESCRIPTOR, 'warp_unified_pb2', _globals)
+if not _descriptor._USE_C_DESCRIPTORS:
+  DESCRIPTOR._loaded_options = None
+  _globals['_CHATREQUEST']._serialized_start=37
+  _globals['_CHATREQUEST']._serialized_end=179
+  _globals['_SESSIONINFO']._serialized_start=181
+  _globals['_SESSIONINFO']._serialized_end=261
+  _globals['_MESSAGEHISTORY']._serialized_start=263
+  _globals['_MESSAGEHISTORY']._serialized_end=381
+  _globals['_MESSAGEENTRY']._serialized_start=384
+  _globals['_MESSAGEENTRY']._serialized_end=828
+  _globals['_MESSAGEENTRY_SYSTEMMESSAGE']._serialized_start=629
+  _globals['_MESSAGEENTRY_SYSTEMMESSAGE']._serialized_end=759
+  _globals['_MESSAGEENTRY_SYSTEMMESSAGE_METADATA']._serialized_start=735
+  _globals['_MESSAGEENTRY_SYSTEMMESSAGE_METADATA']._serialized_end=759
+  _globals['_MESSAGEENTRY_USERMESSAGE']._serialized_start=761
+  _globals['_MESSAGEENTRY_USERMESSAGE']._serialized_end=791
+  _globals['_MESSAGEENTRY_ASSISTANTMESSAGE']._serialized_start=793
+  _globals['_MESSAGEENTRY_ASSISTANTMESSAGE']._serialized_end=828
+  _globals['_SYSTEMINFO']._serialized_start=830
+  _globals['_SYSTEMINFO']._serialized_end=938
+  _globals['_ENVIRONMENTINFO']._serialized_start=940
+  _globals['_ENVIRONMENTINFO']._serialized_end=1001
+  _globals['_TIMESTAMP']._serialized_start=1003
+  _globals['_TIMESTAMP']._serialized_end=1028
+  _globals['_REQUESTINFO']._serialized_start=1030
+  _globals['_REQUESTINFO']._serialized_end=1087
+  _globals['_CONTENTDATA']._serialized_start=1089
+  _globals['_CONTENTDATA']._serialized_end=1149
+  _globals['_MESSAGECONTENT']._serialized_start=1151
+  _globals['_MESSAGECONTENT']._serialized_end=1181
+  _globals['_AICONFIG']._serialized_start=1184
+  _globals['_AICONFIG']._serialized_end=1361
+  _globals['_MODELCONFIG']._serialized_start=1363
+  _globals['_MODELCONFIG']._serialized_end=1427
+  _globals['_CHATRESPONSE']._serialized_start=1429
+  _globals['_CHATRESPONSE']._serialized_end=1493
+  _globals['_RESPONSEMETADATA']._serialized_start=1495
+  _globals['_RESPONSEMETADATA']._serialized_end=1561
+  _globals['_RESPONSECONTENT']._serialized_start=1563
+  _globals['_RESPONSECONTENT']._serialized_end=1680
+  _globals['_PRIMARYRESPONSE']._serialized_start=1682
+  _globals['_PRIMARYRESPONSE']._serialized_end=1762
+  _globals['_RESPONSETEXT']._serialized_start=1764
+  _globals['_RESPONSETEXT']._serialized_end=1848
+  _globals['_TEXTCONTENT']._serialized_start=1850
+  _globals['_TEXTCONTENT']._serialized_end=1877
+  _globals['_SECONDARYRESPONSE']._serialized_start=1880
+  _globals['_SECONDARYRESPONSE']._serialized_end=2016
+  _globals['_FILECONTENT']._serialized_start=2018
+  _globals['_FILECONTENT']._serialized_end=2045
+  _globals['_ALTERNATIVECONTENT']._serialized_start=2047
+  _globals['_ALTERNATIVECONTENT']._serialized_end=2134
+  _globals['_FINALTEXTCONTENT']._serialized_start=2136
+  _globals['_FINALTEXTCONTENT']._serialized_end=2168
+  _globals['_LOGINREQUEST']._serialized_start=2171
+  _globals['_LOGINREQUEST']._serialized_end=2412
+  _globals['_LOGINURLCHAIN']._serialized_start=2415
+  _globals['_LOGINURLCHAIN']._serialized_end=3400
+  _globals['_LOGINURLCHAIN_LEVEL2CONTAINER']._serialized_start=2499
+  _globals['_LOGINURLCHAIN_LEVEL2CONTAINER']._serialized_end=3400
+  _globals['_LOGINURLCHAIN_LEVEL2CONTAINER_LEVEL3CONTAINER']._serialized_start=2601
+  _globals['_LOGINURLCHAIN_LEVEL2CONTAINER_LEVEL3CONTAINER']._serialized_end=3400
+  _globals['_LOGINURLCHAIN_LEVEL2CONTAINER_LEVEL3CONTAINER_LEVEL4CONTAINER']._serialized_start=2719
+  _globals['_LOGINURLCHAIN_LEVEL2CONTAINER_LEVEL3CONTAINER_LEVEL4CONTAINER']._serialized_end=3400
+  _globals['_LOGINURLCHAIN_LEVEL2CONTAINER_LEVEL3CONTAINER_LEVEL4CONTAINER_LEVEL5CONTAINER']._serialized_start=2853
+  _globals['_LOGINURLCHAIN_LEVEL2CONTAINER_LEVEL3CONTAINER_LEVEL4CONTAINER_LEVEL5CONTAINER']._serialized_end=3400
+  _globals['_LOGINURLCHAIN_LEVEL2CONTAINER_LEVEL3CONTAINER_LEVEL4CONTAINER_LEVEL5CONTAINER_LEVEL6CONTAINER']._serialized_start=3004
+  _globals['_LOGINURLCHAIN_LEVEL2CONTAINER_LEVEL3CONTAINER_LEVEL4CONTAINER_LEVEL5CONTAINER_LEVEL6CONTAINER']._serialized_end=3400
+  _globals['_LOGINURLCHAIN_LEVEL2CONTAINER_LEVEL3CONTAINER_LEVEL4CONTAINER_LEVEL5CONTAINER_LEVEL6CONTAINER_LEVEL7CONTAINER']._serialized_start=3173
+  _globals['_LOGINURLCHAIN_LEVEL2CONTAINER_LEVEL3CONTAINER_LEVEL4CONTAINER_LEVEL5CONTAINER_LEVEL6CONTAINER_LEVEL7CONTAINER']._serialized_end=3400
+  _globals['_LOGINURLCHAIN_LEVEL2CONTAINER_LEVEL3CONTAINER_LEVEL4CONTAINER_LEVEL5CONTAINER_LEVEL6CONTAINER_LEVEL7CONTAINER_LEVEL8FINALCONTAINER']._serialized_start=3359
+  _globals['_LOGINURLCHAIN_LEVEL2CONTAINER_LEVEL3CONTAINER_LEVEL4CONTAINER_LEVEL5CONTAINER_LEVEL6CONTAINER_LEVEL7CONTAINER_LEVEL8FINALCONTAINER']._serialized_end=3400
+  _globals['_LOGINDATA']._serialized_start=3402
+  _globals['_LOGINDATA']._serialized_end=3426
+  _globals['_REQUESTSETTINGS']._serialized_start=3428
+  _globals['_REQUESTSETTINGS']._serialized_end=3468
+# @@protoc_insertion_point(module_scope)

web_template.py

@@ -0,0 +1,980 @@
+"""
+Web界面模板模块
+包含管理界面的HTML模板
+"""
+
+def get_admin_login_template():
+    """返回管理员登录页面模板"""
+    return """
+<!DOCTYPE html>
+<html lang="zh-CN">
+<head>
+    <meta charset="UTF-8">
+    <meta name="viewport" content="width=device-width, initial-scale=1.0">
+    <title>🔐 管理员登录 - Warp API 管理中心</title>
+    <style>
+        body { 
+            font-family: 'Segoe UI', Tahoma, Geneva, Verdana, sans-serif; 
+            margin: 0; 
+            padding: 0; 
+            background: linear-gradient(135deg, #0f1419 0%, #1a2332 25%, #2d3748 50%, #1a2332 75%, #0f1419 100%);
+            background-attachment: fixed;
+            min-height: 100vh;
+            color: #e2e8f0;
+            display: flex;
+            justify-content: center;
+            align-items: center;
+        }
+        
+        .login-container { 
+            max-width: 400px;
+            width: 90%;
+            background: rgba(30, 41, 59, 0.9); 
+            backdrop-filter: blur(20px);
+            border-radius: 20px; 
+            padding: 40px; 
+            box-shadow: 0 25px 50px -12px rgba(0, 0, 0, 0.5), 0 0 0 1px rgba(255, 255, 255, 0.05);
+            border: 1px solid rgba(148, 163, 184, 0.1);
+            text-align: center;
+        }
+        
+        h1 { 
+            color: #cbd5e1; 
+            margin-bottom: 30px; 
+            font-size: 2rem;
+            text-shadow: 0 2px 10px rgba(59, 130, 246, 0.3);
+        }
+        
+        .form-group {
+            margin-bottom: 25px;
+            text-align: left;
+        }
+        
+        label {
+            display: block;
+            margin-bottom: 8px;
+            color: #cbd5e1;
+            font-weight: 600;
+        }
+        
+        input { 
+            width: 100%; 
+            padding: 12px 16px; 
+            background: rgba(30, 41, 59, 0.7);
+            border: 2px solid rgba(71, 85, 105, 0.3); 
+            border-radius: 10px; 
+            box-sizing: border-box;
+            color: #e2e8f0;
+            font-size: 14px;
+            transition: all 0.3s ease;
+        }
+        
+        input:focus {
+            outline: none;
+            border-color: rgba(59, 130, 246, 0.5);
+            background: rgba(30, 41, 59, 0.9);
+            box-shadow: 0 0 0 3px rgba(59, 130, 246, 0.1);
+        }
+        
+        button { 
+            background: linear-gradient(135deg, rgba(59, 130, 246, 0.8) 0%, rgba(29, 78, 216, 0.8) 100%);
+            color: white; 
+            padding: 14px 28px; 
+            border: none; 
+            border-radius: 10px; 
+            cursor: pointer; 
+            font-weight: 600;
+            font-size: 16px;
+            width: 100%;
+            transition: all 0.3s ease;
+            backdrop-filter: blur(10px);
+            border: 1px solid rgba(59, 130, 246, 0.3);
+        }
+        
+        button:hover { 
+            transform: translateY(-2px); 
+            box-shadow: 0 10px 25px -5px rgba(59, 130, 246, 0.4);
+            background: linear-gradient(135deg, rgba(59, 130, 246, 1) 0%, rgba(29, 78, 216, 1) 100%);
+        }
+        
+        .status { 
+            padding: 12px 16px; 
+            margin: 15px 0; 
+            border-radius: 8px; 
+            font-weight: 500;
+            display: none;
+        }
+        
+        .status.success { 
+            background: rgba(34, 197, 94, 0.15); 
+            color: #86efac; 
+            border: 1px solid rgba(34, 197, 94, 0.3);
+        }
+        
+        .status.error { 
+            background: rgba(239, 68, 68, 0.15); 
+            color: #fca5a5; 
+            border: 1px solid rgba(239, 68, 68, 0.3);
+        }
+        
+        .note {
+            margin-top: 20px;
+            padding: 15px;
+            background: rgba(79, 70, 229, 0.1);
+            border: 1px solid rgba(79, 70, 229, 0.2);
+            border-radius: 8px;
+            font-size: 14px;
+            color: #a5b4fc;
+        }
+    </style>
+</head>
+<body>
+    <div class="login-container">
+        <h1>🔐 管理员登录</h1>
+        <form id="loginForm">
+            <div class="form-group">
+                <label for="adminKey">管理员密钥</label>
+                <input type="password" id="adminKey" name="adminKey" placeholder="请输入管理员密钥" required>
+            </div>
+            <button type="submit">🚀 登录</button>
+            <div id="status" class="status"></div>
+        </form>
+        <div class="note">
+            💡 管理员密钥通过环境变量 <code>ADMIN_KEY</code> 设置
+        </div>
+    </div>
+
+    <script>
+        document.getElementById('loginForm').addEventListener('submit', async function(e) {
+            e.preventDefault();
+            
+            const adminKey = document.getElementById('adminKey').value;
+            const statusDiv = document.getElementById('status');
+            
+            if (!adminKey) {
+                showStatus('请输入管理员密钥', 'error');
+                return;
+            }
+            
+            try {
+                const response = await fetch('/admin/auth', {
+                    method: 'POST',
+                    headers: { 'Content-Type': 'application/json' },
+                    body: JSON.stringify({ admin_key: adminKey })
+                });
+                
+                const data = await response.json();
+                
+                if (data.success) {
+                    showStatus('登录成功，正在跳转...', 'success');
+                    setTimeout(() => {
+                        window.location.href = data.redirect || '/';
+                    }, 1000);
+                } else {
+                    showStatus(data.message || '登录失败', 'error');
+                }
+            } catch (error) {
+                showStatus('登录请求失败: ' + error.message, 'error');
+            }
+        });
+        
+        function showStatus(message, type) {
+            const statusDiv = document.getElementById('status');
+            statusDiv.textContent = message;
+            statusDiv.className = `status ${type}`;
+            statusDiv.style.display = 'block';
+        }
+    </script>
+</body>
+</html>
+"""
+
+def get_html_template():
+    """返回优化的HTML模板"""
+    return """
+<!DOCTYPE html>
+<html lang="zh-CN">
+<head>
+    <meta charset="UTF-8">
+    <meta name="viewport" content="width=device-width, initial-scale=1.0">
+    <title>🚀 Warp API 管理中心</title>
+    <style>
+        body { 
+            font-family: 'Segoe UI', Tahoma, Geneva, Verdana, sans-serif; 
+            margin: 0; 
+            padding: 20px; 
+            background: linear-gradient(135deg, #0f1419 0%, #1a2332 25%, #2d3748 50%, #1a2332 75%, #0f1419 100%);
+            background-attachment: fixed;
+            min-height: 100vh;
+            color: #e2e8f0;
+        }
+        
+        .container { 
+            max-width: 1400px;
+            margin: 0 auto;
+            background: rgba(30, 41, 59, 0.85); 
+            backdrop-filter: blur(20px);
+            border-radius: 20px; 
+            padding: 40px; 
+            box-shadow: 0 25px 50px -12px rgba(0, 0, 0, 0.5), 0 0 0 1px rgba(255, 255, 255, 0.05);
+            border: 1px solid rgba(148, 163, 184, 0.1);
+        }
+        
+        .header {
+            display: flex;
+            justify-content: space-between;
+            align-items: center;
+            margin-bottom: 40px;
+        }
+        
+        h1 { 
+            color: #cbd5e1; 
+            margin: 0; 
+            font-size: 2.5rem;
+            text-shadow: 0 2px 10px rgba(59, 130, 246, 0.3);
+            letter-spacing: -0.025em;
+        }
+        
+        .logout-btn {
+            background: linear-gradient(135deg, rgba(239, 68, 68, 0.8) 0%, rgba(185, 28, 28, 0.8) 100%);
+            color: white;
+            padding: 10px 20px;
+            border: none;
+            border-radius: 8px;
+            cursor: pointer;
+            font-weight: 600;
+            font-size: 14px;
+            transition: all 0.3s ease;
+            border: 1px solid rgba(239, 68, 68, 0.3);
+        }
+        
+        .logout-btn:hover {
+            background: linear-gradient(135deg, rgba(239, 68, 68, 1) 0%, rgba(185, 28, 28, 1) 100%);
+            transform: translateY(-1px);
+        }
+        
+        .section { 
+            margin-bottom: 40px; 
+            padding: 30px; 
+            background: rgba(51, 65, 85, 0.6);
+            backdrop-filter: blur(10px);
+            border-radius: 16px; 
+            border: 1px solid rgba(148, 163, 184, 0.1);
+            box-shadow: 0 10px 25px -5px rgba(0, 0, 0, 0.1), 0 4px 6px -2px rgba(0, 0, 0, 0.05);
+        }
+        
+        .section h2 { 
+            color: #f1f5f9; 
+            margin-top: 0; 
+            display: flex; 
+            align-items: center; 
+            gap: 12px; 
+            font-size: 1.5rem;
+            margin-bottom: 25px;
+        }
+        
+        .status-grid { 
+            display: grid; 
+            grid-template-columns: repeat(auto-fit, minmax(200px, 1fr)); 
+            gap: 20px; 
+            margin-bottom: 30px; 
+        }
+        
+        .status-card { 
+            padding: 20px; 
+            border-radius: 12px; 
+            text-align: center; 
+            font-weight: 600;
+            background: rgba(59, 130, 246, 0.15);
+            border: 1px solid rgba(59, 130, 246, 0.2);
+            backdrop-filter: blur(10px);
+            color: #e2e8f0;
+            transition: all 0.3s ease;
+        }
+        
+        .status-card:hover {
+            transform: translateY(-2px);
+            box-shadow: 0 10px 25px -5px rgba(59, 130, 246, 0.2);
+            background: rgba(59, 130, 246, 0.2);
+        }
+        
+        .status-card.total { background: rgba(59, 130, 246, 0.15); border-color: rgba(59, 130, 246, 0.3); }
+        .status-card.active { background: rgba(34, 197, 94, 0.15); border-color: rgba(34, 197, 94, 0.3); }
+        .status-card.with-access { background: rgba(168, 85, 247, 0.15); border-color: rgba(168, 85, 247, 0.3); }
+        
+        table { 
+            width: 100%; 
+            border-collapse: collapse; 
+            margin-bottom: 25px; 
+            background: rgba(30, 41, 59, 0.5);
+            border-radius: 12px;
+            overflow: hidden;
+            box-shadow: 0 4px 6px -1px rgba(0, 0, 0, 0.1);
+        }
+        
+        th, td { 
+            padding: 16px; 
+            text-align: left; 
+            border-bottom: 1px solid rgba(71, 85, 105, 0.3);
+        }
+        
+        th { 
+            background: rgba(51, 65, 85, 0.8); 
+            color: #f1f5f9; 
+            font-weight: 600; 
+            font-size: 0.875rem;
+            text-transform: uppercase;
+            letter-spacing: 0.05em;
+        }
+        
+        tr:hover { 
+            background-color: rgba(71, 85, 105, 0.3); 
+            transition: background-color 0.2s ease;
+        }
+        
+        input, textarea { 
+            width: 100%; 
+            padding: 12px 16px; 
+            background: rgba(30, 41, 59, 0.7);
+            border: 2px solid rgba(71, 85, 105, 0.3); 
+            border-radius: 10px; 
+            box-sizing: border-box;
+            color: #e2e8f0;
+            font-size: 14px;
+            transition: all 0.3s ease;
+        }
+        
+        input:focus, textarea:focus {
+            outline: none;
+            border-color: rgba(59, 130, 246, 0.5);
+            background: rgba(30, 41, 59, 0.9);
+            box-shadow: 0 0 0 3px rgba(59, 130, 246, 0.1);
+        }
+        
+        input::placeholder, textarea::placeholder {
+            color: #94a3b8;
+        }
+        
+        button { 
+            background: linear-gradient(135deg, rgba(59, 130, 246, 0.8) 0%, rgba(29, 78, 216, 0.8) 100%);
+            color: white; 
+            padding: 12px 24px; 
+            border: none; 
+            border-radius: 10px; 
+            cursor: pointer; 
+            margin: 6px; 
+            font-weight: 600;
+            font-size: 14px;
+            transition: all 0.3s ease;
+            backdrop-filter: blur(10px);
+            border: 1px solid rgba(59, 130, 246, 0.3);
+        }
+        
+        button:hover { 
+            transform: translateY(-2px); 
+            box-shadow: 0 10px 25px -5px rgba(59, 130, 246, 0.4);
+            background: linear-gradient(135deg, rgba(59, 130, 246, 1) 0%, rgba(29, 78, 216, 1) 100%);
+        }
+        
+        button:active {
+            transform: translateY(0);
+        }
+        
+        .btn-success { 
+            background: linear-gradient(135deg, rgba(34, 197, 94, 0.8) 0%, rgba(21, 128, 61, 0.8) 100%);
+            border-color: rgba(34, 197, 94, 0.3);
+        }
+        
+        .btn-success:hover {
+            background: linear-gradient(135deg, rgba(34, 197, 94, 1) 0%, rgba(21, 128, 61, 1) 100%);
+            box-shadow: 0 10px 25px -5px rgba(34, 197, 94, 0.4);
+        }
+        
+        .btn-danger { 
+            background: linear-gradient(135deg, rgba(239, 68, 68, 0.8) 0%, rgba(185, 28, 28, 0.8) 100%);
+            border-color: rgba(239, 68, 68, 0.3);
+        }
+        
+        .btn-danger:hover {
+            background: linear-gradient(135deg, rgba(239, 68, 68, 1) 0%, rgba(185, 28, 28, 1) 100%);
+            box-shadow: 0 10px 25px -5px rgba(239, 68, 68, 0.4);
+        }
+        
+        .btn-info { 
+            background: linear-gradient(135deg, rgba(6, 182, 212, 0.8) 0%, rgba(8, 145, 178, 0.8) 100%);
+            border-color: rgba(6, 182, 212, 0.3);
+        }
+        
+        .btn-info:hover {
+            background: linear-gradient(135deg, rgba(6, 182, 212, 1) 0%, rgba(8, 145, 178, 1) 100%);
+            box-shadow: 0 10px 25px -5px rgba(6, 182, 212, 0.4);
+        }
+        
+        .btn-warning { 
+            background: linear-gradient(135deg, rgba(245, 158, 11, 0.8) 0%, rgba(217, 119, 6, 0.8) 100%);
+            border-color: rgba(245, 158, 11, 0.3);
+        }
+        
+        .btn-warning:hover {
+            background: linear-gradient(135deg, rgba(245, 158, 11, 1) 0%, rgba(217, 119, 6, 1) 100%);
+            box-shadow: 0 10px 25px -5px rgba(245, 158, 11, 0.4);
+        }
+        
+        .btn-small {
+            padding: 8px 16px;
+            font-size: 12px;
+            margin: 2px;
+        }
+        
+        .status { 
+            padding: 16px 20px; 
+            margin: 20px 0; 
+            border-radius: 12px; 
+            font-weight: 600;
+            backdrop-filter: blur(10px);
+        }
+        
+        .status.success { 
+            background: rgba(34, 197, 94, 0.15); 
+            color: #86efac; 
+            border: 1px solid rgba(34, 197, 94, 0.3);
+        }
+        
+        .status.error { 
+            background: rgba(239, 68, 68, 0.15); 
+            color: #fca5a5; 
+            border: 1px solid rgba(239, 68, 68, 0.3);
+        }
+        
+        .api-info { 
+            background: linear-gradient(135deg, rgba(79, 70, 229, 0.15) 0%, rgba(59, 130, 246, 0.15) 100%);
+            border: 1px solid rgba(79, 70, 229, 0.2);
+            color: #e2e8f0; 
+            padding: 25px; 
+            border-radius: 16px; 
+            margin-bottom: 30px;
+            backdrop-filter: blur(10px);
+        }
+        
+        .api-info code { 
+            background: rgba(30, 41, 59, 0.6); 
+            padding: 6px 12px; 
+            border-radius: 8px;
+            color: #a78bfa;
+            font-family: 'Monaco', 'Menlo', 'Ubuntu Mono', monospace;
+            border: 1px solid rgba(71, 85, 105, 0.3);
+        }
+        
+        .tabs { 
+            display: flex; 
+            margin-bottom: 30px; 
+            background: rgba(30, 41, 59, 0.5);
+            border-radius: 12px;
+            padding: 4px;
+            backdrop-filter: blur(10px);
+        }
+        
+        .tab { 
+            padding: 14px 28px; 
+            cursor: pointer; 
+            border: none; 
+            background: none; 
+            color: #94a3b8; 
+            font-weight: 600;
+            border-radius: 8px;
+            transition: all 0.3s ease;
+            flex: 1;
+            text-align: center;
+        }
+        
+        .tab.active { 
+            color: #f1f5f9; 
+            background: rgba(59, 130, 246, 0.3);
+            backdrop-filter: blur(10px);
+        }
+        
+        .tab:hover:not(.active) {
+            color: #cbd5e1;
+            background: rgba(71, 85, 105, 0.3);
+        }
+        
+        .tab-content { 
+            display: none; 
+        }
+        
+        .tab-content.active { 
+            display: block; 
+        }
+        
+        .loading { 
+            display: none; 
+            text-align: center; 
+            padding: 30px;
+            color: #94a3b8;
+        }
+        
+        .spinner { 
+            border: 4px solid rgba(71, 85, 105, 0.3); 
+            border-top: 4px solid #3b82f6; 
+            border-radius: 50%; 
+            width: 40px; 
+            height: 40px; 
+            animation: spin 1s linear infinite; 
+            margin: 0 auto 15px;
+        }
+        
+        @keyframes spin { 
+            0% { transform: rotate(0deg); } 
+            100% { transform: rotate(360deg); } 
+        }
+        
+        .action-buttons {
+            display: flex;
+            gap: 8px;
+            justify-content: center;
+        }
+        
+        .token-id {
+            font-family: 'Monaco', 'Menlo', 'Ubuntu Mono', monospace;
+            background: rgba(30, 41, 59, 0.6);
+            padding: 4px 8px;
+            border-radius: 6px;
+            font-size: 0.85rem;
+            color: #a78bfa;
+        }
+        
+        .env-info {
+            background: rgba(34, 197, 94, 0.1);
+            border: 1px solid rgba(34, 197, 94, 0.2);
+            color: #86efac;
+            padding: 15px;
+            border-radius: 12px;
+            margin-bottom: 20px;
+            font-size: 14px;
+        }
+        
+        .export-section {
+            background: rgba(245, 158, 11, 0.1);
+            border: 1px solid rgba(245, 158, 11, 0.2);
+            padding: 20px;
+            border-radius: 12px;
+            margin-bottom: 20px;
+        }
+        
+        .export-form {
+            display: flex;
+            gap: 15px;
+            align-items: end;
+        }
+        
+        .export-form input {
+            flex: 1;
+        }
+        
+        .modal {
+            display: none;
+            position: fixed;
+            z-index: 1000;
+            left: 0;
+            top: 0;
+            width: 100%;
+            height: 100%;
+            background-color: rgba(0, 0, 0, 0.5);
+            backdrop-filter: blur(10px);
+        }
+        
+        .modal-content {
+            background: rgba(30, 41, 59, 0.95);
+            margin: 15% auto;
+            padding: 30px;
+            border-radius: 16px;
+            width: 80%;
+            max-width: 500px;
+            border: 1px solid rgba(148, 163, 184, 0.2);
+            box-shadow: 0 25px 50px -12px rgba(0, 0, 0, 0.8);
+        }
+        
+        .close {
+            color: #94a3b8;
+            float: right;
+            font-size: 28px;
+            font-weight: bold;
+            cursor: pointer;
+            line-height: 1;
+        }
+        
+        .close:hover {
+            color: #e2e8f0;
+        }
+    </style>
+</head>
+<body>
+    <div class="container">
+        <div class="header">
+            <h1>🚀 Warp API 管理中心</h1>
+            <button class="logout-btn" onclick="logout()">🚪 退出登录</button>
+        </div>
+        
+        <div class="api-info">
+            <h3>📡 API 端点信息</h3>
+            <p><strong>Base URL:</strong> <code>http://localhost:7860</code></p>
+            <p><strong>Chat:</strong> <code>/v1/chat/completions</code> | <strong>Models:</strong> <code>/v1/models</code></p>
+            <div class="env-info">
+                🔐 <strong>安全提示:</strong> API密钥和敏感信息已隐藏，仅在服务器端可见
+            </div>
+        </div>
+        
+        <div class="tabs">
+            <button class="tab active" onclick="showTab('token-status')">🔑 Token状态</button>
+            <button class="tab" onclick="showTab('add-tokens')">➕ 添加Token</button>
+            <button class="tab" onclick="showTab('get-tokens')">📧 获取Token</button>
+        </div>
+        
+        <div id="token-status" class="tab-content active">
+            <div class="section">
+                <h2>🔑 Token 状态管理</h2>
+                <div class="env-info" id="tokenEnvInfo" style="display: none;">
+                    🎯 <strong>环境变量Token:</strong> 已通过 <code>WARP_REFRESH_TOKEN</code> 设置<br>
+                    💡 <strong>多Token支持:</strong> 可使用分号(;)分割多个token：<code>token1;token2;token3</code>
+                </div>
+                
+                <div class="export-section">
+                    <h3>🔒 导出 Refresh Token (超级管理员功能)</h3>
+                    <p>导出所有refresh token为分号分割的文本文件，需要超级管理员密钥验证</p>
+                    <div class="export-form">
+                        <div style="flex: 1;">
+                            <label>超级管理员密钥</label>
+                            <input type="password" id="superAdminKey" placeholder="请输入超级管理员密钥">
+                        </div>
+                        <button onclick="exportTokens()" class="btn-warning">📥 导出Token</button>
+                    </div>
+                    <div class="env-info" style="margin-top: 15px;">
+                        💡 <strong>提示:</strong> 点击导出后，浏览器会提示您选择保存位置<br>
+                        📁 <strong>文件格式:</strong> 文本文件，token间用分号(;)分割，文件名包含时间戳
+                    </div>
+                    <div id="exportStatus"></div>
+                </div>
+                
+                <div class="status-grid">
+                    <div class="status-card total"><div>总Token数</div><div id="totalTokens">-</div></div>
+                    <div class="status-card active"><div>活跃Token</div><div id="activeTokens">-</div></div>
+                    <div class="status-card with-access"><div>可用Token</div><div id="tokensWithAccess">-</div></div>
+                </div>
+                <button onclick="refreshTokenStatus()" class="btn-info">🔄 刷新状态</button>
+                <button onclick="refreshAllTokens()" class="btn-success">⚡ 刷新所有Token</button>
+                <div style="max-height: 500px; overflow-y: auto; margin-top: 25px;">
+                    <table>
+                        <thead><tr><th>Token ID</th><th>状态</th><th>访问Token</th><th>刷新次数</th><th>使用次数</th><th>操作</th></tr></thead>
+                        <tbody id="tokenTableBody"></tbody>
+                    </table>
+                </div>
+            </div>
+        </div>
+        
+        <div id="add-tokens" class="tab-content">
+            <div class="section">
+                <h2>➕ 添加 Refresh Token</h2>
+                <div class="env-info">
+                    💡 <strong>提示:</strong> 也可通过环境变量 <code>WARP_REFRESH_TOKEN</code> 设置refresh token<br>
+                    🔀 <strong>多Token支持:</strong> 环境变量中可使用分号(;)分割多个token：<code>token1;token2;token3</code>
+                </div>
+                <textarea id="tokensInput" rows="5" placeholder="请输入refresh token，每行一个&#10;或者在环境变量中使用分号分割：token1;token2;token3"></textarea>
+                <div style="margin-top: 20px;">
+                    <button onclick="addTokens()" class="btn-success">➕ 添加Token</button>
+                    <button onclick="clearTokensInput()" class="btn-danger">🗑️ 清空</button>
+                </div>
+                <div id="addTokensStatus"></div>
+            </div>
+        </div>
+        
+        <div id="get-tokens" class="tab-content">
+            <div class="section">
+                <h2>📧 批量获取 Refresh Token</h2>
+                <div style="margin-bottom: 25px;">
+                    <label style="color: #cbd5e1; margin-right: 10px;">并发线程数:</label>
+                    <input type="number" id="maxWorkers" min="1" max="20" value="5" style="width: 100px; display: inline-block;">
+                    <button onclick="addEmailRow()">➕ 添加邮箱</button>
+                    <button onclick="clearEmails()" class="btn-danger">🗑️ 清空</button>
+                </div>
+                <table id="emailTable">
+                    <thead><tr><th>邮箱地址</th><th>登录URL</th><th>操作</th></tr></thead>
+                    <tbody id="emailTableBody">
+                        <tr>
+                            <td><input type="email" placeholder="[email protected]"></td>
+                            <td><input type="url" placeholder="https://..."></td>
+                            <td><button onclick="removeEmailRow(this)" class="btn-danger btn-small">❌</button></td>
+                        </tr>
+                    </tbody>
+                </table>
+                <button onclick="processEmails()" class="btn-success">🚀 开始处理</button>
+                <div class="loading" id="emailLoading"><div class="spinner"></div><p id="loadingText">正在处理邮箱，获取Token并创建用户...</p></div>
+                <div id="emailResults"></div>
+            </div>
+        </div>
+    </div>
+
+    <script>
+        function showTab(tabName) {
+            document.querySelectorAll('.tab').forEach(tab => tab.classList.remove('active'));
+            document.querySelectorAll('.tab-content').forEach(content => content.classList.remove('active'));
+            event.target.classList.add('active');
+            document.getElementById(tabName).classList.add('active');
+            if (tabName === 'token-status') refreshTokenStatus();
+        }
+        
+        async function refreshTokenStatus() {
+            try {
+                const response = await fetch('/token/status');
+                const data = await response.json();
+                if (data.success !== false) {
+                    document.getElementById('totalTokens').textContent = data.total_tokens;
+                    document.getElementById('activeTokens').textContent = data.active_tokens;
+                    document.getElementById('tokensWithAccess').textContent = data.tokens_with_access;
+                    
+                    // 如果有token，检查是否是环境变量设置的
+                    if (data.total_tokens > 0) {
+                        document.getElementById('tokenEnvInfo').style.display = 'block';
+                    }
+                    
+                    const tbody = document.getElementById('tokenTableBody');
+                    tbody.innerHTML = '';
+                    data.tokens.forEach(token => {
+                        const row = tbody.insertRow();
+                        row.innerHTML = `
+                            <td><span class="token-id">${token.refresh_token}</span></td>
+                            <td>${token.is_active ? '✅ 活跃' : '❌ 失效'}</td>
+                            <td>${token.has_access_token ? '✅ 有效' : '❌ 无效'}</td>
+                            <td>${token.refresh_count}</td>
+                            <td>${token.usage_count}</td>
+                            <td>
+                                <div class="action-buttons">
+                                    <button onclick="deleteToken('${token.refresh_token}')" class="btn-danger btn-small">🗑️ 删除</button>
+                                </div>
+                            </td>
+                        `;
+                    });
+                }
+            } catch (error) { 
+                console.error('刷新状态失败:', error); 
+                showStatus('刷新状态失败: ' + error.message, 'error');
+            }
+        }
+        
+        async function deleteToken(tokenId) {
+            if (!confirm('确定要删除这个Token吗？')) return;
+            
+            try {
+                const response = await fetch('/token/remove', {
+                    method: 'POST',
+                    headers: { 'Content-Type': 'application/json' },
+                    body: JSON.stringify({ refresh_token: tokenId })
+                });
+                const data = await response.json();
+                if (data.success) {
+                    showStatus('Token删除成功', 'success');
+                    refreshTokenStatus();
+                } else {
+                    showStatus(data.message || 'Token删除失败', 'error');
+                }
+            } catch (error) {
+                showStatus('删除请求失败: ' + error.message, 'error');
+            }
+        }
+        
+        async function exportTokens() {
+            const superAdminKey = document.getElementById('superAdminKey').value;
+            
+            if (!superAdminKey) {
+                showStatus('请输入超级管理员密钥', 'error', 'exportStatus');
+                return;
+            }
+            
+            try {
+                showStatus('正在准备导出...', 'success', 'exportStatus');
+                
+                const response = await fetch('/token/export', {
+                    method: 'POST',
+                    headers: { 'Content-Type': 'application/json' },
+                    body: JSON.stringify({ super_admin_key: superAdminKey })
+                });
+                
+                const data = await response.json();
+                
+                if (data.success) {
+                    // 使用浏览器下载API
+                    downloadTextFile(data.content, data.suggested_filename);
+                    
+                    showStatus(`导出成功！包含 ${data.token_count} 个token`, 'success', 'exportStatus');
+                    document.getElementById('superAdminKey').value = '';
+                } else {
+                    showStatus(data.message || '导出失败', 'error', 'exportStatus');
+                }
+            } catch (error) {
+                showStatus('导出请求失败: ' + error.message, 'error', 'exportStatus');
+            }
+        }
+        
+        function downloadTextFile(content, filename) {
+            try {
+                // 创建Blob对象
+                const blob = new Blob([content], { type: 'text/plain;charset=utf-8' });
+                
+                // 创建下载链接
+                const url = URL.createObjectURL(blob);
+                const link = document.createElement('a');
+                link.href = url;
+                link.download = filename;
+                
+                // 触发下载
+                document.body.appendChild(link);
+                link.click();
+                
+                // 清理
+                document.body.removeChild(link);
+                URL.revokeObjectURL(url);
+                
+                console.log(`文件 ${filename} 下载完成`);
+            } catch (error) {
+                console.error('下载文件时出错:', error);
+                showStatus('下载文件时出错: ' + error.message, 'error', 'exportStatus');
+            }
+        }
+        
+        async function refreshAllTokens() {
+            try {
+                const response = await fetch('/token/refresh', { method: 'POST' });
+                const data = await response.json();
+                if (data.success) {
+                    showStatus('所有Token刷新已触发', 'success');
+                    setTimeout(refreshTokenStatus, 2000);
+                } else {
+                    showStatus(data.message, 'error');
+                }
+            } catch (error) { showStatus('刷新失败: ' + error.message, 'error'); }
+        }
+        
+        async function addTokens() {
+            const tokens = document.getElementById('tokensInput').value.split('\\n').map(t => t.trim()).filter(t => t);
+            if (tokens.length === 0) { showStatus('请输入至少一个token', 'error', 'addTokensStatus'); return; }
+            try {
+                const response = await fetch('/token/add', {
+                    method: 'POST',
+                    headers: { 'Content-Type': 'application/json' },
+                    body: JSON.stringify({ tokens })
+                });
+                const data = await response.json();
+                if (data.success) {
+                    showStatus(`成功添加 ${data.added_tokens} 个token`, 'success', 'addTokensStatus');
+                    document.getElementById('tokensInput').value = '';
+                } else {
+                    showStatus(data.message, 'error', 'addTokensStatus');
+                }
+            } catch (error) { showStatus('添加失败: ' + error.message, 'error', 'addTokensStatus'); }
+        }
+        
+        function clearTokensInput() { document.getElementById('tokensInput').value = ''; }
+        
+        function addEmailRow() {
+            const tbody = document.getElementById('emailTableBody');
+            const row = tbody.insertRow();
+            row.innerHTML = `<td><input type="email" placeholder="[email protected]"></td><td><input type="url" placeholder="https://..."></td><td><button onclick="removeEmailRow(this)" class="btn-danger btn-small">❌</button></td>`;
+        }
+        
+        function removeEmailRow(button) { button.closest('tr').remove(); }
+        
+        function clearEmails() {
+            document.getElementById('emailTableBody').innerHTML = `<tr><td><input type="email" placeholder="[email protected]"></td><td><input type="url" placeholder="https://..."></td><td><button onclick="removeEmailRow(this)" class="btn-danger btn-small">❌</button></td></tr>`;
+        }
+        
+        async function processEmails() {
+            const rows = document.querySelectorAll('#emailTableBody tr');
+            const emailUrlPairs = [];
+            rows.forEach(row => {
+                const inputs = row.querySelectorAll('input');
+                const email = inputs[0].value.trim();
+                const url = inputs[1].value.trim();
+                if (email && url) emailUrlPairs.push({email, url});
+            });
+            
+            if (emailUrlPairs.length === 0) { showStatus('请至少添加一个邮箱和URL', 'error', 'emailResults'); return; }
+            
+            document.getElementById('emailLoading').style.display = 'block';
+            document.getElementById('emailResults').innerHTML = '';
+            
+            try {
+                const response = await fetch('/login/batch', {
+                    method: 'POST',
+                    headers: { 'Content-Type': 'application/json' },
+                    body: JSON.stringify({ 
+                        email_url_pairs: emailUrlPairs,
+                        max_workers: parseInt(document.getElementById('maxWorkers').value)
+                    })
+                });
+                const data = await response.json();
+                document.getElementById('emailLoading').style.display = 'none';
+                
+                if (data.success) {
+                    let resultsHtml = `<div class="status success">批量处理完成！成功: ${data.success_count}/${data.total_count}</div>`;
+                    resultsHtml += '<table><tr><th>邮箱</th><th>状态</th><th>Token</th><th>用户创建</th></tr>';
+                    Object.entries(data.results).forEach(([email, result]) => {
+                        let userCreationStatus = '';
+                        if (result.status.includes('成功并已创建用户')) {
+                            userCreationStatus = '✅ 已创建';
+                        } else if (result.status.includes('创建用户失败')) {
+                            userCreationStatus = '❌ 创建失败';
+                        } else if (result.status.includes('获取access_token失败')) {
+                            userCreationStatus = '⚠️ Token失败';
+                        } else if (result.refresh_token) {
+                            userCreationStatus = '🔄 未尝试';
+                        } else {
+                            userCreationStatus = '-';
+                        }
+                        
+                        resultsHtml += `<tr><td>${email}</td><td>${result.status}</td><td>${result.refresh_token ? '✅ 已获取' : '❌ 失败'}</td><td>${userCreationStatus}</td></tr>`;
+                    });
+                    resultsHtml += '</table>';
+                    document.getElementById('emailResults').innerHTML = resultsHtml;
+                } else {
+                    showStatus(data.message, 'error', 'emailResults');
+                }
+            } catch (error) {
+                document.getElementById('emailLoading').style.display = 'none';
+                showStatus('处理失败: ' + error.message, 'error', 'emailResults');
+            }
+        }
+        
+        async function logout() {
+            if (!confirm('确定要退出登录吗？')) return;
+            
+            try {
+                const response = await fetch('/admin/logout', { method: 'POST' });
+                const data = await response.json();
+                if (data.success) {
+                    window.location.href = '/admin/login';
+                }
+            } catch (error) {
+                console.error('登出失败:', error);
+            }
+        }
+        
+        function showStatus(message, type, targetId = null) {
+            const status = `<div class="status ${type}">${message}</div>`;
+            if (targetId) {
+                document.getElementById(targetId).innerHTML = status;
+            } else {
+                const container = document.querySelector('.container');
+                const statusDiv = document.createElement('div');
+                statusDiv.innerHTML = status;
+                container.insertBefore(statusDiv, container.firstChild);
+                setTimeout(() => statusDiv.remove(), 5000);
+            }
+        }
+        
+        // 页面加载时刷新状态
+        document.addEventListener('DOMContentLoaded', function() {
+            refreshTokenStatus();
+        });
+    </script>
+</body>
+</html>
+"""