功能: 重写小红书 Skills，完整迁移为 CDP Python 实现 (#1)

## 主要变更

### 核心模块重写
- 创建 scripts/xhs/ 包，包含 18 个专业模块（3728 行代码）
- 基于 xiaohongshu-mcp Go 源码完整实现
- CDP WebSocket 直接通信，替代第三方库依赖

### 模块清单
- cdp.py: Browser/Page/Element 类，完整 CDP 协议实现
- stealth.py: 反检测 JS 注入 + Chrome 启动参数
- login.py: 登录检查与二维码登录（QR 码保存到临时文件供 Agent 显示）
- publish.py: 图文发布完整流程
- publish_video.py: 视频发布完整流程
- search.py: 搜索与内容筛选
- feed_detail.py: 笔记详情与评论加载
- comment.py: 评论与回复
- like_favorite.py: 点赞与收藏
- user_profile.py: 用户主页
- cookies.py: Cookie 持久化
- types.py: 完整的 dataclass 数据类型系统
- errors.py: 自定义异常体系
- human.py: 人类行为模拟（延迟、滚动）
- selectors.py: CSS 选择器常量
- urls.py: URL 构建函数

### CLI 统一接口
- scripts/cli.py: 13 个子命令，完全兼容 xiaohongshu-mcp MCP 工具
- check-login: 检查登录状态
- login: 获取登录二维码
- switch-account/delete-cookies: 账号切换
- publish-content: 图文发布
- publish-with-video: 视频发布
- list-feeds: Feed 列表
- search-feeds: Feed 搜索
- get-feed-detail: 笔记详情
- user-profile: 用户主页
- post-comment: 发送评论
- like-feed: 点赞笔记
- favorite-feed: 收藏笔记

### 支持脚本重写
- chrome_launcher.py: Chrome 进程管理（跨平台）
- account_manager.py: 多账号 Profile 隔离
- image_downloader.py: 图片/视频下载（SHA256 缓存）
- title_utils.py: UTF-16 标题长度计算
- run_lock.py: 单实例锁机制
- publish_pipeline.py: 发布流程编排 CLI

### 文档与配置
- SKILL.md: 统一技能入口（路由到 5 个子技能）
- skills/xhs-auth/SKILL.md: 认证管理技能
- skills/xhs-publish/SKILL.md: 内容发布技能（图文+视频）
- skills/xhs-explore/SKILL.md: 内容发现与分析技能
- skills/xhs-interact/SKILL.md: 社交互动技能（评论/点赞/收藏）
- skills/xhs-content-ops/SKILL.md: 复合内容运营工作流技能
- CLAUDE.md: 项目开发指南
- PROMPT.md: Ralph Loop 驱动文件
- pyproject.toml: uv 项目配置（uv.lock）
- README.md: 完整项目文档

### 技术栈
- Python 3.11+ with uv 包管理
- requests + websockets: CDP WebSocket 通信
- 代码规范: ruff lint + format

## 对应关系
所有 13 个子命令与 xiaohongshu-mcp MCP 工具完全对应
支持 OpenClaw agent 框架直接调用

## 前置工作
- 创建 scripts/xhs/ 包架构
- 实现 CDP WebSocket 协议
- 完整的类型系统和错误处理
- CLI 子命令系统

Co-authored-by: Claude Opus 4.6 <noreply@anthropic.com>

@@ -205,3 +205,15 @@ cython_debug/
 marimo/_static/
 marimo/_static/
 marimo/_lsp/
 marimo/_lsp/
 __marimo__/
 __marimo__/
+
+# Project specific
+tmp/
+*.txt
+!requirements.txt
+config/accounts.json
+title.txt
+content.txt
+comment.txt
+
+# Ralph Loop state
+.claude/.ralph-loop.local.md

+# xiaohongshu-skills
+
+小红书自动化 Claude Code Skills，基于 Python CDP 浏览器自动化引擎。
+为 OpenClaw 生态提供小红书操作能力，同时支持 Claude Code skills 格式。
+
+## 项目结构
+
+```
+xiaohongshu-skills/
+├── scripts/                        # Python CDP 自动化引擎
+│   ├── xhs/                        # 核心 XHS 自动化包
+│   │   ├── __init__.py
+│   │   ├── cdp.py                  # CDP WebSocket 客户端（Browser, Page, Element）
+│   │   ├── stealth.py              # 反检测 JS 注入 + Chrome 启动参数
+│   │   ├── cookies.py              # Cookie 文件持久化
+│   │   ├── types.py                # 数据类型（dataclass）
+│   │   ├── errors.py               # 异常体系
+│   │   ├── selectors.py            # CSS 选择器常量
+│   │   ├── urls.py                 # URL 常量和构建函数
+│   │   ├── human.py                # 人类行为模拟（延迟、滚动）
+│   │   ├── login.py                # 登录检查、二维码登录
+│   │   ├── feeds.py                # 首页 Feed 列表
+│   │   ├── search.py               # 搜索 + 筛选
+│   │   ├── feed_detail.py          # 笔记详情 + 评论加载
+│   │   ├── user_profile.py         # 用户主页
+│   │   ├── comment.py              # 评论、回复
+│   │   ├── like_favorite.py        # 点赞、收藏
+│   │   ├── publish.py              # 图文发布
+│   │   └── publish_video.py        # 视频发布
+│   ├── cli.py                      # 统一 CLI 入口（13 个子命令）
+│   ├── chrome_launcher.py          # Chrome 进程管理
+│   ├── account_manager.py          # 多账号管理
+│   ├── image_downloader.py         # 媒体下载（SHA256 缓存）
+│   ├── title_utils.py              # UTF-16 标题长度计算
+│   ├── run_lock.py                 # 单实例锁
+│   └── publish_pipeline.py         # 发布编排器
+├── skills/                         # Claude Code Skills 定义
+│   ├── xhs-auth/SKILL.md           # 认证管理
+│   ├── xhs-publish/SKILL.md        # 内容发布（图文+视频）
+│   ├── xhs-explore/SKILL.md        # 内容发现与分析
+│   ├── xhs-interact/SKILL.md       # 社交互动（评论/点赞/收藏）
+│   └── xhs-content-ops/SKILL.md    # 复合内容运营工作流
+├── pyproject.toml                  # uv 项目配置
+├── SKILL.md                        # 统一入口（路由到子技能）
+├── CLAUDE.md                       # 本文件
+├── PROMPT.md                       # Ralph Loop 驱动文件
+└── README.md
+```
+
+## 技术栈
+
+- **Python**: >=3.11
+- **包管理**: uv
+- **依赖**: requests + websockets（直接 CDP WebSocket 通信）
+- **浏览器**: Chrome（通过 CDP 远程调试协议控制）
+- **代码规范**: ruff（lint + format）
+- **数据提取**: `window.__INITIAL_STATE__`（与 Go 源码一致）
+
+## 开发命令
+
+```bash
+uv sync                    # 安装依赖
+uv run ruff check .        # Lint 检查
+uv run ruff format .       # 代码格式化
+uv run pytest              # 运行测试
+```
+
+## 架构设计
+
+### 双层结构
+
+1. **scripts/ — Python CDP 引擎**
+   - 基于 xiaohongshu-mcp Go 源码从零重写
+   - `xhs/` 包：模块化的核心自动化库
+   - `cli.py`：统一 CLI 入口，13 个子命令对应 MCP 工具
+   - JSON 结构化输出，便于 agent 解析
+   - 多账号支持，独立 Chrome Profile 隔离
+   - 反检测保护（stealth flags + JS 注入）
+
+2. **skills/ — Claude Code Skills 定义**
+   - SKILL.md 格式，指导 Claude 如何调用 scripts/
+   - 包含输入判断、约束规则、工作流程、失败处理
+
+### 调用方式
+
+```bash
+# 统一 CLI 入口
+python scripts/cli.py check-login
+python scripts/cli.py search-feeds --keyword "关键词"
+python scripts/cli.py publish --title-file t.txt --content-file c.txt --images pic.jpg
+
+# 发布流水线（含图片下载和登录检查）
+python scripts/publish_pipeline.py --title-file t.txt --content-file c.txt --images URL1
+```
+
+## 代码规范
+
+### Python 风格
+- 遵循 PEP 8，使用 ruff 强制执行
+- 完整的 type hints（PEP 484），使用 `str | None` 语法
+- 公共函数和类必须有 docstring
+- 行长度上限 100 字符
+- 使用 `from __future__ import annotations` 启用延迟注解
+
+### 命名约定
+- 文件名：snake_case
+- 类名：PascalCase
+- 函数/变量：snake_case
+- 常量：UPPER_SNAKE_CASE
+
+### 错误处理
+- 自定义异常类继承自 `XHSError` 基类（`xhs/errors.py`）
+- CLI 命令使用结构化 exit code：0=成功，1=未登录，2=错误
+- 所有用户可见的错误信息使用中文
+
+### 安全约束
+- 发布类操作必须有用户确认机制
+- 文件路径必须使用绝对路径
+- 不在命令行参数中内联敏感内容（使用文件传递）
+- Chrome Profile 目录隔离账号 cookies
+
+## 参考资源
+
+- **xiaohongshu-mcp Go 源码**: /Users/zy/src/zy/xiaohongshu-mcp/
+
+## MCP 工具对照表
+
+scripts/cli.py 的 13 个子命令对应 xiaohongshu-mcp 的 MCP 工具：
+
+| CLI 子命令 | MCP 工具 | 分类 |
+|--|--|--|
+| `check-login` | check_login_status | 认证 |
+| `login` | get_login_qrcode | 认证 |
+| `delete-cookies` | delete_cookies | 认证 |
+| `list-feeds` | list_feeds | 浏览 |
+| `search-feeds` | search_feeds | 浏览 |
+| `get-feed-detail` | get_feed_detail | 浏览 |
+| `user-profile` | user_profile | 浏览 |
+| `post-comment` | post_comment_to_feed | 互动 |
+| `reply-comment` | reply_comment_in_feed | 互动 |
+| `like-feed` | like_feed | 互动 |
+| `favorite-feed` | favorite_feed | 互动 |
+| `publish` | publish_content | 发布 |
+| `publish-video` | publish_with_video | 发布 |

+# 小红书 Skills 开发任务
+
+## 目标
+
+基于 xiaohongshu-mcp Go 源码，从零重写 Python CDP 引擎，为 OpenClaw 生态构建完整的小红书自动化 Skills。
+
+## 参考资料
+
+- **xiaohongshu-mcp Go 源码**: `/Users/zy/src/zy/xiaohongshu-mcp/` — 10k stars，13 个 MCP 工具
+- **xiaohongshu-mcp 数据结构**: `/Users/zy/src/zy/xiaohongshu-mcp/xiaohongshu/types.go`
+- **xiaohongshu-mcp 工具定义**: `/Users/zy/src/zy/xiaohongshu-mcp/mcp_server.go`
+
+## 架构
+
+### 模块结构
+
+```
+scripts/
+├── xhs/                        # 核心 XHS 自动化包
+│   ├── cdp.py                  # CDP WebSocket 客户端
+│   ├── stealth.py              # 反检测 JS 注入 + Chrome 启动参数
+│   ├── cookies.py              # Cookie 文件持久化
+│   ├── types.py                # 数据类型（dataclass）
+│   ├── errors.py               # 异常体系
+│   ├── selectors.py            # CSS 选择器常量
+│   ├── urls.py                 # URL 常量
+│   ├── human.py                # 人类行为模拟
+│   ├── login.py                # 登录
+│   ├── feeds.py                # 首页 Feed
+│   ├── search.py               # 搜索 + 筛选
+│   ├── feed_detail.py          # 笔记详情 + 评论加载
+│   ├── user_profile.py         # 用户主页
+│   ├── comment.py              # 评论、回复
+│   ├── like_favorite.py        # 点赞、收藏
+│   ├── publish.py              # 图文发布
+│   └── publish_video.py        # 视频发布
+├── cli.py                      # 统一 CLI 入口（13 个子命令）
+├── chrome_launcher.py          # Chrome 进程管理
+├── account_manager.py          # 多账号管理
+├── image_downloader.py         # 媒体下载（SHA256 缓存）
+├── title_utils.py              # UTF-16 标题长度计算
+├── run_lock.py                 # 单实例锁
+└── publish_pipeline.py         # 发布编排器
+```
+
+### CLI 接口（对应 Go 的 13 个 MCP 工具）
+
+```bash
+python scripts/cli.py check-login
+python scripts/cli.py login
+python scripts/cli.py delete-cookies
+python scripts/cli.py list-feeds
+python scripts/cli.py search-feeds --keyword "关键词" [--sort-by --note-type ...]
+python scripts/cli.py get-feed-detail --feed-id ID --xsec-token TOKEN [--load-all-comments]
+python scripts/cli.py user-profile --user-id ID --xsec-token TOKEN
+python scripts/cli.py post-comment --feed-id ID --xsec-token TOKEN --content "内容"
+python scripts/cli.py reply-comment --feed-id ID --xsec-token TOKEN --content "内容" [--comment-id | --user-id]
+python scripts/cli.py like-feed --feed-id ID --xsec-token TOKEN [--unlike]
+python scripts/cli.py favorite-feed --feed-id ID --xsec-token TOKEN [--unfavorite]
+python scripts/cli.py publish --title-file T --content-file C --images P1 P2 [--tags --schedule-at --visibility]
+python scripts/cli.py publish-video --title-file T --content-file C --video P [--tags --schedule-at]
+```
+
+全局选项：`--host`, `--port`, `--account`
+输出：JSON（`ensure_ascii=False`）
+退出码：0=成功，1=未登录，2=错误
+
+## 代码规范要求
+
+- Python 代码必须通过 `ruff check` 和 `ruff format`
+- 完整的 type hints（PEP 484），使用 `str | None` 而非 `Optional[str]`
+- 公共函数和类必须有 docstring
+- 行长度上限 100 字符
+- 使用 `from __future__ import annotations` 启用延迟注解
+- 异常类统一继承自 `XHSError`
+- CLI 使用 argparse，exit code: 0=成功，1=未登录，2=错误
+- JSON 输出使用 `ensure_ascii=False` 保留中文
+
+## 完成标志
+
+当以下条件全部满足时，输出完成标志：
+1. `xhs/` 包 17 个模块已全部创建
+2. `cli.py` 13 个子命令已实现
+3. 5 个支撑脚本已重写
+4. 5 个 `skills/*/SKILL.md` 已更新
+5. 根目录 `SKILL.md`、`CLAUDE.md`、`README.md` 已更新
+6. `uv run ruff check .` 无错误
+7. `uv run ruff format --check .` 无差异
+
+<promise>ALL SKILLS COMPLETE</promise>

 # xiaohongshu-skills
 # xiaohongshu-skills
-xiaohongshu-skills
+
+小红书自动化 Claude Code Skills，基于 Python CDP 浏览器自动化引擎。
+
+为 OpenClaw 生态提供小红书操作能力，同时兼容 Claude Code Skills 格式。
+
+## 功能概览
+
+| 技能 | 说明 | 核心命令 |
+|------|------|----------|
+| **xhs-auth** | 认证管理 | `check-login`, `login`, `delete-cookies` |
+| **xhs-publish** | 内容发布 | `publish`, `publish-video` |
+| **xhs-explore** | 内容发现 | `list-feeds`, `search-feeds`, `get-feed-detail`, `user-profile` |
+| **xhs-interact** | 社交互动 | `post-comment`, `reply-comment`, `like-feed`, `favorite-feed` |
+| **xhs-content-ops** | 复合运营 | 竞品分析、热点追踪、内容创作、互动管理 |
+
+## 安装
+
+```bash
+# 克隆项目
+git clone https://github.com/autoclaw-cc/xiaohongshu-skills.git
+cd xiaohongshu-skills
+
+# 安装依赖（需要 uv）
+uv sync
+```
+
+### 前置条件
+
+- Python >= 3.11
+- [uv](https://docs.astral.sh/uv/) 包管理器
+- Google Chrome 浏览器
+
+## 快速开始
+
+### 1. 启动 Chrome
+
+```bash
+# 有窗口模式（推荐首次登录）
+python scripts/chrome_launcher.py
+
+# 无头模式
+python scripts/chrome_launcher.py --headless
+```
+
+### 2. 登录小红书
+
+```bash
+# 检查登录状态
+python scripts/cli.py check-login
+
+# 登录（扫码）
+python scripts/cli.py login
+```
+
+### 3. 搜索笔记
+
+```bash
+python scripts/cli.py search-feeds --keyword "关键词"
+
+# 带筛选
+python scripts/cli.py search-feeds \
+  --keyword "关键词" --sort-by 最新 --note-type 图文
+```
+
+### 4. 查看笔记详情
+
+```bash
+python scripts/cli.py get-feed-detail \
+  --feed-id FEED_ID --xsec-token XSEC_TOKEN
+```
+
+### 5. 发布内容
+
+```bash
+# 图文发布
+python scripts/cli.py publish \
+  --title-file title.txt \
+  --content-file content.txt \
+  --images "/abs/path/pic1.jpg" "/abs/path/pic2.jpg"
+
+# 视频发布
+python scripts/cli.py publish-video \
+  --title-file title.txt \
+  --content-file content.txt \
+  --video "/abs/path/video.mp4"
+```
+
+### 6. 社交互动
+
+```bash
+# 发表评论
+python scripts/cli.py post-comment \
+  --feed-id FEED_ID \
+  --xsec-token XSEC_TOKEN \
+  --content "评论内容"
+
+# 点赞
+python scripts/cli.py like-feed \
+  --feed-id FEED_ID --xsec-token XSEC_TOKEN
+
+# 收藏
+python scripts/cli.py favorite-feed \
+  --feed-id FEED_ID --xsec-token XSEC_TOKEN
+```
+
+## CLI 命令参考
+
+所有命令通过 `scripts/cli.py` 统一入口调用，输出 JSON 格式。
+
+全局选项：
+- `--host HOST` — Chrome 调试主机（默认 127.0.0.1）
+- `--port PORT` — Chrome 调试端口（默认 9222）
+- `--account NAME` — 指定账号
+
+| 子命令 | 说明 |
+|--------|------|
+| `check-login` | 检查登录状态 |
+| `login` | 获取登录二维码，等待扫码 |
+| `delete-cookies` | 清除 cookies |
+| `list-feeds` | 获取首页推荐 Feed |
+| `search-feeds` | 关键词搜索笔记 |
+| `get-feed-detail` | 获取笔记详情和评论 |
+| `user-profile` | 获取用户主页信息 |
+| `post-comment` | 对笔记发表评论 |
+| `reply-comment` | 回复指定评论 |
+| `like-feed` | 点赞 / 取消点赞 |
+| `favorite-feed` | 收藏 / 取消收藏 |
+| `publish` | 发布图文内容 |
+| `publish-video` | 发布视频内容 |
+
+退出码：0=成功，1=未登录，2=错误
+
+## 项目结构
+
+```
+xiaohongshu-skills/
+├── scripts/                        # Python CDP 自动化引擎
+│   ├── xhs/                        # 核心自动化包（模块化）
+│   │   ├── cdp.py                  # CDP WebSocket 客户端
+│   │   ├── stealth.py              # 反检测保护
+│   │   ├── cookies.py              # Cookie 持久化
+│   │   ├── types.py                # 数据类型
+│   │   ├── errors.py               # 异常体系
+│   │   ├── selectors.py            # CSS 选择器
+│   │   ├── urls.py                 # URL 常量
+│   │   ├── human.py                # 人类行为模拟
+│   │   ├── login.py                # 登录
+│   │   ├── feeds.py                # 首页 Feed
+│   │   ├── search.py               # 搜索
+│   │   ├── feed_detail.py          # 笔记详情
+│   │   ├── user_profile.py         # 用户主页
+│   │   ├── comment.py              # 评论
+│   │   ├── like_favorite.py        # 点赞/收藏
+│   │   ├── publish.py              # 图文发布
+│   │   └── publish_video.py        # 视频发布
+│   ├── cli.py                      # 统一 CLI（13 个子命令）
+│   ├── chrome_launcher.py          # Chrome 进程管理
+│   ├── account_manager.py          # 多账号管理
+│   ├── image_downloader.py         # 媒体下载
+│   ├── title_utils.py              # 标题长度计算
+│   ├── run_lock.py                 # 单实例锁
+│   └── publish_pipeline.py         # 发布编排器
+├── skills/                         # Claude Code Skills 定义
+│   ├── xhs-auth/SKILL.md           # 认证管理
+│   ├── xhs-publish/SKILL.md        # 内容发布
+│   ├── xhs-explore/SKILL.md        # 内容发现
+│   ├── xhs-interact/SKILL.md       # 社交互动
+│   └── xhs-content-ops/SKILL.md    # 复合运营
+├── SKILL.md                        # 统一入口
+├── CLAUDE.md                       # 项目开发指南
+├── pyproject.toml                  # uv 项目配置
+└── README.md
+```
+
+## 技术架构
+
+### 双层结构
+
+1. **scripts/ — Python CDP 引擎**
+   - 基于 xiaohongshu-mcp Go 源码从零重写
+   - 通过 Chrome DevTools Protocol (CDP) 直接控制浏览器
+   - 数据提取使用 `window.__INITIAL_STATE__` 模式
+   - 内置反检测保护（stealth flags + JS 注入）
+   - JSON 结构化输出
+
+2. **skills/ — Claude Code Skills 定义**
+   - SKILL.md 格式，指导 AI agent 如何调用 scripts/
+   - 包含输入判断、约束规则、工作流程、失败处理
+
+## 开发
+
+```bash
+uv sync                    # 安装依赖
+uv run ruff check .        # Lint 检查
+uv run ruff format .       # 代码格式化
+uv run pytest              # 运行测试
+```

+---
+name: xiaohongshu-skills
+description: |
+  小红书自动化技能集合。支持认证登录、内容发布、搜索发现、社交互动、复合运营。
+  当用户要求操作小红书（发布、搜索、评论、登录、分析、点赞、收藏）时触发。
+---
+
+# 小红书自动化 Skills
+
+你是"小红书自动化助手"。根据用户意图路由到对应的子技能完成任务。
+
+## 输入判断
+
+按优先级判断用户意图，路由到对应子技能：
+
+1. **认证相关**（"登录 / 检查登录 / 切换账号"）→ 执行 `xhs-auth` 技能。
+2. **内容发布**（"发布 / 发帖 / 上传图文 / 上传视频"）→ 执行 `xhs-publish` 技能。
+3. **搜索发现**（"搜索笔记 / 查看详情 / 浏览首页 / 查看用户"）→ 执行 `xhs-explore` 技能。
+4. **社交互动**（"评论 / 回复 / 点赞 / 收藏"）→ 执行 `xhs-interact` 技能。
+5. **复合运营**（"竞品分析 / 热点追踪 / 批量互动 / 一键创作"）→ 执行 `xhs-content-ops` 技能。
+
+## 全局约束
+
+- 所有操作前应确认登录状态（通过 `check-login`）。
+- 发布和评论操作必须经过用户确认后才能执行。
+- 文件路径必须使用绝对路径。
+- CLI 输出为 JSON 格式，结构化呈现给用户。
+- 操作频率不宜过高，保持合理间隔。
+
+## 子技能概览
+
+### xhs-auth — 认证管理
+
+管理小红书登录状态和多账号切换。
+
+| 命令 | 功能 |
+|------|------|
+| `cli.py check-login` | 检查登录状态 |
+| `cli.py login` | 获取登录二维码，等待扫码 |
+| `cli.py delete-cookies` | 清除 cookies（退出/切换账号） |
+
+### xhs-publish — 内容发布
+
+发布图文或视频内容到小红书。
+
+| 命令 | 功能 |
+|------|------|
+| `cli.py publish` | 图文发布（本地图片或 URL） |
+| `cli.py publish-video` | 视频发布 |
+| `publish_pipeline.py` | 发布流水线（含图片下载和登录检查） |
+
+### xhs-explore — 内容发现
+
+搜索笔记、查看详情、获取用户资料。
+
+| 命令 | 功能 |
+|------|------|
+| `cli.py list-feeds` | 获取首页推荐 Feed |
+| `cli.py search-feeds` | 关键词搜索笔记 |
+| `cli.py get-feed-detail` | 获取笔记完整内容和评论 |
+| `cli.py user-profile` | 获取用户主页信息 |
+
+### xhs-interact — 社交互动
+
+发表评论、回复、点赞、收藏。
+
+| 命令 | 功能 |
+|------|------|
+| `cli.py post-comment` | 对笔记发表评论 |
+| `cli.py reply-comment` | 回复指定评论 |
+| `cli.py like-feed` | 点赞 / 取消点赞 |
+| `cli.py favorite-feed` | 收藏 / 取消收藏 |
+
+### xhs-content-ops — 复合运营
+
+组合多步骤完成运营工作流：竞品分析、热点追踪、内容创作、互动管理。
+
+## 快速开始
+
+```bash
+# 1. 启动 Chrome
+python scripts/chrome_launcher.py
+
+# 2. 检查登录状态
+python scripts/cli.py check-login
+
+# 3. 登录（如需要）
+python scripts/cli.py login
+
+# 4. 搜索笔记
+python scripts/cli.py search-feeds --keyword "关键词"
+
+# 5. 查看笔记详情
+python scripts/cli.py get-feed-detail \
+  --feed-id FEED_ID --xsec-token XSEC_TOKEN
+
+# 6. 发布图文
+python scripts/cli.py publish \
+  --title-file title.txt \
+  --content-file content.txt \
+  --images "/abs/path/pic1.jpg"
+
+# 7. 发表评论
+python scripts/cli.py post-comment \
+  --feed-id FEED_ID \
+  --xsec-token XSEC_TOKEN \
+  --content "评论内容"
+
+# 8. 点赞
+python scripts/cli.py like-feed \
+  --feed-id FEED_ID --xsec-token XSEC_TOKEN
+```
+
+## 失败处理
+
+- **未登录**：提示用户执行登录流程（xhs-auth）。
+- **Chrome 未启动**：使用 `chrome_launcher.py` 启动浏览器。
+- **操作超时**：检查网络连接，适当增加等待时间。
+- **频率限制**：降低操作频率，增大间隔。

+[project]
+name = "xiaohongshu-skills"
+version = "0.1.0"
+description = "小红书自动化 Skills，基于 CDP 浏览器自动化"
+readme = "README.md"
+license = { text = "MIT" }
+requires-python = ">=3.11"
+dependencies = [
+    "requests>=2.28.0",
+    "websockets>=12.0",
+]
+
+[project.optional-dependencies]
+dev = [
+    "ruff>=0.9.0",
+    "pytest>=8.0",
+]
+
+[tool.ruff]
+target-version = "py311"
+line-length = 100
+
+[tool.ruff.lint]
+select = [
+    "E",    # pycodestyle errors
+    "W",    # pycodestyle warnings
+    "F",    # pyflakes
+    "I",    # isort
+    "N",    # pep8-naming
+    "UP",   # pyupgrade
+    "B",    # flake8-bugbear
+    "SIM",  # flake8-simplify
+    "RUF",  # ruff-specific rules
+]
+ignore = [
+    "E402",   # module-level imports not at top (needed for sys.path manipulation)
+    "RUF001", # ambiguous unicode characters (Chinese punctuation is intentional)
+    "RUF002", # ambiguous unicode in docstrings (Chinese punctuation is intentional)
+    "RUF003", # ambiguous unicode in comments (Chinese punctuation is intentional)
+]
+
+[tool.ruff.lint.per-file-ignores]
+
+[tool.ruff.lint.isort]
+known-first-party = ["xiaohongshu_skills"]
+
+[tool.pytest.ini_options]
+testpaths = ["tests"]

+"""多账号管理，对应独立的账号配置管理。"""
+
+from __future__ import annotations
+
+import json
+import logging
+import os
+from pathlib import Path
+
+logger = logging.getLogger(__name__)
+
+# 账号配置文件路径
+_CONFIG_DIR = Path.home() / ".xhs"
+_ACCOUNTS_FILE = _CONFIG_DIR / "accounts.json"
+
+
+def _load_config() -> dict:
+    """加载账号配置。"""
+    if not _ACCOUNTS_FILE.exists():
+        return {"default": "", "accounts": {}}
+    with open(_ACCOUNTS_FILE, encoding="utf-8") as f:
+        return json.load(f)
+
+
+def _save_config(config: dict) -> None:
+    """保存账号配置。"""
+    _CONFIG_DIR.mkdir(parents=True, exist_ok=True)
+    with open(_ACCOUNTS_FILE, "w", encoding="utf-8") as f:
+        json.dump(config, f, ensure_ascii=False, indent=2)
+
+
+def list_accounts() -> list[dict]:
+    """列出所有账号。"""
+    config = _load_config()
+    default = config.get("default", "")
+    accounts = config.get("accounts", {})
+    result = []
+    for name, info in accounts.items():
+        result.append(
+            {
+                "name": name,
+                "description": info.get("description", ""),
+                "is_default": name == default,
+                "profile_dir": _get_profile_dir(name),
+            }
+        )
+    return result
+
+
+def add_account(name: str, description: str = "") -> None:
+    """添加账号。"""
+    config = _load_config()
+    accounts = config.setdefault("accounts", {})
+    if name in accounts:
+        raise ValueError(f"账号 '{name}' 已存在")
+
+    accounts[name] = {"description": description}
+
+    # 如果是第一个账号，设为默认
+    if not config.get("default"):
+        config["default"] = name
+
+    _save_config(config)
+
+    # 创建 Profile 目录
+    profile_dir = _get_profile_dir(name)
+    os.makedirs(profile_dir, exist_ok=True)
+
+    logger.info("添加账号: %s", name)
+
+
+def remove_account(name: str) -> None:
+    """删除账号。"""
+    config = _load_config()
+    accounts = config.get("accounts", {})
+    if name not in accounts:
+        raise ValueError(f"账号 '{name}' 不存在")
+
+    del accounts[name]
+
+    # 如果删除的是默认账号，清除默认
+    if config.get("default") == name:
+        config["default"] = next(iter(accounts), "")
+
+    _save_config(config)
+    logger.info("删除账号: %s", name)
+
+
+def set_default_account(name: str) -> None:
+    """设置默认账号。"""
+    config = _load_config()
+    accounts = config.get("accounts", {})
+    if name not in accounts:
+        raise ValueError(f"账号 '{name}' 不存在")
+
+    config["default"] = name
+    _save_config(config)
+    logger.info("默认账号设置为: %s", name)
+
+
+def get_default_account() -> str:
+    """获取默认账号名称。"""
+    config = _load_config()
+    return config.get("default", "")
+
+
+def _get_profile_dir(account: str) -> str:
+    """获取账号的 Chrome Profile 目录。"""
+    return str(_CONFIG_DIR / "accounts" / account / "chrome-profile")

+"""Chrome 进程管理（跨平台），对应 Go browser/browser.go 的进程管理部分。"""
+
+from __future__ import annotations
+
+import logging
+import os
+import platform
+import shutil
+import signal
+import subprocess
+import time
+
+from xhs.stealth import STEALTH_ARGS
+
+logger = logging.getLogger(__name__)
+
+# 默认远程调试端口
+DEFAULT_PORT = 9222
+
+# 各平台 Chrome 默认路径
+_CHROME_PATHS: dict[str, list[str]] = {
+    "Darwin": [
+        "/Applications/Google Chrome.app/Contents/MacOS/Google Chrome",
+        "/Applications/Chromium.app/Contents/MacOS/Chromium",
+    ],
+    "Linux": [
+        "/usr/bin/google-chrome",
+        "/usr/bin/google-chrome-stable",
+        "/usr/bin/chromium",
+        "/usr/bin/chromium-browser",
+        "/snap/bin/chromium",
+    ],
+    "Windows": [
+        r"C:\Program Files\Google\Chrome\Application\chrome.exe",
+        r"C:\Program Files (x86)\Google\Chrome\Application\chrome.exe",
+    ],
+}
+
+
+def find_chrome() -> str | None:
+    """查找 Chrome 可执行文件路径。"""
+    # 环境变量优先
+    env_path = os.getenv("CHROME_BIN")
+    if env_path and os.path.isfile(env_path):
+        return env_path
+
+    # which/where 查找
+    chrome = shutil.which("google-chrome") or shutil.which("chromium")
+    if chrome:
+        return chrome
+
+    # 平台默认路径
+    system = platform.system()
+    for path in _CHROME_PATHS.get(system, []):
+        if os.path.isfile(path):
+            return path
+
+    return None
+
+
+def launch_chrome(
+    port: int = DEFAULT_PORT,
+    headless: bool = False,
+    user_data_dir: str | None = None,
+    chrome_bin: str | None = None,
+) -> subprocess.Popen:
+    """启动 Chrome 进程（带远程调试端口）。
+
+    Args:
+        port: 远程调试端口。
+        headless: 是否无头模式。
+        user_data_dir: 用户数据目录（Profile 隔离）。
+        chrome_bin: Chrome 可执行文件路径。
+
+    Returns:
+        Chrome 子进程。
+
+    Raises:
+        FileNotFoundError: 未找到 Chrome。
+    """
+    if not chrome_bin:
+        chrome_bin = find_chrome()
+    if not chrome_bin:
+        raise FileNotFoundError("未找到 Chrome，请设置 CHROME_BIN 环境变量或安装 Chrome")
+
+    args = [
+        chrome_bin,
+        f"--remote-debugging-port={port}",
+        *STEALTH_ARGS,
+    ]
+
+    if headless:
+        args.append("--headless=new")
+
+    if user_data_dir:
+        args.append(f"--user-data-dir={user_data_dir}")
+
+    # 代理
+    proxy = os.getenv("XHS_PROXY")
+    if proxy:
+        args.append(f"--proxy-server={proxy}")
+        logger.info("使用代理: %s", _mask_proxy(proxy))
+
+    logger.info("启动 Chrome: port=%d, headless=%s", port, headless)
+    process = subprocess.Popen(
+        args,
+        stdout=subprocess.DEVNULL,
+        stderr=subprocess.DEVNULL,
+    )
+
+    # 等待 Chrome 准备就绪
+    _wait_for_chrome(port)
+    return process
+
+
+def close_chrome(process: subprocess.Popen) -> None:
+    """关闭 Chrome 进程。"""
+    if process.poll() is not None:
+        return
+
+    try:
+        process.send_signal(signal.SIGTERM)
+        process.wait(timeout=5)
+    except (subprocess.TimeoutExpired, OSError):
+        process.kill()
+        process.wait(timeout=3)
+
+    logger.info("Chrome 进程已关闭")
+
+
+def is_chrome_running(port: int = DEFAULT_PORT) -> bool:
+    """检查指定端口的 Chrome 是否在运行。"""
+    import requests
+
+    try:
+        resp = requests.get(f"http://127.0.0.1:{port}/json/version", timeout=2)
+        return resp.status_code == 200
+    except (requests.ConnectionError, requests.Timeout):
+        return False
+
+
+def _wait_for_chrome(port: int, timeout: float = 15.0) -> None:
+    """等待 Chrome 调试端口就绪。"""
+    deadline = time.monotonic() + timeout
+    while time.monotonic() < deadline:
+        if is_chrome_running(port):
+            logger.info("Chrome 已就绪 (port=%d)", port)
+            return
+        time.sleep(0.5)
+    logger.warning("等待 Chrome 就绪超时 (port=%d)", port)
+
+
+def _mask_proxy(proxy_url: str) -> str:
+    """隐藏代理 URL 中的敏感信息。"""
+    from urllib.parse import urlparse
+
+    try:
+        parsed = urlparse(proxy_url)
+        if parsed.username:
+            return proxy_url.replace(parsed.username, "***").replace(parsed.password or "", "***")
+    except Exception:
+        pass
+    return proxy_url

+"""统一 CLI 入口，对应 Go MCP 工具的 13 个子命令。
+
+全局选项: --host, --port, --account
+输出: JSON（ensure_ascii=False）
+退出码: 0=成功, 1=未登录, 2=错误
+"""
+
+from __future__ import annotations
+
+import argparse
+import json
+import logging
+import sys
+
+logging.basicConfig(
+    level=logging.INFO,
+    format="%(asctime)s %(levelname)s %(name)s: %(message)s",
+)
+logger = logging.getLogger("xhs-cli")
+
+
+def _output(data: dict, exit_code: int = 0) -> None:
+    """输出 JSON 并退出。"""
+    print(json.dumps(data, ensure_ascii=False, indent=2))
+    sys.exit(exit_code)
+
+
+def _connect(args: argparse.Namespace):
+    """连接到 Chrome 并返回 (browser, page)。"""
+    from xhs.cdp import Browser
+
+    browser = Browser(host=args.host, port=args.port)
+    browser.connect()
+    page = browser.new_page()
+    return browser, page
+
+
+# ========== 子命令实现 ==========
+
+
+def cmd_check_login(args: argparse.Namespace) -> None:
+    """检查登录状态。"""
+    from xhs.login import check_login_status
+
+    browser, page = _connect(args)
+    try:
+        logged_in = check_login_status(page)
+        _output({"logged_in": logged_in}, exit_code=0 if logged_in else 1)
+    finally:
+        browser.close_page(page)
+        browser.close()
+
+
+def cmd_login(args: argparse.Namespace) -> None:
+    """获取登录二维码并等待扫码。"""
+    from xhs.login import fetch_qrcode, save_qrcode_to_file, wait_for_login
+
+    browser, page = _connect(args)
+    try:
+        src, already = fetch_qrcode(page)
+        if already:
+            _output({"logged_in": True, "message": "已登录"})
+        else:
+            # 保存二维码到临时文件
+            qrcode_path = save_qrcode_to_file(src)
+            print(
+                json.dumps(
+                    {
+                        "qrcode_path": qrcode_path,
+                        "message": "请扫码登录，二维码已保存到文件",
+                    },
+                    ensure_ascii=False,
+                )
+            )
+            success = wait_for_login(page, timeout=120)
+            _output(
+                {"logged_in": success, "message": "登录成功" if success else "登录超时"},
+                exit_code=0 if success else 2,
+            )
+    finally:
+        browser.close_page(page)
+        browser.close()
+
+
+def cmd_delete_cookies(args: argparse.Namespace) -> None:
+    """删除 cookies。"""
+    from xhs.cookies import delete_cookies, get_cookies_file_path
+
+    path = get_cookies_file_path(args.account)
+    delete_cookies(path)
+    _output({"success": True, "message": f"已删除 cookies: {path}"})
+
+
+def cmd_list_feeds(args: argparse.Namespace) -> None:
+    """获取首页 Feed 列表。"""
+    from xhs.feeds import list_feeds
+
+    browser, page = _connect(args)
+    try:
+        feeds = list_feeds(page)
+        _output({"feeds": [f.to_dict() for f in feeds], "count": len(feeds)})
+    finally:
+        browser.close_page(page)
+        browser.close()
+
+
+def cmd_search_feeds(args: argparse.Namespace) -> None:
+    """搜索 Feeds。"""
+    from xhs.search import search_feeds
+    from xhs.types import FilterOption
+
+    filter_opt = FilterOption(
+        sort_by=args.sort_by or "",
+        note_type=args.note_type or "",
+        publish_time=args.publish_time or "",
+        search_scope=args.search_scope or "",
+        location=args.location or "",
+    )
+
+    browser, page = _connect(args)
+    try:
+        feeds = search_feeds(page, args.keyword, filter_opt)
+        _output({"feeds": [f.to_dict() for f in feeds], "count": len(feeds)})
+    finally:
+        browser.close_page(page)
+        browser.close()
+
+
+def cmd_get_feed_detail(args: argparse.Namespace) -> None:
+    """获取 Feed 详情。"""
+    from xhs.feed_detail import get_feed_detail
+    from xhs.types import CommentLoadConfig
+
+    config = CommentLoadConfig(
+        click_more_replies=args.click_more_replies,
+        max_replies_threshold=args.max_replies_threshold,
+        max_comment_items=args.max_comment_items,
+        scroll_speed=args.scroll_speed,
+    )
+
+    browser, page = _connect(args)
+    try:
+        detail = get_feed_detail(
+            page,
+            args.feed_id,
+            args.xsec_token,
+            load_all_comments=args.load_all_comments,
+            config=config,
+        )
+        _output(detail.to_dict())
+    finally:
+        browser.close_page(page)
+        browser.close()
+
+
+def cmd_user_profile(args: argparse.Namespace) -> None:
+    """获取用户主页。"""
+    from xhs.user_profile import get_user_profile
+
+    browser, page = _connect(args)
+    try:
+        profile = get_user_profile(page, args.user_id, args.xsec_token)
+        _output(profile.to_dict())
+    finally:
+        browser.close_page(page)
+        browser.close()
+
+
+def cmd_post_comment(args: argparse.Namespace) -> None:
+    """发表评论。"""
+    from xhs.comment import post_comment
+
+    browser, page = _connect(args)
+    try:
+        post_comment(page, args.feed_id, args.xsec_token, args.content)
+        _output({"success": True, "message": "评论发送成功"})
+    finally:
+        browser.close_page(page)
+        browser.close()
+
+
+def cmd_reply_comment(args: argparse.Namespace) -> None:
+    """回复评论。"""
+    from xhs.comment import reply_comment
+
+    browser, page = _connect(args)
+    try:
+        reply_comment(
+            page,
+            args.feed_id,
+            args.xsec_token,
+            args.content,
+            comment_id=args.comment_id or "",
+            user_id=args.user_id or "",
+        )
+        _output({"success": True, "message": "回复成功"})
+    finally:
+        browser.close_page(page)
+        browser.close()
+
+
+def cmd_like_feed(args: argparse.Namespace) -> None:
+    """点赞/取消点赞。"""
+    from xhs.like_favorite import like_feed, unlike_feed
+
+    browser, page = _connect(args)
+    try:
+        if args.unlike:
+            result = unlike_feed(page, args.feed_id, args.xsec_token)
+        else:
+            result = like_feed(page, args.feed_id, args.xsec_token)
+        _output(result.to_dict())
+    finally:
+        browser.close_page(page)
+        browser.close()
+
+
+def cmd_favorite_feed(args: argparse.Namespace) -> None:
+    """收藏/取消收藏。"""
+    from xhs.like_favorite import favorite_feed, unfavorite_feed
+
+    browser, page = _connect(args)
+    try:
+        if args.unfavorite:
+            result = unfavorite_feed(page, args.feed_id, args.xsec_token)
+        else:
+            result = favorite_feed(page, args.feed_id, args.xsec_token)
+        _output(result.to_dict())
+    finally:
+        browser.close_page(page)
+        browser.close()
+
+
+def cmd_publish(args: argparse.Namespace) -> None:
+    """发布图文内容。"""
+    from image_downloader import process_images
+    from xhs.publish import publish_image_content
+    from xhs.types import PublishImageContent
+
+    # 读取标题和正文
+    with open(args.title_file, encoding="utf-8") as f:
+        title = f.read().strip()
+    with open(args.content_file, encoding="utf-8") as f:
+        content = f.read().strip()
+
+    # 处理图片
+    image_paths = process_images(args.images) if args.images else []
+    if not image_paths:
+        _output({"success": False, "error": "没有有效的图片"}, exit_code=2)
+
+    browser, page = _connect(args)
+    try:
+        publish_image_content(
+            page,
+            PublishImageContent(
+                title=title,
+                content=content,
+                tags=args.tags or [],
+                image_paths=image_paths,
+                schedule_time=args.schedule_at,
+                is_original=args.original,
+                visibility=args.visibility or "",
+            ),
+        )
+        _output({"success": True, "title": title, "images": len(image_paths), "status": "发布完成"})
+    finally:
+        browser.close_page(page)
+        browser.close()
+
+
+def cmd_publish_video(args: argparse.Namespace) -> None:
+    """发布视频内容。"""
+    from xhs.publish_video import publish_video_content
+    from xhs.types import PublishVideoContent
+
+    with open(args.title_file, encoding="utf-8") as f:
+        title = f.read().strip()
+    with open(args.content_file, encoding="utf-8") as f:
+        content = f.read().strip()
+
+    browser, page = _connect(args)
+    try:
+        publish_video_content(
+            page,
+            PublishVideoContent(
+                title=title,
+                content=content,
+                tags=args.tags or [],
+                video_path=args.video,
+                schedule_time=args.schedule_at,
+                visibility=args.visibility or "",
+            ),
+        )
+        _output({"success": True, "title": title, "video": args.video, "status": "发布完成"})
+    finally:
+        browser.close_page(page)
+        browser.close()
+
+
+# ========== 参数解析 ==========
+
+
+def build_parser() -> argparse.ArgumentParser:
+    """构建 CLI 参数解析器。"""
+    parser = argparse.ArgumentParser(
+        prog="xhs-cli",
+        description="小红书自动化 CLI",
+    )
+
+    # 全局选项
+    parser.add_argument("--host", default="127.0.0.1", help="Chrome 调试主机 (default: 127.0.0.1)")
+    parser.add_argument("--port", type=int, default=9222, help="Chrome 调试端口 (default: 9222)")
+    parser.add_argument("--account", default="", help="账号名称")
+
+    subparsers = parser.add_subparsers(dest="command", required=True)
+
+    # check-login
+    sub = subparsers.add_parser("check-login", help="检查登录状态")
+    sub.set_defaults(func=cmd_check_login)
+
+    # login
+    sub = subparsers.add_parser("login", help="登录（扫码）")
+    sub.set_defaults(func=cmd_login)
+
+    # delete-cookies
+    sub = subparsers.add_parser("delete-cookies", help="删除 cookies")
+    sub.set_defaults(func=cmd_delete_cookies)
+
+    # list-feeds
+    sub = subparsers.add_parser("list-feeds", help="获取首页 Feed 列表")
+    sub.set_defaults(func=cmd_list_feeds)
+
+    # search-feeds
+    sub = subparsers.add_parser("search-feeds", help="搜索 Feeds")
+    sub.add_argument("--keyword", required=True, help="搜索关键词")
+    sub.add_argument("--sort-by", help="排序: 综合|最新|最多点赞|最多评论|最多收藏")
+    sub.add_argument("--note-type", help="类型: 不限|视频|图文")
+    sub.add_argument("--publish-time", help="时间: 不限|一天内|一周内|半年内")
+    sub.add_argument("--search-scope", help="范围: 不限|已看过|未看过|已关注")
+    sub.add_argument("--location", help="位置: 不限|同城|附近")
+    sub.set_defaults(func=cmd_search_feeds)
+
+    # get-feed-detail
+    sub = subparsers.add_parser("get-feed-detail", help="获取 Feed 详情")
+    sub.add_argument("--feed-id", required=True, help="Feed ID")
+    sub.add_argument("--xsec-token", required=True, help="xsec_token")
+    sub.add_argument("--load-all-comments", action="store_true", help="加载全部评论")
+    sub.add_argument("--click-more-replies", action="store_true", help="点击展开更多回复")
+    sub.add_argument("--max-replies-threshold", type=int, default=10, help="展开回复数阈值")
+    sub.add_argument("--max-comment-items", type=int, default=0, help="最大评论数 (0=不限)")
+    sub.add_argument("--scroll-speed", default="normal", help="滚动速度: slow|normal|fast")
+    sub.set_defaults(func=cmd_get_feed_detail)
+
+    # user-profile
+    sub = subparsers.add_parser("user-profile", help="获取用户主页")
+    sub.add_argument("--user-id", required=True, help="用户 ID")
+    sub.add_argument("--xsec-token", required=True, help="xsec_token")
+    sub.set_defaults(func=cmd_user_profile)
+
+    # post-comment
+    sub = subparsers.add_parser("post-comment", help="发表评论")
+    sub.add_argument("--feed-id", required=True, help="Feed ID")
+    sub.add_argument("--xsec-token", required=True, help="xsec_token")
+    sub.add_argument("--content", required=True, help="评论内容")
+    sub.set_defaults(func=cmd_post_comment)
+
+    # reply-comment
+    sub = subparsers.add_parser("reply-comment", help="回复评论")
+    sub.add_argument("--feed-id", required=True, help="Feed ID")
+    sub.add_argument("--xsec-token", required=True, help="xsec_token")
+    sub.add_argument("--content", required=True, help="回复内容")
+    sub.add_argument("--comment-id", help="目标评论 ID")
+    sub.add_argument("--user-id", help="目标用户 ID")
+    sub.set_defaults(func=cmd_reply_comment)
+
+    # like-feed
+    sub = subparsers.add_parser("like-feed", help="点赞")
+    sub.add_argument("--feed-id", required=True, help="Feed ID")
+    sub.add_argument("--xsec-token", required=True, help="xsec_token")
+    sub.add_argument("--unlike", action="store_true", help="取消点赞")
+    sub.set_defaults(func=cmd_like_feed)
+
+    # favorite-feed
+    sub = subparsers.add_parser("favorite-feed", help="收藏")
+    sub.add_argument("--feed-id", required=True, help="Feed ID")
+    sub.add_argument("--xsec-token", required=True, help="xsec_token")
+    sub.add_argument("--unfavorite", action="store_true", help="取消收藏")
+    sub.set_defaults(func=cmd_favorite_feed)
+
+    # publish
+    sub = subparsers.add_parser("publish", help="发布图文")
+    sub.add_argument("--title-file", required=True, help="标题文件路径")
+    sub.add_argument("--content-file", required=True, help="正文文件路径")
+    sub.add_argument("--images", nargs="+", required=True, help="图片路径/URL")
+    sub.add_argument("--tags", nargs="*", help="标签")
+    sub.add_argument("--schedule-at", help="定时发布 (ISO8601)")
+    sub.add_argument("--original", action="store_true", help="声明原创")
+    sub.add_argument("--visibility", help="可见范围")
+    sub.set_defaults(func=cmd_publish)
+
+    # publish-video
+    sub = subparsers.add_parser("publish-video", help="发布视频")
+    sub.add_argument("--title-file", required=True, help="标题文件路径")
+    sub.add_argument("--content-file", required=True, help="正文文件路径")
+    sub.add_argument("--video", required=True, help="视频文件路径")
+    sub.add_argument("--tags", nargs="*", help="标签")
+    sub.add_argument("--schedule-at", help="定时发布 (ISO8601)")
+    sub.add_argument("--visibility", help="可见范围")
+    sub.set_defaults(func=cmd_publish_video)
+
+    return parser
+
+
+def main() -> None:
+    """CLI 入口。"""
+    parser = build_parser()
+    args = parser.parse_args()
+
+    try:
+        args.func(args)
+    except Exception as e:
+        logger.error("执行失败: %s", e, exc_info=True)
+        _output({"success": False, "error": str(e)}, exit_code=2)
+
+
+if __name__ == "__main__":
+    main()

+"""媒体下载（SHA256 缓存），对应 Go pkg/downloader/images.go。"""
+
+from __future__ import annotations
+
+import hashlib
+import logging
+import os
+import time
+from urllib.parse import urlparse
+
+import requests
+
+logger = logging.getLogger(__name__)
+
+_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"
+)
+
+# 已知图片扩展名
+_IMAGE_EXTENSIONS = {".jpg", ".jpeg", ".png", ".gif", ".webp", ".bmp", ".svg"}
+
+
+def is_image_url(path: str) -> bool:
+    """判断字符串是否为图片/媒体 URL。"""
+    return path.lower().startswith(("http://", "https://"))
+
+
+class ImageDownloader:
+    """图片下载器（带 SHA256 缓存）。"""
+
+    def __init__(self, save_path: str) -> None:
+        self.save_path = save_path
+        os.makedirs(save_path, exist_ok=True)
+        self._session = requests.Session()
+        self._session.timeout = 30
+
+    def download_image(self, image_url: str) -> str:
+        """下载单张图片，返回本地文件路径。
+
+        如果文件已存在（通过 URL hash 判断），直接返回路径。
+
+        Raises:
+            ValueError: URL 格式无效。
+            RuntimeError: 下载失败。
+        """
+        if not is_image_url(image_url):
+            raise ValueError(f"无效的图片 URL: {image_url}")
+
+        # 生成文件名
+        url_hash = hashlib.sha256(image_url.encode()).hexdigest()[:16]
+        ext = self._detect_extension(image_url)
+        filename = f"img_{url_hash}_{int(time.time())}{ext}"
+        filepath = os.path.join(self.save_path, filename)
+
+        # 检查是否已有同 hash 的文件
+        existing = self._find_existing(url_hash)
+        if existing:
+            return existing
+
+        # 下载
+        parsed = urlparse(image_url)
+        headers = {
+            "User-Agent": _USER_AGENT,
+            "Referer": f"{parsed.scheme}://{parsed.hostname}/",
+        }
+
+        resp = self._session.get(image_url, headers=headers)
+        if resp.status_code != 200:
+            raise RuntimeError(f"下载失败 (status={resp.status_code}): {image_url}")
+
+        # 保存
+        with open(filepath, "wb") as f:
+            f.write(resp.content)
+
+        logger.info("下载完成: %s -> %s", image_url, filepath)
+        return filepath
+
+    def download_images(self, image_urls: list[str]) -> list[str]:
+        """批量下载图片。"""
+        paths = []
+        for url in image_urls:
+            try:
+                path = self.download_image(url)
+                paths.append(path)
+            except Exception as e:
+                logger.error("下载失败 %s: %s", url, e)
+        return paths
+
+    def _detect_extension(self, url: str) -> str:
+        """从 URL 推断文件扩展名。"""
+        parsed = urlparse(url)
+        path = parsed.path.lower()
+        for ext in _IMAGE_EXTENSIONS:
+            if path.endswith(ext):
+                return ext
+        return ".jpg"  # 默认
+
+    def _find_existing(self, url_hash: str) -> str | None:
+        """查找已有同 hash 的文件。"""
+        prefix = f"img_{url_hash}_"
+        for filename in os.listdir(self.save_path):
+            if filename.startswith(prefix):
+                return os.path.join(self.save_path, filename)
+        return None
+
+
+def process_images(images: list[str], save_dir: str | None = None) -> list[str]:
+    """处理图片列表（URL 下载，本地路径直接返回）。"""
+    if not save_dir:
+        save_dir = os.path.join(os.path.expanduser("~"), ".xhs", "images")
+
+    downloader = ImageDownloader(save_dir)
+    result = []
+
+    for img in images:
+        if is_image_url(img):
+            path = downloader.download_image(img)
+            result.append(path)
+        else:
+            # 本地路径
+            if os.path.exists(img):
+                result.append(os.path.abspath(img))
+            else:
+                logger.warning("文件不存在: %s", img)
+
+    return result

+"""发布编排器：下载 → 登录检查 → 发布 → 报告。"""
+
+from __future__ import annotations
+
+import json
+import logging
+import sys
+
+from image_downloader import process_images
+from title_utils import calc_title_length
+from xhs.cdp import Browser
+from xhs.login import check_login_status
+from xhs.publish import publish_image_content
+from xhs.publish_video import publish_video_content
+from xhs.types import PublishImageContent, PublishVideoContent
+
+logger = logging.getLogger(__name__)
+
+
+def run_publish_pipeline(
+    title: str,
+    content: str,
+    images: list[str] | None = None,
+    video: str | None = None,
+    tags: list[str] | None = None,
+    schedule_time: str | None = None,
+    is_original: bool = False,
+    visibility: str = "",
+    host: str = "127.0.0.1",
+    port: int = 9222,
+    account: str = "",
+) -> dict:
+    """执行完整发布流水线。
+
+    Returns:
+        发布结果字典。
+    """
+    # 标题长度校验
+    title_len = calc_title_length(title)
+    if title_len > 20:
+        return {"success": False, "error": f"标题长度超限: {title_len}/20"}
+
+    # 处理图片（下载 URL / 验证本地路径）
+    local_images: list[str] = []
+    if images:
+        local_images = process_images(images)
+        if not local_images:
+            return {"success": False, "error": "没有有效的图片"}
+
+    # 连接浏览器
+    browser = Browser(host=host, port=port)
+    browser.connect()
+
+    try:
+        page = browser.new_page()
+        try:
+            # 登录检查
+            if not check_login_status(page):
+                return {"success": False, "error": "未登录", "exit_code": 1}
+
+            # 发布
+            if video:
+                publish_video_content(
+                    page,
+                    PublishVideoContent(
+                        title=title,
+                        content=content,
+                        tags=tags or [],
+                        video_path=video,
+                        schedule_time=schedule_time,
+                        visibility=visibility,
+                    ),
+                )
+            else:
+                publish_image_content(
+                    page,
+                    PublishImageContent(
+                        title=title,
+                        content=content,
+                        tags=tags or [],
+                        image_paths=local_images,
+                        schedule_time=schedule_time,
+                        is_original=is_original,
+                        visibility=visibility,
+                    ),
+                )
+
+            return {
+                "success": True,
+                "title": title,
+                "content_length": len(content),
+                "images": len(local_images),
+                "video": video or "",
+                "status": "发布完成",
+            }
+
+        finally:
+            browser.close_page(page)
+    finally:
+        browser.close()
+
+
+def main() -> None:
+    """CLI 入口（被 cli.py 的 publish/publish-video 子命令调用时使用）。"""
+    import argparse
+
+    parser = argparse.ArgumentParser(description="小红书发布流水线")
+    parser.add_argument("--title-file", required=True, help="标题文件路径")
+    parser.add_argument("--content-file", required=True, help="正文文件路径")
+    parser.add_argument("--images", nargs="*", help="图片路径或 URL 列表")
+    parser.add_argument("--video", help="视频文件路径")
+    parser.add_argument("--tags", nargs="*", help="标签列表")
+    parser.add_argument("--schedule-at", help="定时发布时间 (ISO8601)")
+    parser.add_argument("--original", action="store_true", help="声明原创")
+    parser.add_argument("--visibility", default="", help="可见范围")
+    parser.add_argument("--host", default="127.0.0.1")
+    parser.add_argument("--port", type=int, default=9222)
+    parser.add_argument("--account", default="")
+    args = parser.parse_args()
+
+    # 读取标题和正文
+    with open(args.title_file, encoding="utf-8") as f:
+        title = f.read().strip()
+    with open(args.content_file, encoding="utf-8") as f:
+        content = f.read().strip()
+
+    result = run_publish_pipeline(
+        title=title,
+        content=content,
+        images=args.images,
+        video=args.video,
+        tags=args.tags,
+        schedule_time=args.schedule_at,
+        is_original=args.original,
+        visibility=args.visibility,
+        host=args.host,
+        port=args.port,
+        account=args.account,
+    )
+
+    print(json.dumps(result, ensure_ascii=False, indent=2))
+    sys.exit(0 if result["success"] else 2)
+
+
+if __name__ == "__main__":
+    main()

+"""单实例锁，防止多个进程同时操作浏览器。"""
+
+from __future__ import annotations
+
+import contextlib
+import logging
+import os
+import time
+
+logger = logging.getLogger(__name__)
+
+_DEFAULT_LOCK_FILE = os.path.join(os.path.expanduser("~"), ".xhs", "run.lock")
+
+
+class RunLock:
+    """文件锁，确保同一时间只有一个进程在操作。"""
+
+    def __init__(self, lock_file: str = _DEFAULT_LOCK_FILE) -> None:
+        self.lock_file = lock_file
+        self._fd: int | None = None
+
+    def acquire(self, timeout: float = 30.0) -> bool:
+        """获取锁。
+
+        Args:
+            timeout: 超时时间（秒）。
+
+        Returns:
+            True 获取成功，False 超时。
+        """
+        os.makedirs(os.path.dirname(self.lock_file), exist_ok=True)
+        deadline = time.monotonic() + timeout
+
+        while time.monotonic() < deadline:
+            try:
+                self._fd = os.open(
+                    self.lock_file,
+                    os.O_CREAT | os.O_EXCL | os.O_WRONLY,
+                )
+                # 写入 PID
+                os.write(self._fd, str(os.getpid()).encode())
+                logger.debug("获取锁成功: %s", self.lock_file)
+                return True
+            except FileExistsError:
+                # 检查持有者是否还活着
+                if self._is_stale():
+                    self._force_release()
+                    continue
+                time.sleep(1)
+
+        logger.warning("获取锁超时: %s", self.lock_file)
+        return False
+
+    def release(self) -> None:
+        """释放锁。"""
+        if self._fd is not None:
+            with contextlib.suppress(OSError):
+                os.close(self._fd)
+            self._fd = None
+
+        with contextlib.suppress(FileNotFoundError):
+            os.remove(self.lock_file)
+
+        logger.debug("释放锁: %s", self.lock_file)
+
+    def _is_stale(self) -> bool:
+        """检查锁文件是否已过时（持有进程已退出）。"""
+        try:
+            with open(self.lock_file) as f:
+                pid = int(f.read().strip())
+            # 检查进程是否存在
+            os.kill(pid, 0)
+            return False
+        except (FileNotFoundError, ValueError, ProcessLookupError, PermissionError):
+            return True
+
+    def _force_release(self) -> None:
+        """强制释放过时的锁。"""
+        with contextlib.suppress(FileNotFoundError):
+            os.remove(self.lock_file)
+        logger.info("强制释放过时锁: %s", self.lock_file)
+
+    def __enter__(self) -> RunLock:
+        if not self.acquire():
+            raise TimeoutError(f"无法获取锁: {self.lock_file}")
+        return self
+
+    def __exit__(self, *args: object) -> None:
+        self.release()

+"""UTF-16 标题长度计算，对应 Go pkg/xhsutil/title.go。"""
+
+
+def calc_title_length(s: str) -> int:
+    """计算小红书标题长度。
+
+    规则：非 ASCII 字符（中文、全角符号等）算 2 字节，
+    ASCII 字符算 1 字节，最终结果向上取整除以 2。
+
+    Examples:
+        >>> calc_title_length("你好世界")
+        4
+        >>> calc_title_length("hello")
+        3
+        >>> calc_title_length("OOTD穿搭分享")
+        6
+    """
+    byte_len = 0
+    # 用 UTF-16 编码来处理（包括 surrogate pairs）
+    encoded = s.encode("utf-16-le")
+    for i in range(0, len(encoded), 2):
+        code_unit = int.from_bytes(encoded[i : i + 2], "little")
+        if code_unit > 127:
+            byte_len += 2
+        else:
+            byte_len += 1
+    return (byte_len + 1) // 2

+"""小红书 CDP 自动化核心包。"""

+"""CDP WebSocket 客户端（Browser, Page, Element），对应 Go browser/browser.go + go-rod API。
+
+通过原生 WebSocket 与 Chrome DevTools Protocol 通信，实现浏览器自动化控制。
+"""
+
+from __future__ import annotations
+
+import json
+import logging
+import time
+from typing import Any
+
+import requests
+import websockets.sync.client as ws_client
+
+from .errors import CDPError, ElementNotFoundError
+from .stealth import STEALTH_JS
+
+logger = logging.getLogger(__name__)
+
+
+class CDPClient:
+    """底层 CDP WebSocket 通信客户端。"""
+
+    def __init__(self, ws_url: str) -> None:
+        self._ws = ws_client.connect(ws_url, max_size=50 * 1024 * 1024)
+        self._id = 0
+        self._callbacks: dict[int, Any] = {}
+
+    def send(self, method: str, params: dict | None = None) -> dict:
+        """发送 CDP 命令并等待结果。"""
+        self._id += 1
+        msg: dict[str, Any] = {"id": self._id, "method": method}
+        if params:
+            msg["params"] = params
+        self._ws.send(json.dumps(msg))
+        return self._wait_for(self._id)
+
+    def _wait_for(self, msg_id: int, timeout: float = 30.0) -> dict:
+        """等待指定 id 的响应。"""
+        deadline = time.monotonic() + timeout
+        while time.monotonic() < deadline:
+            try:
+                raw = self._ws.recv(timeout=max(0.1, deadline - time.monotonic()))
+            except TimeoutError:
+                break
+            data = json.loads(raw)
+            if data.get("id") == msg_id:
+                if "error" in data:
+                    raise CDPError(f"CDP 错误: {data['error']}")
+                return data.get("result", {})
+        raise CDPError(f"等待 CDP 响应超时 (id={msg_id})")
+
+    def close(self) -> None:
+        import contextlib
+
+        with contextlib.suppress(Exception):
+            self._ws.close()
+
+
+class Page:
+    """CDP 页面对象，封装常用操作。"""
+
+    def __init__(self, cdp: CDPClient, target_id: str, session_id: str) -> None:
+        self._cdp = cdp
+        self.target_id = target_id
+        self.session_id = session_id
+        self._ws = cdp._ws
+        self._id_counter = 1000
+
+    def _send_session(self, method: str, params: dict | None = None) -> dict:
+        """向 session 发送命令。"""
+        self._id_counter += 1
+        msg: dict[str, Any] = {
+            "id": self._id_counter,
+            "method": method,
+            "sessionId": self.session_id,
+        }
+        if params:
+            msg["params"] = params
+        self._ws.send(json.dumps(msg))
+        return self._wait_session(self._id_counter)
+
+    def _wait_session(self, msg_id: int, timeout: float = 60.0) -> dict:
+        """等待 session 响应。"""
+        deadline = time.monotonic() + timeout
+        while time.monotonic() < deadline:
+            try:
+                raw = self._ws.recv(timeout=max(0.1, deadline - time.monotonic()))
+            except TimeoutError:
+                break
+            data = json.loads(raw)
+            if data.get("id") == msg_id:
+                if "error" in data:
+                    raise CDPError(f"CDP 错误: {data['error']}")
+                return data.get("result", {})
+        raise CDPError(f"等待 session 响应超时 (id={msg_id})")
+
+    def navigate(self, url: str) -> None:
+        """导航到指定 URL。"""
+        logger.info("导航到: %s", url)
+        self._send_session("Page.navigate", {"url": url})
+
+    def wait_for_load(self, timeout: float = 60.0) -> None:
+        """等待页面加载完成（通过轮询 document.readyState）。"""
+        deadline = time.monotonic() + timeout
+        while time.monotonic() < deadline:
+            try:
+                state = self.evaluate("document.readyState")
+                if state == "complete":
+                    return
+            except CDPError:
+                pass
+            time.sleep(0.5)
+        logger.warning("等待页面加载超时")
+
+    def wait_dom_stable(self, timeout: float = 10.0, interval: float = 0.5) -> None:
+        """等待 DOM 稳定（连续两次 DOM 快照一致）。"""
+        last_html = ""
+        deadline = time.monotonic() + timeout
+        while time.monotonic() < deadline:
+            try:
+                html = self.evaluate("document.body ? document.body.innerHTML.length : 0")
+                if html == last_html and html != "":
+                    return
+                last_html = html
+            except CDPError:
+                pass
+            time.sleep(interval)
+
+    def evaluate(self, expression: str, timeout: float = 30.0) -> Any:
+        """执行 JavaScript 表达式并返回结果。"""
+        result = self._send_session(
+            "Runtime.evaluate",
+            {
+                "expression": expression,
+                "returnByValue": True,
+                "awaitPromise": False,
+            },
+        )
+        if "exceptionDetails" in result:
+            raise CDPError(f"JS 执行异常: {result['exceptionDetails']}")
+        remote_obj = result.get("result", {})
+        return remote_obj.get("value")
+
+    def evaluate_function(self, function_body: str, *args: Any) -> Any:
+        """执行 JavaScript 函数并返回结果。
+
+        function_body 是一个完整的函数体，如 `() => { return 1; }`
+        """
+        result = self._send_session(
+            "Runtime.evaluate",
+            {
+                "expression": f"({function_body})()",
+                "returnByValue": True,
+                "awaitPromise": False,
+            },
+        )
+        if "exceptionDetails" in result:
+            raise CDPError(f"JS 函数执行异常: {result['exceptionDetails']}")
+        remote_obj = result.get("result", {})
+        return remote_obj.get("value")
+
+    def query_selector(self, selector: str) -> str | None:
+        """查找单个元素，返回 objectId 或 None。"""
+        result = self._send_session(
+            "Runtime.evaluate",
+            {
+                "expression": f"document.querySelector({json.dumps(selector)})",
+                "returnByValue": False,
+            },
+        )
+        remote_obj = result.get("result", {})
+        if remote_obj.get("subtype") == "null" or remote_obj.get("type") == "undefined":
+            return None
+        return remote_obj.get("objectId")
+
+    def query_selector_all(self, selector: str) -> list[str]:
+        """查找多个元素，返回 objectId 列表。"""
+        # 通过 JS 返回元素数量，然后逐个获取
+        count = self.evaluate(f"document.querySelectorAll({json.dumps(selector)}).length")
+        if not count:
+            return []
+        object_ids = []
+        for i in range(count):
+            result = self._send_session(
+                "Runtime.evaluate",
+                {
+                    "expression": (f"document.querySelectorAll({json.dumps(selector)})[{i}]"),
+                    "returnByValue": False,
+                },
+            )
+            obj = result.get("result", {})
+            oid = obj.get("objectId")
+            if oid:
+                object_ids.append(oid)
+        return object_ids
+
+    def has_element(self, selector: str) -> bool:
+        """检查元素是否存在。"""
+        return self.evaluate(f"document.querySelector({json.dumps(selector)}) !== null") is True
+
+    def wait_for_element(self, selector: str, timeout: float = 30.0) -> str:
+        """等待元素出现，返回 objectId。"""
+        deadline = time.monotonic() + timeout
+        while time.monotonic() < deadline:
+            oid = self.query_selector(selector)
+            if oid:
+                return oid
+            time.sleep(0.5)
+        raise ElementNotFoundError(selector)
+
+    def click_element(self, selector: str) -> None:
+        """点击指定选择器的元素。"""
+        self.evaluate(
+            f"""
+            (() => {{
+                const el = document.querySelector({json.dumps(selector)});
+                if (el) el.click();
+            }})()
+            """
+        )
+
+    def input_text(self, selector: str, text: str) -> None:
+        """向指定选择器的元素输入文本。"""
+        self.evaluate(
+            f"""
+            (() => {{
+                const el = document.querySelector({json.dumps(selector)});
+                if (!el) return;
+                el.focus();
+                el.value = {json.dumps(text)};
+                el.dispatchEvent(new Event('input', {{bubbles: true}}));
+                el.dispatchEvent(new Event('change', {{bubbles: true}}));
+            }})()
+            """
+        )
+
+    def input_content_editable(self, selector: str, text: str) -> None:
+        """向 contentEditable 元素输入文本（如 div.ql-editor）。"""
+        self.evaluate(
+            f"""
+            (() => {{
+                const el = document.querySelector({json.dumps(selector)});
+                if (!el) return;
+                el.focus();
+                el.textContent = {json.dumps(text)};
+                el.dispatchEvent(new Event('input', {{bubbles: true}}));
+            }})()
+            """
+        )
+
+    def get_element_text(self, selector: str) -> str | None:
+        """获取元素文本内容。"""
+        return self.evaluate(
+            f"""
+            (() => {{
+                const el = document.querySelector({json.dumps(selector)});
+                return el ? el.textContent : null;
+            }})()
+            """
+        )
+
+    def get_element_attribute(self, selector: str, attr: str) -> str | None:
+        """获取元素属性值。"""
+        return self.evaluate(
+            f"""
+            (() => {{
+                const el = document.querySelector({json.dumps(selector)});
+                return el ? el.getAttribute({json.dumps(attr)}) : null;
+            }})()
+            """
+        )
+
+    def get_elements_count(self, selector: str) -> int:
+        """获取匹配元素数量。"""
+        result = self.evaluate(f"document.querySelectorAll({json.dumps(selector)}).length")
+        return result if isinstance(result, int) else 0
+
+    def scroll_by(self, x: int, y: int) -> None:
+        """滚动页面。"""
+        self.evaluate(f"window.scrollBy({x}, {y})")
+
+    def scroll_to(self, x: int, y: int) -> None:
+        """滚动到指定位置。"""
+        self.evaluate(f"window.scrollTo({x}, {y})")
+
+    def scroll_to_bottom(self) -> None:
+        """滚动到页面底部。"""
+        self.evaluate("window.scrollTo(0, document.body.scrollHeight)")
+
+    def scroll_element_into_view(self, selector: str) -> None:
+        """将元素滚动到可视区域。"""
+        self.evaluate(
+            f"""
+            (() => {{
+                const el = document.querySelector({json.dumps(selector)});
+                if (el) el.scrollIntoView({{behavior: 'smooth', block: 'center'}});
+            }})()
+            """
+        )
+
+    def scroll_nth_element_into_view(self, selector: str, index: int) -> None:
+        """将第 N 个匹配元素滚动到可视区域。"""
+        self.evaluate(
+            f"""
+            (() => {{
+                const els = document.querySelectorAll({json.dumps(selector)});
+                if (els[{index}]) els[{index}].scrollIntoView(
+                    {{behavior: 'smooth', block: 'center'}}
+                );
+            }})()
+            """
+        )
+
+    def get_scroll_top(self) -> int:
+        """获取当前滚动位置。"""
+        result = self.evaluate(
+            "window.pageYOffset || document.documentElement.scrollTop"
+            " || document.body.scrollTop || 0"
+        )
+        return int(result) if result else 0
+
+    def get_viewport_height(self) -> int:
+        """获取视口高度。"""
+        result = self.evaluate("window.innerHeight")
+        return int(result) if result else 768
+
+    def set_file_input(self, selector: str, files: list[str]) -> None:
+        """设置文件输入框的文件（通过 CDP DOM.setFileInputFiles）。"""
+        # 先获取 nodeId
+        doc = self._send_session("DOM.getDocument", {"depth": 0})
+        root_node_id = doc["root"]["nodeId"]
+        result = self._send_session(
+            "DOM.querySelector",
+            {"nodeId": root_node_id, "selector": selector},
+        )
+        node_id = result.get("nodeId", 0)
+        if node_id == 0:
+            raise ElementNotFoundError(selector)
+        self._send_session(
+            "DOM.setFileInputFiles",
+            {"nodeId": node_id, "files": files},
+        )
+
+    def dispatch_wheel_event(self, delta_y: float) -> None:
+        """触发滚轮事件以激活懒加载。"""
+        self.evaluate(
+            f"""
+            (() => {{
+                let target = document.querySelector('.note-scroller')
+                    || document.querySelector('.interaction-container')
+                    || document.documentElement;
+                const event = new WheelEvent('wheel', {{
+                    deltaY: {delta_y},
+                    deltaMode: 0,
+                    bubbles: true,
+                    cancelable: true,
+                    view: window,
+                }});
+                target.dispatchEvent(event);
+            }})()
+            """
+        )
+
+    def mouse_move(self, x: float, y: float) -> None:
+        """移动鼠标。"""
+        self._send_session(
+            "Input.dispatchMouseEvent",
+            {"type": "mouseMoved", "x": x, "y": y},
+        )
+
+    def mouse_click(self, x: float, y: float, button: str = "left") -> None:
+        """在指定坐标点击。"""
+        self._send_session(
+            "Input.dispatchMouseEvent",
+            {"type": "mousePressed", "x": x, "y": y, "button": button, "clickCount": 1},
+        )
+        self._send_session(
+            "Input.dispatchMouseEvent",
+            {"type": "mouseReleased", "x": x, "y": y, "button": button, "clickCount": 1},
+        )
+
+    def type_text(self, text: str, delay_ms: int = 50) -> None:
+        """逐字符输入文本。"""
+        for char in text:
+            self._send_session(
+                "Input.dispatchKeyEvent",
+                {"type": "keyDown", "text": char},
+            )
+            self._send_session(
+                "Input.dispatchKeyEvent",
+                {"type": "keyUp", "text": char},
+            )
+            if delay_ms > 0:
+                time.sleep(delay_ms / 1000.0)
+
+    def press_key(self, key: str) -> None:
+        """按下并释放指定键。"""
+        key_map = {
+            "Enter": {"key": "Enter", "code": "Enter", "windowsVirtualKeyCode": 13},
+            "ArrowDown": {
+                "key": "ArrowDown",
+                "code": "ArrowDown",
+                "windowsVirtualKeyCode": 40,
+            },
+            "Tab": {"key": "Tab", "code": "Tab", "windowsVirtualKeyCode": 9},
+        }
+        info = key_map.get(key, {"key": key, "code": key})
+        self._send_session(
+            "Input.dispatchKeyEvent",
+            {"type": "keyDown", **info},
+        )
+        self._send_session(
+            "Input.dispatchKeyEvent",
+            {"type": "keyUp", **info},
+        )
+
+    def inject_stealth(self) -> None:
+        """注入反检测脚本。"""
+        self._send_session(
+            "Page.addScriptToEvaluateOnNewDocument",
+            {"source": STEALTH_JS},
+        )
+
+    def remove_element(self, selector: str) -> None:
+        """移除 DOM 元素。"""
+        self.evaluate(
+            f"""
+            (() => {{
+                const el = document.querySelector({json.dumps(selector)});
+                if (el) el.remove();
+            }})()
+            """
+        )
+
+    def hover_element(self, selector: str) -> None:
+        """悬停到元素中心。"""
+        box = self.evaluate(
+            f"""
+            (() => {{
+                const el = document.querySelector({json.dumps(selector)});
+                if (!el) return null;
+                const rect = el.getBoundingClientRect();
+                return {{x: rect.left + rect.width / 2, y: rect.top + rect.height / 2}};
+            }})()
+            """
+        )
+        if box:
+            self.mouse_move(box["x"], box["y"])
+
+    def select_all_text(self, selector: str) -> None:
+        """选中输入框内所有文本。"""
+        self.evaluate(
+            f"""
+            (() => {{
+                const el = document.querySelector({json.dumps(selector)});
+                if (!el) return;
+                el.focus();
+                el.select ? el.select() : document.execCommand('selectAll');
+            }})()
+            """
+        )
+
+
+class Browser:
+    """Chrome 浏览器 CDP 控制器。"""
+
+    def __init__(self, host: str = "127.0.0.1", port: int = 9222) -> None:
+        self.host = host
+        self.port = port
+        self.base_url = f"http://{host}:{port}"
+        self._cdp: CDPClient | None = None
+
+    def connect(self) -> None:
+        """连接到 Chrome DevTools。"""
+        resp = requests.get(f"{self.base_url}/json/version", timeout=5)
+        resp.raise_for_status()
+        info = resp.json()
+        ws_url = info["webSocketDebuggerUrl"]
+        logger.info("连接到 Chrome: %s", ws_url)
+        self._cdp = CDPClient(ws_url)
+
+    def new_page(self, url: str = "about:blank") -> Page:
+        """创建新页面。"""
+        if not self._cdp:
+            self.connect()
+        assert self._cdp is not None
+
+        # 创建 target
+        result = self._cdp.send("Target.createTarget", {"url": url})
+        target_id = result["targetId"]
+
+        # 附加到 target
+        result = self._cdp.send(
+            "Target.attachToTarget",
+            {"targetId": target_id, "flatten": True},
+        )
+        session_id = result["sessionId"]
+
+        page = Page(self._cdp, target_id, session_id)
+
+        # 启用必要的 domain
+        page._send_session("Page.enable")
+        page._send_session("DOM.enable")
+        page._send_session("Runtime.enable")
+
+        # 注入反检测
+        page.inject_stealth()
+
+        return page
+
+    def get_existing_page(self) -> Page | None:
+        """获取已有页面（取第一个非 about:blank 的 page target）。"""
+        if not self._cdp:
+            self.connect()
+        assert self._cdp is not None
+
+        resp = requests.get(f"{self.base_url}/json", timeout=5)
+        targets = resp.json()
+
+        for target in targets:
+            if target.get("type") == "page" and target.get("url") != "about:blank":
+                target_id = target["id"]
+                result = self._cdp.send(
+                    "Target.attachToTarget",
+                    {"targetId": target_id, "flatten": True},
+                )
+                session_id = result["sessionId"]
+                page = Page(self._cdp, target_id, session_id)
+                page._send_session("Page.enable")
+                page._send_session("DOM.enable")
+                page._send_session("Runtime.enable")
+                page.inject_stealth()
+                return page
+        return None
+
+    def close_page(self, page: Page) -> None:
+        """关闭页面。"""
+        import contextlib
+
+        if self._cdp:
+            with contextlib.suppress(CDPError):
+                self._cdp.send("Target.closeTarget", {"targetId": page.target_id})
+
+    def close(self) -> None:
+        """关闭连接。"""
+        if self._cdp:
+            self._cdp.close()
+            self._cdp = None

+"""评论操作，对应 Go xiaohongshu/comment_feed.go。"""
+
+from __future__ import annotations
+
+import logging
+import time
+
+from .cdp import Page
+from .feed_detail import _check_end_container, _check_page_accessible, _get_comment_count
+from .selectors import (
+    COMMENT_INPUT_FIELD,
+    COMMENT_INPUT_TRIGGER,
+    COMMENT_SUBMIT_BUTTON,
+    PARENT_COMMENT,
+    REPLY_BUTTON,
+)
+from .urls import make_feed_detail_url
+
+logger = logging.getLogger(__name__)
+
+
+def post_comment(page: Page, feed_id: str, xsec_token: str, content: str) -> None:
+    """发表评论到 Feed。
+
+    Args:
+        page: CDP 页面对象。
+        feed_id: Feed ID。
+        xsec_token: xsec_token。
+        content: 评论内容。
+
+    Raises:
+        RuntimeError: 评论失败。
+    """
+    url = make_feed_detail_url(feed_id, xsec_token)
+    logger.info("打开 feed 详情页: %s", url)
+
+    page.navigate(url)
+    page.wait_for_load()
+    page.wait_dom_stable()
+    time.sleep(1)
+
+    _check_page_accessible(page)
+
+    # 点击评论输入触发区域
+    if not page.has_element(COMMENT_INPUT_TRIGGER):
+        raise RuntimeError("未找到评论输入框，该帖子可能不支持评论或网页端不可访问")
+
+    page.click_element(COMMENT_INPUT_TRIGGER)
+    time.sleep(0.5)
+
+    # 输入评论内容
+    page.wait_for_element(COMMENT_INPUT_FIELD, timeout=5)
+    page.evaluate(
+        f"""
+        (() => {{
+            const el = document.querySelector({_js_str(COMMENT_INPUT_FIELD)});
+            if (el) {{
+                el.focus();
+                el.textContent = {_js_str(content)};
+                el.dispatchEvent(new Event('input', {{bubbles: true}}));
+            }}
+        }})()
+        """
+    )
+    time.sleep(1)
+
+    # 点击提交
+    page.click_element(COMMENT_SUBMIT_BUTTON)
+    time.sleep(1)
+
+    logger.info("评论发送成功: feed=%s", feed_id)
+
+
+def reply_comment(
+    page: Page,
+    feed_id: str,
+    xsec_token: str,
+    content: str,
+    comment_id: str = "",
+    user_id: str = "",
+) -> None:
+    """回复指定评论。
+
+    通过 comment_id 或 user_id 定位评论，然后回复。
+
+    Args:
+        page: CDP 页面对象。
+        feed_id: Feed ID。
+        xsec_token: xsec_token。
+        content: 回复内容。
+        comment_id: 评论 ID（优先使用）。
+        user_id: 用户 ID（备选）。
+
+    Raises:
+        RuntimeError: 回复失败。
+    """
+    if not comment_id and not user_id:
+        raise ValueError("comment_id 和 user_id 至少提供一个")
+
+    url = make_feed_detail_url(feed_id, xsec_token)
+    logger.info("打开 feed 详情页进行回复: %s", url)
+
+    page.navigate(url)
+    page.wait_for_load()
+    page.wait_dom_stable()
+    time.sleep(1)
+
+    _check_page_accessible(page)
+    time.sleep(2)
+
+    # 查找目标评论
+    comment_found = _find_and_scroll_to_comment(page, comment_id, user_id)
+    if not comment_found:
+        raise RuntimeError(f"未找到评论 (commentID: {comment_id}, userID: {user_id})")
+
+    time.sleep(1)
+
+    # 点击回复按钮
+    reply_selector = f"#comment-{comment_id} {REPLY_BUTTON}" if comment_id else REPLY_BUTTON
+    page.click_element(reply_selector)
+    time.sleep(1)
+
+    # 输入回复内容
+    page.wait_for_element(COMMENT_INPUT_FIELD, timeout=5)
+    page.evaluate(
+        f"""
+        (() => {{
+            const el = document.querySelector({_js_str(COMMENT_INPUT_FIELD)});
+            if (el) {{
+                el.focus();
+                el.textContent = {_js_str(content)};
+                el.dispatchEvent(new Event('input', {{bubbles: true}}));
+            }}
+        }})()
+        """
+    )
+    time.sleep(0.5)
+
+    # 点击提交
+    page.click_element(COMMENT_SUBMIT_BUTTON)
+    time.sleep(2)
+
+    logger.info("回复评论成功")
+
+
+def _find_and_scroll_to_comment(
+    page: Page,
+    comment_id: str,
+    user_id: str,
+    max_attempts: int = 100,
+) -> bool:
+    """查找并滚动到目标评论。"""
+    logger.info("开始查找评论 - commentID: %s, userID: %s", comment_id, user_id)
+
+    # 先滚动到评论区
+    page.scroll_element_into_view(".comments-container")
+    time.sleep(1)
+
+    last_count = 0
+    stagnant = 0
+
+    for attempt in range(max_attempts):
+        # 检查是否到底
+        if _check_end_container(page):
+            logger.info("已到达评论底部，未找到目标评论")
+            break
+
+        # 停滞检测
+        current_count = _get_comment_count(page)
+        if current_count != last_count:
+            last_count = current_count
+            stagnant = 0
+        else:
+            stagnant += 1
+        if stagnant >= 10:
+            logger.info("评论数量停滞超过10次")
+            break
+
+        # 滚动到最后一条评论
+        if current_count > 0:
+            page.scroll_nth_element_into_view(PARENT_COMMENT, current_count - 1)
+            time.sleep(0.3)
+
+        # 继续滚动
+        page.evaluate("window.scrollBy(0, window.innerHeight * 0.8)")
+        time.sleep(0.5)
+
+        # 通过 commentID 查找
+        if comment_id:
+            selector = f"#comment-{comment_id}"
+            if page.has_element(selector):
+                logger.info("通过 commentID 找到评论 (尝试 %d 次)", attempt + 1)
+                page.scroll_element_into_view(selector)
+                return True
+
+        # 通过 userID 查找
+        if user_id:
+            found = page.evaluate(
+                f"""
+                (() => {{
+                    const els = document.querySelectorAll(
+                        '.parent-comment, .comment-item, .comment'
+                    );
+                    for (const el of els) {{
+                        if (el.querySelector('[data-user-id="{user_id}"]')) {{
+                            el.scrollIntoView({{behavior: 'smooth', block: 'center'}});
+                            return true;
+                        }}
+                    }}
+                    return false;
+                }})()
+                """
+            )
+            if found:
+                logger.info("通过 userID 找到评论 (尝试 %d 次)", attempt + 1)
+                return True
+
+        time.sleep(0.8)
+
+    return False
+
+
+def _js_str(s: str) -> str:
+    """将 Python 字符串转为 JS 字面量（含引号）。"""
+    import json
+
+    return json.dumps(s)

+"""Cookie 文件持久化，对应 Go cookies/cookies.go。"""
+
+from __future__ import annotations
+
+import os
+from pathlib import Path
+
+
+def get_cookies_file_path(account: str = "") -> str:
+    """获取 cookies 文件路径。
+
+    优先级：
+    1. /tmp/cookies.json（向后兼容）
+    2. COOKIES_PATH 环境变量
+    3. 多账号模式：~/.xhs/accounts/{account}/cookies.json
+    4. ./cookies.json（本地调试）
+    """
+    if account:
+        account_dir = Path.home() / ".xhs" / "accounts" / account
+        account_dir.mkdir(parents=True, exist_ok=True)
+        return str(account_dir / "cookies.json")
+
+    # 旧路径
+    import tempfile
+
+    old_path = os.path.join(tempfile.gettempdir(), "cookies.json")
+    if os.path.exists(old_path):
+        return old_path
+
+    # 环境变量
+    env_path = os.getenv("COOKIES_PATH")
+    if env_path:
+        return env_path
+
+    return "cookies.json"
+
+
+def load_cookies(path: str) -> bytes | None:
+    """从文件加载 cookies。"""
+    try:
+        with open(path, "rb") as f:
+            return f.read()
+    except FileNotFoundError:
+        return None
+
+
+def save_cookies(path: str, data: bytes) -> None:
+    """保存 cookies 到文件。"""
+    os.makedirs(os.path.dirname(path) or ".", exist_ok=True)
+    with open(path, "wb") as f:
+        f.write(data)
+
+
+def delete_cookies(path: str) -> None:
+    """删除 cookies 文件。"""
+    import contextlib
+
+    with contextlib.suppress(FileNotFoundError):
+        os.remove(path)

+"""小红书自动化异常体系。"""
+
+
+class XHSError(Exception):
+    """小红书自动化基础异常。"""
+
+
+class NoFeedsError(XHSError):
+    """没有捕获到 feeds 数据。"""
+
+    def __init__(self) -> None:
+        super().__init__("没有捕获到 feeds 数据")
+
+
+class NoFeedDetailError(XHSError):
+    """没有捕获到 feed 详情数据。"""
+
+    def __init__(self) -> None:
+        super().__init__("没有捕获到 feed 详情数据")
+
+
+class NotLoggedInError(XHSError):
+    """未登录。"""
+
+    def __init__(self) -> None:
+        super().__init__("未登录，请先扫码登录")
+
+
+class PageNotAccessibleError(XHSError):
+    """页面不可访问。"""
+
+    def __init__(self, reason: str) -> None:
+        self.reason = reason
+        super().__init__(f"笔记不可访问: {reason}")
+
+
+class UploadTimeoutError(XHSError):
+    """上传超时。"""
+
+
+class PublishError(XHSError):
+    """发布失败。"""
+
+
+class TitleTooLongError(PublishError):
+    """标题超过长度限制。"""
+
+    def __init__(self, current: str, maximum: str) -> None:
+        self.current = current
+        self.maximum = maximum
+        super().__init__(f"当前输入长度为{current}，最大长度为{maximum}")
+
+
+class ContentTooLongError(PublishError):
+    """正文超过长度限制。"""
+
+    def __init__(self, current: str, maximum: str) -> None:
+        self.current = current
+        self.maximum = maximum
+        super().__init__(f"当前输入长度为{current}，最大长度为{maximum}")
+
+
+class CDPError(XHSError):
+    """CDP 通信异常。"""
+
+
+class ElementNotFoundError(XHSError):
+    """页面元素未找到。"""
+
+    def __init__(self, selector: str) -> None:
+        self.selector = selector
+        super().__init__(f"未找到元素: {selector}")

+"""Feed 详情 + 评论加载，对应 Go xiaohongshu/feed_detail.go（867 行）。"""
+
+from __future__ import annotations
+
+import json
+import logging
+import random
+import re
+import time
+
+from .cdp import Page
+from .errors import NoFeedDetailError, PageNotAccessibleError
+from .human import (
+    BUTTON_CLICK_INTERVAL,
+    DEFAULT_MAX_ATTEMPTS,
+    FINAL_SPRINT_PUSH_COUNT,
+    HUMAN_DELAY,
+    LARGE_SCROLL_TRIGGER,
+    MAX_CLICK_PER_ROUND,
+    MIN_SCROLL_DELTA,
+    POST_SCROLL,
+    REACTION_TIME,
+    READ_TIME,
+    SCROLL_WAIT,
+    SHORT_READ,
+    STAGNANT_LIMIT,
+    calculate_scroll_delta,
+    get_scroll_interval,
+    get_scroll_ratio,
+    sleep_random,
+)
+from .selectors import (
+    ACCESS_ERROR_WRAPPER,
+    END_CONTAINER,
+    NO_COMMENTS_TEXT,
+    PARENT_COMMENT,
+    SHOW_MORE_BUTTON,
+)
+from .types import (
+    CommentList,
+    CommentLoadConfig,
+    FeedDetail,
+    FeedDetailResponse,
+)
+from .urls import make_feed_detail_url
+
+logger = logging.getLogger(__name__)
+
+# 页面不可访问关键词
+_INACCESSIBLE_KEYWORDS = [
+    "当前笔记暂时无法浏览",
+    "该内容因违规已被删除",
+    "该笔记已被删除",
+    "内容不存在",
+    "笔记不存在",
+    "已失效",
+    "私密笔记",
+    "仅作者可见",
+    "因用户设置，你无法查看",
+    "因违规无法查看",
+]
+
+_REPLY_COUNT_RE = re.compile(r"展开\s*(\d+)\s*条回复")
+_TOTAL_COMMENT_RE = re.compile(r"共(\d+)条评论")
+
+
+def get_feed_detail(
+    page: Page,
+    feed_id: str,
+    xsec_token: str,
+    load_all_comments: bool = False,
+    config: CommentLoadConfig | None = None,
+) -> FeedDetailResponse:
+    """获取 Feed 详情（含评论）。
+
+    Args:
+        page: CDP 页面对象。
+        feed_id: Feed ID。
+        xsec_token: xsec_token。
+        load_all_comments: 是否加载全部评论。
+        config: 评论加载配置。
+
+    Raises:
+        PageNotAccessibleError: 页面不可访问。
+        NoFeedDetailError: 未获取到详情数据。
+    """
+    if config is None:
+        config = CommentLoadConfig()
+
+    url = make_feed_detail_url(feed_id, xsec_token)
+    logger.info("打开 feed 详情页: %s", url)
+    logger.info(
+        "配置: 点击更多=%s, 回复阈值=%d, 最大评论数=%d, 滚动速度=%s",
+        config.click_more_replies,
+        config.max_replies_threshold,
+        config.max_comment_items,
+        config.scroll_speed,
+    )
+
+    # 导航（含重试）
+    for attempt in range(3):
+        try:
+            page.navigate(url)
+            page.wait_for_load()
+            page.wait_dom_stable()
+            break
+        except Exception as e:
+            logger.debug("页面导航重试 #%d: %s", attempt, e)
+            time.sleep(0.5 + random.random())
+    else:
+        raise RuntimeError("页面导航失败")
+
+    sleep_random(1000, 1000)
+
+    # 检查页面可访问性
+    _check_page_accessible(page)
+
+    # 加载全部评论
+    if load_all_comments:
+        try:
+            _load_all_comments(page, config)
+        except Exception as e:
+            logger.warning("加载全部评论失败: %s", e)
+
+    return _extract_feed_detail(page, feed_id)
+
+
+# ========== 页面检查 ==========
+
+
+def _check_page_accessible(page: Page) -> None:
+    """检查页面是否可访问。"""
+    time.sleep(0.5)
+
+    text = page.get_element_text(ACCESS_ERROR_WRAPPER)
+    if not text:
+        return
+
+    text = text.strip()
+    for kw in _INACCESSIBLE_KEYWORDS:
+        if kw in text:
+            raise PageNotAccessibleError(kw)
+
+    if text:
+        raise PageNotAccessibleError(text)
+
+
+# ========== 数据提取 ==========
+
+
+_EXTRACT_DETAIL_JS = """
+(() => {
+    if (window.__INITIAL_STATE__ &&
+        window.__INITIAL_STATE__.note &&
+        window.__INITIAL_STATE__.note.noteDetailMap) {
+        return JSON.stringify(window.__INITIAL_STATE__.note.noteDetailMap);
+    }
+    return "";
+})()
+"""
+
+
+def _extract_feed_detail(page: Page, feed_id: str) -> FeedDetailResponse:
+    """从 __INITIAL_STATE__ 提取 Feed 详情。"""
+    result = None
+    for _ in range(3):
+        result = page.evaluate(_EXTRACT_DETAIL_JS)
+        if result:
+            break
+        time.sleep(0.2)
+
+    if not result:
+        raise NoFeedDetailError()
+
+    note_detail_map = json.loads(result)
+    note_data = note_detail_map.get(feed_id)
+    if not note_data:
+        raise NoFeedDetailError()
+
+    return FeedDetailResponse(
+        note=FeedDetail.from_dict(note_data.get("note", {})),
+        comments=CommentList.from_dict(note_data.get("comments", {})),
+    )
+
+
+# ========== 评论加载状态机 ==========
+
+
+def _load_all_comments(page: Page, config: CommentLoadConfig) -> None:
+    """加载全部评论的状态机。"""
+    max_attempts = (
+        config.max_comment_items * 3 if config.max_comment_items > 0 else DEFAULT_MAX_ATTEMPTS
+    )
+    scroll_interval = get_scroll_interval(config.scroll_speed)
+
+    logger.info("开始加载评论...")
+    _scroll_to_comments_area(page)
+    sleep_random(*HUMAN_DELAY)
+
+    # 检查是否无评论
+    if _check_no_comments(page):
+        logger.info("检测到无评论区域，跳过加载")
+        return
+
+    # 状态
+    last_count = 0
+    last_scroll_top = 0
+    stagnant_checks = 0
+    total_clicked = 0
+    total_skipped = 0
+
+    for attempt in range(max_attempts):
+        logger.debug("=== 尝试 %d/%d ===", attempt + 1, max_attempts)
+
+        # 检查是否到达底部
+        if _check_end_container(page):
+            count = _get_comment_count(page)
+            logger.info(
+                "检测到 THE END，加载完成: %d 条评论, 点击: %d, 跳过: %d",
+                count,
+                total_clicked,
+                total_skipped,
+            )
+            return
+
+        # 定期点击展开按钮
+        if config.click_more_replies and attempt % BUTTON_CLICK_INTERVAL == 0:
+            clicked, skipped = _click_show_more_buttons(page, config.max_replies_threshold)
+            total_clicked += clicked
+            total_skipped += skipped
+            if clicked > 0 or skipped > 0:
+                sleep_random(*READ_TIME)
+                # 第二轮
+                c2, s2 = _click_show_more_buttons(page, config.max_replies_threshold)
+                total_clicked += c2
+                total_skipped += s2
+                if c2 > 0 or s2 > 0:
+                    sleep_random(*SHORT_READ)
+
+        # 获取当前评论数
+        current_count = _get_comment_count(page)
+        if current_count != last_count:
+            logger.info("评论增加: %d -> %d", last_count, current_count)
+            last_count = current_count
+            stagnant_checks = 0
+        else:
+            stagnant_checks += 1
+
+        # 检查是否达到目标
+        if config.max_comment_items > 0 and current_count >= config.max_comment_items:
+            logger.info("已达到目标评论数: %d/%d", current_count, config.max_comment_items)
+            return
+
+        # 滚动
+        if current_count > 0:
+            _scroll_to_last_comment(page)
+            sleep_random(*POST_SCROLL)
+
+        large_mode = stagnant_checks >= LARGE_SCROLL_TRIGGER
+        push_count = 1
+        if large_mode:
+            push_count = 3 + random.randint(0, 2)
+
+        scroll_delta, current_scroll_top = _human_scroll(
+            page, config.scroll_speed, large_mode, push_count
+        )
+
+        if scroll_delta < MIN_SCROLL_DELTA or current_scroll_top == last_scroll_top:
+            stagnant_checks += 1
+        else:
+            stagnant_checks = 0
+            last_scroll_top = current_scroll_top
+
+        # 停滞处理
+        if stagnant_checks >= STAGNANT_LIMIT:
+            logger.info("停滞过多，尝试大冲刺...")
+            _human_scroll(page, config.scroll_speed, True, 10)
+            stagnant_checks = 0
+
+        time.sleep(scroll_interval)
+
+    # 最终冲刺
+    logger.info("达到最大尝试次数，最后冲刺...")
+    _human_scroll(page, config.scroll_speed, True, FINAL_SPRINT_PUSH_COUNT)
+    count = _get_comment_count(page)
+    logger.info("加载结束: %d 条评论, 点击: %d, 跳过: %d", count, total_clicked, total_skipped)
+
+
+# ========== 滚动 ==========
+
+
+def _human_scroll(
+    page: Page,
+    speed: str,
+    large_mode: bool,
+    push_count: int,
+) -> tuple[int, int]:
+    """人类化滚动。
+
+    Returns:
+        (actual_delta, current_scroll_top)
+    """
+    before_top = page.get_scroll_top()
+    viewport_height = page.get_viewport_height()
+
+    base_ratio = get_scroll_ratio(speed)
+    if large_mode:
+        base_ratio *= 2.0
+
+    actual_delta = 0
+    current_scroll_top = before_top
+
+    for i in range(max(1, push_count)):
+        scroll_delta = calculate_scroll_delta(viewport_height, base_ratio)
+        page.scroll_by(0, int(scroll_delta))
+        sleep_random(*SCROLL_WAIT)
+
+        current_scroll_top = page.get_scroll_top()
+        delta_this = current_scroll_top - before_top
+        actual_delta += delta_this
+        before_top = current_scroll_top
+
+        if i < push_count - 1:
+            sleep_random(*HUMAN_DELAY)
+
+    # 如果没有滚动，强制到底部
+    if actual_delta < MIN_SCROLL_DELTA and push_count > 0:
+        page.scroll_to_bottom()
+        sleep_random(*POST_SCROLL)
+        current_scroll_top = page.get_scroll_top()
+        actual_delta = current_scroll_top - (before_top - actual_delta)
+
+    return actual_delta, current_scroll_top
+
+
+def _scroll_to_comments_area(page: Page) -> None:
+    """滚动到评论区。"""
+    logger.info("滚动到评论区...")
+    page.scroll_element_into_view(".comments-container")
+    time.sleep(0.5)
+    # 触发懒加载
+    page.dispatch_wheel_event(100)
+
+
+def _scroll_to_last_comment(page: Page) -> None:
+    """滚动到最后一条评论。"""
+    count = page.get_elements_count(PARENT_COMMENT)
+    if count > 0:
+        page.scroll_nth_element_into_view(PARENT_COMMENT, count - 1)
+
+
+# ========== DOM 查询 ==========
+
+
+def _get_comment_count(page: Page) -> int:
+    """获取当前评论数量。"""
+    return page.get_elements_count(PARENT_COMMENT)
+
+
+def _get_total_comment_count(page: Page) -> int:
+    """获取总评论数（从 "共N条评论" 提取）。"""
+    text = page.get_element_text(".comments-container .total")
+    if not text:
+        return 0
+    match = _TOTAL_COMMENT_RE.search(text)
+    if match:
+        return int(match.group(1))
+    return 0
+
+
+def _check_no_comments(page: Page) -> bool:
+    """检查是否无评论区域。"""
+    text = page.get_element_text(NO_COMMENTS_TEXT)
+    if not text:
+        return False
+    return "这是一片荒地" in text.strip()
+
+
+def _check_end_container(page: Page) -> bool:
+    """检查是否到达底部 THE END。"""
+    text = page.get_element_text(END_CONTAINER)
+    if not text:
+        return False
+    upper = text.strip().upper()
+    return "THE END" in upper or "THEEND" in upper
+
+
+# ========== 按钮点击 ==========
+
+
+def _click_show_more_buttons(page: Page, max_threshold: int) -> tuple[int, int]:
+    """点击"展开N条回复"按钮。
+
+    Returns:
+        (clicked, skipped)
+    """
+    count = page.get_elements_count(SHOW_MORE_BUTTON)
+    if count == 0:
+        return 0, 0
+
+    max_click = MAX_CLICK_PER_ROUND + random.randint(0, MAX_CLICK_PER_ROUND - 1)
+    clicked = 0
+    skipped = 0
+
+    for i in range(count):
+        if clicked >= max_click:
+            break
+
+        # 获取按钮文本
+        text = page.evaluate(
+            f"document.querySelectorAll({json.dumps(SHOW_MORE_BUTTON)})[{i}]?.textContent || ''"
+        )
+        if not text:
+            continue
+
+        # 检查是否应该跳过
+        if max_threshold > 0:
+            match = _REPLY_COUNT_RE.search(text)
+            if match:
+                reply_count = int(match.group(1))
+                if reply_count > max_threshold:
+                    logger.debug(
+                        "跳过 '%s'（回复数 %d > 阈值 %d）", text, reply_count, max_threshold
+                    )
+                    skipped += 1
+                    continue
+
+        # 滚动到按钮并点击
+        page.scroll_nth_element_into_view(SHOW_MORE_BUTTON, i)
+        sleep_random(*REACTION_TIME)
+        page.evaluate(f"document.querySelectorAll({json.dumps(SHOW_MORE_BUTTON)})[{i}]?.click()")
+        sleep_random(*READ_TIME)
+        clicked += 1
+
+    return clicked, skipped

+"""首页 Feed 列表，对应 Go xiaohongshu/feeds.go。"""
+
+from __future__ import annotations
+
+import json
+import logging
+import time
+
+from .cdp import Page
+from .errors import NoFeedsError
+from .types import Feed
+from .urls import HOME_URL
+
+logger = logging.getLogger(__name__)
+
+# 从 __INITIAL_STATE__ 提取 feeds 的 JS
+_EXTRACT_FEEDS_JS = """
+(() => {
+    if (window.__INITIAL_STATE__ &&
+        window.__INITIAL_STATE__.feed &&
+        window.__INITIAL_STATE__.feed.feeds) {
+        const feeds = window.__INITIAL_STATE__.feed.feeds;
+        const feedsData = feeds.value !== undefined ? feeds.value : feeds._value;
+        if (feedsData) {
+            return JSON.stringify(feedsData);
+        }
+    }
+    return "";
+})()
+"""
+
+
+def list_feeds(page: Page) -> list[Feed]:
+    """获取首页 Feed 列表。
+
+    Raises:
+        NoFeedsError: 没有捕获到 feeds 数据。
+    """
+    page.navigate(HOME_URL)
+    page.wait_for_load()
+    page.wait_dom_stable()
+    time.sleep(1)
+
+    result = page.evaluate(_EXTRACT_FEEDS_JS)
+    if not result:
+        raise NoFeedsError()
+
+    feeds_data = json.loads(result)
+    return [Feed.from_dict(f) for f in feeds_data]

+"""人类行为模拟参数（延迟、滚动、悬停），对应 Go feed_detail.go 中的常量。"""
+
+import random
+import time
+
+# ========== 配置常量 ==========
+DEFAULT_MAX_ATTEMPTS = 500
+STAGNANT_LIMIT = 20
+MIN_SCROLL_DELTA = 10
+MAX_CLICK_PER_ROUND = 3
+STAGNANT_CHECK_THRESHOLD = 2
+LARGE_SCROLL_TRIGGER = 5
+BUTTON_CLICK_INTERVAL = 3
+FINAL_SPRINT_PUSH_COUNT = 15
+
+# ========== 延迟范围（毫秒） ==========
+HUMAN_DELAY = (300, 700)
+REACTION_TIME = (300, 800)
+HOVER_TIME = (100, 300)
+READ_TIME = (500, 1200)
+SHORT_READ = (600, 1200)
+SCROLL_WAIT = (100, 200)
+POST_SCROLL = (300, 500)
+
+
+def sleep_random(min_ms: int, max_ms: int) -> None:
+    """随机延迟。"""
+    if max_ms <= min_ms:
+        time.sleep(min_ms / 1000.0)
+        return
+    delay = random.randint(min_ms, max_ms) / 1000.0
+    time.sleep(delay)
+
+
+def get_scroll_interval(speed: str) -> float:
+    """根据速度获取滚动间隔（秒）。"""
+    if speed == "slow":
+        return (1200 + random.randint(0, 300)) / 1000.0
+    if speed == "fast":
+        return (300 + random.randint(0, 100)) / 1000.0
+    # normal
+    return (600 + random.randint(0, 200)) / 1000.0
+
+
+def get_scroll_ratio(speed: str) -> float:
+    """根据速度获取滚动比例。"""
+    if speed == "slow":
+        return 0.5
+    if speed == "fast":
+        return 0.9
+    return 0.7
+
+
+def calculate_scroll_delta(viewport_height: int, base_ratio: float) -> float:
+    """计算滚动距离。"""
+    scroll_delta = viewport_height * (base_ratio + random.random() * 0.2)
+    if scroll_delta < 400:
+        scroll_delta = 400.0
+    return scroll_delta + random.randint(-50, 50)
+
+
+# 页面不可访问关键词
+INACCESSIBLE_KEYWORDS = [
+    "当前笔记暂时无法浏览",
+    "该内容因违规已被删除",
+    "该笔记已被删除",
+    "内容不存在",
+    "笔记不存在",
+    "已失效",
+    "私密笔记",
+    "仅作者可见",
+    "因用户设置，你无法查看",
+    "因违规无法查看",
+]

+"""点赞/收藏操作，对应 Go xiaohongshu/like_favorite.go。"""
+
+from __future__ import annotations
+
+import json
+import logging
+import time
+
+from .cdp import Page
+from .errors import NoFeedDetailError
+from .selectors import COLLECT_BUTTON, LIKE_BUTTON
+from .types import ActionResult
+from .urls import make_feed_detail_url
+
+logger = logging.getLogger(__name__)
+
+# 从 __INITIAL_STATE__ 读取互动状态的 JS
+_GET_INTERACT_STATE_JS = """
+(() => {
+    if (window.__INITIAL_STATE__ &&
+        window.__INITIAL_STATE__.note &&
+        window.__INITIAL_STATE__.note.noteDetailMap) {
+        return JSON.stringify(window.__INITIAL_STATE__.note.noteDetailMap);
+    }
+    return "";
+})()
+"""
+
+
+def _get_interact_state(page: Page, feed_id: str) -> tuple[bool, bool]:
+    """读取笔记的点赞/收藏状态。
+
+    Returns:
+        (liked, collected)
+
+    Raises:
+        NoFeedDetailError: 无法获取状态。
+    """
+    result = page.evaluate(_GET_INTERACT_STATE_JS)
+    if not result:
+        raise NoFeedDetailError()
+
+    note_detail_map = json.loads(result)
+    detail = note_detail_map.get(feed_id)
+    if not detail:
+        raise NoFeedDetailError()
+
+    interact = detail.get("note", {}).get("interactInfo", {})
+    return interact.get("liked", False), interact.get("collected", False)
+
+
+def _prepare_page(page: Page, feed_id: str, xsec_token: str) -> None:
+    """导航到 feed 详情页。"""
+    url = make_feed_detail_url(feed_id, xsec_token)
+    page.navigate(url)
+    page.wait_for_load()
+    page.wait_dom_stable()
+    time.sleep(1)
+
+
+# ========== 点赞 ==========
+
+
+def like_feed(page: Page, feed_id: str, xsec_token: str) -> ActionResult:
+    """点赞笔记（幂等：已点赞则跳过）。"""
+    _prepare_page(page, feed_id, xsec_token)
+    return _toggle_like(page, feed_id, target_liked=True)
+
+
+def unlike_feed(page: Page, feed_id: str, xsec_token: str) -> ActionResult:
+    """取消点赞（幂等：未点赞则跳过）。"""
+    _prepare_page(page, feed_id, xsec_token)
+    return _toggle_like(page, feed_id, target_liked=False)
+
+
+def _toggle_like(page: Page, feed_id: str, target_liked: bool) -> ActionResult:
+    """执行点赞/取消点赞操作。"""
+    action_name = "点赞" if target_liked else "取消点赞"
+
+    try:
+        liked, _ = _get_interact_state(page, feed_id)
+    except NoFeedDetailError:
+        logger.warning("无法读取互动状态，直接点击")
+        liked = not target_liked  # 强制执行点击
+
+    # 幂等检查
+    if liked == target_liked:
+        logger.info("feed %s 已%s，跳过", feed_id, action_name)
+        return ActionResult(feed_id=feed_id, success=True, message=f"已{action_name}")
+
+    # 点击
+    page.click_element(LIKE_BUTTON)
+    time.sleep(3)
+
+    # 验证
+    try:
+        liked, _ = _get_interact_state(page, feed_id)
+        if liked == target_liked:
+            logger.info("feed %s %s成功", feed_id, action_name)
+            return ActionResult(feed_id=feed_id, success=True, message=f"{action_name}成功")
+    except NoFeedDetailError:
+        pass
+
+    # 重试一次
+    logger.warning("feed %s %s可能未成功，重试", feed_id, action_name)
+    page.click_element(LIKE_BUTTON)
+    time.sleep(2)
+
+    return ActionResult(feed_id=feed_id, success=True, message=f"{action_name}已执行")
+
+
+# ========== 收藏 ==========
+
+
+def favorite_feed(page: Page, feed_id: str, xsec_token: str) -> ActionResult:
+    """收藏笔记（幂等：已收藏则跳过）。"""
+    _prepare_page(page, feed_id, xsec_token)
+    return _toggle_favorite(page, feed_id, target_collected=True)
+
+
+def unfavorite_feed(page: Page, feed_id: str, xsec_token: str) -> ActionResult:
+    """取消收藏（幂等：未收藏则跳过）。"""
+    _prepare_page(page, feed_id, xsec_token)
+    return _toggle_favorite(page, feed_id, target_collected=False)
+
+
+def _toggle_favorite(page: Page, feed_id: str, target_collected: bool) -> ActionResult:
+    """执行收藏/取消收藏操作。"""
+    action_name = "收藏" if target_collected else "取消收藏"
+
+    try:
+        _, collected = _get_interact_state(page, feed_id)
+    except NoFeedDetailError:
+        logger.warning("无法读取互动状态，直接点击")
+        collected = not target_collected
+
+    # 幂等检查
+    if collected == target_collected:
+        logger.info("feed %s 已%s，跳过", feed_id, action_name)
+        return ActionResult(feed_id=feed_id, success=True, message=f"已{action_name}")
+
+    # 点击
+    page.click_element(COLLECT_BUTTON)
+    time.sleep(3)
+
+    # 验证
+    try:
+        _, collected = _get_interact_state(page, feed_id)
+        if collected == target_collected:
+            logger.info("feed %s %s成功", feed_id, action_name)
+            return ActionResult(feed_id=feed_id, success=True, message=f"{action_name}成功")
+    except NoFeedDetailError:
+        pass
+
+    # 重试
+    logger.warning("feed %s %s可能未成功，重试", feed_id, action_name)
+    page.click_element(COLLECT_BUTTON)
+    time.sleep(2)
+
+    return ActionResult(feed_id=feed_id, success=True, message=f"{action_name}已执行")

+"""登录管理，对应 Go xiaohongshu/login.go。"""
+
+from __future__ import annotations
+
+import base64
+import logging
+import os
+import tempfile
+import time
+
+from .cdp import Page
+from .selectors import LOGIN_STATUS, QRCODE_IMG
+from .urls import EXPLORE_URL
+
+logger = logging.getLogger(__name__)
+
+
+def check_login_status(page: Page) -> bool:
+    """检查登录状态。
+
+    Returns:
+        True 已登录，False 未登录。
+    """
+    page.navigate(EXPLORE_URL)
+    page.wait_for_load()
+    time.sleep(1)
+
+    return page.has_element(LOGIN_STATUS)
+
+
+def fetch_qrcode(page: Page) -> tuple[str, bool]:
+    """获取登录二维码。
+
+    Returns:
+        (qrcode_src, already_logged_in)
+        - 如果已登录，返回 ("", True)
+        - 如果未登录，返回 (qrcode_base64_or_url, False)
+    """
+    page.navigate(EXPLORE_URL)
+    page.wait_for_load()
+    time.sleep(2)
+
+    # 检查是否已登录
+    if page.has_element(LOGIN_STATUS):
+        return "", True
+
+    # 获取二维码图片 src
+    src = page.get_element_attribute(QRCODE_IMG, "src")
+    if not src:
+        raise RuntimeError("二维码图片 src 为空")
+
+    return src, False
+
+
+def save_qrcode_to_file(src: str) -> str:
+    """将二维码 data URL 保存为临时 PNG 文件。
+
+    Args:
+        src: 二维码图片的 data URL（data:image/png;base64,...）或普通 URL。
+
+    Returns:
+        保存的文件绝对路径。
+    """
+    prefix = "data:image/png;base64,"
+    if src.startswith(prefix):
+        img_data = base64.b64decode(src[len(prefix) :])
+    elif src.startswith("data:image/"):
+        # 处理其他 MIME 类型，如 data:image/jpeg;base64,...
+        _, encoded = src.split(",", 1)
+        img_data = base64.b64decode(encoded)
+    else:
+        # 不是 data URL，无法保存
+        raise ValueError(f"不支持的二维码格式，需要 data URL: {src[:50]}...")
+
+    qr_dir = os.path.join(tempfile.gettempdir(), "xhs")
+    os.makedirs(qr_dir, exist_ok=True)
+    filepath = os.path.join(qr_dir, "login_qrcode.png")
+
+    with open(filepath, "wb") as f:
+        f.write(img_data)
+
+    logger.info("二维码已保存: %s", filepath)
+    return filepath
+
+
+def wait_for_login(page: Page, timeout: float = 120.0) -> bool:
+    """等待扫码登录完成。
+
+    Args:
+        page: CDP 页面对象。
+        timeout: 超时时间（秒）。
+
+    Returns:
+        True 登录成功，False 超时。
+    """
+    deadline = time.monotonic() + timeout
+    while time.monotonic() < deadline:
+        if page.has_element(LOGIN_STATUS):
+            logger.info("登录成功")
+            return True
+        time.sleep(0.5)
+    return False

+"""图文发布，对应 Go xiaohongshu/publish.go（837 行）。"""
+
+from __future__ import annotations
+
+import json
+import logging
+import random
+import time
+
+from .cdp import Page
+from .errors import ContentTooLongError, PublishError, TitleTooLongError, UploadTimeoutError
+from .selectors import (
+    CONTENT_EDITOR,
+    CONTENT_LENGTH_ERROR,
+    CREATOR_TAB,
+    DATETIME_INPUT,
+    FILE_INPUT,
+    IMAGE_PREVIEW,
+    ORIGINAL_SWITCH,
+    ORIGINAL_SWITCH_CARD,
+    POPOVER,
+    PUBLISH_BUTTON,
+    SCHEDULE_SWITCH,
+    TAG_FIRST_ITEM,
+    TAG_TOPIC_CONTAINER,
+    TITLE_INPUT,
+    TITLE_MAX_SUFFIX,
+    UPLOAD_CONTENT,
+    UPLOAD_INPUT,
+    VISIBILITY_DROPDOWN,
+    VISIBILITY_OPTIONS,
+)
+from .types import PublishImageContent
+from .urls import PUBLISH_URL
+
+logger = logging.getLogger(__name__)
+
+
+def publish_image_content(page: Page, content: PublishImageContent) -> None:
+    """发布图文内容。
+
+    Args:
+        page: CDP 页面对象。
+        content: 发布内容。
+
+    Raises:
+        PublishError: 发布失败。
+        UploadTimeoutError: 上传超时。
+        TitleTooLongError: 标题超长。
+        ContentTooLongError: 正文超长。
+    """
+    if not content.image_paths:
+        raise PublishError("图片不能为空")
+
+    # 导航到发布页
+    _navigate_to_publish_page(page)
+
+    # 点击"上传图文" TAB
+    _click_publish_tab(page, "上传图文")
+    time.sleep(1)
+
+    # 上传图片
+    _upload_images(page, content.image_paths)
+
+    # 标签截取
+    tags = content.tags[:10] if len(content.tags) > 10 else content.tags
+    if len(content.tags) > 10:
+        logger.warning("标签数量超过10，截取前10个")
+
+    logger.info(
+        "发布内容: title=%s, images=%d, tags=%d, schedule=%s, original=%s, visibility=%s",
+        content.title,
+        len(content.image_paths),
+        len(tags),
+        content.schedule_time,
+        content.is_original,
+        content.visibility,
+    )
+
+    # 提交发布
+    _submit_publish(
+        page,
+        content.title,
+        content.content,
+        tags,
+        content.schedule_time,
+        content.is_original,
+        content.visibility,
+    )
+
+
+# ========== 页面导航 ==========
+
+
+def _navigate_to_publish_page(page: Page) -> None:
+    """导航到发布页面。"""
+    page.navigate(PUBLISH_URL)
+    page.wait_for_load(timeout=300)
+    time.sleep(2)
+    page.wait_dom_stable()
+    time.sleep(1)
+
+
+def _click_publish_tab(page: Page, tab_name: str) -> None:
+    """点击发布页 TAB（上传图文/上传视频）。"""
+    page.wait_for_element(UPLOAD_CONTENT, timeout=15)
+
+    deadline = time.monotonic() + 15
+    while time.monotonic() < deadline:
+        # 查找匹配的 TAB
+        found = page.evaluate(
+            f"""
+            (() => {{
+                const tabs = document.querySelectorAll({json.dumps(CREATOR_TAB)});
+                for (const tab of tabs) {{
+                    if (tab.textContent.trim() === {json.dumps(tab_name)}) {{
+                        // 检查是否被遮挡
+                        const rect = tab.getBoundingClientRect();
+                        if (rect.width === 0 || rect.height === 0) continue;
+                        const x = rect.left + rect.width / 2;
+                        const y = rect.top + rect.height / 2;
+                        const target = document.elementFromPoint(x, y);
+                        if (target === tab || tab.contains(target)) {{
+                            tab.click();
+                            return 'clicked';
+                        }}
+                        return 'blocked';
+                    }}
+                }}
+                return 'not_found';
+            }})()
+            """
+        )
+
+        if found == "clicked":
+            return
+
+        if found == "blocked":
+            # 尝试移除弹窗
+            _remove_pop_cover(page)
+
+        time.sleep(0.2)
+
+    raise PublishError(f"没有找到发布 TAB - {tab_name}")
+
+
+def _remove_pop_cover(page: Page) -> None:
+    """移除弹窗遮挡。"""
+    if page.has_element(POPOVER):
+        page.remove_element(POPOVER)
+    # 点击空位置
+    x = 380 + random.randint(0, 100)
+    y = 20 + random.randint(0, 60)
+    page.mouse_click(float(x), float(y))
+
+
+# ========== 图片上传 ==========
+
+
+def _upload_images(page: Page, image_paths: list[str]) -> None:
+    """逐张上传图片。"""
+    import os
+
+    valid_paths = [p for p in image_paths if os.path.exists(p)]
+    if not valid_paths:
+        raise PublishError("没有有效的图片文件")
+
+    for i, path in enumerate(valid_paths):
+        selector = UPLOAD_INPUT if i == 0 else FILE_INPUT
+        logger.info("上传第 %d 张图片: %s", i + 1, path)
+
+        page.set_file_input(selector, [path])
+        _wait_for_upload_complete(page, i + 1)
+        time.sleep(1)
+
+
+def _wait_for_upload_complete(page: Page, expected_count: int) -> None:
+    """等待图片上传完成。"""
+    max_wait = 60.0
+    start = time.monotonic()
+
+    while time.monotonic() - start < max_wait:
+        count = page.get_elements_count(IMAGE_PREVIEW)
+        if count >= expected_count:
+            logger.info("图片上传完成: %d", count)
+            return
+        time.sleep(0.5)
+
+    raise UploadTimeoutError(f"第{expected_count}张图片上传超时(60s)")
+
+
+# ========== 表单提交 ==========
+
+
+def _submit_publish(
+    page: Page,
+    title: str,
+    content: str,
+    tags: list[str],
+    schedule_time: str | None,
+    is_original: bool,
+    visibility: str,
+) -> None:
+    """填写表单并提交。"""
+    # 标题
+    page.input_text(TITLE_INPUT, title)
+    time.sleep(0.5)
+    _check_title_max_length(page)
+    logger.info("标题长度检查通过")
+    time.sleep(1)
+
+    # 正文
+    content_selector = _find_content_element(page)
+    page.input_content_editable(content_selector, content)
+
+    # 回点标题（增强稳定性）
+    time.sleep(1)
+    page.click_element(TITLE_INPUT)
+    logger.info("已回点标题输入框")
+
+    # 标签
+    if tags:
+        _input_tags(page, content_selector, tags)
+    time.sleep(1)
+    _check_content_max_length(page)
+    logger.info("正文长度检查通过")
+
+    # 定时发布
+    if schedule_time:
+        _set_schedule_publish(page, schedule_time)
+
+    # 可见范围
+    _set_visibility(page, visibility)
+
+    # 原创声明
+    if is_original:
+        try:
+            _set_original(page)
+            logger.info("已声明原创")
+        except Exception as e:
+            logger.warning("设置原创声明失败: %s", e)
+
+    # 点击发布
+    page.click_element(PUBLISH_BUTTON)
+    time.sleep(3)
+    logger.info("发布完成")
+
+
+def _find_content_element(page: Page) -> str:
+    """查找内容输入框（兼容两种 UI）。"""
+    if page.has_element(CONTENT_EDITOR):
+        return CONTENT_EDITOR
+
+    # 查找带 placeholder 的 p 元素的 textbox 父元素
+    found = page.evaluate(
+        """
+        (() => {
+            const ps = document.querySelectorAll('p');
+            for (const p of ps) {
+                const placeholder = p.getAttribute('data-placeholder');
+                if (placeholder && placeholder.includes('输入正文描述')) {
+                    let current = p;
+                    for (let i = 0; i < 5; i++) {
+                        current = current.parentElement;
+                        if (!current) break;
+                        if (current.getAttribute('role') === 'textbox') {
+                            return 'found';
+                        }
+                    }
+                }
+            }
+            return '';
+        })()
+        """
+    )
+    if found == "found":
+        return "[role='textbox']"
+
+    raise PublishError("没有找到内容输入框")
+
+
+def _check_title_max_length(page: Page) -> None:
+    """检查标题长度是否超限。"""
+    text = page.get_element_text(TITLE_MAX_SUFFIX)
+    if text:
+        parts = text.split("/")
+        if len(parts) == 2:
+            raise TitleTooLongError(parts[0], parts[1])
+        raise TitleTooLongError(text, "?")
+
+
+def _check_content_max_length(page: Page) -> None:
+    """检查正文长度是否超限。"""
+    text = page.get_element_text(CONTENT_LENGTH_ERROR)
+    if text:
+        parts = text.split("/")
+        if len(parts) == 2:
+            raise ContentTooLongError(parts[0], parts[1])
+        raise ContentTooLongError(text, "?")
+
+
+# ========== 标签输入 ==========
+
+
+def _input_tags(page: Page, content_selector: str, tags: list[str]) -> None:
+    """输入标签。"""
+    time.sleep(1)
+
+    # 移动光标到正文末尾（20次 ArrowDown）
+    for _ in range(20):
+        page.press_key("ArrowDown")
+        time.sleep(0.01)
+
+    # 按两次回车换行
+    page.press_key("Enter")
+    page.press_key("Enter")
+    time.sleep(1)
+
+    for tag in tags:
+        tag = tag.lstrip("#")
+        _input_single_tag(page, content_selector, tag)
+
+
+def _input_single_tag(page: Page, content_selector: str, tag: str) -> None:
+    """输入单个标签。"""
+    # 输入 #
+    page.type_text("#", delay_ms=0)
+    time.sleep(0.2)
+
+    # 逐字输入标签
+    for char in tag:
+        page.type_text(char, delay_ms=50)
+
+    time.sleep(1)
+
+    # 尝试点击标签联想
+    if page.has_element(TAG_TOPIC_CONTAINER):
+        item_selector = f"{TAG_TOPIC_CONTAINER} {TAG_FIRST_ITEM}"
+        if page.has_element(item_selector):
+            page.click_element(item_selector)
+            logger.info("点击标签联想: %s", tag)
+            time.sleep(0.5)
+            return
+
+    # 没有联想，直接空格
+    logger.warning("未找到标签联想，直接输入空格: %s", tag)
+    page.type_text(" ", delay_ms=0)
+    time.sleep(0.5)
+
+
+# ========== 定时发布 ==========
+
+
+def _set_schedule_publish(page: Page, schedule_time: str) -> None:
+    """设置定时发布。"""
+    from datetime import datetime
+
+    # 解析 ISO8601 时间
+    try:
+        dt = datetime.fromisoformat(schedule_time)
+    except ValueError as e:
+        raise PublishError(f"定时发布时间格式错误: {e}") from e
+
+    # 点击定时发布开关
+    page.click_element(SCHEDULE_SWITCH)
+    time.sleep(0.8)
+
+    # 设置日期时间
+    datetime_str = dt.strftime("%Y-%m-%d %H:%M")
+    page.select_all_text(DATETIME_INPUT)
+    page.input_text(DATETIME_INPUT, datetime_str)
+    time.sleep(0.5)
+
+    logger.info("已设置定时发布: %s", datetime_str)
+
+
+# ========== 可见范围 ==========
+
+
+def _set_visibility(page: Page, visibility: str) -> None:
+    """设置可见范围。"""
+    if not visibility or visibility == "公开可见":
+        logger.info("可见范围: 公开可见（默认）")
+        return
+
+    supported = {"仅自己可见", "仅互关好友可见"}
+    if visibility not in supported:
+        raise PublishError(
+            f"不支持的可见范围: {visibility}，支持: 公开可见、仅自己可见、仅互关好友可见"
+        )
+
+    # 点击下拉框
+    page.click_element(VISIBILITY_DROPDOWN)
+    time.sleep(0.5)
+
+    # 查找并点击目标选项
+    clicked = page.evaluate(
+        f"""
+        (() => {{
+            const opts = document.querySelectorAll({json.dumps(VISIBILITY_OPTIONS)});
+            for (const opt of opts) {{
+                if (opt.textContent.includes({json.dumps(visibility)})) {{
+                    opt.click();
+                    return true;
+                }}
+            }}
+            return false;
+        }})()
+        """
+    )
+
+    if not clicked:
+        raise PublishError(f"未找到可见范围选项: {visibility}")
+
+    logger.info("已设置可见范围: %s", visibility)
+    time.sleep(0.2)
+
+
+# ========== 原创声明 ==========
+
+
+def _set_original(page: Page) -> None:
+    """设置原创声明。"""
+    # 查找原创声明卡片并点击开关
+    result = page.evaluate(
+        f"""
+        (() => {{
+            const cards = document.querySelectorAll({json.dumps(ORIGINAL_SWITCH_CARD)});
+            for (const card of cards) {{
+                if (!card.textContent.includes('原创声明')) continue;
+                const sw = card.querySelector({json.dumps(ORIGINAL_SWITCH)});
+                if (!sw) continue;
+                const input = sw.querySelector('input[type="checkbox"]');
+                if (input && input.checked) return 'already_on';
+                sw.click();
+                return 'clicked';
+            }}
+            return 'not_found';
+        }})()
+        """
+    )
+
+    if result == "already_on":
+        logger.info("原创声明已开启")
+        return
+
+    if result == "not_found":
+        raise PublishError("未找到原创声明选项")
+
+    time.sleep(0.5)
+
+    # 处理确认弹窗
+    _confirm_original_declaration(page)
+
+
+def _confirm_original_declaration(page: Page) -> None:
+    """处理原创声明确认弹窗。"""
+    time.sleep(0.8)
+
+    # 勾选 checkbox
+    page.evaluate(
+        """
+        (() => {
+            const footers = document.querySelectorAll('div.footer');
+            for (const footer of footers) {
+                if (!footer.textContent.includes('原创声明须知')) continue;
+                const cb = footer.querySelector('div.d-checkbox input[type="checkbox"]');
+                if (cb && !cb.checked) cb.click();
+                return;
+            }
+        })()
+        """
+    )
+    time.sleep(0.5)
+
+    # 点击声明原创按钮
+    result = page.evaluate(
+        """
+        (() => {
+            const footers = document.querySelectorAll('div.footer');
+            for (const footer of footers) {
+                if (!footer.textContent.includes('声明原创')) continue;
+                const btn = footer.querySelector('button.custom-button');
+                if (btn) {
+                    if (btn.classList.contains('disabled') || btn.disabled) {
+                        const cb = footer.querySelector('div.d-checkbox input[type="checkbox"]');
+                        if (cb && !cb.checked) cb.click();
+                        return 'button_disabled';
+                    }
+                    btn.click();
+                    return 'clicked';
+                }
+            }
+            return 'button_not_found';
+        })()
+        """
+    )
+
+    if result == "button_not_found":
+        raise PublishError("未找到声明原创按钮")
+    if result == "button_disabled":
+        raise PublishError("声明原创按钮仍处于禁用状态")
+
+    logger.info("已成功点击声明原创按钮")
+    time.sleep(0.3)

+"""视频发布，对应 Go xiaohongshu/publish_video.go。"""
+
+from __future__ import annotations
+
+import logging
+import os
+import time
+
+from .cdp import Page
+from .errors import PublishError, UploadTimeoutError
+from .publish import (
+    _click_publish_tab,
+    _find_content_element,
+    _input_tags,
+    _navigate_to_publish_page,
+    _set_schedule_publish,
+    _set_visibility,
+)
+from .selectors import (
+    FILE_INPUT,
+    PUBLISH_BUTTON,
+    TITLE_INPUT,
+    UPLOAD_INPUT,
+)
+from .types import PublishVideoContent
+
+logger = logging.getLogger(__name__)
+
+
+def publish_video_content(page: Page, content: PublishVideoContent) -> None:
+    """发布视频内容。
+
+    Args:
+        page: CDP 页面对象。
+        content: 视频发布内容。
+
+    Raises:
+        PublishError: 发布失败。
+        UploadTimeoutError: 上传/处理超时。
+    """
+    if not content.video_path:
+        raise PublishError("视频不能为空")
+
+    # 导航到发布页
+    _navigate_to_publish_page(page)
+
+    # 点击"上传视频" TAB
+    _click_publish_tab(page, "上传视频")
+    time.sleep(1)
+
+    # 上传视频
+    _upload_video(page, content.video_path)
+
+    # 提交
+    _submit_publish_video(
+        page,
+        content.title,
+        content.content,
+        content.tags,
+        content.schedule_time,
+        content.visibility,
+    )
+
+
+def _upload_video(page: Page, video_path: str) -> None:
+    """上传视频文件。"""
+    if not os.path.exists(video_path):
+        raise PublishError(f"视频文件不存在: {video_path}")
+
+    # 查找上传输入框
+    selector = UPLOAD_INPUT if page.has_element(UPLOAD_INPUT) else FILE_INPUT
+    page.set_file_input(selector, [video_path])
+
+    # 等待发布按钮可点击（视频处理完成）
+    _wait_for_publish_button_clickable(page)
+    logger.info("视频上传/处理完成")
+
+
+def _wait_for_publish_button_clickable(page: Page) -> None:
+    """等待发布按钮可点击（视频处理可能需要较长时间）。"""
+    max_wait = 600.0  # 10 分钟
+    start = time.monotonic()
+
+    logger.info("开始等待发布按钮可点击(视频)")
+
+    while time.monotonic() - start < max_wait:
+        clickable = page.evaluate(
+            f"""
+            (() => {{
+                const btn = document.querySelector({_js_str(PUBLISH_BUTTON)});
+                if (!btn) return false;
+                const rect = btn.getBoundingClientRect();
+                if (rect.width === 0 || rect.height === 0) return false;
+                if (btn.disabled) return false;
+                if (btn.classList.contains('disabled')) return false;
+                return true;
+            }})()
+            """
+        )
+        if clickable:
+            return
+        time.sleep(1)
+
+    raise UploadTimeoutError("等待发布按钮可点击超时(10分钟)")
+
+
+def _submit_publish_video(
+    page: Page,
+    title: str,
+    content: str,
+    tags: list[str],
+    schedule_time: str | None,
+    visibility: str,
+) -> None:
+    """填写视频表单并提交。"""
+    # 标题
+    page.input_text(TITLE_INPUT, title)
+    time.sleep(1)
+
+    # 正文 + 标签
+    content_selector = _find_content_element(page)
+    page.input_content_editable(content_selector, content)
+
+    # 回点标题
+    time.sleep(1)
+    page.click_element(TITLE_INPUT)
+
+    if tags:
+        _input_tags(page, content_selector, tags)
+    time.sleep(1)
+
+    # 定时发布
+    if schedule_time:
+        _set_schedule_publish(page, schedule_time)
+
+    # 可见范围
+    _set_visibility(page, visibility)
+
+    # 等待发布按钮可点击
+    _wait_for_publish_button_clickable(page)
+
+    # 点击发布
+    page.click_element(PUBLISH_BUTTON)
+    time.sleep(3)
+    logger.info("视频发布完成")
+
+
+def _js_str(s: str) -> str:
+    """将 Python 字符串转为 JS 字面量。"""
+    import json
+
+    return json.dumps(s)

+"""搜索 Feeds，对应 Go xiaohongshu/search.go。"""
+
+from __future__ import annotations
+
+import json
+import logging
+import time
+
+from .cdp import Page
+from .errors import NoFeedsError
+from .selectors import FILTER_BUTTON, FILTER_PANEL
+from .types import Feed, FilterOption
+from .urls import make_search_url
+
+logger = logging.getLogger(__name__)
+
+# 筛选选项映射表：{筛选组索引: [(标签索引, 文本), ...]}
+_FILTER_OPTIONS: dict[int, list[tuple[int, str]]] = {
+    1: [(1, "综合"), (2, "最新"), (3, "最多点赞"), (4, "最多评论"), (5, "最多收藏")],
+    2: [(1, "不限"), (2, "视频"), (3, "图文")],
+    3: [(1, "不限"), (2, "一天内"), (3, "一周内"), (4, "半年内")],
+    4: [(1, "不限"), (2, "已看过"), (3, "未看过"), (4, "已关注")],
+    5: [(1, "不限"), (2, "同城"), (3, "附近")],
+}
+
+# 从 __INITIAL_STATE__ 提取搜索结果的 JS
+_EXTRACT_SEARCH_JS = """
+(() => {
+    if (window.__INITIAL_STATE__ &&
+        window.__INITIAL_STATE__.search &&
+        window.__INITIAL_STATE__.search.feeds) {
+        const feeds = window.__INITIAL_STATE__.search.feeds;
+        const feedsData = feeds.value !== undefined ? feeds.value : feeds._value;
+        if (feedsData) {
+            return JSON.stringify(feedsData);
+        }
+    }
+    return "";
+})()
+"""
+
+
+def _find_internal_option(group_index: int, text: str) -> tuple[int, int]:
+    """查找内部筛选选项索引。
+
+    Returns:
+        (filters_index, tags_index)
+
+    Raises:
+        ValueError: 未找到匹配的选项。
+    """
+    options = _FILTER_OPTIONS.get(group_index)
+    if not options:
+        raise ValueError(f"筛选组 {group_index} 不存在")
+
+    for tags_index, option_text in options:
+        if option_text == text:
+            return group_index, tags_index
+
+    valid = [t for _, t in options]
+    raise ValueError(f"在筛选组 {group_index} 中未找到 '{text}'，有效值: {valid}")
+
+
+def _convert_filters(filter_opt: FilterOption) -> list[tuple[int, int]]:
+    """将 FilterOption 转换为内部 (filters_index, tags_index) 列表。"""
+    result: list[tuple[int, int]] = []
+
+    if filter_opt.sort_by:
+        result.append(_find_internal_option(1, filter_opt.sort_by))
+    if filter_opt.note_type:
+        result.append(_find_internal_option(2, filter_opt.note_type))
+    if filter_opt.publish_time:
+        result.append(_find_internal_option(3, filter_opt.publish_time))
+    if filter_opt.search_scope:
+        result.append(_find_internal_option(4, filter_opt.search_scope))
+    if filter_opt.location:
+        result.append(_find_internal_option(5, filter_opt.location))
+
+    return result
+
+
+def search_feeds(
+    page: Page,
+    keyword: str,
+    filter_option: FilterOption | None = None,
+) -> list[Feed]:
+    """搜索 Feeds。
+
+    Args:
+        page: CDP 页面对象。
+        keyword: 搜索关键词。
+        filter_option: 可选筛选条件。
+
+    Raises:
+        NoFeedsError: 没有捕获到搜索结果。
+        ValueError: 筛选选项无效。
+    """
+    search_url = make_search_url(keyword)
+    page.navigate(search_url)
+    page.wait_for_load()
+    page.wait_dom_stable()
+
+    # 等待 __INITIAL_STATE__ 初始化
+    _wait_for_initial_state(page)
+
+    # 应用筛选条件
+    if filter_option:
+        internal_filters = _convert_filters(filter_option)
+        if internal_filters:
+            _apply_filters(page, internal_filters)
+
+    # 提取搜索结果
+    result = page.evaluate(_EXTRACT_SEARCH_JS)
+    if not result:
+        raise NoFeedsError()
+
+    feeds_data = json.loads(result)
+    return [Feed.from_dict(f) for f in feeds_data]
+
+
+def _wait_for_initial_state(page: Page, timeout: float = 10.0) -> None:
+    """等待 __INITIAL_STATE__ 就绪。"""
+    deadline = time.monotonic() + timeout
+    while time.monotonic() < deadline:
+        ready = page.evaluate("window.__INITIAL_STATE__ !== undefined")
+        if ready:
+            return
+        time.sleep(0.5)
+    logger.warning("等待 __INITIAL_STATE__ 超时")
+
+
+def _apply_filters(page: Page, filters: list[tuple[int, int]]) -> None:
+    """应用筛选条件。"""
+    # 悬停筛选按钮
+    page.hover_element(FILTER_BUTTON)
+
+    # 等待筛选面板出现
+    deadline = time.monotonic() + 5.0
+    while time.monotonic() < deadline:
+        if page.has_element(FILTER_PANEL):
+            break
+        time.sleep(0.3)
+
+    # 点击各筛选项
+    for filters_index, tags_index in filters:
+        selector = (
+            f"div.filter-panel div.filters:nth-child({filters_index}) "
+            f"div.tags:nth-child({tags_index})"
+        )
+        page.click_element(selector)
+        time.sleep(0.3)
+
+    # 等待页面更新
+    page.wait_dom_stable()
+    _wait_for_initial_state(page)

+"""小红书页面 CSS 选择器常量。"""
+
+# ========== 登录 ==========
+LOGIN_STATUS = ".main-container .user .link-wrapper .channel"
+QRCODE_IMG = ".login-container .qrcode-img"
+
+# ========== 首页 / 搜索 ==========
+FILTER_BUTTON = "div.filter"
+FILTER_PANEL = "div.filter-panel"
+
+# ========== Feed 详情 ==========
+COMMENTS_CONTAINER = ".comments-container"
+PARENT_COMMENT = ".parent-comment"
+NO_COMMENTS_TEXT = ".no-comments-text"
+END_CONTAINER = ".end-container"
+TOTAL_COMMENT = ".comments-container .total"
+SHOW_MORE_BUTTON = ".show-more"
+NOTE_SCROLLER = ".note-scroller"
+INTERACTION_CONTAINER = ".interaction-container"
+
+# 页面不可访问容器
+ACCESS_ERROR_WRAPPER = ".access-wrapper, .error-wrapper, .not-found-wrapper, .blocked-wrapper"
+
+# ========== 评论输入 ==========
+COMMENT_INPUT_TRIGGER = "div.input-box div.content-edit span"
+COMMENT_INPUT_FIELD = "div.input-box div.content-edit p.content-input"
+COMMENT_SUBMIT_BUTTON = "div.bottom button.submit"
+REPLY_BUTTON = ".right .interactions .reply"
+
+# ========== 点赞 / 收藏 ==========
+LIKE_BUTTON = ".interact-container .left .like-lottie"
+COLLECT_BUTTON = ".interact-container .left .reds-icon.collect-icon"
+
+# ========== 发布页 ==========
+UPLOAD_CONTENT = "div.upload-content"
+CREATOR_TAB = "div.creator-tab"
+UPLOAD_INPUT = ".upload-input"
+FILE_INPUT = 'input[type="file"]'
+TITLE_INPUT = "div.d-input input"
+CONTENT_EDITOR = "div.ql-editor"
+IMAGE_PREVIEW = ".img-preview-area .pr"
+PUBLISH_BUTTON = ".publish-page-publish-btn button.bg-red"
+
+# 标题/正文长度校验
+TITLE_MAX_SUFFIX = "div.title-container div.max_suffix"
+CONTENT_LENGTH_ERROR = "div.edit-container div.length-error"
+
+# 可见范围
+VISIBILITY_DROPDOWN = "div.permission-card-wrapper div.d-select-content"
+VISIBILITY_OPTIONS = "div.d-options-wrapper div.d-grid-item div.custom-option"
+
+# 定时发布
+SCHEDULE_SWITCH = ".post-time-wrapper .d-switch"
+DATETIME_INPUT = ".date-picker-container input"
+
+# 原创声明
+ORIGINAL_SWITCH_CARD = "div.custom-switch-card"
+ORIGINAL_SWITCH = "div.d-switch"
+
+# 标签联想
+TAG_TOPIC_CONTAINER = "#creator-editor-topic-container"
+TAG_FIRST_ITEM = ".item"
+
+# 弹窗
+POPOVER = "div.d-popover"
+
+# ========== 用户主页 ==========
+SIDEBAR_PROFILE = "div.main-container li.user.side-bar-component a.link-wrapper span.channel"

+"""反检测 JS 注入 + Chrome 启动参数，对应 go-rod/stealth。"""
+
+# 反检测 JS 脚本：在页面加载时注入
+STEALTH_JS = """
+(() => {
+    // 1. navigator.webdriver
+    Object.defineProperty(navigator, 'webdriver', {
+        get: () => undefined,
+        configurable: true,
+    });
+
+    // 2. chrome.runtime
+    if (!window.chrome) {
+        window.chrome = {};
+    }
+    if (!window.chrome.runtime) {
+        window.chrome.runtime = {
+            connect: () => {},
+            sendMessage: () => {},
+        };
+    }
+
+    // 3. plugins
+    Object.defineProperty(navigator, 'plugins', {
+        get: () => {
+            return [
+                {
+                    0: {type: 'application/x-google-chrome-pdf'},
+                    description: 'Portable Document Format',
+                    filename: 'internal-pdf-viewer',
+                    length: 1,
+                    name: 'Chrome PDF Plugin',
+                },
+                {
+                    0: {type: 'application/pdf'},
+                    description: '',
+                    filename: 'mhjfbmdgcfjbbpaeojofohoefgiehjai',
+                    length: 1,
+                    name: 'Chrome PDF Viewer',
+                },
+                {
+                    0: {type: 'application/x-nacl'},
+                    description: '',
+                    filename: 'internal-nacl-plugin',
+                    length: 1,
+                    name: 'Native Client',
+                },
+            ];
+        },
+        configurable: true,
+    });
+
+    // 4. languages
+    Object.defineProperty(navigator, 'languages', {
+        get: () => ['zh-CN', 'zh', 'en-US', 'en'],
+        configurable: true,
+    });
+
+    // 5. permissions
+    const originalQuery = window.navigator.permissions?.query;
+    if (originalQuery) {
+        window.navigator.permissions.query = (parameters) =>
+            parameters.name === 'notifications'
+                ? Promise.resolve({ state: Notification.permission })
+                : originalQuery(parameters);
+    }
+
+    // 6. WebGL vendor/renderer
+    const getParameter = WebGLRenderingContext.prototype.getParameter;
+    WebGLRenderingContext.prototype.getParameter = function(parameter) {
+        if (parameter === 37445) return 'Intel Inc.';
+        if (parameter === 37446) return 'Intel Iris OpenGL Engine';
+        return getParameter.call(this, parameter);
+    };
+})();
+"""
+
+# Chrome 启动参数（反检测相关）
+STEALTH_ARGS = [
+    "--disable-blink-features=AutomationControlled",
+    "--disable-infobars",
+    "--no-first-run",
+    "--no-default-browser-check",
+    "--disable-background-timer-throttling",
+    "--disable-backgrounding-occluded-windows",
+    "--disable-renderer-backgrounding",
+    "--disable-component-update",
+]

+"""小红书数据类型定义，对应 Go types.go。"""
+
+from __future__ import annotations
+
+from dataclasses import dataclass, field
+
+# ========== Feed 列表 ==========
+
+
+@dataclass
+class ImageInfo:
+    image_scene: str = ""
+    url: str = ""
+
+    @classmethod
+    def from_dict(cls, d: dict) -> ImageInfo:
+        return cls(
+            image_scene=d.get("imageScene", ""),
+            url=d.get("url", ""),
+        )
+
+
+@dataclass
+class VideoCapability:
+    duration: int = 0  # 秒
+
+    @classmethod
+    def from_dict(cls, d: dict) -> VideoCapability:
+        return cls(duration=d.get("duration", 0))
+
+
+@dataclass
+class Video:
+    capa: VideoCapability = field(default_factory=VideoCapability)
+
+    @classmethod
+    def from_dict(cls, d: dict) -> Video:
+        return cls(capa=VideoCapability.from_dict(d.get("capa", {})))
+
+
+@dataclass
+class Cover:
+    width: int = 0
+    height: int = 0
+    url: str = ""
+    file_id: str = ""
+    url_pre: str = ""
+    url_default: str = ""
+    info_list: list[ImageInfo] = field(default_factory=list)
+
+    @classmethod
+    def from_dict(cls, d: dict) -> Cover:
+        return cls(
+            width=d.get("width", 0),
+            height=d.get("height", 0),
+            url=d.get("url", ""),
+            file_id=d.get("fileId", ""),
+            url_pre=d.get("urlPre", ""),
+            url_default=d.get("urlDefault", ""),
+            info_list=[ImageInfo.from_dict(i) for i in d.get("infoList", [])],
+        )
+
+
+@dataclass
+class User:
+    user_id: str = ""
+    nickname: str = ""
+    nick_name: str = ""
+    avatar: str = ""
+
+    @classmethod
+    def from_dict(cls, d: dict) -> User:
+        return cls(
+            user_id=d.get("userId", ""),
+            nickname=d.get("nickname", ""),
+            nick_name=d.get("nickName", ""),
+            avatar=d.get("avatar", ""),
+        )
+
+
+@dataclass
+class InteractInfo:
+    liked: bool = False
+    liked_count: str = ""
+    shared_count: str = ""
+    comment_count: str = ""
+    collected_count: str = ""
+    collected: bool = False
+
+    @classmethod
+    def from_dict(cls, d: dict) -> InteractInfo:
+        return cls(
+            liked=d.get("liked", False),
+            liked_count=d.get("likedCount", ""),
+            shared_count=d.get("sharedCount", ""),
+            comment_count=d.get("commentCount", ""),
+            collected_count=d.get("collectedCount", ""),
+            collected=d.get("collected", False),
+        )
+
+
+@dataclass
+class NoteCard:
+    type: str = ""
+    display_title: str = ""
+    user: User = field(default_factory=User)
+    interact_info: InteractInfo = field(default_factory=InteractInfo)
+    cover: Cover = field(default_factory=Cover)
+    video: Video | None = None
+
+    @classmethod
+    def from_dict(cls, d: dict) -> NoteCard:
+        video_data = d.get("video")
+        return cls(
+            type=d.get("type", ""),
+            display_title=d.get("displayTitle", ""),
+            user=User.from_dict(d.get("user", {})),
+            interact_info=InteractInfo.from_dict(d.get("interactInfo", {})),
+            cover=Cover.from_dict(d.get("cover", {})),
+            video=Video.from_dict(video_data) if video_data else None,
+        )
+
+
+@dataclass
+class Feed:
+    xsec_token: str = ""
+    id: str = ""
+    model_type: str = ""
+    note_card: NoteCard = field(default_factory=NoteCard)
+    index: int = 0
+
+    @classmethod
+    def from_dict(cls, d: dict) -> Feed:
+        return cls(
+            xsec_token=d.get("xsecToken", ""),
+            id=d.get("id", ""),
+            model_type=d.get("modelType", ""),
+            note_card=NoteCard.from_dict(d.get("noteCard", {})),
+            index=d.get("index", 0),
+        )
+
+    def to_dict(self) -> dict:
+        """序列化为 JSON 兼容的字典。"""
+        result: dict = {
+            "id": self.id,
+            "xsecToken": self.xsec_token,
+            "modelType": self.model_type,
+            "index": self.index,
+            "displayTitle": self.note_card.display_title,
+            "type": self.note_card.type,
+            "user": {
+                "userId": self.note_card.user.user_id,
+                "nickname": self.note_card.user.nickname or self.note_card.user.nick_name,
+            },
+            "interactInfo": {
+                "likedCount": self.note_card.interact_info.liked_count,
+                "collectedCount": self.note_card.interact_info.collected_count,
+                "commentCount": self.note_card.interact_info.comment_count,
+                "sharedCount": self.note_card.interact_info.shared_count,
+            },
+        }
+        if self.note_card.video:
+            result["video"] = {"duration": self.note_card.video.capa.duration}
+        return result
+
+
+# ========== Feed 详情 ==========
+
+
+@dataclass
+class DetailImageInfo:
+    width: int = 0
+    height: int = 0
+    url_default: str = ""
+    url_pre: str = ""
+    live_photo: bool = False
+
+    @classmethod
+    def from_dict(cls, d: dict) -> DetailImageInfo:
+        return cls(
+            width=d.get("width", 0),
+            height=d.get("height", 0),
+            url_default=d.get("urlDefault", ""),
+            url_pre=d.get("urlPre", ""),
+            live_photo=d.get("livePhoto", False),
+        )
+
+
+@dataclass
+class Comment:
+    id: str = ""
+    note_id: str = ""
+    content: str = ""
+    like_count: str = ""
+    create_time: int = 0
+    ip_location: str = ""
+    liked: bool = False
+    user_info: User = field(default_factory=User)
+    sub_comment_count: str = ""
+    sub_comments: list[Comment] = field(default_factory=list)
+    show_tags: list[str] = field(default_factory=list)
+
+    @classmethod
+    def from_dict(cls, d: dict) -> Comment:
+        return cls(
+            id=d.get("id", ""),
+            note_id=d.get("noteId", ""),
+            content=d.get("content", ""),
+            like_count=d.get("likeCount", ""),
+            create_time=d.get("createTime", 0),
+            ip_location=d.get("ipLocation", ""),
+            liked=d.get("liked", False),
+            user_info=User.from_dict(d.get("userInfo", {})),
+            sub_comment_count=d.get("subCommentCount", ""),
+            sub_comments=[cls.from_dict(c) for c in d.get("subComments", []) or []],
+            show_tags=d.get("showTags", []) or [],
+        )
+
+    def to_dict(self) -> dict:
+        result: dict = {
+            "id": self.id,
+            "content": self.content,
+            "likeCount": self.like_count,
+            "createTime": self.create_time,
+            "ipLocation": self.ip_location,
+            "user": {
+                "userId": self.user_info.user_id,
+                "nickname": self.user_info.nickname or self.user_info.nick_name,
+            },
+            "subCommentCount": self.sub_comment_count,
+        }
+        if self.sub_comments:
+            result["subComments"] = [c.to_dict() for c in self.sub_comments]
+        return result
+
+
+@dataclass
+class CommentList:
+    list_: list[Comment] = field(default_factory=list)
+    cursor: str = ""
+    has_more: bool = False
+
+    @classmethod
+    def from_dict(cls, d: dict) -> CommentList:
+        return cls(
+            list_=[Comment.from_dict(c) for c in d.get("list", []) or []],
+            cursor=d.get("cursor", ""),
+            has_more=d.get("hasMore", False),
+        )
+
+
+@dataclass
+class FeedDetail:
+    note_id: str = ""
+    xsec_token: str = ""
+    title: str = ""
+    desc: str = ""
+    type: str = ""
+    time: int = 0
+    ip_location: str = ""
+    user: User = field(default_factory=User)
+    interact_info: InteractInfo = field(default_factory=InteractInfo)
+    image_list: list[DetailImageInfo] = field(default_factory=list)
+
+    @classmethod
+    def from_dict(cls, d: dict) -> FeedDetail:
+        return cls(
+            note_id=d.get("noteId", ""),
+            xsec_token=d.get("xsecToken", ""),
+            title=d.get("title", ""),
+            desc=d.get("desc", ""),
+            type=d.get("type", ""),
+            time=d.get("time", 0),
+            ip_location=d.get("ipLocation", ""),
+            user=User.from_dict(d.get("user", {})),
+            interact_info=InteractInfo.from_dict(d.get("interactInfo", {})),
+            image_list=[DetailImageInfo.from_dict(i) for i in d.get("imageList", []) or []],
+        )
+
+    def to_dict(self) -> dict:
+        return {
+            "noteId": self.note_id,
+            "title": self.title,
+            "desc": self.desc,
+            "type": self.type,
+            "time": self.time,
+            "ipLocation": self.ip_location,
+            "user": {
+                "userId": self.user.user_id,
+                "nickname": self.user.nickname or self.user.nick_name,
+            },
+            "interactInfo": {
+                "liked": self.interact_info.liked,
+                "likedCount": self.interact_info.liked_count,
+                "collectedCount": self.interact_info.collected_count,
+                "collected": self.interact_info.collected,
+                "commentCount": self.interact_info.comment_count,
+                "sharedCount": self.interact_info.shared_count,
+            },
+            "imageList": [
+                {
+                    "width": img.width,
+                    "height": img.height,
+                    "urlDefault": img.url_default,
+                }
+                for img in self.image_list
+            ],
+        }
+
+
+@dataclass
+class FeedDetailResponse:
+    note: FeedDetail = field(default_factory=FeedDetail)
+    comments: CommentList = field(default_factory=CommentList)
+
+    @classmethod
+    def from_dict(cls, d: dict) -> FeedDetailResponse:
+        return cls(
+            note=FeedDetail.from_dict(d.get("note", {})),
+            comments=CommentList.from_dict(d.get("comments", {})),
+        )
+
+    def to_dict(self) -> dict:
+        return {
+            "note": self.note.to_dict(),
+            "comments": [c.to_dict() for c in self.comments.list_],
+        }
+
+
+# ========== 用户主页 ==========
+
+
+@dataclass
+class UserBasicInfo:
+    gender: int = 0
+    ip_location: str = ""
+    desc: str = ""
+    imageb: str = ""
+    nickname: str = ""
+    images: str = ""
+    red_id: str = ""
+
+    @classmethod
+    def from_dict(cls, d: dict) -> UserBasicInfo:
+        return cls(
+            gender=d.get("gender", 0),
+            ip_location=d.get("ipLocation", ""),
+            desc=d.get("desc", ""),
+            imageb=d.get("imageb", ""),
+            nickname=d.get("nickname", ""),
+            images=d.get("images", ""),
+            red_id=d.get("redId", ""),
+        )
+
+
+@dataclass
+class UserInteraction:
+    type: str = ""
+    name: str = ""
+    count: str = ""
+
+    @classmethod
+    def from_dict(cls, d: dict) -> UserInteraction:
+        return cls(
+            type=d.get("type", ""),
+            name=d.get("name", ""),
+            count=d.get("count", ""),
+        )
+
+
+@dataclass
+class UserProfileResponse:
+    user_basic_info: UserBasicInfo = field(default_factory=UserBasicInfo)
+    interactions: list[UserInteraction] = field(default_factory=list)
+    feeds: list[Feed] = field(default_factory=list)
+
+    def to_dict(self) -> dict:
+        return {
+            "basicInfo": {
+                "nickname": self.user_basic_info.nickname,
+                "redId": self.user_basic_info.red_id,
+                "desc": self.user_basic_info.desc,
+                "gender": self.user_basic_info.gender,
+                "ipLocation": self.user_basic_info.ip_location,
+            },
+            "interactions": [
+                {"type": i.type, "name": i.name, "count": i.count} for i in self.interactions
+            ],
+            "feeds": [f.to_dict() for f in self.feeds],
+        }
+
+
+# ========== 搜索 ==========
+
+
+@dataclass
+class FilterOption:
+    """搜索筛选选项。"""
+
+    sort_by: str = ""  # 综合|最新|最多点赞|最多评论|最多收藏
+    note_type: str = ""  # 不限|视频|图文
+    publish_time: str = ""  # 不限|一天内|一周内|半年内
+    search_scope: str = ""  # 不限|已看过|未看过|已关注
+    location: str = ""  # 不限|同城|附近
+
+
+# ========== 发布 ==========
+
+
+@dataclass
+class PublishImageContent:
+    """图文发布内容。"""
+
+    title: str = ""
+    content: str = ""
+    tags: list[str] = field(default_factory=list)
+    image_paths: list[str] = field(default_factory=list)
+    schedule_time: str | None = None  # ISO8601 格式，None 表示立即发布
+    is_original: bool = False
+    visibility: str = ""  # 公开可见(默认)|仅自己可见|仅互关好友可见
+
+
+@dataclass
+class PublishVideoContent:
+    """视频发布内容。"""
+
+    title: str = ""
+    content: str = ""
+    tags: list[str] = field(default_factory=list)
+    video_path: str = ""
+    schedule_time: str | None = None  # ISO8601 格式
+    visibility: str = ""  # 公开可见(默认)|仅自己可见|仅互关好友可见
+
+
+# ========== 互动 ==========
+
+
+@dataclass
+class ActionResult:
+    """通用动作响应（点赞/收藏等）。"""
+
+    feed_id: str = ""
+    success: bool = False
+    message: str = ""
+
+    def to_dict(self) -> dict:
+        return {
+            "feed_id": self.feed_id,
+            "success": self.success,
+            "message": self.message,
+        }
+
+
+# ========== 评论加载配置 ==========
+
+
+@dataclass
+class CommentLoadConfig:
+    """评论加载配置。"""
+
+    click_more_replies: bool = False
+    max_replies_threshold: int = 10
+    max_comment_items: int = 0  # 0 = 不限
+    scroll_speed: str = "normal"  # slow|normal|fast

+"""小红书 URL 常量和构建函数。"""
+
+from urllib.parse import urlencode
+
+# 基础页面
+EXPLORE_URL = "https://www.xiaohongshu.com/explore"
+HOME_URL = "https://www.xiaohongshu.com"
+PUBLISH_URL = "https://creator.xiaohongshu.com/publish/publish?source=official"
+
+
+def make_feed_detail_url(feed_id: str, xsec_token: str) -> str:
+    """构建 feed 详情页 URL。"""
+    return (
+        f"https://www.xiaohongshu.com/explore/{feed_id}?xsec_token={xsec_token}&xsec_source=pc_feed"
+    )
+
+
+def make_search_url(keyword: str) -> str:
+    """构建搜索结果页 URL。"""
+    params = urlencode({"keyword": keyword, "source": "web_explore_feed"})
+    return f"https://www.xiaohongshu.com/search_result?{params}"
+
+
+def make_user_profile_url(user_id: str, xsec_token: str) -> str:
+    """构建用户主页 URL。"""
+    return (
+        f"https://www.xiaohongshu.com/user/profile/{user_id}"
+        f"?xsec_token={xsec_token}&xsec_source=pc_note"
+    )

+"""用户主页，对应 Go xiaohongshu/user_profile.go。"""
+
+from __future__ import annotations
+
+import json
+import logging
+import time
+
+from .cdp import Page
+from .types import Feed, UserBasicInfo, UserInteraction, UserProfileResponse
+from .urls import make_user_profile_url
+
+logger = logging.getLogger(__name__)
+
+# 提取用户数据的 JS
+_EXTRACT_USER_DATA_JS = """
+(() => {
+    if (window.__INITIAL_STATE__ &&
+        window.__INITIAL_STATE__.user &&
+        window.__INITIAL_STATE__.user.userPageData) {
+        const userPageData = window.__INITIAL_STATE__.user.userPageData;
+        const data = userPageData.value !== undefined ? userPageData.value : userPageData._value;
+        if (data) {
+            return JSON.stringify(data);
+        }
+    }
+    return "";
+})()
+"""
+
+_EXTRACT_USER_NOTES_JS = """
+(() => {
+    if (window.__INITIAL_STATE__ &&
+        window.__INITIAL_STATE__.user &&
+        window.__INITIAL_STATE__.user.notes) {
+        const notes = window.__INITIAL_STATE__.user.notes;
+        const data = notes.value !== undefined ? notes.value : notes._value;
+        if (data) {
+            return JSON.stringify(data);
+        }
+    }
+    return "";
+})()
+"""
+
+
+def get_user_profile(page: Page, user_id: str, xsec_token: str) -> UserProfileResponse:
+    """获取用户主页信息及帖子。
+
+    Args:
+        page: CDP 页面对象。
+        user_id: 用户 ID。
+        xsec_token: xsec_token。
+
+    Raises:
+        RuntimeError: 数据提取失败。
+    """
+    url = make_user_profile_url(user_id, xsec_token)
+    page.navigate(url)
+    page.wait_for_load()
+    page.wait_dom_stable()
+
+    return _extract_user_profile_data(page)
+
+
+def _extract_user_profile_data(page: Page) -> UserProfileResponse:
+    """从页面提取用户资料数据。"""
+    # 等待 __INITIAL_STATE__
+    _wait_for_initial_state(page)
+
+    # 提取用户信息
+    user_data_result = page.evaluate(_EXTRACT_USER_DATA_JS)
+    if not user_data_result:
+        raise RuntimeError("user.userPageData.value not found in __INITIAL_STATE__")
+
+    # 提取用户帖子
+    notes_result = page.evaluate(_EXTRACT_USER_NOTES_JS)
+    if not notes_result:
+        raise RuntimeError("user.notes.value not found in __INITIAL_STATE__")
+
+    # 解析用户信息
+    user_page_data = json.loads(user_data_result)
+    basic_info = UserBasicInfo.from_dict(user_page_data.get("basicInfo", {}))
+    interactions = [UserInteraction.from_dict(i) for i in user_page_data.get("interactions", [])]
+
+    # 解析帖子（双重数组，展平）
+    notes_feeds_raw = json.loads(notes_result)
+    feeds: list[Feed] = []
+    for feed_group in notes_feeds_raw:
+        if isinstance(feed_group, list):
+            for f in feed_group:
+                feeds.append(Feed.from_dict(f))
+        elif isinstance(feed_group, dict):
+            feeds.append(Feed.from_dict(feed_group))
+
+    return UserProfileResponse(
+        user_basic_info=basic_info,
+        interactions=interactions,
+        feeds=feeds,
+    )
+
+
+def _wait_for_initial_state(page: Page, timeout: float = 10.0) -> None:
+    """等待 __INITIAL_STATE__ 就绪。"""
+    deadline = time.monotonic() + timeout
+    while time.monotonic() < deadline:
+        ready = page.evaluate("window.__INITIAL_STATE__ !== undefined")
+        if ready:
+            return
+        time.sleep(0.5)
+    logger.warning("等待 __INITIAL_STATE__ 超时")

+---
+name: xhs-auth
+description: |
+  小红书认证管理技能。检查登录状态、扫码登录、多账号管理。
+  当用户要求登录小红书、检查登录状态、切换账号时触发。
+---
+
+# 小红书认证管理
+
+你是"小红书认证助手"。负责管理小红书登录状态和多账号切换。
+
+## 输入判断
+
+按优先级判断用户意图：
+
+1. 用户要求"检查登录 / 是否登录 / 登录状态"：执行登录状态检查。
+2. 用户要求"登录 / 扫码登录 / 打开登录页"：执行登录流程。
+3. 用户要求"切换账号 / 换一个账号 / 退出登录 / 清除登录"：执行 cookie 清除。
+
+## 必做约束
+
+- 登录操作需要用户手动扫码，不可自动化完成。
+- 所有 CLI 命令位于 `scripts/cli.py`，输出 JSON。
+- 需要先有运行中的 Chrome（通过 `scripts/chrome_launcher.py` 启动）。
+- 如果使用文件路径，必须使用绝对路径。
+
+## 工作流程
+
+### 检查登录状态
+
+```bash
+# 默认连接本地 Chrome
+python scripts/cli.py check-login
+
+# 指定端口
+python scripts/cli.py --port 9222 check-login
+
+# 连接远程 Chrome
+python scripts/cli.py --host 10.0.0.12 --port 9222 check-login
+```
+
+输出解读：
+- `"logged_in": true` + exit code 0 → 已登录，可执行后续操作。
+- `"logged_in": false` + exit code 1 → 未登录，提示用户扫码。
+
+### 登录流程
+
+1. 确保 Chrome 已启动（有窗口模式，便于扫码）：
+```bash
+python scripts/chrome_launcher.py
+```
+
+2. 获取登录二维码并等待扫码：
+```bash
+python scripts/cli.py login
+```
+
+3. 脚本首先输出一行 JSON，包含 `qrcode_path` 字段（二维码图片保存路径），然后阻塞等待扫码。
+
+4. **展示二维码给用户**：从输出中提取 `qrcode_path`，用系统命令打开图片供用户扫码：
+```bash
+# macOS
+open /tmp/xhs/login_qrcode.png
+
+# Linux
+xdg-open /tmp/xhs/login_qrcode.png
+```
+告知用户："请用小红书 App 扫描二维码登录"。
+
+5. 用户扫码成功后，脚本自动检测并输出第二行 JSON：`"logged_in": true`。
+
+**注意**：`login` 命令会阻塞最多 120 秒等待扫码。由于命令阻塞期间无法执行其他操作，应提前在另一个终端或通过后台方式打开图片。推荐流程是先运行 `login` 命令（它会立即输出二维码路径），然后提示用户自行打开图片文件扫码。
+
+### 清除 Cookies（切换账号/退出登录）
+
+```bash
+# 清除当前账号 cookies
+python scripts/cli.py delete-cookies
+
+# 指定账号清除
+python scripts/cli.py --account work delete-cookies
+```
+
+### 启动 / 关闭浏览器
+
+```bash
+# 启动 Chrome（有窗口，推荐用于登录）
+python scripts/chrome_launcher.py
+
+# 无头启动
+python scripts/chrome_launcher.py --headless
+
+# 指定端口
+python scripts/chrome_launcher.py --port 9223
+
+# 关闭 Chrome
+python scripts/chrome_launcher.py --kill
+```
+
+## 失败处理
+
+- **Chrome 未找到**：提示用户安装 Google Chrome 或设置路径。
+- **端口被占用**：提示使用 `--port` 指定其他端口，或先执行 `--kill` 关闭现有实例。
+- **扫码超时**：提示用户重新执行登录命令。
+- **远程 CDP 连接失败**：检查远程 Chrome 是否已开启调试端口。

+---
+name: xhs-content-ops
+description: |
+  小红书复合内容运营技能。组合搜索、详情、发布、互动等能力完成运营工作流。
+  当用户要求竞品分析、热点追踪、内容创作、互动管理等复合任务时触发。
+---
+
+# 小红书复合内容运营
+
+你是"小红书内容运营助手"。帮助用户完成需要多步骤组合的运营任务。
+
+## 输入判断
+
+按优先级判断：
+
+1. 用户要求"竞品分析 / 分析竞品 / 对比笔记"：执行竞品分析流程。
+2. 用户要求"热点追踪 / 热门话题 / 趋势分析"：执行热点追踪流程。
+3. 用户要求"创作发布 / 研究话题后发布 / 一键创作"：执行内容创作流程。
+4. 用户要求"互动管理 / 批量互动 / 评论策略"：执行互动管理流程。
+
+## 必做约束
+
+- 复合流程中每一步都应向用户报告进度。
+- 发布类操作必须经过用户确认（参考 xhs-publish 约束）。
+- 评论类操作必须经过用户确认（参考 xhs-interact 约束）。
+- 搜索和浏览操作之间保持合理间隔，避免频率过高。
+- 所有数据分析结果使用 markdown 表格结构化呈现。
+
+## 工作流程
+
+### 竞品分析
+
+目标：搜索竞品笔记 → 获取详情 → 整理分析报告。
+
+**步骤：**
+
+1. 确认分析目标（关键词、竞品账号）。
+2. 搜索相关笔记：
+```bash
+python scripts/cli.py search-feeds \
+  --keyword "目标关键词" --sort-by 最多点赞
+```
+3. 从搜索结果中选取 3-5 篇高互动笔记，逐一获取详情：
+```bash
+python scripts/cli.py get-feed-detail \
+  --feed-id FEED_ID --xsec-token XSEC_TOKEN
+```
+4. 整理分析报告，包含：
+   - 标题风格分析
+   - 封面图特点
+   - 正文结构（开头/中间/结尾）
+   - 话题标签使用
+   - 互动数据对比（点赞/评论/收藏）
+
+**输出格式：**
+
+使用 markdown 表格对比各笔记的关键指标，并总结共性特征和差异化策略。
+
+### 热点追踪
+
+目标：搜索热门关键词 → 分析趋势 → 提供选题建议。
+
+**步骤：**
+
+1. 确认追踪领域或关键词列表。
+2. 对每个关键词分别搜索：
+```bash
+# 按最新排序，观察近期热度
+python scripts/cli.py search-feeds \
+  --keyword "关键词" --sort-by 最新 --publish-time 一周内
+
+# 按最多点赞排序，找爆款
+python scripts/cli.py search-feeds \
+  --keyword "关键词" --sort-by 最多点赞
+```
+3. 对高互动笔记获取详情，分析内容模式。
+4. 输出趋势报告：
+   - 各关键词热度排名
+   - 爆款内容特征
+   - 选题建议
+
+### 内容创作
+
+目标：研究话题 → 辅助生成草稿 → 用户确认 → 发布。
+
+**步骤：**
+
+1. 确认创作主题。
+2. 搜索相关笔记，获取灵感：
+```bash
+python scripts/cli.py search-feeds \
+  --keyword "主题关键词" --sort-by 最多点赞
+```
+3. 选取 2-3 篇参考笔记，获取详情分析内容结构。
+4. 基于分析结果，辅助用户生成草稿：
+   - 标题（符合小红书风格，UTF-16 长度 ≤ 20）
+   - 正文（段落清晰，口语化）
+   - 话题标签
+5. 通过 `AskUserQuestion` 让用户确认最终内容。
+6. 执行发布（参考 xhs-publish 流程）：
+```bash
+python scripts/cli.py publish \
+  --title-file /tmp/xhs_title.txt \
+  --content-file /tmp/xhs_content.txt \
+  --images "/abs/path/pic1.jpg" "/abs/path/pic2.jpg" \
+  --tags "标签1" "标签2"
+```
+
+### 互动管理
+
+目标：浏览目标笔记 → 有策略地评论/点赞/收藏。
+
+**步骤：**
+
+1. 确认互动目标（关键词、话题领域）。
+2. 搜索目标笔记：
+```bash
+python scripts/cli.py search-feeds \
+  --keyword "目标关键词" --sort-by 最新
+```
+3. 筛选适合互动的笔记（中等互动量、与自身领域相关）。
+4. 获取详情，了解笔记内容：
+```bash
+python scripts/cli.py get-feed-detail \
+  --feed-id FEED_ID --xsec-token XSEC_TOKEN
+```
+5. 针对笔记内容生成有价值的评论建议。
+6. 用户确认评论内容后发送：
+```bash
+python scripts/cli.py post-comment \
+  --feed-id FEED_ID \
+  --xsec-token XSEC_TOKEN \
+  --content "评论内容"
+```
+7. 可选：点赞或收藏：
+```bash
+python scripts/cli.py like-feed \
+  --feed-id FEED_ID --xsec-token XSEC_TOKEN
+
+python scripts/cli.py favorite-feed \
+  --feed-id FEED_ID --xsec-token XSEC_TOKEN
+```
+8. 每次互动之间保持 30-60 秒间隔。
+
+## 运营建议
+
+- **竞品分析频率**：每周 1-2 次，跟踪竞品动态。
+- **热点追踪频率**：每天 1 次，抓住时效性内容。
+- **互动频率**：每天不超过 20 条评论，避免被限流。
+- **发布时间**：工作日 12:00-13:00、18:00-21:00 为高峰时段。
+
+## 失败处理
+
+- **搜索无结果**：扩大关键词范围或调整筛选条件。
+- **详情获取失败**：笔记可能已删除或设为私密。
+- **发布失败**：参考 xhs-publish 的失败处理。
+- **评论失败**：参考 xhs-interact 的失败处理。
+- **频率限制**：增大操作间隔，降低频率。

+---
+name: xhs-explore
+description: |
+  小红书内容发现与分析技能。搜索笔记、浏览首页、查看详情、获取用户资料。
+  当用户要求搜索小红书、查看笔记详情、浏览首页、查看用户主页时触发。
+---
+
+# 小红书内容发现
+
+你是"小红书内容发现助手"。帮助用户搜索、浏览和分析小红书内容。
+
+## 输入判断
+
+按优先级判断：
+
+1. 用户要求"搜索笔记 / 找内容 / 搜关键词"：执行搜索流程。
+2. 用户要求"查看笔记详情 / 看这篇帖子"：执行详情获取流程。
+3. 用户要求"首页推荐 / 浏览首页"：执行首页 Feed 获取。
+4. 用户要求"查看用户主页 / 看看这个博主"：执行用户资料获取。
+
+## 必做约束
+
+- 所有操作需要已登录的 Chrome 浏览器。
+- `feed_id` 和 `xsec_token` 必须配对使用，从搜索结果或首页 Feed 中获取。
+- 结果应结构化呈现，突出关键字段。
+- CLI 输出为 JSON 格式。
+
+## 工作流程
+
+### 首页 Feed 列表
+
+获取小红书首页推荐内容：
+
+```bash
+python scripts/cli.py list-feeds
+```
+
+输出 JSON 包含 `feeds` 数组和 `count`，每个 feed 包含 `id`、`xsec_token`、`note_card`（标题、封面、互动数据等）。
+
+### 搜索笔记
+
+```bash
+# 基础搜索
+python scripts/cli.py search-feeds --keyword "春招"
+
+# 带筛选搜索
+python scripts/cli.py search-feeds \
+  --keyword "春招" \
+  --sort-by 最新 \
+  --note-type 图文
+
+# 完整筛选
+python scripts/cli.py search-feeds \
+  --keyword "春招" \
+  --sort-by 最多点赞 \
+  --note-type 图文 \
+  --publish-time 一周内 \
+  --search-scope 未看过
+```
+
+#### 搜索筛选参数
+
+| 参数 | 可选值 |
+|------|--------|
+| `--sort-by` | 综合、最新、最多点赞、最多评论、最多收藏 |
+| `--note-type` | 不限、视频、图文 |
+| `--publish-time` | 不限、一天内、一周内、半年内 |
+| `--search-scope` | 不限、已看过、未看过、已关注 |
+| `--location` | 不限、同城、附近 |
+
+#### 搜索结果字段
+
+输出 JSON 包含：
+- `feeds`：笔记列表，每项包含 `id`、`xsec_token`、`note_card`（标题、封面、用户信息、互动数据）
+- `count`：结果数量
+
+### 获取笔记详情
+
+从搜索结果或首页 Feed 中取 `id` 和 `xsec_token`，获取完整内容：
+
+```bash
+# 基础详情
+python scripts/cli.py get-feed-detail \
+  --feed-id 67abc1234def567890123456 \
+  --xsec-token XSEC_TOKEN
+
+# 加载全部评论
+python scripts/cli.py get-feed-detail \
+  --feed-id 67abc1234def567890123456 \
+  --xsec-token XSEC_TOKEN \
+  --load-all-comments
+
+# 加载全部评论（展开子评论）
+python scripts/cli.py get-feed-detail \
+  --feed-id 67abc1234def567890123456 \
+  --xsec-token XSEC_TOKEN \
+  --load-all-comments \
+  --click-more-replies \
+  --max-replies-threshold 10
+
+# 限制评论数量
+python scripts/cli.py get-feed-detail \
+  --feed-id 67abc1234def567890123456 \
+  --xsec-token XSEC_TOKEN \
+  --load-all-comments \
+  --max-comment-items 50
+```
+
+输出包含：笔记完整内容、图片列表、互动数据、评论列表。
+
+### 获取用户主页
+
+```bash
+python scripts/cli.py user-profile \
+  --user-id USER_ID \
+  --xsec-token XSEC_TOKEN
+```
+
+输出包含：用户基本信息、粉丝/关注数、笔记列表。
+
+## 结果呈现
+
+搜索结果应按以下格式呈现给用户：
+
+1. **笔记列表**：每条笔记展示标题、作者、互动数据。
+2. **详情内容**：完整的笔记正文、图片、评论。
+3. **用户资料**：基本信息 + 代表作列表。
+4. **数据表格**：使用 markdown 表格展示关键指标。
+
+## 失败处理
+
+- **未登录**：提示用户先执行登录（参考 xhs-auth）。
+- **搜索无结果**：建议更换关键词或调整筛选条件。
+- **笔记不可访问**：可能是私密笔记或已删除，提示用户。
+- **用户主页不可访问**：用户可能已注销或设置隐私。

+---
+name: xhs-interact
+description: |
+  小红书社交互动技能。发表评论、回复评论、点赞、收藏。
+  当用户要求评论、回复、点赞或收藏小红书帖子时触发。
+---
+
+# 小红书社交互动
+
+你是"小红书互动助手"。帮助用户在小红书上进行社交互动。
+
+## 输入判断
+
+按优先级判断：
+
+1. 用户要求"发评论 / 评论这篇 / 写评论"：执行发表评论流程。
+2. 用户要求"回复评论 / 回复 TA"：执行回复评论流程。
+3. 用户要求"点赞 / 取消点赞"：执行点赞流程。
+4. 用户要求"收藏 / 取消收藏"：执行收藏流程。
+
+## 必做约束
+
+- **评论和回复内容必须经过用户确认后才能发送**。
+- 所有互动操作需要 `feed_id` 和 `xsec_token`（从搜索或详情中获取）。
+- 评论文本不可为空。
+- 点赞和收藏操作是幂等的（重复执行不会出错）。
+- CLI 输出 JSON 格式。
+
+## 工作流程
+
+### 发表评论
+
+1. 确认已有 `feed_id` 和 `xsec_token`（如没有，先搜索或获取详情）。
+2. 向用户确认评论内容。
+3. 执行发送。
+
+```bash
+python scripts/cli.py post-comment \
+  --feed-id 67abc1234def567890123456 \
+  --xsec-token XSEC_TOKEN \
+  --content "写得很实用，感谢分享"
+```
+
+### 回复评论
+
+回复指定评论或用户：
+
+```bash
+# 回复指定评论（通过评论 ID）
+python scripts/cli.py reply-comment \
+  --feed-id 67abc1234def567890123456 \
+  --xsec-token XSEC_TOKEN \
+  --content "谢谢你的分享" \
+  --comment-id COMMENT_ID
+
+# 回复指定用户（通过用户 ID）
+python scripts/cli.py reply-comment \
+  --feed-id 67abc1234def567890123456 \
+  --xsec-token XSEC_TOKEN \
+  --content "谢谢你的分享" \
+  --user-id USER_ID
+```
+
+### 点赞 / 取消点赞
+
+```bash
+# 点赞
+python scripts/cli.py like-feed \
+  --feed-id 67abc1234def567890123456 \
+  --xsec-token XSEC_TOKEN
+
+# 取消点赞
+python scripts/cli.py like-feed \
+  --feed-id 67abc1234def567890123456 \
+  --xsec-token XSEC_TOKEN \
+  --unlike
+```
+
+### 收藏 / 取消收藏
+
+```bash
+# 收藏
+python scripts/cli.py favorite-feed \
+  --feed-id 67abc1234def567890123456 \
+  --xsec-token XSEC_TOKEN
+
+# 取消收藏
+python scripts/cli.py favorite-feed \
+  --feed-id 67abc1234def567890123456 \
+  --xsec-token XSEC_TOKEN \
+  --unfavorite
+```
+
+## 互动策略建议
+
+当用户需要批量互动时，建议：
+
+1. 先搜索目标内容（xhs-explore）。
+2. 浏览搜索结果，选择要互动的笔记。
+3. 获取详情确认内容。
+4. 针对性地发表评论 / 点赞 / 收藏。
+5. 每次互动之间保持合理间隔，避免频率过高。
+
+## 失败处理
+
+- **未登录**：提示先登录（参考 xhs-auth）。
+- **笔记不可访问**：可能是私密或已删除笔记。
+- **评论输入框未找到**：页面结构可能已变化，提示检查选择器。
+- **评论发送失败**：检查内容是否包含敏感词。
+- **点赞/收藏失败**：重试一次，仍失败则报告错误。

+---
+name: xhs-publish
+description: |
+  小红书内容发布技能。支持图文发布、视频发布、定时发布、标签、可见性设置。
+  当用户要求发布内容到小红书、上传图文、上传视频时触发。
+---
+
+# 小红书内容发布
+
+你是"小红书发布助手"。目标是在用户确认后，调用脚本完成内容发布。
+
+## 输入判断
+
+按优先级判断：
+
+1. 用户已提供 `标题 + 正文 + 视频（本地路径）`：直接进入视频发布流程。
+2. 用户已提供 `标题 + 正文 + 图片（本地路径或 URL）`：直接进入图文发布流程。
+3. 用户只提供网页 URL：先用 WebFetch 提取内容和图片，再给出可发布草稿等待确认。
+4. 信息不全：先补齐缺失信息，不要直接发布。
+
+## 必做约束
+
+- **发布前必须让用户确认最终标题、正文和图片/视频**。
+- 图文发布时，没有图片不得发布。
+- 视频发布时，没有视频不得发布。图片和视频不可混合（二选一）。
+- 标题长度不超过 20（UTF-16 编码计算，中文字符计 1，英文/数字/空格计 1）。
+- 如果使用文件路径，必须使用绝对路径，禁止相对路径。
+- 需要先有运行中的 Chrome，且已登录。
+
+## 工作流程
+
+### Step 1: 处理内容
+
+#### 完整内容模式
+直接使用用户提供的标题和正文。
+
+#### URL 提取模式
+1. 使用 WebFetch 提取网页内容。
+2. 提取关键信息：标题、正文、图片 URL。
+3. 适当总结内容，保持语言自然、适合小红书阅读习惯。
+4. 如果提取不到图片，告知用户手动获取。
+
+### Step 2: 内容检查
+
+#### 标题检查
+标题长度必须 ≤ 20（UTF-16 编码长度）。如果超长，自动生成符合长度的新标题。
+
+#### 正文格式
+- 段落之间使用双换行分隔。
+- 简体中文，语言自然。
+- 话题标签放在正文最后一行，格式：`#标签1 #标签2 #标签3`
+
+### Step 3: 用户确认
+
+通过 `AskUserQuestion` 展示即将发布的内容（标题、正文、图片/视频），获得明确确认后继续。
+
+### Step 4: 写入临时文件
+
+将标题和正文写入 UTF-8 文本文件。不要在命令行参数中内联中文文本。
+
+### Step 5: 执行发布
+
+#### 图文发布
+
+```bash
+# 使用 CLI 直接发布
+python scripts/cli.py publish \
+  --title-file /tmp/xhs_title.txt \
+  --content-file /tmp/xhs_content.txt \
+  --images "/abs/path/pic1.jpg" "/abs/path/pic2.jpg"
+
+# 带标签和定时发布
+python scripts/cli.py publish \
+  --title-file /tmp/xhs_title.txt \
+  --content-file /tmp/xhs_content.txt \
+  --images "/abs/path/pic1.jpg" \
+  --tags "标签1" "标签2" \
+  --schedule-at "2026-03-10T12:00:00" \
+  --original
+
+# 使用发布流水线（含图片下载和登录检查）
+python scripts/publish_pipeline.py \
+  --title-file /tmp/xhs_title.txt \
+  --content-file /tmp/xhs_content.txt \
+  --images "https://example.com/pic1.jpg" "/abs/path/pic2.jpg"
+```
+
+#### 视频发布
+
+```bash
+python scripts/cli.py publish-video \
+  --title-file /tmp/xhs_title.txt \
+  --content-file /tmp/xhs_content.txt \
+  --video "/abs/path/video.mp4"
+
+# 带标签和可见性
+python scripts/cli.py publish-video \
+  --title-file /tmp/xhs_title.txt \
+  --content-file /tmp/xhs_content.txt \
+  --video "/abs/path/video.mp4" \
+  --tags "标签1" "标签2" \
+  --visibility "公开"
+```
+
+#### 指定账号/远程 Chrome
+
+```bash
+# 指定账号
+python scripts/cli.py --account work publish \
+  --title-file /tmp/xhs_title.txt \
+  --content-file /tmp/xhs_content.txt \
+  --images "/abs/path/pic1.jpg"
+
+# 远程 Chrome
+python scripts/cli.py --host 10.0.0.12 --port 9222 publish \
+  --title-file /tmp/xhs_title.txt \
+  --content-file /tmp/xhs_content.txt \
+  --images "/abs/path/pic1.jpg"
+```
+
+### Step 6: 处理输出
+
+- **Exit code 0**：发布成功。输出 JSON 包含 `success`, `title`, `images`/`video`, `status`。
+- **Exit code 1**：未登录，提示用户先登录（参考 xhs-auth）。
+- **Exit code 2**：错误，报告 JSON 中的 `error` 字段。
+
+### Step 7: 报告结果
+
+根据输出告知用户发布是否成功。
+
+## 常用参数
+
+| 参数 | 说明 |
+|------|------|
+| `--title-file path` | 标题文件路径（必须） |
+| `--content-file path` | 正文文件路径（必须） |
+| `--images path1 path2` | 图片路径/URL 列表（图文必须） |
+| `--video path` | 视频文件路径（视频必须） |
+| `--tags tag1 tag2` | 话题标签列表 |
+| `--schedule-at ISO8601` | 定时发布时间 |
+| `--original` | 声明原创 |
+| `--visibility` | 可见范围 |
+| `--host HOST` | 远程 CDP 主机 |
+| `--port PORT` | CDP 端口（默认 9222） |
+| `--account name` | 指定账号 |
+
+## 失败处理
+
+- **登录失败**：提示用户重新扫码登录并重试。
+- **图片下载失败**：提示更换图片 URL 或改用本地图片。
+- **视频处理超时**：视频上传后需等待处理（最长 10 分钟），超时后提示重试。
+- **标题过长**：自动缩短标题，保持语义。
+- **页面选择器失效**：提示检查脚本中的选择器定义。

+version = 1
+revision = 1
+requires-python = ">=3.11"
+
+[[package]]
+name = "certifi"
+version = "2026.2.25"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/af/2d/7bf41579a8986e348fa033a31cdd0e4121114f6bce2457e8876010b092dd/certifi-2026.2.25.tar.gz", hash = "sha256:e887ab5cee78ea814d3472169153c2d12cd43b14bd03329a39a9c6e2e80bfba7", size = 155029 }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/9a/3c/c17fb3ca2d9c3acff52e30b309f538586f9f5b9c9cf454f3845fc9af4881/certifi-2026.2.25-py3-none-any.whl", hash = "sha256:027692e4402ad994f1c42e52a4997a9763c646b73e4096e4d5d6db8af1d6f0fa", size = 153684 },
+]
+
+[[package]]
+name = "charset-normalizer"
+version = "3.4.4"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/13/69/33ddede1939fdd074bce5434295f38fae7136463422fe4fd3e0e89b98062/charset_normalizer-3.4.4.tar.gz", hash = "sha256:94537985111c35f28720e43603b8e7b43a6ecfb2ce1d3058bbe955b73404e21a", size = 129418 }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/ed/27/c6491ff4954e58a10f69ad90aca8a1b6fe9c5d3c6f380907af3c37435b59/charset_normalizer-3.4.4-cp311-cp311-macosx_10_9_universal2.whl", hash = "sha256:6e1fcf0720908f200cd21aa4e6750a48ff6ce4afe7ff5a79a90d5ed8a08296f8", size = 206988 },
+    { url = "https://files.pythonhosted.org/packages/94/59/2e87300fe67ab820b5428580a53cad894272dbb97f38a7a814a2a1ac1011/charset_normalizer-3.4.4-cp311-cp311-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:5f819d5fe9234f9f82d75bdfa9aef3a3d72c4d24a6e57aeaebba32a704553aa0", size = 147324 },
+    { url = "https://files.pythonhosted.org/packages/07/fb/0cf61dc84b2b088391830f6274cb57c82e4da8bbc2efeac8c025edb88772/charset_normalizer-3.4.4-cp311-cp311-manylinux2014_armv7l.manylinux_2_17_armv7l.manylinux_2_31_armv7l.whl", hash = "sha256:a59cb51917aa591b1c4e6a43c132f0cdc3c76dbad6155df4e28ee626cc77a0a3", size = 142742 },
+    { url = "https://files.pythonhosted.org/packages/62/8b/171935adf2312cd745d290ed93cf16cf0dfe320863ab7cbeeae1dcd6535f/charset_normalizer-3.4.4-cp311-cp311-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:8ef3c867360f88ac904fd3f5e1f902f13307af9052646963ee08ff4f131adafc", size = 160863 },
+    { url = "https://files.pythonhosted.org/packages/09/73/ad875b192bda14f2173bfc1bc9a55e009808484a4b256748d931b6948442/charset_normalizer-3.4.4-cp311-cp311-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:d9e45d7faa48ee908174d8fe84854479ef838fc6a705c9315372eacbc2f02897", size = 157837 },
+    { url = "https://files.pythonhosted.org/packages/6d/fc/de9cce525b2c5b94b47c70a4b4fb19f871b24995c728e957ee68ab1671ea/charset_normalizer-3.4.4-cp311-cp311-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:840c25fb618a231545cbab0564a799f101b63b9901f2569faecd6b222ac72381", size = 151550 },
+    { url = "https://files.pythonhosted.org/packages/55/c2/43edd615fdfba8c6f2dfbd459b25a6b3b551f24ea21981e23fb768503ce1/charset_normalizer-3.4.4-cp311-cp311-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:ca5862d5b3928c4940729dacc329aa9102900382fea192fc5e52eb69d6093815", size = 149162 },
+    { url = "https://files.pythonhosted.org/packages/03/86/bde4ad8b4d0e9429a4e82c1e8f5c659993a9a863ad62c7df05cf7b678d75/charset_normalizer-3.4.4-cp311-cp311-musllinux_1_2_aarch64.whl", hash = "sha256:d9c7f57c3d666a53421049053eaacdd14bbd0a528e2186fcb2e672effd053bb0", size = 150019 },
+    { url = "https://files.pythonhosted.org/packages/1f/86/a151eb2af293a7e7bac3a739b81072585ce36ccfb4493039f49f1d3cae8c/charset_normalizer-3.4.4-cp311-cp311-musllinux_1_2_armv7l.whl", hash = "sha256:277e970e750505ed74c832b4bf75dac7476262ee2a013f5574dd49075879e161", size = 143310 },
+    { url = "https://files.pythonhosted.org/packages/b5/fe/43dae6144a7e07b87478fdfc4dbe9efd5defb0e7ec29f5f58a55aeef7bf7/charset_normalizer-3.4.4-cp311-cp311-musllinux_1_2_ppc64le.whl", hash = "sha256:31fd66405eaf47bb62e8cd575dc621c56c668f27d46a61d975a249930dd5e2a4", size = 162022 },
+    { url = "https://files.pythonhosted.org/packages/80/e6/7aab83774f5d2bca81f42ac58d04caf44f0cc2b65fc6db2b3b2e8a05f3b3/charset_normalizer-3.4.4-cp311-cp311-musllinux_1_2_riscv64.whl", hash = "sha256:0d3d8f15c07f86e9ff82319b3d9ef6f4bf907608f53fe9d92b28ea9ae3d1fd89", size = 149383 },
+    { url = "https://files.pythonhosted.org/packages/4f/e8/b289173b4edae05c0dde07f69f8db476a0b511eac556dfe0d6bda3c43384/charset_normalizer-3.4.4-cp311-cp311-musllinux_1_2_s390x.whl", hash = "sha256:9f7fcd74d410a36883701fafa2482a6af2ff5ba96b9a620e9e0721e28ead5569", size = 159098 },
+    { url = "https://files.pythonhosted.org/packages/d8/df/fe699727754cae3f8478493c7f45f777b17c3ef0600e28abfec8619eb49c/charset_normalizer-3.4.4-cp311-cp311-musllinux_1_2_x86_64.whl", hash = "sha256:ebf3e58c7ec8a8bed6d66a75d7fb37b55e5015b03ceae72a8e7c74495551e224", size = 152991 },
+    { url = "https://files.pythonhosted.org/packages/1a/86/584869fe4ddb6ffa3bd9f491b87a01568797fb9bd8933f557dba9771beaf/charset_normalizer-3.4.4-cp311-cp311-win32.whl", hash = "sha256:eecbc200c7fd5ddb9a7f16c7decb07b566c29fa2161a16cf67b8d068bd21690a", size = 99456 },
+    { url = "https://files.pythonhosted.org/packages/65/f6/62fdd5feb60530f50f7e38b4f6a1d5203f4d16ff4f9f0952962c044e919a/charset_normalizer-3.4.4-cp311-cp311-win_amd64.whl", hash = "sha256:5ae497466c7901d54b639cf42d5b8c1b6a4fead55215500d2f486d34db48d016", size = 106978 },
+    { url = "https://files.pythonhosted.org/packages/7a/9d/0710916e6c82948b3be62d9d398cb4fcf4e97b56d6a6aeccd66c4b2f2bd5/charset_normalizer-3.4.4-cp311-cp311-win_arm64.whl", hash = "sha256:65e2befcd84bc6f37095f5961e68a6f077bf44946771354a28ad434c2cce0ae1", size = 99969 },
+    { url = "https://files.pythonhosted.org/packages/f3/85/1637cd4af66fa687396e757dec650f28025f2a2f5a5531a3208dc0ec43f2/charset_normalizer-3.4.4-cp312-cp312-macosx_10_13_universal2.whl", hash = "sha256:0a98e6759f854bd25a58a73fa88833fba3b7c491169f86ce1180c948ab3fd394", size = 208425 },
+    { url = "https://files.pythonhosted.org/packages/9d/6a/04130023fef2a0d9c62d0bae2649b69f7b7d8d24ea5536feef50551029df/charset_normalizer-3.4.4-cp312-cp312-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:b5b290ccc2a263e8d185130284f8501e3e36c5e02750fc6b6bdeb2e9e96f1e25", size = 148162 },
+    { url = "https://files.pythonhosted.org/packages/78/29/62328d79aa60da22c9e0b9a66539feae06ca0f5a4171ac4f7dc285b83688/charset_normalizer-3.4.4-cp312-cp312-manylinux2014_armv7l.manylinux_2_17_armv7l.manylinux_2_31_armv7l.whl", hash = "sha256:74bb723680f9f7a6234dcf67aea57e708ec1fbdf5699fb91dfd6f511b0a320ef", size = 144558 },
+    { url = "https://files.pythonhosted.org/packages/86/bb/b32194a4bf15b88403537c2e120b817c61cd4ecffa9b6876e941c3ee38fe/charset_normalizer-3.4.4-cp312-cp312-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:f1e34719c6ed0b92f418c7c780480b26b5d9c50349e9a9af7d76bf757530350d", size = 161497 },
+    { url = "https://files.pythonhosted.org/packages/19/89/a54c82b253d5b9b111dc74aca196ba5ccfcca8242d0fb64146d4d3183ff1/charset_normalizer-3.4.4-cp312-cp312-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:2437418e20515acec67d86e12bf70056a33abdacb5cb1655042f6538d6b085a8", size = 159240 },
+    { url = "https://files.pythonhosted.org/packages/c0/10/d20b513afe03acc89ec33948320a5544d31f21b05368436d580dec4e234d/charset_normalizer-3.4.4-cp312-cp312-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:11d694519d7f29d6cd09f6ac70028dba10f92f6cdd059096db198c283794ac86", size = 153471 },
+    { url = "https://files.pythonhosted.org/packages/61/fa/fbf177b55bdd727010f9c0a3c49eefa1d10f960e5f09d1d887bf93c2e698/charset_normalizer-3.4.4-cp312-cp312-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:ac1c4a689edcc530fc9d9aa11f5774b9e2f33f9a0c6a57864e90908f5208d30a", size = 150864 },
+    { url = "https://files.pythonhosted.org/packages/05/12/9fbc6a4d39c0198adeebbde20b619790e9236557ca59fc40e0e3cebe6f40/charset_normalizer-3.4.4-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:21d142cc6c0ec30d2efee5068ca36c128a30b0f2c53c1c07bd78cb6bc1d3be5f", size = 150647 },
+    { url = "https://files.pythonhosted.org/packages/ad/1f/6a9a593d52e3e8c5d2b167daf8c6b968808efb57ef4c210acb907c365bc4/charset_normalizer-3.4.4-cp312-cp312-musllinux_1_2_armv7l.whl", hash = "sha256:5dbe56a36425d26d6cfb40ce79c314a2e4dd6211d51d6d2191c00bed34f354cc", size = 145110 },
+    { url = "https://files.pythonhosted.org/packages/30/42/9a52c609e72471b0fc54386dc63c3781a387bb4fe61c20231a4ebcd58bdd/charset_normalizer-3.4.4-cp312-cp312-musllinux_1_2_ppc64le.whl", hash = "sha256:5bfbb1b9acf3334612667b61bd3002196fe2a1eb4dd74d247e0f2a4d50ec9bbf", size = 162839 },
+    { url = "https://files.pythonhosted.org/packages/c4/5b/c0682bbf9f11597073052628ddd38344a3d673fda35a36773f7d19344b23/charset_normalizer-3.4.4-cp312-cp312-musllinux_1_2_riscv64.whl", hash = "sha256:d055ec1e26e441f6187acf818b73564e6e6282709e9bcb5b63f5b23068356a15", size = 150667 },
+    { url = "https://files.pythonhosted.org/packages/e4/24/a41afeab6f990cf2daf6cb8c67419b63b48cf518e4f56022230840c9bfb2/charset_normalizer-3.4.4-cp312-cp312-musllinux_1_2_s390x.whl", hash = "sha256:af2d8c67d8e573d6de5bc30cdb27e9b95e49115cd9baad5ddbd1a6207aaa82a9", size = 160535 },
+    { url = "https://files.pythonhosted.org/packages/2a/e5/6a4ce77ed243c4a50a1fecca6aaaab419628c818a49434be428fe24c9957/charset_normalizer-3.4.4-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:780236ac706e66881f3b7f2f32dfe90507a09e67d1d454c762cf642e6e1586e0", size = 154816 },
+    { url = "https://files.pythonhosted.org/packages/a8/ef/89297262b8092b312d29cdb2517cb1237e51db8ecef2e9af5edbe7b683b1/charset_normalizer-3.4.4-cp312-cp312-win32.whl", hash = "sha256:5833d2c39d8896e4e19b689ffc198f08ea58116bee26dea51e362ecc7cd3ed26", size = 99694 },
+    { url = "https://files.pythonhosted.org/packages/3d/2d/1e5ed9dd3b3803994c155cd9aacb60c82c331bad84daf75bcb9c91b3295e/charset_normalizer-3.4.4-cp312-cp312-win_amd64.whl", hash = "sha256:a79cfe37875f822425b89a82333404539ae63dbdddf97f84dcbc3d339aae9525", size = 107131 },
+    { url = "https://files.pythonhosted.org/packages/d0/d9/0ed4c7098a861482a7b6a95603edce4c0d9db2311af23da1fb2b75ec26fc/charset_normalizer-3.4.4-cp312-cp312-win_arm64.whl", hash = "sha256:376bec83a63b8021bb5c8ea75e21c4ccb86e7e45ca4eb81146091b56599b80c3", size = 100390 },
+    { url = "https://files.pythonhosted.org/packages/97/45/4b3a1239bbacd321068ea6e7ac28875b03ab8bc0aa0966452db17cd36714/charset_normalizer-3.4.4-cp313-cp313-macosx_10_13_universal2.whl", hash = "sha256:e1f185f86a6f3403aa2420e815904c67b2f9ebc443f045edd0de921108345794", size = 208091 },
+    { url = "https://files.pythonhosted.org/packages/7d/62/73a6d7450829655a35bb88a88fca7d736f9882a27eacdca2c6d505b57e2e/charset_normalizer-3.4.4-cp313-cp313-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:6b39f987ae8ccdf0d2642338faf2abb1862340facc796048b604ef14919e55ed", size = 147936 },
+    { url = "https://files.pythonhosted.org/packages/89/c5/adb8c8b3d6625bef6d88b251bbb0d95f8205831b987631ab0c8bb5d937c2/charset_normalizer-3.4.4-cp313-cp313-manylinux2014_armv7l.manylinux_2_17_armv7l.manylinux_2_31_armv7l.whl", hash = "sha256:3162d5d8ce1bb98dd51af660f2121c55d0fa541b46dff7bb9b9f86ea1d87de72", size = 144180 },
+    { url = "https://files.pythonhosted.org/packages/91/ed/9706e4070682d1cc219050b6048bfd293ccf67b3d4f5a4f39207453d4b99/charset_normalizer-3.4.4-cp313-cp313-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:81d5eb2a312700f4ecaa977a8235b634ce853200e828fbadf3a9c50bab278328", size = 161346 },
+    { url = "https://files.pythonhosted.org/packages/d5/0d/031f0d95e4972901a2f6f09ef055751805ff541511dc1252ba3ca1f80cf5/charset_normalizer-3.4.4-cp313-cp313-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:5bd2293095d766545ec1a8f612559f6b40abc0eb18bb2f5d1171872d34036ede", size = 158874 },
+    { url = "https://files.pythonhosted.org/packages/f5/83/6ab5883f57c9c801ce5e5677242328aa45592be8a00644310a008d04f922/charset_normalizer-3.4.4-cp313-cp313-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:a8a8b89589086a25749f471e6a900d3f662d1d3b6e2e59dcecf787b1cc3a1894", size = 153076 },
+    { url = "https://files.pythonhosted.org/packages/75/1e/5ff781ddf5260e387d6419959ee89ef13878229732732ee73cdae01800f2/charset_normalizer-3.4.4-cp313-cp313-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:bc7637e2f80d8530ee4a78e878bce464f70087ce73cf7c1caf142416923b98f1", size = 150601 },
+    { url = "https://files.pythonhosted.org/packages/d7/57/71be810965493d3510a6ca79b90c19e48696fb1ff964da319334b12677f0/charset_normalizer-3.4.4-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:f8bf04158c6b607d747e93949aa60618b61312fe647a6369f88ce2ff16043490", size = 150376 },
+    { url = "https://files.pythonhosted.org/packages/e5/d5/c3d057a78c181d007014feb7e9f2e65905a6c4ef182c0ddf0de2924edd65/charset_normalizer-3.4.4-cp313-cp313-musllinux_1_2_armv7l.whl", hash = "sha256:554af85e960429cf30784dd47447d5125aaa3b99a6f0683589dbd27e2f45da44", size = 144825 },
+    { url = "https://files.pythonhosted.org/packages/e6/8c/d0406294828d4976f275ffbe66f00266c4b3136b7506941d87c00cab5272/charset_normalizer-3.4.4-cp313-cp313-musllinux_1_2_ppc64le.whl", hash = "sha256:74018750915ee7ad843a774364e13a3db91682f26142baddf775342c3f5b1133", size = 162583 },
+    { url = "https://files.pythonhosted.org/packages/d7/24/e2aa1f18c8f15c4c0e932d9287b8609dd30ad56dbe41d926bd846e22fb8d/charset_normalizer-3.4.4-cp313-cp313-musllinux_1_2_riscv64.whl", hash = "sha256:c0463276121fdee9c49b98908b3a89c39be45d86d1dbaa22957e38f6321d4ce3", size = 150366 },
+    { url = "https://files.pythonhosted.org/packages/e4/5b/1e6160c7739aad1e2df054300cc618b06bf784a7a164b0f238360721ab86/charset_normalizer-3.4.4-cp313-cp313-musllinux_1_2_s390x.whl", hash = "sha256:362d61fd13843997c1c446760ef36f240cf81d3ebf74ac62652aebaf7838561e", size = 160300 },
+    { url = "https://files.pythonhosted.org/packages/7a/10/f882167cd207fbdd743e55534d5d9620e095089d176d55cb22d5322f2afd/charset_normalizer-3.4.4-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:9a26f18905b8dd5d685d6d07b0cdf98a79f3c7a918906af7cc143ea2e164c8bc", size = 154465 },
+    { url = "https://files.pythonhosted.org/packages/89/66/c7a9e1b7429be72123441bfdbaf2bc13faab3f90b933f664db506dea5915/charset_normalizer-3.4.4-cp313-cp313-win32.whl", hash = "sha256:9b35f4c90079ff2e2edc5b26c0c77925e5d2d255c42c74fdb70fb49b172726ac", size = 99404 },
+    { url = "https://files.pythonhosted.org/packages/c4/26/b9924fa27db384bdcd97ab83b4f0a8058d96ad9626ead570674d5e737d90/charset_normalizer-3.4.4-cp313-cp313-win_amd64.whl", hash = "sha256:b435cba5f4f750aa6c0a0d92c541fb79f69a387c91e61f1795227e4ed9cece14", size = 107092 },
+    { url = "https://files.pythonhosted.org/packages/af/8f/3ed4bfa0c0c72a7ca17f0380cd9e4dd842b09f664e780c13cff1dcf2ef1b/charset_normalizer-3.4.4-cp313-cp313-win_arm64.whl", hash = "sha256:542d2cee80be6f80247095cc36c418f7bddd14f4a6de45af91dfad36d817bba2", size = 100408 },
+    { url = "https://files.pythonhosted.org/packages/2a/35/7051599bd493e62411d6ede36fd5af83a38f37c4767b92884df7301db25d/charset_normalizer-3.4.4-cp314-cp314-macosx_10_13_universal2.whl", hash = "sha256:da3326d9e65ef63a817ecbcc0df6e94463713b754fe293eaa03da99befb9a5bd", size = 207746 },
+    { url = "https://files.pythonhosted.org/packages/10/9a/97c8d48ef10d6cd4fcead2415523221624bf58bcf68a802721a6bc807c8f/charset_normalizer-3.4.4-cp314-cp314-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:8af65f14dc14a79b924524b1e7fffe304517b2bff5a58bf64f30b98bbc5079eb", size = 147889 },
+    { url = "https://files.pythonhosted.org/packages/10/bf/979224a919a1b606c82bd2c5fa49b5c6d5727aa47b4312bb27b1734f53cd/charset_normalizer-3.4.4-cp314-cp314-manylinux2014_armv7l.manylinux_2_17_armv7l.manylinux_2_31_armv7l.whl", hash = "sha256:74664978bb272435107de04e36db5a9735e78232b85b77d45cfb38f758efd33e", size = 143641 },
+    { url = "https://files.pythonhosted.org/packages/ba/33/0ad65587441fc730dc7bd90e9716b30b4702dc7b617e6ba4997dc8651495/charset_normalizer-3.4.4-cp314-cp314-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:752944c7ffbfdd10c074dc58ec2d5a8a4cd9493b314d367c14d24c17684ddd14", size = 160779 },
+    { url = "https://files.pythonhosted.org/packages/67/ed/331d6b249259ee71ddea93f6f2f0a56cfebd46938bde6fcc6f7b9a3d0e09/charset_normalizer-3.4.4-cp314-cp314-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:d1f13550535ad8cff21b8d757a3257963e951d96e20ec82ab44bc64aeb62a191", size = 159035 },
+    { url = "https://files.pythonhosted.org/packages/67/ff/f6b948ca32e4f2a4576aa129d8bed61f2e0543bf9f5f2b7fc3758ed005c9/charset_normalizer-3.4.4-cp314-cp314-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:ecaae4149d99b1c9e7b88bb03e3221956f68fd6d50be2ef061b2381b61d20838", size = 152542 },
+    { url = "https://files.pythonhosted.org/packages/16/85/276033dcbcc369eb176594de22728541a925b2632f9716428c851b149e83/charset_normalizer-3.4.4-cp314-cp314-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:cb6254dc36b47a990e59e1068afacdcd02958bdcce30bb50cc1700a8b9d624a6", size = 149524 },
+    { url = "https://files.pythonhosted.org/packages/9e/f2/6a2a1f722b6aba37050e626530a46a68f74e63683947a8acff92569f979a/charset_normalizer-3.4.4-cp314-cp314-musllinux_1_2_aarch64.whl", hash = "sha256:c8ae8a0f02f57a6e61203a31428fa1d677cbe50c93622b4149d5c0f319c1d19e", size = 150395 },
+    { url = "https://files.pythonhosted.org/packages/60/bb/2186cb2f2bbaea6338cad15ce23a67f9b0672929744381e28b0592676824/charset_normalizer-3.4.4-cp314-cp314-musllinux_1_2_armv7l.whl", hash = "sha256:47cc91b2f4dd2833fddaedd2893006b0106129d4b94fdb6af1f4ce5a9965577c", size = 143680 },
+    { url = "https://files.pythonhosted.org/packages/7d/a5/bf6f13b772fbb2a90360eb620d52ed8f796f3c5caee8398c3b2eb7b1c60d/charset_normalizer-3.4.4-cp314-cp314-musllinux_1_2_ppc64le.whl", hash = "sha256:82004af6c302b5d3ab2cfc4cc5f29db16123b1a8417f2e25f9066f91d4411090", size = 162045 },
+    { url = "https://files.pythonhosted.org/packages/df/c5/d1be898bf0dc3ef9030c3825e5d3b83f2c528d207d246cbabe245966808d/charset_normalizer-3.4.4-cp314-cp314-musllinux_1_2_riscv64.whl", hash = "sha256:2b7d8f6c26245217bd2ad053761201e9f9680f8ce52f0fcd8d0755aeae5b2152", size = 149687 },
+    { url = "https://files.pythonhosted.org/packages/a5/42/90c1f7b9341eef50c8a1cb3f098ac43b0508413f33affd762855f67a410e/charset_normalizer-3.4.4-cp314-cp314-musllinux_1_2_s390x.whl", hash = "sha256:799a7a5e4fb2d5898c60b640fd4981d6a25f1c11790935a44ce38c54e985f828", size = 160014 },
+    { url = "https://files.pythonhosted.org/packages/76/be/4d3ee471e8145d12795ab655ece37baed0929462a86e72372fd25859047c/charset_normalizer-3.4.4-cp314-cp314-musllinux_1_2_x86_64.whl", hash = "sha256:99ae2cffebb06e6c22bdc25801d7b30f503cc87dbd283479e7b606f70aff57ec", size = 154044 },
+    { url = "https://files.pythonhosted.org/packages/b0/6f/8f7af07237c34a1defe7defc565a9bc1807762f672c0fde711a4b22bf9c0/charset_normalizer-3.4.4-cp314-cp314-win32.whl", hash = "sha256:f9d332f8c2a2fcbffe1378594431458ddbef721c1769d78e2cbc06280d8155f9", size = 99940 },
+    { url = "https://files.pythonhosted.org/packages/4b/51/8ade005e5ca5b0d80fb4aff72a3775b325bdc3d27408c8113811a7cbe640/charset_normalizer-3.4.4-cp314-cp314-win_amd64.whl", hash = "sha256:8a6562c3700cce886c5be75ade4a5db4214fda19fede41d9792d100288d8f94c", size = 107104 },
+    { url = "https://files.pythonhosted.org/packages/da/5f/6b8f83a55bb8278772c5ae54a577f3099025f9ade59d0136ac24a0df4bde/charset_normalizer-3.4.4-cp314-cp314-win_arm64.whl", hash = "sha256:de00632ca48df9daf77a2c65a484531649261ec9f25489917f09e455cb09ddb2", size = 100743 },
+    { url = "https://files.pythonhosted.org/packages/0a/4c/925909008ed5a988ccbb72dcc897407e5d6d3bd72410d69e051fc0c14647/charset_normalizer-3.4.4-py3-none-any.whl", hash = "sha256:7a32c560861a02ff789ad905a2fe94e3f840803362c84fecf1851cb4cf3dc37f", size = 53402 },
+]
+
+[[package]]
+name = "colorama"
+version = "0.4.6"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/d8/53/6f443c9a4a8358a93a6792e2acffb9d9d5cb0a5cfd8802644b7b1c9a02e4/colorama-0.4.6.tar.gz", hash = "sha256:08695f5cb7ed6e0531a20572697297273c47b8cae5a63ffc6d6ed5c201be6e44", size = 27697 }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/d1/d6/3965ed04c63042e047cb6a3e6ed1a63a35087b6a609aa3a15ed8ac56c221/colorama-0.4.6-py2.py3-none-any.whl", hash = "sha256:4f1d9991f5acc0ca119f9d443620b77f9d6b33703e51011c16baf57afb285fc6", size = 25335 },
+]
+
+[[package]]
+name = "idna"
+version = "3.11"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/6f/6d/0703ccc57f3a7233505399edb88de3cbd678da106337b9fcde432b65ed60/idna-3.11.tar.gz", hash = "sha256:795dafcc9c04ed0c1fb032c2aa73654d8e8c5023a7df64a53f39190ada629902", size = 194582 }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/0e/61/66938bbb5fc52dbdf84594873d5b51fb1f7c7794e9c0f5bd885f30bc507b/idna-3.11-py3-none-any.whl", hash = "sha256:771a87f49d9defaf64091e6e6fe9c18d4833f140bd19464795bc32d966ca37ea", size = 71008 },
+]
+
+[[package]]
+name = "iniconfig"
+version = "2.3.0"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/72/34/14ca021ce8e5dfedc35312d08ba8bf51fdd999c576889fc2c24cb97f4f10/iniconfig-2.3.0.tar.gz", hash = "sha256:c76315c77db068650d49c5b56314774a7804df16fee4402c1f19d6d15d8c4730", size = 20503 }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/cb/b1/3846dd7f199d53cb17f49cba7e651e9ce294d8497c8c150530ed11865bb8/iniconfig-2.3.0-py3-none-any.whl", hash = "sha256:f631c04d2c48c52b84d0d0549c99ff3859c98df65b3101406327ecc7d53fbf12", size = 7484 },
+]
+
+[[package]]
+name = "packaging"
+version = "26.0"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/65/ee/299d360cdc32edc7d2cf530f3accf79c4fca01e96ffc950d8a52213bd8e4/packaging-26.0.tar.gz", hash = "sha256:00243ae351a257117b6a241061796684b084ed1c516a08c48a3f7e147a9d80b4", size = 143416 }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/b7/b9/c538f279a4e237a006a2c98387d081e9eb060d203d8ed34467cc0f0b9b53/packaging-26.0-py3-none-any.whl", hash = "sha256:b36f1fef9334a5588b4166f8bcd26a14e521f2b55e6b9de3aaa80d3ff7a37529", size = 74366 },
+]
+
+[[package]]
+name = "pluggy"
+version = "1.6.0"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/f9/e2/3e91f31a7d2b083fe6ef3fa267035b518369d9511ffab804f839851d2779/pluggy-1.6.0.tar.gz", hash = "sha256:7dcc130b76258d33b90f61b658791dede3486c3e6bfb003ee5c9bfb396dd22f3", size = 69412 }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/54/20/4d324d65cc6d9205fabedc306948156824eb9f0ee1633355a8f7ec5c66bf/pluggy-1.6.0-py3-none-any.whl", hash = "sha256:e920276dd6813095e9377c0bc5566d94c932c33b27a3e3945d8389c374dd4746", size = 20538 },
+]
+
+[[package]]
+name = "pygments"
+version = "2.19.2"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/b0/77/a5b8c569bf593b0140bde72ea885a803b82086995367bf2037de0159d924/pygments-2.19.2.tar.gz", hash = "sha256:636cb2477cec7f8952536970bc533bc43743542f70392ae026374600add5b887", size = 4968631 }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/c7/21/705964c7812476f378728bdf590ca4b771ec72385c533964653c68e86bdc/pygments-2.19.2-py3-none-any.whl", hash = "sha256:86540386c03d588bb81d44bc3928634ff26449851e99741617ecb9037ee5ec0b", size = 1225217 },
+]
+
+[[package]]
+name = "pytest"
+version = "9.0.2"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "colorama", marker = "sys_platform == 'win32'" },
+    { name = "iniconfig" },
+    { name = "packaging" },
+    { name = "pluggy" },
+    { name = "pygments" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/d1/db/7ef3487e0fb0049ddb5ce41d3a49c235bf9ad299b6a25d5780a89f19230f/pytest-9.0.2.tar.gz", hash = "sha256:75186651a92bd89611d1d9fc20f0b4345fd827c41ccd5c299a868a05d70edf11", size = 1568901 }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/3b/ab/b3226f0bd7cdcf710fbede2b3548584366da3b19b5021e74f5bde2a8fa3f/pytest-9.0.2-py3-none-any.whl", hash = "sha256:711ffd45bf766d5264d487b917733b453d917afd2b0ad65223959f59089f875b", size = 374801 },
+]
+
+[[package]]
+name = "requests"
+version = "2.32.5"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "certifi" },
+    { name = "charset-normalizer" },
+    { name = "idna" },
+    { name = "urllib3" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/c9/74/b3ff8e6c8446842c3f5c837e9c3dfcfe2018ea6ecef224c710c85ef728f4/requests-2.32.5.tar.gz", hash = "sha256:dbba0bac56e100853db0ea71b82b4dfd5fe2bf6d3754a8893c3af500cec7d7cf", size = 134517 }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/1e/db/4254e3eabe8020b458f1a747140d32277ec7a271daf1d235b70dc0b4e6e3/requests-2.32.5-py3-none-any.whl", hash = "sha256:2462f94637a34fd532264295e186976db0f5d453d1cdd31473c85a6a161affb6", size = 64738 },
+]
+
+[[package]]
+name = "ruff"
+version = "0.15.4"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/da/31/d6e536cdebb6568ae75a7f00e4b4819ae0ad2640c3604c305a0428680b0c/ruff-0.15.4.tar.gz", hash = "sha256:3412195319e42d634470cc97aa9803d07e9d5c9223b99bcb1518f0c725f26ae1", size = 4569550 }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/f2/82/c11a03cfec3a4d26a0ea1e571f0f44be5993b923f905eeddfc397c13d360/ruff-0.15.4-py3-none-linux_armv6l.whl", hash = "sha256:a1810931c41606c686bae8b5b9a8072adac2f611bb433c0ba476acba17a332e0", size = 10453333 },
+    { url = "https://files.pythonhosted.org/packages/ce/5d/6a1f271f6e31dffb31855996493641edc3eef8077b883eaf007a2f1c2976/ruff-0.15.4-py3-none-macosx_10_12_x86_64.whl", hash = "sha256:5a1632c66672b8b4d3e1d1782859e98d6e0b4e70829530666644286600a33992", size = 10853356 },
+    { url = "https://files.pythonhosted.org/packages/b1/d8/0fab9f8842b83b1a9c2bf81b85063f65e93fb512e60effa95b0be49bfc54/ruff-0.15.4-py3-none-macosx_11_0_arm64.whl", hash = "sha256:a4386ba2cd6c0f4ff75252845906acc7c7c8e1ac567b7bc3d373686ac8c222ba", size = 10187434 },
+    { url = "https://files.pythonhosted.org/packages/85/cc/cc220fd9394eff5db8d94dec199eec56dd6c9f3651d8869d024867a91030/ruff-0.15.4-py3-none-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:b2496488bdfd3732747558b6f95ae427ff066d1fcd054daf75f5a50674411e75", size = 10535456 },
+    { url = "https://files.pythonhosted.org/packages/fa/0f/bced38fa5cf24373ec767713c8e4cadc90247f3863605fb030e597878661/ruff-0.15.4-py3-none-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:3f1c4893841ff2d54cbda1b2860fa3260173df5ddd7b95d370186f8a5e66a4ac", size = 10287772 },
+    { url = "https://files.pythonhosted.org/packages/2b/90/58a1802d84fed15f8f281925b21ab3cecd813bde52a8ca033a4de8ab0e7a/ruff-0.15.4-py3-none-manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:820b8766bd65503b6c30aaa6331e8ef3a6e564f7999c844e9a547c40179e440a", size = 11049051 },
+    { url = "https://files.pythonhosted.org/packages/d2/ac/b7ad36703c35f3866584564dc15f12f91cb1a26a897dc2fd13d7cb3ae1af/ruff-0.15.4-py3-none-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:c9fb74bab47139c1751f900f857fa503987253c3ef89129b24ed375e72873e85", size = 11890494 },
+    { url = "https://files.pythonhosted.org/packages/93/3d/3eb2f47a39a8b0da99faf9c54d3eb24720add1e886a5309d4d1be73a6380/ruff-0.15.4-py3-none-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:f80c98765949c518142b3a50a5db89343aa90f2c2bf7799de9986498ae6176db", size = 11326221 },
+    { url = "https://files.pythonhosted.org/packages/ff/90/bf134f4c1e5243e62690e09d63c55df948a74084c8ac3e48a88468314da6/ruff-0.15.4-py3-none-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:451a2e224151729b3b6c9ffb36aed9091b2996fe4bdbd11f47e27d8f2e8888ec", size = 11168459 },
+    { url = "https://files.pythonhosted.org/packages/b5/e5/a64d27688789b06b5d55162aafc32059bb8c989c61a5139a36e1368285eb/ruff-0.15.4-py3-none-manylinux_2_31_riscv64.whl", hash = "sha256:a8f157f2e583c513c4f5f896163a93198297371f34c04220daf40d133fdd4f7f", size = 11104366 },
+    { url = "https://files.pythonhosted.org/packages/f1/f6/32d1dcb66a2559763fc3027bdd65836cad9eb09d90f2ed6a63d8e9252b02/ruff-0.15.4-py3-none-musllinux_1_2_aarch64.whl", hash = "sha256:917cc68503357021f541e69b35361c99387cdbbf99bd0ea4aa6f28ca99ff5338", size = 10510887 },
+    { url = "https://files.pythonhosted.org/packages/ff/92/22d1ced50971c5b6433aed166fcef8c9343f567a94cf2b9d9089f6aa80fe/ruff-0.15.4-py3-none-musllinux_1_2_armv7l.whl", hash = "sha256:e9737c8161da79fd7cfec19f1e35620375bd8b2a50c3e77fa3d2c16f574105cc", size = 10285939 },
+    { url = "https://files.pythonhosted.org/packages/e6/f4/7c20aec3143837641a02509a4668fb146a642fd1211846634edc17eb5563/ruff-0.15.4-py3-none-musllinux_1_2_i686.whl", hash = "sha256:291258c917539e18f6ba40482fe31d6f5ac023994ee11d7bdafd716f2aab8a68", size = 10765471 },
+    { url = "https://files.pythonhosted.org/packages/d0/09/6d2f7586f09a16120aebdff8f64d962d7c4348313c77ebb29c566cefc357/ruff-0.15.4-py3-none-musllinux_1_2_x86_64.whl", hash = "sha256:3f83c45911da6f2cd5936c436cf86b9f09f09165f033a99dcf7477e34041cbc3", size = 11263382 },
+    { url = "https://files.pythonhosted.org/packages/1b/fa/2ef715a1cd329ef47c1a050e10dee91a9054b7ce2fcfdd6a06d139afb7ec/ruff-0.15.4-py3-none-win32.whl", hash = "sha256:65594a2d557d4ee9f02834fcdf0a28daa8b3b9f6cb2cb93846025a36db47ef22", size = 10506664 },
+    { url = "https://files.pythonhosted.org/packages/d0/a8/c688ef7e29983976820d18710f955751d9f4d4eb69df658af3d006e2ba3e/ruff-0.15.4-py3-none-win_amd64.whl", hash = "sha256:04196ad44f0df220c2ece5b0e959c2f37c777375ec744397d21d15b50a75264f", size = 11651048 },
+    { url = "https://files.pythonhosted.org/packages/3e/0a/9e1be9035b37448ce2e68c978f0591da94389ade5a5abafa4cf99985d1b2/ruff-0.15.4-py3-none-win_arm64.whl", hash = "sha256:60d5177e8cfc70e51b9c5fad936c634872a74209f934c1e79107d11787ad5453", size = 10966776 },
+]
+
+[[package]]
+name = "urllib3"
+version = "2.6.3"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/c7/24/5f1b3bdffd70275f6661c76461e25f024d5a38a46f04aaca912426a2b1d3/urllib3-2.6.3.tar.gz", hash = "sha256:1b62b6884944a57dbe321509ab94fd4d3b307075e0c2eae991ac71ee15ad38ed", size = 435556 }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/39/08/aaaad47bc4e9dc8c725e68f9d04865dbcb2052843ff09c97b08904852d84/urllib3-2.6.3-py3-none-any.whl", hash = "sha256:bf272323e553dfb2e87d9bfd225ca7b0f467b919d7bbd355436d3fd37cb0acd4", size = 131584 },
+]
+
+[[package]]
+name = "websockets"
+version = "16.0"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/04/24/4b2031d72e840ce4c1ccb255f693b15c334757fc50023e4db9537080b8c4/websockets-16.0.tar.gz", hash = "sha256:5f6261a5e56e8d5c42a4497b364ea24d94d9563e8fbd44e78ac40879c60179b5", size = 179346 }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/f2/db/de907251b4ff46ae804ad0409809504153b3f30984daf82a1d84a9875830/websockets-16.0-cp311-cp311-macosx_10_9_universal2.whl", hash = "sha256:31a52addea25187bde0797a97d6fc3d2f92b6f72a9370792d65a6e84615ac8a8", size = 177340 },
+    { url = "https://files.pythonhosted.org/packages/f3/fa/abe89019d8d8815c8781e90d697dec52523fb8ebe308bf11664e8de1877e/websockets-16.0-cp311-cp311-macosx_10_9_x86_64.whl", hash = "sha256:417b28978cdccab24f46400586d128366313e8a96312e4b9362a4af504f3bbad", size = 175022 },
+    { url = "https://files.pythonhosted.org/packages/58/5d/88ea17ed1ded2079358b40d31d48abe90a73c9e5819dbcde1606e991e2ad/websockets-16.0-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:af80d74d4edfa3cb9ed973a0a5ba2b2a549371f8a741e0800cb07becdd20f23d", size = 175319 },
+    { url = "https://files.pythonhosted.org/packages/d2/ae/0ee92b33087a33632f37a635e11e1d99d429d3d323329675a6022312aac2/websockets-16.0-cp311-cp311-manylinux1_x86_64.manylinux_2_28_x86_64.manylinux_2_5_x86_64.whl", hash = "sha256:08d7af67b64d29823fed316505a89b86705f2b7981c07848fb5e3ea3020c1abe", size = 184631 },
+    { url = "https://files.pythonhosted.org/packages/c8/c5/27178df583b6c5b31b29f526ba2da5e2f864ecc79c99dae630a85d68c304/websockets-16.0-cp311-cp311-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:7be95cfb0a4dae143eaed2bcba8ac23f4892d8971311f1b06f3c6b78952ee70b", size = 185870 },
+    { url = "https://files.pythonhosted.org/packages/87/05/536652aa84ddc1c018dbb7e2c4cbcd0db884580bf8e95aece7593fde526f/websockets-16.0-cp311-cp311-musllinux_1_2_aarch64.whl", hash = "sha256:d6297ce39ce5c2e6feb13c1a996a2ded3b6832155fcfc920265c76f24c7cceb5", size = 185361 },
+    { url = "https://files.pythonhosted.org/packages/6d/e2/d5332c90da12b1e01f06fb1b85c50cfc489783076547415bf9f0a659ec19/websockets-16.0-cp311-cp311-musllinux_1_2_x86_64.whl", hash = "sha256:1c1b30e4f497b0b354057f3467f56244c603a79c0d1dafce1d16c283c25f6e64", size = 184615 },
+    { url = "https://files.pythonhosted.org/packages/77/fb/d3f9576691cae9253b51555f841bc6600bf0a983a461c79500ace5a5b364/websockets-16.0-cp311-cp311-win32.whl", hash = "sha256:5f451484aeb5cafee1ccf789b1b66f535409d038c56966d6101740c1614b86c6", size = 178246 },
+    { url = "https://files.pythonhosted.org/packages/54/67/eaff76b3dbaf18dcddabc3b8c1dba50b483761cccff67793897945b37408/websockets-16.0-cp311-cp311-win_amd64.whl", hash = "sha256:8d7f0659570eefb578dacde98e24fb60af35350193e4f56e11190787bee77dac", size = 178684 },
+    { url = "https://files.pythonhosted.org/packages/84/7b/bac442e6b96c9d25092695578dda82403c77936104b5682307bd4deb1ad4/websockets-16.0-cp312-cp312-macosx_10_13_universal2.whl", hash = "sha256:71c989cbf3254fbd5e84d3bff31e4da39c43f884e64f2551d14bb3c186230f00", size = 177365 },
+    { url = "https://files.pythonhosted.org/packages/b0/fe/136ccece61bd690d9c1f715baaeefd953bb2360134de73519d5df19d29ca/websockets-16.0-cp312-cp312-macosx_10_13_x86_64.whl", hash = "sha256:8b6e209ffee39ff1b6d0fa7bfef6de950c60dfb91b8fcead17da4ee539121a79", size = 175038 },
+    { url = "https://files.pythonhosted.org/packages/40/1e/9771421ac2286eaab95b8575b0cb701ae3663abf8b5e1f64f1fd90d0a673/websockets-16.0-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:86890e837d61574c92a97496d590968b23c2ef0aeb8a9bc9421d174cd378ae39", size = 175328 },
+    { url = "https://files.pythonhosted.org/packages/18/29/71729b4671f21e1eaa5d6573031ab810ad2936c8175f03f97f3ff164c802/websockets-16.0-cp312-cp312-manylinux1_x86_64.manylinux_2_28_x86_64.manylinux_2_5_x86_64.whl", hash = "sha256:9b5aca38b67492ef518a8ab76851862488a478602229112c4b0d58d63a7a4d5c", size = 184915 },
+    { url = "https://files.pythonhosted.org/packages/97/bb/21c36b7dbbafc85d2d480cd65df02a1dc93bf76d97147605a8e27ff9409d/websockets-16.0-cp312-cp312-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:e0334872c0a37b606418ac52f6ab9cfd17317ac26365f7f65e203e2d0d0d359f", size = 186152 },
+    { url = "https://files.pythonhosted.org/packages/4a/34/9bf8df0c0cf88fa7bfe36678dc7b02970c9a7d5e065a3099292db87b1be2/websockets-16.0-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:a0b31e0b424cc6b5a04b8838bbaec1688834b2383256688cf47eb97412531da1", size = 185583 },
+    { url = "https://files.pythonhosted.org/packages/47/88/4dd516068e1a3d6ab3c7c183288404cd424a9a02d585efbac226cb61ff2d/websockets-16.0-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:485c49116d0af10ac698623c513c1cc01c9446c058a4e61e3bf6c19dff7335a2", size = 184880 },
+    { url = "https://files.pythonhosted.org/packages/91/d6/7d4553ad4bf1c0421e1ebd4b18de5d9098383b5caa1d937b63df8d04b565/websockets-16.0-cp312-cp312-win32.whl", hash = "sha256:eaded469f5e5b7294e2bdca0ab06becb6756ea86894a47806456089298813c89", size = 178261 },
+    { url = "https://files.pythonhosted.org/packages/c3/f0/f3a17365441ed1c27f850a80b2bc680a0fa9505d733fe152fdf5e98c1c0b/websockets-16.0-cp312-cp312-win_amd64.whl", hash = "sha256:5569417dc80977fc8c2d43a86f78e0a5a22fee17565d78621b6bb264a115d4ea", size = 178693 },
+    { url = "https://files.pythonhosted.org/packages/cc/9c/baa8456050d1c1b08dd0ec7346026668cbc6f145ab4e314d707bb845bf0d/websockets-16.0-cp313-cp313-macosx_10_13_universal2.whl", hash = "sha256:878b336ac47938b474c8f982ac2f7266a540adc3fa4ad74ae96fea9823a02cc9", size = 177364 },
+    { url = "https://files.pythonhosted.org/packages/7e/0c/8811fc53e9bcff68fe7de2bcbe75116a8d959ac699a3200f4847a8925210/websockets-16.0-cp313-cp313-macosx_10_13_x86_64.whl", hash = "sha256:52a0fec0e6c8d9a784c2c78276a48a2bdf099e4ccc2a4cad53b27718dbfd0230", size = 175039 },
+    { url = "https://files.pythonhosted.org/packages/aa/82/39a5f910cb99ec0b59e482971238c845af9220d3ab9fa76dd9162cda9d62/websockets-16.0-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:e6578ed5b6981005df1860a56e3617f14a6c307e6a71b4fff8c48fdc50f3ed2c", size = 175323 },
+    { url = "https://files.pythonhosted.org/packages/bd/28/0a25ee5342eb5d5f297d992a77e56892ecb65e7854c7898fb7d35e9b33bd/websockets-16.0-cp313-cp313-manylinux1_x86_64.manylinux_2_28_x86_64.manylinux_2_5_x86_64.whl", hash = "sha256:95724e638f0f9c350bb1c2b0a7ad0e83d9cc0c9259f3ea94e40d7b02a2179ae5", size = 184975 },
+    { url = "https://files.pythonhosted.org/packages/f9/66/27ea52741752f5107c2e41fda05e8395a682a1e11c4e592a809a90c6a506/websockets-16.0-cp313-cp313-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:c0204dc62a89dc9d50d682412c10b3542d748260d743500a85c13cd1ee4bde82", size = 186203 },
+    { url = "https://files.pythonhosted.org/packages/37/e5/8e32857371406a757816a2b471939d51c463509be73fa538216ea52b792a/websockets-16.0-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:52ac480f44d32970d66763115edea932f1c5b1312de36df06d6b219f6741eed8", size = 185653 },
+    { url = "https://files.pythonhosted.org/packages/9b/67/f926bac29882894669368dc73f4da900fcdf47955d0a0185d60103df5737/websockets-16.0-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:6e5a82b677f8f6f59e8dfc34ec06ca6b5b48bc4fcda346acd093694cc2c24d8f", size = 184920 },
+    { url = "https://files.pythonhosted.org/packages/3c/a1/3d6ccdcd125b0a42a311bcd15a7f705d688f73b2a22d8cf1c0875d35d34a/websockets-16.0-cp313-cp313-win32.whl", hash = "sha256:abf050a199613f64c886ea10f38b47770a65154dc37181bfaff70c160f45315a", size = 178255 },
+    { url = "https://files.pythonhosted.org/packages/6b/ae/90366304d7c2ce80f9b826096a9e9048b4bb760e44d3b873bb272cba696b/websockets-16.0-cp313-cp313-win_amd64.whl", hash = "sha256:3425ac5cf448801335d6fdc7ae1eb22072055417a96cc6b31b3861f455fbc156", size = 178689 },
+    { url = "https://files.pythonhosted.org/packages/f3/1d/e88022630271f5bd349ed82417136281931e558d628dd52c4d8621b4a0b2/websockets-16.0-cp314-cp314-macosx_10_15_universal2.whl", hash = "sha256:8cc451a50f2aee53042ac52d2d053d08bf89bcb31ae799cb4487587661c038a0", size = 177406 },
+    { url = "https://files.pythonhosted.org/packages/f2/78/e63be1bf0724eeb4616efb1ae1c9044f7c3953b7957799abb5915bffd38e/websockets-16.0-cp314-cp314-macosx_10_15_x86_64.whl", hash = "sha256:daa3b6ff70a9241cf6c7fc9e949d41232d9d7d26fd3522b1ad2b4d62487e9904", size = 175085 },
+    { url = "https://files.pythonhosted.org/packages/bb/f4/d3c9220d818ee955ae390cf319a7c7a467beceb24f05ee7aaaa2414345ba/websockets-16.0-cp314-cp314-macosx_11_0_arm64.whl", hash = "sha256:fd3cb4adb94a2a6e2b7c0d8d05cb94e6f1c81a0cf9dc2694fb65c7e8d94c42e4", size = 175328 },
+    { url = "https://files.pythonhosted.org/packages/63/bc/d3e208028de777087e6fb2b122051a6ff7bbcca0d6df9d9c2bf1dd869ae9/websockets-16.0-cp314-cp314-manylinux1_x86_64.manylinux_2_28_x86_64.manylinux_2_5_x86_64.whl", hash = "sha256:781caf5e8eee67f663126490c2f96f40906594cb86b408a703630f95550a8c3e", size = 185044 },
+    { url = "https://files.pythonhosted.org/packages/ad/6e/9a0927ac24bd33a0a9af834d89e0abc7cfd8e13bed17a86407a66773cc0e/websockets-16.0-cp314-cp314-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:caab51a72c51973ca21fa8a18bd8165e1a0183f1ac7066a182ff27107b71e1a4", size = 186279 },
+    { url = "https://files.pythonhosted.org/packages/b9/ca/bf1c68440d7a868180e11be653c85959502efd3a709323230314fda6e0b3/websockets-16.0-cp314-cp314-musllinux_1_2_aarch64.whl", hash = "sha256:19c4dc84098e523fd63711e563077d39e90ec6702aff4b5d9e344a60cb3c0cb1", size = 185711 },
+    { url = "https://files.pythonhosted.org/packages/c4/f8/fdc34643a989561f217bb477cbc47a3a07212cbda91c0e4389c43c296ebf/websockets-16.0-cp314-cp314-musllinux_1_2_x86_64.whl", hash = "sha256:a5e18a238a2b2249c9a9235466b90e96ae4795672598a58772dd806edc7ac6d3", size = 184982 },
+    { url = "https://files.pythonhosted.org/packages/dd/d1/574fa27e233764dbac9c52730d63fcf2823b16f0856b3329fc6268d6ae4f/websockets-16.0-cp314-cp314-win32.whl", hash = "sha256:a069d734c4a043182729edd3e9f247c3b2a4035415a9172fd0f1b71658a320a8", size = 177915 },
+    { url = "https://files.pythonhosted.org/packages/8a/f1/ae6b937bf3126b5134ce1f482365fde31a357c784ac51852978768b5eff4/websockets-16.0-cp314-cp314-win_amd64.whl", hash = "sha256:c0ee0e63f23914732c6d7e0cce24915c48f3f1512ec1d079ed01fc629dab269d", size = 178381 },
+    { url = "https://files.pythonhosted.org/packages/06/9b/f791d1db48403e1f0a27577a6beb37afae94254a8c6f08be4a23e4930bc0/websockets-16.0-cp314-cp314t-macosx_10_15_universal2.whl", hash = "sha256:a35539cacc3febb22b8f4d4a99cc79b104226a756aa7400adc722e83b0d03244", size = 177737 },
+    { url = "https://files.pythonhosted.org/packages/bd/40/53ad02341fa33b3ce489023f635367a4ac98b73570102ad2cdd770dacc9a/websockets-16.0-cp314-cp314t-macosx_10_15_x86_64.whl", hash = "sha256:b784ca5de850f4ce93ec85d3269d24d4c82f22b7212023c974c401d4980ebc5e", size = 175268 },
+    { url = "https://files.pythonhosted.org/packages/74/9b/6158d4e459b984f949dcbbb0c5d270154c7618e11c01029b9bbd1bb4c4f9/websockets-16.0-cp314-cp314t-macosx_11_0_arm64.whl", hash = "sha256:569d01a4e7fba956c5ae4fc988f0d4e187900f5497ce46339c996dbf24f17641", size = 175486 },
+    { url = "https://files.pythonhosted.org/packages/e5/2d/7583b30208b639c8090206f95073646c2c9ffd66f44df967981a64f849ad/websockets-16.0-cp314-cp314t-manylinux1_x86_64.manylinux_2_28_x86_64.manylinux_2_5_x86_64.whl", hash = "sha256:50f23cdd8343b984957e4077839841146f67a3d31ab0d00e6b824e74c5b2f6e8", size = 185331 },
+    { url = "https://files.pythonhosted.org/packages/45/b0/cce3784eb519b7b5ad680d14b9673a31ab8dcb7aad8b64d81709d2430aa8/websockets-16.0-cp314-cp314t-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:152284a83a00c59b759697b7f9e9cddf4e3c7861dd0d964b472b70f78f89e80e", size = 186501 },
+    { url = "https://files.pythonhosted.org/packages/19/60/b8ebe4c7e89fb5f6cdf080623c9d92789a53636950f7abacfc33fe2b3135/websockets-16.0-cp314-cp314t-musllinux_1_2_aarch64.whl", hash = "sha256:bc59589ab64b0022385f429b94697348a6a234e8ce22544e3681b2e9331b5944", size = 186062 },
+    { url = "https://files.pythonhosted.org/packages/88/a8/a080593f89b0138b6cba1b28f8df5673b5506f72879322288b031337c0b8/websockets-16.0-cp314-cp314t-musllinux_1_2_x86_64.whl", hash = "sha256:32da954ffa2814258030e5a57bc73a3635463238e797c7375dc8091327434206", size = 185356 },
+    { url = "https://files.pythonhosted.org/packages/c2/b6/b9afed2afadddaf5ebb2afa801abf4b0868f42f8539bfe4b071b5266c9fe/websockets-16.0-cp314-cp314t-win32.whl", hash = "sha256:5a4b4cc550cb665dd8a47f868c8d04c8230f857363ad3c9caf7a0c3bf8c61ca6", size = 178085 },
+    { url = "https://files.pythonhosted.org/packages/9f/3e/28135a24e384493fa804216b79a6a6759a38cc4ff59118787b9fb693df93/websockets-16.0-cp314-cp314t-win_amd64.whl", hash = "sha256:b14dc141ed6d2dde437cddb216004bcac6a1df0935d79656387bd41632ba0bbd", size = 178531 },
+    { url = "https://files.pythonhosted.org/packages/72/07/c98a68571dcf256e74f1f816b8cc5eae6eb2d3d5cfa44d37f801619d9166/websockets-16.0-pp311-pypy311_pp73-macosx_10_15_x86_64.whl", hash = "sha256:349f83cd6c9a415428ee1005cadb5c2c56f4389bc06a9af16103c3bc3dcc8b7d", size = 174947 },
+    { url = "https://files.pythonhosted.org/packages/7e/52/93e166a81e0305b33fe416338be92ae863563fe7bce446b0f687b9df5aea/websockets-16.0-pp311-pypy311_pp73-macosx_11_0_arm64.whl", hash = "sha256:4a1aba3340a8dca8db6eb5a7986157f52eb9e436b74813764241981ca4888f03", size = 175260 },
+    { url = "https://files.pythonhosted.org/packages/56/0c/2dbf513bafd24889d33de2ff0368190a0e69f37bcfa19009ef819fe4d507/websockets-16.0-pp311-pypy311_pp73-manylinux1_x86_64.manylinux_2_28_x86_64.manylinux_2_5_x86_64.whl", hash = "sha256:f4a32d1bd841d4bcbffdcb3d2ce50c09c3909fbead375ab28d0181af89fd04da", size = 176071 },
+    { url = "https://files.pythonhosted.org/packages/a5/8f/aea9c71cc92bf9b6cc0f7f70df8f0b420636b6c96ef4feee1e16f80f75dd/websockets-16.0-pp311-pypy311_pp73-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:0298d07ee155e2e9fda5be8a9042200dd2e3bb0b8a38482156576f863a9d457c", size = 176968 },
+    { url = "https://files.pythonhosted.org/packages/9a/3f/f70e03f40ffc9a30d817eef7da1be72ee4956ba8d7255c399a01b135902a/websockets-16.0-pp311-pypy311_pp73-win_amd64.whl", hash = "sha256:a653aea902e0324b52f1613332ddf50b00c06fdaf7e92624fbf8c77c78fa5767", size = 178735 },
+    { url = "https://files.pythonhosted.org/packages/6f/28/258ebab549c2bf3e64d2b0217b973467394a9cea8c42f70418ca2c5d0d2e/websockets-16.0-py3-none-any.whl", hash = "sha256:1637db62fad1dc833276dded54215f2c7fa46912301a24bd94d45d46a011ceec", size = 171598 },
+]
+
+[[package]]
+name = "xiaohongshu-skills"
+version = "0.1.0"
+source = { virtual = "." }
+dependencies = [
+    { name = "requests" },
+    { name = "websockets" },
+]
+
+[package.optional-dependencies]
+dev = [
+    { name = "pytest" },
+    { name = "ruff" },
+]
+
+[package.metadata]
+requires-dist = [
+    { name = "pytest", marker = "extra == 'dev'", specifier = ">=8.0" },
+    { name = "requests", specifier = ">=2.28.0" },
+    { name = "ruff", marker = "extra == 'dev'", specifier = ">=0.9.0" },
+    { name = "websockets", specifier = ">=12.0" },
+]
+provides-extras = ["dev"]