Upload 5 files

Dockerfile

@@ -0,0 +1,27 @@
+FROM python:3.10-slim-bullseye
+
+# 安装必要的系统依赖
+# DrissionPage 需要浏览器才能工作
+RUN apt-get update && apt-get install -y \
+  chromium \
+  chromium-driver \
+  && rm -rf /var/lib/apt/lists/*
+
+WORKDIR /app
+
+# 复制项目文件
+COPY . .
+
+# 安装 Python 依赖
+RUN pip install --no-cache-dir \
+  flask \
+  python-dotenv \
+  DrissionPage \
+  requests
+
+# 暴露端口
+ENV PORT=7860
+EXPOSE 7860
+
+# 运行应用
+CMD ["python", "app.py"]

app.py

@@ -0,0 +1,787 @@
+import os
+import sys
+import json
+import threading
+import queue
+import time
+import uuid
+from datetime import datetime
+from typing import Dict, List, Optional
+from functools import wraps
+
+from flask import Flask, request, jsonify, render_template, Response
+from dotenv import load_dotenv
+
+from browser_worker import BrowserWorker, AccountInfo, AccountStatus
+from email_manager import EmailManager
+from config import Config, setup_logging
+import logging
+
+log = logging.getLogger('werkzeug')
+log.setLevel(logging.ERROR)
+logger = logging.getLogger(__name__)
+
+# 加载环境变量
+load_dotenv()
+
+if getattr(sys, 'frozen', False):
+    template_folder = os.path.join(os.getcwd(), 'templates')
+    static_folder = os.path.join(os.getcwd(), 'static')
+    app = Flask(__name__, template_folder=template_folder, static_folder=static_folder)
+else:
+    app = Flask(__name__)
+app.secret_key = os.getenv('SECRET_KEY', 'your-secret-key-change-in-production')
+
+# 全局配置和状态
+setup_logging()
+config = Config()
+accounts: Dict[str, AccountInfo] = {}  # email -> AccountInfo
+workers: Dict[int, BrowserWorker] = {}  # worker_id -> BrowserWorker
+task_queue = queue.Queue()
+accounts_lock = threading.Lock()
+workers_lock = threading.Lock()
+
+# 管理员认证
+ADMIN_USERNAME = os.getenv('ADMIN_USERNAME', 'admin')
+ADMIN_PASSWORD = os.getenv('ADMIN_PASSWORD', 'admin123')
+
+
+def check_auth(username, password):
+    """验证管理员凭据"""
+    return username == ADMIN_USERNAME and password == ADMIN_PASSWORD
+
+
+def authenticate():
+    """返回401认证请求"""
+    return Response(
+        json.dumps({'error': '需要认证'}),
+        401,
+        {'WWW-Authenticate': 'Basic realm="Admin Area"'}
+    )
+
+
+def requires_auth(f):
+    """认证装饰器"""
+    @wraps(f)
+    def decorated(*args, **kwargs):
+        auth = request.authorization
+        if not auth or not check_auth(auth.username, auth.password):
+            api_key = (
+                request.headers.get("Authorization", "").replace("Bearer ", "") or
+                request.headers.get("X-API-Key")
+            )
+            adminpassword = os.getenv('ADMIN_PASSWORD', '')
+
+            if api_key != os.getenv('ADMIN_TOKEN', '') and api_key != os.getenv('ADMIN_PASSWORD', ''):
+                return authenticate()
+        return f(*args, **kwargs)
+    return decorated
+
+
+def get_available_worker_slot() -> Optional[int]:
+    """获取可用的工作槽位"""
+    max_workers = config.get_max_workers()
+    with workers_lock:
+        active_count = sum(1 for w in workers.values() if w.is_alive())
+        if active_count >= max_workers:
+            return None
+        for i in range(max_workers):
+            if i not in workers or not workers[i].is_alive():
+                return i
+    return None
+
+
+def start_worker(worker_id: int, account: AccountInfo, mode: str = "register"):
+    """启动工作线程"""
+    worker = BrowserWorker(
+        worker_id=worker_id,
+        account=account,
+        config=config,
+        mode=mode,
+        on_update=on_account_update,
+        on_complete=on_worker_complete
+    )
+    with workers_lock:
+        workers[worker_id] = worker
+    worker.start()
+    return worker
+
+
+def on_account_update(email: str, account: AccountInfo):
+    """账号更新回调"""
+    with accounts_lock:
+        accounts[email] = account
+
+
+def on_worker_complete(worker_id: int, email: str, success: bool):
+    """工作线程完成回调"""
+    with workers_lock:
+        if worker_id in workers:
+            del workers[worker_id]
+
+
+def get_email_config_by_domain(email: str) -> Optional[Dict]:
+    """根据邮箱地址获取对应的邮箱配置"""
+    if '@' not in email:
+        return None
+    
+    domain = email.split('@')[1].lower()
+    email_configs = config.get_email_configs()
+    
+    for cfg in email_configs:
+        if cfg.get('email_domain', '').lower() == domain:
+            return cfg
+    
+    return None
+
+
+def create_account_from_email(email: str) -> Optional[AccountInfo]:
+    """根据邮箱地址创建账号（用于刷新场景）"""
+    email_config = get_email_config_by_domain(email)
+    if not email_config:
+        return None
+    
+    # 尝试获取JWT
+    email_manager = EmailManager(
+        email_config['worker_domain'],
+        email_config['email_domain'],
+        email_config['admin_password']
+    )
+    
+    account = AccountInfo(
+        email=email,
+        jwt= "",
+        status=AccountStatus.PENDING,
+        email_config=email_config,
+        created_at=datetime.now().isoformat()
+    )
+    
+    return account
+
+
+# ==================== API 路由 ====================
+
+@app.route('/')
+def index():
+    """管理面板首页"""
+    return render_template('index.html')
+
+
+@app.route('/api/login', methods=['POST'])
+def login():
+    """登录验证"""
+    data = request.get_json()
+    username = data.get('username', '')
+    password = data.get('password', '')
+    
+    if check_auth(username, password):
+        token = str(uuid.uuid4())
+        return jsonify({
+            'success': True,
+            'token': token,
+            'message': '登录成功'
+        })
+    
+    return jsonify({
+        'success': False,
+        'message': '用户名或密码错误'
+    }), 401
+
+
+@app.route('/api/accounts', methods=['POST'])
+@requires_auth
+def create_account():
+    """创建新账号"""
+    data = request.get_json() or {}
+    username = data.get('username', '')
+    
+    worker_id = get_available_worker_slot()
+    if worker_id is None:
+        return jsonify({
+            'success': False,
+            'error': '浏览器线程已达上限，请稍后再试'
+        }), 429
+    
+    email_config = config.get_random_email_config()
+    if not email_config:
+        return jsonify({
+            'success': False,
+            'error': '没有配置邮箱域'
+        }), 500
+    
+    email_manager = EmailManager(
+        email_config['worker_domain'],
+        email_config['email_domain'],
+        email_config['admin_password']
+    )
+    
+    jwt, email = email_manager.create_email(username)
+    if not jwt or not email:
+        return jsonify({
+            'success': False,
+            'error': '创建邮箱失败'
+        }), 500
+    
+    account = AccountInfo(
+        email=email,
+        jwt=jwt,
+        status=AccountStatus.PENDING,
+        email_config=email_config,
+        created_at=datetime.now().isoformat()
+    )
+    
+    with accounts_lock:
+        accounts[email] = account
+    
+    worker = start_worker(worker_id, account, mode="register")
+    worker.join()  # 等待任务完成
+    
+    if account.status == AccountStatus.SUCCESS:
+        return jsonify({
+            'success': True,
+            'account': account.to_dict(),
+            'message': '账号创建成功'
+        })
+    else:
+        return jsonify({
+            'success': False,
+            'error': account.error_message or '创建失败',
+            'details': account.to_dict()
+        }), 500
+
+
+@app.route('/api/accounts', methods=['GET'])
+@requires_auth
+def get_accounts():
+    """获取账号列表"""
+    email = request.args.get('email')
+    status_filter = request.args.get('status')
+    search = request.args.get('search', '')
+    page = int(request.args.get('page', 1))
+    per_page = int(request.args.get('per_page', 20))
+    
+    with accounts_lock:
+        if email:
+            if email in accounts:
+                return jsonify({
+                    'success': True,
+                    'account': accounts[email].to_dict()
+                })
+            else:
+                return jsonify({
+                    'success': False,
+                    'error': '账号不存在'
+                }), 404
+        
+        result = []
+        for acc in accounts.values():
+            if status_filter:
+                if status_filter == 'success' and acc.status != AccountStatus.SUCCESS:
+                    continue
+                elif status_filter == 'failed' and acc.status != AccountStatus.FAILED:
+                    continue
+                elif status_filter == 'creating' and acc.status not in [
+                    AccountStatus.PENDING, AccountStatus.CREATING_EMAIL, 
+                    AccountStatus.ENTERING_EMAIL, AccountStatus.WAITING_CODE,
+                    AccountStatus.VERIFYING, AccountStatus.COMPLETING
+                ]:
+                    continue
+                elif status_filter == 'updating' and acc.status != AccountStatus.UPDATING:
+                    continue
+            
+            if search and search.lower() not in acc.email.lower():
+                continue
+            
+            result.append(acc.to_dict())
+        
+        total = len(result)
+        success_count = sum(1 for acc in accounts.values() if acc.status == AccountStatus.SUCCESS)
+        creating_count = sum(1 for acc in accounts.values() if acc.status in [
+            AccountStatus.PENDING, AccountStatus.CREATING_EMAIL,
+            AccountStatus.ENTERING_EMAIL, AccountStatus.WAITING_CODE,
+            AccountStatus.VERIFYING, AccountStatus.COMPLETING, AccountStatus.UPDATING
+        ])
+        failed_count = sum(1 for acc in accounts.values() if acc.status == AccountStatus.FAILED)
+        
+        start = (page - 1) * per_page
+        end = start + per_page
+        paginated = result[start:end]
+        
+        return jsonify({
+            'success': True,
+            'accounts': paginated,
+            'total': total,
+            'page': page,
+            'per_page': per_page,
+            'total_pages': (total + per_page - 1) // per_page,
+            'stats': {
+                'total': len(accounts),
+                'success': success_count,
+                'creating': creating_count,
+                'failed': failed_count
+            }
+        })
+
+
+@app.route('/api/accounts/<email>', methods=['DELETE'])
+@requires_auth
+def delete_account(email: str):
+    """删除账号"""
+    with accounts_lock:
+        if email in accounts:
+            del accounts[email]
+            return jsonify({
+                'success': True,
+                'message': '账号已删除'
+            })
+        else:
+            return jsonify({
+                'success': False,
+                'error': '账号不存在'
+            }), 404
+
+
+@app.route('/api/accounts/<email>/refresh', methods=['POST'])
+@requires_auth
+def refresh_account(email: str):
+    """
+    刷新账号Cookie
+    - 如果账号存在，直接刷新
+    - 如果账号不存在但邮箱域名匹配，自动创建并刷新
+    """
+    with accounts_lock:
+        account = accounts.get(email)
+    
+    # 账号不存在，尝试根据邮箱域名创建
+    if not account:
+        account = create_account_from_email(email)
+        if not account:
+            return jsonify({
+                'success': False,
+                'error': f'账号不存在，且邮箱域名 {email.split("@")[1] if "@" in email else "unknown"} 未配置'
+            }), 404
+        
+        # 保存新创建的账号
+        with accounts_lock:
+            accounts[email] = account
+    
+    # 检查是否有可用的工作槽位
+    worker_id = get_available_worker_slot()
+    if worker_id is None:
+        return jsonify({
+            'success': False,
+            'error': '浏览器线程已达上限，请稍后再试'
+        }), 429
+    
+    # 更新状态
+    account.status = AccountStatus.UPDATING
+    with accounts_lock:
+        accounts[email] = account
+    
+    # 启动刷新工作线程
+    start_worker(worker_id, account, mode="refresh")
+    
+    return jsonify({
+        'success': True,
+        'message': '刷新已开始',
+        'email': email
+    })
+
+
+@app.route('/api/accounts/refresh-all', methods=['POST'])
+@requires_auth
+def refresh_all_accounts():
+    """刷新所有成功的账号"""
+    with accounts_lock:
+        success_accounts = [acc for acc in accounts.values() if acc.status == AccountStatus.SUCCESS]
+    
+    if not success_accounts:
+        return jsonify({
+            'success': False,
+            'error': '没有可刷新的账号'
+        }), 400
+    
+    max_workers = config.get_max_workers()
+    queued_count = 0
+    
+    for account in success_accounts:
+        worker_id = get_available_worker_slot()
+        if worker_id is not None:
+            account.status = AccountStatus.UPDATING
+            with accounts_lock:
+                accounts[account.email] = account
+            start_worker(worker_id, account, mode="refresh")
+            queued_count += 1
+        else:
+            task_queue.put(('refresh', account))
+            queued_count += 1
+    
+    return jsonify({
+        'success': True,
+        'message': f'已开始刷新 {queued_count} 个账号'
+    })
+
+
+@app.route('/api/accounts/<email>/retry', methods=['POST'])
+@requires_auth
+def retry_account(email: str):
+    """重试失败的账号"""
+    with accounts_lock:
+        if email not in accounts:
+            return jsonify({
+                'success': False,
+                'error': '账号不存在'
+            }), 404
+        
+        account = accounts[email]
+        
+        if account.status != AccountStatus.FAILED:
+            return jsonify({
+                'success': False,
+                'error': '只能重试失败的账号'
+            }), 400
+    
+    worker_id = get_available_worker_slot()
+    if worker_id is None:
+        return jsonify({
+            'success': False,
+            'error': '浏览器线程已达上限，请稍后再试'
+        }), 429
+    
+    account.status = AccountStatus.PENDING
+    account.error_message = ""
+    with accounts_lock:
+        accounts[email] = account
+    
+    start_worker(worker_id, account, mode="register")
+    
+    return jsonify({
+        'success': True,
+        'message': '重试已开始'
+    })
+
+
+@app.route('/api/accounts/<email>/stop', methods=['POST'])
+@requires_auth
+def stop_account(email: str):
+    """停止账号操作"""
+    with workers_lock:
+        for worker_id, worker in list(workers.items()):
+            if worker.account.email == email:
+                worker.stop()
+                del workers[worker_id]
+                
+                with accounts_lock:
+                    if email in accounts:
+                        accounts[email].status = AccountStatus.FAILED
+                        accounts[email].error_message = "用户手动停止"
+                
+                return jsonify({
+                    'success': True,
+                    'message': '已停止'
+                })
+    
+    return jsonify({
+        'success': False,
+        'error': '未找到正在运行的任务'
+    }), 404
+
+
+@app.route('/api/accounts/stop-all', methods=['POST'])
+@requires_auth
+def stop_all():
+    """停止所有操作"""
+    stopped_count = 0
+    with workers_lock:
+        for worker_id, worker in list(workers.items()):
+            worker.stop()
+            email = worker.account.email
+            
+            with accounts_lock:
+                if email in accounts:
+                    accounts[email].status = AccountStatus.FAILED
+                    accounts[email].error_message = "用户手动停止"
+            
+            stopped_count += 1
+        workers.clear()
+    
+    while not task_queue.empty():
+        try:
+            task_queue.get_nowait()
+        except:
+            break
+    
+    return jsonify({
+        'success': True,
+        'message': f'已停止 {stopped_count} 个任务'
+    })
+
+
+@app.route('/api/accounts/export', methods=['GET'])
+@requires_auth
+def export_accounts():
+    """导出成功的账号（包含时间戳和邮箱）"""
+    with accounts_lock:
+        success_accounts = [acc for acc in accounts.values() if acc.status == AccountStatus.SUCCESS and acc.is_complete()]
+    
+    export_data = {
+        'accounts': []
+    }
+    
+    for acc in success_accounts:
+        export_data['accounts'].append({
+            'available': True,
+            'email': acc.email,  # 重要：包含邮箱用于刷新
+            'csesidx': acc.csesidx,
+            'host_c_oses': acc.c_oses,
+            'secure_c_ses': acc.c_ses,
+            'team_id': acc.config_id,
+            'user_agent': config.get_user_agent(),
+            'created_at': acc.created_at or datetime.now().isoformat(),
+            'updated_at': acc.updated_at or acc.created_at or datetime.now().isoformat()
+        })
+    
+    return jsonify(export_data)
+
+
+@app.route('/api/settings', methods=['GET'])
+@requires_auth
+def get_settings():
+    """获取设置"""
+    return jsonify({
+        'success': True,
+        'settings': {
+            'user_agent': config.get_user_agent(),
+            'max_workers': config.get_max_workers(),
+            'headless': config.get_headless(),
+            'email_configs': config.get_email_configs_safe(),
+            'browser_fingerprint': config.get_browser_fingerprint()
+        }
+    })
+
+
+@app.route('/api/settings', methods=['POST'])
+@requires_auth
+def update_settings():
+    """更新设置"""
+    data = request.get_json()
+    
+    if 'user_agent' in data:
+        config.set_user_agent(data['user_agent'])
+    
+    if 'max_workers' in data:
+        config.set_max_workers(int(data['max_workers']))
+    
+    if 'headless' in data:
+        config.set_headless(bool(data['headless']))
+    
+    if 'browser_fingerprint' in data:
+        config.set_browser_fingerprint(data['browser_fingerprint'])
+    
+    return jsonify({
+        'success': True,
+        'message': '设置已更新'
+    })
+
+
+@app.route('/api/email-configs', methods=['GET'])
+@requires_auth
+def get_email_configs():
+    """获取邮箱配置列表"""
+    return jsonify({
+        'success': True,
+        'configs': config.get_email_configs_safe()
+    })
+
+
+@app.route('/api/email-configs', methods=['POST'])
+@requires_auth
+def add_email_config():
+    """添加邮箱配置"""
+    data = request.get_json()
+    
+    worker_domain = data.get('worker_domain', '')
+    email_domain = data.get('email_domain', '')
+    admin_password = data.get('admin_password', '')
+    
+    if not all([worker_domain, email_domain, admin_password]):
+        return jsonify({
+            'success': False,
+            'error': '缺少必要参数'
+        }), 400
+    
+    config.add_email_config(worker_domain, email_domain, admin_password)
+    
+    return jsonify({
+        'success': True,
+        'message': '邮箱配置已添加'
+    })
+
+
+@app.route('/api/email-configs/<int:index>', methods=['PUT'])
+@requires_auth
+def update_email_config(index: int):
+    """更新邮箱配置"""
+    data = request.get_json()
+    
+    try:
+        config.update_email_config(
+            index,
+            data.get('worker_domain'),
+            data.get('email_domain'),
+            data.get('admin_password')
+        )
+        return jsonify({
+            'success': True,
+            'message': '邮箱配置已更新'
+        })
+    except IndexError:
+        return jsonify({
+            'success': False,
+            'error': '配置不存在'
+        }), 404
+
+
+@app.route('/api/email-configs/<int:index>', methods=['DELETE'])
+@requires_auth
+def delete_email_config(index: int):
+    """删除邮箱配置"""
+    try:
+        config.delete_email_config(index)
+        return jsonify({
+            'success': True,
+            'message': '邮箱配置已删除'
+        })
+    except IndexError:
+        return jsonify({
+            'success': False,
+            'error': '配置不存在'
+        }), 404
+
+
+@app.route('/api/status', methods=['GET'])
+@requires_auth
+def get_status():
+    """获取系统状态"""
+    with accounts_lock:
+        total = len(accounts)
+        success = sum(1 for acc in accounts.values() if acc.status == AccountStatus.SUCCESS)
+        creating = sum(1 for acc in accounts.values() if acc.status in [
+            AccountStatus.PENDING, AccountStatus.CREATING_EMAIL,
+            AccountStatus.ENTERING_EMAIL, AccountStatus.WAITING_CODE,
+            AccountStatus.VERIFYING, AccountStatus.COMPLETING
+        ])
+        updating = sum(1 for acc in accounts.values() if acc.status == AccountStatus.UPDATING)
+        failed = sum(1 for acc in accounts.values() if acc.status == AccountStatus.FAILED)
+    
+    with workers_lock:
+        active_workers = sum(1 for w in workers.values() if w.is_alive())
+    
+    return jsonify({
+        'success': True,
+        'status': {
+            'accounts': {
+                'total': total,
+                'success': success,
+                'creating': creating,
+                'updating': updating,
+                'failed': failed
+            },
+            'workers': {
+                'active': active_workers,
+                'max': config.get_max_workers()
+            },
+            'queue_size': task_queue.qsize()
+        }
+    })
+
+
+@app.route('/api/screenshot', methods=['GET'])
+@requires_auth
+def get_screenshot():
+    """获取浏览器截图"""
+    email = request.args.get('email')
+    
+    if email:
+        # 获取特定账号的截图
+        target_worker = None
+        with workers_lock:
+            for worker in workers.values():
+                if worker.account.email == email:
+                    target_worker = worker
+                    break
+        
+        if not target_worker:
+            return jsonify({
+                'success': False,
+                'error': '未找到该账号的运行实例'
+            }), 404
+            
+        screenshot = target_worker.get_screenshot()
+        if screenshot:
+            return jsonify({
+                'success': True,
+                'email': email,
+                'image': f'![screenshot](data:image/png;base64,{screenshot})'
+            })
+        else:
+            return jsonify({
+                'success': False,
+                'error': '截图失败'
+            }), 500
+            
+    else:
+        # 获取所有活跃实例的截图
+        results = []
+        with workers_lock:
+            active_workers = list(workers.values())
+            
+        for worker in active_workers:
+            if worker.is_alive():
+                screenshot = worker.get_screenshot()
+                if screenshot:
+                    results.append({
+                        'email': worker.account.email,
+                        'image': f'![screenshot](data:image/png;base64,{screenshot})'
+                    })
+        
+        return jsonify({
+            'success': True,
+            'screenshots': results
+        })
+
+
+# 后台任务处理器
+def background_task_processor():
+    """后台任务处理器"""
+    while True:
+        try:
+            task = task_queue.get(timeout=1)
+            if task is None:
+                break
+            
+            mode, account = task
+            worker_id = get_available_worker_slot()
+            
+            if worker_id is not None:
+                start_worker(worker_id, account, mode=mode)
+            else:
+                task_queue.put(task)
+                time.sleep(1)
+                
+        except queue.Empty:
+            continue
+        except Exception as e:
+            logger.error(f"后台任务处理器错误: {e}")
+
+
+# 启动后台任务处理器
+task_processor_thread = threading.Thread(target=background_task_processor, daemon=True)
+task_processor_thread.start()
+
+
+if __name__ == '__main__':
+    port = int(os.getenv('PORT', 5000))
+    debug = os.getenv('DEBUG', 'false').lower() == 'true'
+    logger.info(f"启动 Flask 应用, http://127.0.0.1:{port}")
+    app.run(host='0.0.0.0', port=port, debug=debug, threaded=True)

browser_worker.py

@@ -0,0 +1,881 @@
+import re
+import time
+import random
+import threading
+from enum import Enum
+from typing import Optional, Callable
+from dataclasses import dataclass, field
+from datetime import datetime
+from urllib.parse import urlparse, parse_qs
+import logging
+
+from DrissionPage import Chromium, ChromiumOptions
+
+from email_manager import EmailManager
+
+logger = logging.getLogger(__name__)
+
+class AccountStatus(Enum):
+    PENDING = "pending"
+    CREATING_EMAIL = "creating_email"
+    OPENING_PAGE = "opening_page"
+    ENTERING_EMAIL = "entering_email"
+    WAITING_CODE = "waiting_code"
+    ENTERING_CODE = "entering_code"
+    VERIFYING = "verifying"
+    ENTERING_NAME = "entering_name"
+    AGREEING = "agreeing"
+    WAITING_REDIRECT = "waiting_redirect"
+    COMPLETING = "completing"
+    EXTRACTING_DATA = "extracting_data"
+    SUCCESS = "success"
+    FAILED = "failed"
+    UPDATING = "updating"
+
+
+@dataclass
+class AccountInfo:
+    email: str = ""
+    jwt: str = ""
+    status: AccountStatus = AccountStatus.PENDING
+    error_message: str = ""
+    verification_code: str = ""
+    c_oses: str = ""
+    c_ses: str = ""
+    csesidx: str = ""
+    config_id: str = ""
+    created_at: str = ""
+    updated_at: str = ""
+    email_config: dict = field(default_factory=dict)
+    
+    def to_dict(self) -> dict:
+        return {
+            "email": self.email,
+            "status": self.status.value,
+            "error_message": self.error_message,
+            "verification_code": self.verification_code,
+            "c_oses": self.c_oses,
+            "c_ses": self.c_ses,
+            "csesidx": self.csesidx,
+            "config_id": self.config_id,
+            "created_at": self.created_at,
+            "updated_at": self.updated_at,
+            "is_complete": self.is_complete()
+        }
+    
+    def to_export_dict(self) -> dict:
+        """导出格式，包含时间戳"""
+        return {
+            "available": True,
+            "csesidx": self.csesidx,
+            "host_c_oses": self.c_oses,
+            "secure_c_ses": self.c_ses,
+            "team_id": self.config_id,
+            "user_agent": "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/142.0.0.0 Safari/537.36",
+            "created_at": self.created_at or datetime.now().isoformat(),
+            "updated_at": self.updated_at or self.created_at or datetime.now().isoformat()
+        }
+    
+    def is_complete(self) -> bool:
+        return all([
+            self.c_oses,
+            self.c_ses,
+            self.csesidx,
+            self.config_id
+        ])
+
+
+class BrowserWorker(threading.Thread):
+    """浏览器工作线程"""
+    
+    def __init__(
+        self,
+        worker_id: int,
+        account: AccountInfo,
+        config,
+        mode: str = "register",
+        on_update: Optional[Callable] = None,
+        on_complete: Optional[Callable] = None
+    ):
+        super().__init__(daemon=True)
+        self.worker_id = worker_id
+        self.account = account
+        self.config = config
+        self.mode = mode
+        self.on_update = on_update
+        self.on_complete = on_complete
+        self.is_running = True
+        self.browser: Optional[Chromium] = None
+        self.page = None
+    
+    def update_status(self, status: AccountStatus, error: str = ""):
+        """更新状态"""
+        self.account.status = status
+        self.account.error_message = error
+        self.account.updated_at = datetime.now().isoformat()
+        if self.on_update:
+            self.on_update(self.account.email, self.account)
+    
+    def create_browser(self) -> bool:
+        """创建浏览器实例"""
+        try:
+            self.close_browser()
+            
+            options = ChromiumOptions().auto_port()
+            # 设置浏览器路径
+            browser_path = self.config.get_browser_path()
+            if browser_path:
+                options.set_browser_path(browser_path)
+                logger.info(f"[{self.worker_id}] 使用浏览器: {browser_path}")
+
+            ua = self.config.get_user_agent()
+            options.set_user_agent(ua)
+            
+            if self.config.get_headless():
+                options.set_argument('--headless=new')
+            options.set_argument('--incognito')
+            
+            options.set_argument('--disable-blink-features=AutomationControlled')
+            options.set_argument('--no-sandbox')
+            options.set_argument('--disable-dev-shm-usage')
+            options.set_argument('--disable-gpu')
+            options.set_argument('--lang=zh-CN')
+            options.set_argument('--disable-web-security')
+            options.set_argument('--disable-features=VizDisplayCompositor')
+            
+            fingerprint = self.config.get_browser_fingerprint()
+            if fingerprint:
+                if fingerprint.get('window_size'):
+                    w, h = fingerprint['window_size'].split('x')
+                    options.set_argument(f'--window-size={w},{h}')
+                
+                if fingerprint.get('timezone'):
+                    options.set_argument(f'--timezone={fingerprint["timezone"]}')
+                
+                if fingerprint.get('locale'):
+                    options.set_argument(f'--lang={fingerprint["locale"]}')
+            
+            options.set_argument('--disable-reading-from-canvas')
+            options.set_pref('credentials_enable_service', False)
+            options.set_pref('profile.password_manager_enabled', False)
+            
+            self.browser = Chromium(options)
+            self.page = self.browser.latest_tab
+            
+            self._inject_fingerprint_script()
+            
+            return True
+            
+        except Exception as e:
+            logger.error(f"创建浏览器失败: {e}")
+            return False
+    
+    def _inject_fingerprint_script(self):
+        """注入指纹混淆脚本"""
+        script = '''
+        Object.defineProperty(navigator, 'webdriver', { get: () => undefined });
+        Object.defineProperty(navigator, 'plugins', { get: () => [1, 2, 3, 4, 5] });
+        Object.defineProperty(navigator, 'languages', { get: () => ['zh-CN', 'zh', 'en'] });
+        window.chrome = { runtime: {} };
+        '''
+        try:
+            self.page.run_js(script)
+        except:
+            pass
+    
+    def close_browser(self):
+        """关闭浏览器"""
+        if self.browser:
+            try:
+                self.browser.quit()
+            except:
+                pass
+            finally:
+                self.browser = None
+                self.page = None
+    
+    def get_screenshot(self) -> Optional[str]:
+        """获取当前页面截图 (Base64)"""
+        if self.page:
+            try:
+                return self.page.get_screenshot(as_base64=True, full_page=False)
+            except Exception as e:
+                logger.error(f"截图失败: {e}")
+                return None
+        return None
+    
+    def safe_input(self, selector: str, text: str, max_retries: int = 3) -> bool:
+        """安全输入文本"""
+        for attempt in range(max_retries):
+            try:
+                ele = self.page.ele(selector, timeout=10)
+                if not ele:
+                    continue
+                
+                ele.clear()
+                time.sleep(0.3)
+                clean_text = ''.join(c for c in text if ord(c) < 128)
+                ele.input(clean_text)
+                time.sleep(0.5)
+                
+                input_value = ele.attr('value') or ele.value
+                if input_value and clean_text in input_value:
+                    return True
+                else:
+                    ele.clear()
+                    time.sleep(0.5)
+                    
+            except Exception as e:
+                logger.error(f"输入失败: {e}")
+                time.sleep(1)
+        
+        return False
+
+    def wait_and_input(self, selector: str, text: str, timeout: float = 10, description: str = "") -> bool:
+        """等待元素并输入"""
+        try:
+            ele = self.page.ele(selector, timeout=timeout)
+            if ele:
+                ele.clear()
+                ele.input(text)
+                logger.info(f"输入成功: {description}")
+                return True
+            else:
+                logger.warning(f"未找到输入框: {description}")
+                return False
+        except Exception as e:
+            logger.error(f"输入失败 {description}: {e}")
+            return False
+
+    def wait_and_click(self, selector: str, timeout: float = 10) -> bool:
+        """等待并点击元素"""
+        try:
+            ele = self.page.ele(selector, timeout=timeout)
+            if ele:
+                ele.click()
+                return True
+            return False
+        except Exception as e:
+            logger.error(f"点击失败: {e}")
+            return False
+    
+    def wait_for_url_pattern(self, pattern: str, timeout: float = 60) -> bool:
+        """等待URL匹配模式"""
+        start_time = time.time()
+        while time.time() - start_time < timeout:
+            if not self.is_running:
+                return False
+            try:
+                current_url = self.page.url
+                if re.search(pattern, current_url):
+                    return True
+            except:
+                pass
+            time.sleep(1)
+        return False
+    
+    def wait_for_element(self, selector: str, timeout: float = 30) -> bool:
+        """等待元素出现"""
+        start_time = time.time()
+        while time.time() - start_time < timeout:
+            if not self.is_running:
+                return False
+            try:
+                ele = self.page.ele(selector, timeout=1)
+                if ele:
+                    return True
+            except:
+                pass
+            time.sleep(0.5)
+        return False
+    
+    def extract_data(self) -> bool:
+        """提取数据"""
+        try:
+            cookies = self.page.cookies()
+            for cookie in cookies:
+                name = cookie.get('name', '')
+                if name == '__Host-C_OSES':
+                    self.account.c_oses = cookie.get('value', '')
+                elif name == '__Secure-C_SES':
+                    self.account.c_ses = cookie.get('value', '')
+            
+            current_url = self.page.url
+            parsed = urlparse(current_url)
+            query_params = parse_qs(parsed.query)
+            self.account.csesidx = query_params.get('csesidx', [''])[0]
+            
+            path_match = re.search(r'/cid/([a-f0-9-]+)', parsed.path)
+            if path_match:
+                self.account.config_id = path_match.group(1)
+            
+            # 设置更新时间
+            self.account.updated_at = datetime.now().isoformat()
+            
+            return self.account.is_complete()
+            
+        except Exception as e:
+            logger.error(f"提取数据失败: {e}")
+            return False
+    
+    def handle_welcome_dialog(self) -> bool:
+        """处理欢迎对话框"""
+        try:
+            time.sleep(2)
+            
+            try:
+                app_ele = self.page.ele('tag:ucs-standalone-app', timeout=5)
+                if app_ele:
+                    sr1 = app_ele.shadow_root
+                    if sr1:
+                        dialog_ele = sr1.ele('tag:ucs-welcome-dialog', timeout=3)
+                        if dialog_ele:
+                            sr2 = dialog_ele.shadow_root
+                            if sr2:
+                                btn_ele = sr2.ele('tag:md-text-button', timeout=3)
+                                if btn_ele:
+                                    sr3 = btn_ele.shadow_root
+                                    if sr3:
+                                        inner_btn = sr3.ele('tag:button', timeout=3)
+                                        if inner_btn:
+                                            inner_btn.click()
+                                            return True
+            except:
+                pass
+            
+            try:
+                js_code = '''
+                function clickWelcomeButton() {
+                    const app = document.querySelector('ucs-standalone-app');
+                    if (app && app.shadowRoot) {
+                        const dialog = app.shadowRoot.querySelector('ucs-welcome-dialog');
+                        if (dialog && dialog.shadowRoot) {
+                            const btn = dialog.shadowRoot.querySelector('md-text-button');
+                            if (btn) {
+                                if (btn.shadowRoot) {
+                                    const innerBtn = btn.shadowRoot.querySelector('button');
+                                    if (innerBtn) { innerBtn.click(); return true; }
+                                }
+                                btn.click();
+                                return true;
+                            }
+                        }
+                    }
+                    return false;
+                }
+                return clickWelcomeButton();
+                '''
+                result = self.page.run_js(js_code)
+                return bool(result)
+            except:
+                pass
+            
+            return False
+            
+        except:
+            return False
+    
+    def click_verify_button(self) -> bool:
+        """点击验证按钮"""
+        verify_selectors = [
+            'xpath://button[@jsname="XooR8e"]',
+            'xpath://button[@aria-label="验证"]',
+            'xpath://button[contains(@class, "YUhpIc-LgbsSe") and @type="submit"]',
+            'xpath://button[.//span[contains(text(), "验证")]]',
+            'css:button[jsname="XooR8e"]',
+            'css:button[aria-label="验证"]',
+        ]
+        
+        for selector in verify_selectors:
+            try:
+                ele = self.page.ele(selector, timeout=3)
+                if ele:
+                    time.sleep(0.5)
+                    ele.click()
+                    logger.info(f"成功点击验证按钮: {selector}")
+                    return True
+            except:
+                continue
+        
+        try:
+            js_code = '''
+            const buttons = document.querySelectorAll('button');
+            for (const btn of buttons) {
+                if (btn.getAttribute('jsname') === 'XooR8e' || 
+                    btn.getAttribute('aria-label') === '验证' ||
+                    btn.innerText.includes('验证')) {
+                    btn.click();
+                    return true;
+                }
+            }
+            return false;
+            '''
+            result = self.page.run_js(js_code)
+            if result:
+                logger.info("通过 JavaScript 成功点击验证按钮")
+                return True
+        except:
+            pass
+        
+        return False
+    
+    def click_resend_button(self) -> bool:
+        """点��重新发送按钮"""
+        resend_selectors = [
+            'button[aria-label="Resend Code"]',
+            'button[aria-label="重新发送"]',
+            'xpath://button[contains(., "Resend")]',
+            'xpath://button[contains(., "重新发送验证码")]',
+        ]
+        
+        for sel in resend_selectors:
+            if self.wait_and_click(sel, timeout=5):
+                logger.info(f"[{self.worker_id}] 已点击重新发送按钮")
+                return True
+        
+        return False
+
+    def get_verification_code_with_retry(self, email_manager) -> Optional[str]:
+        """带重试机制的获取验证码"""
+        max_loops = 1
+        
+        for i in range(max_loops):
+            logger.info(f"[{self.worker_id}] 第 {i+1} 次尝试获取验证码流程")
+            
+            # 1. 第一次检测 (15次)
+            logger.info(f"[{self.worker_id}] 正在检测邮件 (10次尝试)...")
+            code = email_manager.check_verification_code(self.account.email, max_retries=10)
+            if code:
+                return code
+            
+            # 2. 如果没收到，检测是否有重发按钮
+            logger.info(f"[{self.worker_id}] 未收到邮件，检查重发按钮...")
+            if self.click_resend_button():
+                logger.info(f"[{self.worker_id}] 点击了重发按钮，等待邮件发送...")
+                time.sleep(10) # 等待邮件发送
+                continue # 重新开始循环，会再次检测邮件
+            
+            # 3. 如果没有重发按钮，继续等待15次
+            logger.info(f"[{self.worker_id}] 未找到重发按钮，继续等待邮件 (10次尝试)...")
+            code = email_manager.check_verification_code(self.account.email, max_retries=10)
+            if code:
+                return code
+                
+            # 4. 再次检测重发按钮
+            logger.info(f"[{self.worker_id}] 仍未收到邮件，再次检查重发按钮...")
+            if self.click_resend_button():
+                logger.info(f"[{self.worker_id}] 点击了重发按钮，等待邮件发送...")
+                time.sleep(10)
+                continue
+            else:
+                logger.warning(f"[{self.worker_id}] 无法找到重发按钮且未收到邮件，本轮失败")
+                return None
+                
+        return None
+
+    def register_account(self) -> bool:
+        """注册账号"""
+        try:
+            self.update_status(AccountStatus.OPENING_PAGE)
+            logger.info(f"[{self.worker_id}] 正在打开页面...")
+            
+            self.page.get('https://business.gemini.google')
+            
+            email_input_selectors = [
+                'xpath://input[@id="email-input"]',
+                'xpath://input[@name="loginHint"]',
+                '#email-input',
+            ]
+            
+            email_input_found = False
+            for selector in email_input_selectors:
+                if self.wait_for_element(selector, timeout=30):
+                    email_input_found = True
+                    break
+            
+            if not email_input_found:
+                raise Exception("等待邮箱输入框超时")
+            
+            time.sleep(1)
+            
+            self.update_status(AccountStatus.ENTERING_EMAIL)
+            logger.info(f"[{self.worker_id}] 正在输入邮箱: {self.account.email}")
+            
+            input_success = False
+            for selector in email_input_selectors:
+                if self.safe_input(selector, self.account.email):
+                    input_success = True
+                    break
+            
+            if not input_success:
+                raise Exception("无法输入邮箱")
+            
+            time.sleep(1)
+            
+            continue_selectors = [
+                'xpath://button[@id="log-in-button"]',
+                'xpath://button[contains(@aria-label, "使用邮箱继续")]',
+                '#log-in-button',
+            ]
+            
+            clicked = False
+            for selector in continue_selectors:
+                if self.wait_and_click(selector, timeout=5):
+                    clicked = True
+                    break
+            
+            if not clicked:
+                raise Exception("无法点击继续按钮")
+            
+            time.sleep(2)
+            
+            self.update_status(AccountStatus.WAITING_CODE)
+            logger.info(f"[{self.worker_id}] 正在等待验证码...")
+            
+            email_manager = EmailManager(
+                self.account.email_config.get('worker_domain', ''),
+                self.account.email_config.get('email_domain', ''),
+                self.account.email_config.get('admin_password', '')
+            )
+            
+            verification_code = self.get_verification_code_with_retry(email_manager)
+            
+            if not verification_code:
+                raise Exception("未收到验证码 (已重试)")
+            
+            self.account.verification_code = verification_code
+            logger.info(f"[{self.worker_id}] 获取到验证码: {verification_code}")
+            
+            self.update_status(AccountStatus.ENTERING_CODE)
+            
+            code_input_selectors = [
+                'xpath://input[@name="pinInput"]',
+                'xpath://input[contains(@aria-label, "验证码")]',
+                'input[name="pinInput"]',
+            ]
+            logger.info(f"[{self.worker_id}] 正在输入验证码: {self.account.email}")
+            input_success = False
+            for selector in code_input_selectors:
+                if self.wait_and_input(selector, verification_code, timeout=10, description="验证码输入框"):
+                    input_success = True
+                    break
+            
+            if not input_success:
+                raise Exception("无法输入验证码")
+            
+            time.sleep(1)
+            
+            self.update_status(AccountStatus.VERIFYING)
+            
+            if not self.click_verify_button():
+                raise Exception("无法点击验证按钮")
+            
+            time.sleep(3)
+
+            # 检查验证码错误并重试
+            if self.page.ele('text:请输入验证码。', timeout=2):
+                logger.warning(f"[{self.worker_id}] 验证码失效，尝试重新发送...")
+                
+                resend_selectors = [
+                    'button[aria-label="重新发送验证码"]',
+                    'xpath://button[contains(., "重新发送验证码")]'
+                ]
+                
+                resend_clicked = False
+                for sel in resend_selectors:
+                    if self.wait_and_click(sel, timeout=5):
+                        resend_clicked = True
+                        break
+                
+                if resend_clicked:
+                    logger.info(f"[{self.worker_id}] 已点击重新发送，等待新验证码...")
+                    time.sleep(10) # 等待邮件发送
+                    
+                    verification_code = email_manager.check_verification_code(self.account.email)
+                    if not verification_code:
+                         raise Exception("重发后未收到验证码")
+                    
+                    self.account.verification_code = verification_code
+                    logger.info(f"[{self.worker_id}] 获取到新验证码: {verification_code}")
+                    
+                    input_success = False
+                    for selector in code_input_selectors:
+                        if self.wait_and_input(selector, verification_code, timeout=10, description="验证码输入框"):
+                            input_success = True
+                            break
+                    
+                    if input_success:
+                        time.sleep(1)
+                        if not self.click_verify_button():
+                            raise Exception("无法点击验证按钮(重试)")
+                        time.sleep(3)
+                    else:
+                        raise Exception("无法重新输入验证码")
+                else:
+                    logger.warning(f"[{self.worker_id}] 未找到重新发送按钮")
+            
+            self.update_status(AccountStatus.ENTERING_NAME)
+            
+            fullname = ''.join(random.choices('abcdefghijklmnopqrstuvwxyz', k=5))
+            name_selectors = [
+                'xpath://input[@formcontrolname="fullName"]',
+                'xpath://input[@placeholder="全名"]',
+                'input[formcontrolname="fullName"]',
+            ]
+            
+            name_input_found = False
+            for selector in name_selectors:
+                if self.wait_for_element(selector, timeout=15):
+                    name_input_found = True
+                    break
+            
+            if not name_input_found:
+                raise Exception("等待姓名输入框超时")
+            
+            input_success = False
+            for selector in name_selectors:
+                if self.safe_input(selector, fullname):
+                    input_success = True
+                    break
+            
+            if not input_success:
+                raise Exception("无法输入姓名")
+            
+            time.sleep(1)
+            
+            self.update_status(AccountStatus.AGREEING)
+            
+            agree_selectors = [
+                'xpath://button[contains(@class, "agree-button")]',
+                'xpath://button[contains(., "同意并开始使用")]',
+                'xpath://button[contains(., "同意")]',
+                'button.agree-button',
+            ]
+            
+            clicked = False
+            for selector in agree_selectors:
+                if self.wait_and_click(selector, timeout=5):
+                    clicked = True
+                    break
+            
+            if not clicked:
+                raise Exception("无法点击同意按钮")
+            
+            self.update_status(AccountStatus.WAITING_REDIRECT)
+            
+            target_pattern = r'business\.gemini\.google/home/cid/[a-f0-9-]+\?csesidx=\d+'
+            if not self.wait_for_url_pattern(target_pattern, timeout=90):
+                current_url = self.page.url
+                if '/admin/create' in current_url:
+                    time.sleep(15)
+                    if not self.wait_for_url_pattern(target_pattern, timeout=120):
+                        raise Exception("页面跳转超时")
+                else:
+                    raise Exception("页面跳转超时")
+            
+            time.sleep(3)
+            
+            self.update_status(AccountStatus.COMPLETING)
+            self.handle_welcome_dialog()
+            time.sleep(2)
+            
+            self.update_status(AccountStatus.EXTRACTING_DATA)
+            
+            if self.extract_data():
+                # 设置创建时间
+                if not self.account.created_at:
+                    self.account.created_at = datetime.now().isoformat()
+                self.update_status(AccountStatus.SUCCESS)
+                logger.info(f"[{self.worker_id}] 注册成功!")
+                return True
+            else:
+                raise Exception("未能获取完整数据")
+            
+        except Exception as e:
+            error_msg = str(e)
+            logger.error(f"[{self.worker_id}] 注册失败: {error_msg}")
+            self.update_status(AccountStatus.FAILED, error_msg)
+            return False
+    
+    def refresh_account(self) -> bool:
+        """刷新账号Cookie"""
+        try:
+            self.update_status(AccountStatus.UPDATING)
+            logger.info(f"[{self.worker_id}] 正在刷新账号: {self.account.email}")
+            
+            self.page.get('https://business.gemini.google')
+            
+            email_input_selectors = [
+                'xpath://input[@id="email-input"]',
+                'xpath://input[@name="loginHint"]',
+                '#email-input',
+            ]
+            logger.info(f"[{self.worker_id}] 正在等待邮箱输入框: {self.account.email}")
+            email_input_found = False
+            for selector in email_input_selectors:
+                if self.wait_for_element(selector, timeout=30):
+                    email_input_found = True
+                    break
+            
+            if not email_input_found:
+                raise Exception("等待邮箱输入框超时")
+            
+            time.sleep(1)
+            
+            input_success = False
+            for selector in email_input_selectors:
+                if self.safe_input(selector, self.account.email):
+                    input_success = True
+                    break
+            
+            if not input_success:
+                raise Exception("无法输入邮箱")
+            
+            time.sleep(1)
+            
+            logger.info(f"[{self.worker_id}] 正在点击继续按钮: {self.account.email}")
+            continue_selectors = [
+                'xpath://button[@id="log-in-button"]',
+                'xpath://button[contains(@aria-label, "使用邮箱继续")]',
+                '#log-in-button',
+            ]
+            
+            clicked = False
+            for selector in continue_selectors:
+                if self.wait_and_click(selector, timeout=5):
+                    clicked = True
+                    break
+            
+            if not clicked:
+                raise Exception("无法点击继续按钮")
+            
+            time.sleep(2)
+            
+            email_manager = EmailManager(
+                self.account.email_config.get('worker_domain', ''),
+                self.account.email_config.get('email_domain', ''),
+                self.account.email_config.get('admin_password', '')
+            )
+
+            logger.info(f"[{self.worker_id}] 正在获取邮箱验证码: {self.account.email}")
+            verification_code = self.get_verification_code_with_retry(email_manager)
+            
+            if not verification_code:
+                raise Exception("未收到验证码 (已重试)")
+            
+            self.account.verification_code = verification_code
+            
+            code_input_selectors = [
+                'xpath://input[@name="pinInput"]',
+                'xpath://input[contains(@aria-label, "验证码")]',
+                'input[name="pinInput"]',
+            ]
+            logger.info(f"[{self.worker_id}] 正在输入验证码: {self.account.email}")
+            input_success = False
+            for selector in code_input_selectors:
+                if self.wait_and_input(selector, verification_code, timeout=10, description="验证码输入框"):
+                    input_success = True
+                    break
+            
+            if not input_success:
+                raise Exception("无法输入验证码")
+            
+            time.sleep(1)
+            
+            if not self.click_verify_button():
+                raise Exception("无法点击验证按钮")
+            
+            time.sleep(3)
+
+            # 检查验证码错误并重试
+            if self.page.ele('text:请输入验证码。', timeout=2):
+                logger.warning(f"[{self.worker_id}] 验证码失效，尝试重新发送...")
+                
+                resend_selectors = [
+                    'button[aria-label="重新发送验证码"]',
+                    'xpath://button[contains(., "重新发送验证码")]'
+                ]
+                
+                resend_clicked = False
+                for sel in resend_selectors:
+                    if self.wait_and_click(sel, timeout=5):
+                        resend_clicked = True
+                        break
+                
+                if resend_clicked:
+                    logger.info(f"[{self.worker_id}] 已点击重新发送，等待新验证码...")
+                    time.sleep(10) # 等待邮件发送
+                    
+                    verification_code = email_manager.check_verification_code(self.account.email)
+                    if not verification_code:
+                         raise Exception("重发后未收到验证码")
+                    
+                    self.account.verification_code = verification_code
+                    logger.info(f"[{self.worker_id}] 获取到新验证码: {verification_code}")
+                    
+                    input_success = False
+                    for selector in code_input_selectors:
+                        if self.wait_and_input(selector, verification_code, timeout=10, description="验证码输入框"):
+                            input_success = True
+                            break
+                    
+                    if input_success:
+                        time.sleep(1)
+                        if not self.click_verify_button():
+                            raise Exception("无法点击验证按钮(重试)")
+                        time.sleep(3)
+                    else:
+                        raise Exception("无法重新输入验证码")
+                else:
+                    logger.warning(f"[{self.worker_id}] 未找到重新发送按钮")
+
+            logger.info(f"[{self.worker_id}] 正在等待跳转: {self.account.email}")
+            
+            target_pattern = r'business\.gemini\.google/home/cid/[a-f0-9-]+\?csesidx=\d+'
+            if not self.wait_for_url_pattern(target_pattern, timeout=120):
+                raise Exception("页面跳转超时")
+            
+            time.sleep(3)
+            
+            self.handle_welcome_dialog()
+            time.sleep(2)
+            
+            if self.extract_data():
+                self.account.updated_at = datetime.now().isoformat()
+                self.update_status(AccountStatus.SUCCESS)
+                logger.info(f"[{self.worker_id}] 刷新成功!")
+                return True
+            else:
+                raise Exception("未能获取完整数据")
+            
+        except Exception as e:
+            error_msg = str(e)
+            logger.error(f"[{self.worker_id}] 刷新失败: {error_msg}")
+            self.update_status(AccountStatus.FAILED, error_msg)
+            return False
+    
+    def run(self):
+        """运行工作线程"""
+        success = False
+        
+        try:
+            if not self.create_browser():
+                self.update_status(AccountStatus.FAILED, "创建浏览器失败")
+                return
+            
+            if self.mode == "register":
+                success = self.register_account()
+            else:
+                success = self.refresh_account()
+                
+        except Exception as e:
+            self.update_status(AccountStatus.FAILED, str(e))
+        finally:
+            self.close_browser()
+            if self.on_complete:
+                self.on_complete(self.worker_id, self.account.email, success)
+    
+    def stop(self):
+        """停止工作线程"""
+        self.is_running = False
+        self.close_browser()

config.py

@@ -0,0 +1,617 @@
+import os
+import sys
+import glob
+import random
+import threading
+import shutil
+import platform
+import subprocess
+from typing import List, Dict, Optional
+import logging
+
+def setup_logging():
+    """配置日志"""
+    logging.basicConfig(
+        level=logging.INFO,
+        format='%(asctime)s - %(name)s - %(levelname)s - %(message)s',
+        datefmt='%Y-%m-%d %H:%M:%S'
+    )
+
+logger = logging.getLogger(__name__)
+
+
+class BrowserPathFinder:
+    """跨平台浏览器路径查找器"""
+    
+    # 浏览器可执行文件名（按优先级排序）
+    BROWSER_EXECUTABLES = {
+        'windows': [
+            'chrome.exe',
+            'msedge.exe',
+            'chromium.exe',
+            'brave.exe',
+            'vivaldi.exe',
+            'opera.exe',
+        ],
+        'darwin': [  # macOS
+            'Google Chrome',
+            'Chromium',
+            'Microsoft Edge',
+            'Brave Browser',
+            'Vivaldi',
+            'Opera',
+        ],
+        'linux': [
+            'google-chrome',
+            'google-chrome-stable',
+            'google-chrome-beta',
+            'google-chrome-dev',
+            'google-chrome-unstable',
+            'chromium',
+            'chromium-browser',
+            'microsoft-edge',
+            'microsoft-edge-stable',
+            'microsoft-edge-beta',
+            'microsoft-edge-dev',
+            'brave-browser',
+            'brave-browser-stable',
+            'brave',
+            'vivaldi',
+            'vivaldi-stable',
+            'opera',
+            'opera-stable',
+            'chrome',  # 通用名称
+        ],
+    }
+    
+    # 各平台常见安装路径
+    COMMON_PATHS = {
+        'windows': [
+            # Chrome
+            os.path.expandvars(r'%ProgramFiles%\Google\Chrome\Application'),
+            os.path.expandvars(r'%ProgramFiles(x86)%\Google\Chrome\Application'),
+            os.path.expandvars(r'%LocalAppData%\Google\Chrome\Application'),
+            # Edge
+            os.path.expandvars(r'%ProgramFiles%\Microsoft\Edge\Application'),
+            os.path.expandvars(r'%ProgramFiles(x86)%\Microsoft\Edge\Application'),
+            os.path.expandvars(r'%LocalAppData%\Microsoft\Edge\Application'),
+            # Brave
+            os.path.expandvars(r'%ProgramFiles%\BraveSoftware\Brave-Browser\Application'),
+            os.path.expandvars(r'%LocalAppData%\BraveSoftware\Brave-Browser\Application'),
+            # Chromium
+            os.path.expandvars(r'%LocalAppData%\Chromium\Application'),
+            # Vivaldi
+            os.path.expandvars(r'%LocalAppData%\Vivaldi\Application'),
+            # Opera
+            os.path.expandvars(r'%LocalAppData%\Programs\Opera'),
+            # Playwright
+            os.path.expandvars(r'%LocalAppData%\ms-playwright'),
+            os.path.expandvars(r'%UserProfile%\.cache\ms-playwright'),
+            # Puppeteer
+            os.path.expandvars(r'%LocalAppData%\puppeteer'),
+            os.path.expandvars(r'%UserProfile%\.cache\puppeteer'),
+        ],
+        'darwin': [  # macOS
+            # 标准应用目录
+            '/Applications',
+            os.path.expanduser('~/Applications'),
+            # Chrome
+            '/Applications/Google Chrome.app/Contents/MacOS',
+            os.path.expanduser('~/Applications/Google Chrome.app/Contents/MacOS'),
+            # Chromium
+            '/Applications/Chromium.app/Contents/MacOS',
+            os.path.expanduser('~/Applications/Chromium.app/Contents/MacOS'),
+            # Edge
+            '/Applications/Microsoft Edge.app/Contents/MacOS',
+            os.path.expanduser('~/Applications/Microsoft Edge.app/Contents/MacOS'),
+            # Brave
+            '/Applications/Brave Browser.app/Contents/MacOS',
+            os.path.expanduser('~/Applications/Brave Browser.app/Contents/MacOS'),
+            # Vivaldi
+            '/Applications/Vivaldi.app/Contents/MacOS',
+            # Opera
+            '/Applications/Opera.app/Contents/MacOS',
+            # Homebrew
+            '/opt/homebrew/bin',
+            '/usr/local/bin',
+            '/opt/homebrew/Caskroom/google-chrome/latest/Google Chrome.app/Contents/MacOS',
+            # Playwright
+            os.path.expanduser('~/.cache/ms-playwright'),
+            os.path.expanduser('~/Library/Caches/ms-playwright'),
+            # Puppeteer
+            os.path.expanduser('~/.cache/puppeteer'),
+        ],
+        'linux': [
+            # 标准路径
+            '/usr/bin',
+            '/usr/local/bin',
+            '/bin',
+            '/sbin',
+            # Chrome
+            '/opt/google/chrome',
+            '/opt/google/chrome-stable',
+            '/opt/google/chrome-beta',
+            '/opt/google/chrome-unstable',
+            # Chromium
+            '/opt/chromium',
+            '/opt/chromium-browser',
+            '/usr/lib/chromium',
+            '/usr/lib/chromium-browser',
+            '/usr/lib64/chromium-browser',
+            # Edge
+            '/opt/microsoft/msedge',
+            '/opt/microsoft/msedge-stable',
+            '/opt/microsoft/msedge-beta',
+            '/opt/microsoft/msedge-dev',
+            # Brave
+            '/opt/brave.com/brave',
+            '/opt/brave.com/brave-browser',
+            '/usr/lib/brave-browser',
+            # Snap 安装路径
+            '/snap/bin',
+            '/snap/chromium/current/usr/lib/chromium-browser',
+            '/snap/chromium/current/usr/lib/chromium',
+            '/var/lib/snapd/snap/bin',
+            # Flatpak 路径
+            '/var/lib/flatpak/exports/bin',
+            os.path.expanduser('~/.local/share/flatpak/exports/bin'),
+            # AppImage 路径
+            os.path.expanduser('~/Applications'),
+            os.path.expanduser('~/.local/bin'),
+            # Playwright
+            os.path.expanduser('~/.cache/ms-playwright'),
+            '/root/.cache/ms-playwright',
+            '/home/*/.cache/ms-playwright',
+            # Puppeteer
+            os.path.expanduser('~/.cache/puppeteer'),
+            '/root/.cache/puppeteer',
+            '/home/*/.cache/puppeteer',
+            # Docker 常见路径
+            '/headless-shell',
+            '/chrome',
+            '/chromium',
+            '/browser',
+            '/app/chrome',
+            '/app/chromium',
+            '/usr/share/chromium',
+            # NixOS
+            '/run/current-system/sw/bin',
+            os.path.expanduser('~/.nix-profile/bin'),
+        ],
+    }
+    
+    # Playwright/Puppeteer 浏览器的 glob 模式
+    GLOB_PATTERNS = [
+        # Playwright Chromium
+        os.path.expanduser('~/.cache/ms-playwright/chromium-*/chrome-linux/chrome'),
+        os.path.expanduser('~/.cache/ms-playwright/chromium-*/chrome-mac/Chromium.app/Contents/MacOS/Chromium'),
+        os.path.expanduser('~/.cache/ms-playwright/chromium-*/chrome-win/chrome.exe'),
+        '/root/.cache/ms-playwright/chromium-*/chrome-linux/chrome',
+        '/home/*/.cache/ms-playwright/chromium-*/chrome-linux/chrome',
+        # Playwright Chrome
+        os.path.expanduser('~/.cache/ms-playwright/chrome-*/chrome-linux/chrome'),
+        os.path.expanduser('~/.cache/ms-playwright/chrome-*/chrome-mac/Google Chrome for Testing.app/Contents/MacOS/Google Chrome for Testing'),
+        '/root/.cache/ms-playwright/chrome-*/chrome-linux/chrome',
+        # Puppeteer
+        os.path.expanduser('~/.cache/puppeteer/chrome/*/chrome-linux64/chrome'),
+        os.path.expanduser('~/.cache/puppeteer/chrome/*/chrome-mac-x64/Google Chrome for Testing.app/Contents/MacOS/Google Chrome for Testing'),
+        os.path.expanduser('~/.cache/puppeteer/chrome/*/chrome-win64/chrome.exe'),
+        '/root/.cache/puppeteer/chrome/*/chrome-linux64/chrome',
+        '/home/*/.cache/puppeteer/chrome/*/chrome-linux64/chrome',
+        # Windows Playwright
+        os.path.expandvars(r'%LocalAppData%\ms-playwright\chromium-*\chrome-win\chrome.exe'),
+        os.path.expandvars(r'%UserProfile%\.cache\ms-playwright\chromium-*\chrome-win\chrome.exe'),
+    ]
+    
+    @classmethod
+    def get_platform(cls) -> str:
+        """获取当前平台"""
+        system = platform.system().lower()
+        if system == 'windows':
+            return 'windows'
+        elif system == 'darwin':
+            return 'darwin'
+        else:
+            return 'linux'  # Linux 和其他 Unix-like 系统
+    
+    @classmethod
+    def find_browser(cls) -> Optional[str]:
+        """
+        查找可用的浏览器路径
+        返回找到的第一个可执行浏览器路径，未找到返回None
+        """
+        current_platform = cls.get_platform()
+        
+        # 1. 首先检查环境变量
+        for env_var in ['BROWSER_PATH', 'CHROME_PATH', 'CHROMIUM_PATH', 'CHROME_EXECUTABLE_PATH']:
+            env_path = os.getenv(env_var)
+            if env_path and cls._is_valid_executable(env_path):
+                return env_path
+        
+        # 2. 使用 which/where 命令查找
+        executables = cls.BROWSER_EXECUTABLES.get(current_platform, cls.BROWSER_EXECUTABLES['linux'])
+        for name in executables:
+            path = shutil.which(name)
+            if path and cls._is_valid_executable(path):
+                return path
+        
+        # 3. 检查 glob 模式（Playwright/Puppeteer）
+        for pattern in cls.GLOB_PATTERNS:
+            matches = glob.glob(pattern)
+            for match in sorted(matches, reverse=True):  # 优先使用最新版本
+                if cls._is_valid_executable(match):
+                    return match
+        
+        # 4. 遍历常见路径
+        common_paths = cls.COMMON_PATHS.get(current_platform, cls.COMMON_PATHS['linux'])
+        for base_path in common_paths:
+            # 处理包含通配符的路径
+            if '*' in base_path:
+                expanded_paths = glob.glob(base_path)
+            else:
+                expanded_paths = [base_path]
+            
+            for expanded_path in expanded_paths:
+                if not os.path.isdir(expanded_path):
+                    continue
+                
+                for name in executables:
+                    full_path = os.path.join(expanded_path, name)
+                    if cls._is_valid_executable(full_path):
+                        return full_path
+        
+        # 5. macOS 特殊处理：检查 .app 包
+        if current_platform == 'darwin':
+            found = cls._find_macos_app()
+            if found:
+                return found
+        
+        # 6. 递归搜索特定目录
+        search_roots = {
+            'windows': [
+                os.path.expandvars(r'%ProgramFiles%'),
+                os.path.expandvars(r'%LocalAppData%'),
+            ],
+            'darwin': [
+                '/Applications',
+                os.path.expanduser('~/Applications'),
+            ],
+            'linux': [
+                '/opt',
+                '/usr/lib',
+                '/snap',
+                os.path.expanduser('~/.cache'),
+            ],
+        }
+        
+        for search_root in search_roots.get(current_platform, []):
+            if os.path.isdir(search_root):
+                found = cls._recursive_search(search_root, executables, max_depth=4)
+                if found:
+                    return found
+        
+        # 7. Linux: 使用 find 命令（最后手段）
+        if current_platform == 'linux':
+            found = cls._find_with_command(executables)
+            if found:
+                return found
+        
+        return None
+    
+    @classmethod
+    def _is_valid_executable(cls, path: str) -> bool:
+        """检查路径是否是有效的可执行文件"""
+        if not path:
+            return False
+        
+        # 处理 Windows 路径
+        path = os.path.normpath(path)
+        
+        if not os.path.isfile(path):
+            return False
+        
+        # Windows 不需要检查执行权限
+        if cls.get_platform() == 'windows':
+            return path.lower().endswith('.exe')
+        
+        return os.access(path, os.X_OK)
+    
+    @classmethod
+    def _find_macos_app(cls) -> Optional[str]:
+        """macOS 特殊处理：查找 .app 包"""
+        app_dirs = ['/Applications', os.path.expanduser('~/Applications')]
+        app_names = [
+            ('Google Chrome.app', 'Contents/MacOS/Google Chrome'),
+            ('Chromium.app', 'Contents/MacOS/Chromium'),
+            ('Microsoft Edge.app', 'Contents/MacOS/Microsoft Edge'),
+            ('Brave Browser.app', 'Contents/MacOS/Brave Browser'),
+            ('Vivaldi.app', 'Contents/MacOS/Vivaldi'),
+            ('Opera.app', 'Contents/MacOS/Opera'),
+        ]
+        
+        for app_dir in app_dirs:
+            for app_name, executable_path in app_names:
+                full_path = os.path.join(app_dir, app_name, executable_path)
+                if cls._is_valid_executable(full_path):
+                    return full_path
+        
+        return None
+    
+    @classmethod
+    def _recursive_search(cls, root: str, executables: List[str], max_depth: int = 3, current_depth: int = 0) -> Optional[str]:
+        """递归搜索目录"""
+        if current_depth >= max_depth:
+            return None
+        
+        # 跳过的目录
+        skip_dirs = {'.git', 'node_modules', '__pycache__', 'cache', 'tmp', 'temp', 
+                     'logs', 'log', '.npm', '.yarn', 'site-packages', 'dist-packages'}
+        
+        try:
+            for entry in os.scandir(root):
+                try:
+                    if entry.is_file(follow_symlinks=True):
+                        if entry.name in executables or entry.name.lower() in [e.lower() for e in executables]:
+                            if cls._is_valid_executable(entry.path):
+                                return entry.path
+                    elif entry.is_dir(follow_symlinks=False):
+                        if entry.name.lower() in skip_dirs:
+                            continue
+                        found = cls._recursive_search(entry.path, executables, max_depth, current_depth + 1)
+                        if found:
+                            return found
+                except (PermissionError, OSError):
+                    continue
+        except (PermissionError, OSError):
+            pass
+        
+        return None
+    
+    @classmethod
+    def _find_with_command(cls, executables: List[str]) -> Optional[str]:
+        """使用系统命令查找浏览器（Linux）"""
+        for name in executables[:5]:  # 只检查前几个常见的
+            try:
+                result = subprocess.run(
+                    ['find', '/', '-maxdepth', '6', '-name', name, '-type', 'f', '-executable', '-print', '-quit'],
+                    capture_output=True,
+                    text=True,
+                    timeout=30,
+                    stderr=subprocess.DEVNULL
+                )
+                if result.returncode == 0 and result.stdout.strip():
+                    path = result.stdout.strip().split('\n')[0]
+                    if cls._is_valid_executable(path):
+                        return path
+            except (subprocess.TimeoutExpired, FileNotFoundError, Exception):
+                continue
+        
+        return None
+    
+    @classmethod
+    def get_browser_info(cls) -> Dict:
+        """获取浏览器信息"""
+        path = cls.find_browser()
+        info = {
+            'found': path is not None,
+            'path': path,
+            'version': None,
+            'platform': cls.get_platform()
+        }
+        
+        return info
+    
+    @classmethod
+    def find_all_browsers(cls) -> List[Dict]:
+        """查找所有可用的浏览器"""
+        browsers = []
+        seen_paths = set()
+        current_platform = cls.get_platform()
+        executables = cls.BROWSER_EXECUTABLES.get(current_platform, cls.BROWSER_EXECUTABLES['linux'])
+        
+        # 查找所有可能的浏览器
+        for name in executables:
+            path = shutil.which(name)
+            if path and path not in seen_paths and cls._is_valid_executable(path):
+                seen_paths.add(path)
+                browsers.append({'name': name, 'path': path})
+        
+        # 检查 glob 模式
+        for pattern in cls.GLOB_PATTERNS:
+            matches = glob.glob(pattern)
+            for match in matches:
+                if match not in seen_paths and cls._is_valid_executable(match):
+                    seen_paths.add(match)
+                    browsers.append({'name': os.path.basename(match), 'path': match})
+        
+        return browsers
+class Config:
+    """配置管理器"""
+    
+    def __init__(self):
+        self._lock = threading.Lock()
+        self._browser_path = None
+        self._user_agent = None
+        self._max_workers = 1
+        self._headless = True
+        self._email_configs = []
+        self._browser_fingerprint = {}        
+        self._load_from_env()
+        self._detect_browser()
+    
+    def _detect_browser(self):
+        """检测浏览器路径"""
+        import os
+        
+        # 优先使用环境变量
+        env_path = os.getenv('BROWSER_PATH') or os.getenv('CHROME_PATH')
+        if env_path and os.path.isfile(env_path):
+            self._browser_path = env_path
+            logger.info(f"[Config] 使用环境变量指定的浏览器: {env_path}")
+            return
+        
+        # 自动检测
+        # 自动检测
+        logger.info(f"[Config] 正在自动检测浏览器路径 (平台: {BrowserPathFinder.get_platform()})...")
+        browser_info = BrowserPathFinder.get_browser_info()
+        
+        if browser_info['found']:
+            self._browser_path = browser_info['path']
+        if browser_info['found']:
+            self._browser_path = browser_info['path']
+            logger.info(f"[Config] ✓ 检测到浏览器: {browser_info['path']}")
+            if browser_info['version']:
+                logger.info(f"[Config] ✓ 浏览器版本: {browser_info['version']}")
+        else:
+            logger.warning("[Config] ✗ 警告: 未检测到可用的浏览器！")
+            logger.warning("[Config] 请确保已安装 Chrome/Chromium/Edge 或设置 BROWSER_PATH 环境变量")
+            logger.warning("[Config] 支持的浏览器: Chrome, Chromium, Edge, Brave, Vivaldi, Opera")
+            
+            # 列出所有检查过的路径（调试用）
+            all_browsers = BrowserPathFinder.find_all_browsers()
+            if all_browsers:
+                logger.info(f"[Config] 找到以下浏览器但可能不兼容:")
+                for b in all_browsers:
+                    logger.info(f"[Config]   - {b['name']}: {b['path']}")
+    
+    def get_browser_path(self) -> Optional[str]:
+        """获取浏览器路径"""
+        with self._lock:
+            return self._browser_path
+    
+    def set_browser_path(self, path: str):
+        """设置浏览器路径"""
+        with self._lock:
+            if os.path.isfile(path):
+                self._browser_path = path
+            else:
+                raise ValueError(f"无效的浏览器路径: {path}")
+    
+    def _load_from_env(self):
+        """从环境变量加载配置"""
+        # User-Agent
+        self._user_agent = os.getenv(
+            'USER_AGENT',
+            'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/133.0.0.0 Safari/537.36'
+        )
+        
+        # 最大工作线程数
+        self._max_workers = int(os.getenv('MAX_WORKERS', '1'))
+        
+        # 无头模式
+        self._headless = os.getenv('HEADLESS', 'true').lower() == 'true'
+        
+        # 邮箱配置（支持多个，用分号分隔）
+        self._email_configs = []
+        
+        worker_domains = os.getenv('WORKER_DOMAINS', '').split(';')
+        email_domains = os.getenv('EMAIL_DOMAINS', '').split(';')
+        admin_passwords = os.getenv('ADMIN_PASSWORDS', '').split(';')
+        
+        # 确保三个列表长度一致
+        max_len = max(len(worker_domains), len(email_domains), len(admin_passwords))
+        
+        for i in range(max_len):
+            worker = worker_domains[i].strip() if i < len(worker_domains) else ''
+            email = email_domains[i].strip() if i < len(email_domains) else ''
+            password = admin_passwords[i].strip() if i < len(admin_passwords) else ''
+            
+            if worker and email and password:
+                self._email_configs.append({
+                    'worker_domain': worker,
+                    'email_domain': email,
+                    'admin_password': password
+                })
+        
+        # 浏览器指纹配置
+        self._browser_fingerprint = {
+            'window_size': os.getenv('WINDOW_SIZE', '1920x1080'),
+            'timezone': os.getenv('TIMEZONE', 'Asia/Shanghai'),
+            'locale': os.getenv('LOCALE', 'zh-CN'),
+            'platform': os.getenv('PLATFORM', 'Win64'),
+            'color_depth': int(os.getenv('COLOR_DEPTH', '24')),
+            'device_memory': int(os.getenv('DEVICE_MEMORY', '8')),
+            'hardware_concurrency': int(os.getenv('HARDWARE_CONCURRENCY', '8'))
+        }
+    
+    def get_user_agent(self) -> str:
+        with self._lock:
+            return self._user_agent
+    
+    def set_user_agent(self, ua: str):
+        with self._lock:
+            self._user_agent = ua
+    
+    def get_max_workers(self) -> int:
+        with self._lock:
+            return self._max_workers
+    
+    def set_max_workers(self, count: int):
+        with self._lock:
+            self._max_workers = max(1, min(count, 10))
+    
+    def get_headless(self) -> bool:
+        with self._lock:
+            return self._headless
+    
+    def set_headless(self, headless: bool):
+        with self._lock:
+            self._headless = headless
+    
+    def get_email_configs(self) -> List[Dict]:
+        with self._lock:
+            return self._email_configs.copy()
+    
+    def get_email_configs_safe(self) -> List[Dict]:
+        """获取邮箱配置（隐藏密码）"""
+        with self._lock:
+            return [
+                {
+                    'worker_domain': c['worker_domain'],
+                    'email_domain': c['email_domain'],
+                    'admin_password': '***'
+                }
+                for c in self._email_configs
+            ]
+    
+    def get_random_email_config(self) -> Optional[Dict]:
+        with self._lock:
+            if self._email_configs:
+                return random.choice(self._email_configs)
+            return None
+    
+    def add_email_config(self, worker_domain: str, email_domain: str, admin_password: str):
+        with self._lock:
+            self._email_configs.append({
+                'worker_domain': worker_domain,
+                'email_domain': email_domain,
+                'admin_password': admin_password
+            })
+    
+    def update_email_config(self, index: int, worker_domain: str = None, 
+                           email_domain: str = None, admin_password: str = None):
+        with self._lock:
+            if 0 <= index < len(self._email_configs):
+                if worker_domain:
+                    self._email_configs[index]['worker_domain'] = worker_domain
+                if email_domain:
+                    self._email_configs[index]['email_domain'] = email_domain
+                if admin_password:
+                    self._email_configs[index]['admin_password'] = admin_password
+            else:
+                raise IndexError("配置索引不存在")
+    
+    def delete_email_config(self, index: int):
+        with self._lock:
+            if 0 <= index < len(self._email_configs):
+                del self._email_configs[index]
+            else:
+                raise IndexError("配置索引不存在")
+    
+    def get_browser_fingerprint(self) -> Dict:
+        with self._lock:
+            return self._browser_fingerprint.copy()
+    
+    def set_browser_fingerprint(self, fingerprint: Dict):
+        with self._lock:
+            self._browser_fingerprint.update(fingerprint)

email_manager.py

@@ -0,0 +1,121 @@
+import re
+import time
+import random
+import string
+from typing import Optional, Tuple
+from datetime import datetime, timezone, timedelta
+from email.utils import parsedate_to_datetime
+
+import requests
+import logging
+
+logger = logging.getLogger(__name__)
+
+
+class EmailManager:
+    """邮箱管理器"""
+    
+    def __init__(self, worker_domain: str, email_domain: str, admin_password: str):
+        self.worker_domain = worker_domain
+        self.email_domain = email_domain
+        self.admin_password = admin_password
+    
+    @staticmethod
+    def generate_random_name() -> str:
+        """生成随机邮箱名称"""
+        letters1 = ''.join(random.choices(string.ascii_lowercase, k=4))
+        numbers = ''.join(random.choices(string.digits, k=2))
+        letters2 = ''.join(random.choices(string.ascii_lowercase, k=3))
+        return letters1 + numbers + letters2
+    
+    def create_email(self, username: str = "") -> Tuple[Optional[str], Optional[str]]:
+        """创建邮箱"""
+        try:
+            name = username if username else self.generate_random_name()
+            
+            res = requests.post(
+                f"https://{self.worker_domain}/admin/new_address",
+                json={
+                    "enablePrefix": True,
+                    "name": name,
+                    "domain": self.email_domain,
+                },
+                headers={
+                    'x-admin-auth': self.admin_password,
+                    "Content-Type": "application/json"
+                },
+                timeout=30
+            )
+            
+            if res.status_code == 200:
+                data = res.json()
+                return data.get('jwt'), data.get('address')
+            else:
+                return None, None
+        except Exception as e:
+            logger.error(f"创建邮箱出错: {e}")
+            return None, None
+    
+    def check_verification_code(self, email: str, max_retries: int = 15, interval: float = 3.0) -> Optional[str]:
+        """检查验证码邮件"""
+        for attempt in range(max_retries):
+            try:
+                api_url = f"https://{self.worker_domain}/admin/mails"
+                res = requests.get(
+                    api_url,
+                    params={"limit": 5, "offset": 0, "address": email},
+                    headers={
+                        "x-admin-auth": self.admin_password,
+                        "Content-Type": "application/json"
+                    },
+                    timeout=30
+                )
+                
+                if res.status_code == 200:
+                    data = res.json()
+                    
+                    if data.get('results') and len(data['results']) > 0:
+                        email_data = data['results'][0]
+                        raw_content = email_data.get('raw', '')
+                        
+                        # 检查邮件时间
+                        try:
+                            # 提取 Received 头中的时间
+                            received_match = re.search(r'Received:.*?;\s*(.*?)\r\n', raw_content, re.DOTALL)
+                            if received_match:
+                                date_str = received_match.group(1).strip()
+                                email_time = parsedate_to_datetime(date_str)
+                                current_time = datetime.now(timezone.utc)
+                                
+                                # 如果邮件时间与当前时间相差超过1分钟，则认为是旧邮件
+                                if (current_time - email_time) > timedelta(minutes=1):
+                                    logger.warning(f"忽略过期邮件 (时间: {email_time}, 当前: {current_time})")
+                                    time.sleep(interval)
+                                    continue
+                        except Exception as e:
+                            logger.warning(f"解析邮件时间失败: {e}")
+
+                        cleaned_content = raw_content.replace('=\r\n', '').replace('=\n', '').replace('=3D', '=')
+                        
+                        patterns = [
+                            r'class=["\']?verification-code["\']?[^>]*>([A-Z0-9]{6})</span>',
+                            r'verification-code[^>]*>([A-Z0-9]{6})<',
+                            r'>([A-Z0-9]{6})</span>',
+                            r'font-size:\s*28px[^>]*>([A-Z0-9]{6})<',
+                        ]
+                        
+                        for pattern in patterns:
+                            match = re.search(pattern, cleaned_content, re.IGNORECASE | re.DOTALL)
+                            if match:
+                                code = match.group(1).upper()
+                                if len(code) == 6 and code.isalnum():
+                                    logger.info(f"找到验证码: {code}")
+                                    return code
+                
+                time.sleep(interval)
+                
+            except Exception as e:
+                logger.error(f"检查验证码出错: {e}")
+                time.sleep(interval)
+        
+        return None