# 完整的 HTTP 头部示例（以 Chrome 为例）
headers = {
    'User-Agent': 'Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/131.0.0.0 Safari/537.36',
    'Accept': 'text/html,application/xhtml+xml,application/xml;q=0.9,image/avif,image/webp,image/apng,*/*;q=0.8',
    'Accept-Language': 'zh-CN,zh;q=0.9,en;q=0.8',
    'Accept-Encoding': 'gzip, deflate, br',
    'Connection': 'keep-alive',
    'Upgrade-Insecure-Requests': '1',
    'Sec-Fetch-Dest': 'document',
    'Sec-Fetch-Mode': 'navigate',
    'Sec-Fetch-Site': 'none',
    'Sec-Fetch-User': '?1',
    'Cache-Control': 'max-age=0',
}

// 1. 浏览器引擎识别
console.log(window.navigator.userAgentData?.platform);  // 'macOS'
console.log(window.navigator.userAgentData?.brands);      // Chrome 品牌

// 2. 特性检测
console.log('chrome' in window);        // Chrome 特定 API
console.log('webkit' in window);        // WebKit 特性

// 3. WebGL 渲染器
const gl = canvas.getContext('webgl');
console.log(gl.getParameter(gl.RENDERER));  // GPU 信息

# 使用 curl_cffi 进行 HTTP/2 指纹伪装
from curl_cffi import requests

# 禁用 HTTP/2 草级
session = requests.Session(impersonate="chrome120")

# 自定义 SETTINGS
response = session.get(
    url,
    http2_settings={
        'ENABLE_PUSH': False,
        'MAX_CONCURRENT_STREAMS': 100,
    }
)

import asyncio
import websockets
import json
import random
import time

class RealisticWebSocket:
    def __init__(self, url):
        self.url = url
        self.heartbeat_interval = random.randint(25, 40)
        self.last_ping = None

    async def connect(self):
        # 连接时发送正确的协议
        self.ws = await websockets.connect(
            self.url,
            extra_headers={
                'User-Agent': 'Mozilla/5.0...',
                'Sec-WebSocket-Protocol': 'permessage, deflate',
            }
        )

        # 启动心跳
        asyncio.create_task(self._heartbeat())

    async def send_message(self, data):
        await self.ws.send(json.dumps(data))

    async def _heartbeat(self):
        """模拟心跳机制"""
        while True:
            await asyncio.sleep(self.heartbeat_interval)

            # 发送 ping
            ping_data = {
                'type': 'ping',
                'timestamp': int(time.time() * 1000),
                'data': f'ping_{random.randint(1000, 9999)}'
            }
            await self.ws.send(json.dumps(ping_data))
            self.last_ping = time.time()

            # 接收超时检测
            if time.time() - self.last_ping > self.heartbeat_interval * 3:
                await self.reconnect()

    async def reconnect(self):
        """断线重连"""
        await self.ws.close()
        await asyncio.sleep(random.uniform(2, 5))
        await self.connect()

    async def close(self):
        await self.ws.close()

import hashlib
import time

class SmartCacheManager:
    def __init__(self):
        self.cache = {}
        self.etags = {}

    def should_fetch(self, url, headers):
        """判断是否需要获取新内容"""
        # 1. 检查 ETag
        if 'ETag' in headers:
            etag = headers['ETag']
            if url in self.etags and self.etags[url] == etag:
                return False

        # 2. 检查 Cache-Control
        cache_control = headers.get('Cache-Control', '')
        if 'no-cache' in cache_control:
            return True
        if 'max-age' in cache_control:
            # 解析 max-age
            max_age = int(cache_control.split('max-age=')[1].split(',')[0])
            cached_time = self.cache.get(f'{url}_time', 0)
            return time.time() - cached_time > max_age

        return True

    def update_cache(self, url, response):
        """更新缓存"""
        # 保存 ETag
        if 'ETag' in response.headers:
            self.etags[url] = response.headers['ETag']

        # 保存时间
        self.cache[f'{url}_time'] = time.time()

def create_secure_cookie(name, value, domain):
    """创建安全 Cookie"""
    return {
        'name': name,
        'value': value,
        'domain': domain,
        'path': '/',
        'secure': True,           # 仅 HTTPS
        'httponly': False,         # 允许 JS 访问
        'samesite': 'Lax',        # 严格同站
        'max-age': 3600 * 24,     # 24 小时过期
        'sameparty': 'None',       # 不跨域
    }

# 创建指纹 Cookie（长期）
fingerprint_cookies = {
    '_ga': create_secure_cookie('_ga', 'GA1.2.xxxxxxxxx', '.google.com'),
    '_gid': create_secure_cookie('_gid', 'GA1.2.yyyyyyyyy', '.google.com'),
    '__cfduid': create_secure_cookie('__cfduid', 'cfduid_hash', '.example.com'),
}

# 创建会话 Cookie（短期）
session_cookie = create_secure_cookie('sessionid', 'session_token_hash', '.example.com')
session_cookie['max-age'] = 3600  # 1 小时过期

def get_complete_headers(user_agent):
    """生成完整的 Chrome 请求头"""
    return {
        'User-Agent': user_agent,
        'Accept': 'text/html,application/xhtml+xml,application/xml;q=0.9,image/avif,image/webp,image/apng,*/*;q=0.8',
        'Accept-Language': 'zh-CN,zh;q=0.9,en;q=0.8',
        'Accept-Encoding': 'gzip, deflate, br',
        'Connection': 'keep-alive',
        'Upgrade-Insecure-Requests': '1',
        'Sec-Fetch-Dest': 'document',
        'Sec-Fetch-Mode': 'navigate',
        'Sec-Fetch-Site': 'same-origin',
        'Sec-Fetch-User': '?1',
        'Sec-Ch-Ua': '"Windows"; v="131", u="0", a="Google Chrome 131.0.0.0 Safari/537.36"',
        'Sec-Ch-Ua-Platform': '"Windows"',
        'Sec-Ch-Ua-Mobile': '?0',
        'Sec-Ch-Ua-Arch': '"x86"',
        'DNT': '1',
        'Sec-GPC': '1',
        'Cache-Control': 'max-age=0',
        'sec-ch-ua': ' "Not_A;Brand";v="8", "Chromium";v="8", "Google Chrome";v="131"',
        'sec-ch-ua-mobile': '?0',
        'sec-ch-ua-full-version-list': '"Not_A;Brand";v="8", "Chromium";v="8", "Google Chrome";v="131"',
        'sec-ch-ua-platform': '"Windows"',
        'sec-ch-ua-arch': '"x86"',
        'sec-ch-ua-bitness': '"32"',
        'sec-ch-ua-model': '""',
        'sec-ch-ua-wow64': '?0',
    }

import random
from urllib.parse import urlparse

class RefererManager:
    """Referer 管理器"""

    def __init__(self):
        self.history = []
        self.max_history = 10

    def get_referer(self, target_url):
        """获取合理的 Referer"""
        # 解析目标域名
        target_domain = urlparse(target_url).netloc

        # 检查历史记录
        for url in reversed(self.history):
            domain = urlparse(url).netloc
            if domain == target_domain:
                return url

        # 同域无历史，使用首页
        return f'https://{target_domain}/'

    def update_history(self, url):
        """更新访问历史"""
        self.history.append(url)

        # 保持历史长度
        if len(self.history) > self.max_history:
            self.history.pop(0)

import os
import requests

class ResumableDownloader:
    """支持断点续传的下载器"""

    def __init__(self, chunk_size=8192):
        self.chunk_size = chunk_size

    def download(self, url, save_path, headers=None):
        """带续传的下载"""
        # 检查已下载部分
        downloaded = 0
        temp_file = f'{save_path}.tmp'

        if os.path.exists(temp_file):
            downloaded = os.path.getsize(temp_file)

        # 设置 Range 头
        if headers is None:
            headers = {}

        if downloaded > 0:
            headers['Range'] = f'bytes={downloaded}-'

        # 下载
        mode = 'ab' if downloaded > 0 else 'wb'

        with open(temp_file, mode) as f:
            with requests.get(url, headers=headers, stream=True) as r:
                total_size = int(r.headers.get('content-length', 0))

                for chunk in r.iter_content(chunk_size=self.chunk_size):
                    f.write(chunk)
                    downloaded += len(chunk)

                    # 显示进度
                    self._show_progress(downloaded, total_size)

        # 重命名
        os.rename(temp_file, save_path)

    def _show_progress(self, downloaded, total):
        percent = (downloaded / total) * 100 if total > 0 else 100
        print(f'\r下载进度: {percent:.1f}% ({downloaded}/{total})', end='')

import time
import random
from functools import wraps

def retry_with_backoff(max_retries=3, base_delay=1, backoff_factor=2):
    """带指数退避的重试装饰器"""
    def decorator(func):
        @wraps(func)
        def wrapper(*args, **kwargs):
            retries = 0
            last_exception = None

            while retries < max_retries:
                try:
                    return func(*args, **kwargs)
                except Exception as e:
                    last_exception = e
                    retries += 1

                    if retries < max_retries:
                        # 计算退避延迟
                        delay = base_delay * (backoff_factor ** (retries - 1))
                        delay = delay + random.uniform(0, 1)

                        print(f'重试 {retries}/{max_retries}，延迟 {delay:.2f}s')
                        time.sleep(delay)

            raise last_exception

        return wrapper
    return decorator

# 使用示例
@retry_with_backoff(max_retries=3, base_delay=1, backoff_factor=2)
def fetch_url(url):
    response = requests.get(url)
    response.raise_for_status()
    return response.json()

import asyncio
import aiohttp
from asyncio import Semaphore

class ConcurrentRequestManager:
    """并发请求管理器"""

    def __init__(self, max_concurrent=10):
        self.semaphore = Semaphore(max_concurrent)

    async def fetch(self, url, session):
        """带并发控制的请求"""
        async with self.semaphore:
            try:
                async with session.get(url) as response:
                    return await response.text()
            except Exception as e:
                print(f'请求失败 {url}: {e}')
                return None

    async def fetch_all(self, urls):
        """并发请求所有 URL"""
        async with aiohttp.ClientSession() as session:
            tasks = [self.fetch(url, session) for url in urls]
            results = await asyncio.gather(*tasks)

        return results

# 使用示例
manager = ConcurrentRequestManager(max_concurrent=5)
results = await manager.fetch_all(urls)

class CookieSync:
    """Cookie 同步器"""

    def __init__(self, storage_path):
        self.storage_path = Path(storage_path)
        self.storage_path.mkdir(exist_ok=True)

    def sync_cookies(self, page, account_id):
        """同步 Cookie 到浏览器"""
        cookie_file = self.storage_path / f'cookies_{account_id}.json'

        if cookie_file.exists():
            with open(cookie_file) as f:
                cookies = json.load(f)

            # 清除现有 Cookies
            page.context.clear_cookies()

            # 添加 Cookies
            for cookie in cookies:
                page.context.add_cookie(cookie)

    def update_cookies(self, page, account_id):
        """更新 Cookie 存储"""
        cookies = page.context.cookies()

        cookie_file = self.storage_path / f'cookies_{account_id}.json'

        with open(cookie_file, 'w') as f:
            json.dump(cookies, f)

def add_cookie_with_domain(cookie, page):
    """根据 Cookie 添加域Cookie"""
    # 获取当前域名
    current_domain = page.evaluate('window.location.hostname')

    # 处理 Cookie 域名
    cookie_domain = cookie.get('domain')

    if cookie_domain and cookie_domain.startswith('.'):
        # 域名以点开头，所有子域共享
        pass
    elif cookie_domain:
        # 特定域名
        pass
    else:
        # 当前域名
        cookie['domain'] = current_domain

    page.context.add_cookie(cookie)

def secure_cookie_from_string(cookie_string, domain):
    """从 Cookie 字符串创建安全 Cookie"""
    parts = cookie_string.split(';')

    name_value = parts[0].split('=', 1)
    cookie = {
        'name': name_value[0],
        'value': name_value[1] if len(name_value) > 1 else '',
        'domain': domain,
        'path': '/',
    }

    # 解析属性
    for part in parts[1:]:
        part = part.strip().lower()

        if part == 'httponly':
            cookie['httpOnly'] = True
        elif part == 'secure':
            cookie['secure'] = True
        elif part.startswith('path='):
            cookie['path'] = part[5:].strip('"')
        elif part.startswith('max-age='):
            cookie['expires'] = time.time() + int(part[8:])
        elif part.startswith('expires='):
            # 解析日期
            pass

    return cookie

// 1. 基础 webdriver 属性移除
await page.evaluateOnNewDocument(() => {
  Object.defineProperty(navigator, 'webdriver', {
    get: () => undefined,
  });
});

// 2. 完整 plugins 伪造
await page.evaluateOnNewDocument(() => {
  navigator.plugins = [
    {
      name: 'Chrome PDF Plugin',
      description: 'Portable Document Format',
      filename: 'internal-pdf-viewer',
    },
    {
      name: 'Chrome PDF Viewer',
      description: '',
      filename: 'mhjfbmdgcfjbbpaeojofohoefgiehjai',
    },
    {
      name: 'Native Client',
      description: '',
      filename: 'internal-nacl-plugin',
    },
  ];
});

// 3. languages 伪造
await page.evaluateOnNewDocument(() => {
  navigator.languages = ['zh-CN', 'zh', 'en-US', 'en'];
});

// 4. platform 伪造
await page.evaluateOnNewDocument(() => {
  Object.defineProperty(navigator, 'platform', {
    get: () => 'MacIntel',
  });
});

// 检测方法 1：错误堆栈检测
const error = new Error();
const isAutomated = error.stack.includes('puppeteer') ||
                    error.stack.includes('playwright') ||
                    error.stack.includes('selenium');

// 检测方法 2：window.chrome 属性
// 自动化工具可能缺少完整的 chrome 对象结构

// 检测方法 3：外部脚本注入检测
const scripts = Array.from(document.scripts);
const hasInjectedScripts = scripts.some(s =>
  s.src.includes('puppeteer') || !s.src && s.innerHTML.includes('evaluate')
);

// 使用 undetected-chromedriver (Python)
// 或 puppeteer-extra-plugin-stealth (Node.js)

// 获取 Canvas 指纹
function getCanvasFingerprint() {
  const canvas = document.createElement('canvas');
  const ctx = canvas.getContext('2d');
  ctx.textBaseline = 'top';
  ctx.font = '14px Arial';
  ctx.fillText('Fingerprint', 2, 2);
  return canvas.toDataURL();
}

// 获取 WebGL 指纹
function getWebGLFingerprint() {
  const canvas = document.createElement('canvas');
  const gl = canvas.getContext('webgl') || canvas.getContext('experimental-webgl');
  if (!gl) return null;

  const debugInfo = gl.getExtension('WEBGL_debug_renderer_info');
  const renderer = gl.getParameter(debugInfo.UNMASKED_RENDERER_WEBGL);
  const vendor = gl.getParameter(debugInfo.UNMASKED_VENDOR_WEBGL);

  return { renderer, vendor };
}

// Canvas 指纹注入噪声
const originalToDataURL = HTMLCanvasElement.prototype.toDataURL;
HTMLCanvasElement.prototype.toDataURL = function() {
  const result = originalToDataURL.apply(this, arguments);
  // 在结果中注入微小噪声
  return result.slice(0, -5) + Math.random().toString(36).slice(2, 5);
};

import random
import time

class ProxyPool:
    def __init__(self, proxies):
        self.proxies = proxies
        self.failed = {}
        self.cooldown = {}

    def get_proxy(self):
        # 排除冷却中的代理
        available = [p for p in self.proxies
                    if p not in self.cooldown
                    or time.time() > self.cooldown[p]]

        # 按失败率加权随机
        weights = [1 / (1 + self.failed.get(p, 0)) for p in available]
        return random.choices(available, weights=weights)[0]

    def mark_failed(self, proxy):
        self.failed[proxy] = self.failed.get(proxy, 0) + 1
        # 失败次数多则冷却更久
        self.cooldown[proxy] = time.time() + min(300, self.failed[proxy] * 60)

// 匹配常见分辨率
const resolutions = [
  [1920, 1080],  // FHD
  [1366, 768],   // 笔记本
  [2560, 1440],  // 2K
  [1440, 900],   // MacBook Pro 13"
  [1680, 1050],  // MacBook Pro 15"
];

const [width, height] = resolutions[Math.floor(Math.random() * resolutions.length)];

Object.defineProperty(screen, 'width', { get: () => width });
Object.defineProperty(screen, 'height', { get: () => height });
Object.defineProperty(window, 'innerWidth', { get: () => width });
Object.defineProperty(window, 'innerHeight', { get: () => height });

// 时区设置应与 IP 地理位置一致
const timezones = {
  'US': 'America/New_York',
  'CN': 'Asia/Shanghai',
  'JP': 'Asia/Tokyo',
  'EU': 'Europe/London',
};

// 注意：时区不能通过 JS 直接修改，需要在浏览器启动时设置
// Chrome: --timezone="Asia/Shanghai"

# 使用 curl_cffi 进行 TLS 指纹伪装
from curl_cffi import requests, Curl

# 使用预设的浏览器指纹
session = requests.Session(impersonate="chrome110")

# 自定义指纹
curl = Curl()
curl.setopt(curl.IMPERSONATE, "chrome120")
curl.setopt(curl.URL, "https://example.com")
curl.perform()

# Playwright + curl-impersonate
from playwright.sync_api import sync_playwright
import subprocess

# 启动带有 TLS 伪装的代理
# 详见: https://github.com/lwthiker/curl-impersonate

// 检测 WebRTC 泄露
const pc = new RTCPeerConnection({
  iceServers: [{ urls: 'stun:stun.l.google.com:19302' }]
});

pc.createOffer().then(offer => {
  // SDP 中可能包含真实 IP
  console.log(offer.sdp);
});

// 1. 禁用 WebRTC
await page.evaluateOnNewDocument(() => {
  Object.defineProperty(navigator, 'mediaDevices', {
    get: () => undefined,
  });
});

// 2. 使用浏览器插件
// Chrome: WebRTC Leak Shield
// Firefox: Disable WebRTC

// 3. Playwright 防护
context = browser.new_context(
  permissions=['geolocation'],  # 限制权限
  # 禁用 WebRTC
)

# 1. 使用 curl_cffi
from curl_cffi import requests

# Chrome 浏览器指纹
response = requests.get(
    url,
    impersonate="chrome120",
    headers={
        'User-Agent': 'Mozilla/5.0 ...',
        'Accept': 'text/html,application/xhtml+xml...',
    }
)

# 2. 使用 undetected-chromedriver
import undetected_chromedriver as uc

driver = uc.Chrome()
driver.get(url)

# 3. 使用 playwright + proxy
from playwright.sync_api import sync_playwright

with sync_playwright() as p:
    browser = p.chromium.launch(
        proxy={'server': 'http://proxy'},
        args=[
            '--disable-blink-features=AutomationControlled',
        ]
    )

// 检测方法 1: debugger 语句
setInterval(() => {
  const start = Date.now();
  debugger;
  if (Date.now() - start > 100) {
    // 调试器打开
    console.log('Debugger detected!');
  }
}, 1000);

// 检测方法 2: DevTools 检测
const devtools = /./;
devtools.toString = function() {
  this.opened = true;
}

// 检测方法 3: window 对象检测
if (window.chrome && window.chrome.webstore) {
  // 可能是自动化工具
}

# 1. 禁用 debugger
await page.evaluateOnNewDocument(() => {
  window.debugger = () => {};
  setInterval = new Proxy(setInterval, {
    apply: (target, thisArg, args) => {
      if (args[0]?.toString?.()?.includes('debugger')) {
        return;
      }
      return Reflect.apply(target, thisArg, args);
    }
  });
});

# 2. 启动参数
browser = p.chromium.launch(
    args=[
        '--disable-dev-shm-usage',
        '--no-first-run',
        '--no-default-browser-check',
        '--disable-blink-features=AutomationControlled',
    ]
)

# 3. 注入反检测脚本
stealth_script = """
Object.defineProperty(navigator, 'webdriver', {get: () => undefined});
"""
await page.add_init_script(stealth_script)

# Playwright 请求拦截
async def handle_route(route):
    # 修改请求头
    headers = route.request.headers
    headers['X-Custom-Header'] = 'value'

    # 阻止特定资源
    if route.request.resource_type in ['image', 'font']:
        await route.abort()
    else:
        await route.continue_(headers=headers)

page.route('**/*', handle_route)

# 控制资源加载
context = browser.new_context(
    # 禁用图片加载
    accept_downloads=False,
)

# 拦截并响应自定义内容
await page.route('**/*.{png,jpg,jpeg}', lambda route: route.fulfill(
    status=404,
    body=b''
))

import asyncio
import aiohttp
import time

class ProxyHealthChecker:
    def __init__(self):
        self.proxies = {}  # {proxy_url: {last_check, success_rate, latency}}

    async def check_proxy(self, proxy_url):
        """检查单个代理"""
        start_time = time.time()

        try:
            async with aiohttp.ClientSession() as session:
                async with session.get(
                    'https://httpbin.org/ip',
                    proxy=proxy_url,
                    timeout=aiohttp.ClientTimeout(total=10)
                ) as response:
                    latency = time.time() - start_time
                    if response.status == 200:
                        return {
                            'status': 'success',
                            'latency': latency,
                            'ip': (await response.json()).get('origin')
                        }
        except Exception as e:
            return {'status': 'failed', 'error': str(e)}

    async def check_all_proxies(self, proxy_list):
        """检查所有代理"""
        results = await asyncio.gather(
            *[self.check_proxy(p) for p in proxy_list],
            return_exceptions=True
        )

        for proxy, result in zip(proxy_list, results):
            if result and result.get('status') == 'success':
                self.proxies[proxy] = {
                    'last_check': time.time(),
                    'latency': result['latency'],
                    'ip': result['ip']
                }

        return self.proxies

from datetime import datetime
import pytz

class GeoLocationMatcher:
    def __init__(self):
        # 代理 IP 对应的时区
        self.proxy_timezones = {
            'US': 'America/New_York',
            'US-West': 'America/Los_Angeles',
            'EU': 'Europe/London',
            'EU-West': 'Europe/Paris',
            'CN': 'Asia/Shanghai',
            'JP': 'Asia/Tokyo',
            'KR': 'Asia/Seoul',
            'SG': 'Asia/Singapore',
            'AU': 'Australia/Sydney',
            'IN': 'Asia/Kolkata',
        }

    def match_timezone(self, proxy_region):
        """根据代理地区匹配时区"""
        return self.proxy_timezones.get(proxy_region, 'UTC')

    def set_browser_timezone(self, page, timezone_str):
        """设置浏览器时区"""
        # 通过启动参数设置
        # Chrome: --timezone="Asia/Shanghai"
        # 或通过 JS 注入修改 Date 对象行为

        page.evaluate(f'''
            () => {{
                const originalDate = Date;
                const timezone = '{timezone_str}';

                // 覆盖 getTimezoneOffset
                Date.prototype.getTimezoneOffset = function() {{
                    const offset = new Date().toLocaleString('en-US', {{
                        timeZone: timezone,
                        timeZoneName: 'short'
                    }});

                    // 解析时差（小时）
                    const match = offset.match(/GMT([+-]{{0,1}}\\d+){{0,1}}\\d*)/);
                    if (match) {{
                        return parseInt(match[1]) * 60;
                    }}
                    return 0;
                }};

                // 覆盖 toString
                Date.prototype.toString = function() {{
                    return this.toLocaleString('en-US', {{
                        timeZone: timezone,
                        year: 'numeric',
                        month: 'short',
                        day: 'numeric',
                        hour: '2-digit',
                        minute: '2-digit',
                        second: '2-digit',
                        timeZoneName: 'short'
                    }});
                }};
            }}
        ''')

// 网站检测安装的字体
function detectFonts() {
    const baseFonts = ['monospace', 'sans-serif', 'serif'];
    const testFonts = ['Arial', 'Times New Roman', 'Courier New', 'Verdana', 'Georgia'];

    const testString = 'mmmmmmmmmmlli';
    const testSize = '72px';
    const h = document.getElementsByTagName('body')[0];

    const canvas = document.createElement('canvas');
    const context = canvas.getContext('2d');

    const fontMap = {};

    baseFonts.forEach(function(baseFont) {
        testFonts.forEach(function(font) {
            context.font = testSize + ' ' + font + ', ' + baseFont;
            context.fillText(testString, 0, 0);

            const dataUrl = canvas.toDataURL();
            fontMap[font] = dataUrl;
        });
    });

    return fontMap;
}

# Playwright + 字体注入
def inject_font_fingerprint(page):
    """注入字体指纹"""

    # 方法1: 伪装已安装字体
    page.evaluate_on_new_document("""
        () => {
            // 覆盖 measureText 和其他字体检测方法
            const originalMeasureText = CanvasRenderingContext2D.prototype.measureText;

            CanvasRenderingContext2D.prototype.measureText = function(text) {
                // 添加随机噪声使指纹不一致
                const result = originalMeasureText.call(this, text);
                result.width += Math.random() * 0.01;
                return result;
            };
        }
    """)

    # 方法2: 使用字体回退列表
    context.fonts = [
        'Arial', 'Times New Roman', 'Courier New',
        'Verdana', 'Georgia', 'Palatino',
        'Garamond', 'Bookman', 'Comic Sans MS',
        'Trebuchet MS', 'Arial Black', 'Impact'
    ]

// Audio 指纹获取
function getAudioFingerprint() {
    const audioContext = new (window.AudioContext || window.webkitAudioContext)();

    const oscillator = audioContext.createOscillator();
    const analyser = audioContext.createAnalyser();
    const gain = audioContext.createGain();
    const scriptProcessor = audioContext.createScriptProcessor(4096, 1, 1);

    gain.gain.value = 0; // 静音

    oscillator.connect(analyser);
    analyser.connect(scriptProcessor);
    scriptProcessor.connect(gain);
    gain.connect(audioContext.destination);

    oscillator.start(0);

    const audioData = [];
    scriptProcessor.onaudioprocess = (e) => {
        audioData.push(e.inputBuffer.getChannelData(0));
    };

    return new Promise((resolve) => {
        setTimeout(() => {
            oscillator.stop(0);
            audioContext.close();
            resolve(audioData);
        }, 100);
    });
}

def spoof_audio_fingerprint(page):
    """伪装 Audio 指纹"""

    page.evaluate_on_new_document("""
        () => {
            // Hook AudioContext
            const AudioContext = window.AudioContext || window.webkitAudioContext;

            if (AudioContext) {
                // 重写 createOscillator
                const originalCreateOscillator = AudioContext.prototype.createOscillator;

                AudioContext.prototype.createOscillator = function() {
                    const oscillator = originalCreateOscillator.call(this);
                    const originalStart = oscillator.start.bind(oscillator);

                    oscillator.start = function(when) {
                        // 添加随机噪声
                        this.detune.value = Math.random() * 10 - 5;
                        return originalStart(when || 0);
                    };

                    return oscillator;
                };
            }

            // Hook AnalyserNode
            const AudioContext = window.AudioContext || window.webkitAudioContext;

            if (AudioContext) {
                const originalCreateAnalyser = AudioContext.prototype.createAnalyser;

                AudioContext.prototype.createAnalyser = function() {
                    const analyser = originalCreateAnalyser.call(this);
                    analyser.fftSize = 2048 + Math.floor(Math.random() * 10);
                    return analyser;
                };
            }
        }
    """)

// 获取电池信息
navigator.getBattery().then(battery => {
    console.log('Battery level:', battery.level);        // 0-1
    console.log('Charging:', battery.charging);            // boolean
    console.log('Charging time:', battery.chargingTime);  // seconds
    console.log('Discharging time:', battery.dischargingTime);
});

def spoof_battery_api(page):
    """伪造电池信息"""

    page.evaluate_on_new_document("""
        () => {
            Object.defineProperty(navigator, 'getBattery', {
                value: () => Promise.resolve({
                    charging: Math.random() > 0.5,
                    chargingTime: Math.random() > 0.5 ? Infinity : 3600,
                    dischargingTime: Math.random() > 0.5 ? Infinity : 7200,
                    level: 0.3 + Math.random() * 0.6,  // 30%-90%
                    addEventListener: () => {},
                    removeEventListener: () => {}
                }),
                writable: false
            });
        }
    """)

// 获取网络信息
const connection = navigator.connection || navigator.mozConnection || navigator.webkitConnection;

console.log('Effective Type:', connection.effectiveType);  // 4g, 3g, 2g
console.log('Downlink:', connection.downlink);              // Mbps
console.log('RTT:', connection.rtt);                        // 往返时间 ms
console.log('Save Data:', connection.saveData);            // 省流量模式

def spoof_network_api(page):
    """伪造网络信息"""

    page.evaluate_on_new_document("""
        () => {
            Object.defineProperty(navigator, 'connection', {
                value: {
                    effectiveType: '4g',
                    rtt: Math.floor(Math.random() * 100) + 50,  // 50-150ms
                    downlink: Math.floor(Math.random() * 10) + 5,  // 5-15 Mbps
                    saveData: false,
                    addEventListener: () => {},
                    removeEventListener: () => {},
                    onchange: null,
                    ontypechange: null
                },
                writable: false
            });
        }
    """)

// 屏幕方向
console.log(screen.orientation.type);      // landscape-primary
console.log(screen.orientation.angle);     // 90, 180, 270, 0

// 像素比
console.log(window.devicePixelRatio);      // 1, 2, 3

// 颜色深度
console.log(screen.colorDepth);            // 24, 32

def spoof_screen_api(page):
    """伪造屏幕信息"""

    page.evaluate_on_new_document("""
        () => {
            // 屏幕方向
            Object.defineProperty(screen.orientation, 'type', {
                get: () => 'landscape-primary',
                configurable: true
            });

            // 像素比
            Object.defineProperty(window, 'devicePixelRatio', {
                get: () => 2,
                configurable: true
            });

            // 颜色深度
            Object.defineProperty(screen, 'colorDepth', {
                get: () => 24,
                configurable: true
            });
        }
    """)

// 检查权限状态
navigator.permissions.query({name: 'notifications'}).then(result => {
    console.log('Notification permission:', result.state);  // granted, denied, prompt
});

// 检查多个权限
const permissions = ['notifications', 'geolocation', 'camera', 'microphone'];

Promise.all(permissions.map(p => navigator.permissions.query({name: p}))).then(results => {
    results.forEach(r => {
        console.log(r.name, ':', r.state);
    });
});

def control_permissions(page):
    """控制权限请求"""

    # 方式1: 自动授权
    context = browser.new_context(
        geolocation={'latitude': 39.9, 'longitude': 116.4},
        permissions=['geolocation', 'notifications']
    )

    # 方式2: 拦截权限请求
    page.route('**/api/permissions/**', lambda route: route.fulfill(
        status=200,
        body='{"permissions": ["notifications", "geolocation"]}'
    ))

    # 方式3: 修改 Permissions API
    page.evaluate_on_new_document("""
        () => {
            const Permissions = window.Permissions || window.webkitPermissions;

            if (Permissions) {
                const originalQuery = Permissions.prototype.query;

                Permissions.prototype.query = function(permissionDesc) {
                    return Promise.resolve({
                        state: 'granted',
                        name: permissionDesc.name,
                        onchange: null
                    });
                };
            }
        }
    """)

// 获取位置
navigator.geolocation.getCurrentPosition(
    (position) => {
        console.log('Lat:', position.coords.latitude);
        console.log('Lon:', position.coords.longitude);
        console.log('Accuracy:', position.coords.accuracy);
    },
    (error) => {
        console.error('Error:', error.message);
    }
);

def spoof_geolocation(page, latitude, longitude):
    """伪造地理位置"""

    page.evaluate_on_new_document(f"""
        () => {{
            const fakePosition = {{
                coords: {{
                    latitude: {latitude},
                    longitude: {longitude},
                    accuracy: 100 + Math.random() * 500,
                    altitude: null,
                    altitudeAccuracy: null,
                    heading: null,
                    speed: null
                }},
                timestamp: Date.now()
            }};

            const originalGetCurrentPosition = navigator.geolocation.getCurrentPosition;
            const originalWatchPosition = navigator.geolocation.watchPosition;
            const originalClearWatch = navigator.geolocation.clearWatch;

            navigator.geolocation.getCurrentPosition = function(success, error) {{
                if (success) success(fakePosition);
            }};

            navigator.geolocation.watchPosition = function(success, error, options) {{
                if (success) success(fakePosition);
                return 1; // watch ID
            }};

            navigator.geolocation.clearWatch = function(id) {{
                // Do nothing
            }};
        }}
    """)

// WebGL 渲染器参数
const canvas = document.createElement('canvas');
const gl = canvas.getContext('webgl');

console.log('MAX_TEXTURE_SIZE:', gl.getParameter(gl.MAX_TEXTURE_SIZE));
console.log('MAX_VIEWPORT_DIMS:', gl.getParameter(gl.MAX_VIEWPORT_DIMS));
console.log('RENDERER:', gl.getParameter(gl.RENDERER));
console.log('VENDOR:', gl.getParameter(gl.VENDOR));
console.log('VERSION:', gl.getParameter(gl.VERSION));

def randomize_webgl_params(page):
    """随机化 WebGL 参数"""

    page.evaluate_on_new_document("""
        () => {
            const getParameter = WebGLRenderingContext.prototype.getParameter;

            WebGLRenderingContext.prototype.getParameter = function(parameter) {
                const result = getParameter.call(this, parameter);

                // 随机化某些参数
                switch (parameter) {
                    case 37445:  // MAX_TEXTURE_SIZE
                        return result + Math.floor(Math.random() * 100) - 50;
                    case 32802:  // MAX_VIEWPORT_DIMS
                        return [result[0], result[1]];
                    case 7938:   // MAX_VIEWPORT_DIMS
                        return [result[0], result[1]];
                    default:
                        return result;
                }
            };
        }
    """)

def hide_devtools_fingerprints(page):
    """隐藏 DevTools 特征"""

    page.evaluate_on_new_document("""
        () => {
            // 1. 移除 chrome.runtime 对象
            if (window.chrome && window.chrome.runtime) {
                delete window.chrome.runtime;
            }

            // 2. 移除调试器检测
            const originalDebugger = window.debugger;
            window.debugger = () => {};

            // 3. 移除外检测脚本标记
            const scripts = document.querySelectorAll('script');
            scripts.forEach(script => {
                if (script.innerHTML.includes('evaluate')) {
                    script.remove();
                }
            });

            // 4. 移除错误堆栈中的 puppeteer 标记
            const originalError = Error;
            window.Error = function(...args) {
                const error = new originalError(...args);
                if (error.stack) {
                    error.stack = error.stack
                        .replace(/puppeteer/g, '')
                        .replace(/playwright/g, '')
                        .replace(/selenium/g, '');
                }
                return error;
            };
        }
    """)

def spoof_iframe_fingerprints(page):
    """处理 iframe 指纹检测"""

    page.evaluate_on_new_document("""
        () => {
            // Hook iframe 创建
            const originalCreateElement = document.createElement;

            document.createElement = function(tagName) {
                const element = originalCreateElement.call(this, tagName);

                if (tagName.toLowerCase() === 'iframe') {
                    // 监听 iframe 加载
                    element.addEventListener('load', function() {
                        try {
                            const iframeWindow = element.contentWindow;

                            if (iframeWindow) {
                                // 在 iframe 中注入伪装脚本
                                Object.defineProperty(
                                    iframeWindow.navigator,
                                    'webdriver',
                                    { get: () => undefined }
                                );

                                // 注入插件伪造
                                iframeWindow.navigator.plugins = [
                                    { name: 'Chrome PDF Plugin' }
                                ];
                            }
                        } catch (e) {
                            // 跨域 iframe 无法访问
                        }
                    });
                }

                return element;
            };
        }
    """)

def spoof_media_codecs(page):
    """伪造媒体编解码器支持"""

    page.evaluate_on_new_document("""
        () => {
            // 伪造 MediaCapabilities
            const originalGetCapabilities = navigator.mediaCapabilities;

            if (originalGetCapabilities) {
                const mockCapabilities = {
                    decodingInfo: {
                        powerEfficient: true,
                        smooth: true,
                        supportedPowerEfficient: [],
                        supportedSmooth: [],
                    },
                    encodingInfo: {
                        powerEfficient: true,
                        smooth: true,
                        supportedPowerEfficient: [],
                        supportedSmooth: [],
                    }
                };

                Object.defineProperty(navigator, 'mediaCapabilities', {
                    get: () => mockCapabilities
                });
            }

            // 伪造 canPlayType 方法
            const mockCanPlayType = (mimeType) => {
                // 常见视频类型
                const videoTypes = [
                    'video/mp4; codecs="avc1.64201f, mp4a.40.2"',
                    'video/webm; codecs="vp8, vorbis"',
                    'video/ogg; codecs="theora, vorbis"'
                ];

                // 常见音频类型
                const audioTypes = [
                    'audio/mpeg',
                    'audio/ogg; codecs="vorbis"',
                    'audio/wav; codecs="1"',
                    'audio/webm; codecs="opus"'
                ];

                return [...videoTypes, ...audioTypes].includes(mimeType) ||
                       'probably';
            };

            const mockVideoElement = {
                canPlayType: mockCanPlayType
            };

            // 尝试替换
            if (typeof HTMLVideoElement !== 'undefined') {
                Object.assign(HTMLVideoElement.prototype, mockVideoElement);
            }
        }
    """)

def spoof_memory_api(page):
    """伪装内存 API"""

    page.evaluate_on_new_document("""
        () => {
            // 添加 deviceMemory 属性
            Object.defineProperty(navigator, 'deviceMemory', {
                get: () => 8,  // GB
                configurable: true
            });

            // 如果已有 deviceMemory，修改其值
            if (navigator.deviceMemory) {
                const originalMemory = navigator.deviceMemory;
                Object.defineProperty(navigator, 'deviceMemory', {
                    get: () => ({
                        ...originalMemory,
                        jsHeapSizeLimit: 8589934592,  // 8GB
                        totalJSHeapSize: 8589934592,
                        usedJSHeapSize: 800000000
                    })
                });
            }
        }
    """)

class DynamicNetworkSpoof:
    """动态网络指纹伪装"""

    def __init__(self):
        self.rtt_history = []
        self.bandwidth_history = []

    def update_network_stats(self, page, actual_rtt=None):
        """更新网络统计"""

        if actual_rtt:
            self.rtt_history.append(actual_rtt)
            if len(self.rtt_history) > 10:
                self.rtt_history.pop(0)

        # 计算平均值
        avg_rtt = sum(self.rtt_history) / len(self.rtt_history) if self.rtt_history else 50

        page.evaluate(f'''
            () => {{
                const rtt = {avg_rtt};
                const downlink = Math.max(10, Math.min(50, 5000 / rtt));

                Object.defineProperty(navigator, 'connection', {{
                    value: {{
                        effectiveType: rtt < 100 ? '4g' : rtt < 300 ? '3g' : '2g',
                        rtt: rtt,
                        downlink: downlink,
                        saveData: false,
                        addEventListener: () => {{}},
                        removeEventListener: () => {{}},
                        onchange: null
                    }},
                    writable: false
                }});
            }}
        ''')

def spoof_touch_api(page, is_touch_device=True):
    """伪装触摸设备"""

    if is_touch_device:
        page.evaluate_on_new_document("""
            () => {
                // 添加 touch support
                Object.defineProperty(navigator, 'maxTouchPoints', {
                    get: () => 5,
                    configurable: true
                });

                // 伪造触摸事件
                const mockTouchEvent = new TouchEvent('touchstart', {
                    bubbles: true,
                    cancelable: true,
                    touches: [{
                        identifier: 0,
                        target: document.body,
                        clientX: 100,
                        clientY: 100,
                        pageX: 100,
                        pageY: 100,
                        screenX: 100,
                        screenY: 100
                    }]
                });

                document.dispatchEvent(mockTouchEvent);
            }
        """)
    else:
        # 确保没有触摸支持
        page.evaluate_on_new_document("""
            () => {
                Object.defineProperty(navigator, 'maxTouchPoints', {
                    get: () => 0,
                    configurable: true
                });
            }
        """)

def spoof_vendor_prefixes(page):
    """处理厂商前缀"""

    page.evaluate_on_new_document("""
        () => {
            // 添加 WebKit 前缀属性
            window.webkit = window.webkit || {};

            // 伪装特定前缀
            window.webkitAudioContext = AudioContext;
            window.webkitSpeechRecognition = window.SpeechRecognition || null;

            // 处理特定前缀的 API
            if (!window.requestAnimationFrame) {
                window.requestAnimationFrame = window.webkitRequestAnimationFrame;
            }

            if (!window.cancelAnimationFrame) {
                window.cancelAnimationFrame = window.webkitCancelAnimationFrame;
            }
        }
    """)

def spoof_webgl_extensions(page):
    """伪装 WebGL 扩展"""

    page.evaluate_on_new_document("""
        () => {
            const canvas = document.createElement('canvas');
            const gl = canvas.getContext('webgl') ||
                       canvas.getContext('experimental-webgl');

            if (gl) {
                // Hook getExtension
                const originalGetExtension = gl.getExtension.bind(gl);

                gl.getExtension = function(name) {
                    // 禁用某些扩展
                    if (name === 'WEBGL_debug_renderer_info') {
                        return null;
                    }

                    // 对其他扩展正常处理
                    return originalGetExtension(name);
                };

                // Hook getSupportedExtensions
                const originalGetSupportedExtensions = gl.getSupportedExtensions?.bind(gl);

                if (originalGetSupportedExtensions) {
                    gl.getSupportedExtensions = function() {
                        const extensions = originalGetSupportedExtensions();
                        // 过滤敏感扩展
                        return extensions.filter(ext =>
                            !ext.includes('debug') &&
                            !ext.includes('EXT_texture_float')
                        );
                    };
                }
            }
        }
    """)

import uuid
import hashlib

class HardwareEntropyManager:
    """硬件熵管理器"""

    def __init__(self):
        self.seeds = {}

    def get_consistent_hardware_id(self, base_string):
        """生成一致的硬件 ID"""
        if base_string not in self.seeds:
            # 使用 base_string 作为种子
            hash_obj = hashlib.sha256(base_string.encode())
            self.seeds[base_string] = hash_obj.hexdigest()[:16]

        return self.seeds[base_string]

    def get_random_hardware_info(self):
        """生成随机但一致的硬件信息"""
        # 基于某种固定值生成
        hardware_id = self.get_consistent_hardware_id('anti-detection-seed')

        # 生成硬件序列号
        serial = f'HW-{hardware_id.upper()}'

        return {
            'hardwareConcurrency': 4 + (hash(hardware_id) % 4),
            'deviceMemory': 4 + (hash(hardware_id) % 4),
            'serial': serial,
            'uuid': str(uuid.UUID(hardware_id.ljust(32, '0')[:32]))
        }

import math
import time

class MouseSimulator:
    def bezier_curve(self, p0, p1, p2, p3, t):
        """三次贝塞尔曲线计算"""
        x = (1-t)**3 * p0[0] + 3*(1-t)**2*t * p1[0] + 3*(1-t)*t**2 * p2[0] + t**3 * p3[0]
        y = (1-t)**3 * p0[1] + 3*(1-t)**2*t * p1[1] + 3*(1-t)*t**2 * p2[1] + t**3 * p3[1]
        return (x, y)

    def natural_move(self, page, start, end, duration=1.0):
        """模拟自然鼠标移动"""
        # 生成控制点，制造随机偏差
        mid_x = (start[0] + end[0]) / 2
        mid_y = (start[1] + end[1]) / 2

        offset = 50
        p0 = start
        p1 = (mid_x + random.uniform(-offset, offset),
               mid_y + random.uniform(-offset, offset))
        p2 = (mid_x + random.uniform(-offset, offset),
               mid_y + random.uniform(-offset, offset))
        p3 = end

        # 分段移动
        steps = 20
        for i in range(steps + 1):
            t = i / steps
            x, y = self.bezier_curve(p0, p1, p2, p3, t)
            page.mouse.move(x, y)
            time.sleep(duration / steps)

# 完整的点击事件序列
def human_click(page, selector):
    element = page.query_selector(selector)
    if not element:
        return

    box = element.bounding_box()

    # 1. hover
    page.mouse.move(box.x + box.width / 2, box.y + box.height / 2)
    time.sleep(random.uniform(0.1, 0.3))

    # 2. mouse down
    page.mouse.down()
    time.sleep(random.uniform(0.05, 0.15))

    # 3. click
    page.mouse.up()
    time.sleep(random.uniform(0.1, 0.2))

import random

class KeyboardSimulator:
    def human_type(self, page, selector, text):
        """模拟人类打字"""
        page.click(selector)

        for char in text:
            page.keyboard.type(char)

            # 随机延迟，模拟真实打字节奏
            delay = random.gauss(0.1, 0.05)  # 正态分布
            delay = max(0.02, min(0.3, delay))  # 限制范围
            time.sleep(delay)

            # 偶尔停顿（思考）
            if random.random() < 0.05:
                time.sleep(random.uniform(0.3, 0.8))

// 真实用户输入会触发一系列事件
inputElement.dispatchEvent(new Event('focus', { bubbles: true }));
inputElement.value = 'text';
inputElement.dispatchEvent(new InputEvent('input', { bubbles: true, data: 'text' }));
inputElement.dispatchEvent(new Event('change', { bubbles: true }));

def human_scroll(page, direction='down', amount=None):
    """模拟人类滚动行为"""
    viewport = page.viewport_size
    scroll_height = page.evaluate('document.documentElement.scrollHeight')

    if amount is None:
        amount = random.randint(200, 500)

    # 分段滚动，模拟惯性
    segments = random.randint(3, 7)
    for _ in range(segments):
        if direction == 'down':
            page.mouse.wheel(0, amount / segments)
        else:
            page.mouse.wheel(0, -amount / segments)

        time.sleep(random.uniform(0.1, 0.3))

    # 随机等待
    time.sleep(random.uniform(0.5, 1.5))

# 不同元素类型的平均停留时间（秒）
DWELL_TIMES = {
    'title': random.uniform(0.5, 1.5),
    'content': random.uniform(2, 5),
    'button': random.uniform(0.3, 0.8),
    'link': random.uniform(0.2, 0.5),
    'form': random.uniform(3, 8),
}

def human_read(page, selector):
    """模拟阅读停留"""
    time.sleep(DWELL_TIMES.get(selector, 1))

def random_window_resize(page):
    """随机调整窗口大小"""
    # 常见分辨率
    resolutions = [
        (1920, 1080), (1366, 768), (1536, 864),
        (1440, 900), (1280, 720), (2560, 1440)
    ]

    # 随机选择新分辨率
    if random.random() < 0.1:  # 10% 概率调整窗口
        width, height = random.choice(resolutions)
        page.set_viewport_size(width, height)
        time.sleep(random.uniform(0.5, 2.0))

PAGE_DWELL_TIMES = {
    'homepage': (3, 10),      # 首页：浏览时间长
    'article': (10, 30),      # 文章：阅读时间长
    'product': (5, 15),       # 商品页：比较选择
    'listing': (2, 8),        # 列表页：快速浏览
    'checkout': (20, 60),     # 结算页：填写信息
    'search': (3, 8),         # 搜索结果：快速筛选
}

def page_dwell_time(page_type):
    """根据页面类型返回停留时间"""
    min_time, max_time = PAGE_DWELL_TIMES.get(page_type, (2, 10))
    return random.uniform(min_time, max_time)

def click_with_offset(page, selector):
    """带位置偏移的点击"""
    element = page.query_selector(selector)
    box = element.bounding_box()

    # 中心点
    center_x = box.x + box.width / 2
    center_y = box.y + box.height / 2

    # 添加随机偏移（在元素范围内）
    offset_x = random.uniform(-box.width * 0.3, box.width * 0.3)
    offset_y = random.uniform(-box.height * 0.3, box.height * 0.3)

    page.mouse.click(center_x + offset_x, center_y + offset_y)

class TabManager:
    """标签页管理器"""

    def __init__(self, context):
        self.context = context
        self.tabs = []

    def open_new_tab(self, url):
        """打开新标签页"""
        new_page = self.context.new_page()
        new_page.goto(url)
        self.tabs.append(new_page)

        # 随机等待后切换回原标签页
        time.sleep(random.uniform(2, 5))

        return new_page

    def switch_tabs(self):
        """随机切换标签页"""
        if len(self.tabs) < 2:
            return

        # 随机选择一个标签页切换
        target_tab = random.choice(self.tabs)
        target_tab.bring_to_front()

        time.sleep(random.uniform(1, 3))

    def close_tab(self, page):
        """关闭标签页"""
        page.close()
        if page in self.tabs:
            self.tabs.remove(page)

def simulate_history_navigation(page):
    """模拟历史导航"""
    # 随机决定是否进行历史导航
    if random.random() < 0.15:  # 15% 概率
        action = random.choice(['back', 'forward'])

        if action == 'back':
            page.go_back()
        else:
            page.go_forward()

        # 导航后的停留
        time.sleep(random.uniform(2, 5))

def simulate_context_menu(page, selector, action='copy'):
    """模拟右键菜单操作"""
    element = page.query_selector(selector)
    box = element.bounding_box()

    # 右键点击
    page.mouse.click(box.x + box.width / 2, box.y + box.height / 2, button='right')

    time.sleep(random.uniform(0.3, 0.6))

    # 使用键盘快捷键执行操作
    if action == 'copy':
        # Ctrl+C
        page.keyboard.down('Control')
        page.keyboard.press('c')
        page.keyboard.up('Control')
    elif action == 'paste':
        # Ctrl+V
        page.keyboard.down('Control')
        page.keyboard.press('v')
        page.keyboard.up('Control')

    time.sleep(random.uniform(0.2, 0.5))

def simulate_drag_and_drop(page, source_selector, target_selector):
    """模拟拖放操作"""
    source = page.query_selector(source_selector)
    target = page.query_selector(target_selector)

    source_box = source.bounding_box()
    target_box = target.bounding_box()

    # 1. 鼠标移动到源元素
    start_x = source_box.x + source_box.width / 2
    start_y = source_box.y + source_box.height / 2

    page.mouse.move(start_x, start_y)
    time.sleep(random.uniform(0.2, 0.4))

    # 2. 按下鼠标
    page.mouse.down()
    time.sleep(random.uniform(0.1, 0.2))

    # 3. 拖动到目标位置（使用贝塞尔曲线）
    end_x = target_box.x + target_box.width / 2
    end_y = target_box.y + target_box.height / 2

    steps = 20
    for i in range(steps + 1):
        t = i / steps
        x = start_x + (end_x - start_x) * t
        y = start_y + (end_y - start_y) * t
        page.mouse.move(x, y)
        time.sleep(0.02)

    # 4. 释放鼠标
    page.mouse.up()
    time.sleep(random.uniform(0.3, 0.6))