multi-platform-media-manage/server/python/platforms/xiaohongshu.py

# -*- coding: utf-8 -*-
"""
小红书视频发布器
参考: matrix/xhs_uploader/main.py
使用 xhs SDK API 方式发布，更稳定
"""

import asyncio
import os
import sys
import time
import concurrent.futures
from pathlib import Path
from typing import List
from .base import (
    BasePublisher,
    PublishParams,
    PublishResult,
    WorkItem,
    WorksResult,
    CommentItem,
    CommentsResult,
)
from playwright.async_api import async_playwright

stored_cookies = None

# 添加 matrix 项目路径，用于导入签名脚本
MATRIX_PATH = Path(__file__).parent.parent.parent.parent / "matrix"
sys.path.insert(0, str(MATRIX_PATH))

# 尝试导入 xhs SDK
try:
    from xhs import XhsClient

    XHS_SDK_AVAILABLE = True
except ImportError:
    print("[Warning] xhs 库未安装，请运行: pip install xhs")
    XhsClient = None
    XHS_SDK_AVAILABLE = False

# 签名脚本路径
STEALTH_JS_PATH = MATRIX_PATH / "xhs-api" / "js" / "stealth.min.js"

_xhs_sign_executor = concurrent.futures.ThreadPoolExecutor(max_workers=1)


class XiaohongshuPublisher(BasePublisher):
    """
    小红书视频发布器
    优先使用 xhs SDK API 方式发布
    """

    platform_name = "xiaohongshu"
    login_url = "https://creator.xiaohongshu.com/"
    publish_url = "https://creator.xiaohongshu.com/publish/publish"
    cookie_domain = ".xiaohongshu.com"

    async def get_sign(self, uri: str, data=None, a1: str = "", web_session: str = ""):
        """获取小红书 API 签名"""
        from playwright.async_api import async_playwright

        try:
            async with async_playwright() as playwright:
                browser = await playwright.chromium.launch(headless=True)
                browser_context = await browser.new_context()

                if STEALTH_JS_PATH.exists():
                    await browser_context.add_init_script(path=str(STEALTH_JS_PATH))

                page = await browser_context.new_page()
                await page.goto("https://www.xiaohongshu.com")
                await asyncio.sleep(1)
                await page.reload()
                await asyncio.sleep(1)

                if a1:
                    await browser_context.add_cookies(
                        [
                            {
                                "name": "a1",
                                "value": a1,
                                "domain": ".xiaohongshu.com",
                                "path": "/",
                            }
                        ]
                    )
                    await page.reload()
                    await asyncio.sleep(0.5)

                encrypt_params = await page.evaluate(
                    "([url, data]) => window._webmsxyw(url, data)", [uri, data]
                )

                await browser_context.close()
                await browser.close()

                return {"x-s": encrypt_params["X-s"], "x-t": str(encrypt_params["X-t"])}
        except Exception as e:
            import traceback

            traceback.print_exc()
            raise Exception(f"签名失败: {e}")

    def sign_sync(self, uri, data=None, a1="", web_session=""):
        """
        同步签名函数，供 XhsClient 使用。

        注意：发布流程运行在 asyncio 事件循环中（通过 asyncio.run 启动）。
        XhsClient 以同步方式调用 sign 回调，但我们需要使用 Playwright Async API 进行签名。
        因此当处于事件循环中时，将签名逻辑放到独立线程里执行 asyncio.run。
        """

        def run_async_sign():
            return asyncio.run(
                self.get_sign(uri, data=data, a1=a1, web_session=web_session)
            )

        try:
            asyncio.get_running_loop()
            future = _xhs_sign_executor.submit(run_async_sign)
            return future.result(timeout=120)
        except RuntimeError:
            return run_async_sign()

    async def publish_via_api(
        self, cookies: str, params: PublishParams
    ) -> PublishResult:
        """通过 API 发布视频"""
        if not XHS_SDK_AVAILABLE:
            raise Exception("xhs SDK 未安装，请运行: pip install xhs")

        self.report_progress(10, "正在通过 API 发布...")
        print(f"[{self.platform_name}] 使用 XHS SDK API 发布...")
        print(f"[{self.platform_name}] 视频路径: {params.video_path}")
        print(f"[{self.platform_name}] 标题: {params.title}")

        # 转换 cookie 格式
        cookie_list = self.parse_cookies(cookies)
        cookie_string = self.cookies_to_string(cookie_list) if cookie_list else cookies
        print(f"[{self.platform_name}] Cookie 长度: {len(cookie_string)}")

        self.report_progress(20, "正在上传视频...")

        async def ensure_valid_cookie_for_sdk() -> str | None:
            await self.init_browser()
            cookie_list_for_browser = self.parse_cookies(cookie_string)
            await self.set_cookies(cookie_list_for_browser)

            if not self.page or not self.context:
                return None

            await self.page.goto(
                "https://creator.xiaohongshu.com/new/home",
                wait_until="domcontentloaded",
                timeout=60000,
            )
            await asyncio.sleep(2)

            current_url = (self.page.url or "").lower()
            if "login" in current_url or "passport" in current_url:
                if self.headless:
                    return None

                waited = 0
                while waited < 180:
                    current_url = (self.page.url or "").lower()
                    if (
                        "login" not in current_url
                        and "passport" not in current_url
                        and "creator.xiaohongshu.com" in current_url
                    ):
                        break
                    await asyncio.sleep(2)
                    waited += 2

                current_url = (self.page.url or "").lower()
                if "login" in current_url or "passport" in current_url:
                    return None

            cookies_after = await self.context.cookies()
            try:
                await self.sync_cookies_to_node(cookies_after)
            except Exception:
                pass
            refreshed_cookie_str = self.cookies_to_string(cookies_after)
            return refreshed_cookie_str or None

        def call_create_video_note(sdk_cookie_str: str):
            xhs_client = XhsClient(sdk_cookie_str, sign=self.sign_sync)
            return xhs_client.create_video_note(
                title=params.title,
                desc=params.description or params.title,
                topics=params.tags or [],
                post_time=params.publish_date.strftime("%Y-%m-%d %H:%M:%S")
                if params.publish_date
                else None,
                video_path=params.video_path,
                cover_path=params.cover_path
                if params.cover_path and os.path.exists(params.cover_path)
                else None,
            )

        print(f"[{self.platform_name}] 开始调用 create_video_note...")

        try:
            result = call_create_video_note(cookie_string)
            print(f"[{self.platform_name}] SDK 返回结果: {result}")
        except Exception as e:
            err_text = str(e)
            if (
                "无登录信息" in err_text
                or '"code": -100' in err_text
                or "'code': -100" in err_text
            ):
                self.report_progress(15, "登录信息失效，尝试刷新登录信息...")
                refreshed = await ensure_valid_cookie_for_sdk()
                if not refreshed:
                    screenshot_base64 = await self.capture_screenshot()
                    page_url = (
                        await self.get_page_url()
                        if hasattr(self, "get_page_url")
                        else (self.page.url if self.page else "")
                    )
                    return PublishResult(
                        success=False,
                        platform=self.platform_name,
                        error="登录已过期，请使用有头浏览器重新登录",
                        screenshot_base64=screenshot_base64,
                        page_url=page_url,
                        status="need_captcha",
                        need_captcha=True,
                        captcha_type="login",
                    )
                try:
                    result = call_create_video_note(refreshed)
                    print(f"[{self.platform_name}] SDK 重试返回结果: {result}")
                except Exception as e2:
                    import traceback

                    traceback.print_exc()
                    raise Exception(f"XHS SDK 发布失败: {e2}")
            else:
                import traceback

                traceback.print_exc()
                print(f"[{self.platform_name}] SDK 调用失败: {e}")
                raise Exception(f"XHS SDK 发布失败: {e}")

        # 验证返回结果
        if not result:
            raise Exception("XHS SDK 返回空结果")

        # 检查是否有错误
        if isinstance(result, dict):
            if result.get("code") and result.get("code") != 0:
                raise Exception(f"发布失败: {result.get('msg', '未知错误')}")
            if result.get("success") == False:
                raise Exception(
                    f"发布失败: {result.get('msg', result.get('error', '未知错误'))}"
                )

        note_id = result.get("note_id", "") if isinstance(result, dict) else ""
        video_url = result.get("url", "") if isinstance(result, dict) else ""

        if not note_id:
            print(f"[{self.platform_name}] 警告: 未获取到 note_id，返回结果: {result}")

        self.report_progress(100, "发布成功")
        print(f"[{self.platform_name}] 发布成功! note_id={note_id}, url={video_url}")

        return PublishResult(
            success=True,
            platform=self.platform_name,
            video_id=note_id,
            video_url=video_url,
            message="发布成功",
        )

    async def publish(self, cookies: str, params: PublishParams) -> PublishResult:
        """发布视频到小红书 - 参考 matrix/xhs_uploader/main.py"""
        print(f"\n{'=' * 60}")
        print(f"[{self.platform_name}] 开始发布视频")
        print(f"[{self.platform_name}] 视频路径: {params.video_path}")
        print(f"[{self.platform_name}] 标题: {params.title}")
        print(f"[{self.platform_name}] Headless: {self.headless}")
        print(f"[{self.platform_name}] XHS SDK 可用: {XHS_SDK_AVAILABLE}")
        print(f"{'=' * 60}")

        # 检查视频文件
        if not os.path.exists(params.video_path):
            raise Exception(f"视频文件不存在: {params.video_path}")

        print(
            f"[{self.platform_name}] 视频文件存在，大小: {os.path.getsize(params.video_path)} bytes"
        )

        self.report_progress(5, "正在准备发布...")

        if isinstance(
            getattr(self, "proxy_config", None), dict
        ) and self.proxy_config.get("server"):
            print(
                f"[{self.platform_name}] 检测到代理配置，跳过 SDK 方式，使用 Playwright 走代理发布",
                flush=True,
            )
            return await self.publish_via_playwright(cookies, params)

        # 参考 matrix: 优先使用 XHS SDK API 方式发布（更稳定）
        if XHS_SDK_AVAILABLE:
            try:
                print(f"[{self.platform_name}] 尝试使用 XHS SDK API 发布...")
                result = await self.publish_via_api(cookies, params)
                print(f"[{self.platform_name}] API 发布完成: success={result.success}")

                # 如果 API 返回成功，直接返回
                if result.success:
                    return result

                # 如果 API 返回失败但有具体错误，也返回
                if result.error and "请刷新" not in result.error:
                    return result

                # 其他情况尝试 Playwright 方式
                print(f"[{self.platform_name}] API 方式未成功，尝试 Playwright...")
            except Exception as e:
                err_text = str(e)
                if "登录已过期" in err_text or "无登录信息" in err_text:
                    print(
                        f"[{self.platform_name}] API 登录失效，切换到 Playwright 方式...",
                        flush=True,
                    )
                else:
                    import traceback

                    traceback.print_exc()
                    print(f"[{self.platform_name}] API 发布失败: {e}")
                print(f"[{self.platform_name}] 尝试使用 Playwright 方式...")

        # 使用 Playwright 方式发布
        print(f"[{self.platform_name}] 使用 Playwright 方式发布...")
        return await self.publish_via_playwright(cookies, params)

    async def publish_via_playwright(
        self, cookies: str, params: PublishParams
    ) -> PublishResult:
        """通过 Playwright 发布视频"""
        self.report_progress(10, "正在初始化浏览器...")
        print(f"[{self.platform_name}] Playwright 方式开始...")

        await self.init_browser()

        cookie_list = self.parse_cookies(cookies)
        print(f"[{self.platform_name}] 设置 {len(cookie_list)} 个 cookies")
        await self.set_cookies(cookie_list)

        if not self.page:
            raise Exception("Page not initialized")

        self.report_progress(15, "正在打开发布页面...")

        # 直接访问视频发布页面
        publish_url = "https://creator.xiaohongshu.com/publish/publish?source=official"
        print(f"[{self.platform_name}] 打开页面: {publish_url}")
        await self.page.goto(publish_url)
        await asyncio.sleep(3)

        current_url = self.page.url
        print(f"[{self.platform_name}] 当前 URL: {current_url}")

        async def wait_for_manual_login(timeout_seconds: int = 300) -> bool:
            if not self.page:
                return False
            self.report_progress(12, "检测到需要登录，请在浏览器窗口完成登录...")
            try:
                await self.page.bring_to_front()
            except:
                pass
            waited = 0
            while waited < timeout_seconds:
                try:
                    url = self.page.url
                    if (
                        "login" not in url
                        and "passport" not in url
                        and "creator.xiaohongshu.com" in url
                    ):
                        return True
                    await asyncio.sleep(2)
                    waited += 2
                except:
                    await asyncio.sleep(2)
                    waited += 2
            return False

        async def wait_for_manual_captcha(timeout_seconds: int = 180) -> bool:
            waited = 0
            while waited < timeout_seconds:
                try:
                    ai_captcha = await self.ai_check_captcha()
                    if not ai_captcha.get("has_captcha"):
                        return True
                except:
                    pass
                await asyncio.sleep(3)
                waited += 3
            return False

        # 检查登录状态
        if "login" in current_url or "passport" in current_url:
            if not self.headless:
                logged_in = await wait_for_manual_login()
                if logged_in:
                    try:
                        if self.context:
                            cookies_after = await self.context.cookies()
                            await self.sync_cookies_to_node(cookies_after)
                    except:
                        pass
                    await self.page.goto(publish_url)
                    await asyncio.sleep(3)
                    current_url = self.page.url
                else:
                    screenshot_base64 = await self.capture_screenshot()
                    return PublishResult(
                        success=False,
                        platform=self.platform_name,
                        error="需要登录：请在浏览器窗口完成登录后重试",
                        screenshot_base64=screenshot_base64,
                        page_url=current_url,
                        status="need_captcha",
                        need_captcha=True,
                        captcha_type="login",
                    )
            else:
                screenshot_base64 = await self.capture_screenshot()
                return PublishResult(
                    success=False,
                    platform=self.platform_name,
                    error="登录已过期，请重新登录",
                    screenshot_base64=screenshot_base64,
                    page_url=current_url,
                    status="need_captcha",
                    need_captcha=True,
                    captcha_type="login",
                )

        # 使用 AI 检查验证码
        ai_captcha = await self.ai_check_captcha()
        if ai_captcha["has_captcha"]:
            print(
                f"[{self.platform_name}] AI检测到验证码: {ai_captcha['captcha_type']}",
                flush=True,
            )
            if not self.headless:
                solved = await wait_for_manual_captcha()
                if solved:
                    try:
                        if self.context:
                            cookies_after = await self.context.cookies()
                            await self.sync_cookies_to_node(cookies_after)
                    except:
                        pass
                else:
                    screenshot_base64 = await self.capture_screenshot()
                    return PublishResult(
                        success=False,
                        platform=self.platform_name,
                        error=f"需要验证码：请在浏览器窗口完成验证后重试",
                        screenshot_base64=screenshot_base64,
                        page_url=current_url,
                        status="need_captcha",
                        need_captcha=True,
                        captcha_type=ai_captcha["captcha_type"],
                    )
            else:
                screenshot_base64 = await self.capture_screenshot()
                return PublishResult(
                    success=False,
                    platform=self.platform_name,
                    error=f"检测到{ai_captcha['captcha_type']}验证码，需要使用有头浏览器完成验证",
                    screenshot_base64=screenshot_base64,
                    page_url=current_url,
                    status="need_captcha",
                    need_captcha=True,
                    captcha_type=ai_captcha["captcha_type"],
                )

        self.report_progress(20, "正在上传视频...")

        # 等待页面加载
        await asyncio.sleep(2)

        # 上传视频
        upload_triggered = False

        # 方法1: 直接设置隐藏的 file input
        print(f"[{self.platform_name}] 尝试方法1: 设置 file input")
        file_inputs = self.page.locator('input[type="file"]')
        input_count = await file_inputs.count()
        print(f"[{self.platform_name}] 找到 {input_count} 个 file input")

        if input_count > 0:
            # 找到接受视频的 input
            for i in range(input_count):
                input_el = file_inputs.nth(i)
                accept = await input_el.get_attribute("accept") or ""
                print(f"[{self.platform_name}] Input {i} accept: {accept}")
                if "video" in accept or "*" in accept or not accept:
                    await input_el.set_input_files(params.video_path)
                    upload_triggered = True
                    print(f"[{self.platform_name}] 视频文件已设置到 input {i}")
                    break

        # 方法2: 点击上传区域触发文件选择器
        if not upload_triggered:
            print(f"[{self.platform_name}] 尝试方法2: 点击上传区域")
            try:
                upload_area = self.page.locator(
                    '[class*="upload-wrapper"], [class*="upload-area"], .upload-input'
                ).first
                if await upload_area.count() > 0:
                    async with self.page.expect_file_chooser(timeout=5000) as fc_info:
                        await upload_area.click()
                    file_chooser = await fc_info.value
                    await file_chooser.set_files(params.video_path)
                    upload_triggered = True
                    print(f"[{self.platform_name}] 通过点击上传区域上传成功")
            except Exception as e:
                print(f"[{self.platform_name}] 方法2失败: {e}")

        if not upload_triggered:
            screenshot_base64 = await self.capture_screenshot()
            page_url = await self.get_page_url()
            return PublishResult(
                success=False,
                platform=self.platform_name,
                error="无法上传视频文件",
                screenshot_base64=screenshot_base64,
                page_url=page_url,
                status="need_action",
            )

        self.report_progress(40, "等待视频上传完成...")
        print(f"[{self.platform_name}] 等待视频上传和处理...")

        # 等待上传完成（检测页面变化）
        upload_complete = False
        for i in range(60):  # 最多等待3分钟
            await asyncio.sleep(3)

            # 检查是否有标题输入框（上传完成后出现）
            title_input_count = await self.page.locator(
                'input[placeholder*="标题"], input[placeholder*="填写标题"]'
            ).count()
            # 或者检查编辑器区域
            editor_count = await self.page.locator(
                '[class*="ql-editor"], [contenteditable="true"]'
            ).count()
            # 检查发布按钮是否可见
            publish_btn_count = await self.page.locator(
                '.publishBtn, button:has-text("发布")'
            ).count()

            print(
                f"[{self.platform_name}] 检测 {i + 1}: 标题框={title_input_count}, 编辑器={editor_count}, 发布按钮={publish_btn_count}"
            )

            if title_input_count > 0 or (editor_count > 0 and publish_btn_count > 0):
                upload_complete = True
                print(f"[{self.platform_name}] 视频上传完成!")
                break

        if not upload_complete:
            screenshot_base64 = await self.capture_screenshot()
            page_url = await self.get_page_url()
            return PublishResult(
                success=False,
                platform=self.platform_name,
                error="视频上传超时",
                screenshot_base64=screenshot_base64,
                page_url=page_url,
                status="need_action",
            )

        await asyncio.sleep(2)

        self.report_progress(60, "正在填写笔记信息...")
        print(f"[{self.platform_name}] 填写标题: {params.title[:20]}")

        # 填写标题
        title_filled = False
        title_selectors = [
            'input[placeholder*="标题"]',
            'input[placeholder*="填写标题"]',
            '[class*="title"] input',
            ".c-input_inner",
        ]
        for selector in title_selectors:
            title_input = self.page.locator(selector).first
            if await title_input.count() > 0:
                await title_input.click()
                await title_input.fill("")  # 先清空
                await title_input.fill(params.title[:20])
                title_filled = True
                print(f"[{self.platform_name}] 标题已填写，使用选择器: {selector}")
                break

        if not title_filled:
            print(f"[{self.platform_name}] 警告: 未找到标题输入框")

        # 填写描述和标签
        if params.description or params.tags:
            desc_filled = False
            desc_selectors = [
                '[class*="ql-editor"]',
                '[class*="content-input"] [contenteditable="true"]',
                '[class*="editor"] [contenteditable="true"]',
                ".ql-editor",
            ]
            for selector in desc_selectors:
                desc_input = self.page.locator(selector).first
                if await desc_input.count() > 0:
                    await desc_input.click()
                    await asyncio.sleep(0.5)

                    if params.description:
                        await self.page.keyboard.type(params.description, delay=20)
                        print(f"[{self.platform_name}] 描述已填写")

                    if params.tags:
                        # 添加标签
                        await self.page.keyboard.press("Enter")
                        for tag in params.tags[:5]:  # 最多5个标签
                            await self.page.keyboard.type(f"#{tag}", delay=20)
                            await asyncio.sleep(0.3)
                            await self.page.keyboard.press("Space")
                        print(f"[{self.platform_name}] 标签已填写: {params.tags[:5]}")

                    desc_filled = True
                    break

            if not desc_filled:
                print(f"[{self.platform_name}] 警告: 未找到描述输入框")

        await asyncio.sleep(2)
        self.report_progress(80, "正在发布...")

        await asyncio.sleep(2)

        # 滚动到页面底部确保发布按钮可见
        await self.page.evaluate("window.scrollTo(0, document.body.scrollHeight)")
        await asyncio.sleep(1)

        print(f"[{self.platform_name}] 查找发布按钮...")

        # 点击发布
        publish_selectors = [
            "button.publishBtn",
            ".publishBtn",
            "button.d-button.red",
            'button:has-text("发布"):not(:has-text("定时发布"))',
            '[class*="publish"][class*="btn"]',
        ]

        publish_clicked = False
        for selector in publish_selectors:
            try:
                btn = self.page.locator(selector).first
                if await btn.count() > 0:
                    is_visible = await btn.is_visible()
                    is_enabled = await btn.is_enabled()
                    print(
                        f"[{self.platform_name}] 按钮 {selector}: visible={is_visible}, enabled={is_enabled}"
                    )

                    if is_visible and is_enabled:
                        box = await btn.bounding_box()
                        if box:
                            print(
                                f"[{self.platform_name}] 点击发布按钮: {selector}, 位置: ({box['x']}, {box['y']})"
                            )
                            # 使用真实鼠标点击
                            await self.page.mouse.click(
                                box["x"] + box["width"] / 2,
                                box["y"] + box["height"] / 2,
                            )
                            publish_clicked = True
                            break
            except Exception as e:
                print(f"[{self.platform_name}] 选择器 {selector} 错误: {e}")

        if not publish_clicked:
            try:
                suggest = await self.ai_suggest_playwright_selector(
                    "点击小红书发布按钮"
                )
                if suggest.get("has_selector") and suggest.get("selector"):
                    sel = suggest.get("selector")
                    btn = self.page.locator(sel).first
                    if (
                        await btn.count() > 0
                        and await btn.is_visible()
                        and await btn.is_enabled()
                    ):
                        try:
                            await btn.click()
                        except:
                            box = await btn.bounding_box()
                            if box:
                                await self.page.mouse.click(
                                    box["x"] + box["width"] / 2,
                                    box["y"] + box["height"] / 2,
                                )
                        publish_clicked = True
            except Exception as e:
                print(f"[{self.platform_name}] AI 点击发布按钮失败: {e}", flush=True)

        if not publish_clicked:
            # 保存截图用于调试
            screenshot_dir = os.path.join(
                os.path.dirname(os.path.dirname(os.path.abspath(__file__))),
                "screenshots",
            )
            os.makedirs(screenshot_dir, exist_ok=True)
            screenshot_path = os.path.join(
                screenshot_dir, f"debug_publish_failed_{self.platform_name}.png"
            )
            await self.page.screenshot(path=screenshot_path, full_page=True)
            print(
                f"[{self.platform_name}] 未找到发布按钮，截图保存到: {screenshot_path}"
            )

            # 打印页面 HTML 结构用于调试
            buttons = await self.page.query_selector_all("button")
            print(f"[{self.platform_name}] 页面上共有 {len(buttons)} 个按钮")
            for i, btn in enumerate(buttons[:10]):
                text = await btn.text_content() or ""
                cls = await btn.get_attribute("class") or ""
                print(f"  按钮 {i}: text='{text.strip()[:30]}', class='{cls[:50]}'")

            raise Exception("未找到发布按钮")

        print(f"[{self.platform_name}] 已点击发布按钮，等待发布完成...")
        self.report_progress(90, "等待发布结果...")

        # 等待发布完成（检测 URL 变化或成功提示）
        publish_success = False
        refresh_retry = 0
        for i in range(20):  # 最多等待 20 秒
            await asyncio.sleep(1)

            current_url = self.page.url

            # 检查是否跳转到发布成功页面或内容管理页面
            if (
                "published=true" in current_url
                or "success" in current_url
                or "content" in current_url
            ):
                publish_success = True
                print(f"[{self.platform_name}] 发布成功! 跳转到: {current_url}")
                break

            # 检查是否有成功提示
            try:
                success_msg = await self.page.locator(
                    '[class*="success"], .toast-success, [class*="Toast"]'
                ).first.is_visible()
                if success_msg:
                    publish_success = True
                    print(f"[{self.platform_name}] 检测到成功提示!")
                    break
            except:
                pass

            # 检查是否有错误提示
            try:
                error_elements = self.page.locator(
                    '[class*="error"], .toast-error, [class*="fail"]'
                )
                if await error_elements.count() > 0:
                    first_error = error_elements.first
                    if await first_error.is_visible():
                        error_text = (await first_error.text_content()) or ""
                        error_text = error_text.strip()
                        if error_text:
                            if "请刷新" in error_text and refresh_retry < 3:
                                refresh_retry += 1
                                print(
                                    f"[{self.platform_name}] 检测到临时错误: {error_text}，尝试刷新并重试发布（{refresh_retry}/3）",
                                    flush=True,
                                )
                                try:
                                    await self.page.reload(
                                        wait_until="domcontentloaded"
                                    )
                                except Exception:
                                    pass
                                await asyncio.sleep(2)
                                await self.page.evaluate(
                                    "window.scrollTo(0, document.body.scrollHeight)"
                                )
                                await asyncio.sleep(1)
                                republish_clicked = False
                                for selector in publish_selectors:
                                    try:
                                        btn = self.page.locator(selector).first
                                        if (
                                            await btn.count() > 0
                                            and await btn.is_visible()
                                            and await btn.is_enabled()
                                        ):
                                            try:
                                                await btn.click()
                                            except:
                                                box = await btn.bounding_box()
                                                if box:
                                                    await self.page.mouse.click(
                                                        box["x"] + box["width"] / 2,
                                                        box["y"] + box["height"] / 2,
                                                    )
                                            republish_clicked = True
                                            break
                                    except:
                                        continue
                                continue
                            screenshot_base64 = await self.capture_screenshot()
                            page_url = await self.get_page_url()
                            return PublishResult(
                                success=False,
                                platform=self.platform_name,
                                error=f"发布失败: {error_text}",
                                screenshot_base64=screenshot_base64,
                                page_url=page_url,
                                status="failed",
                            )
            except Exception as e:
                if "发布失败" in str(e):
                    raise

        # 如果没有明确的成功标志，返回截图供 AI 分析
        if not publish_success:
            final_url = self.page.url
            print(f"[{self.platform_name}] 发布结果不确定，当前 URL: {final_url}")
            screenshot_base64 = await self.capture_screenshot()
            print(f"[{self.platform_name}] 已获取截图供 AI 分析")

            # 如果 URL 还是发布页面，可能需要继续操作
            if "publish/publish" in final_url:
                return PublishResult(
                    success=False,
                    platform=self.platform_name,
                    error="发布结果待确认，请查看截图",
                    screenshot_base64=screenshot_base64,
                    page_url=final_url,
                    status="need_action",
                )

        self.report_progress(100, "发布完成")
        print(f"[{self.platform_name}] Playwright 方式发布完成!")
        screenshot_base64 = await self.capture_screenshot()
        page_url = await self.get_page_url()

        return PublishResult(
            success=True,
            platform=self.platform_name,
            message="发布完成",
            screenshot_base64=screenshot_base64,
            page_url=page_url,
            status="success",
        )

    async def get_account_info(self, cookies: str) -> dict:
        """获取账号信息"""
        print(f"\n{'=' * 60}")
        print(f"[{self.platform_name}] 获取账号信息")
        print(f"{'=' * 60}")

        captured_info = {}

        try:
            await self.init_browser()
            cookie_list = self.parse_cookies(cookies)
            await self.set_cookies(cookie_list)

            if not self.page:
                raise Exception("Page not initialized")

            # 监听个人信息 API
            async def handle_response(response):
                nonlocal captured_info
                if "api/galaxy/creator/home/personal_info" in response.url:
                    try:
                        json_data = await response.json()
                        print(f"[{self.platform_name}] 捕获个人信息 API", flush=True)
                        if json_data.get("success") or json_data.get("code") == 0:
                            data = json_data.get("data", {})
                            captured_info = {
                                "account_id": f"xhs_{data.get('red_num', '')}",
                                "account_name": data.get("name", ""),
                                "avatar_url": data.get("avatar", ""),
                                "fans_count": data.get("fans_count", 0),
                                "works_count": 0,  # 暂时无法直接获取准确的作品数，需要从作品列表获取
                            }
                    except Exception as e:
                        print(
                            f"[{self.platform_name}] 解析个人信息失败: {e}", flush=True
                        )

            self.page.on("response", handle_response)

            # 访问首页
            print(f"[{self.platform_name}] 访问创作者首页...", flush=True)
            await self.page.goto(
                "https://creator.xiaohongshu.com/new/home",
                wait_until="domcontentloaded",
            )

            # 等待 API 响应
            for _ in range(10):
                if captured_info:
                    break
                await asyncio.sleep(1)

            if not captured_info:
                print(
                    f"[{self.platform_name}] 未捕获到个人信息，尝试刷新...", flush=True
                )
                await self.page.reload()
                for _ in range(10):
                    if captured_info:
                        break
                    await asyncio.sleep(1)

            if not captured_info:
                raise Exception("无法获取账号信息")

            # 尝试获取作品数（从首页或其他地方）
            # 或者简单地返回已获取的信息，作品数由 get_works 更新

            return {"success": True, **captured_info}

        except Exception as e:
            import traceback

            traceback.print_exc()
            return {"success": False, "error": str(e)}
        finally:
            await self.close_browser()

    async def get_works(
        self, cookies: str, page: int = 0, page_size: int = 20
    ) -> WorksResult:
        """获取小红书作品列表 - 通过直接调用创作者笔记列表 API 获取"""
        print(f"\n{'=' * 60}", flush=True)
        print(f"[{self.platform_name}] 获取作品列表", flush=True)
        print(f"[{self.platform_name}] page={page}, page_size={page_size}", flush=True)
        print(f"{'=' * 60}", flush=True)

        works: List[WorkItem] = []
        total = 0
        has_more = False
        next_page = ""
        api_page_size = 20

        try:
            await self.init_browser()
            cookie_list = self.parse_cookies(cookies)

            # 打印 cookies 信息用于调试
            print(
                f"[{self.platform_name}] 解析到 {len(cookie_list)} 个 cookies",
                flush=True,
            )

            await self.set_cookies(cookie_list)

            if not self.page:
                raise Exception("Page not initialized")

            # 访问笔记管理页面 - 页面会自动发起 API 请求
            print(f"[{self.platform_name}] 访问笔记管理页面...", flush=True)

            try:
                await self.page.goto(
                    "https://creator.xiaohongshu.com/new/note-manager",
                    wait_until="domcontentloaded",
                    timeout=30000,
                )
            except Exception as nav_error:
                print(
                    f"[{self.platform_name}] 导航超时，但继续尝试: {nav_error}",
                    flush=True,
                )

            # 检查登录状态
            current_url = self.page.url
            print(f"[{self.platform_name}] 当前页面: {current_url}", flush=True)
            if "login" in current_url:
                raise Exception("Cookie 已过期，请重新登录")

            # 等待页面完全加载，确保签名函数可用
            print(
                f"[{self.platform_name}] 等待页面完全加载和签名函数初始化...",
                flush=True,
            )
            await asyncio.sleep(3)

            # 检查签名函数是否可用
            sign_check_attempts = 0
            max_sign_check_attempts = 10
            while sign_check_attempts < max_sign_check_attempts:
                sign_available = await self.page.evaluate("""() => {
                    return typeof window !== 'undefined' && typeof window._webmsxyw === 'function';
                }""")
                if sign_available:
                    print(
                        f"[{self.platform_name}] ✓ 签名函数 _webmsxyw 已可用",
                        flush=True,
                    )
                    break
                sign_check_attempts += 1
                print(
                    f"[{self.platform_name}] ⏳ 等待签名函数... ({sign_check_attempts}/{max_sign_check_attempts})",
                    flush=True,
                )
                await asyncio.sleep(1)

            if sign_check_attempts >= max_sign_check_attempts:
                print(
                    f"[{self.platform_name}] ⚠️ 警告: 签名函数 _webmsxyw 在 {max_sign_check_attempts} 次检查后仍不可用",
                    flush=True,
                )
                print(
                    f"[{self.platform_name}] 继续尝试，但 API 调用可能会失败",
                    flush=True,
                )

            async def fetch_notes_page(p):
                # 再次检查签名函数（每次调用前都检查）
                sign_available = await self.page.evaluate("""() => {
                    return typeof window !== 'undefined' && typeof window._webmsxyw === 'function';
                }""")

                if not sign_available:
                    print(
                        f"[{self.platform_name}] ⚠️ 签名函数 _webmsxyw 不可用，等待...",
                        flush=True,
                    )
                    await asyncio.sleep(2)

                return await self.page.evaluate(
                    """async (pageNum) => {
                        try {
                            // 使用正确的 API 端点：/api/galaxy/v2/creator/note/user/posted
                            const url = `/api/galaxy/v2/creator/note/user/posted?tab=0&page=${pageNum}`;
                            const headers = {
                                'Accept': 'application/json, text/plain, */*',
                                'Accept-Language': 'zh-CN,zh;q=0.9,en;q=0.8,en-GB;q=0.7,en-US;q=0.6',
                                'Referer': 'https://creator.xiaohongshu.com/new/note-manager',
                                'Sec-Fetch-Dest': 'empty',
                                'Sec-Fetch-Mode': 'cors',
                                'Sec-Fetch-Site': 'same-origin'
                            };
                            
                            // 尝试获取签名
                            let signResult = { hasSign: false, x_s: '', x_t: '', x_s_common: '', error: '' };
                            if (typeof window !== 'undefined' && typeof window._webmsxyw === 'function') {
                                try {
                                    const sign = window._webmsxyw(url, '');
                                    headers['x-s'] = sign['X-s'];
                                    headers['x-t'] = String(sign['X-t']);
                                    // 检查是否有 x-s-common
                                    if (sign['X-s-common']) {
                                        headers['x-s-common'] = sign['X-s-common'];
                                    }
                                    signResult = {
                                        hasSign: true,
                                        x_s: sign['X-s'] ? sign['X-s'].substring(0, 50) + '...' : '',
                                        x_t: String(sign['X-t']),
                                        x_s_common: sign['X-s-common'] ? sign['X-s-common'].substring(0, 50) + '...' : '',
                                        error: ''
                                    };
                                    console.log('签名生成成功:', signResult);
                                } catch (e) {
                                    signResult.error = e.toString();
                                    console.error('签名生成失败:', e);
                                }
                            } else {
                                signResult.error = '_webmsxyw function not found';
                                console.error('签名函数不存在');
                            }
                            
                            const res = await fetch(url, {
                                method: 'GET',
                                credentials: 'include',
                                headers
                            });
                            
                            const responseData = await res.json();
                            return {
                                ...responseData,
                                _debug: {
                                    signResult: signResult,
                                    status: res.status,
                                    statusText: res.statusText
                                }
                            };
                        } catch (e) {
                            return { success: false, error: e.toString() };
                        }
                    }""",
                    p,
                )

            def parse_notes(notes_list):
                parsed = []
                for note in notes_list:
                    note_id = note.get("id", "")
                    if not note_id:
                        continue

                    cover_url = ""
                    images_list = note.get("images_list", [])
                    if images_list:
                        cover_url = images_list[0].get("url", "")
                        if cover_url.startswith("http://"):
                            cover_url = cover_url.replace("http://", "https://")

                    duration = note.get("video_info", {}).get("duration", 0)

                    status = "published"
                    tab_status = note.get("tab_status", 1)
                    if tab_status == 0:
                        status = "draft"
                    elif tab_status == 2:
                        status = "reviewing"
                    elif tab_status == 3:
                        status = "rejected"

                    video_url = (
                        f"https://www.xiaohongshu.com/explore/{note_id}"
                        if note_id
                        else ""
                    )
                    parsed.append(
                        WorkItem(
                            work_id=note_id,
                            title=note.get("display_title", "") or "无标题",
                            cover_url=cover_url,
                            video_url=video_url,
                            duration=duration,
                            status=status,
                            publish_time=note.get("time", ""),
                            play_count=note.get("view_count", 0),
                            like_count=note.get("likes", 0),
                            comment_count=note.get("comments_count", 0),
                            share_count=note.get("shared_count", 0),
                            collect_count=note.get("collected_count", 0),
                        )
                    )
                return parsed

            resp = None
            for attempt in range(1, 4):
                resp = await fetch_notes_page(page)

                # 打印调试信息
                if resp and isinstance(resp, dict) and resp.get("_debug"):
                    debug_info = resp.get("_debug", {})
                    sign_result = debug_info.get("signResult", {})
                    print(
                        f"[{self.platform_name}] 🔍 调试信息: 签名可用: {sign_result.get('hasSign', False)}, X-S: {sign_result.get('x_s', '')}, X-T: {sign_result.get('x_t', '')}, X-S-Common: {sign_result.get('x_s_common', '')}, 签名错误: {sign_result.get('error', '')}, HTTP 状态: {debug_info.get('status', 'N/A')}",
                        flush=True,
                    )
                    resp.pop("_debug", None)

                if (
                    resp
                    and (resp.get("success") or resp.get("code") == 0)
                    and resp.get("data")
                ):
                    break
                print(
                    f"[{self.platform_name}] 拉取作品列表失败，重试 {attempt}/3: {str(resp)[:200]}",
                    flush=True,
                )
                await asyncio.sleep(1.2 * attempt)

            if (
                not resp
                or not (resp.get("success") or resp.get("code") == 0)
                or not resp.get("data")
            ):
                error_msg = resp.get("msg") if isinstance(resp, dict) else str(resp)
                # 打印详细的错误信息
                if isinstance(resp, dict):
                    if resp.get("msg"):
                        print(
                            f"[{self.platform_name}] 错误消息: {resp.get('msg')}",
                            flush=True,
                        )
                    if resp.get("message"):
                        print(
                            f"[{self.platform_name}] 错误消息: {resp.get('message')}",
                            flush=True,
                        )
                    if resp.get("error"):
                        print(
                            f"[{self.platform_name}] 错误: {resp.get('error')}",
                            flush=True,
                        )
                raise Exception(f"无法获取作品列表数据: {error_msg}")

            data = resp.get("data", {}) or {}
            notes = data.get("notes", []) or []
            print(
                f"[{self.platform_name}] 第 {page} 页 notes 数量: {len(notes)}",
                flush=True,
            )

            tags = data.get("tags", []) or []
            if tags:
                preferred = 0
                for tag in tags:
                    if tag.get("id") == "special.note_time_desc":
                        preferred = (
                            tag.get("notes_count", 0)
                            or tag.get("notesCount", 0)
                            or tag.get("count", 0)
                            or 0
                        )
                        break
                if preferred:
                    total = preferred
                else:
                    total = max(
                        [
                            int(
                                t.get("notes_count", 0)
                                or t.get("notesCount", 0)
                                or t.get("count", 0)
                                or 0
                            )
                            for t in tags
                        ]
                        + [0]
                    )
            if not total:
                total = int(
                    data.get("total", 0)
                    or data.get("total_count", 0)
                    or data.get("totalCount", 0)
                    or 0
                )
                if not total and isinstance(data.get("page", {}), dict):
                    total = int(
                        data.get("page", {}).get("total", 0)
                        or data.get("page", {}).get("totalCount", 0)
                        or 0
                    )

            next_page = data.get("page", "")
            if next_page == page:
                next_page = page + 1

            works.extend(parse_notes(notes))

            if total:
                has_more = (page * api_page_size + len(notes)) < total
                if has_more and (
                    next_page == -1
                    or str(next_page) == "-1"
                    or next_page == ""
                    or next_page is None
                ):
                    next_page = page + 1
            else:
                if len(notes) == 0:
                    has_more = False
                else:
                    next_resp = await fetch_notes_page(page + 1)
                    next_data = (
                        (next_resp or {}).get("data", {})
                        if isinstance(next_resp, dict)
                        else {}
                    )
                    next_notes = next_data.get("notes", []) or []
                    has_more = len(next_notes) > 0
                    next_page = next_data.get("page", next_page)

        except Exception as e:
            import traceback

            print(f"[{self.platform_name}] 发生异常: {e}", flush=True)
            traceback.print_exc()
            return WorksResult(success=False, platform=self.platform_name, error=str(e))
        finally:
            # 确保关闭浏览器
            await self.close_browser()

        return WorksResult(
            success=True,
            platform=self.platform_name,
            works=works,
            total=total or (page * api_page_size + len(works)),
            has_more=has_more,
            next_page=next_page,
        )

    async def get_all_works(self, cookies: str) -> WorksResult:
        """获取小红书全部作品（单次请求内自动翻页抓全量，避免 Node 侧分页不一致）"""
        print(f"\n{'=' * 60}", flush=True)
        print(f"[{self.platform_name}] 获取全部作品（auto paging）", flush=True)
        print(f"{'=' * 60}", flush=True)

        works: List[WorkItem] = []
        total = 0
        seen_ids = set()
        cursor: object = 0
        max_iters = 800
        api_page_size = 20

        try:
            await self.init_browser()
            cookie_list = self.parse_cookies(cookies)
            print(
                f"[{self.platform_name}] 解析到 {len(cookie_list)} 个 cookies",
                flush=True,
            )
            await self.set_cookies(cookie_list)
            if not self.page:
                raise Exception("Page not initialized")

            print(f"[{self.platform_name}] 访问笔记管理页面...", flush=True)
            try:
                await self.page.goto(
                    "https://creator.xiaohongshu.com/new/note-manager",
                    wait_until="domcontentloaded",
                    timeout=60000,
                )
                print(f"[{self.platform_name}] 页面加载成功", flush=True)
            except Exception as nav_error:
                print(
                    f"[{self.platform_name}] 导航超时，但继续尝试: {nav_error}",
                    flush=True,
                )
                # 即使超时也检查当前页面状态
                try:
                    await asyncio.sleep(2)
                    current_url = self.page.url
                    print(
                        f"[{self.platform_name}] 超时后当前页面: {current_url}",
                        flush=True,
                    )
                except Exception as e:
                    print(f"[{self.platform_name}] 检查页面状态时出错: {e}", flush=True)

            current_url = self.page.url
            print(f"[{self.platform_name}] 当前页面: {current_url}", flush=True)
            if "login" in current_url:
                raise Exception("Cookie 已过期，请重新登录")

            # 等待页面完全加载，确保签名函数可用
            print(
                f"[{self.platform_name}] 等待页面完全加载和签名函数初始化...",
                flush=True,
            )
            await asyncio.sleep(3)

            # 检查签名函数是否可用
            sign_check_attempts = 0
            max_sign_check_attempts = 10
            while sign_check_attempts < max_sign_check_attempts:
                sign_available = await self.page.evaluate("""() => {
                    return typeof window !== 'undefined' && typeof window._webmsxyw === 'function';
                }""")
                if sign_available:
                    print(
                        f"[{self.platform_name}] ✓ 签名函数 _webmsxyw 已可用",
                        flush=True,
                    )
                    break
                sign_check_attempts += 1
                print(
                    f"[{self.platform_name}] ⏳ 等待签名函数... ({sign_check_attempts}/{max_sign_check_attempts})",
                    flush=True,
                )
                await asyncio.sleep(1)

            if sign_check_attempts >= max_sign_check_attempts:
                print(
                    f"[{self.platform_name}] ⚠️ 警告: 签名函数 _webmsxyw 在 {max_sign_check_attempts} 次检查后仍不可用",
                    flush=True,
                )
                print(
                    f"[{self.platform_name}] 继续尝试，但 API 调用可能会失败",
                    flush=True,
                )

            async def fetch_notes_page(p):
                # 再次检查签名函数（每次调用前都检查）
                sign_available = await self.page.evaluate("""() => {
                    return typeof window !== 'undefined' && typeof window._webmsxyw === 'function';
                }""")

                if not sign_available:
                    print(
                        f"[{self.platform_name}] ⚠️ 签名函数 _webmsxyw 不可用，等待...",
                        flush=True,
                    )
                    await asyncio.sleep(2)

                return await self.page.evaluate(
                    """async (pageNum) => {
                        try {
                            // 使用正确的 API 端点：/api/galaxy/v2/creator/note/user/posted
                            const url = `/api/galaxy/v2/creator/note/user/posted?tab=0&page=${pageNum}`;
                            const headers = {
                                'Accept': 'application/json, text/plain, */*',
                                'Accept-Language': 'zh-CN,zh;q=0.9,en;q=0.8,en-GB;q=0.7,en-US;q=0.6',
                                'Referer': 'https://creator.xiaohongshu.com/new/note-manager',
                                'Sec-Fetch-Dest': 'empty',
                                'Sec-Fetch-Mode': 'cors',
                                'Sec-Fetch-Site': 'same-origin'
                            };
                            
                            // 尝试获取签名
                            let signResult = { hasSign: false, x_s: '', x_t: '', x_s_common: '', error: '' };
                            if (typeof window !== 'undefined' && typeof window._webmsxyw === 'function') {
                                try {
                                    const sign = window._webmsxyw(url, '');
                                    headers['x-s'] = sign['X-s'];
                                    headers['x-t'] = String(sign['X-t']);
                                    // 检查是否有 x-s-common
                                    if (sign['X-s-common']) {
                                        headers['x-s-common'] = sign['X-s-common'];
                                    }
                                    signResult = {
                                        hasSign: true,
                                        x_s: sign['X-s'] ? sign['X-s'].substring(0, 50) + '...' : '',
                                        x_t: String(sign['X-t']),
                                        x_s_common: sign['X-s-common'] ? sign['X-s-common'].substring(0, 50) + '...' : '',
                                        error: ''
                                    };
                                    console.log('签名生成成功:', signResult);
                                } catch (e) {
                                    signResult.error = e.toString();
                                    console.error('签名生成失败:', e);
                                }
                            } else {
                                signResult.error = '_webmsxyw function not found';
                                console.error('签名函数不存在');
                            }
                            
                            const res = await fetch(url, {
                                method: 'GET',
                                credentials: 'include',
                                headers
                            });
                            
                            const responseData = await res.json();
                            return {
                                ...responseData,
                                _debug: {
                                    signResult: signResult,
                                    status: res.status,
                                    statusText: res.statusText
                                }
                            };
                        } catch (e) {
                            return { success: false, error: e.toString() };
                        }
                    }""",
                    p,
                )

            def parse_notes(notes_list):
                parsed = []
                for note in notes_list:
                    note_id = note.get("id", "")
                    if not note_id:
                        continue

                    cover_url = ""
                    images_list = note.get("images_list", [])
                    if images_list:
                        cover_url = images_list[0].get("url", "")
                        if cover_url.startswith("http://"):
                            cover_url = cover_url.replace("http://", "https://")

                    duration = note.get("video_info", {}).get("duration", 0)

                    status = "published"
                    tab_status = note.get("tab_status", 1)
                    if tab_status == 0:
                        status = "draft"
                    elif tab_status == 2:
                        status = "reviewing"
                    elif tab_status == 3:
                        status = "rejected"

                    video_url = (
                        f"https://www.xiaohongshu.com/explore/{note_id}"
                        if note_id
                        else ""
                    )
                    parsed.append(
                        WorkItem(
                            work_id=note_id,
                            title=note.get("display_title", "") or "无标题",
                            cover_url=cover_url,
                            video_url=video_url,
                            duration=duration,
                            status=status,
                            publish_time=note.get("time", ""),
                            play_count=note.get("view_count", 0),
                            like_count=note.get("likes", 0),
                            comment_count=note.get("comments_count", 0),
                            share_count=note.get("shared_count", 0),
                            collect_count=note.get("collected_count", 0),
                        )
                    )
                return parsed

            async def collect_by_scrolling() -> WorksResult:
                print(
                    f"[{self.platform_name}] 直连接口被拒绝，切换为滚动页面 + 监听 API 响应模式",
                    flush=True,
                )
                captured: List[WorkItem] = []
                captured_total = 0
                captured_seen = set()
                lock = asyncio.Lock()

                async def handle_response(response):
                    nonlocal captured_total
                    url = response.url
                    if (
                        "creator.xiaohongshu.com" not in url
                        and "edith.xiaohongshu.com" not in url
                    ) or "creator/note/user/posted" not in url:
                        return
                    try:
                        json_data = await response.json()
                    except Exception:
                        return

                    if not isinstance(json_data, dict):
                        return
                    if not (
                        json_data.get("success") or json_data.get("code") == 0
                    ) or not json_data.get("data"):
                        return

                    data = json_data.get("data", {}) or {}
                    notes = data.get("notes", []) or []
                    tags = data.get("tags", []) or []

                    declared = 0
                    if tags:
                        preferred = 0
                        for tag in tags:
                            if tag.get("id") == "special.note_time_desc":
                                preferred = (
                                    tag.get("notes_count", 0)
                                    or tag.get("notesCount", 0)
                                    or tag.get("count", 0)
                                    or 0
                                )
                                break
                        if preferred:
                            declared = int(preferred)
                        else:
                            declared = max(
                                [
                                    int(
                                        t.get("notes_count", 0)
                                        or t.get("notesCount", 0)
                                        or t.get("count", 0)
                                        or 0
                                    )
                                    for t in tags
                                ]
                                + [0]
                            )

                    if not declared:
                        declared = int(
                            data.get("total", 0)
                            or data.get("total_count", 0)
                            or data.get("totalCount", 0)
                            or 0
                        )
                        if not declared and isinstance(data.get("page", {}), dict):
                            declared = int(
                                data.get("page", {}).get("total", 0)
                                or data.get("page", {}).get("totalCount", 0)
                                or 0
                            )

                    async with lock:
                        if declared:
                            captured_total = max(captured_total, declared)

                        parsed = parse_notes(notes)
                        new_count = 0
                        for w in parsed:
                            if w.work_id and w.work_id not in captured_seen:
                                captured_seen.add(w.work_id)
                                captured.append(w)
                                new_count += 1

                        if new_count > 0:
                            print(
                                f"[{self.platform_name}] 捕获 notes 响应: notes={len(notes)}, new={new_count}, total_now={len(captured)}, declared_total={captured_total}",
                                flush=True,
                            )

                self.page.on("response", handle_response)

                try:
                    try:
                        # 使用更宽松的等待条件，避免超时
                        await self.page.goto(
                            "https://creator.xiaohongshu.com/new/note-manager",
                            wait_until="domcontentloaded",
                            timeout=90000,
                        )
                        print(f"[{self.platform_name}] 页面加载成功", flush=True)
                    except Exception as nav_error:
                        print(
                            f"[{self.platform_name}] 导航异常（继续）：{nav_error}",
                            flush=True,
                        )
                        # 即使超时也继续尝试，可能页面已经部分加载
                        try:
                            await asyncio.sleep(3)
                            current_url = self.page.url
                            print(
                                f"[{self.platform_name}] 超时后当前页面: {current_url}",
                                flush=True,
                            )
                            if "login" in current_url:
                                raise Exception("Cookie 已过期，请重新登录")
                        except Exception as e:
                            if "Cookie" in str(e):
                                raise
                            print(
                                f"[{self.platform_name}] 检查页面状态时出错: {e}",
                                flush=True,
                            )

                    await asyncio.sleep(2.0)

                    idle_rounds = 0
                    last_count = 0
                    last_height = 0

                    for _ in range(1, 400):
                        scroll_state = await self.page.evaluate(
                            """() => {
                                const isScrollable = (el) => {
                                    if (!el) return false;
                                    const style = window.getComputedStyle(el);
                                    const oy = style.overflowY;
                                    return (oy === 'auto' || oy === 'scroll') && (el.scrollHeight - el.clientHeight > 200);
                                };
                                const pickBest = () => {
                                    const nodes = Array.from(document.querySelectorAll('*'));
                                    let best = document.scrollingElement || document.documentElement || document.body;
                                    let bestScroll = (best.scrollHeight || 0) - (best.clientHeight || 0);
                                    for (const el of nodes) {
                                        if (!isScrollable(el)) continue;
                                        const diff = el.scrollHeight - el.clientHeight;
                                        if (diff > bestScroll) {
                                            best = el;
                                            bestScroll = diff;
                                        }
                                    }
                                    return best;
                                };
                                const el = pickBest();
                                const beforeTop = el.scrollTop || 0;
                                const beforeHeight = el.scrollHeight || 0;
                                el.scrollTo(0, beforeHeight);
                                return {
                                    beforeTop,
                                    afterTop: el.scrollTop || 0,
                                    height: el.scrollHeight || 0,
                                    client: el.clientHeight || 0,
                                };
                            }"""
                        )

                        await asyncio.sleep(1.2)

                        async with lock:
                            count_now = len(captured)
                            total_now = captured_total

                        if total_now and count_now >= total_now:
                            break

                        height_now = (
                            int(scroll_state.get("height", 0) or 0)
                            if isinstance(scroll_state, dict)
                            else 0
                        )
                        if count_now == last_count and height_now == last_height:
                            idle_rounds += 1
                        else:
                            idle_rounds = 0

                        last_count = count_now
                        last_height = height_now

                        if idle_rounds >= 6:
                            break

                    async with lock:
                        final_works = list(captured)
                        final_total = captured_total or len(final_works)

                    return WorksResult(
                        success=True,
                        platform=self.platform_name,
                        works=final_works,
                        total=final_total,
                        has_more=False,
                        next_page=-1,
                    )
                finally:
                    try:
                        self.page.remove_listener("response", handle_response)
                    except Exception:
                        pass

            # 添加请求监听，捕获请求头信息
            captured_requests = []

            async def handle_request(request):
                url = request.url
                if (
                    "creator.xiaohongshu.com" in url or "edith.xiaohongshu.com" in url
                ) and "creator/note/user/posted" in url:
                    headers = request.headers
                    captured_requests.append(
                        {
                            "url": url,
                            "method": request.method,
                            "headers": dict(headers),
                            "timestamp": asyncio.get_event_loop().time(),
                        }
                    )
                    # 打印关键头部信息
                    x_s = headers.get("x-s", "")
                    x_t = headers.get("x-t", "")
                    x_s_common = headers.get("x-s-common", "")
                    print(f"[{self.platform_name}] 📡 API 请求: {url}", flush=True)
                    print(
                        f"[{self.platform_name}]    Method: {request.method}",
                        flush=True,
                    )
                    print(
                        f"[{self.platform_name}]    X-S: {x_s[:50] if x_s else '(none)'}...",
                        flush=True,
                    )
                    print(f"[{self.platform_name}]    X-T: {x_t}", flush=True)
                    print(
                        f"[{self.platform_name}]    X-S-Common: {x_s_common[:50] if x_s_common else '(none)'}...",
                        flush=True,
                    )
                    print(
                        f"[{self.platform_name}]    Cookie: {headers.get('cookie', '')[:100]}...",
                        flush=True,
                    )

            self.page.on("request", handle_request)

            iters = 0
            page_count = 0  # 统计实际获取到的页数
            print(
                f"[{self.platform_name}] ========== 开始自动分页获取作品 ==========",
                flush=True,
            )
            print(
                f"[{self.platform_name}] 最大迭代次数: {max_iters}, 每页大小: {api_page_size}",
                flush=True,
            )

            while iters < max_iters:
                iters += 1
                print(
                    f"\n[{self.platform_name}] ---------- 第 {iters} 次请求 (cursor={cursor}) ----------",
                    flush=True,
                )
                resp = await fetch_notes_page(cursor)

                # 打印调试信息
                if resp and isinstance(resp, dict) and resp.get("_debug"):
                    debug_info = resp.get("_debug", {})
                    sign_result = debug_info.get("signResult", {})
                    print(f"[{self.platform_name}] 🔍 调试信息:", flush=True)
                    print(
                        f"[{self.platform_name}]    签名可用: {sign_result.get('hasSign', False)}",
                        flush=True,
                    )
                    if sign_result.get("x_s"):
                        print(
                            f"[{self.platform_name}]    X-S: {sign_result.get('x_s', '')}",
                            flush=True,
                        )
                    if sign_result.get("x_t"):
                        print(
                            f"[{self.platform_name}]    X-T: {sign_result.get('x_t', '')}",
                            flush=True,
                        )
                    if sign_result.get("error"):
                        print(
                            f"[{self.platform_name}]    签名错误: {sign_result.get('error', '')}",
                            flush=True,
                        )
                    print(
                        f"[{self.platform_name}]    HTTP 状态: {debug_info.get('status', 'N/A')} {debug_info.get('statusText', '')}",
                        flush=True,
                    )
                    # 移除调试信息，避免影响后续处理
                    resp.pop("_debug", None)

                if not resp or not isinstance(resp, dict):
                    print(
                        f"[{self.platform_name}] ❌ 第 {iters} 次拉取无响应，cursor={cursor}",
                        flush=True,
                    )
                    print(
                        f"[{self.platform_name}] 响应类型: {type(resp)}, 响应内容: {str(resp)[:500]}",
                        flush=True,
                    )
                    break
                if not (resp.get("success") or resp.get("code") == 0) or not resp.get(
                    "data"
                ):
                    error_msg = str(resp)[:500]
                    print(
                        f"[{self.platform_name}] ❌ 拉取失败 cursor={cursor}",
                        flush=True,
                    )
                    print(f"[{self.platform_name}] 响应详情: {error_msg}", flush=True)
                    print(
                        f"[{self.platform_name}] success={resp.get('success')}, code={resp.get('code')}, has_data={bool(resp.get('data'))}",
                        flush=True,
                    )
                    # 打印详细的错误信息
                    if resp.get("msg"):
                        print(
                            f"[{self.platform_name}] 错误消息: {resp.get('msg')}",
                            flush=True,
                        )
                    if resp.get("message"):
                        print(
                            f"[{self.platform_name}] 错误消息: {resp.get('message')}",
                            flush=True,
                        )
                    if resp.get("error"):
                        print(
                            f"[{self.platform_name}] 错误: {resp.get('error')}",
                            flush=True,
                        )
                    # 打印调试信息
                    if resp.get("_debug"):
                        debug_info = resp.get("_debug", {})
                        print(
                            f"[{self.platform_name}] HTTP 状态: {debug_info.get('status', 'N/A')} {debug_info.get('statusText', '')}",
                            flush=True,
                        )
                        sign_result = debug_info.get("signResult", {})
                        if sign_result.get("error"):
                            print(
                                f"[{self.platform_name}] 签名错误: {sign_result.get('error')}",
                                flush=True,
                            )
                    if iters == 1:
                        print(
                            f"[{self.platform_name}] 第一次请求失败，切换到滚动模式",
                            flush=True,
                        )
                        return await collect_by_scrolling()
                    break

                data = resp.get("data", {}) or {}
                notes = data.get("notes", []) or []
                if not notes:
                    print(
                        f"[{self.platform_name}] ⚠️ cursor={cursor} 无作品，停止分页",
                        flush=True,
                    )
                    break

                # 统计页数
                page_count += 1
                print(
                    f"[{self.platform_name}] ✅ 第 {page_count} 页获取成功，本页作品数: {len(notes)}",
                    flush=True,
                )

                tags = data.get("tags", []) or []
                if tags:
                    preferred = 0
                    for tag in tags:
                        if tag.get("id") == "special.note_time_desc":
                            preferred = (
                                tag.get("notes_count", 0)
                                or tag.get("notesCount", 0)
                                or tag.get("count", 0)
                                or 0
                            )
                            break
                    if preferred:
                        total = max(total, int(preferred))
                        print(
                            f"[{self.platform_name}] 📊 从 tags 获取总数: {total} (preferred)",
                            flush=True,
                        )
                    else:
                        tag_total = max(
                            [
                                int(
                                    t.get("notes_count", 0)
                                    or t.get("notesCount", 0)
                                    or t.get("count", 0)
                                    or 0
                                )
                                for t in tags
                            ]
                            + [0]
                        )
                        total = max(total, tag_total)
                        if tag_total > 0:
                            print(
                                f"[{self.platform_name}] 📊 从 tags 获取总数: {total}",
                                flush=True,
                            )
                if not total:
                    t2 = int(
                        data.get("total", 0)
                        or data.get("total_count", 0)
                        or data.get("totalCount", 0)
                        or 0
                    )
                    if not t2 and isinstance(data.get("page", {}), dict):
                        t2 = int(
                            data.get("page", {}).get("total", 0)
                            or data.get("page", {}).get("totalCount", 0)
                            or 0
                        )
                    total = max(total, t2)
                    if t2 > 0:
                        print(
                            f"[{self.platform_name}] 📊 从 data.total 获取总数: {total}",
                            flush=True,
                        )

                parsed = parse_notes(notes)
                new_items = []
                for w in parsed:
                    if w.work_id and w.work_id not in seen_ids:
                        seen_ids.add(w.work_id)
                        new_items.append(w)
                works.extend(new_items)

                print(
                    f"[{self.platform_name}] 📈 累计统计: 本页新作品={len(new_items)}, 累计作品数={len(works)}, 声明总数={total}",
                    flush=True,
                )

                if total and len(works) >= total:
                    print(
                        f"[{self.platform_name}] ✅ 已获取全部作品 (累计={len(works)} >= 总数={total})，停止分页",
                        flush=True,
                    )
                    break
                if len(new_items) == 0:
                    print(
                        f"[{self.platform_name}] ⚠️ 本页无新作品，停止分页", flush=True
                    )
                    break

                next_page = data.get("page", "")
                old_cursor = cursor
                if next_page == cursor:
                    next_page = ""
                if next_page == -1 or str(next_page) == "-1":
                    next_page = ""
                if next_page is None or next_page == "":
                    if isinstance(cursor, int):
                        cursor = cursor + 1
                    else:
                        cursor = len(works) // api_page_size
                    print(
                        f"[{self.platform_name}] 🔄 下一页 cursor: {old_cursor} -> {cursor} (自动递增)",
                        flush=True,
                    )
                else:
                    cursor = next_page
                    print(
                        f"[{self.platform_name}] 🔄 下一页 cursor: {old_cursor} -> {cursor} (API返回)",
                        flush=True,
                    )

                await asyncio.sleep(0.5)

            # 移除请求监听器
            try:
                self.page.remove_listener("request", handle_request)
            except Exception:
                pass

            print(
                f"\n[{self.platform_name}] ========== 分页完成 ==========", flush=True
            )
            print(
                f"[{self.platform_name}] 📊 分页统计: 总请求次数={iters}, 成功获取页数={page_count}, 累计作品数={len(works)}, 声明总数={total}",
                flush=True,
            )
            if captured_requests:
                print(
                    f"[{self.platform_name}] 📡 捕获到 {len(captured_requests)} 个 API 请求",
                    flush=True,
                )
                for i, req in enumerate(captured_requests[:3], 1):  # 只显示前3个
                    print(
                        f"[{self.platform_name}]    请求 {i}: {req['method']} {req['url']}",
                        flush=True,
                    )
                    if "x-s" in req["headers"]:
                        print(
                            f"[{self.platform_name}]      X-S: {req['headers']['x-s'][:50]}...",
                            flush=True,
                        )
                    if "x-t" in req["headers"]:
                        print(
                            f"[{self.platform_name}]      X-T: {req['headers']['x-t']}",
                            flush=True,
                        )
            print(
                f"[{self.platform_name}] ========================================\n",
                flush=True,
            )

        except Exception as e:
            import traceback

            error_trace = traceback.format_exc()
            print(f"[{self.platform_name}] 发生异常: {e}", flush=True)
            traceback.print_exc()
            return WorksResult(
                success=False,
                platform=self.platform_name,
                error=str(e),
                debug_info=f"异常详情: {error_trace[:500]}",
            )
        finally:
            await self.close_browser()

        debug_info = f"总请求次数={iters}, 成功获取页数={page_count}, 累计作品数={len(works)}, 声明总数={total}"
        if len(works) == 0:
            debug_info += " | 警告: 没有获取到任何作品，可能原因: Cookie失效、API调用失败、或账号无作品"

        return WorksResult(
            success=True,
            platform=self.platform_name,
            works=works,
            total=total or len(works),
            has_more=False,
            next_page=-1,
            debug_info=debug_info,
        )

    async def get_comments(
        self, cookies: str, work_id: str, cursor: str = ""
    ) -> CommentsResult:
        """
        获取账号下所有作品的评论 —— 完全复刻 get_xiaohongshu_work_comments.py 的7步流程。
        """
        all_comments: List[CommentItem] = []
        total_comments = 0
        has_more = False
        browser = None
        print(222222222222222222222222222222222222)
        print(work_id)
        global stored_cookies
        try:
            # --- Step 1: 初始化浏览器和 Cookie ---
            cookie_list = self.parse_cookies(cookies)
            playwright = await async_playwright().start()
            browser = await playwright.chromium.launch(headless=False)
            context = await browser.new_context(
                viewport={"width": 1400, "height": 900},
                user_agent="Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/120.0.0.0 Safari/537.36",
            )
            if os.path.exists("cookies.json"):
                with open("cookies.json", "r") as f:
                    stored_cookies = json.load(f)
            if stored_cookies:
                await context.add_cookies(stored_cookies)
            page = await context.new_page()

            # --- Step 2: 打开小红书主页 ---
            await page.goto(
                "https://www.xiaohongshu.com", wait_until="domcontentloaded"
            )
            await asyncio.sleep(1.5)

            # --- Step 3: 检查并处理登录弹窗 ---
            try:
                if await page.is_visible(".login-container", timeout=3000):
                    await page.wait_for_selector(
                        ".login-container", state="hidden", timeout=120000
                    )
                    stored_cookies = await context.cookies()
                    with open("xiaohongshu_cookies.json", "w") as f:
                        json.dump(stored_cookies, f)

            except Exception as e:
                pass  # 忽略超时，继续执行

            # --- 提取 User ID ---
            user_id = None
            for cookie in cookie_list:
                if cookie.get("name") == "x-user-id-creator.xiaohongshu.com":
                    user_id = cookie.get("value")
                    break
            if not user_id:
                raise ValueError("无法从 Cookie 中提取 user_id")

            # --- Step 4: 跳转到用户主页 ---
            profile_url = f"https://www.xiaohongshu.com/user/profile/{user_id}"
            await page.goto(profile_url, wait_until="domcontentloaded")
            await asyncio.sleep(2)

            # --- 等待笔记区域加载 ---
            try:
                await page.wait_for_selector(
                    "#userPostedFeeds .note-item", timeout=20000
                )
            except:
                raise Exception("笔记区域未加载，请检查账号是否公开或 Cookie 是否有效")

            # --- Step 5: 滚动到底部加载全部笔记 ---
            last_height = None
            while True:
                await page.evaluate("window.scrollTo(0, document.body.scrollHeight)")
                await asyncio.sleep(2)
                new_height = await page.evaluate("document.body.scrollHeight")
                if new_height == last_height:
                    break
                last_height = new_height

            # --- 获取所有封面图 ---
            note_imgs = await page.query_selector_all(
                "#userPostedFeeds .note-item .cover img"
            )
            print(f"共找到 {len(note_imgs)} 张封面图")

            # --- Step 6 & 7: 依次点击封面图，捕获评论并结构化 ---
            for i, img in enumerate(note_imgs):
                try:
                    # >>> 新增：从 img 提取 note_id 并与 work_id 比较 <<<
                    note_id = await img.evaluate("""el => {
                        const item = el.closest('.note-item');
                        if (!item) return null;
                        const link = item.querySelector('a[href^="/explore/"]');
                        return link ? link.href.split('/').pop() : null;
                    }""")
                    if note_id != work_id:
                        print(
                            f"note_id {note_id} 与目标 work_id {work_id} 不匹配，跳出循环"
                        )
                        continue
                    # <<< 新增结束 >>>

                    await img.scroll_into_view_if_needed()
                    await asyncio.sleep(0.5)

                    comment_resp = None

                    def handle_response(response):
                        nonlocal comment_resp
                        if (
                            "edith.xiaohongshu.com/api/sns/web/v2/comment/page"
                            in response.url
                        ):
                            comment_resp = response

                    page.on("response", handle_response)
                    await img.click()
                    await asyncio.sleep(1.5)
                    page.remove_listener("response", handle_response)

                    if not comment_resp:
                        await page.keyboard.press("Escape")
                        continue

                    json_data = await comment_resp.json()
                    if not (json_data.get("success") or json_data.get("code") == 0):
                        await page.keyboard.press("Escape")
                        continue

                    data = json_data.get("data", {})
                    raw_comments = data.get("comments", [])
                    note_id = data.get("note_id", "")

                    for main_cmt in raw_comments:
                        # 主评论
                        user_info = main_cmt.get("user_info", {})
                        all_comments.append(
                            CommentItem(
                                comment_id=main_cmt["id"],
                                parent_comment_id=None,
                                work_id=work_id,
                                content=main_cmt["content"],
                                author_id=user_info.get("user_id", ""),
                                author_name=user_info.get("nickname", ""),
                                author_avatar=user_info.get("image", ""),
                                like_count=int(main_cmt.get("like_count", 0)),
                                reply_count=main_cmt.get("sub_comment_count", 0),
                                create_time=self._timestamp_to_readable(
                                    main_cmt.get("create_time", 0)
                                ),
                            )
                        )

                        # 子评论
                        for sub_cmt in main_cmt.get("sub_comments", []):
                            sub_user = sub_cmt.get("user_info", {})
                            all_comments.append(
                                CommentItem(
                                    comment_id=sub_cmt["id"],
                                    parent_comment_id=main_cmt["id"],
                                    work_id=work_id,
                                    content=sub_cmt["content"],
                                    author_id=sub_user.get("user_id", ""),
                                    author_name=sub_user.get("nickname", ""),
                                    author_avatar=sub_user.get("image", ""),
                                    like_count=int(sub_cmt.get("like_count", 0)),
                                    reply_count=0,
                                    create_time=self._timestamp_to_readable(
                                        sub_cmt.get("create_time", 0)
                                    ),
                                )
                            )

                    # 关闭弹窗
                    await page.keyboard.press("Escape")
                    await asyncio.sleep(1)

                except Exception as e:
                    # 出错也尝试关闭弹窗
                    try:
                        await page.keyboard.press("Escape")
                        await asyncio.sleep(0.5)
                    except:
                        pass
                    continue

            # --- 返回结果 ---
            total_comments = len(all_comments)
            # return {
            #     'success': True,
            #     'platform': self.platform_name,
            #     'work_comments': all_comments,  # 注意：此处为扁平列表，如需按作品分组可在外层处理
            #     'total': total_comments
            # }
            return CommentsResult(
                success=True,
                platform=self.platform_name,
                work_id=work_id,
                comments=all_comments,
                total=total_comments,
                has_more=has_more,
            )

        except Exception as e:
            import traceback

            traceback.print_exc()
            return CommentsResult(
                success=True, platform=self.platform_name, work_id=work_id, total=0
            )
        finally:
            if browser:
                await browser.close()

    def _timestamp_to_readable(self, ts_ms: int) -> str:
        """将毫秒时间戳转换为可读格式"""
        from datetime import datetime

        if not ts_ms:
            return ""
        try:
            return datetime.fromtimestamp(ts_ms / 1000).strftime("%Y-%m-%d %H:%M:%S")
        except Exception:
            return ""

    async def get_all_comments(self, cookies: str) -> dict:
        """获取所有作品的评论 - 通过评论管理页面"""
        print(f"\n{'=' * 60}")
        print(f"[{self.platform_name}] 获取所有作品评论")
        print(f"{'=' * 60}")

        all_work_comments = []
        captured_comments = []
        captured_notes = {}  # note_id -> note_info

        try:
            await self.init_browser()
            cookie_list = self.parse_cookies(cookies)
            await self.set_cookies(cookie_list)

            if not self.page:
                raise Exception("Page not initialized")

            # 设置 API 响应监听器
            async def handle_response(response):
                nonlocal captured_comments, captured_notes
                url = response.url
                try:
                    # 监听评论列表 API - 多种格式
                    if "/comment/" in url and ("page" in url or "list" in url):
                        json_data = await response.json()
                        print(
                            f"[{self.platform_name}] 捕获到评论 API: {url[:100]}...",
                            flush=True,
                        )

                        if json_data.get("success") or json_data.get("code") == 0:
                            data = json_data.get("data", {})
                            comments = data.get("comments", []) or data.get("list", [])

                            # 从 URL 中提取 note_id
                            import re

                            note_id_match = re.search(r"note_id=([^&]+)", url)
                            note_id = note_id_match.group(1) if note_id_match else ""

                            if comments:
                                for comment in comments:
                                    # 添加 note_id 到评论中
                                    if note_id and "note_id" not in comment:
                                        comment["note_id"] = note_id
                                    captured_comments.append(comment)

                                print(
                                    f"[{self.platform_name}] 捕获到 {len(comments)} 条评论 (note_id={note_id})，总计: {len(captured_comments)}",
                                    flush=True,
                                )

                    # 监听笔记列表 API
                    if "/note/" in url and (
                        "list" in url or "posted" in url or "manager" in url
                    ):
                        json_data = await response.json()
                        if json_data.get("success") or json_data.get("code") == 0:
                            data = json_data.get("data", {})
                            notes = data.get("notes", []) or data.get("list", [])
                            print(
                                f"[{self.platform_name}] 捕获到笔记列表 API: {len(notes)} 个笔记",
                                flush=True,
                            )
                            for note in notes:
                                note_id = note.get("note_id", "") or note.get("id", "")
                                if note_id:
                                    cover_url = ""
                                    cover = note.get("cover", {})
                                    if isinstance(cover, dict):
                                        cover_url = cover.get("url", "") or cover.get(
                                            "url_default", ""
                                        )
                                    elif isinstance(cover, str):
                                        cover_url = cover

                                    captured_notes[note_id] = {
                                        "title": note.get("title", "")
                                        or note.get("display_title", ""),
                                        "cover": cover_url,
                                    }
                except Exception as e:
                    print(f"[{self.platform_name}] 解析响应失败: {e}", flush=True)

            self.page.on("response", handle_response)
            print(f"[{self.platform_name}] 已注册 API 响应监听器", flush=True)

            # 访问评论管理页面
            print(f"[{self.platform_name}] 访问评论管理页面...", flush=True)
            await self.page.goto(
                "https://creator.xiaohongshu.com/creator/comment",
                wait_until="domcontentloaded",
                timeout=30000,
            )
            await asyncio.sleep(5)

            # 检查登录状态
            current_url = self.page.url
            if "login" in current_url:
                raise Exception("Cookie 已过期，请重新登录")

            print(
                f"[{self.platform_name}] 页面加载完成，当前捕获: {len(captured_comments)} 条评论, {len(captured_notes)} 个笔记",
                flush=True,
            )

            # 滚动加载更多评论
            for i in range(5):
                await self.page.evaluate("window.scrollBy(0, 500)")
                await asyncio.sleep(1)

            await asyncio.sleep(3)

            # 移除监听器
            self.page.remove_listener("response", handle_response)

            print(
                f"[{self.platform_name}] 最终捕获: {len(captured_comments)} 条评论, {len(captured_notes)} 个笔记",
                flush=True,
            )

            # 按作品分组评论
            work_comments_map = {}  # note_id -> work_comments
            for comment in captured_comments:
                # 获取笔记信息
                note_info = comment.get("note_info", {}) or comment.get("note", {})
                note_id = (
                    comment.get("note_id", "")
                    or note_info.get("note_id", "")
                    or note_info.get("id", "")
                )

                if not note_id:
                    continue

                if note_id not in work_comments_map:
                    saved_note = captured_notes.get(note_id, {})
                    cover_url = ""
                    cover = note_info.get("cover", {})
                    if isinstance(cover, dict):
                        cover_url = cover.get("url", "") or cover.get("url_default", "")
                    elif isinstance(cover, str):
                        cover_url = cover
                    if not cover_url:
                        cover_url = saved_note.get("cover", "")

                    work_comments_map[note_id] = {
                        "work_id": note_id,
                        "title": note_info.get("title", "")
                        or note_info.get("display_title", "")
                        or saved_note.get("title", ""),
                        "cover_url": cover_url,
                        "comments": [],
                    }

                cid = comment.get("id", "") or comment.get("comment_id", "")
                if not cid:
                    continue

                user_info = comment.get("user_info", {}) or comment.get("user", {})

                work_comments_map[note_id]["comments"].append(
                    {
                        "comment_id": cid,
                        "author_id": user_info.get("user_id", "")
                        or user_info.get("id", ""),
                        "author_name": user_info.get("nickname", "")
                        or user_info.get("name", ""),
                        "author_avatar": user_info.get("image", "")
                        or user_info.get("avatar", ""),
                        "content": comment.get("content", ""),
                        "like_count": comment.get("like_count", 0),
                        "create_time": comment.get("create_time", ""),
                    }
                )

            all_work_comments = list(work_comments_map.values())
            total_comments = sum(len(w["comments"]) for w in all_work_comments)
            print(
                f"[{self.platform_name}] 获取到 {len(all_work_comments)} 个作品的 {total_comments} 条评论",
                flush=True,
            )

        except Exception as e:
            import traceback

            traceback.print_exc()
            return {
                "success": False,
                "platform": self.platform_name,
                "error": str(e),
                "work_comments": [],
            }
        finally:
            await self.close_browser()

        return {
            "success": True,
            "platform": self.platform_name,
            "work_comments": all_work_comments,
            "total": len(all_work_comments),
        }

    async def get_note_base(self, cookies: str, note_id: str) -> dict:
        """
        调用创作者中心「笔记数据- note/base」接口，用于每日作品数据同步。
        使用账号已存 Cookie，不启浏览器，直接带 Referer 调 note/base。
        """
        import aiohttp

        note_id = (note_id or "").strip()
        if not note_id:
            return {"data": None, "code": -1, "msg": "missing note_id"}

        cookie_list = self.parse_cookies(cookies)
        cookie_dict = {
            c.get("name") or "": c.get("value") or ""
            for c in cookie_list
            if c.get("name")
        }

        api_headers = {
            "Accept": "application/json, text/plain, */*",
            "User-Agent": "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/120.0.0.0 Safari/537.36",
            "Referer": f"https://creator.xiaohongshu.com/statistics/note-detail?noteId={note_id}",
            "Accept-Language": "zh-CN,zh;q=0.9,en;q=0.8",
            "Accept-Encoding": "gzip, deflate, br",
            "Connection": "keep-alive",
        }

        api_url = f"https://creator.xiaohongshu.com/api/galaxy/creator/datacenter/note/base?note_id={note_id}"

        async with aiohttp.ClientSession(cookies=cookie_dict) as session:
            async with session.get(
                api_url,
                headers=api_headers,
                timeout=aiohttp.ClientTimeout(total=30),
            ) as resp:
                status = resp.status
                try:
                    data = await resp.json()
                except Exception:
                    text = await resp.text()
                    print(f"[{self.platform_name}] note/base non-JSON: {text[:500]}")
                    return {"data": None, "code": status, "msg": "invalid response"}

        if status != 200:
            return {
                "data": None,
                "code": status,
                "msg": data.get("msg") if isinstance(data, dict) else "request failed",
            }

        return (
            data
            if isinstance(data, dict)
            else {"data": None, "code": -1, "msg": "invalid response"}
        )

    async def get_account_base(self, cookies: str) -> dict:
        """
        调用创作者中心「账号概览- account/base」接口，用于每日用户数据同步。
        使用账号已存 Cookie，不启浏览器，直接带 Referer 请求 API。
        """
        import aiohttp

        cookie_list = self.parse_cookies(cookies)
        cookie_dict = {
            c.get("name") or "": c.get("value") or ""
            for c in cookie_list
            if c.get("name")
        }

        api_headers = {
            "Accept": "application/json, text/plain, */*",
            "User-Agent": "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/120.0.0.0 Safari/537.36",
            "Referer": "https://creator.xiaohongshu.com/statistics/account/v2",
            "Accept-Language": "zh-CN,zh;q=0.9,en;q=0.8",
            "Accept-Encoding": "gzip, deflate, br",
            "Connection": "keep-alive",
        }

        api_url = "https://creator.xiaohongshu.com/api/galaxy/v2/creator/datacenter/account/base"

        async with aiohttp.ClientSession(cookies=cookie_dict) as session:
            async with session.get(
                api_url,
                headers=api_headers,
                timeout=aiohttp.ClientTimeout(total=30),
            ) as resp:
                status = resp.status
                try:
                    data = await resp.json()
                except Exception:
                    text = await resp.text()
                    print(f"[{self.platform_name}] account/base non-JSON: {text[:500]}")
                    return {"data": None, "code": status, "msg": "invalid response"}

        if status != 200:
            return {
                "data": None,
                "code": status,
                "msg": data.get("msg") if isinstance(data, dict) else "request failed",
            }

        return (
            data
            if isinstance(data, dict)
            else {"data": None, "code": -1, "msg": "invalid response"}
        )

    async def get_fans_overall_new(self, cookies: str) -> dict:
        """
        调用创作者中心「粉丝数据- overall_new」接口，用于每日用户数据中的粉丝趋势。
        使用账号已存 Cookie，不启浏览器，直接带 Referer 请求 API。
        """
        import aiohttp

        cookie_list = self.parse_cookies(cookies)
        cookie_dict = {
            c.get("name") or "": c.get("value") or ""
            for c in cookie_list
            if c.get("name")
        }

        api_headers = {
            "Accept": "application/json, text/plain, */*",
            "User-Agent": "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/120.0.0.0 Safari/537.36",
            "Referer": "https://creator.xiaohongshu.com/statistics/fans-data",
            "Accept-Language": "zh-CN,zh;q=0.9,en;q=0.8",
            "Accept-Encoding": "gzip, deflate, br",
            "Connection": "keep-alive",
        }

        api_url = (
            "https://creator.xiaohongshu.com/api/galaxy/creator/data/fans/overall_new"
        )

        async with aiohttp.ClientSession(cookies=cookie_dict) as session:
            async with session.get(
                api_url,
                headers=api_headers,
                timeout=aiohttp.ClientTimeout(total=30),
            ) as resp:
                status = resp.status
                try:
                    data = await resp.json()
                except Exception:
                    text = await resp.text()
                    print(
                        f"[{self.platform_name}] fans/overall_new non-JSON: {text[:500]}"
                    )
                    return {"data": None, "code": status, "msg": "invalid response"}

        if status != 200:
            return {
                "data": None,
                "code": status,
                "msg": data.get("msg") if isinstance(data, dict) else "request failed",
            }

        return (
            data
            if isinstance(data, dict)
            else {"data": None, "code": -1, "msg": "invalid response"}
        )

    async def get_account_overview(self, cookies: str) -> dict:
        """
        一次请求同时拉取 account/base 与 fans/overall_new，用于每日用户数据同步。
        使用已存 Cookie，不先访问页面，直接带 Referer 并行请求两个 API。
        返回: { "account_base": {...}, "fans_overall_new": {...} }
        """
        import aiohttp

        cookie_list = self.parse_cookies(cookies)
        cookie_dict = {
            c.get("name") or "": c.get("value") or ""
            for c in cookie_list
            if c.get("name")
        }

        account_api_headers = {
            "Accept": "application/json, text/plain, */*",
            "User-Agent": "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/120.0.0.0 Safari/537.36",
            "Referer": "https://creator.xiaohongshu.com/statistics/account/v2",
            "Accept-Language": "zh-CN,zh;q=0.9,en;q=0.8",
            "Accept-Encoding": "gzip, deflate, br",
            "Connection": "keep-alive",
        }
        fans_api_headers = {
            "Accept": "application/json, text/plain, */*",
            "User-Agent": "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/120.0.0.0 Safari/537.36",
            "Referer": "https://creator.xiaohongshu.com/statistics/fans-data",
            "Accept-Language": "zh-CN,zh;q=0.9,en;q=0.8",
            "Accept-Encoding": "gzip, deflate, br",
            "Connection": "keep-alive",
        }

        api_account = "https://creator.xiaohongshu.com/api/galaxy/v2/creator/datacenter/account/base"
        api_fans = (
            "https://creator.xiaohongshu.com/api/galaxy/creator/data/fans/overall_new"
        )

        async def fetch_account_base(session):
            async with session.get(
                api_account,
                headers=account_api_headers,
                timeout=aiohttp.ClientTimeout(total=30),
            ) as resp:
                status = resp.status
                try:
                    data = await resp.json()
                except Exception:
                    text = await resp.text()
                    print(f"[{self.platform_name}] account/base non-JSON: {text[:500]}")
                    return {"data": None, "code": status, "msg": "invalid response"}
                if status != 200:
                    return {
                        "data": None,
                        "code": status,
                        "msg": data.get("msg")
                        if isinstance(data, dict)
                        else "request failed",
                    }
                return (
                    data
                    if isinstance(data, dict)
                    else {"data": None, "code": -1, "msg": "invalid response"}
                )

        async def fetch_fans_overall_new(session):
            async with session.get(
                api_fans,
                headers=fans_api_headers,
                timeout=aiohttp.ClientTimeout(total=30),
            ) as resp:
                status = resp.status
                try:
                    data = await resp.json()
                except Exception:
                    text = await resp.text()
                    print(
                        f"[{self.platform_name}] fans/overall_new non-JSON: {text[:500]}"
                    )
                    return {"data": None, "code": status, "msg": "invalid response"}
                if status != 200:
                    return {
                        "data": None,
                        "code": status,
                        "msg": data.get("msg")
                        if isinstance(data, dict)
                        else "request failed",
                    }
                return (
                    data
                    if isinstance(data, dict)
                    else {"data": None, "code": -1, "msg": "invalid response"}
                )

        async with aiohttp.ClientSession(cookies=cookie_dict) as session:
            account_base_result, fans_overall_new_result = await asyncio.gather(
                fetch_account_base(session),
                fetch_fans_overall_new(session),
            )
        return {
            "account_base": account_base_result,
            "fans_overall_new": fans_overall_new_result,
        }