4513 lines
231 KiB
Python
4513 lines
231 KiB
Python
"""
|
||
小红书登录服务
|
||
使用 Playwright 模拟浏览器登录小红书
|
||
"""
|
||
from playwright.async_api import async_playwright, Browser, Page, BrowserContext
|
||
from typing import Dict, Any, Optional, Union
|
||
import asyncio
|
||
import json
|
||
import random
|
||
import unicodedata
|
||
import sys
|
||
import os
|
||
import tempfile
|
||
import aiohttp
|
||
import time
|
||
from datetime import datetime
|
||
from pathlib import Path
|
||
from browser_pool import get_browser_pool
|
||
from error_screenshot import save_error_screenshot, save_screenshot_with_html
|
||
from loguru import logger
|
||
from damai_proxy_config import get_random_proxy, format_proxy_for_playwright
|
||
from tianqi_proxy_pool import get_tianqi_proxy_pool
|
||
from xhs_login_helper import get_login_helper, XHSSelectors
|
||
from fingerprint_browser import FingerprintBrowserManager
|
||
|
||
# 配置loguru日志格式
|
||
logger.remove() # 移除默认handler
|
||
logger.add(
|
||
sys.stderr,
|
||
format="<green>{time:YYYY-MM-DD HH:mm:ss}</green> | <level>{level: <8}</level> | <cyan>{message}</cyan>",
|
||
level="INFO"
|
||
)
|
||
|
||
|
||
async def download_image(url: str) -> str:
|
||
"""
|
||
下载网络图片到临时文件
|
||
|
||
Args:
|
||
url: 图片URL
|
||
|
||
Returns:
|
||
本地文件路径
|
||
"""
|
||
try:
|
||
logger.info(f"下载网络图片: {url}")
|
||
async with aiohttp.ClientSession() as session:
|
||
async with session.get(url, timeout=aiohttp.ClientTimeout(total=30)) as response:
|
||
if response.status == 200:
|
||
# 获取文件扩展名
|
||
ext = '.jpg' # 默认jpg
|
||
content_type = response.headers.get('Content-Type', '')
|
||
if 'png' in content_type:
|
||
ext = '.png'
|
||
elif 'jpeg' in content_type or 'jpg' in content_type:
|
||
ext = '.jpg'
|
||
elif 'webp' in content_type:
|
||
ext = '.webp'
|
||
|
||
# 创建临时文件
|
||
temp_dir = Path(tempfile.gettempdir()) / 'xhs_images'
|
||
temp_dir.mkdir(exist_ok=True)
|
||
temp_file = temp_dir / f"img_{random.randint(10000, 99999)}{ext}"
|
||
|
||
# 保存图片
|
||
with open(temp_file, 'wb') as f:
|
||
f.write(await response.read())
|
||
|
||
logger.success(f"✅ 图片下载成功: {temp_file}")
|
||
return str(temp_file)
|
||
else:
|
||
raise Exception(f"HTTP {response.status}")
|
||
except Exception as e:
|
||
logger.error(f"⚠️ 下载图片失败: {str(e)}")
|
||
raise
|
||
|
||
|
||
class XHSLoginService:
|
||
"""小红书登录服务"""
|
||
|
||
def __init__(self, use_pool: bool = True, headless: bool = True, session_id: Optional[str] = None, use_page_isolation: bool = False, use_adspower: bool = False, adspower_profile_id: Optional[str] = None):
|
||
"""
|
||
初始化登录服务
|
||
|
||
Args:
|
||
use_pool: 是否使用浏览器池（默认True，提升性能）
|
||
headless: 是否使用无头模式，False为有头模式（方便调试）
|
||
session_id: 会话 ID，用于并发隔离（不同的session_id会创建独立的浏览器实例）
|
||
use_page_isolation: 是否使用页面隔离模式（扫码登录专用，减少浏览器实例数）
|
||
use_adspower: 是否使用AdsPower指纹浏览器（默认False）
|
||
adspower_profile_id: AdsPower配置文件ID（可选，不指定则自动选择）
|
||
"""
|
||
self.use_pool = use_pool
|
||
self.headless = headless
|
||
self.session_id = session_id # 保存session_id用于并发隔离
|
||
self.use_page_isolation = use_page_isolation # 页面隔离模式
|
||
self.use_adspower = use_adspower # 是否使用AdsPower
|
||
self.adspower_profile_id = adspower_profile_id # AdsPower配置ID
|
||
self.browser_pool = get_browser_pool(headless=headless) if use_pool else None
|
||
self.fingerprint_manager = None # AdsPower管理器
|
||
self.playwright = None
|
||
self.browser: Optional[Browser] = None
|
||
self.context: Optional[BrowserContext] = None
|
||
self.page: Optional[Page] = None
|
||
self.current_phone = None
|
||
|
||
# 打印配置信息
|
||
logger.info(f"[XHSLoginService] 初始化: use_pool={use_pool}, headless={headless}, use_adspower={use_adspower}, profile_id={adspower_profile_id}")
|
||
|
||
async def init_browser(self, cookies: Optional[list] = None, proxy: Optional[dict] = None, user_agent: Optional[str] = None, restore_state: bool = False, use_random_proxy: bool = True, phone: Optional[str] = None):
|
||
"""
|
||
初始化浏览器
|
||
|
||
Args:
|
||
cookies: 可选的Cookie列表，用于恢复登录状态
|
||
proxy: 可选的代理配置，例如 {"server": "http://ip:port", "username": "...", "password": "..."}
|
||
user_agent: 可选的自定义User-Agent
|
||
restore_state: 是否从log_state.json文件恢复完整登录状态
|
||
use_random_proxy: 是否自动使用随机代理（默认True）
|
||
phone: 手机号（用作AdsPower配置名称）
|
||
"""
|
||
try:
|
||
# 如果没有指定代理且启用自动代理，则使用随机代理
|
||
if not proxy and use_random_proxy:
|
||
# 优先使用大麦IP代理池
|
||
tianqi_pool = get_tianqi_proxy_pool()
|
||
logger.info(f"[代理调试] tianqi_pool.is_enabled() = {tianqi_pool.is_enabled()}")
|
||
if tianqi_pool.is_enabled():
|
||
logger.info("[代理] 使用大麦IP代理池...")
|
||
proxy_raw = tianqi_pool.fetch_proxy()
|
||
logger.info(f"[代理调试] tianqi_pool.fetch_proxy() 返回: {proxy_raw}")
|
||
if proxy_raw:
|
||
proxy = tianqi_pool.format_for_playwright(proxy_raw)
|
||
logger.info(f"[代理调试] format_for_playwright() 返回: {proxy}")
|
||
# 输出代理信息
|
||
if proxy.get('username') and proxy.get('password'):
|
||
logger.success(f"[代理] 大麦IP获取成功: {proxy['server']} (认证代理, 用户名: {proxy['username']})")
|
||
else:
|
||
logger.success(f"[代理] 大麦IP获取成功: {proxy['server']} (白名单代理)")
|
||
else:
|
||
logger.warning("[代理] 大麦IP获取失败，尝试使用固定代理...")
|
||
|
||
# 如果大麦IP不可用或获取失败，则使用固定代理池
|
||
if not proxy:
|
||
try:
|
||
proxy_config = get_random_proxy()
|
||
proxy = format_proxy_for_playwright(proxy_config)
|
||
logger.info(f"[代理] 使用固定代理: {proxy_config['name']} ({proxy_config['server']})")
|
||
except Exception as e:
|
||
logger.info(f"[代理] 无可用代理，使用直连访问")
|
||
|
||
# 如果启用AdsPower，使用指纹浏览器（传入已获取的代理和cookies）
|
||
if self.use_adspower:
|
||
logger.info("[AdsPower] 启用AdsPower指纹浏览器模式")
|
||
logger.info(f"[代理调试] 传递给_init_adspower_browser的proxy参数: {proxy}")
|
||
if cookies:
|
||
logger.info(f"[Cookie调试] 传递给_init_adspower_browser的cookies数量: {len(cookies)}")
|
||
return await self._init_adspower_browser(proxy=proxy, phone=phone, cookies=cookies)
|
||
# 如果要求恢复状态，先加载 login_state.json
|
||
login_state = None
|
||
if restore_state and os.path.exists('login_state.json'):
|
||
try:
|
||
with open('login_state.json', 'r', encoding='utf-8') as f:
|
||
login_state = json.load(f)
|
||
logger.success("✅ 加载到保存的登录状态")
|
||
|
||
# 使用保存的配置
|
||
cookies = login_state.get('cookies', cookies)
|
||
if not user_agent and login_state.get('user_agent'):
|
||
user_agent = login_state['user_agent']
|
||
except Exception as e:
|
||
logger.error(f"⚠️ 加载登录状态失败: {str(e)}")
|
||
|
||
# 使用浏览器池
|
||
if self.use_pool and self.browser_pool:
|
||
# 扫码登录使用页面隔离模式
|
||
if self.use_page_isolation and self.session_id:
|
||
logger.info(f"[页面隔离模式] 获取扫码登录页面 (session_id={self.session_id})")
|
||
|
||
# 获取或创建页面
|
||
self.page = await self.browser_pool.get_qrcode_page(self.session_id)
|
||
|
||
# 使用浏览器池的主浏览器和context
|
||
self.browser = self.browser_pool.browser
|
||
self.context = self.browser_pool.context
|
||
|
||
logger.success("浏览器初始化成功（页面隔离模式）")
|
||
return
|
||
|
||
# 普通浏览器池模式
|
||
logger.info(f"[浏览器池模式] 从浏览器池获取实例 (session_id={self.session_id}, headless={self.headless})")
|
||
self.browser, self.context, self.page = await self.browser_pool.get_browser(
|
||
cookies=cookies, proxy=proxy, user_agent=user_agent, session_id=self.session_id,
|
||
headless=self.headless # 传递headless参数
|
||
)
|
||
|
||
# 保存proxy配置
|
||
if proxy:
|
||
self.proxy = proxy
|
||
|
||
# 检查page状态，如果是空白页或已关闭，重新创建page
|
||
try:
|
||
current_url = self.page.url
|
||
logger.info(f"当前URL: {current_url}")
|
||
|
||
if current_url == 'about:blank' or current_url == '':
|
||
logger.warning("[浏览器池] 检测到空白页面，重新创建page")
|
||
try:
|
||
# 关闭旧page
|
||
await self.page.close()
|
||
except Exception as e:
|
||
logger.error(f"[浏览器池] 关闭旧page失败: {str(e)}")
|
||
# 创建新page
|
||
self.page = await self.context.new_page()
|
||
logger.success(f"[浏览器池] 已创建新page, 新URL: {self.page.url}")
|
||
|
||
# 更新浏览器池中保存的page引用
|
||
if self.session_id and self.session_id in self.browser_pool.temp_browsers:
|
||
self.browser_pool.temp_browsers[self.session_id]["page"] = self.page
|
||
logger.success("[浏览器池] 已更新浏览器池中的page引用")
|
||
except Exception as e:
|
||
logger.error(f"[浏览器池] 检查page状态异常: {str(e)}")
|
||
|
||
# 如果有localStorage/sessionStorage，恢复它们
|
||
if login_state:
|
||
await self._restore_storage(login_state)
|
||
|
||
logger.success("浏览器初始化成功（池模式）")
|
||
return
|
||
|
||
# 传统模式（每次新建）
|
||
logger.info("[传统模式] 创建新浏览器实例")
|
||
|
||
# Windows环境下，需要设置事件循环策略
|
||
if sys.platform == 'win32':
|
||
try:
|
||
asyncio.set_event_loop_policy(asyncio.WindowsProactorEventLoopPolicy())
|
||
except Exception as e:
|
||
logger.error(f"警告: 设置事件循环策略失败: {str(e)}")
|
||
|
||
self.playwright = await async_playwright().start()
|
||
|
||
# 启动浏览器（使用chromium）
|
||
# headless=True 在服务器环境下运行，不显示浏览器界面
|
||
launch_kwargs = {
|
||
"headless": self.headless, # 使用配置的headless参数
|
||
"args": [
|
||
'--disable-blink-features=AutomationControlled',
|
||
'--disable-infobars',
|
||
'--no-first-run',
|
||
'--no-default-browser-check',
|
||
],
|
||
}
|
||
if proxy:
|
||
launch_kwargs["proxy"] = proxy # 直接使用proxy字典
|
||
self.proxy = proxy # 保存proxy配置供后续使用
|
||
|
||
self.browser = await self.playwright.chromium.launch(**launch_kwargs)
|
||
|
||
# 创建浏览器上下文，模拟真实用户
|
||
context_kwargs = {
|
||
"viewport": login_state.get('viewport') if login_state else {'width': 1280, 'height': 720},
|
||
"user_agent": user_agent or 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/120.0.0.0 Safari/537.36',
|
||
}
|
||
self.context = await self.browser.new_context(**context_kwargs)
|
||
|
||
# 添加初始化脚本，隐藏自动化特征
|
||
await self.context.add_init_script("""
|
||
// 移除webdriver标记
|
||
Object.defineProperty(navigator, 'webdriver', {
|
||
get: () => undefined
|
||
});
|
||
|
||
// 阻止检测自动化调试端口
|
||
window.chrome = {
|
||
runtime: {}
|
||
};
|
||
|
||
// 阻止检测Chrome DevTools Protocol
|
||
const originalFetch = window.fetch;
|
||
window.fetch = function(...args) {
|
||
const url = args[0];
|
||
// 阻止小红书检测本地调试端口
|
||
if (typeof url === 'string' && (
|
||
url.includes('127.0.0.1:9222') ||
|
||
url.includes('127.0.0.1:54345') ||
|
||
url.includes('localhost:9222') ||
|
||
url.includes('chrome-extension://invalid')
|
||
)) {
|
||
return Promise.reject(new Error('blocked'));
|
||
}
|
||
return originalFetch.apply(this, args);
|
||
};
|
||
|
||
// 阻止XMLHttpRequest检测
|
||
const originalXHROpen = XMLHttpRequest.prototype.open;
|
||
XMLHttpRequest.prototype.open = function(...args) {
|
||
const url = args[1];
|
||
if (typeof url === 'string' && (
|
||
url.includes('127.0.0.1:9222') ||
|
||
url.includes('127.0.0.1:54345') ||
|
||
url.includes('localhost:9222') ||
|
||
url.includes('chrome-extension://invalid')
|
||
)) {
|
||
throw new Error('blocked');
|
||
}
|
||
return originalXHROpen.apply(this, args);
|
||
};
|
||
|
||
// 添加chrome.app
|
||
Object.defineProperty(window, 'chrome', {
|
||
get: () => ({
|
||
app: {
|
||
isInstalled: false,
|
||
},
|
||
webstore: {
|
||
onInstallStageChanged: {},
|
||
onDownloadProgress: {},
|
||
},
|
||
runtime: {
|
||
PlatformOs: {
|
||
MAC: 'mac',
|
||
WIN: 'win',
|
||
ANDROID: 'android',
|
||
CROS: 'cros',
|
||
LINUX: 'linux',
|
||
OPENBSD: 'openbsd',
|
||
},
|
||
PlatformArch: {
|
||
ARM: 'arm',
|
||
X86_32: 'x86-32',
|
||
X86_64: 'x86-64',
|
||
},
|
||
PlatformNaclArch: {
|
||
ARM: 'arm',
|
||
X86_32: 'x86-32',
|
||
X86_64: 'x86-64',
|
||
},
|
||
RequestUpdateCheckStatus: {
|
||
THROTTLED: 'throttled',
|
||
NO_UPDATE: 'no_update',
|
||
UPDATE_AVAILABLE: 'update_available',
|
||
},
|
||
OnInstalledReason: {
|
||
INSTALL: 'install',
|
||
UPDATE: 'update',
|
||
CHROME_UPDATE: 'chrome_update',
|
||
SHARED_MODULE_UPDATE: 'shared_module_update',
|
||
},
|
||
OnRestartRequiredReason: {
|
||
APP_UPDATE: 'app_update',
|
||
OS_UPDATE: 'os_update',
|
||
PERIODIC: 'periodic',
|
||
},
|
||
},
|
||
}),
|
||
configurable: true,
|
||
});
|
||
|
||
// 模拟permissions
|
||
const originalQuery = window.navigator.permissions.query;
|
||
window.navigator.permissions.query = (parameters) => (
|
||
parameters.name === 'notifications' ?
|
||
Promise.resolve({ state: Notification.permission }) :
|
||
originalQuery(parameters)
|
||
);
|
||
|
||
// 添加plugins
|
||
Object.defineProperty(navigator, 'plugins', {
|
||
get: () => [
|
||
{
|
||
0: {type: "application/x-google-chrome-pdf", suffixes: "pdf", description: "Portable Document Format"},
|
||
description: "Portable Document Format",
|
||
filename: "internal-pdf-viewer",
|
||
length: 1,
|
||
name: "Chrome PDF Plugin"
|
||
},
|
||
{
|
||
0: {type: "application/pdf", suffixes: "pdf", description: ""},
|
||
description: "",
|
||
filename: "mhjfbmdgcfjbbpaeojofohoefgiehjai",
|
||
length: 1,
|
||
name: "Chrome PDF Viewer"
|
||
},
|
||
{
|
||
0: {type: "application/x-nacl", suffixes: "", description: "Native Client Executable"},
|
||
1: {type: "application/x-pnacl", suffixes: "", description: "Portable Native Client Executable"},
|
||
description: "",
|
||
filename: "internal-nacl-plugin",
|
||
length: 2,
|
||
name: "Native Client"
|
||
}
|
||
],
|
||
});
|
||
""")
|
||
logger.success("✅ 已注入反检测脚本")
|
||
|
||
# 如果提供了Cookies，注入到浏览器上下文
|
||
if cookies:
|
||
await self.context.add_cookies(cookies)
|
||
logger.success(f"已注入 {len(cookies)} 个Cookie")
|
||
|
||
# 创建新页面
|
||
self.page = await self.context.new_page()
|
||
|
||
# 使用Playwright路由拦截，直接阻止小红书的检测请求
|
||
async def block_detection_requests(route, request):
|
||
url = request.url
|
||
# 阻止所有检测自动化的请求
|
||
if any([
|
||
'127.0.0.1:9222' in url,
|
||
'127.0.0.1:54345' in url,
|
||
'localhost:9222' in url,
|
||
'chrome-extension://invalid' in url,
|
||
'chrome-extension://bla' in url,
|
||
]):
|
||
await route.abort()
|
||
else:
|
||
await route.continue_()
|
||
|
||
# 注册路由拦截，匹配所有请求
|
||
await self.page.route('**/*', block_detection_requests)
|
||
logger.success("✅ 已启用请求拦截，阻止检测自动化")
|
||
|
||
# 添加页面跳转监控，检测无限跳转
|
||
self.redirect_count = 0
|
||
self.last_redirect_time = 0
|
||
|
||
async def on_response(response):
|
||
"""监控页面响应，检测重定向循环"""
|
||
if response.status in [301, 302, 303, 307, 308]:
|
||
import time
|
||
current_time = time.time()
|
||
if current_time - self.last_redirect_time < 1: # 1秒内连续重定向
|
||
self.redirect_count += 1
|
||
if self.redirect_count > 5:
|
||
logger.warning(f"⚠️ 检测到频繁重定向 ({self.redirect_count}次)，可能是无限跳转")
|
||
else:
|
||
self.redirect_count = 0
|
||
self.last_redirect_time = current_time
|
||
|
||
self.page.on('response', on_response)
|
||
|
||
# 如果有localStorage/sessionStorage，恢复它们
|
||
if login_state:
|
||
await self._restore_storage(login_state)
|
||
|
||
logger.success("浏览器初始化成功（传统模式）")
|
||
|
||
except Exception as e:
|
||
logger.error(f"浏览器初始化失败: {str(e)}")
|
||
raise
|
||
|
||
async def _init_adspower_browser(self, proxy: Optional[Union[str, dict]] = None, phone: Optional[str] = None, cookies: Optional[list] = None):
|
||
"""
|
||
初始化AdsPower指纹浏览器（参考ai_mip项目完整流程）
|
||
|
||
流程：
|
||
1. 检查AdsPower运行状态
|
||
2. 获取或创建浏览器配置
|
||
3. 更新代理配置（如果有）
|
||
4. 启动浏览器
|
||
5. 通过CDP连接
|
||
6. 注入Cookie（如果有）
|
||
|
||
Args:
|
||
proxy: 可选的代理配置，支持两种格式：
|
||
- 字符串: 'http://ip:port' 或 'http://user:pass@ip:port'
|
||
- 字典: {'server': 'http://ip:port', 'username': '...', 'password': '...'}
|
||
phone: 手机号（用作配置名称）
|
||
cookies: 可选的Cookie列表，连接成功后注入
|
||
"""
|
||
try:
|
||
logger.info("\n" + "="*70)
|
||
logger.info("[AdsPower] 开始初始化指纹浏览器")
|
||
logger.info("="*70)
|
||
|
||
# 步骤1: 创建指纹浏览器管理器
|
||
logger.info("[步骤 1/5] 创建指纹浏览器管理器...")
|
||
self.fingerprint_manager = FingerprintBrowserManager()
|
||
logger.success(">> 管理器创建成功")
|
||
|
||
# 步骤2: 检查AdsPower是否运行
|
||
logger.info("\n[步骤 2/5] 检查AdsPower运行状态...")
|
||
is_running = await self.fingerprint_manager.check_adspower_status()
|
||
if not is_running:
|
||
logger.error("!! AdsPower未运行")
|
||
raise Exception("警告: AdsPower未运行，请先启动AdsPower应用")
|
||
logger.success(">> AdsPower运行正常")
|
||
|
||
# 格式转换：如果proxy是字符串，转换为字典格式
|
||
proxy_config = None
|
||
if proxy:
|
||
if isinstance(proxy, str):
|
||
# 字符串格式: 'http://ip:port' 或 'http://user:pass@ip:port'
|
||
logger.info(f"[代理转换] 检测到字符串格式代理: {proxy}")
|
||
proxy_config = {'server': proxy}
|
||
logger.info(f"[代理转换] 已转换为字典格式")
|
||
elif isinstance(proxy, dict):
|
||
# 已经是字典格式
|
||
proxy_config = proxy
|
||
logger.info(f"[代理配置] 使用字典格式代理")
|
||
else:
|
||
logger.warning(f"[代理配置] 未知的代理类型: {type(proxy).__name__}，将忽略")
|
||
proxy_config = None
|
||
|
||
# 步骤3: 获取或创建配置文件
|
||
logger.info("\n[步骤 3/5] 获取或创建浏览器配置...")
|
||
if not self.adspower_profile_id:
|
||
# 如果提供了cookies，说明这是临时发布环境，强制创建新配置
|
||
force_create = cookies is not None and len(cookies) > 0
|
||
|
||
if force_create:
|
||
logger.info(" 检测到Cookie，创建临时发布环境（Cookie将在创建时直接注入）...")
|
||
elif phone:
|
||
logger.info(f" 为手机号 {phone} 查找或创建配置...")
|
||
else:
|
||
logger.info(" 未指定配置ID，自动选择配置...")
|
||
|
||
self.adspower_profile_id = await self.fingerprint_manager.get_or_create_profile(
|
||
proxy_config=proxy_config,
|
||
phone=phone,
|
||
force_create=force_create, # 有Cookie时强制创建临时环境
|
||
cookies=cookies # 传递cookies到创建接口
|
||
)
|
||
|
||
if not self.adspower_profile_id:
|
||
logger.error("!! 获取配置失败")
|
||
raise Exception("获取AdsPower配置失败")
|
||
|
||
if force_create:
|
||
logger.success(f">> 临时环境创建成功（Cookie已注入）: {self.adspower_profile_id}")
|
||
else:
|
||
logger.success(f">> 自动选择配置: {self.adspower_profile_id}")
|
||
else:
|
||
logger.info(f" 使用指定配置: {self.adspower_profile_id}")
|
||
logger.success(f">> 配置ID确认: {self.adspower_profile_id}")
|
||
|
||
# 输出代理信息
|
||
if proxy_config:
|
||
logger.info("\n 代理配置信息:")
|
||
logger.info(f" 服务器: {proxy_config.get('server', 'N/A')}")
|
||
if proxy_config.get('username') and proxy_config.get('password'):
|
||
logger.info(f" 认证: 是 (用户名: {proxy_config['username']})")
|
||
else:
|
||
logger.info(" 认证: 否 (白名单模式)")
|
||
else:
|
||
logger.info("\n 代理配置: 未使用代理（直连）")
|
||
|
||
# 步骤4: 启动浏览器
|
||
logger.info("\n[步骤 4/5] 启动浏览器...")
|
||
logger.info(f" 配置ID: {self.adspower_profile_id}")
|
||
if proxy_config:
|
||
logger.info(f" 代理服务器: {proxy_config.get('server')}")
|
||
|
||
cdp_url = await self.fingerprint_manager.start_browser(
|
||
profile_id=self.adspower_profile_id,
|
||
proxy_config=proxy_config
|
||
)
|
||
|
||
if not cdp_url:
|
||
logger.error("!! 浏览器启动失败")
|
||
raise Exception("AdsPower浏览器启动失败")
|
||
|
||
logger.success(f">> 浏览器启动成功")
|
||
logger.info(f" CDP地址: {cdp_url}")
|
||
|
||
# 步骤5: 通过CDP连接到浏览器
|
||
logger.info("\n[步骤 5/5] 通过CDP连接浏览器...")
|
||
logger.info(f" 连接地址: {cdp_url}")
|
||
|
||
browser, context, page = await self.fingerprint_manager.connect_browser(cdp_url)
|
||
|
||
if not browser or not context or not page:
|
||
logger.error("!! CDP连接失败")
|
||
raise Exception("CDP连接失败")
|
||
|
||
self.browser = browser
|
||
self.context = context
|
||
self.page = page
|
||
|
||
logger.success(">> CDP连接成功")
|
||
|
||
# 输出最终信息
|
||
logger.info("\n" + "-"*70)
|
||
logger.info("[初始化完成摘要]")
|
||
logger.info("-"*70)
|
||
logger.success(f">> 配置ID: {self.adspower_profile_id}")
|
||
logger.success(f">> 浏览器类型: AdsPower 指纹浏览器")
|
||
logger.success(f">> 代理状态: {'已启用' if proxy_config else '未启用'}")
|
||
if proxy_config:
|
||
logger.success(f">> 代理服务器: {proxy_config.get('server')}")
|
||
if cookies:
|
||
logger.success(f">> Cookie状态: 已注入（创建时）")
|
||
logger.success(f">> Cookie数量: {len(cookies)}")
|
||
else:
|
||
logger.success(f">> Cookie状态: 未注入")
|
||
logger.success(f">> 上下文数: {len(browser.contexts)}")
|
||
logger.success(f">> 页面数: {len(context.pages)}")
|
||
logger.info("="*70 + "\n")
|
||
|
||
except Exception as e:
|
||
logger.error("\n" + "="*70)
|
||
logger.error("!! [AdsPower] 初始化失败")
|
||
logger.error("="*70)
|
||
logger.error(f"错误信息: {str(e)}")
|
||
logger.error("提示: 请确保 AdsPower 应用已启动并正常运行")
|
||
logger.error("="*70 + "\n")
|
||
raise
|
||
|
||
async def _restore_storage(self, login_state: dict):
|
||
"""恢夏localStorage和sessionStorage"""
|
||
try:
|
||
# 首先访问小红书的任意页面，以便注入storage
|
||
target_url = login_state.get('url', 'https://www.xiaohongshu.com')
|
||
logger.debug(f"正在访问 {target_url} 以注入storage...")
|
||
|
||
# 设置更短的超时时间，避免长时间等待
|
||
try:
|
||
await self.page.goto(target_url, wait_until='domcontentloaded', timeout=15000)
|
||
await asyncio.sleep(1)
|
||
|
||
# 检查是否被重定向到登录页
|
||
current_url = self.page.url
|
||
if 'login' in current_url.lower():
|
||
logger.warning("⚠️ 检测到被重定向到登录页，跳过storage恢复")
|
||
return
|
||
|
||
except Exception as e:
|
||
logger.error(f"⚠️ 访问页面失败: {str(e)}，跳过storage恢复")
|
||
return
|
||
|
||
# 恢夏localStorage
|
||
if login_state.get('localStorage'):
|
||
for key, value in login_state['localStorage'].items():
|
||
try:
|
||
await self.page.evaluate(f'localStorage.setItem("{key}", {json.dumps(value)})')
|
||
except Exception as e:
|
||
logger.error(f"⚠️ 设置localStorage {key} 失败: {str(e)}")
|
||
logger.success(f"✅ 已恢复 {len(login_state['localStorage'])} 个localStorage项")
|
||
|
||
# 恢夏sessionStorage
|
||
if login_state.get('sessionStorage'):
|
||
for key, value in login_state['sessionStorage'].items():
|
||
try:
|
||
await self.page.evaluate(f'sessionStorage.setItem("{key}", {json.dumps(value)})')
|
||
except Exception as e:
|
||
logger.error(f"⚠️ 设置sessionStorage {key} 失败: {str(e)}")
|
||
logger.success(f"✅ 已恢复 {len(login_state['sessionStorage'])} 个sessionStorage项")
|
||
|
||
except Exception as e:
|
||
logger.error(f"⚠️ 恢夏storage失败: {str(e)}")
|
||
|
||
async def init_browser_with_storage_state(self, storage_state_path: str, proxy: Optional[dict] = None):
|
||
"""
|
||
使用Playwright原生storage_state初始化浏览器（最优方案）
|
||
|
||
Args:
|
||
storage_state_path: storage_state文件路径
|
||
proxy: 可选的代理配置
|
||
"""
|
||
try:
|
||
if not os.path.exists(storage_state_path):
|
||
raise Exception(f"storage_state文件不存在: {storage_state_path}")
|
||
|
||
logger.success(f"✅ 使用 storage_state 初始化浏览器: {storage_state_path}")
|
||
|
||
# Windows环境下，需要设置事件循环策略
|
||
if sys.platform == 'win32':
|
||
try:
|
||
asyncio.set_event_loop_policy(asyncio.WindowsProactorEventLoopPolicy())
|
||
except Exception as e:
|
||
logger.error(f"警告: 设置事件循环策略失败: {str(e)}")
|
||
|
||
self.playwright = await async_playwright().start()
|
||
|
||
# 启动浏览器
|
||
launch_kwargs = {
|
||
"headless": self.headless,
|
||
"args": [
|
||
'--disable-blink-features=AutomationControlled',
|
||
'--disable-infobars',
|
||
'--no-first-run',
|
||
'--no-default-browser-check',
|
||
],
|
||
}
|
||
if proxy:
|
||
launch_kwargs["proxy"] = proxy # 直接使用proxy字典
|
||
|
||
self.browser = await self.playwright.chromium.launch(**launch_kwargs)
|
||
|
||
# 使用storage_state创建上下文（Playwright原生API）
|
||
self.context = await self.browser.new_context(storage_state=storage_state_path)
|
||
logger.success(f"✅ 已使用 storage_state 创建浏览器上下文")
|
||
|
||
# 添加反检测脚本
|
||
await self.context.add_init_script("""
|
||
// 移除webdriver标记
|
||
Object.defineProperty(navigator, 'webdriver', {
|
||
get: () => undefined
|
||
});
|
||
|
||
// 阻止检测自动化调试端口
|
||
window.chrome = {
|
||
runtime: {}
|
||
};
|
||
""")
|
||
logger.success("✅ 已注入反检测脚本")
|
||
|
||
# 创建页面
|
||
self.page = await self.context.new_page()
|
||
|
||
# 添加请求拦截
|
||
async def block_detection_requests(route, request):
|
||
url = request.url
|
||
if any([
|
||
'127.0.0.1:9222' in url,
|
||
'127.0.0.1:54345' in url,
|
||
'localhost:9222' in url,
|
||
'chrome-extension://invalid' in url,
|
||
]):
|
||
await route.abort()
|
||
else:
|
||
await route.continue_()
|
||
|
||
await self.page.route('**/*', block_detection_requests)
|
||
logger.success("✅ 已启用请求拦截，阻止检测自动化")
|
||
|
||
logger.success("✅ 浏览器初始化成功（storage_state模式）")
|
||
|
||
except Exception as e:
|
||
logger.error(f"浏览器初始化失败: {str(e)}")
|
||
raise
|
||
|
||
async def close_browser(self):
|
||
"""关闭浏览器（池模式下不关闭，仅清理引用）"""
|
||
try:
|
||
# 浏览器池模式：不关闭浏览器，保持复用
|
||
if self.use_pool and self.browser_pool:
|
||
logger.info("[浏览器池模式] 保留浏览器实例供下次复用")
|
||
# 仅清理当前服务的引用，浏览器池保持运行
|
||
self.browser = None
|
||
self.context = None
|
||
self.page = None
|
||
return
|
||
|
||
# 传统模式：完全关闭
|
||
logger.info("[传统模式] 完全关闭浏览器")
|
||
|
||
# 如果使用AdsPower，需要调用API关闭
|
||
if self.use_adspower and self.fingerprint_manager and self.adspower_profile_id:
|
||
try:
|
||
logger.info(f"[关闭浏览器] 调用AdsPower API关闭配置: {self.adspower_profile_id}")
|
||
await self.fingerprint_manager.stop_browser(self.adspower_profile_id)
|
||
logger.success("[关闭浏览器] AdsPower浏览器已关闭")
|
||
except Exception as e:
|
||
logger.error(f"[关闭浏览器] AdsPower关闭失败: {str(e)}")
|
||
|
||
# 关闭Playwright实例
|
||
if self.page:
|
||
await self.page.close()
|
||
if self.context:
|
||
await self.context.close()
|
||
if self.browser:
|
||
await self.browser.close()
|
||
if self.playwright:
|
||
await self.playwright.stop()
|
||
logger.success("浏览器已关闭")
|
||
except Exception as e:
|
||
logger.error(f"关闭浏览器异常: {str(e)}")
|
||
|
||
async def get_adspower_cookies_after_close(self) -> Optional[list]:
|
||
"""
|
||
关闭浏览器后查询AdsPower Cookie
|
||
AdsPower需要先关闭浏览器，Cookie才会同步到配置
|
||
|
||
Returns:
|
||
Cookie数组，失败返回None
|
||
"""
|
||
if not self.use_adspower or not self.fingerprint_manager or not self.adspower_profile_id:
|
||
logger.warning("[查询Cookie] 未使用AdsPower或配置ID为空")
|
||
return None
|
||
|
||
try:
|
||
logger.info("="*50)
|
||
logger.info("[查询Cookie] 浏览器已关闭，开始查询AdsPower环境Cookie...")
|
||
logger.info(f"[查询Cookie] 配置ID: {self.adspower_profile_id}")
|
||
|
||
# 等待一下，确俜Cookie已经同步
|
||
await asyncio.sleep(1)
|
||
|
||
adspower_cookies = await self.fingerprint_manager.get_profile_cookies(self.adspower_profile_id)
|
||
|
||
if adspower_cookies:
|
||
logger.success(f"[查询Cookie] 成功获取AdsPower Cookie: {len(adspower_cookies)}个")
|
||
logger.info(f"[查询Cookie] Cookie示例: {[c['name'] for c in adspower_cookies[:5]]}...")
|
||
logger.info("="*50)
|
||
return adspower_cookies
|
||
else:
|
||
logger.warning("[查询Cookie] 未能获取AdsPower Cookie")
|
||
logger.info("="*50)
|
||
return None
|
||
|
||
except Exception as e:
|
||
logger.error(f"[查询Cookie] 异常: {str(e)}")
|
||
import traceback
|
||
traceback.print_exc()
|
||
logger.info("="*50)
|
||
return None
|
||
|
||
async def extract_verification_qrcode(self) -> Optional[str]:
|
||
"""
|
||
提取验证页面的二维码图片
|
||
|
||
Returns:
|
||
二维码图片的base64数据，如果提取失败则返回none
|
||
"""
|
||
try:
|
||
if not self.page:
|
||
return None
|
||
|
||
logger.debug("正在提取验证二维码...")
|
||
|
||
# 先检查是否出现“请求太频繁”错误
|
||
try:
|
||
error_text_elem = await self.page.query_selector('.confirm-text')
|
||
if error_text_elem:
|
||
error_text = await error_text_elem.inner_text()
|
||
if '请求太频繁' in error_text or '请稍后再试' in error_text:
|
||
logger.warning("⚠️ 检测到'请求太频繁'错误，尝试点击刷新按钮")
|
||
|
||
# 查找刷新按钮
|
||
refresh_btn_selectors = [
|
||
'.btn:has-text("刷新")',
|
||
'button:has-text("刷新")',
|
||
'div:has-text("刷新")',
|
||
'.btn.btn-stroke',
|
||
'.refresh-container .btn',
|
||
]
|
||
|
||
for selector in refresh_btn_selectors:
|
||
try:
|
||
refresh_btn = await self.page.query_selector(selector)
|
||
if refresh_btn:
|
||
logger.info(f"找到刷新按钮: {selector}")
|
||
await refresh_btn.click()
|
||
logger.success("✅ 已点击刷新按钮")
|
||
|
||
# 等待页面重新加载
|
||
await asyncio.sleep(2)
|
||
logger.info("等待页面重新加载...")
|
||
break
|
||
except Exception as e:
|
||
logger.debug(f"尝试选择器 {selector} 失败: {str(e)}")
|
||
continue
|
||
except Exception as e:
|
||
logger.debug(f"检查'请求太频繁'错误时失败: {str(e)}")
|
||
|
||
# 尝试查找二维码图片元素
|
||
qrcode_selectors = [
|
||
'.qrcode-img', # 小红书风控二维码的特定class
|
||
'img.qrcode-img',
|
||
'.qrcode-container img', # 二维码容器内的图片
|
||
'.verify-captcha img', # 验证弹窗内的图片
|
||
'img[alt*="二维码"]', # alt属性包含“二维码”
|
||
'img[alt*="qrcode"]', # alt属性包含“qrcode”
|
||
]
|
||
|
||
for selector in qrcode_selectors:
|
||
try:
|
||
qrcode_img = await self.page.wait_for_selector(selector, timeout=3000)
|
||
if qrcode_img:
|
||
logger.success(f"✅ 找到二维码图片: {selector}")
|
||
|
||
# 获取图片src属性
|
||
src = await qrcode_img.get_attribute('src')
|
||
if src:
|
||
# 如果是base64格式，直接返回
|
||
if src.startswith('data:image'):
|
||
logger.success("✅ 二维码已是base64格式，直接返回")
|
||
return src
|
||
|
||
# 如果是URL，尝试下载并转换为base64
|
||
logger.info(f"二维码是URL格式: {src[:100]}...")
|
||
try:
|
||
async with aiohttp.ClientSession() as session:
|
||
async with session.get(src, timeout=aiohttp.ClientTimeout(total=10)) as response:
|
||
if response.status == 200:
|
||
img_data = await response.read()
|
||
import base64
|
||
img_base64 = base64.b64encode(img_data).decode('utf-8')
|
||
# 根据内容类型确定格式
|
||
content_type = response.headers.get('Content-Type', 'image/png')
|
||
base64_str = f"data:{content_type};base64,{img_base64}"
|
||
logger.success("✅ 成功下载并转换为base64")
|
||
return base64_str
|
||
except Exception as e:
|
||
logger.error(f"⚠️ 下载二维码图片失败: {str(e)}")
|
||
|
||
# 如果src方法失败，尝试截图
|
||
logger.info("尝试截取二维码区域...")
|
||
screenshot_bytes = await qrcode_img.screenshot()
|
||
if screenshot_bytes:
|
||
import base64
|
||
img_base64 = base64.b64encode(screenshot_bytes).decode('utf-8')
|
||
base64_str = f"data:image/png;base64,{img_base64}"
|
||
logger.success("✅ 成功截取二维码并转换为base64")
|
||
return base64_str
|
||
|
||
break
|
||
except Exception as e:
|
||
logger.error(f"尝试选择器 {selector} 失败: {str(e)}")
|
||
continue
|
||
|
||
logger.warning("⚠️ 未找到二维码图片")
|
||
return None
|
||
|
||
except Exception as e:
|
||
logger.error(f"⚠️ 提取二维码失败: {str(e)}")
|
||
return None
|
||
|
||
async def refresh_qrcode(self) -> Dict[str, Any]:
|
||
"""
|
||
刷新过期的二维码
|
||
自动点击页面上的刷新按钮，获取新的二维码
|
||
|
||
Returns:
|
||
Dict: {"success": bool, "qrcode_image": str, "message": str}
|
||
"""
|
||
try:
|
||
logger.info(f"[刷新二维码] 开始")
|
||
logger.info(f"[刷新二维码] 浏览器状态: browser={self.browser is not None}, context={self.context is not None}, page={self.page is not None}")
|
||
|
||
if not self.page:
|
||
logger.error("[刷新二维码] 错误: 页面对象不存在")
|
||
return {
|
||
"success": False,
|
||
"message": "页面对象不存在，请重新发送验证码"
|
||
}
|
||
|
||
# 检查页面是否关闭
|
||
try:
|
||
current_url = self.page.url
|
||
logger.info(f"[刷新二维码] 当前URL: {current_url}")
|
||
except Exception as e:
|
||
logger.error(f"[刷新二维码] 错误: 无法访问页面URL，页面可能已关闭: {str(e)}")
|
||
return {
|
||
"success": False,
|
||
"message": "页面已关闭，请重新发送验证码"
|
||
}
|
||
|
||
# 查找刷新按钮（小红书的刷新按钮通常在二维码下方）
|
||
logger.info("[刷新二维码] 步骤1: 开始查找刷新按钮...")
|
||
refresh_selectors = [
|
||
'text="点击二维码区域刷新"',
|
||
'text="刷新"',
|
||
'text="重新获取"',
|
||
'.refresh-btn',
|
||
'.qrcode-refresh',
|
||
'button:has-text("刷新")',
|
||
'div:has-text("刷新")',
|
||
# 尝试点击二维码图片本身（很多网站点击二维码就可以刷新）
|
||
'.qrcode-image',
|
||
'img[alt*="二维码"]',
|
||
'canvas', # 某些二维码是canvas绘制的
|
||
]
|
||
|
||
refresh_btn = None
|
||
for selector in refresh_selectors:
|
||
try:
|
||
refresh_btn = await self.page.query_selector(selector)
|
||
if refresh_btn:
|
||
is_visible = await refresh_btn.is_visible()
|
||
if is_visible:
|
||
logger.success(f"[刷新二维码] 找到刷新按钮: {selector}")
|
||
break
|
||
else:
|
||
logger.debug(f"[刷新二维码] 选择器 {selector} 存在但不可见")
|
||
except Exception as e:
|
||
logger.debug(f"[刷新二维码] 尝试选择器 {selector} 失败: {str(e)}")
|
||
continue
|
||
|
||
if not refresh_btn:
|
||
logger.warning("[刷新二维码] 未找到刷新按钮，尝试点击整个二维码区域")
|
||
logger.info("[刷新二维码] 步骤2: 尝试查找二维码区域...")
|
||
# 如果找不到刷新按钮，尝试直接点击二维码区域
|
||
qrcode_area_selectors = [
|
||
'.qrcode-container',
|
||
'.qrcode-box',
|
||
'.captcha-qrcode',
|
||
'[class*="qrcode"]',
|
||
'[class*="QRCode"]',
|
||
]
|
||
|
||
for selector in qrcode_area_selectors:
|
||
try:
|
||
refresh_btn = await self.page.query_selector(selector)
|
||
if refresh_btn:
|
||
is_visible = await refresh_btn.is_visible()
|
||
if is_visible:
|
||
logger.success(f"[刷新二维码] 找到二维码区域: {selector}")
|
||
break
|
||
else:
|
||
logger.debug(f"[刷新二维码] 选择器 {selector} 存在但不可见")
|
||
except Exception as e:
|
||
logger.debug(f"[刷新二维码] 尝试选择器 {selector} 失败: {str(e)}")
|
||
continue
|
||
|
||
if not refresh_btn:
|
||
logger.error("[刷新二维码] 未找到任何可点击的元素")
|
||
logger.info("[刷新二维码] 步骤3: 尝试点击页面中心位置作为兜底...")
|
||
|
||
try:
|
||
# 获取页面尺寸
|
||
viewport_size = self.page.viewport_size
|
||
if viewport_size:
|
||
center_x = viewport_size['width'] // 2
|
||
center_y = viewport_size['height'] // 2
|
||
logger.info(f"[刷新二维码] 页面尺寸: {viewport_size['width']}x{viewport_size['height']}, 中心位置: ({center_x}, {center_y})")
|
||
|
||
# 点击页面中心
|
||
await self.page.mouse.click(center_x, center_y)
|
||
logger.success(f"[刷新二维码] 已点击页面中心位置: ({center_x}, {center_y})")
|
||
else:
|
||
logger.warning("[刷新二维码] 无法获取页面尺寸，使用默认位置 (500, 300)")
|
||
await self.page.mouse.click(500, 300)
|
||
logger.success("[刷新二维码] 已点击默认位置: (500, 300)")
|
||
except Exception as click_error:
|
||
logger.error(f"[刷新二维码] 点击页面中心失败: {str(click_error)}")
|
||
return {
|
||
"success": False,
|
||
"message": "未找到刷新按钮且点击失败"
|
||
}
|
||
|
||
# 点击刷新按钮
|
||
logger.info("[刷新二维码] 点击刷新按钮...")
|
||
await refresh_btn.click()
|
||
logger.success("[刷新二维码] 已点击刷新按钮")
|
||
|
||
# 等待一下，让二维码重新加载
|
||
await asyncio.sleep(1.5)
|
||
|
||
# 重新提取二维码
|
||
logger.info("[刷新二维码] 提取新的二维码...")
|
||
qrcode_data = await self.extract_verification_qrcode()
|
||
|
||
if qrcode_data:
|
||
logger.success(f"[刷新二维码] 成功获取新二维码 (长度: {len(qrcode_data)})")
|
||
return {
|
||
"success": True,
|
||
"qrcode_image": qrcode_data,
|
||
"message": "二维码已刷新"
|
||
}
|
||
else:
|
||
logger.error("[刷新二维码] 未能提取到新二维码")
|
||
return {
|
||
"success": False,
|
||
"message": "刷新后未能获取到新二维码"
|
||
}
|
||
|
||
except Exception as e:
|
||
logger.error(f"[刷新二维码] 异常: {str(e)}")
|
||
import traceback
|
||
traceback.print_exc()
|
||
return {
|
||
"success": False,
|
||
"message": f"刷新失败: {str(e)}"
|
||
}
|
||
|
||
async def _monitor_qrcode_scan(self, session_id: str):
|
||
"""
|
||
后台监听扫码后的页面跳转和二维码失效
|
||
通过监听小红书API https://edith.xiaohongshu.com/api/redcaptcha/v2/qr/status/query
|
||
来精准判断二维码状态：
|
||
- status=1: 正常,等待扫码
|
||
- status=2: 扫码完成,待APP确认
|
||
- status=5: 二维码已过期/失效
|
||
|
||
Args:
|
||
session_id: 会话 ID
|
||
"""
|
||
try:
|
||
logger.info(f"[WebSocket] 开始监听扫码状态: {session_id}")
|
||
|
||
# 等待1秒，确保WebSocket连接完全建立
|
||
logger.info(f"[WebSocket] 等待WebSocket连接建立...")
|
||
await asyncio.sleep(1.0)
|
||
logger.info(f"[WebSocket] 等待完成，开始监听")
|
||
|
||
if not self.page:
|
||
logger.error(f"[WebSocket] 页面对象不存在: {session_id}")
|
||
return
|
||
|
||
# 用于存储最新的二维码状态
|
||
latest_qr_status = {"status": 1}
|
||
# 标记是否已推送失效消息
|
||
expired_notified = False
|
||
# 标记是否已推送扫码成功消息
|
||
scan_success_notified = False
|
||
# 记录上次推送的状态，避免重复推送
|
||
last_notified_status = None
|
||
|
||
# 设置响应监听，拦截二维码状态查询API
|
||
async def handle_qr_status_response(response):
|
||
nonlocal last_notified_status
|
||
try:
|
||
if '/api/redcaptcha/v2/qr/status/query' in response.url:
|
||
json_data = await response.json()
|
||
if json_data.get('success') and 'data' in json_data:
|
||
status = json_data['data'].get('status')
|
||
latest_qr_status['status'] = status
|
||
|
||
# 推送状态变化给前端
|
||
if status != last_notified_status:
|
||
status_message = {
|
||
1: "等待扫码",
|
||
2: "扫码完成，请在APP中确认",
|
||
5: "二维码已过期"
|
||
}.get(status, f"二维码状态: {status}")
|
||
|
||
try:
|
||
# 使用Redis发布消息，避免事件循环隔离问题
|
||
import redis
|
||
import json as json_lib
|
||
from config import get_config
|
||
|
||
config = get_config()
|
||
redis_host = config.get_str('redis.host', 'localhost')
|
||
redis_port = config.get_int('redis.port', 6379)
|
||
redis_password = config.get_str('redis.password', '')
|
||
|
||
redis_client = redis.Redis(
|
||
host=redis_host,
|
||
port=redis_port,
|
||
password=redis_password if redis_password else None,
|
||
decode_responses=True
|
||
)
|
||
|
||
message = {
|
||
"type": "qrcode_status",
|
||
"status": status,
|
||
"message": status_message
|
||
}
|
||
|
||
# 发布到Redis频道
|
||
channel = f"ws_message:{session_id}"
|
||
redis_client.publish(channel, json_lib.dumps(message))
|
||
logger.info(f"[WebSocket] 已通过Redis推送二维码状态: status={status}, channel={channel}")
|
||
last_notified_status = status
|
||
|
||
redis_client.close()
|
||
except Exception as ws_error:
|
||
logger.error(f"[WebSocket] 推送状态失败: {str(ws_error)}")
|
||
import traceback
|
||
traceback.print_exc()
|
||
|
||
if status == 1:
|
||
logger.debug(f"[WebSocket] 二维码正常,等待扫码: status={status}")
|
||
elif status == 2:
|
||
logger.info(f"[WebSocket] 检测到扫码完成,等待APP确认: status={status}")
|
||
elif status == 5:
|
||
logger.warning(f"[WebSocket] 检测到二维码已过期: status={status}")
|
||
else:
|
||
logger.info(f"[WebSocket] 二维码状态: status={status}")
|
||
except Exception as e:
|
||
logger.error(f"[WebSocket] 解析二维码状态响应失败: {str(e)}")
|
||
|
||
# 注册API响应监听
|
||
self.page.on('response', handle_qr_status_response)
|
||
logger.info(f"[WebSocket] 已注册二维码状态API监听")
|
||
|
||
# 最多监吡5分钟
|
||
for i in range(600): # 600 * 0.5 = 300秒 = 5分钟
|
||
await asyncio.sleep(0.5)
|
||
|
||
try:
|
||
current_url = self.page.url
|
||
|
||
# 1. 检测是否跳转回首页（不再是captcha/verify页）
|
||
if 'captcha' not in current_url.lower() and 'verify' not in current_url.lower():
|
||
# 如果已经推送过扫码成功消息,跳过
|
||
if scan_success_notified:
|
||
continue
|
||
|
||
# 检查是否跳转到小红书首页
|
||
if 'xiaohongshu.com' in current_url:
|
||
logger.success(f"[WebSocket] 检测到扫码完成，页面跳转回: {current_url}")
|
||
|
||
# 等待500ms确保WebSocket连接完全建立
|
||
await asyncio.sleep(0.5)
|
||
|
||
# 扫码成功，自动继续发送验证码流程
|
||
logger.info(f"[WebSocket] 扫码验证完成，自动继续发送验证码...")
|
||
|
||
# 通过Redis推送扫码成功消息（仅用于前端显示Toast）
|
||
try:
|
||
import redis
|
||
import json as json_lib
|
||
from config import get_config
|
||
|
||
config = get_config()
|
||
redis_host = config.get_str('redis.host', 'localhost')
|
||
redis_port = config.get_int('redis.port', 6379)
|
||
redis_password = config.get_str('redis.password', '')
|
||
|
||
redis_client = redis.Redis(
|
||
host=redis_host,
|
||
port=redis_port,
|
||
password=redis_password if redis_password else None,
|
||
decode_responses=True
|
||
)
|
||
|
||
message = {
|
||
"type": "qrcode_scan_success",
|
||
"message": "扫码验证完成，正在自动发送验证码..."
|
||
}
|
||
|
||
channel = f"ws_message:{session_id}"
|
||
redis_client.publish(channel, json_lib.dumps(message))
|
||
logger.success(f"[WebSocket] 已通过Redis推送扫码成功消息: channel={channel}")
|
||
scan_success_notified = True
|
||
|
||
redis_client.close()
|
||
except Exception as ws_error:
|
||
logger.error(f"[WebSocket] 推送消息失败: {str(ws_error)}")
|
||
import traceback
|
||
traceback.print_exc()
|
||
|
||
# 退出监听，返回主流程继续执行
|
||
logger.info(f"[WebSocket] 扫码成功，退出监听，返回主流程")
|
||
return # 退出监听循环
|
||
|
||
# 2. 检测二维码是否失效（通过API状态判断）
|
||
if 'captcha' in current_url.lower() or 'verify' in current_url.lower():
|
||
# 如果已经推送过失效消息,跳过后续检测
|
||
if expired_notified:
|
||
continue
|
||
|
||
# 如果状态是5,说明二维码已过期
|
||
if latest_qr_status['status'] == 5:
|
||
logger.warning(f"[WebSocket] API检测到二维码过期: status=5")
|
||
|
||
# 等待500ms确保WebSocket连接完全建立
|
||
await asyncio.sleep(0.5)
|
||
|
||
# 通过WebSocket推送失效消息
|
||
try:
|
||
# 使用Redis发布消息
|
||
import redis
|
||
import json as json_lib
|
||
from config import get_config
|
||
|
||
config = get_config()
|
||
redis_host = config.get_str('redis.host', 'localhost')
|
||
redis_port = config.get_int('redis.port', 6379)
|
||
redis_password = config.get_str('redis.password', '')
|
||
|
||
redis_client = redis.Redis(
|
||
host=redis_host,
|
||
port=redis_port,
|
||
password=redis_password if redis_password else None,
|
||
decode_responses=True
|
||
)
|
||
|
||
message = {
|
||
"type": "qrcode_expired",
|
||
"message": "二维码已过期，点击二维码区域刷新"
|
||
}
|
||
|
||
channel = f"ws_message:{session_id}"
|
||
redis_client.publish(channel, json_lib.dumps(message))
|
||
logger.success(f"[WebSocket] 已通过Redis推送二维码失效消息: channel={channel}")
|
||
expired_notified = True
|
||
|
||
redis_client.close()
|
||
except Exception as ws_error:
|
||
logger.error(f"[WebSocket] 推送消息失败: {str(ws_error)}")
|
||
import traceback
|
||
traceback.print_exc()
|
||
|
||
# 不退出监听,继续等待用户重新操作
|
||
|
||
# 每30秒打印一次状态
|
||
if i > 0 and i % 60 == 0:
|
||
logger.info(f"[WebSocket] 扫码监听中... ({i // 2}秒) URL: {current_url}, QR_Status: {latest_qr_status['status']}")
|
||
|
||
except Exception as e:
|
||
logger.error(f"[WebSocket] 监听异常: {str(e)}")
|
||
# 不退出,继续监听
|
||
|
||
# 超时5分钟,通知前端(但不退出监听)
|
||
logger.warning(f"[WebSocket] 监听已运行5分钟: {session_id}")
|
||
logger.info(f"[WebSocket] 监听仍将继续,直到用户关闭页面")
|
||
|
||
except Exception as e:
|
||
logger.error(f"[WebSocket] 监听任务异常: {str(e)}")
|
||
finally:
|
||
# 清理监听器
|
||
try:
|
||
if self.page:
|
||
self.page.remove_listener('response', handle_qr_status_response)
|
||
logger.info(f"[WebSocket] 已移除API监听器")
|
||
except Exception as e:
|
||
logger.error(f"[WebSocket] 移除监听器失败: {str(e)}")
|
||
async def _navigate_with_qrcode_listener(self, url: str, timeout: int = 120):
|
||
"""
|
||
带有二维码API监听的页面导航
|
||
通过监听https://edith.xiaohongshu.com/api/sns/web/v1/login/qrcode/create
|
||
来判断登录框是否已加载完成，而不是等待固定时间
|
||
|
||
Args:
|
||
url: 目标URL
|
||
timeout: 最大等待时间（秒），默认120秒
|
||
"""
|
||
qrcode_api_detected = False
|
||
|
||
# 设置路由监听二维码创建API
|
||
async def handle_qrcode_create(route):
|
||
nonlocal qrcode_api_detected
|
||
try:
|
||
request = route.request
|
||
logger.info(f"[页面导航] 监听到二维码API请求: {request.url}")
|
||
qrcode_api_detected = True
|
||
|
||
# 继续请求
|
||
await route.continue_()
|
||
except Exception as e:
|
||
logger.error(f"[页面导航] 处理二维码API请求失败: {str(e)}")
|
||
await route.continue_()
|
||
|
||
try:
|
||
# 注册路由监听
|
||
await self.page.route('**/api/sns/web/v1/login/qrcode/create', handle_qrcode_create)
|
||
logger.info(f"[页面导航] 已注册二维码API监听")
|
||
|
||
# 开始导航，不等待加载完成
|
||
try:
|
||
await self.page.goto(url, wait_until='commit', timeout=timeout * 1000)
|
||
logger.info(f"[页面导航] 已开始导航到 {url}")
|
||
except Exception as e:
|
||
# 即使超时也继续，只要URL匹配
|
||
current_url = self.page.url
|
||
logger.warning(f"[页面导航] 导航超时，但尝试继续: {str(e)}")
|
||
logger.info(f"[页面导航] 当前URL: {current_url}")
|
||
|
||
# 检测小红书反爬JSON页面
|
||
await asyncio.sleep(0.5) # 等待页面内容加载
|
||
try:
|
||
page_content = await self.page.content()
|
||
# 检查页面是否只返回JSON（小红书的检测机制）
|
||
if page_content and len(page_content) < 500: # JSON页面通常很短
|
||
# 尝试解析JSON
|
||
if '{"code"' in page_content and '"success":true' in page_content:
|
||
logger.warning("="*50)
|
||
logger.warning("⚠️ 检测到小红书反爬JSON页面")
|
||
logger.warning(f"页面内容: {page_content[:200]}")
|
||
logger.warning("="*50)
|
||
# 抛出异常，让外层处理
|
||
raise Exception("ANTI_CRAWL_JSON")
|
||
except Exception as e:
|
||
if "ANTI_CRAWL_JSON" in str(e):
|
||
raise # 重新抛出，让外层捕获
|
||
# 其他异常忽略，继续执行
|
||
pass
|
||
|
||
# 等待二维码API请求（最多等待timeout秒）
|
||
wait_count = 0
|
||
max_wait = timeout * 10 # 每次等待0.1秒
|
||
|
||
while not qrcode_api_detected and wait_count < max_wait:
|
||
# 每次循环检查URL是否被风控跳转
|
||
current_url = self.page.url
|
||
if 'captcha' in current_url.lower() or 'verify' in current_url.lower():
|
||
logger.warning(f"[页面导航] 检测到风控页面跳转: {current_url}")
|
||
logger.warning("[页面导航] 立即停止等待二维码API")
|
||
break
|
||
|
||
await asyncio.sleep(0.1)
|
||
wait_count += 1
|
||
|
||
if qrcode_api_detected:
|
||
logger.success(f"[页面导航] 监听到二维码API请求，登录框已加载完成（耗时{wait_count * 0.1:.1f}秒）")
|
||
else:
|
||
logger.warning(f"[页面导航] {timeout}秒内未监听到二维码API请求，尝试继续")
|
||
|
||
# 额外等待500ms确保元素渲染完成
|
||
await asyncio.sleep(0.5)
|
||
|
||
finally:
|
||
# 移除路由监听
|
||
try:
|
||
await self.page.unroute('**/api/sns/web/v1/login/qrcode/create')
|
||
logger.info(f"[页面导航] 已移除二维码API监听")
|
||
except Exception:
|
||
pass
|
||
|
||
async def send_verification_code(self, phone: str, country_code: str = "+86", login_page: str = "creator", session_id: str = None) -> Dict[str, Any]:
|
||
"""
|
||
发送验证码
|
||
|
||
Args:
|
||
phone: 手机号
|
||
country_code: 国家区号
|
||
login_page: 登录页面类型，creator(创作者中心) 或 home(小红书首页)
|
||
session_id: 会话ID，用于WebSocket通知
|
||
|
||
Returns:
|
||
Dict containing success status and error message if any
|
||
"""
|
||
try:
|
||
logger.info(f"[发送验证码] 开始 - 手机号: {phone}, 登录页面: {login_page}")
|
||
|
||
if not self.page:
|
||
logger.info(f"[发送验证码] 浏览器未初始化，开始初始化...")
|
||
await self.init_browser(phone=phone)
|
||
|
||
self.current_phone = phone
|
||
|
||
# 根据login_page参数选择登录URL
|
||
if login_page == "home":
|
||
login_url = 'https://www.xiaohongshu.com'
|
||
page_name = "小红书首页"
|
||
else:
|
||
login_url = 'https://creator.xiaohongshu.com/login'
|
||
page_name = "创作者中心"
|
||
|
||
# 优化：如果浏览器已预热且在登录页，直接使用
|
||
current_url = self.page.url if self.page else ""
|
||
if self.use_pool and self.browser_pool and self.browser_pool.is_preheated:
|
||
if login_url in current_url:
|
||
logger.success(f"✅ 浏览器已预热在{page_name}登录页，直接使用！")
|
||
else:
|
||
# 页面变了，重新访问登录页
|
||
logger.success(f"[预热] 页面已变更 ({current_url})，重新访问{page_name}登录页...")
|
||
try:
|
||
await self._navigate_with_qrcode_listener(login_url)
|
||
except Exception as e:
|
||
if "ANTI_CRAWL_JSON" in str(e):
|
||
logger.error("⚠️ 检测到小红书反爬检测，请稍后再试")
|
||
return {
|
||
"success": False,
|
||
"error": "当前IP被小红书检测，请等待5分钟后再试"
|
||
}
|
||
raise
|
||
else:
|
||
# 未预热或不是池模式，使用监听机制访问页面
|
||
logger.debug(f"正在访问{page_name}登录页...")
|
||
|
||
try:
|
||
await self._navigate_with_qrcode_listener(login_url)
|
||
except Exception as e:
|
||
if "ANTI_CRAWL_JSON" in str(e):
|
||
logger.error("⚠️ 检测到小红书反爬检测，请稍后再试")
|
||
return {
|
||
"success": False,
|
||
"error": "当前IP被小红书检测，请等待5分钟后再试"
|
||
}
|
||
raise
|
||
|
||
logger.success(f"✅ 已进入{page_name}登录页面")
|
||
|
||
# 立即检查是否被风控跳转到验证页面
|
||
current_url = self.page.url
|
||
logger.info(f"[风控检测] 当前URL: {current_url}")
|
||
|
||
# 检查是否在风控页面
|
||
if 'captcha' in current_url.lower() or 'verify' in current_url.lower():
|
||
logger.warning("="*50)
|
||
logger.warning(f"⚠️ 发送验证码阶段检测到风控页面!")
|
||
logger.warning(f"完整URL: {current_url}")
|
||
logger.warning("="*50)
|
||
|
||
# 等待页面加载完成
|
||
logger.info("等待验证页面加载完成...")
|
||
await asyncio.sleep(1)
|
||
|
||
# 尝试提取二维码
|
||
logger.info("开始提取二维码...")
|
||
qrcode_data = await self.extract_verification_qrcode()
|
||
if qrcode_data:
|
||
logger.success("✅ 成功提取验证二维码")
|
||
logger.info(f"二维码数据长度: {len(qrcode_data)} 字符")
|
||
logger.info("返回二维码给前端，等待用户扫码...")
|
||
|
||
# 不再在这里启动监听任务，由main.py中的WebSocket端点启动
|
||
# asyncio.create_task(self._monitor_qrcode_scan(session_id))
|
||
|
||
# 先返回二维码给前端显示，然后等待扫码完成
|
||
# 注意：这里返回后，main.py会启动WebSocket监听
|
||
# 当扫码完成后，不需要前端重新调用，而是在监听器中
|
||
# 自动重新调用send_verification_code
|
||
return {
|
||
"success": False,
|
||
"error": "需要验证",
|
||
"need_captcha": True,
|
||
"captcha_type": "qrcode",
|
||
"qrcode_image": qrcode_data,
|
||
"message": "请使用小红书APP扫码验证",
|
||
"session_id": session_id, # 返回session_id用于后续自动继续
|
||
"phone": phone, # 返回手机号用于后续自动继续
|
||
"country_code": country_code, # 返回国家区号用于后续自动继续
|
||
"login_page": login_page # 返回登录页面类型用于后续自动继续
|
||
}
|
||
else:
|
||
logger.error("⚠️ 检测到验证页面但未提取到二维码")
|
||
logger.info("尝试保存截图...")
|
||
try:
|
||
await self.page.screenshot(path='logs/captcha_page_sendcode.png')
|
||
logger.success("截图已保存到 logs/captcha_page_sendcode.png")
|
||
except Exception as e:
|
||
logger.error(f"保存截图失败: {str(e)}")
|
||
return {
|
||
"success": False,
|
||
"error": "验证页面异常",
|
||
"need_captcha": True,
|
||
"captcha_type": "unknown",
|
||
"message": "检测到验证页面但无法提取二维码"
|
||
}
|
||
|
||
# 检查是否已经在首页（扫码后跳转回来的）
|
||
if login_page == "home" and login_url in current_url:
|
||
logger.success("✅ 已在首页，风控已解除，继续正常登录流程")
|
||
|
||
# 根据登录页面类型处理协议复选框
|
||
if login_page == "home":
|
||
# 小红书首页需要主动触发登录框
|
||
logger.info("处理小红书首页登录流程...")
|
||
try:
|
||
# 首先尝试触发登录框（点击登录按钮）
|
||
logger.debug("查找并点击登录按钮以弹出登录框...")
|
||
login_trigger_selectors = [
|
||
'.login', # 常见的登录按钮class
|
||
'text="登录"',
|
||
'button:has-text("登录")',
|
||
'a:has-text("登录")',
|
||
'.header-login',
|
||
'[class*="login"]',
|
||
]
|
||
|
||
login_triggered = False
|
||
for selector in login_trigger_selectors:
|
||
try:
|
||
login_btn = await self.page.query_selector(selector)
|
||
if login_btn:
|
||
# 检查是否可见
|
||
is_visible = await login_btn.is_visible()
|
||
if is_visible:
|
||
logger.success(f"✅ 找到登录触发按钮: {selector}")
|
||
await login_btn.click()
|
||
logger.success("✅ 已点击登录按钮，等待登录框弹出...")
|
||
await asyncio.sleep(0.5) # 从1秒减少到0.5秒
|
||
login_triggered = True
|
||
break
|
||
except Exception as e:
|
||
logger.error(f"尝试选择器 {selector} 失败: {str(e)}")
|
||
continue
|
||
|
||
if not login_triggered:
|
||
logger.warning("⚠️ 未找到登录触发按钮，假设登录框已存在")
|
||
|
||
# 等待登录弹窗中的元素加载
|
||
logger.info("等待登录弹窗中的元素加载...")
|
||
|
||
# 直接等待手机号输入框出现（说明登录框已弹出）
|
||
phone_input_ready = False
|
||
try:
|
||
await self.page.wait_for_selector('input[placeholder="输入手机号"]', timeout=3000) # 从to 8秒减少到3秒
|
||
phone_input_ready = True
|
||
logger.success("✅ 登录弹窗已弹出，手机号输入框就绪")
|
||
except Exception:
|
||
logger.warning("⚠️ 等待登录弹窗超时，尝试继续...")
|
||
|
||
# 检查是否需要点击“手机号登录”选项卡（如果有多个登录方式）
|
||
phone_login_tab_selectors = [
|
||
'text="手机号登录"',
|
||
'div:has-text("手机号登录")',
|
||
'.title:has-text("手机号登录")',
|
||
]
|
||
|
||
phone_login_tab = None
|
||
for selector in phone_login_tab_selectors:
|
||
try:
|
||
phone_login_tab = await self.page.query_selector(selector)
|
||
if phone_login_tab:
|
||
# 检查是否已经选中
|
||
is_active = await phone_login_tab.evaluate('el => el.classList.contains("active") || el.parentElement.classList.contains("active")')
|
||
if not is_active:
|
||
logger.success(f"✅ 找到手机号登录选项卡: {selector}")
|
||
await phone_login_tab.click()
|
||
logger.success("✅ 已点击手机号登录选项卡")
|
||
await asyncio.sleep(0.3) # 从0.5秒减少到0.3秒
|
||
else:
|
||
logger.success("✅ 手机号登录选项卡已选中")
|
||
break
|
||
except Exception:
|
||
continue
|
||
|
||
if not phone_login_tab:
|
||
logger.warning("✅ 未找到手机号登录选项卡，可能已经是手机号登录界面")
|
||
|
||
# 查找并点击协议复选框（小红书首页特有）
|
||
agreement_selectors = [
|
||
'.agree-icon',
|
||
'.agreements .icon-wrapper',
|
||
'span.agree-icon',
|
||
'.icon-wrapper',
|
||
]
|
||
|
||
agreement_checkbox = None
|
||
for selector in agreement_selectors:
|
||
agreement_checkbox = await self.page.query_selector(selector)
|
||
if agreement_checkbox:
|
||
# 检查是否已勾选
|
||
is_checked = await agreement_checkbox.evaluate('el => el.classList.contains("checked") || el.querySelector(".checked") !== null')
|
||
if not is_checked:
|
||
logger.success(f"✅ 找到协议复选框: {selector}")
|
||
await agreement_checkbox.click()
|
||
logger.success("✅ 已勾选协议")
|
||
await asyncio.sleep(0.2)
|
||
else:
|
||
logger.success("✅ 协议已勾选")
|
||
break
|
||
|
||
if not agreement_checkbox:
|
||
logger.warning("⚠️ 未找到协议复选框，尝试继续...")
|
||
except Exception as e:
|
||
logger.error(f"处理首页登录流程失败: {str(e)}")
|
||
else:
|
||
# 创作者中心登录流程
|
||
# 根据记忆：小红书登录跳过协议复选框，无需处理
|
||
# 优化：简化协议处理，减少等待时间
|
||
try:
|
||
agreement_btn = await self.page.query_selector('text="同意并继续"')
|
||
if agreement_btn:
|
||
await agreement_btn.click()
|
||
logger.success(f"✅ 已点击协议按钮")
|
||
await asyncio.sleep(0.3)
|
||
except Exception:
|
||
pass # 无协议弹窗（正常情况）
|
||
|
||
# 输入手机号（使用增强的辅助类）
|
||
try:
|
||
logger.debug("查找手机号输入框...")
|
||
|
||
# 创建登录辅助器
|
||
helper = get_login_helper(self.page)
|
||
|
||
# 根据登录页面类型选择不同的选择器
|
||
if login_page == "home":
|
||
primary_selectors = XHSSelectors.PHONE_INPUT_HOME
|
||
else:
|
||
primary_selectors = XHSSelectors.PHONE_INPUT_CREATOR
|
||
|
||
# 使用智能查找（借鉴ai_mip的多选择器降级策略）
|
||
phone_input = await helper.find_input_with_fallback(
|
||
primary_selectors=primary_selectors,
|
||
fallback_selectors=XHSSelectors.PHONE_INPUT_FALLBACK
|
||
)
|
||
|
||
if not phone_input:
|
||
# 调试：打印页面信息
|
||
await helper.debug_print_inputs()
|
||
|
||
return {
|
||
"success": False,
|
||
"error": "未找到手机号输入框，请检查页面是否正确加载"
|
||
}
|
||
|
||
# 使用人类输入方式（直接在元素上输入）
|
||
# 先清空输入框
|
||
await phone_input.click()
|
||
await helper.random_delay(0.1, 0.2)
|
||
|
||
# 全选并删除（模拟Ctrl+A, Backspace）
|
||
await phone_input.press('Control+A')
|
||
await phone_input.press('Backspace')
|
||
await helper.random_delay(0.1, 0.2)
|
||
|
||
# 逐个字符输入（模拟人类打字）
|
||
for char in phone:
|
||
await phone_input.type(char, delay=random.uniform(80, 150))
|
||
await helper.random_delay(0.05, 0.15)
|
||
|
||
logger.success(f">> 手机号输入完成: {phone}")
|
||
|
||
# 随机延迟，模拟人类行为
|
||
await helper.random_delay(0.3, 0.5)
|
||
|
||
except Exception as e:
|
||
# 保存错误截图
|
||
await save_error_screenshot(
|
||
self.page,
|
||
"send_code_input_phone_failed",
|
||
f"输入手机号失败: {str(e)}"
|
||
)
|
||
return {
|
||
"success": False,
|
||
"error": f"输入手机号失败: {str(e)}"
|
||
}
|
||
|
||
# 点击发送验证码按钮（使用增强的辅助类）
|
||
try:
|
||
logger.debug("查找发送验证码按钮...")
|
||
|
||
# 创建登录辅助器
|
||
helper = get_login_helper(self.page)
|
||
|
||
# 等待页面稳定（输入手机号后可能有动态渲染）
|
||
await helper.random_delay(0.3, 0.5)
|
||
|
||
# 根据登录页面类型选择不同的选择器
|
||
if login_page == "home":
|
||
selectors = XHSSelectors.SEND_CODE_BTN_HOME
|
||
expected_texts = ["获取验证码"]
|
||
else:
|
||
selectors = XHSSelectors.SEND_CODE_BTN_CREATOR
|
||
expected_texts = ["获取验证码", "发送验证码", "重新发送"]
|
||
|
||
# 使用智能查找按钮（借鉴ai_mip）
|
||
send_code_btn = await helper.find_button_with_fallback(
|
||
primary_selectors=selectors,
|
||
expected_texts=expected_texts
|
||
)
|
||
|
||
if not send_code_btn:
|
||
# 调试：打印页面按钮信息
|
||
await helper.debug_print_buttons()
|
||
|
||
return {
|
||
"success": False,
|
||
"error": "未找到发送验证码按钮，请检查页面结构"
|
||
}
|
||
|
||
# 检查按钮是否处于倒计时状态（借鉴ai_mip）
|
||
countdown_text = await helper.check_button_countdown(send_code_btn)
|
||
if countdown_text:
|
||
return {
|
||
"success": False,
|
||
"error": f"验证码发送过于频繁，请{countdown_text}后再试"
|
||
}
|
||
|
||
# 小红书首页需要等待按钮激活
|
||
if login_page == "home":
|
||
# 等待按钮激活
|
||
is_active = await helper.wait_for_button_active(send_code_btn, timeout=5)
|
||
if not is_active:
|
||
return {
|
||
"success": False,
|
||
"error": "按钮未激活，请检查手机号是否正确输入"
|
||
}
|
||
|
||
# 使用人类点击方式（借鉴ai_mip）
|
||
# 先获取按钮的选择器
|
||
btn_selector = await send_code_btn.evaluate('''
|
||
el => {
|
||
// 尝试常见的选择器组合
|
||
const selectors = [
|
||
'span.code-button',
|
||
'.code-button',
|
||
'div.css-uyobdj',
|
||
'button',
|
||
'div[role="button"]',
|
||
'span'
|
||
];
|
||
|
||
for (const sel of selectors) {
|
||
const elements = document.querySelectorAll(sel);
|
||
for (const elem of elements) {
|
||
if (elem === el) return sel;
|
||
}
|
||
}
|
||
|
||
// 如果没有匹配，返回通用选择器
|
||
return el.tagName.toLowerCase();
|
||
}
|
||
''')
|
||
|
||
success = await helper.human_click(btn_selector, wait_after=1.5)
|
||
if not success:
|
||
return {
|
||
"success": False,
|
||
"error": "点击发送验证码失败"
|
||
}
|
||
|
||
# 检查当前页面URL是否包含captcha（验证页面）
|
||
current_url = self.page.url
|
||
if 'captcha' in current_url or 'verify' in current_url:
|
||
logger.warning(f"⚠️ 检测到验证页面: {current_url}")
|
||
|
||
# 尝试提取二维码图片
|
||
qrcode_data = await self.extract_verification_qrcode()
|
||
if qrcode_data:
|
||
logger.success("✅ 成功提取验证二维码")
|
||
return {
|
||
"success": False,
|
||
"need_captcha": True,
|
||
"captcha_type": "qrcode",
|
||
"qrcode_image": qrcode_data,
|
||
"message": "需要扫码验证，请使用小红书APP扫描二维码"
|
||
}
|
||
else:
|
||
return {
|
||
"success": False,
|
||
"need_captcha": True,
|
||
"captcha_type": "unknown",
|
||
"message": "出现验证码验证，请稍后重试"
|
||
}
|
||
|
||
# 直接返回成功，不再检测滑块
|
||
logger.info(f"[发送验证码] 成功 - 手机号: {phone}")
|
||
logger.success("\n✅ 验证码发送流程完成，请查看手机短信")
|
||
logger.info("请在小程序中输入收到的验证码并点击登录\n")
|
||
logger.success("[响应即将返回] success=True, message=验证码发送成功")
|
||
|
||
return {
|
||
"success": True,
|
||
"message": "验证码发送成功，请查看手机短信"
|
||
}
|
||
except Exception as e:
|
||
# 保存错误截图
|
||
await save_error_screenshot(
|
||
self.page,
|
||
"send_code_click_button_failed",
|
||
f"点击发送验证码失败: {str(e)}"
|
||
)
|
||
return {
|
||
"success": False,
|
||
"error": f"点击发送验证码失败: {str(e)}"
|
||
}
|
||
|
||
except Exception as e:
|
||
error_msg = str(e)
|
||
logger.error(f"[发送验证码] 异常 - 手机号: {phone}, 错误: {error_msg}")
|
||
logger.error(f"\n❌ 发送验证码异常: {error_msg}")
|
||
logger.info(f"当前页面URL: {self.page.url if self.page else 'N/A'}")
|
||
|
||
# 打印调试信息
|
||
if self.page:
|
||
try:
|
||
logger.error("尝试截图保存错误状态...")
|
||
await self.page.screenshot(path='error_screenshot.png')
|
||
logger.error("✅ 错误状态已截图保存到 error_screenshot.png")
|
||
except Exception:
|
||
pass
|
||
|
||
return {
|
||
"success": False,
|
||
"error": error_msg
|
||
}
|
||
|
||
async def login(self, phone: str, code: str, country_code: str = "+86", login_page: str = "creator") -> Dict[str, Any]:
|
||
"""
|
||
使用验证码登录
|
||
|
||
Args:
|
||
phone: 手机号
|
||
code: 验证码
|
||
country_code: 国家区号
|
||
login_page: 登录页面类型，creator(创作者中心) 或 home(小红书首页)
|
||
|
||
Returns:
|
||
Dict containing login result, user info and cookies
|
||
"""
|
||
try:
|
||
if not self.page:
|
||
return {
|
||
"success": False,
|
||
"error": "页面未初始化，请先发送验证码"
|
||
}
|
||
|
||
# 输入验证码
|
||
try:
|
||
logger.debug("查找验证码输入框...")
|
||
|
||
# 根据登录页面类型选择不同的选择器
|
||
if login_page == "home":
|
||
# 小红书首页的验证码输入框
|
||
code_input_selectors = [
|
||
'input[placeholder="输入验证码"]', # 从您提供的HTML中找到
|
||
'label.auth-code input',
|
||
'input[type="number"]',
|
||
'input[placeholder*="验证码"]',
|
||
]
|
||
else:
|
||
# 创作者中心的验证码输入框
|
||
code_input_selectors = [
|
||
'input[placeholder="验证码"]', # 根据HTML精确匹配
|
||
'input.css-1ge5flv', # 根据HTML中的class
|
||
'input[placeholder*="验证码"]',
|
||
'input[type="text"]:not([placeholder*="手机"])',
|
||
]
|
||
|
||
code_input = None
|
||
for selector in code_input_selectors:
|
||
try:
|
||
code_input = await self.page.wait_for_selector(selector, timeout=2000)
|
||
if code_input:
|
||
logger.success(f"✅ 找到验证码输入框: {selector}")
|
||
break
|
||
except Exception:
|
||
continue
|
||
|
||
if not code_input:
|
||
return {
|
||
"success": False,
|
||
"error": "未找到验证码输入框"
|
||
}
|
||
|
||
await code_input.click()
|
||
await asyncio.sleep(0.2)
|
||
await code_input.press('Control+A')
|
||
await code_input.type(code, delay=50)
|
||
logger.success(f"✅ 已输入验证码: {code}")
|
||
await asyncio.sleep(0.5)
|
||
except Exception as e:
|
||
return {
|
||
"success": False,
|
||
"error": f"输入验证码失败: {str(e)}"
|
||
}
|
||
|
||
# 点击登录按钮
|
||
try:
|
||
logger.debug("查找登录按钮...")
|
||
|
||
# 根据登录页面类型选择不同的选择器
|
||
if login_page == "home":
|
||
# 小红书首页的登录按钮
|
||
login_btn_selectors = [
|
||
'button.submit', # 从您提供的HTML中找到
|
||
'button:has-text("登录")',
|
||
'text="登录"',
|
||
'.submit',
|
||
]
|
||
else:
|
||
# 创作者中心的登录按钮
|
||
login_btn_selectors = [
|
||
'button.beer-login-btn', # 根据HTML中的class
|
||
'button.css-y4h4ay', # 根据HTML
|
||
'button:has-text("登 录")', # 注意有空格
|
||
'button:has-text("登录")',
|
||
'text="登 录"',
|
||
'text="登录"',
|
||
'.login-button',
|
||
]
|
||
|
||
login_btn = None
|
||
for selector in login_btn_selectors:
|
||
try:
|
||
login_btn = await self.page.wait_for_selector(selector, timeout=2000)
|
||
if login_btn:
|
||
logger.success(f"✅ 找到登录按钮: {selector}")
|
||
break
|
||
except Exception:
|
||
continue
|
||
|
||
if not login_btn:
|
||
# 打印所有按钮用于调试
|
||
logger.warning("⚠️ 未找到登录按钮，打印所有按钮...")
|
||
buttons = await self.page.query_selector_all('button')
|
||
logger.info(f"页面上找到 {len(buttons)} 个按钮")
|
||
for i, btn in enumerate(buttons[:10]):
|
||
try:
|
||
text = await btn.inner_text()
|
||
classes = await btn.get_attribute('class')
|
||
logger.info(f"按钮 {i+1}: 文本=[{text.strip()}] class=[{classes}]")
|
||
except Exception:
|
||
pass
|
||
|
||
return {
|
||
"success": False,
|
||
"error": "未找到登录按钮"
|
||
}
|
||
|
||
# 优化：在点击登录前注册API监听，避免错过直接登录成功的API响应
|
||
logger.info("[登录检测] 开始监听user/me API...")
|
||
login_success = False
|
||
user_me_data = None
|
||
|
||
# 添加：拦截小红书反检测脚本请求（异步处理，不阻塞）
|
||
async def handle_shield_script(route):
|
||
try:
|
||
# 快速放行，不阻塞后续流程
|
||
await route.continue_()
|
||
|
||
# 异步记录日志
|
||
request = route.request
|
||
url = request.url
|
||
logger.warning(f"[反检测拦截] 监听到小红书反检测脚本请求: {url}")
|
||
except Exception as e:
|
||
logger.error(f"[反检测拦截] 处理失败: {str(e)}")
|
||
await route.continue_()
|
||
|
||
# 注册小红书反检测脚本监听
|
||
await self.page.route('**/api/sec/v1/scripting*', handle_shield_script)
|
||
logger.info("[反检测拦截] 已注册小红书反检测脚本监听")
|
||
|
||
# 设置路由监听用户信息API
|
||
async def handle_user_me(route):
|
||
nonlocal login_success, user_me_data
|
||
try:
|
||
request = route.request
|
||
logger.info(f"[登录检测] 监听到用户信息API: {request.url}")
|
||
|
||
response = await route.fetch()
|
||
body = await response.body()
|
||
try:
|
||
data = json.loads(body.decode('utf-8'))
|
||
logger.info(f"[登录检测] API响应: {json.dumps(data, ensure_ascii=False)}")
|
||
|
||
# 检查是否登录成功：code=0, success=true, guest=false
|
||
if (data.get('code') == 0 and
|
||
data.get('success') == True and
|
||
data.get('data', {}).get('guest') == False):
|
||
login_success = True
|
||
user_me_data = data.get('data')
|
||
logger.success(f"✅ 检测到登录成功，用户: {user_me_data.get('nickname')}")
|
||
|
||
# 通过WebSocket推送登录成功消息
|
||
if self.session_id:
|
||
try:
|
||
from main import ws_manager
|
||
await ws_manager.send_message(self.session_id, {
|
||
"type": "login_success",
|
||
"user_info": user_me_data
|
||
})
|
||
logger.info(f"[WebSocket] 已推送登录成功消息: {self.session_id}")
|
||
except Exception as ws_error:
|
||
logger.error(f"[WebSocket] 推送消息失败: {str(ws_error)}")
|
||
except Exception as e:
|
||
logger.error(f"[登录检测] 解析响应失败: {str(e)}")
|
||
await route.fulfill(response=response)
|
||
except Exception as e:
|
||
logger.error(f"[登录检测] 处理API请求失败: {str(e)}")
|
||
await route.continue_()
|
||
|
||
# 注册路由监听
|
||
await self.page.route('**/api/sns/web/v2/user/me', handle_user_me)
|
||
logger.info("[登录检测] 已注册用户信息API监听")
|
||
|
||
# 点击登录按钮
|
||
logger.info("="*50)
|
||
logger.info("开始点击登录按钮")
|
||
logger.info(f"点击前URL: {self.page.url}")
|
||
await login_btn.click()
|
||
logger.success("✅ 已点击登录按钮")
|
||
|
||
# 立即检查URL变化
|
||
await asyncio.sleep(0.2)
|
||
logger.info(f"点击后0.2秒URL: {self.page.url}")
|
||
|
||
# 优化：简化协议处理，减少等待
|
||
await asyncio.sleep(0.3)
|
||
logger.info(f"点击后0.5秒URL: {self.page.url}")
|
||
try:
|
||
popup_btn = await self.page.query_selector('text="同意并继续"')
|
||
if popup_btn:
|
||
await popup_btn.click()
|
||
logger.success(f"✅ 已点击登录后的协议弹窗")
|
||
await asyncio.sleep(0.3)
|
||
logger.info(f"点击协议后URL: {self.page.url}")
|
||
except Exception:
|
||
pass # 无弹窗
|
||
|
||
# 优化：持续检测URL变化，最多等待10秒
|
||
logger.info("="*50)
|
||
logger.info("开始持续检测URL变化...")
|
||
captcha_detected = False
|
||
for i in range(20): # 20 * 0.5 = 10秒
|
||
await asyncio.sleep(0.5)
|
||
current_url = self.page.url
|
||
|
||
# 每次都打印URL,方便看到变化
|
||
if i == 0 or i % 2 == 0: # 每秒打印一次
|
||
logger.info(f"[检测{i+1}/20] 当前URL: {current_url}")
|
||
|
||
# 1. 检查URL是否包含captcha或verify
|
||
if 'captcha' in current_url.lower() or 'verify' in current_url.lower():
|
||
logger.warning("="*50)
|
||
logger.warning(f"⚠️ 检测到验证页面跳转!")
|
||
logger.warning(f"完整URL: {current_url}")
|
||
logger.warning("="*50)
|
||
captcha_detected = True
|
||
|
||
# 等待页面加载完成
|
||
logger.info("等待验证页面加载完成...")
|
||
await asyncio.sleep(1)
|
||
logger.info(f"等待后URL: {self.page.url}")
|
||
|
||
# 尝试提取二维码
|
||
logger.info("开始提取二维码...")
|
||
qrcode_data = await self.extract_verification_qrcode()
|
||
if qrcode_data:
|
||
logger.success("✅ 成功提取验证二维码，返回给前端")
|
||
logger.info(f"二维码数据长度: {len(qrcode_data)} 字符")
|
||
# 注意：不移除API监听，保持session_id对应的浏览器继续运行
|
||
return {
|
||
"success": False,
|
||
"need_captcha": True,
|
||
"captcha_type": "qrcode",
|
||
"qrcode_image": qrcode_data,
|
||
"session_id": self.session_id, # 返回session_id，供后续轮询使用
|
||
"message": "需要扫码验证，请使用小红书APP扫描二维码"
|
||
}
|
||
else:
|
||
logger.error("⚠️ 检测到验证页面但未提取到二维码")
|
||
logger.info("尝试保存截图...")
|
||
try:
|
||
await self.page.screenshot(path='logs/captcha_page.png')
|
||
logger.success("截图已保存到 logs/captcha_page.png")
|
||
except Exception as e:
|
||
logger.error(f"保存截图失败: {str(e)}")
|
||
break
|
||
|
||
# 2. 检查是否直接登录成功（URL跳转到explore或creator）
|
||
if 'explore' in current_url or 'creator' in current_url:
|
||
logger.success("="*50)
|
||
logger.success(f"✅ 检测到登录成功URL跳转")
|
||
logger.success(f"完整URL: {current_url}")
|
||
logger.success("="*50)
|
||
break
|
||
|
||
if not captcha_detected:
|
||
logger.info("="*50)
|
||
logger.info(f"10秒检测结束，未检测到验证页面")
|
||
logger.info(f"最终URL: {self.page.url}")
|
||
logger.info("="*50)
|
||
|
||
# 2. 只有在未检测到风控且未登录成功时，才检测页面上是否出现二维码弹窗
|
||
current_url = self.page.url
|
||
# 如果已经跳转到成功页面，不再检测二维码
|
||
if 'explore' in current_url or 'creator' in current_url or 'xiaohongshu.com' in current_url:
|
||
if 'login' not in current_url:
|
||
logger.info("已跳转到登录成功页面，跳过二维码检测")
|
||
else:
|
||
logger.info("仍在登录页，检测页面上是否出现扫码验证...")
|
||
# 先检测提示文本
|
||
try:
|
||
tip_elem = await self.page.query_selector('.tip')
|
||
if tip_elem:
|
||
tip_text = await tip_elem.inner_text()
|
||
logger.info(f"检测到提示文本: {tip_text}")
|
||
if '扫码' in tip_text or '二维码' in tip_text:
|
||
logger.warning("⚠️ 确认检测到扫码验证提示")
|
||
except Exception as e:
|
||
logger.debug(f"检测提示文本失败: {str(e)}")
|
||
|
||
qrcode_selectors = [
|
||
'.qrcode-img', # 小红书风控二维码的特定class
|
||
'img.qrcode-img',
|
||
'.qrcode-container img', # 二维码容器内的图片
|
||
'.qrcode .qrcode-img', # 二维码容器下的二维码图片
|
||
'.verify-captcha img', # 验证弹窗内的图片
|
||
'.login-container .qrcode-img', # 登录容器内的二维码
|
||
'img[alt*="二维码"]', # alt属性包含"二维码"
|
||
'img[alt*="qrcode"]', # alt属性包含"qrcode"
|
||
]
|
||
|
||
for selector in qrcode_selectors:
|
||
try:
|
||
qrcode_elem = await self.page.query_selector(selector)
|
||
if qrcode_elem:
|
||
logger.info(f"检测到符合选择器的元素: {selector}，尝试提取二维码...")
|
||
qrcode_data = await self.extract_verification_qrcode()
|
||
if qrcode_data:
|
||
logger.warning(f"⚠️ 确认检测到风控二维码: {selector}")
|
||
logger.success("✅ 成功提取扫码验证二维码，返回给前端")
|
||
# 注意：不移除API监听，保持session_id对应的浏览器继续运行
|
||
return {
|
||
"success": False,
|
||
"need_captcha": True,
|
||
"captcha_type": "qrcode",
|
||
"qrcode_image": qrcode_data,
|
||
"session_id": self.session_id, # 返回session_id，供后续轮询使用
|
||
"message": "需要扫码验证，请使用小红书APP扫描二维码"
|
||
}
|
||
else:
|
||
logger.debug(f"选择器 {selector} 匹配到元素但无法提取二维码，可能不是风控二维码")
|
||
break
|
||
except Exception as e:
|
||
logger.debug(f"选择器 {selector} 检测失败: {str(e)}")
|
||
continue
|
||
|
||
logger.info("未检测到扫码验证")
|
||
else:
|
||
logger.info("仍在登录页，检测页面上是否出现扫码验证...")
|
||
# 先检测提示文本
|
||
try:
|
||
tip_elem = await self.page.query_selector('.tip')
|
||
if tip_elem:
|
||
tip_text = await tip_elem.inner_text()
|
||
logger.info(f"检测到提示文本: {tip_text}")
|
||
if '扫码' in tip_text or '二维码' in tip_text:
|
||
logger.warning("⚠️ 确认检测到扫码验证提示")
|
||
except Exception as e:
|
||
logger.debug(f"检测提示文本失败: {str(e)}")
|
||
|
||
qrcode_selectors = [
|
||
'.qrcode-img', # 小红书风控二维码的特定class
|
||
'img.qrcode-img',
|
||
'.qrcode-container img', # 二维码容器内的图片
|
||
'.qrcode .qrcode-img', # 二维码容器下的二维码图片
|
||
'.verify-captcha img', # 验证弹窗内的图片
|
||
'.login-container .qrcode-img', # 登录容器内的二维码
|
||
'img[alt*="二维码"]', # alt属性包含"二维码"
|
||
'img[alt*="qrcode"]', # alt属性包含"qrcode"
|
||
]
|
||
|
||
for selector in qrcode_selectors:
|
||
try:
|
||
qrcode_elem = await self.page.query_selector(selector)
|
||
if qrcode_elem:
|
||
logger.info(f"检测到符合选择器的元素: {selector}，尝试提取二维码...")
|
||
qrcode_data = await self.extract_verification_qrcode()
|
||
if qrcode_data:
|
||
logger.warning(f"⚠️ 确认检测到风控二维码: {selector}")
|
||
logger.success("✅ 成功提取扫码验证二维码，返回给前端")
|
||
# 注意：不移除API监听，保持session_id对应的浏览器继续运行
|
||
return {
|
||
"success": False,
|
||
"need_captcha": True,
|
||
"captcha_type": "qrcode",
|
||
"qrcode_image": qrcode_data,
|
||
"session_id": self.session_id, # 返回session_id，供后续轮询使用
|
||
"message": "需要扫码验证，请使用小红书APP扫描二维码"
|
||
}
|
||
else:
|
||
logger.debug(f"选择器 {selector} 匹配到元素但无法提取二维码，可能不是风控二维码")
|
||
break
|
||
except Exception as e:
|
||
logger.debug(f"选择器 {selector} 检测失败: {str(e)}")
|
||
continue
|
||
|
||
logger.info("未检测到扫码验证")
|
||
|
||
logger.info("继续等待登录...")
|
||
|
||
# 等待URL跳转或API响应（最多30秒）
|
||
logger.info("[登录检测] 等待扫码完成或登录跳转...")
|
||
url_jumped = False
|
||
for i in range(60): # 60 * 0.5 = 30秒
|
||
await asyncio.sleep(0.5)
|
||
|
||
# 如果捕获到user/me API，说明登录成功
|
||
if login_success:
|
||
logger.success(f"✅ 通过API确认登录成功")
|
||
break
|
||
|
||
current_url = self.page.url
|
||
|
||
# 检查URL是否跳转
|
||
if 'login' not in current_url:
|
||
if 'creator.xiaohongshu.com' in current_url or 'www.xiaohongshu.com' in current_url:
|
||
if not url_jumped:
|
||
logger.success(f"✅ URL已跳转: {current_url}")
|
||
url_jumped = True
|
||
# URL跳转后继续等待API响应，最多再等待10秒
|
||
logger.info("[登录检测] URL已跳转，继续等待user/me API...")
|
||
|
||
# 移除路由监听
|
||
try:
|
||
await self.page.unroute('**/api/sns/web/v2/user/me')
|
||
logger.info("[登录检测] 已移除用户信息API监听")
|
||
except Exception:
|
||
pass
|
||
|
||
# 如果没有捕获到API，但URL已跳转，尝试通过Cookie判断
|
||
if not login_success and url_jumped:
|
||
logger.warning("[登录检测] 未捕获到user/me API，尝试通过Cookie判断...")
|
||
cookies = await self.context.cookies()
|
||
cookies_dict = {cookie['name']: cookie['value'] for cookie in cookies}
|
||
|
||
# 检查关键Cookie是否存在
|
||
key_cookies = ['web_session', 'webId', 'a1']
|
||
has_key_cookies = all(key in cookies_dict for key in key_cookies)
|
||
|
||
if has_key_cookies:
|
||
logger.success(f"✅ 检测到关键Cookie，判定登录成功")
|
||
login_success = True
|
||
# 没有user_me_data，后续会从localStorage获取
|
||
else:
|
||
logger.error(f"❌ 未检测到关键Cookie: {list(cookies_dict.keys())}")
|
||
|
||
# 移除路由监听
|
||
try:
|
||
await self.page.unroute('**/api/sns/web/v2/user/me')
|
||
logger.info("[登录检测] 已移除用户信息API监听")
|
||
except Exception:
|
||
pass
|
||
|
||
if not login_success:
|
||
# 8秒后还在登录页，可能验证码错误
|
||
if 'login' in self.page.url:
|
||
# 保存错误截图
|
||
await save_error_screenshot(
|
||
self.page,
|
||
"login_failed_wrong_code",
|
||
"登录失败，验证码可能错误"
|
||
)
|
||
return {
|
||
"success": False,
|
||
"error": "登录失败，请检查验证码是否正确"
|
||
}
|
||
else:
|
||
# URL已跳转但Cookie不对
|
||
await save_error_screenshot(
|
||
self.page,
|
||
"login_failed_no_cookie",
|
||
"登录失败，未获取到登录Cookie"
|
||
)
|
||
return {
|
||
"success": False,
|
||
"error": "登录失败，未获取到有效的登录信息"
|
||
}
|
||
except Exception as e:
|
||
# 保存错误截图
|
||
await save_error_screenshot(
|
||
self.page,
|
||
"login_click_button_failed",
|
||
f"点击登录按钮失败: {str(e)}"
|
||
)
|
||
return {
|
||
"success": False,
|
||
"error": f"点击登录按钮失败: {str(e)}"
|
||
}
|
||
|
||
# 检查是否登录成功
|
||
# 优化：已经通过URL跳转检查，但需要再次确认页面稳定
|
||
logger.success("✅ 登录成功，正在确认页面稳定性...")
|
||
|
||
# 优化：减少等待时间
|
||
await asyncio.sleep(1) # 从2秒减少到1秒
|
||
final_url = self.page.url
|
||
|
||
if 'login' in final_url:
|
||
logger.warning("⚠️ 检测到页面被重定向回登录页，Cookie可能被小红书拒绝")
|
||
await save_error_screenshot(
|
||
self.page,
|
||
"login_redirect_back",
|
||
"登录后被重定向回登录页"
|
||
)
|
||
return {
|
||
"success": False,
|
||
"error": "登录失败：小红书检测到异常登录行为，请稍后再试或使用手动登录"
|
||
}
|
||
|
||
logger.success(f"✅ 页面稳定，最终URL: {final_url}")
|
||
|
||
# 获取Cookies
|
||
cookies = await self.context.cookies()
|
||
|
||
# 注意：这里返回两种格式
|
||
# 1. cookies_dict: 键值对格式（用于 API 返回，方便前端展示）
|
||
# 2. cookies: Playwright 完整格式（用于保存文件和后续使用）
|
||
cookies_dict = {cookie['name']: cookie['value'] for cookie in cookies}
|
||
|
||
# 打印重要的Cookies
|
||
logger.info(f"\n========== Cookies 信息 ==========")
|
||
logger.info(f"共获取到 {len(cookies)} 个Cookie")
|
||
|
||
# 打印所有Cookie名称
|
||
logger.info(f"\nCookie名称列表: {list(cookies_dict.keys())}")
|
||
|
||
# 完整打印所有Cookies（键值对格式）
|
||
logger.info(f"\n完整Cookies内容（键值对格式）:")
|
||
for name, value in cookies_dict.items():
|
||
logger.info(f" {name}: {value}")
|
||
|
||
logger.info(f"\n================================\n")
|
||
|
||
# 获取用户信息（优先使用API返回的user_me_data）
|
||
user_info = {}
|
||
if user_me_data:
|
||
# 使用API返回的用户信息
|
||
user_info = {
|
||
'nickname': user_me_data.get('nickname'),
|
||
'desc': user_me_data.get('desc'),
|
||
'gender': user_me_data.get('gender'),
|
||
'avatar': user_me_data.get('images'),
|
||
'red_id': user_me_data.get('red_id'),
|
||
'user_id': user_me_data.get('user_id'),
|
||
'guest': user_me_data.get('guest')
|
||
}
|
||
logger.success(f"✅ 使用API返回的用户信息: {user_info.get('nickname')}")
|
||
else:
|
||
# 备用方案：从localStorage获取
|
||
try:
|
||
# 从 localStorage 获取用户信息（最关键）
|
||
storage = await self.page.evaluate('() => JSON.stringify(localStorage)')
|
||
storage_dict = json.loads(storage)
|
||
|
||
# 提取有用的localStorage数据
|
||
useful_keys = ['b1', 'b1b1', 'p1']
|
||
for key in useful_keys:
|
||
if key in storage_dict:
|
||
try:
|
||
value = storage_dict[key]
|
||
if value and value.strip():
|
||
user_info[key] = json.loads(value) if value.startswith('{') or value.startswith('[') else value
|
||
except:
|
||
user_info[key] = storage_dict[key]
|
||
|
||
# 获取用户数据
|
||
for key, value in storage_dict.items():
|
||
if 'user' in key.lower():
|
||
try:
|
||
user_info['user_data'] = json.loads(value)
|
||
break
|
||
except:
|
||
pass
|
||
|
||
logger.success(f"✅ 从 localStorage 获取到用户信息: {list(user_info.keys())}")
|
||
|
||
except Exception as e:
|
||
logger.error(f"⚠️ 获取用户信息失败: {str(e)}")
|
||
|
||
# 获取当前URL（可能包含token等信息）
|
||
current_url = self.page.url
|
||
logger.info(f"当前URL: {current_url}")
|
||
|
||
# 获取完整的localStorage数据
|
||
localStorage_data = {}
|
||
try:
|
||
storage = await self.page.evaluate('() => JSON.stringify(localStorage)')
|
||
localStorage_data = json.loads(storage)
|
||
logger.success(f"✅ 获取到 {len(localStorage_data)} 个localStorage项")
|
||
except Exception as e:
|
||
logger.error(f"⚠️ 获取localStorage失败: {str(e)}")
|
||
|
||
# 获取sessionStorage数据
|
||
sessionStorage_data = {}
|
||
try:
|
||
session_storage = await self.page.evaluate('() => JSON.stringify(sessionStorage)')
|
||
sessionStorage_data = json.loads(session_storage)
|
||
logger.success(f"✅ 获取到 {len(sessionStorage_data)} 个sessionStorage项")
|
||
except Exception as e:
|
||
logger.error(f"⚠️ 获取sessionStorage失败: {str(e)}")
|
||
|
||
# 保存完整的登录状态（包含Cookies、localStorage、sessionStorage）
|
||
try:
|
||
login_state = {
|
||
"cookies": cookies, # Playwright 完整格式
|
||
"localStorage": localStorage_data,
|
||
"sessionStorage": sessionStorage_data,
|
||
"url": current_url,
|
||
"timestamp": time.time(),
|
||
"user_agent": self.context._impl_obj._options.get('userAgent'),
|
||
"viewport": self.context._impl_obj._options.get('viewport')
|
||
}
|
||
|
||
# 保存到文件（兼容旧版）
|
||
with open('login_state.json', 'w', encoding='utf-8') as f:
|
||
json.dump(login_state, f, ensure_ascii=False, indent=2)
|
||
logger.success("✅ 已保存完整登录状态到 login_state.json 文件")
|
||
logger.info(f" 包含: {len(cookies)} 个Cookies, {len(localStorage_data)} 个localStorage, {len(sessionStorage_data)} 个sessionStorage")
|
||
|
||
# 兼容性：同时保存单独的cookies.json文件
|
||
with open('cookies.json', 'w', encoding='utf-8') as f:
|
||
json.dump(cookies, f, ensure_ascii=False, indent=2)
|
||
logger.success("✅ 已保存 Cookies 到 cookies.json 文件（兼容旧版）")
|
||
|
||
# 新增：使用Playwright原生storage_state保存（按手机号命名）
|
||
storage_state_dir = 'storage_states'
|
||
os.makedirs(storage_state_dir, exist_ok=True)
|
||
storage_state_filename = f"xhs_{phone}.json"
|
||
storage_state_path = os.path.join(storage_state_dir, storage_state_filename)
|
||
|
||
# 使用Playwright原生API保存storage_state
|
||
storage_state_data = await self.context.storage_state(path=storage_state_path)
|
||
logger.success(f"✅ 已保存 Playwright Storage State 到: {storage_state_path}")
|
||
logger.info(f" 此文件包含完整的浏览器上下文状态，可用于后续免登录恢复")
|
||
|
||
except Exception as e:
|
||
logger.error(f"保存登录状态文件失败: {str(e)}")
|
||
|
||
# 如果使用AdsPower，在关闭浏览器前记录配置ID，但不查询Cookie
|
||
# 因为AdsPower需要关闭浏览器后才会同步Cookie
|
||
# Cookie查询将在close_browser()后由调用者执行
|
||
if self.use_adspower and self.adspower_profile_id:
|
||
logger.info("="*50)
|
||
logger.info(f"[登录成功] AdsPower配置ID: {self.adspower_profile_id}")
|
||
logger.info("[登录成功] 注意：需要关闭浏览器后才能查询AdsPower Cookie")
|
||
logger.info("="*50)
|
||
|
||
return {
|
||
"success": True,
|
||
"user_info": user_info,
|
||
"cookies": cookies_dict, # API 返回：键值对格式（方便前端展示）
|
||
"cookies_full": cookies, # API 返回：Playwright完整格式（数据库存储/脚本使用）
|
||
"login_state": login_state, # API 返回：完整登录状态（供Go服务存储到数据库）
|
||
"localStorage": localStorage_data, # API 返回：localStorage数据
|
||
"sessionStorage": sessionStorage_data, # API 返回：sessionStorage数据
|
||
"url": current_url,
|
||
"storage_state": storage_state_data, # 新增：Playwright storage_state对象
|
||
"storage_state_path": storage_state_path, # 新增：storage_state文件路径
|
||
"adspower_profile_id": self.adspower_profile_id if self.use_adspower else None # 新增：AdsPower配置ID
|
||
}
|
||
|
||
except Exception as e:
|
||
logger.error(f"登录异常: {str(e)}")
|
||
# 保存错误截图（通用错误）
|
||
await save_error_screenshot(
|
||
self.page,
|
||
"login_exception",
|
||
f"登录异常: {str(e)}"
|
||
)
|
||
return {
|
||
"success": False,
|
||
"error": str(e)
|
||
}
|
||
|
||
async def get_user_profile(self) -> Dict[str, Any]:
|
||
"""
|
||
获取用户详细信息
|
||
登录成功后可以调用此方法获取更多用户信息
|
||
"""
|
||
try:
|
||
if not self.page:
|
||
return {
|
||
"success": False,
|
||
"error": "页面未初始化"
|
||
}
|
||
|
||
# 访问用户主页
|
||
await self.page.goto('https://www.xiaohongshu.com/user/profile', wait_until='networkidle')
|
||
await asyncio.sleep(2)
|
||
|
||
# 这里可以根据实际需求抓取用户信息
|
||
# 示例：获取用户昵称、头像等
|
||
|
||
return {
|
||
"success": True,
|
||
"profile": {}
|
||
}
|
||
|
||
except Exception as e:
|
||
return {
|
||
"success": False,
|
||
"error": str(e)
|
||
}
|
||
|
||
async def verify_login_status(self, url: str = None) -> Dict[str, Any]:
|
||
"""
|
||
验证当前登录状态
|
||
访问指定的小红书页面检查是否已登录
|
||
|
||
Args:
|
||
url: 可选的验证URL，默认访问创作者平台
|
||
|
||
Returns:
|
||
Dict containing login status and user info if logged in
|
||
"""
|
||
try:
|
||
if not self.page:
|
||
return {
|
||
"success": False,
|
||
"logged_in": False,
|
||
"error": "页面未初始化"
|
||
}
|
||
|
||
logger.debug("正在验证登录状态...")
|
||
|
||
# 确定要访问的URL
|
||
target_url = url or 'https://creator.xiaohongshu.com/'
|
||
page_name = "创作者平台" if "creator" in target_url else "小红书首页"
|
||
|
||
logger.info(f"访问{page_name}...")
|
||
|
||
# 重置跳转计数器
|
||
self.redirect_count = 0
|
||
self.last_redirect_time = 0
|
||
|
||
try:
|
||
await self.page.goto(target_url, wait_until='domcontentloaded', timeout=60000)
|
||
await asyncio.sleep(2) # 等待页面加载
|
||
|
||
# 检查是否发生了频繁跳转
|
||
if self.redirect_count > 5:
|
||
logger.error(f"❌ 检测到无限跳转 ({self.redirect_count}次重定向)，Cookie已失效")
|
||
return {
|
||
"success": True,
|
||
"logged_in": False,
|
||
"cookie_expired": True,
|
||
"infinite_redirect": True,
|
||
"message": "Cookie已失效，小红书检测到异常登录行为",
|
||
"url": self.page.url
|
||
}
|
||
|
||
logger.success(f"✅ 已访问{page_name}，当前URL: {self.page.url}")
|
||
except Exception as e:
|
||
logger.error(f"访问{page_name}失败: {str(e)}")
|
||
return {
|
||
"success": False,
|
||
"logged_in": False,
|
||
"error": f"访问{page_name}失败: {str(e)}"
|
||
}
|
||
|
||
# 检查是否被重定向到登录页（未登录状态）
|
||
current_url = self.page.url
|
||
if 'login' in current_url.lower():
|
||
logger.error("❌ 未登录状态（被重定向到登录页）")
|
||
return {
|
||
"success": True,
|
||
"logged_in": False,
|
||
"cookie_expired": True, # 标识Cookie已失效
|
||
"message": "Cookie已失效或未登录",
|
||
"url": current_url
|
||
}
|
||
|
||
# 如果成功访问目标页面且未被重定向到登录页，说明已登录
|
||
if 'xiaohongshu.com' in current_url and 'login' not in current_url.lower():
|
||
logger.success(f"✅ 已登录状态（成功访问{page_name}）")
|
||
|
||
# 获取当前的Cookies
|
||
cookies = await self.context.cookies()
|
||
|
||
# 转换为键值对格式（用于 API 返回）
|
||
cookies_dict = {cookie['name']: cookie['value'] for cookie in cookies}
|
||
|
||
# 尝试获取用户信息
|
||
user_info = {}
|
||
try:
|
||
storage = await self.page.evaluate('() => JSON.stringify(localStorage)')
|
||
storage_dict = json.loads(storage)
|
||
|
||
# 提取有用的localStorage数据
|
||
for key, value in storage_dict.items():
|
||
if 'user' in key.lower():
|
||
try:
|
||
user_data = json.loads(value)
|
||
user_info['user_data'] = user_data
|
||
break
|
||
except:
|
||
pass
|
||
except Exception as e:
|
||
logger.error(f"获取用户信息失败: {str(e)}")
|
||
|
||
return {
|
||
"success": True,
|
||
"logged_in": True,
|
||
"message": "Cookie有效，已登录",
|
||
"cookies": cookies_dict, # 键值对格式（前端展示）
|
||
"cookies_full": cookies, # Playwright完整格式（数据库存储/脚本使用）
|
||
"user_info": user_info,
|
||
"url": current_url
|
||
}
|
||
else:
|
||
logger.error("❌ 未登录状态（URL异常）")
|
||
return {
|
||
"success": True,
|
||
"logged_in": False,
|
||
"cookie_expired": True, # 标识Cookie已失效
|
||
"message": "Cookie已失效或未登录",
|
||
"url": current_url
|
||
}
|
||
|
||
except Exception as e:
|
||
logger.error(f"验证登录状态异常: {str(e)}")
|
||
return {
|
||
"success": False,
|
||
"logged_in": False,
|
||
"error": str(e)
|
||
}
|
||
|
||
def _calculate_title_width(self, title: str) -> int:
|
||
width = 0
|
||
for ch in title:
|
||
if unicodedata.east_asian_width(ch) in ("F", "W"):
|
||
width += 2
|
||
else:
|
||
width += 1
|
||
return width
|
||
|
||
async def publish_note(self, title: str, content: str, images: list = None, topics: list = None, cookies: list = None, proxy: str = None, user_agent: str = None) -> Dict[str, Any]:
|
||
"""
|
||
发布笔记（支持Cookie注入）
|
||
|
||
Args:
|
||
title: 笔记标题
|
||
content: 笔记内容
|
||
images: 图片路径列表（本地文件路径）
|
||
topics: 话题标签列表
|
||
cookies: 可选的Cookie列表（Playwright完整格式），用于注入登录态
|
||
proxy: 可选的代理地址，例如 http://ip:port
|
||
user_agent: 可选的自定义User-Agent，用于防指纹识别
|
||
|
||
Returns:
|
||
Dict containing publish result
|
||
"""
|
||
try:
|
||
# ========== 内容验证 ==========
|
||
logger.debug("\n========== 开始验证发布内容 ==========")
|
||
|
||
# 1. 验证标题长度
|
||
if not title or len(title.strip()) == 0:
|
||
return {
|
||
"success": False,
|
||
"error": "标题不能为空",
|
||
"error_type": "validation_error"
|
||
}
|
||
|
||
title = title.strip()
|
||
title_width = self._calculate_title_width(title)
|
||
if title_width > 40:
|
||
return {
|
||
"success": False,
|
||
"error": f"标题超出限制：当前宽度 {title_width}，平台限制 40",
|
||
"error_type": "validation_error"
|
||
}
|
||
logger.success(f"✅ 标题验证通过: 宽度 {title_width}/40")
|
||
|
||
# 2. 验证内容长度
|
||
if not content or len(content.strip()) == 0:
|
||
return {
|
||
"success": False,
|
||
"error": "内容不能为空",
|
||
"error_type": "validation_error"
|
||
}
|
||
|
||
content_length = len(content)
|
||
if content_length > 1000:
|
||
return {
|
||
"success": False,
|
||
"error": f"内容超出限制：当前 {content_length} 个字，最多 1000 个字",
|
||
"error_type": "validation_error"
|
||
}
|
||
logger.success(f"✅ 内容验证通过: {content_length}/1000 个字")
|
||
|
||
# 3. 验证图片数量
|
||
images_count = len(images) if images else 0
|
||
if images_count == 0:
|
||
return {
|
||
"success": False,
|
||
"error": "至少需要 1 张图片",
|
||
"error_type": "validation_error"
|
||
}
|
||
if images_count > 18:
|
||
return {
|
||
"success": False,
|
||
"error": f"图片超出限制：当前 {images_count} 张，最多 18 张",
|
||
"error_type": "validation_error"
|
||
}
|
||
logger.success(f"✅ 图片数量验证通过: {images_count}/18 张")
|
||
|
||
logger.success("✅ 所有验证通过，开始发布\n")
|
||
|
||
# ========== 开始发布流程 ==========
|
||
# 如果提供了Cookie且使用浏览器池，创建独立的context和page
|
||
if cookies:
|
||
logger.warning("✅ 检测到Cookie，将创建独立的浏览器环境")
|
||
# 调试：打印cookies格式
|
||
if cookies and len(cookies) > 0:
|
||
logger.info(f" Cookie格式检查: 类型={type(cookies).__name__}, 数量={len(cookies)}")
|
||
if isinstance(cookies, list) and len(cookies) > 0:
|
||
first_cookie = cookies[0]
|
||
logger.info(f" 第一个cookie字段: {list(first_cookie.keys()) if isinstance(first_cookie, dict) else 'not dict'}")
|
||
if isinstance(first_cookie, dict):
|
||
# 检查关键字段的类型
|
||
for key in ['name', 'value', 'expires', 'sameSite']:
|
||
if key in first_cookie:
|
||
val = first_cookie[key]
|
||
logger.info(f" {key}: type={type(val).__name__}, value={val}")
|
||
|
||
# 使用浏览器池模式：复用主浏览器，但为发布创建独立的context
|
||
if self.use_pool and self.browser_pool:
|
||
logger.info("[浏览器池模式] 复用主浏览器实例")
|
||
# 从池中获取浏览器（仅获取browser实例）
|
||
self.browser, _, _ = await self.browser_pool.get_browser()
|
||
logger.info("[浏览器池] 复用主浏览器实例")
|
||
|
||
# 为发布任务创建全新的context（不复用预热的context）
|
||
context_kwargs = {
|
||
"viewport": {'width': 1280, 'height': 720},
|
||
"user_agent": user_agent or 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/120.0.0.0 Safari/537.36',
|
||
}
|
||
self.context = await self.browser.new_context(**context_kwargs)
|
||
logger.info("[浏览器池模式] 为发布创建独立的context（避免污染预热环境）")
|
||
|
||
# 注入Cookie到新的context
|
||
await self.context.add_cookies(cookies)
|
||
logger.success(f"✅ 已注入 {len(cookies)} 个Cookie")
|
||
|
||
# 创建发布页面
|
||
logger.info("[浏览器池模式] 创建发布专用页面")
|
||
self.page = await self.context.new_page()
|
||
logger.success("✅ 发布页面创建成功\n")
|
||
|
||
elif not self.page:
|
||
# 非池模式且页面不存在，初始化浏览器
|
||
await self.init_browser(cookies, proxy=proxy, user_agent=user_agent)
|
||
else:
|
||
# 非池模式但页面已存在，添加Cookie
|
||
await self.context.add_cookies(cookies)
|
||
logger.success(f"✅ 已注入 {len(cookies)} 个Cookie")
|
||
|
||
# 如果没有Cookie且没有page，尝试使用池
|
||
if not self.page:
|
||
if self.use_pool and self.browser_pool:
|
||
logger.info("[浏览器池模式] 获取浏览器实例")
|
||
self.browser, self.context, self.page = await self.browser_pool.get_browser(proxy=proxy, user_agent=user_agent)
|
||
else:
|
||
return {
|
||
"success": False,
|
||
"error": "页面未初始化，请先登录或提供Cookie"
|
||
}
|
||
|
||
logger.debug("\n========== 开始发布笔记 ==========")
|
||
logger.info(f"标题: {title}")
|
||
logger.info(f"内容: {content[:50]}..." if len(content) > 50 else f"内容: {content}")
|
||
logger.info(f"图片数量: {len(images) if images else 0}")
|
||
logger.info(f"话题: {topics if topics else []}")
|
||
|
||
# 优化流程：先访问小红书首页，然后点击发布按钮跳转到创作者中心
|
||
logger.info("步骤1: 访问小红书首页...")
|
||
try:
|
||
await self.page.goto('https://www.xiaohongshu.com', wait_until='domcontentloaded', timeout=30000)
|
||
await asyncio.sleep(2)
|
||
logger.success("✅ 已进入小红书首页")
|
||
except Exception as e:
|
||
logger.warning(f"⚠️ 访问首页失败: {str(e)}，尝试直接访问创作者中心")
|
||
|
||
logger.info("步骤2: 点击发布按钮跳转到创作者中心...")
|
||
publish_url = 'https://creator.xiaohongshu.com/publish/publish?source=official&from=menu&target=image'
|
||
|
||
# 查找首页的发布按钮
|
||
publish_button_found = False
|
||
try:
|
||
# 尝试多种可能的发布按钮选择器
|
||
publish_button_selectors = [
|
||
'a[href*="creator.xiaohongshu.com"]', # 包含创作者中心链接
|
||
'a[href*="publish"]', # 包含publish关键词
|
||
'div[class*="publish"]', # class包含publish
|
||
'button:has-text("发布")', # 文字为发布
|
||
]
|
||
|
||
for selector in publish_button_selectors:
|
||
try:
|
||
button = await self.page.query_selector(selector)
|
||
if button:
|
||
logger.info(f" 找到发布按钮: {selector}")
|
||
await button.click()
|
||
await asyncio.sleep(2)
|
||
publish_button_found = True
|
||
logger.success("✅ 已点击发布按钮")
|
||
break
|
||
except Exception as e:
|
||
continue
|
||
except Exception as e:
|
||
logger.warning(f"⚠️ 查找发布按钮失败: {str(e)}")
|
||
|
||
# 如果没找到发布按钮，直接访问发布页
|
||
if not publish_button_found:
|
||
logger.info("步骤3: 未找到发布按钮，直接访问创作者中心发布页...")
|
||
else:
|
||
logger.info("步骤3: 验证是否跳转到创作者中心...")
|
||
|
||
# 尝试访问页面(最多重试2次)
|
||
page_loaded = False
|
||
for attempt in range(2):
|
||
try:
|
||
if attempt > 0:
|
||
logger.info(f"第 {attempt + 1} 次尝试加载页面...")
|
||
else:
|
||
logger.debug("开始加载页面...")
|
||
|
||
# 检查当前URL，如果已经在发布页则跳过访问
|
||
current_url = self.page.url
|
||
if 'publish/publish' not in current_url:
|
||
# 使用更宽松的等待条件,不等待networkidle
|
||
await self.page.goto(
|
||
publish_url,
|
||
wait_until='load', # 从networkidle改为load,更快
|
||
timeout=40000 # 增加到40秒
|
||
)
|
||
else:
|
||
logger.info("已在发布页，无需跳转")
|
||
|
||
# 等待页面稳定
|
||
await asyncio.sleep(2)
|
||
|
||
# 检查是否被跳转回登录页或其他页面
|
||
current_url = self.page.url
|
||
|
||
# 先打印URL信息，但不立即判定为错误
|
||
if current_url != publish_url:
|
||
logger.warning(f"⚠️ 检测到页面跳转: {current_url}")
|
||
logger.warning(f"⚠️ 期望页面: {publish_url}")
|
||
|
||
# 关键优化：等待5秒，给小红书时间自动重定向回发布页
|
||
if 'redirectReason' in current_url or 'login' in current_url:
|
||
logger.warning("🔄 检测到重定向参数，等待5秒让小红书自动重定向...")
|
||
await asyncio.sleep(5)
|
||
|
||
# 再次检查最终URL
|
||
final_url = self.page.url
|
||
logger.info(f"🔍 最终页面URL: {final_url}")
|
||
|
||
# 如果最终还是在发布页，则认为成功
|
||
if 'publish/publish' in final_url:
|
||
logger.success("✅ 自动重定向成功，已到达发布页")
|
||
current_url = final_url # 更新当前URL
|
||
elif 'login' in final_url and 'publish' not in final_url:
|
||
# 真的停留在登录页，Cookie失效
|
||
return {
|
||
"success": False,
|
||
"error": "Cookie可能已失效,页面跳转到登录页",
|
||
"error_type": "cookie_expired"
|
||
}
|
||
|
||
# 最终检查：只要URL中包含'publish/publish'，就认为在发布页
|
||
if 'publish/publish' not in current_url:
|
||
logger.error(f"❌ 页面最终未到达发布页: {current_url}")
|
||
# 其他跳转,重试
|
||
if attempt < 1:
|
||
logger.info("等待3秒后重试...")
|
||
await asyncio.sleep(3)
|
||
continue
|
||
else:
|
||
return {
|
||
"success": False,
|
||
"error": f"页面跳转到意外地址: {current_url}"
|
||
}
|
||
|
||
# 验证页面是否加载成功(检查是否有上传控件)
|
||
upload_check = await self.page.query_selector('input[type="file"]')
|
||
if upload_check:
|
||
logger.success(f"✅ 已进入图文发布页面: {current_url}")
|
||
page_loaded = True
|
||
break
|
||
else:
|
||
logger.warning("⚠️ 页面加载完成但未找到上传控件,可能需要重试")
|
||
if attempt < 1: # 还有重试机会
|
||
await asyncio.sleep(2)
|
||
continue
|
||
else:
|
||
# 最后一次尝试也失败了,继续执行看看
|
||
logger.warning("⚠️ 未找到上传控件,但继续执行")
|
||
page_loaded = True
|
||
break
|
||
|
||
except Exception as e:
|
||
error_msg = f"访问发布页面失败(尝试{attempt + 1}/2): {str(e)}"
|
||
logger.error(f"❌ {error_msg}")
|
||
|
||
# 保存错误截图
|
||
try:
|
||
timestamp = datetime.now().strftime('%Y%m%d%H%M%S')
|
||
error_type = type(e).__name__
|
||
screenshot_path = f"error_screenshots/{timestamp}_{error_type}.png"
|
||
os.makedirs('error_screenshots', exist_ok=True)
|
||
await self.page.screenshot(path=screenshot_path, full_page=True)
|
||
logger.error(f"📸 已保存错误截图: {screenshot_path}")
|
||
except Exception as screenshot_error:
|
||
logger.error(f"⚠️ 保存截图失败: {screenshot_error}")
|
||
|
||
if attempt < 1: # 还有重试机会
|
||
logger.info("等待3秒后重试...")
|
||
await asyncio.sleep(3)
|
||
continue
|
||
else:
|
||
# 所有重试都失败了
|
||
import traceback
|
||
traceback.print_exc()
|
||
return {
|
||
"success": False,
|
||
"error": f"访问发布页面失败(已重试2次): {str(e)}"
|
||
}
|
||
|
||
if not page_loaded:
|
||
return {
|
||
"success": False,
|
||
"error": "页面加载失败"
|
||
}
|
||
|
||
# 上传图片（如果有）
|
||
if images and len(images) > 0:
|
||
try:
|
||
logger.debug(f"开始上传 {len(images)} 张图片...")
|
||
|
||
# 预处理图片：将网络图片下载到本地
|
||
local_images = []
|
||
downloaded_files = [] # 用于清理临时文件
|
||
|
||
# OSS域名前缀（用于补充不完整的图片路径）
|
||
oss_prefix = "https://bxmkb-beijing.oss-cn-beijing.aliyuncs.com/Images/"
|
||
|
||
for img_path in images:
|
||
original_path = img_path
|
||
|
||
# 检查是否需要补充OSS前缀
|
||
if not (img_path.startswith('http://') or img_path.startswith('https://')):
|
||
# 不是完整URL
|
||
if not os.path.isabs(img_path):
|
||
# 也不是绝对路径，检查是否需要补充OSS前缀
|
||
if '/' in img_path and not img_path.startswith('/'):
|
||
# 可能是OSS相对路径（如 20251221/xxx.png），补充前缀
|
||
img_path = oss_prefix + img_path
|
||
logger.warning(f" 检测到相对路径，补充OSS前缀: {original_path} -> {img_path}")
|
||
|
||
if img_path.startswith('http://') or img_path.startswith('https://'):
|
||
# 网络图片，需要下载
|
||
try:
|
||
local_path = await download_image(img_path)
|
||
local_images.append(local_path)
|
||
downloaded_files.append(local_path) # 记录以便后续清理
|
||
except Exception as e:
|
||
logger.error(f"⚠️ 下载图片 {img_path} 失败: {str(e)}")
|
||
return {
|
||
"success": False,
|
||
"error": f"下载图片失败: {str(e)}"
|
||
}
|
||
else:
|
||
# 本地图片，直接使用
|
||
local_images.append(img_path)
|
||
|
||
logger.success(f"✅ 图片预处理完成，共 {len(local_images)} 张本地图片")
|
||
|
||
# 优化：减少等待时间
|
||
await asyncio.sleep(0.5)
|
||
|
||
# 优化：直接使用最常见的选择器，先用query_selector快速查找
|
||
logger.debug("查找图片上传控件...")
|
||
upload_selectors = [
|
||
'input[type="file"][accept*="image"]',
|
||
'input[type="file"]',
|
||
'input[accept*="image"]',
|
||
'.upload-input',
|
||
'[class*="upload"] input[type="file"]',
|
||
]
|
||
|
||
file_input = None
|
||
for selector in upload_selectors:
|
||
try:
|
||
# 优化：使用query_selector代替wait_for_selector，更快
|
||
file_input = await self.page.query_selector(selector)
|
||
if file_input:
|
||
logger.info(f"找到文件上传控件: {selector}")
|
||
break
|
||
except Exception:
|
||
continue
|
||
|
||
# 如果快速查找失败，再用wait方式
|
||
if not file_input:
|
||
for selector in upload_selectors:
|
||
try:
|
||
file_input = await self.page.wait_for_selector(selector, timeout=3000)
|
||
if file_input:
|
||
logger.info(f"找到文件上传控件: {selector}")
|
||
break
|
||
except Exception:
|
||
continue
|
||
|
||
if file_input:
|
||
# 批量上传图片（使用本地图片）
|
||
images_count = len(local_images)
|
||
logger.debug(f"正在上传 {images_count} 张本地图片: {local_images}")
|
||
|
||
# 验证文件是否存在
|
||
for img_path in local_images:
|
||
if not os.path.exists(img_path):
|
||
logger.warning(f"⚠️ 警告: 图片文件不存在: {img_path}")
|
||
else:
|
||
file_size = os.path.getsize(img_path) / 1024
|
||
logger.success(f" ✅ 文件存在: {img_path} ({file_size:.1f}KB)")
|
||
|
||
await file_input.set_input_files(local_images)
|
||
logger.success(f"已设置文件路径，等待上传...")
|
||
|
||
# 等待一下让页面处理文件
|
||
await asyncio.sleep(1)
|
||
|
||
# 优化：更快速的图片上传检测（500ms间隔）
|
||
upload_success = False
|
||
uploaded_count = 0
|
||
page_destroyed = False
|
||
|
||
for i in range(60): # 最多等待30秒（60次 × 500ms）
|
||
await asyncio.sleep(0.5) # 优化：从1秒改为500ms
|
||
try:
|
||
# 检查页面是否还有效
|
||
if self.page.is_closed():
|
||
logger.warning("检测到页面已关闭")
|
||
page_destroyed = True
|
||
break
|
||
|
||
# 查找所有已上传的图片缩略图 - 增加更多选择器
|
||
uploaded_images = await self.page.query_selector_all('img[src*="blob:"]')
|
||
if not uploaded_images:
|
||
# 尝试其他选择器
|
||
uploaded_images = await self.page.query_selector_all('[class*="image"][class*="item"] img')
|
||
if not uploaded_images:
|
||
# 再尝试其他可能的选择器
|
||
uploaded_images = await self.page.query_selector_all('.image-item img, .upload-item img, .pic-item img')
|
||
if not uploaded_images:
|
||
# 最后尝试查找包含图片的元素
|
||
uploaded_images = await self.page.query_selector_all('img[src*="data:image"]')
|
||
|
||
uploaded_count = len(uploaded_images)
|
||
|
||
if uploaded_count > 0:
|
||
# 检查是否所有图片都已上传
|
||
if uploaded_count >= images_count:
|
||
logger.success(f"✅ 所有图片上传完成！共 {uploaded_count} 张")
|
||
upload_success = True
|
||
break
|
||
|
||
# 每秒打印一次进度（避免刷屏）
|
||
if i % 2 == 0:
|
||
logger.info(f"等待图片上传... {uploaded_count}/{images_count} ({(i+1)*0.5:.1f}/30秒)")
|
||
except Exception as e:
|
||
error_msg = str(e)
|
||
# 检查是否是页面跳转/销毁导致的异常
|
||
if 'context was destroyed' in error_msg.lower() or 'navigation' in error_msg.lower():
|
||
logger.error(f"检测到页面跳转: {error_msg}")
|
||
page_destroyed = True
|
||
break
|
||
logger.error(f"检测上传状态异常: {e}")
|
||
# 连续异常可能说明页面有问题，等待更长时间
|
||
if i > 10: # 5秒后还在异常
|
||
await asyncio.sleep(1)
|
||
|
||
# 如果页面被销毁，尝试等待重定向完成
|
||
if page_destroyed:
|
||
logger.warning("⚠️ 页面发生跳转，检查当前URL...")
|
||
await asyncio.sleep(3)
|
||
|
||
# 检查跳转后的URL
|
||
current_url = self.page.url
|
||
logger.info(f"跳转后的URL: {current_url}")
|
||
|
||
# 如果跳转到登录页，说明Cookie失效
|
||
if 'login' in current_url:
|
||
# 清理临时文件
|
||
for temp_file in downloaded_files:
|
||
try:
|
||
os.remove(temp_file)
|
||
except Exception:
|
||
pass
|
||
return {
|
||
"success": False,
|
||
"error": "Cookie已失效，上传过程中跳转到登录页",
|
||
"error_type": "cookie_expired"
|
||
}
|
||
|
||
# 如果仍然在发布页，重新检查图片
|
||
if 'publish/publish' in current_url:
|
||
logger.success("✅ 仍在发布页，重新检查图片...")
|
||
try:
|
||
uploaded_images = await self.page.query_selector_all('img[src*="blob:"], img[src*="data:image"], [class*="image"][class*="item"] img')
|
||
uploaded_count = len(uploaded_images)
|
||
if uploaded_count >= images_count:
|
||
logger.success(f"✅ 页面稳定后确认图片已上传！共 {uploaded_count} 张")
|
||
upload_success = True
|
||
else:
|
||
logger.warning(f"⚠️ 页面稳定后检测到 {uploaded_count}/{images_count} 张图片")
|
||
except Exception as e:
|
||
logger.error(f"页面稳定后检测失败: {e}")
|
||
else:
|
||
# 跳转到其他页面
|
||
# 清理临时文件
|
||
for temp_file in downloaded_files:
|
||
try:
|
||
os.remove(temp_file)
|
||
except Exception:
|
||
pass
|
||
return {
|
||
"success": False,
|
||
"error": f"上传过程中页面跳转到: {current_url}"
|
||
}
|
||
|
||
if upload_success:
|
||
logger.success(f"✅ 图片上传成功！共 {uploaded_count} 张")
|
||
await asyncio.sleep(0.5) # 优化：从2秒减少到0.5秒
|
||
|
||
# 清理下载的临时文件
|
||
for temp_file in downloaded_files:
|
||
try:
|
||
os.remove(temp_file)
|
||
logger.success(f"✅ 已清理临时文件: {temp_file}")
|
||
except Exception:
|
||
pass
|
||
else:
|
||
logger.warning(f"⚠️ 仅检测到 {uploaded_count}/{images_count} 张图片，但继续执行...")
|
||
else:
|
||
logger.warning("未找到隐藏的file input，尝试查找可点击的上传区域...")
|
||
|
||
# 调试: 打印页面上所有包含upload的元素
|
||
try:
|
||
all_elements = await self.page.query_selector_all('[class*="upload"], [id*="upload"]')
|
||
logger.info(f"\u627e到 {len(all_elements)} 个包含upload的元素")
|
||
for i, el in enumerate(all_elements[:10]): # 只看前10个
|
||
try:
|
||
tag_name = await el.evaluate('el => el.tagName')
|
||
class_name = await el.evaluate('el => el.className')
|
||
logger.info(f" [{i+1}] {tag_name} class='{class_name}'")
|
||
except Exception:
|
||
pass
|
||
except Exception:
|
||
pass
|
||
|
||
# 尝试点击上传区域或按钮
|
||
upload_area_selectors = [
|
||
'[class*="upload"][class*="box"]',
|
||
'[class*="upload"][class*="area"]',
|
||
'[class*="upload"][class*="wrapper"]',
|
||
'.upload-zone',
|
||
'div:has-text("上传图片")',
|
||
'div:has-text("点击上传")',
|
||
'button:has-text("上传图片")',
|
||
]
|
||
|
||
clicked = False
|
||
for selector in upload_area_selectors:
|
||
try:
|
||
area = await self.page.wait_for_selector(selector, timeout=2000)
|
||
if area:
|
||
logger.info(f"找到上传区域: {selector}")
|
||
await area.click()
|
||
await asyncio.sleep(0.5)
|
||
# 点击后再次查找file input
|
||
file_input = await self.page.wait_for_selector('input[type="file"]', timeout=2000)
|
||
if file_input:
|
||
images_count = len(local_images)
|
||
logger.debug(f"正在上传 {images_count} 张本地图片: {local_images}")
|
||
await file_input.set_input_files(local_images)
|
||
logger.success(f"已设置文件路径，等待上传...")
|
||
|
||
# 等待一下让页面处理文件
|
||
await asyncio.sleep(1)
|
||
|
||
# 优化：更快的图片上传检测
|
||
upload_success = False
|
||
uploaded_count = 0
|
||
page_destroyed = False
|
||
|
||
for i in range(60): # 最多30秒
|
||
await asyncio.sleep(0.5) # 优化：500ms间隔
|
||
try:
|
||
# 检查页面是否还有效
|
||
if self.page.is_closed():
|
||
logger.warning("检测到页面已关闭")
|
||
page_destroyed = True
|
||
break
|
||
|
||
uploaded_images = await self.page.query_selector_all('img[src*="blob:"]')
|
||
if not uploaded_images:
|
||
uploaded_images = await self.page.query_selector_all('[class*="image"][class*="item"] img')
|
||
if not uploaded_images:
|
||
uploaded_images = await self.page.query_selector_all('.image-item img, .upload-item img, .pic-item img')
|
||
if not uploaded_images:
|
||
uploaded_images = await self.page.query_selector_all('img[src*="data:image"]')
|
||
|
||
uploaded_count = len(uploaded_images)
|
||
|
||
if uploaded_count > 0:
|
||
if uploaded_count >= images_count:
|
||
logger.success(f"✅ 所有图片上传完成！共 {uploaded_count} 张")
|
||
upload_success = True
|
||
break
|
||
|
||
# 每秒打印一次进度
|
||
if i % 2 == 0:
|
||
logger.info(f"等待图片上传... {uploaded_count}/{images_count} ({(i+1)*0.5:.1f}/30秒)")
|
||
except Exception as e:
|
||
error_msg = str(e)
|
||
if 'context was destroyed' in error_msg.lower() or 'navigation' in error_msg.lower():
|
||
logger.error(f"检测到页面跳转: {error_msg}")
|
||
page_destroyed = True
|
||
break
|
||
logger.error(f"检测上传状态异常: {e}")
|
||
if i > 10:
|
||
await asyncio.sleep(1)
|
||
|
||
# 如果页面被销毁，尝试等待重定向完成
|
||
if page_destroyed:
|
||
logger.warning("⚠️ 页面发生跳转，等待页面稳定...")
|
||
await asyncio.sleep(3)
|
||
try:
|
||
uploaded_images = await self.page.query_selector_all('img[src*="blob:"], img[src*="data:image"], [class*="image"][class*="item"] img')
|
||
uploaded_count = len(uploaded_images)
|
||
if uploaded_count >= images_count:
|
||
logger.success(f"✅ 页面稳定后确认图片已上传！共 {uploaded_count} 张")
|
||
upload_success = True
|
||
else:
|
||
logger.warning(f"⚠️ 页面稳定后检测到 {uploaded_count}/{images_count} 张图片")
|
||
except Exception as e:
|
||
logger.error(f"页面稳定后检测失败: {e}")
|
||
|
||
if upload_success:
|
||
logger.success(f"✅ 图片上传成功！共 {uploaded_count} 张")
|
||
await asyncio.sleep(0.5) # 优化：0.5秒
|
||
|
||
# 清理下载的临时文件
|
||
for temp_file in downloaded_files:
|
||
try:
|
||
os.remove(temp_file)
|
||
logger.success(f"✅ 已清理临时文件: {temp_file}")
|
||
except Exception:
|
||
pass
|
||
else:
|
||
logger.warning(f"⚠️ 仅检测到 {uploaded_count}/{images_count} 张图片，但继续执行...")
|
||
|
||
clicked = True
|
||
break
|
||
except Exception:
|
||
continue
|
||
|
||
if not clicked:
|
||
logger.warning("⚠️ 未找到任何上传控件，跳过图片上传")
|
||
|
||
except Exception as e:
|
||
logger.error(f"上传图片失败: {str(e)}")
|
||
# 不中断流程，继续发布文字
|
||
|
||
# 输入标题和内容
|
||
try:
|
||
logger.debug("开始输入文字内容...")
|
||
|
||
# 查找标题输入框(使用显式等待确保元素可交互)
|
||
title_selectors = [
|
||
'input[placeholder*="标题"]',
|
||
'input[placeholder*="填写标题"]',
|
||
'input[placeholder*="曝光"]',
|
||
'.title-input',
|
||
'[class*="title"] input',
|
||
]
|
||
|
||
title_input = None
|
||
# 优化：先用快速query_selector查找
|
||
for selector in title_selectors:
|
||
try:
|
||
title_input = await self.page.query_selector(selector)
|
||
if title_input:
|
||
# 检查元素是否可见
|
||
is_visible = await title_input.is_visible()
|
||
if is_visible:
|
||
await asyncio.sleep(0.2) # 优化：减少等待时间
|
||
logger.info(f"找到标题输入框: {selector}")
|
||
break
|
||
else:
|
||
title_input = None
|
||
except Exception:
|
||
continue
|
||
|
||
# 如果快速查找失败，再用wait方式
|
||
if not title_input:
|
||
for selector in title_selectors:
|
||
try:
|
||
title_input = await self.page.wait_for_selector(
|
||
selector,
|
||
state='visible',
|
||
timeout=3000 # 优化：减少超时时间
|
||
)
|
||
if title_input:
|
||
await asyncio.sleep(0.2)
|
||
logger.info(f"找到标题输入框: {selector}")
|
||
break
|
||
except Exception:
|
||
continue
|
||
|
||
if title_input:
|
||
await title_input.click()
|
||
await asyncio.sleep(0.3)
|
||
await title_input.fill(title)
|
||
logger.success(f"已输入标题: {title}")
|
||
else:
|
||
logger.warning("未找到标题输入框，可能不需要单独标题")
|
||
|
||
# 查找内容输入框(正文)(使用显式等待确保元素可交互)
|
||
content_selectors = [
|
||
'div[contenteditable="true"]',
|
||
'div[placeholder*="正文"]',
|
||
'div[placeholder*="输入正文"]',
|
||
'textarea[placeholder*="输入正文"]',
|
||
'textarea[placeholder*="填写笔记内容"]',
|
||
'textarea[placeholder*="笔记内容"]',
|
||
'[class*="content"] div[contenteditable="true"]',
|
||
'[class*="editor"] div[contenteditable="true"]',
|
||
'textarea',
|
||
]
|
||
|
||
content_input = None
|
||
# 优化：先用快速query_selector查找
|
||
for selector in content_selectors:
|
||
try:
|
||
content_input = await self.page.query_selector(selector)
|
||
if content_input:
|
||
is_visible = await content_input.is_visible()
|
||
if is_visible:
|
||
await asyncio.sleep(0.2) # 优化：减少等待时间
|
||
logger.info(f"找到内容输入框: {selector}")
|
||
break
|
||
else:
|
||
content_input = None
|
||
except Exception:
|
||
continue
|
||
|
||
# 如果快速查找失败，再用wait方式
|
||
if not content_input:
|
||
for selector in content_selectors:
|
||
try:
|
||
content_input = await self.page.wait_for_selector(
|
||
selector,
|
||
state='visible',
|
||
timeout=3000 # 优化：减少超时时间
|
||
)
|
||
if content_input:
|
||
await asyncio.sleep(0.2)
|
||
logger.info(f"找到内容输入框: {selector}")
|
||
break
|
||
except Exception:
|
||
continue
|
||
|
||
if content_input:
|
||
# 清空并输入内容
|
||
await content_input.click()
|
||
await asyncio.sleep(0.2) # 优化：减少等待时间
|
||
|
||
# 检查是否是contenteditable元素
|
||
try:
|
||
is_contenteditable = await content_input.evaluate('el => el.getAttribute("contenteditable") === "true"')
|
||
if is_contenteditable:
|
||
# 使用innerText设置内容
|
||
await content_input.evaluate(f'el => el.innerText = {json.dumps(content)}')
|
||
else:
|
||
# 普通textarea
|
||
await content_input.fill(content)
|
||
except Exception:
|
||
# 如果判断失败，尝试直接fill
|
||
await content_input.fill(content)
|
||
|
||
logger.success("已输入笔记内容")
|
||
await asyncio.sleep(0.2) # 优化：减少等待时间
|
||
|
||
# 添加话题标签
|
||
if topics:
|
||
logger.info(f"添加话题标签: {topics}")
|
||
for topic in topics:
|
||
# 在内容末尾添加话题
|
||
topic_text = f" #{topic}"
|
||
try:
|
||
is_contenteditable = await content_input.evaluate('el => el.getAttribute("contenteditable") === "true"')
|
||
if is_contenteditable:
|
||
await content_input.evaluate(f'el => el.innerText += {json.dumps(topic_text)}')
|
||
else:
|
||
current_value = await content_input.evaluate('el => el.value')
|
||
await content_input.fill(current_value + topic_text)
|
||
except Exception:
|
||
# 如果添加失败，继续下一个
|
||
pass
|
||
logger.success(f"已添加 {len(topics)} 个话题标签")
|
||
|
||
await asyncio.sleep(0.5) # 优化：减少等待时间
|
||
|
||
# 单独在话题输入框中模拟人类方式输入标签
|
||
if topics:
|
||
logger.info("尝试在话题输入框中逐个输入标签...")
|
||
tag_input_selectors = [
|
||
'input[placeholder*="话题"]',
|
||
'input[placeholder*="#"]',
|
||
'input[placeholder*="添加标签"]',
|
||
'[class*="tag"] input',
|
||
'[class*="topic"] input',
|
||
]
|
||
tag_input = None
|
||
# 优化：先用query_selector快速查找
|
||
for selector in tag_input_selectors:
|
||
try:
|
||
tag_input = await self.page.query_selector(selector)
|
||
if tag_input:
|
||
logger.info(f"找到话题输入框: {selector}")
|
||
break
|
||
except Exception:
|
||
continue
|
||
|
||
# 快速查找失败再用wait
|
||
if not tag_input:
|
||
for selector in tag_input_selectors:
|
||
try:
|
||
tag_input = await self.page.wait_for_selector(selector, timeout=2000)
|
||
if tag_input:
|
||
logger.info(f"找到话题输入框: {selector}")
|
||
break
|
||
except Exception:
|
||
continue
|
||
|
||
if tag_input:
|
||
for topic in topics:
|
||
try:
|
||
await tag_input.click()
|
||
await asyncio.sleep(0.2) # 优化：减少等待时间
|
||
# 清空已有内容
|
||
try:
|
||
await tag_input.fill("")
|
||
except Exception:
|
||
pass
|
||
# 优化：使用fill代替type，更快
|
||
await tag_input.fill("#" + topic)
|
||
await asyncio.sleep(0.5) # 优化：减少等待时间
|
||
# 等待联想列表并选择第一项
|
||
suggestion = None
|
||
suggestion_selectors = [
|
||
'[class*="suggest"] li',
|
||
'[role="listbox"] li',
|
||
'[class*="dropdown"] li',
|
||
]
|
||
for s_selector in suggestion_selectors:
|
||
try:
|
||
suggestion = await self.page.query_selector(s_selector)
|
||
if suggestion:
|
||
break
|
||
except Exception:
|
||
continue
|
||
if suggestion:
|
||
await suggestion.click()
|
||
logger.success(f"✅ 已选择联想话题: {topic}")
|
||
else:
|
||
# 没有联想列表时，通过回车确认
|
||
await tag_input.press("Enter")
|
||
logger.warning(f"✅ 未找到联想列表，使用回车确认话题: {topic}")
|
||
await asyncio.sleep(0.3) # 优化：减少等待时间
|
||
except Exception as e:
|
||
logger.error(f"添加话题 {topic} 到输入框失败: {str(e)}")
|
||
else:
|
||
logger.warning("⚠️ 未找到话题输入框，已退回到在正文中追加 #话题 的方式")
|
||
else:
|
||
return {
|
||
"success": False,
|
||
"error": "未找到内容输入框"
|
||
}
|
||
|
||
except Exception as e:
|
||
return {
|
||
"success": False,
|
||
"error": f"输入内容失败: {str(e)}"
|
||
}
|
||
|
||
# 模拟简单的人类滚动行为
|
||
try:
|
||
for _ in range(3):
|
||
await self.page.mouse.wheel(0, random.randint(200, 500))
|
||
await asyncio.sleep(random.uniform(0.3, 0.8))
|
||
except Exception:
|
||
pass
|
||
|
||
# 点击发布按钮
|
||
try:
|
||
logger.debug("查找发布按钮...")
|
||
submit_selectors = [
|
||
'button:has-text("发布笔记")',
|
||
'button:has-text("发布")',
|
||
'text="发布笔记"',
|
||
'text="发布"',
|
||
'.publish-btn',
|
||
'.submit-btn',
|
||
]
|
||
|
||
submit_btn = None
|
||
for selector in submit_selectors:
|
||
try:
|
||
submit_btn = await self.page.wait_for_selector(selector, timeout=3000)
|
||
if submit_btn:
|
||
# 检查按钮是否可点击
|
||
is_disabled = await submit_btn.evaluate('el => el.disabled')
|
||
if not is_disabled:
|
||
logger.info(f"找到发布按钮: {selector}")
|
||
break
|
||
else:
|
||
submit_btn = None
|
||
except Exception:
|
||
continue
|
||
|
||
if submit_btn:
|
||
# 设置网络监听,捕获发布接口响应
|
||
note_id = None
|
||
share_link = None
|
||
|
||
async def handle_response(response):
|
||
nonlocal note_id, share_link
|
||
try:
|
||
# 监听发布笔记的API响应
|
||
if '/web_api/sns/v2/note' in response.url:
|
||
logger.success(f"✅ 捕获到发布API响应: {response.url}")
|
||
if response.status == 200:
|
||
try:
|
||
data = await response.json()
|
||
logger.info(f"API响应数据: {json.dumps(data, ensure_ascii=False)}")
|
||
|
||
if data.get('success') and data.get('data'):
|
||
note_id = data['data'].get('id')
|
||
# 优先使用share_link,如果没有则使用note_id拼接
|
||
if 'share_link' in data:
|
||
share_link = data['share_link']
|
||
logger.success(f"✅ 获取到笔记链接: {share_link}")
|
||
elif note_id:
|
||
share_link = f"https://www.xiaohongshu.com/discovery/item/{note_id}"
|
||
logger.success(f"✅ 根据ID生成笔记链接: {share_link}")
|
||
except Exception as e:
|
||
logger.error(f"解析API响应失败: {str(e)}")
|
||
except Exception as e:
|
||
logger.error(f"处理响应失败: {str(e)}")
|
||
|
||
# 添加响应监听器
|
||
self.page.on('response', handle_response)
|
||
|
||
await submit_btn.click()
|
||
logger.success("✅ 已点击发布按钮")
|
||
await asyncio.sleep(3) # 等待更长时间以捕获API响应
|
||
|
||
# 检查是否出现社区规范限制提示
|
||
logger.info("检查是否有社区规范限制...")
|
||
try:
|
||
# 尝试查找各种可能的错误提示
|
||
error_selectors = [
|
||
'text="因违反社区规范禁止发笔记"',
|
||
'text*="违反社区规范"',
|
||
'text*="禁止发布"',
|
||
'text*="账号被限制"',
|
||
'text*="账号异常"',
|
||
'.error-tip',
|
||
'.warning-tip',
|
||
'[class*="error"]',
|
||
'[class*="warning"]',
|
||
]
|
||
|
||
for selector in error_selectors:
|
||
try:
|
||
error_el = await self.page.wait_for_selector(selector, timeout=2000)
|
||
if error_el:
|
||
error_text = await error_el.inner_text()
|
||
logger.error(f"❌ 检测到错误提示: {error_text}")
|
||
return {
|
||
"success": False,
|
||
"error": f"发布失败: {error_text}",
|
||
"error_type": "community_violation", # 标记错误类型
|
||
"message": error_text
|
||
}
|
||
except Exception:
|
||
continue
|
||
except Exception as e:
|
||
logger.error(f"检查错误提示异常: {str(e)}")
|
||
|
||
# 检查是否发布成功
|
||
logger.info("检查发布结果...")
|
||
try:
|
||
await asyncio.sleep(2) # 等待发布完成
|
||
|
||
# 如果捕获到了真实的笔记链接,直接返回
|
||
if share_link:
|
||
logger.success(f"✅ 发布成功,获取到笔记链接: {share_link}")
|
||
|
||
# 如果是浏览器池模式且使用了Cookie，关闭发布专用页面
|
||
if self.use_pool and self.browser_pool and cookies:
|
||
try:
|
||
logger.info("[浏览器池模式] 关闭发布专用页面")
|
||
await self.page.close()
|
||
self.page = None
|
||
logger.success("✅ 发布页面已关闭")
|
||
except Exception as e:
|
||
logger.error(f"⚠️ 关闭页面失败: {str(e)}")
|
||
|
||
return {
|
||
"success": True,
|
||
"message": "笔记发布成功",
|
||
"data": {
|
||
"note_id": note_id,
|
||
"note_url": share_link
|
||
},
|
||
"url": share_link # 保持兼容性
|
||
}
|
||
|
||
# 如果没有捕获到,使用原来的逻辑
|
||
# 等待发布成功的提示或页面跳转
|
||
success_selectors = [
|
||
'text="发布成功"',
|
||
'text="发布完成"',
|
||
'text*="成功"',
|
||
'.success-tip',
|
||
'.success-message',
|
||
]
|
||
|
||
publish_success = False
|
||
for selector in success_selectors:
|
||
try:
|
||
success_el = await self.page.wait_for_selector(selector, timeout=3000)
|
||
if success_el:
|
||
success_text = await success_el.inner_text()
|
||
logger.warning(f"✅ 检测到发布成功提示: {success_text}")
|
||
publish_success = True
|
||
break
|
||
except Exception:
|
||
continue
|
||
|
||
# 如果没有明确的成功提示，检查URL是否变化
|
||
current_url = self.page.url
|
||
if not publish_success:
|
||
# 如果还在发布页面，可能是发布失败
|
||
if 'publish' in current_url.lower():
|
||
logger.warning("⚠️ 未检测到成功提示，但继续执行")
|
||
else:
|
||
logger.success("✅ URL已变化，似乎发布成功")
|
||
publish_success = True
|
||
|
||
logger.info(f"发布后URL: {current_url}")
|
||
|
||
# 如果是浏览器池模式且使用了Cookie，关闭发布专用页面和context
|
||
if self.use_pool and self.browser_pool and cookies:
|
||
try:
|
||
logger.info("[浏览器池模式] 关闭发布专用环境")
|
||
if self.page:
|
||
await self.page.close()
|
||
self.page = None
|
||
logger.success("✅ 发布页面已关闭")
|
||
if self.context:
|
||
await self.context.close()
|
||
self.context = None
|
||
logger.success("✅ 发布context已关闭（预热环境保持不受影响）")
|
||
except Exception as e:
|
||
logger.error(f"⚠️ 关闭发布环境失败: {str(e)}")
|
||
|
||
# 如果使用AdsPower，关闭并删除浏览器环境
|
||
if self.use_adspower and self.fingerprint_manager and self.adspower_profile_id:
|
||
try:
|
||
logger.info("\n" + "="*70)
|
||
logger.info(f"[AdsPower清理] 开始清理临时发布环境")
|
||
logger.info("="*70)
|
||
logger.info(f" Profile ID: {self.adspower_profile_id}")
|
||
|
||
# 步骤1: 关闭浏览器
|
||
logger.info("\n[步骤 1/3] 关闭浏览器...")
|
||
await self.fingerprint_manager.stop_browser(self.adspower_profile_id)
|
||
logger.success(">> 浏览器已关闭")
|
||
|
||
# 步骤2: 检查是否有关联的代理ID（API v2代理池）
|
||
logger.info("\n[步骤 2/3] 检查代理配置...")
|
||
proxy_id = await self.fingerprint_manager.get_profile_proxy_id(self.adspower_profile_id)
|
||
if proxy_id:
|
||
logger.info(f" 检测到代理池代理ID: {proxy_id}")
|
||
else:
|
||
logger.info(" 使用直接配置的代理，无需删除代理池记录")
|
||
|
||
# 步骤3: 删除浏览器环境
|
||
logger.info("\n[步骤 3/3] 删除浏览器环境...")
|
||
await self.fingerprint_manager.delete_profile(self.adspower_profile_id)
|
||
logger.success(">> 浏览器环境已删除")
|
||
|
||
# 如果使用了代理池，删除代理
|
||
if proxy_id:
|
||
logger.info("\n[额外步骤] 删除代理池代理...")
|
||
await self.fingerprint_manager.delete_proxy(proxy_id)
|
||
logger.success(">> 代理已删除")
|
||
|
||
logger.info("\n" + "="*70)
|
||
logger.success("[AdsPower清理] 临时环境清理完成")
|
||
logger.info("="*70 + "\n")
|
||
|
||
self.adspower_profile_id = None
|
||
except Exception as e:
|
||
logger.error(f"\n[AdsPower清理] 清理失败: {str(e)}")
|
||
|
||
return {
|
||
"success": True,
|
||
"message": "笔记发布成功",
|
||
"url": current_url
|
||
}
|
||
except Exception as e:
|
||
logger.error(f"检查发布结果异常: {str(e)}")
|
||
|
||
# 如果是浏览器池模式且使用了Cookie,关闭发布专用页面和context
|
||
if self.use_pool and self.browser_pool and cookies:
|
||
try:
|
||
logger.info("[浏览器池模式] 关闭发布专用环境")
|
||
if self.page:
|
||
await self.page.close()
|
||
self.page = None
|
||
logger.success("✅ 发布页面已关闭")
|
||
if self.context:
|
||
await self.context.close()
|
||
self.context = None
|
||
logger.success("✅ 发布context已关闭（预热环境保持不受影响）")
|
||
except Exception as e2:
|
||
logger.error(f"⚠️ 关闭发布环境失败: {str(e2)}")
|
||
|
||
# 如果使用AdsPower，关闭并删除浏览器环境
|
||
if self.use_adspower and self.fingerprint_manager and self.adspower_profile_id:
|
||
try:
|
||
logger.info("\n" + "="*70)
|
||
logger.info(f"[AdsPower清理] 开始清理临时发布环境（发布异常）")
|
||
logger.info("="*70)
|
||
logger.info(f" Profile ID: {self.adspower_profile_id}")
|
||
|
||
# 步骤1: 关闭浏览器
|
||
logger.info("\n[步骤 1/3] 关闭浏览器...")
|
||
await self.fingerprint_manager.stop_browser(self.adspower_profile_id)
|
||
logger.success(">> 浏览器已关闭")
|
||
|
||
# 步骤2: 检查是否有关联的代理ID（API v2代理池）
|
||
logger.info("\n[步骤 2/3] 检查代理配置...")
|
||
proxy_id = await self.fingerprint_manager.get_profile_proxy_id(self.adspower_profile_id)
|
||
if proxy_id:
|
||
logger.info(f" 检测到代理池代理ID: {proxy_id}")
|
||
else:
|
||
logger.info(" 使用直接配置的代理，无需删除代理池记录")
|
||
|
||
# 步骤3: 删除浏览器环境
|
||
logger.info("\n[步骤 3/3] 删除浏览器环境...")
|
||
await self.fingerprint_manager.delete_profile(self.adspower_profile_id)
|
||
logger.success(">> 浏览器环境已删除")
|
||
|
||
# 如果使用了代理池，删除代理
|
||
if proxy_id:
|
||
logger.info("\n[额外步骤] 删除代理池代理...")
|
||
await self.fingerprint_manager.delete_proxy(proxy_id)
|
||
logger.success(">> 代理已删除")
|
||
|
||
logger.info("\n" + "="*70)
|
||
logger.success("[AdsPower清理] 临时环境清理完成")
|
||
logger.info("="*70 + "\n")
|
||
|
||
self.adspower_profile_id = None
|
||
except Exception as e2:
|
||
logger.error(f"\n[AdsPower清理] 清理失败: {str(e2)}")
|
||
|
||
# 即使检查异常，也返回成功（因为按钮已点击）
|
||
return {
|
||
"success": True,
|
||
"message": "笔记已提交发布，但未能确认结果",
|
||
"url": self.page.url if self.page else ""
|
||
}
|
||
else:
|
||
return {
|
||
"success": False,
|
||
"error": "未找到可用的发布按钮，可能内容不完整"
|
||
}
|
||
|
||
except Exception as e:
|
||
return {
|
||
"success": False,
|
||
"error": f"点击发布按钮失败: {str(e)}"
|
||
}
|
||
|
||
except Exception as e:
|
||
logger.error(f"发布笔记异常: {str(e)}")
|
||
return {
|
||
"success": False,
|
||
"error": str(e)
|
||
}
|
||
|
||
async def start_qrcode_login(self, login_page: str = "home") -> Dict[str, Any]:
|
||
"""
|
||
启动小红书首页的扫码登录流程
|
||
|
||
Args:
|
||
login_page: 登录页面类型，默认home(小红书首页)
|
||
|
||
Returns:
|
||
Dict containing qrcode image and status
|
||
"""
|
||
try:
|
||
if not self.page:
|
||
await self.init_browser()
|
||
|
||
# 访问小红书首页
|
||
login_url = 'https://www.xiaohongshu.com'
|
||
logger.info(f"[扫码登录] 正在访问小红书首页...")
|
||
|
||
# 强制访问首页，不管当前在哪个页面
|
||
try:
|
||
# 使用domcontentloaded而不是networkidle，避免等待所有资源加载
|
||
await self.page.goto(login_url, wait_until='domcontentloaded', timeout=10000)
|
||
current_url = self.page.url
|
||
logger.success(f"[扫码登录] 页面加载完成, 当前URL: {current_url}")
|
||
|
||
# 检测小红书反爬JSON页面
|
||
await asyncio.sleep(0.5) # 等待页面内容加载
|
||
try:
|
||
page_content = await self.page.content()
|
||
# 检查页面是否只返回JSON（小红书的检测机制）
|
||
if page_content and len(page_content) < 500: # JSON页面通常很短
|
||
# 尝试解析JSON
|
||
if '{"code"' in page_content and '"success":true' in page_content:
|
||
logger.warning("="*50)
|
||
logger.warning("⚠️ 检测到小红书反爬JSON页面")
|
||
logger.warning(f"页面内容: {page_content[:200]}")
|
||
logger.warning("="*50)
|
||
return {
|
||
"success": False,
|
||
"error": "当前IP被小红书检测，请等待5分钟后再试"
|
||
}
|
||
except Exception as e:
|
||
# 其他异常忽略，继续执行
|
||
pass
|
||
|
||
# 检查是否跳转到验证码页面
|
||
if '/website-login/captcha' in current_url or 'verifyUuid=' in current_url:
|
||
logger.warning(f"[扫码登录] 检测到风控验证页面，尝试等待或跳过...")
|
||
# 等待30秒，看是否会自动跳过
|
||
await asyncio.sleep(30)
|
||
current_url = self.page.url
|
||
logger.info(f"[扫码登录] 等待30秒后当前URL: {current_url}")
|
||
|
||
# 如果还在验证码页面，返回错误
|
||
if '/website-login/captcha' in current_url or 'verifyUuid=' in current_url:
|
||
return {
|
||
"success": False,
|
||
"error": "当前IP被风控，需要验证。请稍后再试或启用代理。"
|
||
}
|
||
except Exception as e:
|
||
# 即使超时也继续,因为页面可能已经跳转到explore
|
||
current_url = self.page.url
|
||
if 'xiaohongshu.com' in current_url:
|
||
logger.warning(f"[扫码登录] 页面加载超时但已到达小红书页面: {current_url}")
|
||
else:
|
||
logger.error(f"[扫码登录] 页面加载失败: {str(e)}, 当前URL: {current_url}")
|
||
raise e
|
||
|
||
# 🔥 关键修改: 在explore页面后立即注册路由监听，被动等待二维码创建
|
||
qrcode_create_data = None
|
||
|
||
# 设置路由监听二维码创建 API
|
||
async def handle_qrcode_create(route):
|
||
nonlocal qrcode_create_data
|
||
try:
|
||
request = route.request
|
||
logger.info(f"[扫码登录] API请求: {request.method} {request.url}")
|
||
|
||
response = await route.fetch()
|
||
body = await response.body()
|
||
try:
|
||
data = json.loads(body.decode('utf-8'))
|
||
logger.info(f"[扫码登录] API响应: {json.dumps(data, ensure_ascii=False)}")
|
||
|
||
if data.get('code') == 0 and data.get('success') and data.get('data'):
|
||
qrcode_create_data = data.get('data')
|
||
logger.success(f"[扫码登录] 获取到二维码 qr_id={qrcode_create_data.get('qr_id')}")
|
||
except Exception as e:
|
||
logger.error(f"[扫码登录] 解析响应失败: {str(e)}")
|
||
await route.fulfill(response=response)
|
||
except Exception as e:
|
||
logger.error(f"[扫码登录] 处理API请求失败: {str(e)}")
|
||
await route.continue_()
|
||
|
||
# 注册路由 (在explore页面后立即注册)
|
||
await self.page.route('**/api/sns/web/v1/login/qrcode/create', handle_qrcode_create)
|
||
logger.info("[扫码登录] 已注册 API路由监听，等待页面自动触发二维码创建...")
|
||
|
||
# 被动等待二维码创建 API请求完成(最多等待30秒)
|
||
for i in range(300): # 300 * 0.1 = 30秒
|
||
if qrcode_create_data:
|
||
break
|
||
await asyncio.sleep(0.1)
|
||
|
||
if not qrcode_create_data:
|
||
logger.warning("[扫码登录] 30秒内未捕获到二维码创建 API请求，尝试从页面提取二维码")
|
||
|
||
# 提取二维码和状态（但不检测登录成功，因为这是初始化）
|
||
qrcode_result = await self.extract_qrcode_with_status(check_login_success=False)
|
||
|
||
# 如果获取到二维码创建信息，添加到结果中
|
||
if qrcode_create_data:
|
||
qrcode_result["qr_id"] = qrcode_create_data.get('qr_id')
|
||
qrcode_result["qr_code"] = qrcode_create_data.get('code')
|
||
qrcode_result["qr_url"] = qrcode_create_data.get('url')
|
||
qrcode_result["multi_flag"] = qrcode_create_data.get('multi_flag')
|
||
|
||
return qrcode_result
|
||
|
||
except Exception as e:
|
||
logger.error(f"启动扫码登录失败: {str(e)}")
|
||
return {
|
||
"success": False,
|
||
"error": str(e)
|
||
}
|
||
|
||
async def extract_qrcode_with_status(self, check_login_success: bool = True) -> Dict[str, Any]:
|
||
"""
|
||
提取二维码图片和状态信息，并检测是否扫码成功
|
||
|
||
Args:
|
||
check_login_success: 是否检测登录成功，默认True。start_qrcode_login时传False
|
||
|
||
Returns:
|
||
Dict containing qrcode image, status text, login success and user data
|
||
"""
|
||
try:
|
||
if not self.page:
|
||
return {
|
||
"success": False,
|
||
"error": "浏览器未初始化"
|
||
}
|
||
|
||
result = {
|
||
"success": True,
|
||
"qrcode_image": "",
|
||
"status_text": "",
|
||
"status_desc": "",
|
||
"is_expired": False,
|
||
"login_success": False, # 新增：是否扫码登录成功
|
||
"user_info": None,
|
||
"cookies": None,
|
||
"cookies_full": None,
|
||
"login_state": None
|
||
}
|
||
|
||
# 只有在轮询检查时才判断登录成功
|
||
if check_login_success:
|
||
# 方法1: 监听用户信息API请求(最准确的方式)
|
||
user_me_data = None
|
||
try:
|
||
# 直接请求用户信息API
|
||
response = await self.page.evaluate('''
|
||
async () => {
|
||
try {
|
||
const response = await fetch('https://edith.xiaohongshu.com/api/sns/web/v2/user/me', {
|
||
method: 'GET',
|
||
credentials: 'include'
|
||
});
|
||
const data = await response.json();
|
||
return data;
|
||
} catch (error) {
|
||
return { error: error.message };
|
||
}
|
||
}
|
||
''')
|
||
|
||
if response and not response.get('error'):
|
||
# 关键修复: 检查是否是游客状态
|
||
if response.get('code') == 0 and response.get('success') and response.get('data'):
|
||
data = response.get('data')
|
||
is_guest = data.get('guest', False)
|
||
|
||
# 只有非游客状态才算登录成功
|
||
if not is_guest and data.get('user_id') and data.get('nickname'):
|
||
user_me_data = data
|
||
logger.success(f"[扫码登录] 登录成功! user_id={user_me_data.get('user_id')}, nickname={user_me_data.get('nickname')}")
|
||
except Exception as e:
|
||
logger.error(f"[扫码登录] 请求用户信息 API异常: {str(e)}")
|
||
|
||
# 如果获取到用户信息,说明登录成功
|
||
if user_me_data:
|
||
result["login_success"] = True
|
||
|
||
# 等待页面稳定
|
||
await asyncio.sleep(1)
|
||
|
||
# 获取Cookies
|
||
try:
|
||
cookies = await self.context.cookies()
|
||
cookies_dict = {cookie['name']: cookie['value'] for cookie in cookies}
|
||
result["cookies"] = cookies_dict
|
||
result["cookies_full"] = cookies
|
||
except Exception as e:
|
||
logger.error(f"[扫码登录] 获取Cookie失败: {str(e)}")
|
||
|
||
# 构建用户信息(使用API返回的数据 + localStorage)
|
||
try:
|
||
# 先从 localStorage 获取基础信息
|
||
storage = await self.page.evaluate('() => JSON.stringify(localStorage)')
|
||
storage_dict = json.loads(storage)
|
||
|
||
user_info = {
|
||
# 从 API 响应中提取的信息(最准确)
|
||
'user_id': user_me_data.get('user_id'),
|
||
'red_id': user_me_data.get('red_id'),
|
||
'nickname': user_me_data.get('nickname'),
|
||
'desc': user_me_data.get('desc'),
|
||
'gender': user_me_data.get('gender'),
|
||
'avatar_small': user_me_data.get('images'), # 小头像
|
||
'avatar_large': user_me_data.get('imageb'), # 大头像
|
||
'is_guest': user_me_data.get('guest', False)
|
||
}
|
||
|
||
# 补充 localStorage 中的其他信息
|
||
useful_keys = ['b1', 'b1b1', 'p1']
|
||
for key in useful_keys:
|
||
if key in storage_dict:
|
||
try:
|
||
value = storage_dict[key]
|
||
if value and value.strip():
|
||
user_info[key] = json.loads(value) if value.startswith('{') or value.startswith('[') else value
|
||
except:
|
||
user_info[key] = storage_dict[key]
|
||
|
||
result["user_info"] = user_info
|
||
except Exception as e:
|
||
logger.error(f"[扫码登录] 构建用户信息失败: {str(e)}")
|
||
# 即\u4f7f失\u8d25,\u4e5f\u4f7f\u7528API\u8fd4\u56de\u7684\u6570\u636e
|
||
result["user_info"] = {
|
||
'user_id': user_me_data.get('user_id'),
|
||
'red_id': user_me_data.get('red_id'),
|
||
'nickname': user_me_data.get('nickname'),
|
||
'desc': user_me_data.get('desc'),
|
||
'gender': user_me_data.get('gender'),
|
||
'avatar_small': user_me_data.get('images'),
|
||
'avatar_large': user_me_data.get('imageb'),
|
||
'is_guest': user_me_data.get('guest', False)
|
||
}
|
||
|
||
# 获取完整的登录状态
|
||
try:
|
||
current_url = self.page.url
|
||
localStorage_data = {}
|
||
sessionStorage_data = {}
|
||
|
||
try:
|
||
storage = await self.page.evaluate('() => JSON.stringify(localStorage)')
|
||
localStorage_data = json.loads(storage)
|
||
except Exception as e:
|
||
logger.info(f"\u26a0\ufe0f \u83b7\u53d6localStorage\u5931\u8d25: {str(e)}")
|
||
|
||
try:
|
||
session_storage = await self.page.evaluate('() => JSON.stringify(sessionStorage)')
|
||
sessionStorage_data = json.loads(session_storage)
|
||
except Exception as e:
|
||
logger.info(f"\u26a0\ufe0f \u83b7\u53d6sessionStorage\u5931\u8d25: {str(e)}")
|
||
|
||
result["login_state"] = {
|
||
"cookies": result["cookies_full"],
|
||
"localStorage": localStorage_data,
|
||
"sessionStorage": sessionStorage_data,
|
||
"url": current_url,
|
||
"timestamp": time.time()
|
||
}
|
||
logger.info("\u2705 \u5df2\u6784\u5efa\u5b8c\u6574\u767b\u5f55\u72b6\u6001")
|
||
except Exception as e:
|
||
logger.info(f"\u26a0\ufe0f \u6784\u5efa\u767b\u5f55\u72b6\u6001\u5931\u8d25: {str(e)}")
|
||
|
||
return result
|
||
|
||
# 如果API请求失败,退而求其次使用页面元素检测
|
||
logger.info("\u26a0\ufe0f API\u68c0\u6d4b\u5931\u8d25,\u4f7f\u7528\u9875\u9762\u5143\u7d20\u68c0\u6d4b")
|
||
current_url = self.page.url
|
||
logger.info(f"\u5f53\u524dURL: {current_url}")
|
||
|
||
# 方法2: 检查\u4e8c\u7ef4\u7801\u662f\u5426\u8fd8\u5728(如\u679c\u4e8c\u7ef4\u7801\u6d88\u5931\u4e86,\u8bf4\u660e\u53ef\u80fd\u767b\u5f55\u4e86)
|
||
qrcode_exists = False
|
||
try:
|
||
qrcode_img = await self.page.query_selector('.qrcode-img')
|
||
if qrcode_img:
|
||
qrcode_exists = await qrcode_img.is_visible()
|
||
except Exception:
|
||
pass
|
||
|
||
# 方法3: 检查\u767b\u5f55\u5f39\u7a97\u662f\u5426\u5173\u95ed
|
||
login_modal_closed = True
|
||
try:
|
||
modal_selectors = [
|
||
'.login-container',
|
||
'.reds-modal',
|
||
'[class*="login-modal"]',
|
||
'[class*="LoginModal"]',
|
||
]
|
||
for selector in modal_selectors:
|
||
modal = await self.page.query_selector(selector)
|
||
if modal and await modal.is_visible():
|
||
login_modal_closed = False
|
||
break
|
||
except Exception:
|
||
pass
|
||
|
||
# 方法4: 检查\u662f\u5426\u6709\u767b\u5f55\u540e\u7684\u7528\u6237\u4fe1\u606f\u5143\u7d20
|
||
has_user_info = False
|
||
try:
|
||
user_selectors = [
|
||
'.user-info',
|
||
'.avatar',
|
||
'[class*="user"]',
|
||
]
|
||
for selector in user_selectors:
|
||
user_el = await self.page.query_selector(selector)
|
||
if user_el and await user_el.is_visible():
|
||
has_user_info = True
|
||
break
|
||
except Exception:
|
||
pass
|
||
|
||
logger.info(f"\u767b\u5f55\u72b6\u6001\u68c0\u6d4b: \u4e8c\u7ef4\u7801\u5b58\u5728={qrcode_exists}, \u767b\u5f55\u6846\u5173\u95ed={login_modal_closed}, \u6709\u7528\u6237\u4fe1\u606f={has_user_info}")
|
||
|
||
# 综合\u5224\u65ad: \u4e8c\u7ef4\u7801\u6d88\u5931 \u4e14 (\u767b\u5f55\u6846\u5173\u95ed \u6216 \u6709\u7528\u6237\u4fe1\u606f)
|
||
if not qrcode_exists and (login_modal_closed or has_user_info):
|
||
logger.info("\u2705 \u68c0\u6d4b\u5230\u626b\u7801\u767b\u5f55\u6210\u529f!(\u4e8c\u7ef4\u7801\u5df2\u6d88\u5931)")
|
||
result["login_success"] = True
|
||
|
||
# 等\u5f85\u9875\u9762\u7a33\u5b9a
|
||
await asyncio.sleep(1)
|
||
|
||
# 获\u53d6Cookies
|
||
try:
|
||
cookies = await self.context.cookies()
|
||
cookies_dict = {cookie['name']: cookie['value'] for cookie in cookies}
|
||
result["cookies"] = cookies_dict
|
||
result["cookies_full"] = cookies
|
||
logger.info(f"\u2705 \u5df2\u83b7\u53d6 {len(cookies)} \u4e2aCookie")
|
||
except Exception as e:
|
||
logger.info(f"\u26a0\ufe0f \u83b7\u53d6Cookie\u5931\u8d25: {str(e)}")
|
||
|
||
# 获\u53d6\u7528\u6237\u4fe1\u606f
|
||
try:
|
||
storage = await self.page.evaluate('() => JSON.stringify(localStorage)')
|
||
storage_dict = json.loads(storage)
|
||
|
||
user_info = {}
|
||
useful_keys = ['b1', 'b1b1', 'p1']
|
||
for key in useful_keys:
|
||
if key in storage_dict:
|
||
try:
|
||
value = storage_dict[key]
|
||
if value and value.strip():
|
||
user_info[key] = json.loads(value) if value.startswith('{') or value.startswith('[') else value
|
||
except:
|
||
user_info[key] = storage_dict[key]
|
||
|
||
result["user_info"] = user_info
|
||
logger.info(f"\u2705 \u5df2\u83b7\u53d6\u7528\u6237\u4fe1\u606f: {list(user_info.keys())}")
|
||
except Exception as e:
|
||
logger.info(f"\u26a0\ufe0f \u83b7\u53d6\u7528\u6237\u4fe1\u606f\u5931\u8d25: {str(e)}")
|
||
|
||
# 获\u53d6\u5b8c\u6574\u7684\u767b\u5f55\u72b6\u6001
|
||
try:
|
||
localStorage_data = {}
|
||
sessionStorage_data = {}
|
||
|
||
try:
|
||
storage = await self.page.evaluate('() => JSON.stringify(localStorage)')
|
||
localStorage_data = json.loads(storage)
|
||
except Exception as e:
|
||
logger.info(f"\u26a0\ufe0f \u83b7\u53d6localStorage\u5931\u8d25: {str(e)}")
|
||
|
||
try:
|
||
session_storage = await self.page.evaluate('() => JSON.stringify(sessionStorage)')
|
||
sessionStorage_data = json.loads(session_storage)
|
||
except Exception as e:
|
||
logger.info(f"\u26a0\ufe0f \u83b7\u53d6sessionStorage\u5931\u8d25: {str(e)}")
|
||
|
||
result["login_state"] = {
|
||
"cookies": result["cookies_full"],
|
||
"localStorage": localStorage_data,
|
||
"sessionStorage": sessionStorage_data,
|
||
"url": current_url,
|
||
"timestamp": time.time()
|
||
}
|
||
logger.info("\u2705 \u5df2\u6784\u5efa\u5b8c\u6574\u767b\u5f55\u72b6\u6001")
|
||
except Exception as e:
|
||
logger.info(f"\u26a0\ufe0f \u6784\u5efa\u767b\u5f55\u72b6\u6001\u5931\u8d25: {str(e)}")
|
||
|
||
return result
|
||
|
||
# 还在登录页或不检查登录状态，继续提取二维码和状态
|
||
# 提取二维码图片
|
||
qrcode_selectors = [
|
||
'.qrcode-img',
|
||
'img.qrcode-img',
|
||
'.qrcode img',
|
||
'img[src*="data:image"]',
|
||
'img[alt*="二维码"]',
|
||
]
|
||
|
||
for selector in qrcode_selectors:
|
||
try:
|
||
qrcode_img = await self.page.wait_for_selector(selector, timeout=3000)
|
||
if qrcode_img:
|
||
# 获取src属性
|
||
src = await qrcode_img.get_attribute('src')
|
||
if src:
|
||
if src.startswith('data:image'):
|
||
result["qrcode_image"] = src
|
||
else:
|
||
# 如果是URL,尝试下载转换
|
||
try:
|
||
async with aiohttp.ClientSession() as session:
|
||
async with session.get(src, timeout=aiohttp.ClientTimeout(total=10)) as response:
|
||
if response.status == 200:
|
||
img_data = await response.read()
|
||
import base64
|
||
img_base64 = base64.b64encode(img_data).decode('utf-8')
|
||
content_type = response.headers.get('Content-Type', 'image/png')
|
||
result["qrcode_image"] = f"data:{content_type};base64,{img_base64}"
|
||
logger.success("✅ 成功下载并转换二维码")
|
||
except Exception as e:
|
||
logger.error(f"⚠️ 下载二维码失败: {str(e)}")
|
||
|
||
# 如果还是没有图片,尝试截图
|
||
if not result["qrcode_image"]:
|
||
try:
|
||
screenshot_bytes = await qrcode_img.screenshot()
|
||
if screenshot_bytes:
|
||
import base64
|
||
img_base64 = base64.b64encode(screenshot_bytes).decode('utf-8')
|
||
result["qrcode_image"] = f"data:image/png;base64,{img_base64}"
|
||
logger.success("✅ 成功截取二维码")
|
||
except Exception as e:
|
||
logger.error(f"⚠️ 截取二维码失败: {str(e)}")
|
||
|
||
break
|
||
except Exception as e:
|
||
continue
|
||
|
||
if not result["qrcode_image"]:
|
||
return {
|
||
"success": False,
|
||
"error": "未找到二维码图片"
|
||
}
|
||
|
||
# 提取状态信息
|
||
logger.debug("正在提取二维码状态...")
|
||
status_selectors = [
|
||
'.status',
|
||
'.qrcode-status',
|
||
'[class*="status"]',
|
||
]
|
||
|
||
for selector in status_selectors:
|
||
try:
|
||
status_el = await self.page.query_selector(selector)
|
||
if status_el:
|
||
# 检查状态是否可见
|
||
is_visible = await status_el.is_visible()
|
||
if not is_visible:
|
||
logger.info("二维码状态元素不可见，说明二维码有效")
|
||
result["status_text"] = "" # 空字符串表示正常状态
|
||
result["is_expired"] = False
|
||
break
|
||
|
||
logger.success(f"✅ 找到状态元素: {selector}")
|
||
|
||
# 提取状态文本
|
||
status_text_el = await status_el.query_selector('.status-text')
|
||
if status_text_el:
|
||
status_text = await status_text_el.inner_text()
|
||
result["status_text"] = status_text.strip()
|
||
logger.info(f"状态文本: {result['status_text']}")
|
||
|
||
# 提取状态描述
|
||
status_desc_el = await status_el.query_selector('.status-desc')
|
||
if status_desc_el:
|
||
status_desc = await status_desc_el.inner_text()
|
||
result["status_desc"] = status_desc.strip()
|
||
logger.info(f"状态描述: {result['status_desc']}")
|
||
|
||
# 判断是否过期
|
||
if "过期" in result["status_text"] or "过期" in result["status_desc"]:
|
||
result["is_expired"] = True
|
||
logger.warning("⚠️ 二维码已过期")
|
||
|
||
break
|
||
except Exception as e:
|
||
continue
|
||
|
||
# 如果没有找到状态元素，说明二维码正常(不设置status_text，小程序端自己显示)
|
||
if not result["status_text"]:
|
||
result["status_text"] = "" # 空字符串表示正常状态，小程序端不显示覆盖层
|
||
result["is_expired"] = False
|
||
|
||
logger.success(f"✅ 二维码提取完成: 状态={result['status_text']}, 过期={result['is_expired']}, 登录成功={result['login_success']}")
|
||
return result
|
||
|
||
except Exception as e:
|
||
logger.error(f"提取二维码状态失败: {str(e)}")
|
||
return {
|
||
"success": False,
|
||
"error": str(e)
|
||
}
|
||
|
||
async def refresh_qrcode(self) -> Dict[str, Any]:
|
||
"""
|
||
刷新二维码（当二维码过期时点击刷新）
|
||
|
||
Returns:
|
||
Dict containing new qrcode and status
|
||
"""
|
||
try:
|
||
if not self.page:
|
||
return {
|
||
"success": False,
|
||
"error": "浏览器未初始化"
|
||
}
|
||
|
||
# 检查page状态，如果是空白页，需要重新导航到登录页
|
||
try:
|
||
current_url = self.page.url
|
||
logger.info(f"[刷新二维码] 当前URL: {current_url}")
|
||
|
||
if current_url == 'about:blank' or current_url == '':
|
||
logger.warning("[刷新二维码] 检测到空白页，重新导航到explore页面")
|
||
await self.page.goto('https://www.xiaohongshu.com/explore', wait_until='networkidle')
|
||
await asyncio.sleep(1)
|
||
except Exception as e:
|
||
logger.error(f"[刷新二维码] 检查page状态异常: {str(e)}")
|
||
|
||
logger.info("[刷新二维码] 正在刷新...")
|
||
|
||
# 🔥 关键修改: 先注册路由监听，然后再打开登录弹窗
|
||
qrcode_create_data = None
|
||
|
||
# 设置路由监听二维码创建 API
|
||
async def handle_qrcode_create(route):
|
||
nonlocal qrcode_create_data
|
||
try:
|
||
# 记录请求
|
||
request = route.request
|
||
logger.info(f"[刷新二维码] API请求: {request.method} {request.url}")
|
||
|
||
response = await route.fetch()
|
||
body = await response.body()
|
||
try:
|
||
data = json.loads(body.decode('utf-8'))
|
||
logger.info(f"[刷新二维码] API响应: {json.dumps(data, ensure_ascii=False)}")
|
||
|
||
if data.get('code') == 0 and data.get('success') and data.get('data'):
|
||
qrcode_create_data = data.get('data')
|
||
logger.success(f"[刷新二维码] 获取到新二维码 qr_id={qrcode_create_data.get('qr_id')}")
|
||
except Exception as e:
|
||
logger.error(f"[刷新二维码] 解析响应失败: {str(e)}")
|
||
await route.fulfill(response=response)
|
||
except Exception as e:
|
||
logger.error(f"[刷新二维码] 处理API请求失败: {str(e)}")
|
||
await route.continue_()
|
||
|
||
# 注册路由 (在打开登录页之前)
|
||
await self.page.route('**/api/sns/web/v1/login/qrcode/create', handle_qrcode_create)
|
||
logger.info("[刷新二维码] 已注册 API路由监听")
|
||
|
||
# 确保在登录页面或扫码页面
|
||
current_url = self.page.url
|
||
if 'login' not in current_url.lower():
|
||
# 如果不在登录页，先打开登录页
|
||
logger.info("[刷新二维码] 不在登录页，先打开登录页")
|
||
try:
|
||
login_btn = await self.page.wait_for_selector('text="登录"', timeout=3000)
|
||
if login_btn:
|
||
await login_btn.click()
|
||
await asyncio.sleep(1)
|
||
except Exception as e:
|
||
logger.warning(f"[刷新二维码] 打开登录页失败: {str(e)}")
|
||
|
||
# 确保切换到扫码登录选项卡
|
||
qrcode_tab_selectors = [
|
||
'text="扫码登录"',
|
||
'div:has-text("扫码登录")',
|
||
'text="二维码登录"',
|
||
'div:has-text("二维码登录")',
|
||
'.qrcode-tab',
|
||
'[data-type="qrcode"]',
|
||
]
|
||
|
||
for selector in qrcode_tab_selectors:
|
||
try:
|
||
qrcode_tab = await self.page.query_selector(selector)
|
||
if qrcode_tab:
|
||
logger.info("[刷新二维码] 切换到扫码登录模式")
|
||
await qrcode_tab.click()
|
||
await asyncio.sleep(0.5)
|
||
break
|
||
except Exception:
|
||
continue
|
||
|
||
# 查找刷新按钮或刷新文本
|
||
refresh_selectors = [
|
||
'.status-desc.refresh',
|
||
'text="点击刷新"',
|
||
'.refresh',
|
||
'[class*="refresh"]',
|
||
]
|
||
|
||
refresh_clicked = False
|
||
for selector in refresh_selectors:
|
||
try:
|
||
refresh_el = await self.page.query_selector(selector)
|
||
if refresh_el:
|
||
logger.info(f"[刷新二维码] 找到刷新按钮: {selector}")
|
||
await refresh_el.click()
|
||
logger.success("[刷新二维码] 已点击刷新")
|
||
await asyncio.sleep(1)
|
||
refresh_clicked = True
|
||
break
|
||
except Exception:
|
||
continue
|
||
|
||
if not refresh_clicked:
|
||
return {
|
||
"success": False,
|
||
"error": "未找到刷新按钮"
|
||
}
|
||
|
||
# 等待二维码创建 API请求完成(最多等待 3 秒)
|
||
for i in range(30): # 30 * 0.1 = 3秒
|
||
if qrcode_create_data:
|
||
break
|
||
await asyncio.sleep(0.1)
|
||
|
||
if not qrcode_create_data:
|
||
logger.warning("[刷新二维码] 未捕获到二维码创建 API请求")
|
||
|
||
# 重新提取二维码
|
||
qrcode_result = await self.extract_qrcode_with_status(check_login_success=False)
|
||
|
||
# 如果获取到二维码创建信息，添加到结果中
|
||
if qrcode_create_data:
|
||
qrcode_result["qr_id"] = qrcode_create_data.get('qr_id')
|
||
qrcode_result["qr_code"] = qrcode_create_data.get('code')
|
||
qrcode_result["qr_url"] = qrcode_create_data.get('url')
|
||
qrcode_result["multi_flag"] = qrcode_create_data.get('multi_flag')
|
||
logger.success("[刷新二维码] 已将二维码创建信息添加到返回结果")
|
||
|
||
return qrcode_result
|
||
|
||
except Exception as e:
|
||
logger.error(f"[刷新二维码] 失败: {str(e)}")
|
||
return {
|
||
"success": False,
|
||
"error": str(e)
|
||
}
|
||
|