Sync from GitHub: 71b4e35efd6a40202ad9904ea8e1cdf66d0504ac

.gitignore

@@ -0,0 +1,5 @@
+node_modules/
+data/
+test/
+config.yaml
+camoufox/

CHANGELOG.md

@@ -0,0 +1,254 @@
+# Changelog
+
+All notable changes to this project will be documented in this file.
+
+The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.0.0/),
+and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
+
+## [3.4.5] - 2026-01-11
+
+### ✨ Added
+- **增加计数功能**
+  - 支持在 WebUI 记录与查看成功次数
+- **FireFox 参数**
+  - 增加 FireFox 站点隔离机制开关
+- **提示词违规提示**
+  - 提示词违规时提示内容被阻止
+
+### 🐛 Fixed
+- **修复图片上传**
+  - 修复 LMArena 因模型选择与图片上传的顺序错误导致的图片上传失败
+
+## [3.4.4] - 2026-01-10
+
+### ✨ Added
+- **新增适配器**
+  - 支持豆包图片生成与文本生成适配器
+
+### 🐛 Fixed
+- **未捕获的超时错误**
+  - 修复因未捕获的超时错误导致的程序崩溃
+- **模型选择**
+  - 修复 LMArena 模型选择的问题并同步模型列表
+
+## [3.4.3] - 2025-12-26
+
+### ✨ Added
+- **适配器描述**
+  - 为每个适配器添加描述，可以在 WebUI 中的适配器设置页面点击查看每个适配器的描述和使用方法。
+- **适配器模型管理**
+  - 为每个适配器添加模型列表管理，支持黑名单和白名单，可用于禁用网站出现问题的模型
+- **调试适配器**
+  - 多种检测网站聚合，IP 纯净度查询等，并初步测试自动过盾
+
+## [3.4.3] - 2025-12-26
+
+### 🐛 Fixed
+- **Gemini**：修复因懒加载导致的等待图片超时问题
+
+## [3.4.2] - 2025-12-25
+
+### 🔄 Changed
+- **浏览器指纹**
+  - 增加 WebGL 和 Canvas 噪点的持久化，防止频繁变化
+  - 清洗插件列表，防止出现 FireFox 中有 Chrome 内置的 PDF 阅读器插件
+  - 清洗 UA 标识，防止出现未来浏览器版本，导致某些网站报错403 (如：aistudio)
+- **关闭动画**
+  - 通过 about:config 中的设置禁用背景高斯模糊 CSS 和减少动画，节省资源占用
+
+## [3.4.1] - 2025-12-24
+
+### ✨ Added
+- **新增适配器**
+  - 支持 Google Flow 图片生成适配器
+
+### 🐛 Fixed
+- **Gemini Business**：修复因懒加载导致的等待图片超时问题
+
+## [3.4.0] - 2025-12-23
+
+### ✨ Added
+- **新增适配器**
+  - 支持 ChatGPT 文本生成适配器
+  - 支持 zAI 文本生成适配器
+  - 支持 DeepSeek 文本生成适配器
+  - 支持 Sora 视频生成适配器
+
+### 🔄 Changed
+- **适配器实现更改**
+  - zAI 图片生成适配器不再使用拦截请求修改响应体的方式，改为UI选择模型列表，并且Nano Banana Pro 支持选择1K、2K、4K
+
+## [3.3.2] - 2025-12-22
+
+### 🔄 Changed
+- **配置文件**
+  - 自动复制初始化配置文件，并放进`data/config.yaml`，Docker友好化
+  - 优化 Dockerfile
+  - 初始化脚本不再依赖配置文件，支持交互式和参数传入式配置代理
+  - 优化 WebUI 文案和日志排列
+
+### ❌ Removed
+- **删除测试脚本**
+  - 现在有 WebUI 测试了，已经无需 test 脚本了
+
+## [3.3.1] - 2025-12-21
+
+### ✨ Added
+- **新增适配器**
+  - 支持 Gemini 网页版文本生成
+  - 支持 ChatGPT 图片生成
+- **支持视频生成**
+  - 支持在 Gemini 网页版和 Gemini Enterprise Business 图片生成适配器中生成视频
+
+### 🔄 Changed
+- **优化图片下载方式**
+  - 让文件下载步骤直接继承浏览器上下文减少特征
+
+## [3.3.0] - 2025-12-20
+
+### ✨ Added
+- **新增适配器**
+  - 支持 ZenMux 
+
+### 🔄 Changed
+- **清理历史遗留**
+  - 清除历史遗留的多余的逻辑
+
+## [3.2.1] - 2025-12-20
+
+### ✨ Added
+- **WebUI**
+  - 完善 WebUI 功能，添加接口测试和日志查看器，优化部分布局
+- **日志记录**
+  - 会在 data/temp 文件夹下记录日志（最大5MB轮转）
+
+### 🔄 Changed
+- **初始化失败逻辑**
+  - 程序初始化失败后不会直接推出，以便利用 WebUI 修改错误的配置
+- **LMArena 图片适配器**
+  - 支持通过配置直接返回图片URL (但其他不支持该选项的适配器仍然会返回 Base64)
+
+## [3.2.0] - 2025-12-19
+
+### ✨ Added
+- **WebUI**
+  - 为项目添加了网页版管理工具，便于修改配置文件（可能会有问题，可随时反馈）
+
+- **增加看门狗**
+  - 增加看门狗机制（Supervisor），保证程序失败重载和利于利用 WebUI 完整重启程序
+  - 同时将 Linux 上的虚拟显示器和 VNC 服务器启动程序也迁移至看门狗机制
+
+## [3.1.0] - 2025-12-17
+
+### ✨ Added
+- **支持文本模型**
+  - 添加专门的文本模型适配器（目前仅支持 LMArena 和 Gemini Busineess）
+  - 支持网络搜索模型，例如 gemini-3-pro-grounding、grok-4-1-fast-search
+- **图片调度**
+  - 若有适配器同时支持同一个模型，但是图片策略不同，将会优先将带图片的请求分发给支持图片的适配器
+- **为自动通过验证码做准备**
+  - 新增测试适配器 turnstile_test ，为将来需要自动过 CloudFlare 验证码做准备
+
+### 🔄 Changed
+- **项目名称更新**
+  - 因支持的功能越来越多，决定为项目改名为 WebAI2API
+
+## [3.0.1] - 2025-12-16
+
+### ✨ Added
+- **故障转移系统**
+  - 实现了基于 Pool 的自动故障转移：当某个 Worker 执行任务失败（如 API 超时、页面崩溃、被限流）时，系统会自动寻找下一个支持该模型的 Worker 进行重试。
+  - **Merge 模式增强**：Merge Worker 内部也会在不同的适配器之间进行故障转移。
+
+## [3.0.0] - 2025-12-14
+
+### ✨ Added
+- **多窗口多账号支持**
+  - 架构升级，支持同时管理多个浏览器实例和多个标签页。
+  - 实现了浏览器实例间的数据（Cookies/Storage）完全隔离。
+- **Cookies 管理**
+  - 新增 `/v1/cookies` 接口，支持获取指定 browser instance 的 Cookies。
+
+### 🔄 Changed
+- **配置系统重构**
+  - 配置文件结构大幅调整，采用更清晰的 `backend.pool` 结构配置 Worker。
+
+## [2.4.0] - 2025-12-13
+
+### ✨ Added
+- **浏览器伪装增强**
+  - 集成 GEOIP 数据库，实现基于 IP 的自动时区伪装。
+- **初始化脚本 (init.js)**
+  - 支持 `npm run init -- -custom` 自定义初始化。
+  - 自动下载 GeoLite2 sum数据库。
+- **服务器自检**
+  - 启动时自动检查依赖完整性和环境补丁。
+- **Merge 模式监控**
+  - 闲时自动跳转到指定网站以维持会话活跃（保活）。
+
+### 🔄 Changed
+- **代码重构**
+  - 服务器代码模块化 (`src/server/`).
+  - 目录结构重新整理。
+
+## [2.3.0] - 2025-12-12
+
+### ✨ Added
+- **新适配器支持**
+  - 初步支持 Gemini 网页版 (`gemini.js`).
+
+### 🔄 Changed
+- **流式接口优化**
+  - 移除了全局开关，改为由请求体参数 `stream: true` 动态控制。
+  - **保活机制**：流式模式下支持无限排队，并通过 SSE 心跳包防止连接超时。
+  - **拒绝策略**：非流式请求在队列满时立即拒绝，避免无限等待。
+
+## [2.2.3] - 2025-12-12
+
+### ✨ Added
+- **后端聚合**
+  - 实现了根据模型 ID 自动路由到对应适配器的逻辑。
+
+### 🐛 Fixed
+- **Mac 兼容性**
+  - 修复了 MacOS 初始化步骤缺失导致的启动失败。
+
+## [2.2.2] - 2025-12-12
+
+### ✨ Added
+- **Docker 支持**
+  - 发布 Docker 镜像
+
+## [2.2.1] - 2025-12-12
+
+### ✨ Added
+- **Cookie 导出**
+  - 利用自动续登机制获取最新 Cookie，供外部工具使用。
+
+### 🐛 Fixed
+- **自动续登修复**：改为全局监听，修复了部分场景下不触发的问题。
+- **杂项修复**：VNC 端口冲突、启动参数优化、zAI 错误反馈优化。
+
+## [2.2.0] - 2025-12-11
+
+### ✨ Added
+- **新适配器支持**
+  - 支持 zAI (zai.is)，含自动 Discord 登录处理。
+
+### 🐛 Fixed
+- **Gemini Business**：修复监听器重复触发问题。
+- **Mac 输入法**：修复拟人输入无法全选的问题。
+
+## [2.0.0] - 2025-12-06
+
+### 💥 Breaking Changes
+- **核心迁移**
+  - 从 Puppeteer 迁移至 **Playwright + Camoufox**。
+  - 旧版代码归档至 `puppeteer-edition` 分支。
+
+### ✨ Added
+- **新适配器支持**
+  - 支持 Nano Banana Free。
+- **功能特性**
+  - 内置 XVFB/VNC 支持命令。
+  - 支持 Gemini Business 过期自动续登。

Dockerfile

@@ -0,0 +1,41 @@
+FROM node:22-bookworm
+
+WORKDIR /app
+
+ENV DEBIAN_FRONTEND=noninteractive
+ENV PLAYWRIGHT_SKIP_BROWSER_DOWNLOAD=true
+
+# 1. 安装系统依赖
+RUN apt-get update && apt-get install -y \
+    xvfb \
+    x11vnc \
+    libasound2 \
+    libatk-bridge2.0-0 \
+    libgtk-3-0 \
+    libnss3 \
+    libx11-xcb1 \
+    libxss1 \
+    libxtst6 \
+    libgbm1 \
+    libdbus-glib-1-2 \
+    python3 \
+    build-essential \
+    && rm -rf /var/lib/apt/lists/*
+
+# 2. 复制依赖文件、脚本和补丁目录，然后安装
+COPY package.json pnpm-lock.yaml ./
+COPY scripts/ ./scripts/
+COPY patches/ ./patches/
+RUN npm install -g pnpm && pnpm install --no-frozen-lockfile
+
+# 3. 复制源码并初始化
+COPY . .
+RUN npm run init
+
+# 4. 设置启动脚本权限
+RUN chmod +x start_hf.sh
+
+EXPOSE 3000 5900
+
+# 5. 使用 Hugging Face Space 启动脚本
+CMD ["./start_hf.sh"]

HUGGINGFACE_SPACE.md

@@ -0,0 +1,198 @@
+# Hugging Face Space 部署指南
+
+## 📋 前置要求
+
+- Hugging Face 账号
+- 推荐使用 **CPU Basic** 或更高级别的 Space（免费版可能资源不足）
+
+## 🚀 部署步骤
+
+### 1. 创建 Space
+
+1. 访问 https://huggingface.co/spaces
+2. 点击 "Create new Space"
+3. 配置：
+   - **Owner**: 选择您的账号
+   - **Space name**: 输入名称（如 `webai2api`）
+   - **SDK**: 选择 **Docker**
+   - **Hardware**: 推荐 **CPU Basic**（$0.10/小时）或更高
+   - **Visibility**: Public 或 Private
+
+### 2. 推送代码
+
+```bash
+# 克隆 Space
+git clone https://huggingface.co/spaces/YOUR_USERNAME/YOUR_SPACE_NAME
+cd YOUR_SPACE_NAME
+
+# 添加远程仓库
+git remote add origin https://huggingface.co/spaces/YOUR_USERNAME/YOUR_SPACE_NAME
+
+# 推送 webai2hf 分支
+git push origin webai2hf:main
+```
+
+### 3. 配置环境变量（可选）
+
+在 Space 的 **Settings** → **Variables** 中添加：
+
+- `AUTH_TOKEN`: API 鉴权密钥（可选，不设置则使用配置文件中的值）
+
+### 4. 等待构建
+
+- 首次构建需要 5-10 分钟
+- 构建完成后服务自动启动
+- 浏览器初始化需要 30-60 秒
+
+## ⚠️ 重要提示
+
+### 资源限制
+
+| 硬件类型 | CPU | 内存 | 价格 | 推荐度 |
+|---------|-----|------|------|--------|
+| CPU Basic | 2 vCPU | 16 GB | $0.10/小时 | ✅ 推荐 |
+| CPU Upgrade | 4 vCPU | 32 GB | $0.30/小时 | ✅✅ 最佳 |
+| CPU XL | 8 vCPU | 64 GB | $0.80/小时 | ✅✅✅ 极佳 |
+
+**免费版**（CPU tiny）资源严重不足，**不推荐**使用。
+
+### 内存优化
+
+已针对 Hugging Face Space 进行了以下优化：
+
+1. **关闭 Fission**：`fission: false`（内存从 ~2GB 降至 ~1GB）
+2. **使用无头模式**：`headless: true`（节省显示资源）
+3. **减少队列缓冲**：`queueBuffer: 1`
+4. **限制图片数量**：`imageLimit: 3`
+
+### 首次使用
+
+1. **访问 Space URL**：`https://huggingface.co/spaces/YOUR_USERNAME/YOUR_SPACE_NAME`
+2. **点击 "🎨 访问 WebUI"**
+3. **完成账号登录**：
+   - 在 WebUI 中找到适配器管理
+   - 手动登录所需的 AI 网站
+   - 发送测试消息验证
+
+## 🔧 故障排除
+
+### 问题 1：服务器被暂停（SIGTERM）
+
+**原因**：内存超限或启动超时
+
+**解决方案**：
+1. 升级到 **CPU Basic** 或更高级别的 Space
+2. 检查日志查看具体错误
+3. 确保使用优化配置 `config.hf.yaml`
+
+### 问题 2：浏览器启动失败
+
+**原因**：资源不足或配置错误
+
+**解决方案**：
+1. 检查 Space 硬件配置
+2. 查看 Space Logs 中的错误信息
+3. 确认配置文件正确
+
+### 问题 3：无法访问虚拟显示器
+
+**原因**：Hugging Face Space 网络限制
+
+**解决方案**：
+1. 通过 WebUI 的 VNC 功能访问
+2. 不支持直接 VNC 客户端连接
+3. 使用 WebUI 进行所有操作
+
+### 问题 4：API 返回 503
+
+**原因**：浏览器初始化未完成或配置错误
+
+**解决方案**：
+1. 等待 30-60 秒让浏览器完全启动
+2. 检查 `/v1/models` 端点是否正常
+3. 查看 Space Logs 确认浏览器已启动
+
+## 📊 监控和日志
+
+### 查看日志
+
+1. 访问 Space 页面
+2. 点击 **"Logs"** 标签
+3. 查看实时日志输出
+
+### 健康检查
+
+访问以下端点检查服务状态：
+
+- `GET /` - 首页（显示服务状态）
+- `GET /v1/models` - 模型列表（API 是否正常）
+
+## 💰 成本估算
+
+以 **CPU Basic** 为例：
+
+- **空闲时**：$0.10/小时 = $2.40/天 = $72/月
+- **使用时**：相同费用（按小时计费）
+
+**建议**：
+- 只在需要时启动 Space
+- 使用后及时暂停或删除
+- 考虑使用其他更便宜的云服务
+
+## 🔄 更新部署
+
+```bash
+# 拉取最新代码
+git pull origin main
+
+# 推送更新
+git push origin main
+```
+
+Space 会自动重新构建和部署。
+
+## 📞 获取帮助
+
+- **GitHub Issues**: https://github.com/foxhui/WebAI2API/issues
+- **文档**: https://foxhui.github.io/WebAI2API/
+- **Hugging Face Discord**: https://discord.gg/huggingface
+
+## 📝 配置说明
+
+### config.hf.yaml 优化配置
+
+```yaml
+server:
+  port: 7860
+
+browser:
+  headless: true      # 无头模式节省资源
+  fission: false      # 关闭站点隔离降低内存
+
+queue:
+  queueBuffer: 1      # 减少队列缓冲
+  imageLimit: 3       # 限制图片数量
+```
+
+## ⚡ 性能优化建议
+
+1. **使用付费版 Space**：免费版资源严重不足
+2. **按需启动**：不需要时暂停 Space
+3. **监控资源使用**：定期查看 CPU 和内存使用情况
+4. **优化配置**：根据实际需求调整配置参数
+
+## 🎯 使用场景
+
+### 适合
+
+- ✅ 测试和演示
+- ✅ 临时使用
+- ✅ 小规模应用
+
+### 不适合
+
+- ❌ 高并发生产环境
+- ❌ 长时间运行
+- ❌ 大规模应用
+
+**建议**：生产环境使用自己的服务器或云服务（如 AWS、阿里云等）。

LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025 foxhui
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

PERSISTENCE_SOLUTIONS.md

@@ -0,0 +1,247 @@
+# Hugging Face Space 数据持久化方案
+
+## 📋 问题
+
+Hugging Face Space 的存储不是持久化的，每次重启后：
+- `data/` 目录会被清空
+- 浏览器登录状态会丢失
+- 需要重新登录
+
+## 🎯 需求
+
+1. **首次启动**：登录模式，保存登录信息
+2. **再次启动**：正常模式，使用保存的登录信息
+
+## 💡 解决方案
+
+### 方案一：使用 Hugging Face Datasets（推荐）
+
+**优点**：
+- ✅ 免费
+- ✅ 完全集成在 Hugging Face 生态中
+- ✅ 支持大文件
+- ✅ 自动版本控制
+
+**缺点**：
+- ❌ 需要额外的 API Token
+- ❌ 上传/下载需要时间
+
+**实现步骤**：
+
+1. **创建 Dataset**：
+   - 访问 https://huggingface.co/datasets
+   - 创建新的 Dataset（如 `YOUR_USERNAME/webai2api-data`）
+   - 设置为 Private（保护隐私）
+
+2. **配置环境变量**：
+   在 Space Settings 中添加：
+   - `HF_DATASET_REPO`: `YOUR_USERNAME/webai2api-data`
+   - `HF_TOKEN`: 您的 Hugging Face Token（需要 write 权限）
+
+3. **自动保存脚本**：
+   ```bash
+   # 登录完成后，手动执行
+   npm run save-data
+   ```
+
+4. **启动时自动恢复**：
+   启动脚本会自动检查并恢复数据
+
+---
+
+### 方案二：使用外部云存储（S3/OneDrive）
+
+**优点**：
+- ✅ 灵活性高
+- ✅ 可以使用任何云服务
+- ✅ 成本可控
+
+**缺点**：
+- ❌ 需要额外的云服务账号
+- ❌ 需要配置 API 密钥
+
+**支持的云服务**：
+- AWS S3
+- 阿里云 OSS
+- 腾讯云 COS
+- OneDrive
+- Google Drive
+
+---
+
+### 方案三：使用 Cookie 导出/导入（轻量级）
+
+**优点**：
+- ✅ 文件小，上传快
+- ✅ 只保存必要信息
+- ✅ 安全性高
+
+**缺点**：
+- ❌ 可能需要重新登录（Cookie 过期）
+- ❌ 功能有限
+
+**实现**：
+```bash
+# 导出 Cookie
+npm run export-cookies
+
+# 导入 Cookie
+npm run import-cookies
+```
+
+---
+
+### 方案四：使用 Hugging Face Space 持久化存储（付费）
+
+**优点**：
+- ✅ 最简单
+- ✅ 自动持久化
+- ✅ 无需额外配置
+
+**缺点**：
+- ❌ 需要付费（$5/月 起）
+- ❌ 需要升级 Space
+
+**步骤**：
+1. 在 Space Settings 中启用持久化存储
+2. 选择存储大小（10GB 起）
+3. 每月 $5
+
+---
+
+## 🚀 推荐方案对比
+
+| 方案 | 成本 | 复杂度 | 可靠性 | 推荐度 |
+|------|------|--------|--------|--------|
+| Datasets | 免费 | 中 | 高 | ✅✅✅ |
+| 外部云存储 | 低 | 高 | 高 | ✅✅ |
+| Cookie 导出 | 免费 | 低 | 中 | ✅ |
+| 持久化存储 | $5/月 | 低 | 最高 | ✅✅✅✅ |
+
+## 📖 详细实现
+
+### 方案一：使用 Hugging Face Datasets（完整实现）
+
+#### 1. 创建 Dataset
+
+1. 访问 https://huggingface.co/datasets/new
+2. 输入名称：`YOUR_USERNAME/webai2api-data`
+3. 选择：Private
+4. 点击 Create
+
+#### 2. 获取 Token
+
+1. 访问 https://huggingface.co/settings/tokens
+2. 创建新 Token
+3. 权限选择：`write`
+4. 复制 Token
+
+#### 3. 配置 Space
+
+在 Space Settings → Variables 中添加：
+```
+HF_DATASET_REPO=YOUR_USERNAME/webai2api-data
+HF_TOKEN=hf_xxxxxxxxxxxxxxxxxxxxxxxxxxxxxx
+```
+
+#### 4. 使用脚本
+
+项目已包含以下脚本：
+
+**保存数据**：
+```bash
+# 登录完成后执行
+npm run save-data
+```
+
+**恢复数据**：
+```bash
+# 启动时自动执行
+# 或手动执行
+npm run restore-data
+```
+
+**删除数据**：
+```bash
+npm run clear-data
+```
+
+#### 5. 工作流程
+
+**首次使用**：
+1. 启动 Space（无数据）
+2. 通过 WebUI 登录
+3. 执行 `npm run save-data` 保存数据
+4. 数据上传到 Hugging Face Dataset
+
+**后续使用**：
+1. 启动 Space
+2. 自动从 Dataset 恢复数据
+3. 直接使用，无需重新登录
+
+---
+
+## 🔧 故障排除
+
+### 问题 1：上传失败
+
+**原因**：Token 权限不足
+
+**解决**：
+1. 检查 Token 是否有 `write` 权限
+2. 检查 Dataset 名称是否正确
+3. 检查网络连接
+
+### 问题 2：恢复失败
+
+**原因**：数据损坏或不完整
+
+**解决**：
+1. 删除本地数据：`npm run clear-data`
+2. 重新上传：`npm run save-data`
+3. 检查 Dataset 中的文件
+
+### 问题 3：Cookie 过期
+
+**原因**：Cookie 有效期已过
+
+**解决**：
+1. 重新登录
+2. 重新保存数据
+
+---
+
+## 💰 成本估算
+
+### 方案一：Hugging Face Datasets
+- **存储**：免费（有限制）
+- **流量**：免费
+- **总计**：$0/月
+
+### 方案二：外部云存储
+- **AWS S3**: $0.023/GB/月
+- **阿里云 OSS**: ¥0.12/GB/月
+- **腾讯云 COS**: ¥0.118/GB/月
+
+### 方案三：Cookie 导出
+- **存储**：免费（文件很小）
+- **总计**：$0/月
+
+### 方案四：持久化存储
+- **10GB**: $5/月
+- **20GB**: $10/月
+- **50GB**: $20/月
+
+---
+
+## 📝 总结
+
+**推荐方案**：
+- **测试/个人使用**：方案一（Hugging Face Datasets）
+- **生产环境**：方案四（持久化存储）
+- **成本敏感**：方案三（Cookie 导出）
+
+**注意事项**：
+- ⚠️ 定期备份数据
+- ⚠️ 不要将敏感信息提交到公开仓库
+- ⚠️ 使用 HTTPS 保护数据传输

QUICK_START_PERSISTENCE.md

@@ -0,0 +1,273 @@
+# Hugging Face Space 数据持久化快速指南
+
+## 🚀 快速开始（3 步完成）
+
+### 步骤 1：创建 Dataset
+
+1. 访问 https://huggingface.co/datasets/new
+2. 输入名称：`YOUR_USERNAME/webai2api-data`
+3. 选择：**Private**（保护隐私）
+4. 点击 **Create**
+
+### 步骤 2：获取 Token
+
+1. 访问 https://huggingface.co/settings/tokens
+2. 点击 **New token**
+3. Token name: `webai2api-space`
+4. 权限选择：**write**
+5. 点击 **Create token**
+6. 复制 Token（格式：`hf_xxxxxxxxxxxxxxxxxxxxxxxxxxxxxx`）
+
+### 步骤 3：配置 Space
+
+在 Space Settings → **Variables** 中添加：
+
+```
+HF_DATASET_REPO=YOUR_USERNAME/webai2api-data
+HF_TOKEN=hf_xxxxxxxxxxxxxxxxxxxxxxxxxxxxxx
+```
+
+例如：
+```
+HF_DATASET_REPO=iudd/webai2api-data
+HF_TOKEN=hf_abc123xyz456...
+```
+
+保存后，Space 会自动重启。
+
+---
+
+## 📖 使用流程
+
+### 首次使用（登录模式）
+
+1. **启动 Space**（首次，无数据）
+   ```
+   Space 自动启动，检测到无数据
+   ```
+
+2. **访问 WebUI**
+   ```
+   https://huggingface.co/spaces/YOUR_USERNAME/YOUR_SPACE_NAME
+   ```
+
+3. **连接虚拟显示器**
+   - 点击 "🎨 访问 WebUI"
+   - 在 WebUI 中找到 "虚拟显示器" 板块
+   - 点击连接
+
+4. **完成登录**
+   - 在虚拟显示器中登录所需的 AI 网站
+   - 发送测试消息验证
+   - 确保登录状态正常
+
+5. **保存数据**
+   - 在 Space 的终端中执行：
+     ```bash
+     npm run save-data
+     ```
+   - 等待上传完成（约 1-2 分钟）
+   - 看到 "✅ 数据保存成功" 即可
+
+### 后续使用（自动恢复）
+
+1. **启动 Space**
+   ```
+   Space 自动启动
+   检测到环境变量
+   自动从 Dataset 恢复数据
+   ```
+
+2. **直接使用**
+   - 浏览器已恢复登录状态
+   - 无需重新登录
+   - 直接调用 API
+
+---
+
+## 🛠️ 常用命令
+
+### 保存数据
+```bash
+npm run save-data
+```
+**使用场景**：
+- 首次登录完成后
+- 更新登录状态后
+- 定期备份
+
+### 恢复数据
+```bash
+npm run restore-data
+```
+**使用场景**：
+- 手动恢复数据
+- 数据丢失后恢复
+
+### 清除数据
+```bash
+npm run clear-data
+```
+**使用场景**：
+- 清除本地数据
+- 重新登录前
+- 5 秒倒计时，可取消
+
+---
+
+## ⚠️ 注意事项
+
+1. **首次使用必须手动保存**
+   - 自动恢复只在有数据时生效
+   - 首次登录后必须手动执行 `npm run save-data`
+
+2. **Cookie 过期问题**
+   - 如果 Cookie 过期，需要重新登录
+   - 重新登录后执行 `npm run save-data`
+
+3. **数据隐私**
+   - Dataset 设置为 **Private**
+   - 不要将 Token 泄露
+   - 定期更换 Token
+
+4. **网络问题**
+   - 上传/下载需要时间
+   - 如果失败，重试即可
+   - 检查网络连接
+
+---
+
+## 🔧 故障排除
+
+### 问题 1：自动恢复失败
+
+**症状**：
+```
+⚠️  数据恢复失败，将使用新的浏览器实例
+```
+
+**解决方案**：
+1. 检查环境变量是否正确
+2. 检查 Dataset 是否存在
+3. 检查 Token 权限（需要 read）
+4. 手动执行 `npm run restore-data`
+
+### 问题 2：保存失败
+
+**症状**：
+```
+❌ 保存失败: ...
+```
+
+**解决方案**：
+1. 检查 Token 权限（需要 write）
+2. 检查 Dataset 名称
+3. 检查网络连接
+4. 确保已登录
+
+### 问题 3：需要重新登录
+
+**原因**：Cookie 过期
+
+**解决方案**：
+1. 清除数据：`npm run clear-data`
+2. 重新登录
+3. 保存数据：`npm run save-data`
+
+---
+
+## 💡 最佳实践
+
+1. **定期保存**
+   - 每次登录后立即保存
+   - 定期检查数据状态
+
+2. **备份策略**
+   - 保留多个版本（Dataset 自动版本控制）
+   - 定期导出关键数据
+
+3. **安全建议**
+   - 使用强密码
+   - 定期更换 Token
+   - 监控访问日志
+
+4. **成本控制**
+   - Dataset 存储免费
+   - 流量免费
+   - 无额外成本
+
+---
+
+## 📊 数据大小
+
+浏览器数据通常包含：
+- Cookies: ~10 KB
+- LocalStorage: ~50 KB
+- SessionStorage: ~10 KB
+- Cache: ~100-500 KB
+- 其他: ~50-100 KB
+
+**总计**: 约 200-700 KB
+
+上传/下载时间：
+- 上传: ~10-30 秒
+- 下载: ~5-15 秒
+
+---
+
+## 🎯 完整示例
+
+### 场景：首次部署
+
+```bash
+# 1. 创建 Dataset（在网页上操作）
+# 访问：https://huggingface.co/datasets/new
+# 名称：iudd/webai2api-data
+# 类型：Private
+
+# 2. 获取 Token（在网页上操作）
+# 访问：https://huggingface.co/settings/tokens
+# 权限：write
+# 复制 Token
+
+# 3. 配置环境变量（在 Space Settings 中）
+# HF_DATASET_REPO=iudd/webai2api-data
+# HF_TOKEN=hf_abc123...
+
+# 4. Space 自动重启
+
+# 5. 访问 WebUI 并登录
+# URL: https://huggingface.co/spaces/iudd/webai2api
+# 在虚拟显示器中登录
+
+# 6. 保存数据
+npm run save-data
+
+# ✅ 完成！下次启动自动恢复
+```
+
+### 场景：日常使用
+
+```bash
+# 1. 启动 Space
+# 自动恢复数据（无需操作）
+
+# 2. 直接使用 API
+curl https://huggingface.co/spaces/iudd/webai2api/v1/models
+
+# 3. 如果需要更新登录状态
+# 在 WebUI 中重新登录
+npm run save-data
+```
+
+---
+
+## 📞 获取帮助
+
+- **文档**: [PERSISTENCE_SOLUTIONS.md](PERSISTENCE_SOLUTIONS.md)
+- **Issues**: https://github.com/foxhui/WebAI2API/issues
+- **Hugging Face Discord**: https://discord.gg/huggingface
+
+---
+
+**提示**：首次使用建议先在本地测试，确认流程后再部署到 Space。

QUICK_START_WEBDAV.md

@@ -0,0 +1,286 @@
+# WebDAV 数据持久化快速指南
+
+## 🚀 快速开始（2 步完成）
+
+### 步骤 1：配置环境变量
+
+在 Hugging Face Space Settings → **Variables** 中添加以下 3 个环境变量：
+
+```
+WEBDAV_URL=https://rebun.infini-cloud.net/dav
+WEBDAV_USER=iyougame
+WEBDAV_PASS=exzgmqInkoFADbjOx1ak_reGVIf_ptIZxYUtBFp3mLw
+```
+
+保存后，Space 会自动重启。
+
+### 步骤 2：完成
+
+✅ 配置完成！现在可以使用 WebDAV 保存和恢复浏览器数据了。
+
+---
+
+## 📖 使用流程
+
+### 首次使用（登录模式）
+
+1. **启动 Space**（首次，无数据）
+   ```
+   Space 自动启动，检测到无数据
+   ```
+
+2. **访问 WebUI**
+   ```
+   https://huggingface.co/spaces/YOUR_USERNAME/YOUR_SPACE_NAME
+   ```
+
+3. **连接虚拟显示器**
+   - 点击 "🎨 访问 WebUI"
+   - 在 WebUI 中找到 "虚拟显示器" 板块
+   - 点击连接
+
+4. **完成登录**
+   - 在虚拟显示器中登录所需的 AI 网站
+   - 发送测试消息验证
+   - 确保登录状态正常
+
+5. **保存数据到 WebDAV**
+   - 在 Space 的终端中执行：
+     ```bash
+     npm run save-data-webdav
+     ```
+   - 等待上传完成（约 10-30 秒）
+   - 看到 "✅ 数据保存成功" 即可
+
+### 后续使用（自动恢复）
+
+1. **启动 Space**
+   ```
+   Space 自动启动
+   检测到 WebDAV 环境变量
+   自动从 WebDAV 恢复数据
+   ```
+
+2. **直接使用**
+   - 浏览器已恢复登录状态
+   - 无需重新登录
+   - 直接调用 API
+
+---
+
+## 🛠️ 常用命令
+
+### 保存数据到 WebDAV
+```bash
+npm run save-data-webdav
+```
+**使用场景**：
+- 首次登录完成后
+- 更新登录状态后
+- 定期备份
+
+### 从 WebDAV 恢复数据
+```bash
+npm run restore-data-webdav
+```
+**使用场景**：
+- 手动恢复数据
+- 数据丢失后恢复
+
+### 清除本地数据
+```bash
+npm run clear-data
+```
+**使用场景**：
+- 清除本地数据
+- 重新登录前
+- 5 秒倒计时，可取消
+
+---
+
+## ⚠️ 注意事项
+
+1. **首次使用必须手动保存**
+   - 自动恢复只在有数据时生效
+   - 首次登录后必须手动执行 `npm run save-data-webdav`
+
+2. **Cookie 过期问题**
+   - 如果 Cookie 过期，需要重新登录
+   - 重新登录后执行 `npm run save-data-webdav`
+
+3. **WebDAV 连接**
+   - 确保 WebDAV 服务器可访问
+   - 检查用户名和密码
+   - 网络问题可能导致上传/下载失败
+
+4. **数据隐私**
+   - WebDAV 服务器由您自己控制
+   - 确保密码安全
+   - 定期更换密码
+
+---
+
+## 🔧 故障排除
+
+### 问题 1：自动恢复失败
+
+**症状**：
+```
+⚠️  数据恢复失败，将使用新的浏览器实例
+```
+
+**解决方案**：
+1. 检查环境变量是否正确
+2. 检查 WebDAV 服务器是否可访问
+3. 检查用户名和密码
+4. 手动执行 `npm run restore-data-webdav`
+
+### 问题 2：保存失败
+
+**症状**：
+```
+❌ 保存失败: ...
+```
+
+**解决方案**：
+1. 检查 WebDAV 服务器连接
+2. 检查用户名和密码
+3. 检查网络连接
+4. 确保已登录
+
+### 问题 3：需要重新登录
+
+**原因**：Cookie 过期
+
+**解决方案**：
+1. 清除数据：`npm run clear-data`
+2. 重新登录
+3. 保存数据：`npm run save-data-webdav`
+
+### 问题 4：连接超时
+
+**原因**：WebDAV 服务器响应慢或网络问题
+
+**解决方案**：
+1. 检查网络连接
+2. 检查 WebDAV 服务器状态
+3. 重试保存/恢复操作
+
+---
+
+## 💡 最佳实践
+
+1. **定期保存**
+   - 每次登录后立即保存
+   - 定期检查数据状态
+
+2. **备份策略**
+   - WebDAV 服务器可以配置备份
+   - 定期导出关键数据
+
+3. **安全建议**
+   - 使用强密码
+   - 定期更换密码
+   - 监控访问日志
+
+4. **成本控制**
+   - WebDAV 完全免费
+   - 无流量限制
+   - 无存储限制（取决于您的 WebDAV 服务）
+
+---
+
+## 📊 数据大小
+
+浏览器数据通常包含：
+- Cookies: ~10 KB
+- LocalStorage: ~50 KB
+- SessionStorage: ~10 KB
+- Cache: ~100-500 KB
+- 其他: ~50-100 KB
+
+**总计**: 约 200-700 KB
+
+上传/下载时间：
+- 上传: ~10-30 秒
+- 下载: ~5-15 秒
+
+---
+
+## 🎯 完整示例
+
+### 场景：首次部署
+
+```bash
+# 1. 配置环境变量（在 Space Settings 中）
+# WEBDAV_URL=https://rebun.infini-cloud.net/dav
+# WEBDAV_USER=iyougame
+# WEBDAV_PASS=exzgmqInkoFADbjOx1ak_reGVIf_ptIZxYUtBFp3mLw
+
+# 2. Space 自动重启
+
+# 3. 访问 WebUI 并登录
+# URL: https://huggingface.co/spaces/iudd/webai2api
+# 在虚拟显示器中登录
+
+# 4. 保存数据到 WebDAV
+npm run save-data-webdav
+
+# ✅ 完成！下次启动自动恢复
+```
+
+### 场景：日常使用
+
+```bash
+# 1. 启动 Space
+# 自动恢复数据（无需操作）
+
+# 2. 直接使用 API
+curl https://huggingface.co/spaces/iudd/webai2api/v1/models
+
+# 3. 如果需要更新登录状态
+# 在 WebUI 中重新登录
+npm run save-data-webdav
+```
+
+---
+
+## 🔐 安全提示
+
+1. **不要公开密码**
+   - 密���保存在 Space Settings 中（私密）
+   - 不要在代码中硬编码密码
+   - 不要在公开仓库中提交密码
+
+2. **定期更换密码**
+   - 建议每月更换一次
+   - 更换后更新 Space Settings
+
+3. **监控访问**
+   - 定期检查 WebDAV 访问日志
+   - 发现异常及时更换密码
+
+---
+
+## 📞 获取帮助
+
+- **WebDAV 服务器**: https://rebun.infini-cloud.net
+- **文档**: [PERSISTENCE_SOLUTIONS.md](PERSISTENCE_SOLUTIONS.md)
+- **Issues**: https://github.com/foxhui/WebAI2API/issues
+- **Hugging Face Discord**: https://discord.gg/huggingface
+
+---
+
+## 💰 成本对比
+
+| 方案 | 成本 | 限制 | 推荐度 |
+|------|------|------|--------|
+| **WebDAV** | 免费 | 无 | ✅✅✅✅ |
+| Hugging Face Datasets | 免费 | 有流量限制 | ✅✅✅ |
+| 持久化存储 | $5/月 | 10GB | ✅✅ |
+
+**推荐**：使用 WebDAV，完全免费且无限制！
+
+---
+
+**提示**：首次使用建议先在本地测试，确认流程后再部署到 Space。

README.md

@@ -1,10 +1,496 @@
 ---
-title: Webai2hf
-emoji: 🌖
-colorFrom: gray
-colorTo: blue
+title: WebAI2API
+emoji: 🤖
+colorFrom: blue
+colorTo: indigo
 sdk: docker
 pinned: false
+license: mit
+tags:
+  - web-automation
+  - openai-api
+  - playwright
+  - camoufox
+  - ai-api
+  - lm-arena
+  - gemini
+short_description: 将网页版 AI 服务转换为 OpenAI 兼容 API 的自动化工具
 ---
 
-Check out the configuration reference at https://huggingface.co/docs/hub/spaces-config-reference
+# WebAI2API
+
+简体中文 | [English](README_EN.md)
+
+<p align="center">
+  <img src="https://github.com/user-attachments/assets/296a518e-c42b-4e39-8ff6-9b4381ed4f6e" width="49%" />
+  <img src="https://github.com/user-attachments/assets/bfa30ece-6947-4f18-b2c9-ccc8087b7e89" width="49%" />
+</p>
+<p align="center">
+  <img src="https://github.com/user-attachments/assets/5b15ebd2-7593-4f0e-8561-83d6ba5d88ab" width="49%" />
+  <img src="https://github.com/user-attachments/assets/53deea29-4071-4a07-8a61-211761c5f2f7" width="49%" />
+</p>
+
+## 📑 目录
+
+- [Space 部署说明](#-space-部署说明)
+- [数据持久化配置](#-数据持久化配置)
+- [快速部署](#-快速部署)
+- [快速开始](#-快速开始)
+- [使用方法](#-使用方法)
+- [API 接口](#-api-接口)
+- [设备配置参考](#-设备配置参考)
+
+---
+
+## 📝 项目简介
+
+**WebAI2API** 是一个基于 **Camoufox (Playwright)** 的网页版 AI 服务转通用 API 的工具。通过模拟人类操作与 LMArena、Gemini 等网站交互, 提供兼容 **OpenAI 格式** 的接口服务, 同时支持 **多窗口并发** 与 **多账号管理**(浏览器实例数据隔离)。
+
+### ✨ 主要特性
+
+- 🤖 **拟人交互**: 模拟人类打字与鼠标轨迹, 通过特征伪装规避自动化检测
+- 🔄 **接口兼容**: 提供标准 OpenAI 格式接口, 支持流式响应与心跳保活
+- 🚀 **并发隔离**: 支持多窗口并发执行, 可配置独立代理,实现多账号浏览器实例级数据隔离
+- 🛡️ **稳定防护**: 内置任务队列、负载均衡、故障转移、错误重试等基础功能
+- 🎨 **网页管理**: 提供可视化管理界面, 支持实时日志查看、VNC 连接、适配器管理等
+
+### 📋 支持列表
+
+| 网站名称 | 文本生成 | 图片生成 | 视频生成 |
+| :--- | :---: | :---: | :---: | 
+| [**LMArena**](https://lmarena.ai/) | ✅ | ✅ | 🚫 |
+| [**Gemini Enterprise Business**](https://business.gemini.google/) | ✅ | ✅ | ✅ |
+| [**Nano Banana Free**](https://nanobananafree.ai/) | 🚫 | ✅ | 🚫 |
+| [**zAI**](https://zai.is/) | ✅ | ✅ | 🚫 |
+| [**Google Gemini**](https://gemini.google.com/) | ✅ | ✅💧 | ✅💧 | 
+| [**ZenMux**](https://zenmux.ai/) | ✅ | ❌ | 🚫 | 
+| [**ChatGPT**](https://chatgpt.com/) | ✅ | ✅ | 🚫 | 
+| [**DeepSeek**](https://chat.deepseek.com/) | ✅ | 🚫 | 🚫 | 
+| [**Sora**](https://sora.chatgpt.com/) | 🚫 | 🚫 | ✅💧 | 
+| [**Google Flow**](https://labs.google/fx/zh/tools/flow) | 🚫 | ✅ | ❌ | 
+| [**豆包**](https://www.doubao.com/) | ✅ | ✅ | ❌ | 
+| 待续... | - | - | - | 
+
+> [!NOTE]
+> **获取完整模型列表**: 通过 `GET /v1/models` 接口查看当前配置下所有可用模型及其详细信息。
+> 
+> ✅目前支持；❌目前不支持，但未来可能会支持；🚫网站不支持, 未来是否在支持看网站具体情况；💧结果带水印且无法去除；
+
+---
+
+## 🚀 Space 部署说明
+
+### ⚠️ 重要提示
+
+**Hugging Face Space 免费版（CPU tiny）资源严重不足，不推荐使用！**
+
+**推荐硬件配置：**
+
+| 硬件类型 | CPU | 内存 | 价格 | 推荐度 |
+|---------|-----|------|------|--------|
+| CPU Basic | 2 vCPU | 16 GB | $0.10/小时 | ✅ 推荐 |
+| CPU Upgrade | 4 vCPU | 32 GB | $0.30/小时 | ✅✅ 最佳 |
+| CPU XL | 8 vCPU | 64 GB | $0.80/小时 | ✅✅✅ 极佳 |
+
+**为什么需要这么多资源？**
+
+- 浏览器启动需要约 1-2 GB 内存
+- 每个浏览器实例需要额外 500 MB - 1 GB
+- 虚拟显示器（Xvfb）需要约 100 MB
+- VNC 服务需要约 50 MB
+
+**免费版限制：**
+- CPU: 2 vCPU（共享）
+- 内存: 16 GB（共享，实际可用更少）
+- 经常因资源不足导致服务被暂停
+
+---
+
+## 💾 数据持久化配置
+
+**Hugging Face Space 的存储不是持久化的，每次重启后数据会丢失。**
+
+### 方案：使用 WebDAV（免费，推荐）
+
+**优势：**
+- ✅ 完全免费
+- ✅ 无流量限制
+- ✅ 无存储限制
+- ✅ 自动恢复
+
+#### 配置步骤（2 步）
+
+1. **在 Space Settings 中添加环境变量**：
+
+```
+WEBDAV_URL=https://rebun.infini-cloud.net/dav
+WEBDAV_USER=iyougame
+WEBDAV_PASS=exzgmqInkoFADbjOx1ak_reGVIf_ptIZxYUtBFp3mLw
+```
+
+2. **保存并等待 Space 重启**
+
+✅ 配置完成！
+
+#### 使用流程
+
+**首次使用：**
+1. 启动 Space（无数据）
+2. 访问 WebUI 并登录
+3. 保存数据：`npm run save-data-webdav`
+
+**后续使用：**
+1. 启动 Space
+2. 自动从 WebDAV 恢复数据
+3. 直接使用，无需重新登录
+
+#### 常用命令
+
+```bash
+# 保存数据到 WebDAV
+npm run save-data-webdav
+
+# 从 WebDAV 恢复数据
+npm run restore-data-webdav
+
+# 清除本地数据
+npm run clear-data
+```
+
+**详细文档**: [QUICK_START_WEBDAV.md](QUICK_START_WEBDAV.md)
+
+---
+
+## 🛠️ 部署步骤
+
+### 1. 创建 Space
+
+1. 访问 https://huggingface.co/spaces
+2. 点击 "Create new Space"
+3. 配置：
+   - **Owner**: 选择您的账号
+   - **Space name**: 输入名称（如 `webai2api`）
+   - **SDK**: 选择 **Docker**
+   - **Hardware**: 推荐 **CPU Basic**（$0.10/小时）或更高
+   - **Visibility**: Public 或 Private
+
+### 2. 配置环境变量
+
+**数据持久化（必需）：**
+```
+WEBDAV_URL=https://rebun.infini-cloud.net/dav
+WEBDAV_USER=iyougame
+WEBDAV_PASS=exzgmqInkoFADbjOx1ak_reGVIf_ptIZxYUtBFp3mLw
+```
+
+**可选配置：**
+- `AUTH_TOKEN`: API 鉴权密钥（建议使用强密码）
+
+### 3. 推送代码
+
+```bash
+# 克隆 Space
+git clone https://huggingface.co/spaces/YOUR_USERNAME/YOUR_SPACE_NAME
+cd YOUR_SPACE_NAME
+
+# 添加远程仓库
+git remote add origin https://huggingface.co/spaces/YOUR_USERNAME/YOUR_SPACE_NAME
+
+# 推送 webai2hf 分支
+git push origin webai2hf:main
+```
+
+### 4. 等待构建
+
+- 首次构建需要 5-10 分钟
+- 构建完成后服务自动启动
+- 浏览器初始化需要 30-60 秒
+
+### 5. 访问服务
+
+- 主页：`https://huggingface.co/spaces/YOUR_USERNAME/YOUR_SPACE_NAME`
+- WebUI：点击页面上的 "🎨 访问 WebUI"
+- API：`https://huggingface.co/spaces/YOUR_USERNAME/YOUR_SPACE_NAME/v1/models`
+
+---
+
+## ⚠️ Space 限制说明
+
+- **资源限制**: 免费版 Space 有 CPU 和内存限制，**强烈建议使用付费版**
+- **构建时间**: 首次构建需要下载浏览器，时间较长（5-10 分钟）
+- **启动时间**: 浏览器初始化需要 30-60 秒
+- **持久化存储**: Space 重启后数据会丢失（使用 WebDAV 解决）
+
+---
+
+## 🚀 快速部署
+
+本项目支持 **源码直接运行** 和 **Docker 容器化部署** 两种方式。
+
+### 📋 环境要求
+
+- **Node.js**: v20.0.0+ (ABI 115+)
+- **操作系统**: Windows / Linux / macOS
+- **核心依赖**: Camoufox (安装过程中自动获取)
+
+### 🛠️ 方式一:手动部署
+
+1. **安装与配置**
+   ```bash
+   # 1. 安装 NPM 依赖
+   pnpm install
+   # 2. 安装浏览器等预编译依赖
+   # ⚠️ 该脚本需连接 GitHub 下载资源。若网络受限，请使用代理
+   npm run init 
+   # 使用代理
+   # 直接使用 -proxy 可交互式输入代理配置
+   npm run init -- -proxy=http://username:passwd@host:port
+   ```
+
+2. **启动服务**
+   ```bash
+   # 标准启动
+   npm start
+
+   # Linux 系统 - 虚拟显示启动
+   npm start -- -xvfb -vnc
+
+   # 登录模式 (会临时强行禁用无头模式和自动化)
+   npm start -- -login (-xvfb -vnc)
+   ```
+
+### 🐳 方式二:Docker 部署
+
+> [!WARNING]
+> **安全提醒**: 
+> - Docker 镜像默认开启虚拟显示器 (Xvfb) 和 VNC 服务
+> - 可通过 WebUI 的虚拟显示器板块连接
+> - **WebUI 传输过程未加密, 公网环境请使用 SSH 隧道或 HTTPS**
+
+**Docker CLI 启动**
+```bash
+docker run -d --name webai-2api \
+  -p 3000:3000 \
+  -v "$(pwd)/data:/app/data" \
+  --shm-size=2gb \
+  foxhui/webai-2api:latest
+```
+
+**Docker Compose 启动**
+```bash
+docker-compose up -d
+```
+
+---
+
+## ⚡ 快速开始
+
+### 1. 调整配置文件
+
+程序初次运行会从`config.example.yaml`复制配置文件到`data/config.yaml`
+
+**配置文件的生效需要重启程序！**
+
+```yaml
+server:
+  # 监听端口
+  port: 3000
+  # 鉴权 API Token (可使用 npm run genkey 生成)
+  # 该配置会对 API 接口和 WebUI 生效
+  auth: sk-change-me-to-your-secure-key
+```
+
+> [!TIP]
+> **完整配置说明**: 请参考 [config.example.yaml](config.example.yaml) 文件中的详细注释,或访问 [WebAI2API 文档中心](https://foxhui.github.io/WebAI2API/) 查看完整配置指南。
+
+### 2. 访问 Web 管理界面
+
+服务启动后, 打开浏览器访问:
+```
+http://localhost:3000
+```
+
+> [!TIP]
+> **远程访问**: 将 `localhost` 替换为服务器 IP 地址即可远程访问。
+> **API Token**: 配置文件中的`auth`所配置的鉴权密钥。
+> **安全建议**: 公网环境建议使用 Nginx/Caddy 配置 HTTPS 或通过 SSH 隧道访问。
+
+### 3. 初始化账号登录
+
+> [!IMPORTANT]
+> **首次使用必须完成以下初始化步骤**:
+
+1. **连接虚拟显示器**:
+   - Linux/Docker: 在 WebUI 的"虚拟显示器"板块连接
+   - Windows: 直接在弹出的浏览器窗口中操作
+
+2. **完成账号登录**:
+   - 手动登录所需的 AI 网站账号 (账号要求可进入 WebUI 的适配器管理中查看)
+   - 在输入框发送任意消息, 触发并完成人机验证 (如需要)
+   - 同意服务条款或者新手指引 (如需要)
+   - 确保不再有初次使用相关内容的阻拦
+
+3. **保存数据到 WebDAV**:
+   - 在 Space 的终端中执行：`npm run save-data-webdav`
+   - 等待上传完��
+
+4. **SSH 隧道连接示例**(公网服务器推荐):
+   ```bash
+   # 在本地终端运行,将服务器的 WebUI 映射到本地
+   ssh -L 3000:127.0.0.1:3000 root@服务器IP
+   
+   # 然后在本地访问
+   # WebUI: http://localhost:3000
+   ```
+
+---
+
+## 📖 使用方法
+
+### 运行模式说明
+
+> [!NOTE]
+> **关于有头/无头模式**:
+> - **有头模式**(默认): 显示浏览器窗口, 便于调试和人工干预
+> - **无头模式**: 后台运行, 节省资源但无法查看浏览器界面, 且可能会被网站检测
+> 
+> **建议**: 为降低风控, **强烈建议长期保持非无头模式运行**(或使用虚拟显示器 Xvfb)。
+
+---
+
+## 🔌 API 接口
+
+> [!TIP]
+> **详细文档**: 请访问 [WebAI2API 文档中心](https://foxhui.github.io/WebAI2API/) 获取更全面的配置指南与接口说明。
+
+### 1. OpenAI 兼容接口
+
+> [!WARNING]
+> **并发限制与流式保活建议**
+> 
+> 本项目通过模拟真实浏览器操作实现, 处理过程根据实际情况时间可能有所变化, 当积压的任务超过设置的数量时会直接拒绝非流式模式的请求。
+> 
+> **💡 强烈建议开启流式模式**: 服务器将发送保活心跳包, 可无限排队避免超时。
+
+#### 文本对话
+
+**端点**: `POST /v1/chat/completions`
+
+**请求示例**:
+```bash
+curl http://localhost:3000/v1/chat/completions \
+  -H "Content-Type: application/json" \
+  -H "Authorization: Bearer YOUR_API_KEY" \
+  -d '{
+    "model": "gemini-3-pro",
+    "messages": [
+      {"role": "user", "content": "你好,请介绍一下你自己"}
+    ],
+    "stream": true
+  }'
+```
+
+#### 多模态请求(文生图/图生图)
+
+**支持的图片格式**:
+- **格式**: PNG, JPEG, GIF, WebP
+- **数量**: 最大 10 张(具体限制因网站而异)
+- **数据格式**: 必须使用 Base64 Data URL 格式
+- **自动转换**: 服务器会自动将所有图片转换为 JPG 格式以保证兼容性
+
+#### 参数说明
+
+| 参数 | 类型 | 必填 | 说明 |
+| :--- | :--- | :---: | :--- |
+| `model` | string | ✅ | 模型名称, 可通过 `/v1/models` 获取可用列表 |
+| `stream` | boolean | 推荐 | 是否开启流式响应, 包含心跳保活机制 |
+
+> [!NOTE]
+> **关于流式保活 (Heartbeat)**
+>
+> 为防止长连接超时, 系统提供两种保活模式 (可在配置中切换):
+> 1. **Comment 模式 (默认/推荐)**: 发送 `:keepalive` 注释, 符合 SSE 标准,兼容性最好
+> 2. **Content 模式**: 发送空内容的 data 包, 仅用于必须收到 JSON 数据才重置超时的特殊客户端
+
+### 2. 获取模型列表
+
+**端点**: `GET /v1/models`
+
+**请求示例**:
+```bash
+curl http://localhost:3000/v1/models \
+  -H "Authorization: Bearer YOUR_API_KEY"
+```
+
+### 3. 获取 Cookies
+
+**功能说明**: 利用本项目的自动续登功能获取最新 Cookie 供其他工具使用。
+
+**端点**: `GET /v1/cookies`
+
+**参数**:
+- `name` (可选): 浏览器实例名称,默认为 `default`
+- `domain` (可选): 过滤指定域名的 Cookie
+
+**请求示例**:
+```bash
+# 获取指定实例和域名的 Cookie
+curl "http://localhost:3000/v1/cookies?name=browser_default&domain=lmarena.ai" \
+  -H "Authorization: Bearer YOUR_API_KEY"
+```
+
+---
+
+## 📊 设备配置参考
+
+| 资源 | 最低配置 | 推荐配置 (单实例) | 推荐配置 (多实例) |
+| :--- | :--- | :--- | :--- |
+| **CPU** | 1 核 | 2 核及以上 | 2 核及以上 |
+| **内存** | 1 GB | 2 GB 及以上 | 4 GB 及以上 |
+| **磁盘** | 2 GB 可用空间 | 5 GB 及以上 | 7 GB 及以上 |
+
+**实测环境表现** (均为单浏览器实例):
+- **Oracle 免费机** (1C1G, Debian 12): 资源紧张, 比较卡顿, 仅供尝鲜或轻度使用
+- **阿里云轻量云** (2C2G, Debian 11): 运行流畅但实例也会卡顿, 项目开发测试所用机型
+
+---
+
+## 📄 许可证和免责声明
+
+本项目采用 [MIT License](LICENSE) 开源。
+
+> [!CAUTION]
+> **免责声明**
+> 
+> 本项目仅供学习交流使用。如果因使用该项目造成的任何后果 (包括但不限于账号被禁用),作者和项目均不承担任何责任。请遵守相关网站和服务的使用条款 (ToS),并做好相关数据的备份工作。
+
+---
+
+## 📋 更新日志
+
+查看完整的版本历史和更新内容, 请访问 [CHANGELOG.md](CHANGELOG.md)。
+
+### 🕰️ 历史版本说明
+
+本项目已从 Puppeteer 迁移至 Camoufox, 以应对日益复杂的反机器人检测机制。基于 Puppeteer 的旧版本代码已归档至 `puppeteer-edition` 分支, 仅作留存, **不再提供更新与维护**。
+
+---
+
+## 🙏 致谢
+
+感谢 LMArena、Gemini 等网站提供 AI 服务! 🎉
+
+感谢 Hugging Face 提供免费的 Space 托管服务! 🙌
+
+感谢 Infini Cloud 提供免费的 WebDAV 存储! ☁️
+
+---
+
+## 📞 联系方式
+
+- **作者**: foxhui
+- **GitHub**: [https://github.com/foxhui](https://github.com/foxhui)
+- **文档**: [WebAI2API 文档中心](https://foxhui.github.io/WebAI2API/)
+- **Issues**: [提交问题](https://github.com/foxhui/WebAI2API/issues)
+- **Hugging Face Space 部署指南**: [查看详细文档](HUGGINGFACE_SPACE.md)
+- **WebDAV 数据持久化指南**: [查看详细文档](QUICK_START_WEBDAV.md)

README_EN.md

@@ -0,0 +1,398 @@
+---
+title: WebAI2API
+emoji: 🤖
+colorFrom: blue
+colorTo: indigo
+sdk: docker
+pinned: false
+license: mit
+tags:
+  - web-automation
+  - openai-api
+  - playwright
+  - camoufox
+  - ai-api
+  - lm-arena
+  - gemini
+short_description: Automated tool to convert web-based AI services to OpenAI-compatible APIs
+---
+
+# WebAI2API
+
+[简体中文](README.md) | English
+
+> [!NOTE]
+> This English version is translated by **Gemini 3 Flash**.
+
+<p align="center">
+  <img src="https://github.com/user-attachments/assets/296a518e-c42b-4e39-8ff6-9b4381ed4f6e" width="49%" />
+  <img src="https://github.com/user-attachments/assets/bfa30ece-6947-4f18-b2c9-ccc8087b7e89" width="49%" />
+</p>
+<p align="center">
+  <img src="https://github.com/user-attachments/assets/5b15ebd2-7593-4f0e-8561-83d6ba5d88ab" width="49%" />
+  <img src="https://github.com/user-attachments/assets/53deea29-4071-4a07-8a61-211761c5f2f7" width="49%" />
+</p>
+
+## 📑 Table of Contents
+
+- [Space Deployment Guide](#-space-deployment-guide)
+- [Quick Deployment](#-quick-deployment)
+- [Quick Start](#-quick-start)
+- [Usage](#-usage)
+- [API Reference](#-api-reference)
+- [Hardware Configuration Reference](#-hardware-configuration-reference)
+
+---
+
+## 📝 Project Introduction
+
+**WebAI2API** is a tool that converts web-based AI services into general APIs based on **Camoufox (Playwright)**. It interacts with websites like LMArena and Gemini by simulating human operations, providing interfaces compatible with the **OpenAI format**, while supporting **multi-window concurrency** and **multi-account management** (browser instance data isolation).
+
+### ✨ Key Features
+
+- 🤖 **Human-like Interaction**: Simulates human typing and mouse trajectories, evading automation detection through feature camouflage.
+- 🔄 **API Compatibility**: Provides standard OpenAI format interfaces, supporting streaming responses and heartbeat persistence.
+- 🚀 **Concurrency & Isolation**: Supports multi-window concurrent execution with independent proxy configurations, achieving browser-level data isolation for multiple accounts.
+- 🛡️ **Stable Protection**: Built-in task queue, load balancing, failover, error retry, and other essential functions.
+- 🎨 **Web Management**: Provides a visual management interface supporting real-time log viewing, VNC connection, adapter management, etc.
+
+### 📋 Supported Platforms
+
+| Website | Text Gen | Image Gen | Video Gen |
+| :--- | :---: | :---: | :---: | 
+| [**LMArena**](https://lmarena.ai/) | ✅ | ✅ | 🚫 |
+| [**Gemini Enterprise Business**](https://business.gemini.google/) | ✅ | ✅ | ✅ |
+| [**Nano Banana Free**](https://nanobananafree.ai/) | 🚫 | ✅ | 🚫 |
+| [**zAI**](https://zai.is/) | ✅ | ✅ | 🚫 |
+| [**Google Gemini**](https://gemini.google.com/) | ✅ | ✅💧 | ✅💧 | 
+| [**ZenMux**](https://zenmux.ai/) | ✅ | ❌ | 🚫 | 
+| [**ChatGPT**](https://chatgpt.com/) | ✅ | ✅ | 🚫 | 
+| [**DeepSeek**](https://chat.deepseek.com/) | ✅ | 🚫 | 🚫 | 
+| [**Sora**](https://sora.chatgpt.com/) | 🚫 | 🚫 | ✅💧 | 
+| [**Google Flow**](https://labs.google/fx/zh/tools/flow) | 🚫 | ✅ | ❌ | 
+| [**Doubao**](https://www.doubao.com/) | ✅ | ✅ | ❌ | 
+| To be continued... | - | - | - | 
+
+> [!NOTE]
+> **Get full model list**: Use the `GET /v1/models` endpoint to view all available models and their details under the current configuration.
+> 
+> ✅ Supported; ❌ Not currently supported, but may be in the future; 🚫 Website does not support, future support depends on the website's status; 💧 Results contain watermarks that cannot be removed.
+
+---
+
+## 🚀 Space Deployment Guide
+
+### 📋 Prerequisites
+
+- Hugging Face account
+- Created Space (Docker SDK)
+- Space type set to **Docker**
+
+### 🛠️ Deployment Steps
+
+1. **Clone or Upload Code to Space**
+   ```bash
+   git clone https://huggingface.co/spaces/YOUR_USERNAME/YOUR_SPACE_NAME
+   cd YOUR_SPACE_NAME
+   git remote add origin https://huggingface.co/spaces/YOUR_USERNAME/YOUR_SPACE_NAME
+   git push origin main
+   ```
+
+2. **Configure Space Settings**
+   - Ensure **SDK** is set to **Docker** in Space settings
+   - Ensure public/private settings meet your requirements
+
+3. **Configure Environment Variables** (Optional)
+   Add the following environment variables in Space settings (if customization is needed):
+   - `PORT`: Service port (default 3000)
+   - `AUTH_TOKEN`: API authentication key (recommended to use a strong password)
+
+4. **Wait for Build to Complete**
+   - Space will automatically build the Docker image
+   - Build time is approximately 5-10 minutes
+   - Service starts automatically after build completion
+
+5. **Access Service**
+   - Space URL: `https://huggingface.co/spaces/YOUR_USERNAME/YOUR_SPACE_NAME`
+   - WebUI: Access Space URL directly
+   - API: `https://huggingface.co/spaces/YOUR_USERNAME/YOUR_SPACE_NAME/v1/...`
+
+### ⚠️ Space Limitations
+
+- **Resource Limits**: Free tier Spaces have CPU and memory limitations
+- **Build Time**: First build requires downloading browser, takes longer
+- **Persistent Storage**: Data is lost after Space restart (recommend using Secrets for configuration)
+- **Network Access**: Spaces can access external websites but may have rate limits
+
+### 💡 Usage Recommendations
+
+1. **First Use**: Access WebUI to complete account login initialization
+2. **Authentication**: Set `AUTH_TOKEN` environment variable in Space Settings
+3. **Monitor Logs**: Check running status via Space's Logs page
+4. **Performance**: Upgrade Space to paid tier for better performance if needed
+
+---
+
+## 🚀 Quick Deployment
+
+This project supports both **source code execution** and **Docker containerized deployment**.
+
+### 📋 Environment Requirements
+
+- **Node.js**: v20.0.0+ (ABI 115+)
+- **OS**: Windows / Linux / macOS
+- **Core Dependency**: Camoufox (automatically downloaded during installation)
+
+### 🛠️ Method 1: Manual Deployment
+
+1. **Installation & Configuration**
+   ```bash
+   # 1. Install NPM dependencies
+   pnpm install
+   # 2. Install precompiled dependencies like the browser
+   # ⚠️ This script requires connecting to GitHub to download resources. Use a proxy if network access is limited.
+   npm run init 
+   # Using a proxy
+   # Use -proxy to interactively input proxy configuration
+   npm run init -- -proxy=http://username:passwd@host:port
+   ```
+
+2. **Start Service**
+   ```bash
+   # Standard start
+   npm start
+
+   # Linux - Start with virtual display
+   npm start -- -xvfb -vnc
+
+   # Login mode (Temporarily forces disabling headless mode and automation)
+   npm start -- -login (-xvfb -vnc)
+   ```
+
+### 🐳 Method 2: Docker Deployment
+
+> [!WARNING]
+> **Security Reminder**: 
+> - The Docker image enables the virtual display (Xvfb) and VNC service by default.
+> - Connection is possible via the virtual display section of the WebUI.
+> - **WebUI transmission is unencrypted. Please use SSH tunneling or HTTPS in public network environments.**
+
+**Start with Docker CLI**
+```bash
+docker run -d --name webai-2api \
+  -p 3000:3000 \
+  -v "$(pwd)/data:/app/data" \
+  --shm-size=2gb \
+  foxhui/webai-2api:latest
+```
+
+**Start with Docker Compose**
+```bash
+docker-compose up -d
+```
+
+---
+
+## ⚡ Quick Start
+
+### 1. Adjust Configuration File
+
+On first run, the program will copy the configuration file from `config.example.yaml` to `data/config.yaml`.
+
+**Changes to the configuration file require a program restart to take effect!**
+
+```yaml
+server:
+  # Listening port
+  port: 3000
+  # Authentication API Token (can be generated using npm run genkey)
+  # This configuration applies to both API endpoints and the WebUI
+  auth: sk-change-me-to-your-secure-key
+```
+
+> [!TIP]
+> **Full Configuration Details**: Please refer to the detailed comments in [config.example.yaml](config.example.yaml), or visit the [WebAI2API Documentation Center](https://foxhui.github.io/WebAI2API/en/) for a complete configuration guide.
+
+### 2. Access Web Management Interface
+
+After the service starts, open your browser and visit:
+```
+http://localhost:3000
+```
+
+> [!TIP]
+> **Remote Access**: Replace `localhost` with your server's IP address.
+> **API Token**: The authentication key configured in `auth` of the configuration file.
+> **Security Suggestion**: For public network environments, it is recommended to configure HTTPS using Nginx/Caddy or access via SSH tunnel.
+
+### 3. Initial Account Login
+
+> [!IMPORTANT]
+> **The following initialization steps must be completed on first use**:
+
+1. **Connect to Virtual Display**:
+   - Linux/Docker: Connect in the "Virtual Display" section of the WebUI.
+   - Windows: Operate directly in the browser window that pops up.
+
+2. **Complete Account Login**:
+   - Manually log in to the required AI website account (account requirements can be found in the WebUI's adapter management).
+   - Send any message in the input box to trigger and complete human-machine verification (if required).
+   - Agree to terms of service or新手 guides (if required).
+   - Ensure there are no more initial use related obstructions.
+
+3. **SSH Tunnel Connection Example** (Recommended for public servers):
+   ```bash
+   # Run in your local terminal to map the server's WebUI to local
+   ssh -L 3000:127.0.0.1:3000 root@Server_IP
+   
+   # Then access locally
+   # WebUI: http://localhost:3000
+   ```
+
+---
+
+## 📖 Usage
+
+### Running Mode Description
+
+> [!NOTE]
+> **Regarding Headful/Headless Mode**:
+> - **Headful Mode** (Default): Displays the browser window, convenient for debugging and manual intervention.
+> - **Headless Mode**: Runs in the background, saves resources but interfaces cannot be viewed, and may be detected by websites.
+> 
+> **Recommendation**: To reduce risk, **it is strongly recommended to run in non-headless mode for the long term** (or use virtual display Xvfb).
+
+---
+
+## 🔌 API Reference
+
+> [!TIP]
+> **Detailed Documentation**: Please visit the [WebAI2API Documentation Center](https://foxhui.github.io/WebAI2API/en/) for a more comprehensive configuration guide and interface description.
+
+### 1. OpenAI Compatible API
+
+> [!WARNING]
+> **Concurrency Limits and Streaming Keep-alive Recommendations**
+> 
+> This project is implemented by simulating real browser operations, and processing time may vary. When the backlog of tasks exceeds the configured amount, non-streaming requests will be rejected directly.
+> 
+> **💡 Highly Recommended to enable Streaming Mode**: The server will send keep-alive heartbeat packets, allowing for infinite queuing to avoid timeouts.
+
+#### Text Chat
+
+**Endpoint**: `POST /v1/chat/completions`
+
+**Request Example**:
+```bash
+curl http://localhost:3000/v1/chat/completions \
+  -H "Content-Type: application/json" \
+  -H "Authorization: Bearer YOUR_API_KEY" \
+  -d '{
+    "model": "gemini-3-pro",
+    "messages": [
+      {"role": "user", "content": "Hello, please introduce yourself"}
+    ],
+    "stream": true
+  }'
+```
+
+#### Multimodal Requests (Text-to-Image / Image-to-Image)
+
+**Supported Image Formats**:
+- **Formats**: PNG, JPEG, GIF, WebP
+- **Quantity**: Max 10 images (specific limits vary by website)
+- **Data Format**: Must use Base64 Data URL format
+- **Auto Conversion**: The server automatically converts all images to JPG to ensure compatibility.
+
+#### Parameter Description
+
+| Parameter | Type | Required | Description |
+| :--- | :--- | :---: | :--- |
+| `model` | string | ✅ | Model name, available list can be retrieved via `/v1/models` |
+| `stream` | boolean | Rec. | Whether to enable streaming response, includes heartbeat keep-alive mechanism |
+
+> [!NOTE]
+> **Regarding Streaming Keep-alive (Heartbeat)**
+>
+> To prevent long connection timeouts, the system provides two keep-alive modes (configurable):
+> 1. **Comment Mode (Default/Recommended)**: Sends `:keepalive` comments, compliant with SSE standards, best compatibility.
+> 2. **Content Mode**: Sends data packets with empty content, only for special clients that must receive JSON data to reset timeouts.
+
+### 2. Get Model List
+
+**Endpoint**: `GET /v1/models`
+
+**Request Example**:
+```bash
+curl http://localhost:3000/v1/models \
+  -H "Authorization: Bearer YOUR_API_KEY"
+```
+
+### 3. Get Cookies
+
+**Description**: Utilize the project's automatic renewal feature to get the latest Cookies for use with other tools.
+
+**Endpoint**: `GET /v1/cookies`
+
+**Parameters**:
+- `name` (Optional): Browser instance name, defaults to `default`.
+- `domain` (Optional): Filter Cookies for a specific domain.
+
+**Request Example**:
+```bash
+# Get cookies for a specific instance and domain
+curl "http://localhost:3000/v1/cookies?name=browser_default&domain=lmarena.ai" \
+  -H "Authorization: Bearer YOUR_API_KEY"
+```
+
+---
+
+## 📊 Hardware Configuration Reference
+
+| Resource | Minimum | Recommended (Single Instance) | Recommended (Multi-Instance) |
+| :--- | :--- | :--- | :--- |
+| **CPU** | 1 Core | 2 Cores+ | 2 Cores+ |
+| **RAM** | 1 GB | 2 GB+ | 4 GB+ |
+| **Disk** | 2 GB available | 5 GB+ | 7 GB+ |
+
+**Measured Environment Performance** (All with single browser instance):
+- **Oracle Free Tier** (1C1G, Debian 12): Resource-intensive, quite laggy, only for trial or light use.
+- **Aliyun Lightweight Cloud** (2C2G, Debian 11): Runs smoothly but instances may still lag; used for project development and testing.
+
+---
+
+## 📄 License and Disclaimer
+
+This project is open-sourced under the [MIT License](LICENSE).
+
+> [!CAUTION]
+> **Disclaimer**
+> 
+> This project is for educational and exchange purposes only. The author and the project are not responsible for any consequences (including but not limited to account suspension) caused by using this project. Please comply with the Terms of Service (ToS) of the relevant websites and services, and ensure proper backup of relevant data.
+
+---
+
+## 📋 Changelog
+
+View the full version history and update details at [CHANGELOG.md](CHANGELOG.md).
+
+### 🕰️ Historical Version Note
+
+This project has migrated from Puppeteer to Camoufox to handle increasingly complex anti-bot detection mechanisms. Older code based on Puppeteer has been archived to the `puppeteer-edition` branch for reference only and is **no longer updated or maintained**.
+
+---
+
+## 🙏 Acknowledgments
+
+Thanks to sites like LMArena and Gemini for providing AI services! 🎉
+
+Thanks to Hugging Face for providing free Space hosting! 🙌
+
+---
+
+## 📞 Contact
+
+- **Author**: foxhui
+- **GitHub**: [https://github.com/foxhui](https://github.com/foxhui)
+- **Documentation**: [WebAI2API Documentation Center](https://foxhui.github.io/WebAI2API/en/)
+- **Issues**: [Submit Issue](https://github.com/foxhui/WebAI2API/issues)

config.example.yaml

@@ -0,0 +1,172 @@
+# 日志等级: debug | info | warn | error
+logLevel: info
+
+server:
+  # 监听端口
+  port: 3000
+  # 鉴权 API Token (可使用 npm run genkey 生成)
+  # 该配置会对 API 接口和 WebUI 生效
+  auth: sk-change-me-to-your-secure-key
+  # 流式请求心跳设置 (自动对 stream: true 的请求发送心跳防止超时)
+  keepalive:
+    # 心跳模式
+    # "comment": (推荐) 发送 :keepalive 注释，不污染数据
+    # "content": (备用) 发送空 delta，仅当客户端必须收到 JSON 包才重置超时时使用
+    mode: "comment"
+
+backend:
+  # ========================================
+  # Pool 配置
+  # ========================================
+  pool:
+    # 全局调度策略:
+    # - least_busy (推荐): 优先分配给当前任务最少的 Worker
+    # - round_robin: 轮询分配 (A -> B -> C -> A)
+    # - random: 随机分配
+    # 任务分发时，会把所有 Instance 下的所有 Worker 扁平化看待
+    strategy: least_busy
+
+    # ========================================
+    # 故障转移配置
+    # ========================================
+    # 当适配器返回网络错误时，自动尝试其他支持相同模型的 Worker
+    failover:
+      enabled: true          # 启用故障转移
+      maxRetries: 2          # 最多重试次数 (0=无限制)
+
+    # ========================================
+    # 浏览器实例列表
+    # ========================================
+    # 每个 Instance 代表一个独立的浏览器进程 (Context + UserData + Proxy)
+    # 登录模式:
+    #   npm start -- -login              启动第一个 Worker 进行登录
+    #   npm start -- -login=workerName   启动指定名称的 Worker 进行登录
+    # 注意: Worker 名称在全局必须唯一
+    # ========================================
+    instances:
+      # ------------------------------------------------
+      # [实例 1] 默认浏览器实例
+      # ------------------------------------------------
+      - name: "browser_default"        # 实例 ID (用于日志显示和Cookie获取)
+        # userDataMark 不设置时，数据存放在 data/camoufoxUserData
+        # 同一实例下的所有 Worker 共享浏览器数据和登录状态
+        # 使用 Google OAuth 等统一登录时，只需登录一次即可用于所有 Worker
+        
+        # 该浏览器实例具备的能力 (适配器列表)
+        # 相当于在这个浏览器里打开了不同的标签页
+        workers:
+          - name: "default"            # 唯一标识 (用于登录模式和日志显示)
+            # 适配器类型列表:
+            #   lmarena                (LMArena 图片生成)
+            #   lmarena_text           (LMArena 文本生成)
+            #   gemini_biz             (Gemini Business 图片、视频生成)
+            #   gemini_biz_text        (Gemini Business 文本生成)
+            #   gemini                 (Google Gemini 图片、视频生成)
+            #   gemini_text            (Google Gemini 文本生成)
+            #   zai_is                 (zAI 图片生成)
+            #   nanobananafree_ai      (NanoBananaFree 图片生成)
+            #   zenmux_ai_text         (ZenMux 文本生成)
+            #   chatgpt                (ChatGPT 图片生成)
+            type: lmarena              # 适配器类型
+
+      # ------------------------------------------------
+      # 以下为多实例配置示例 (默认注释)
+      # ------------------------------------------------
+      
+      # [实例 2] 独立数据目录 + 专属代理
+      # - name: "browser_us_01"
+      #   userDataMark: "us_01"        # 数据目录: data/camoufoxUserData_us_01
+      #   
+      #   # 实例级代理 (该实例下所有 Worker 共享此代理)
+      #   proxy:
+      #     enable: true
+      #     type: socks5
+      #     host: 192.168.1.10
+      #     port: 1080
+      #     user: myuser               # 可选认证
+      #     passwd: mypassword
+      #
+      #   workers:
+      #     - name: "us_lmarena"
+      #       type: lmarena
+      #     
+      #     - name: "us_zai"
+      #       type: zai_is
+      #     
+      #     # 聚合类型 Worker (单标签多后端)
+      #     - name: "us_merged"
+      #       type: merge
+      #       mergeTypes: [gemini_biz, nanobananafree_ai]
+      #       mergeMonitor: gemini_biz  # 空闲时挂机监控的后端 (可选，留空则不启用)
+
+      # [实例 3] 强制直连 (不使用代理)
+      # - name: "browser_direct"
+      #   userDataMark: "direct"
+      #   proxy:
+      #     enable: false              # 即使有全局代理也不使用
+      #
+      #   workers:
+      #     - name: "direct_gemini"
+      #       type: gemini_biz
+
+  # ========================================
+  # 适配器专属配置 (按需填写)
+  # ========================================
+  adapter:
+    # Gemini Business 设置
+    gemini_biz:
+      # 入口URL
+      # 示例: "https://business.gemini.google/home/cid/8888a888-b6e0-88be-86e1-888cf3ee8cf4"
+      entryUrl: ""
+    # Lmarena 配置
+    lmarena:
+      # 开启后直接返回图片 URL (但其他不支持该选项的适配器仍然会返回 Base64)
+      returnUrl: false
+      # 该适配器的模型黑白名单 (每个适配器都可以使用该功能，配置上级为适配器ID，推荐使用 WebUI 修改)
+      # modelFilter:
+      #  mode: whitelist                        # 白名单whitelist 黑名单blacklist
+      #  list:                                  # 仅启用和仅禁用的模型列表
+      #    - gemini-3-pro-image-preview
+      #    - gemini-3-pro-image-preview-2k
+      #    - gemini-2.5-flash-image-preview
+      
+
+queue:
+  # 队列缓冲区大小（非流式请求的额外排队数）
+  # 实际队列上限 = Workers数量 + queueBuffer
+  # 设为 0 则不限制非流式请求数量
+  queueBuffer: 2
+  # 图片数量上限 
+  # 网页最多支持10个附件，如果设置大于10则直接丢弃超出10的图片
+  imageLimit: 5
+
+browser:
+  # 浏览器可执行文件路径 (留空则使用默认的)
+  # 非必要不建议修改，否则你要处理很多额外依赖
+  # Windows系统示例 "C:\\camoufox\\camoufox.exe"
+  # Linux系统示例 "/opt/camoufox/camoufox"
+  path: ""
+  
+  # 是否启用无头模式
+  headless: false
+
+  # 站点隔离 (fission.autostart)
+  # 开启保持 Firefox 默认开启状态
+  # 关闭此项可显著降低内存占用，防止低配服务器崩溃
+  # ⚠️ 风险提示: 正常 Firefox 用户默认开启 Fission，虽然关闭它不会泄露常规指纹，
+  # 但极高阶的反爬系统可能会通过检测“单进程模型”或“跨进程通信延迟”来识别自动化特征！
+  fission: true
+  
+  # [全局代理] 如果 Instance 没有独立配置代理，将使用此配置
+  proxy:
+    # 是否启用代理
+    enable: false
+    # 代理类型: http 或 socks5
+    type: http
+    # 代理主机
+    host: 127.0.0.1
+    # 代理端口
+    port: 7890
+    # 代理认证 (可选)
+    # user: username
+    # passwd: password

config.hf.yaml

@@ -0,0 +1,54 @@
+# Hugging Face Space 优化配置
+# 针对 CPU 基础版 (2 vCPU, 16 GB) 优化
+
+# 日志等级: debug | info | warn | error
+logLevel: info
+
+server:
+  # 监听端口 (会被 start_hf.sh 覆盖为 7860)
+  port: 7860
+  # 鉴权 API Token (可使用 npm run genkey 生成)
+  # 该配置会对 API 接口和 WebUI 生效
+  auth: sk-change-me-to-your-secure-key
+  # 流式请求心跳设置
+  keepalive:
+    mode: "comment"
+
+backend:
+  pool:
+    # 全局调度策略
+    strategy: least_busy
+
+    # 故障转移配置
+    failover:
+      enabled: true
+      maxRetries: 2
+
+    # 浏览器实例列表
+    instances:
+      # 默认浏览器实例
+      - name: "browser_default"
+        workers:
+          - name: "default"
+            type: lmarena
+
+  adapter:
+    lmarena:
+      returnUrl: false
+
+queue:
+  # 队列缓冲区大小
+  queueBuffer: 2
+  # 图片数量上限
+  imageLimit: 5
+
+browser:
+  # 浏览器可执行文件路径
+  path: ""
+  
+  # 无头模式 (Hugging Face Space 推荐)
+  headless: false
+
+  # 关闭 Fission 降低内存占用
+  # ⚠️ 可能会增加被检测风险，但 HF Space 资源有限
+  fission: false

docker-compose.yaml

@@ -0,0 +1,11 @@
+services:
+  webai-2api:
+    image: foxhui/webai-2api:latest
+    container_name: webai-2api
+    restart: unless-stopped
+    ports:
+      - "3000:3000"  # API + WebUI
+    volumes:
+      - ./data:/app/data  # 数据和配置持久化，config.yaml 会自动生成到此目录
+    shm_size: '2gb'
+    init: true

package.json

@@ -0,0 +1,39 @@
+{
+	"name": "webai-2api",
+	"version": "3.0.0",
+	"description": "基于 Playwright + Camoufox 的自动化图像生成工具",
+	"license": "MIT",
+	"author": "foxhui",
+	"type": "module",
+	"scripts": {
+		"start": "node supervisor.js",
+		"genkey": "node scripts/genkey.js",
+		"init": "node scripts/init.js",
+		"postinstall": "node scripts/postinstall.js",
+		"save-data": "node scripts/save-data.js",
+		"restore-data": "node scripts/restore-data.js",
+		"clear-data": "node scripts/clear-data.js",
+		"save-data-webdav": "node scripts/save-data-webdav.js",
+		"restore-data-webdav": "node scripts/restore-data-webdav.js"
+	},
+	"imports": {
+		"#config": "./src/config/index.js",
+		"#utils/*": "./src/utils/*.js",
+		"#backend/*": "./src/backend/*.js",
+		"#server/*": "./src/server/*.js"
+	},
+	"dependencies": {
+		"@inquirer/prompts": "^8.0.1",
+		"better-sqlite3": "^12.5.0",
+		"camoufox-js": "^0.8.3",
+		"compressing": "^2.0.0",
+		"fingerprint-generator": "^2.1.78",
+		"ghost-cursor-playwright-port": "^1.4.3",
+		"got-scraping": "^4.1.2",
+		"playwright-core": "^1.57.0",
+		"proxy-chain": "^2.6.0",
+		"sharp": "^0.34.5",
+		"webdav": "^5.7.1",
+		"yaml": "^2.8.2"
+	}
+}

patches/camoufox-js@0.8.3.locale.patched.js

@@ -0,0 +1,289 @@
+import * as fs from "node:fs";
+import * as path from "node:path";
+import tags from "language-tags";
+import maxmind from "maxmind";
+import xml2js from "xml2js";
+import { InvalidLocale, MissingRelease, NotInstalledGeoIPExtra, UnknownIPLocation, UnknownLanguage, UnknownTerritory, } from "./exceptions.js";
+import { validateIP } from "./ip.js";
+import { GitHubDownloader, INSTALL_DIR, webdl } from "./pkgman.js";
+import { getAsBooleanFromENV } from "./utils.js";
+import { LeakWarning } from "./warnings.js";
+export const ALLOW_GEOIP = true;
+class Locale {
+    language;
+    region;
+    script;
+    constructor(language, region, script) {
+        this.language = language;
+        this.region = region;
+        this.script = script;
+    }
+    asString() {
+        if (this.region) {
+            return `${this.language}-${this.region}`;
+        }
+        return this.language;
+    }
+    asConfig() {
+        if (!this.region) {
+            throw new Error("Region is required for config");
+        }
+        const data = {
+            "locale:region": this.region,
+            "locale:language": this.language,
+        };
+        if (this.script) {
+            data["locale:script"] = this.script;
+        }
+        return data;
+    }
+}
+class Geolocation {
+    locale;
+    longitude;
+    latitude;
+    timezone;
+    accuracy;
+    constructor(locale, longitude, latitude, timezone, accuracy) {
+        this.locale = locale;
+        this.longitude = longitude;
+        this.latitude = latitude;
+        this.timezone = timezone;
+        this.accuracy = accuracy;
+    }
+    asConfig() {
+        const data = {
+            "geolocation:longitude": this.longitude,
+            "geolocation:latitude": this.latitude,
+            timezone: this.timezone,
+            ...this.locale.asConfig(),
+        };
+        if (this.accuracy !== undefined) {
+            data["geolocation:accuracy"] = this.accuracy;
+        }
+        return data;
+    }
+}
+function verifyLocale(loc) {
+    if (tags.check(loc)) {
+        return;
+    }
+    throw InvalidLocale.invalidInput(loc);
+}
+export function normalizeLocale(locale) {
+    verifyLocale(locale);
+    const parser = tags(locale);
+    if (!parser.region) {
+        throw InvalidLocale.invalidInput(locale);
+    }
+    return new Locale(parser.language()?.format() ?? "en", parser.region()?.format(), parser.language()?.script()?.format());
+}
+export function handleLocale(locale, ignoreRegion = false) {
+    if (locale.length > 3) {
+        return normalizeLocale(locale);
+    }
+    try {
+        return SELECTOR.fromRegion(locale);
+    }
+    catch (e) {
+        if (e instanceof UnknownTerritory) {
+        }
+        else {
+            throw e;
+        }
+    }
+    if (ignoreRegion) {
+        verifyLocale(locale);
+        return new Locale(locale);
+    }
+    try {
+        const language = SELECTOR.fromLanguage(locale);
+        LeakWarning.warn("no_region");
+        return language;
+    }
+    catch (e) {
+        if (e instanceof UnknownLanguage) {
+        }
+        else {
+            throw e;
+        }
+    }
+    throw InvalidLocale.invalidInput(locale);
+}
+export function handleLocales(locales, config) {
+    if (typeof locales === "string") {
+        locales = locales.split(",").map((loc) => loc.trim());
+    }
+    const intlLocale = handleLocale(locales[0]).asConfig();
+    for (const key in intlLocale) {
+        config[key] = intlLocale[key];
+    }
+    if (locales.length < 2) {
+        return;
+    }
+    config["locale:all"] = joinUnique(locales.map((locale) => handleLocale(locale, true).asString()));
+}
+function joinUnique(seq) {
+    const seen = new Set();
+    return seq.filter((x) => !seen.has(x) && seen.add(x)).join(", ");
+}
+// [PATCH] Portable Mode: 优先检查项目根目录下的 camoufox 文件夹
+const localMMDB = path.join(process.cwd(), "camoufox", "GeoLite2-City.mmdb");
+const MMDB_FILE = fs.existsSync(localMMDB)
+    ? localMMDB
+    : path.join(INSTALL_DIR.toString(), "GeoLite2-City.mmdb");
+//const MMDB_FILE = path.join(INSTALL_DIR.toString(), "GeoLite2-City.mmdb");
+
+const MMDB_REPO = "P3TERX/GeoLite.mmdb";
+class MaxMindDownloader extends GitHubDownloader {
+    checkAsset(asset) {
+        if (asset.name.endsWith("-City.mmdb")) {
+            return asset.browser_download_url;
+        }
+        return null;
+    }
+    missingAssetError() {
+        throw new MissingRelease("Failed to find GeoIP database release asset");
+    }
+}
+export function geoipAllowed() {
+    if (!ALLOW_GEOIP) {
+        throw new NotInstalledGeoIPExtra("Please install the geoip extra to use this feature: pip install camoufox[geoip]");
+    }
+}
+export async function downloadMMDB() {
+    geoipAllowed();
+    if (getAsBooleanFromENV("PLAYWRIGHT_SKIP_BROWSER_DOWNLOAD", false)) {
+        console.log("Skipping GeoIP database download due to PLAYWRIGHT_SKIP_BROWSER_DOWNLOAD set!");
+        return;
+    }
+    const assetUrl = await new MaxMindDownloader(MMDB_REPO).getAsset();
+    const fileStream = fs.createWriteStream(MMDB_FILE);
+    await webdl(assetUrl, "Downloading GeoIP database", true, fileStream);
+}
+export function removeMMDB() {
+    if (!fs.existsSync(MMDB_FILE)) {
+        console.log("GeoIP database not found.");
+        return;
+    }
+    fs.unlinkSync(MMDB_FILE);
+    console.log("GeoIP database removed.");
+}
+export async function getGeolocation(ip) {
+    if (!fs.existsSync(MMDB_FILE)) {
+        await downloadMMDB();
+    }
+    validateIP(ip);
+    const reader = await maxmind.open(MMDB_FILE);
+    const resp = reader.get(ip);
+    const isoCode = resp.country?.iso_code.toUpperCase();
+    const location = resp.location;
+    if (!location?.longitude ||
+        !location?.latitude ||
+        !location?.time_zone ||
+        !isoCode) {
+        throw new UnknownIPLocation(`Unknown IP location: ${ip}`);
+    }
+    // [PATCHED] 强制锁定为美式英语，但保留 IP 的经纬度和时区
+    const locale = new Locale("en", "US");
+    return new Geolocation(locale, location.longitude, location.latitude, location.time_zone);
+    //const locale = SELECTOR.fromRegion(isoCode);
+    //return new Geolocation(locale, location.longitude, location.latitude, location.time_zone);
+}
+async function getUnicodeInfo() {
+    const data = await fs.promises.readFile(path.join(import.meta.dirname, "data-files", "territoryInfo.xml"));
+    const parser = new xml2js.Parser();
+    return parser.parseStringPromise(data);
+}
+function asFloat(element, attr) {
+    return parseFloat(element[attr] || "0");
+}
+class StatisticalLocaleSelector {
+    root;
+    constructor() {
+        this.loadUnicodeInfo();
+    }
+    async loadUnicodeInfo() {
+        this.root = await getUnicodeInfo();
+    }
+    loadTerritoryData(isoCode) {
+        const territory = this.root.territoryInfo.territory.find((t) => t.$.type === isoCode);
+        if (!territory) {
+            throw new UnknownTerritory(`Unknown territory: ${isoCode}`);
+        }
+        const langPopulations = territory.languagePopulation;
+        if (!langPopulations) {
+            throw new Error(`No language data found for region: ${isoCode}`);
+        }
+        const languages = langPopulations.map((lang) => lang.$.type);
+        const percentages = langPopulations.map((lang) => asFloat(lang.$, "populationPercent"));
+        return this.normalizeProbabilities(languages, percentages);
+    }
+    loadLanguageData(language) {
+        const territories = this.root.territory.filter((t) => t.languagePopulation.some((lp) => lp.$.type === language));
+        if (!territories.length) {
+            throw new UnknownLanguage(`No region data found for language: ${language}`);
+        }
+        const regions = [];
+        const percentages = [];
+        for (const terr of territories) {
+            const region = terr.$.type;
+            const langPop = terr.languagePopulation.find((lp) => lp.$.type === language);
+            if (region && langPop) {
+                regions.push(region);
+                percentages.push(((asFloat(langPop.$, "populationPercent") *
+                    asFloat(terr.$, "literacyPercent")) /
+                    10000) *
+                    asFloat(terr.$, "population"));
+            }
+        }
+        if (!regions.length) {
+            throw new Error(`No valid region data found for language: ${language}`);
+        }
+        return this.normalizeProbabilities(regions, percentages);
+    }
+    normalizeProbabilities(languages, freq) {
+        const total = freq.reduce((a, b) => a + b, 0);
+        return [languages, freq.map((f) => f / total)];
+    }
+    weightedRandomChoice(items, weights) {
+        if (items.length === 0) {
+            throw new Error("items must not be empty");
+        }
+        if (items.length !== weights.length) {
+            throw new Error("items and weights must have the same length");
+        }
+        let total = 0;
+        for (const w of weights) {
+            if (w < 0) {
+                throw new Error("weights must be non-negative");
+            }
+            total += w;
+        }
+        // Fallback to uniform choice if all weights are zero
+        if (total === 0) {
+            return items[Math.floor(Math.random() * items.length)];
+        }
+        const r = Math.random() * total;
+        let acc = 0;
+        for (let i = 0; i < items.length; i++) {
+            acc += weights[i];
+            if (r < acc) {
+                return items[i];
+            }
+        }
+        // Numerical edge case
+        return items[items.length - 1];
+    }
+    fromRegion(region) {
+        const [languages, probabilities] = this.loadTerritoryData(region);
+        const language = this.weightedRandomChoice(languages, probabilities).replace("_", "-");
+        return normalizeLocale(`${language}-${region}`);
+    }
+    fromLanguage(language) {
+        const [regions, probabilities] = this.loadLanguageData(language);
+        const region = this.weightedRandomChoice(regions, probabilities);
+        return normalizeLocale(`${language}-${region}`);
+    }
+}
+const SELECTOR = new StatisticalLocaleSelector();

patches/camoufox-js@0.8.3.pkgman.patched.js

@@ -0,0 +1,351 @@
+import { execSync } from "node:child_process";
+import * as fs from "node:fs";
+import * as os from "node:os";
+import * as path from "node:path";
+import { setTimeout } from "node:timers/promises";
+import AdmZip from "adm-zip";
+import ProgressBar from "progress";
+import { CONSTRAINTS } from "./__version__.js";
+import { CamoufoxNotInstalled, FileNotFoundError, MissingRelease, UnsupportedArchitecture, UnsupportedOS, UnsupportedVersion, } from "./exceptions.js";
+const ARCH_MAP = {
+    x64: "x86_64",
+    ia32: "i686",
+    arm64: "arm64",
+    arm: "arm64",
+};
+const OS_MAP = {
+    darwin: "mac",
+    linux: "lin",
+    win32: "win",
+};
+if (!(process.platform in OS_MAP)) {
+    throw new UnsupportedOS(`OS ${process.platform} is not supported`);
+}
+export const OS_NAME = OS_MAP[process.platform];
+// [PATCH] Portable Mode: 优先使用项目目录下的 camoufox 文件夹
+const localInstallDir = path.join(process.cwd(), "camoufox");
+export const INSTALL_DIR = fs.existsSync(localInstallDir) ? localInstallDir : userCacheDir("camoufox");
+//export const INSTALL_DIR = userCacheDir("camoufox");
+
+export const LOCAL_DATA = path.join(import.meta.dirname, "data-files");
+export const OS_ARCH_MATRIX = {
+    win: ["x86_64", "i686"],
+    mac: ["x86_64", "arm64"],
+    lin: ["x86_64", "arm64", "i686"],
+};
+const LAUNCH_FILE = {
+    win: "camoufox.exe",
+    mac: "../MacOS/camoufox",
+    lin: "camoufox-bin",
+};
+class Version {
+    release;
+    version;
+    sorted_rel;
+    constructor(release, version) {
+        this.release = release;
+        this.version = version;
+        this.sorted_rel = this.buildSortedRel();
+    }
+    buildSortedRel() {
+        const parts = this.release
+            .split(".")
+            .map((x) => Number.isNaN(Number(x)) ? x.charCodeAt(0) - 1024 : Number(x));
+        while (parts.length < 5) {
+            parts.push(0);
+        }
+        return parts;
+    }
+    get fullString() {
+        return `${this.version}-${this.release}`;
+    }
+    equals(other) {
+        return this.sorted_rel.join(".") === other.sorted_rel.join(".");
+    }
+    lessThan(other) {
+        for (let i = 0; i < this.sorted_rel.length; i++) {
+            if (this.sorted_rel[i] < other.sorted_rel[i])
+                return true;
+            if (this.sorted_rel[i] > other.sorted_rel[i])
+                return false;
+        }
+        return false;
+    }
+    isSupported() {
+        return VERSION_MIN.lessThan(this) && this.lessThan(VERSION_MAX);
+    }
+    static fromPath(filePath = INSTALL_DIR) {
+        const versionPath = path.join(filePath.toString(), "version.json");
+        if (!fs.existsSync(versionPath)) {
+            throw new FileNotFoundError(`Version information not found at ${versionPath}. Please run \`camoufox fetch\` to install.`);
+        }
+        const versionData = JSON.parse(fs.readFileSync(versionPath, "utf-8"));
+        return new Version(versionData.release, versionData.version);
+    }
+    static isSupportedPath(path) {
+        return Version.fromPath(path).isSupported();
+    }
+    static buildMinMax() {
+        return [
+            new Version(CONSTRAINTS.MIN_VERSION),
+            new Version(CONSTRAINTS.MAX_VERSION),
+        ];
+    }
+}
+const [VERSION_MIN, VERSION_MAX] = Version.buildMinMax();
+export class GitHubDownloader {
+    githubRepo;
+    apiUrl;
+    constructor(githubRepo) {
+        this.githubRepo = githubRepo;
+        this.apiUrl = `https://api.github.com/repos/${githubRepo}/releases`;
+    }
+    checkAsset(asset) {
+        return asset.browser_download_url;
+    }
+    missingAssetError() {
+        throw new MissingRelease(`Could not find a release asset in ${this.githubRepo}.`);
+    }
+    async getAsset({ retries } = { retries: 5 }) {
+        let attempts = 0;
+        let response;
+        while (attempts < retries) {
+            try {
+                response = await fetch(this.apiUrl);
+                if (response.ok)
+                    break;
+            }
+            catch (e) {
+                console.error(e, `retrying (${attempts + 1}/${retries})...`);
+                await setTimeout(5e3);
+            }
+            attempts++;
+        }
+        if (!response || !response.ok) {
+            throw new Error(`Failed to fetch releases from ${this.apiUrl} after ${retries} attempts`);
+        }
+        const releases = await response.json();
+        for (const release of releases) {
+            for (const asset of release.assets) {
+                const data = this.checkAsset(asset);
+                if (data) {
+                    return data;
+                }
+            }
+        }
+        this.missingAssetError();
+    }
+}
+export class CamoufoxFetcher extends GitHubDownloader {
+    arch;
+    _version_obj;
+    pattern;
+    _url;
+    constructor() {
+        super("daijro/camoufox");
+        this.arch = CamoufoxFetcher.getPlatformArch();
+        this.pattern = new RegExp(`camoufox-(.+)-(.+)-${OS_NAME}\\.${this.arch}\\.zip`);
+    }
+    async init() {
+        await this.fetchLatest();
+    }
+    checkAsset(asset) {
+        const match = asset.name.match(this.pattern);
+        if (!match)
+            return null;
+        const version = new Version(match[2], match[1]);
+        if (!version.isSupported())
+            return null;
+        return [version, asset.browser_download_url];
+    }
+    missingAssetError() {
+        throw new MissingRelease(`No matching release found for ${OS_NAME} ${this.arch} in the supported range: (${CONSTRAINTS.asRange()}). Please update the library.`);
+    }
+    static getPlatformArch() {
+        const platArch = os.arch().toLowerCase();
+        if (!(platArch in ARCH_MAP)) {
+            throw new UnsupportedArchitecture(`Architecture ${platArch} is not supported`);
+        }
+        const arch = ARCH_MAP[platArch];
+        if (!OS_ARCH_MATRIX[OS_NAME].includes(arch)) {
+            throw new UnsupportedArchitecture(`Architecture ${arch} is not supported for ${OS_NAME}`);
+        }
+        return arch;
+    }
+    async fetchLatest() {
+        if (this._version_obj)
+            return;
+        const releaseData = await this.getAsset();
+        this._version_obj = releaseData[0];
+        this._url = releaseData[1];
+    }
+    static async downloadFile(url) {
+        const response = await fetch(url);
+        return Buffer.from(await response.arrayBuffer());
+    }
+    async extractZip(zipFile) {
+        const zip = new AdmZip(zipFile);
+        zip.extractAllTo(INSTALL_DIR.toString(), true);
+    }
+    static cleanup() {
+        if (fs.existsSync(INSTALL_DIR)) {
+            fs.rmSync(INSTALL_DIR, { recursive: true });
+            return true;
+        }
+        return false;
+    }
+    setVersion() {
+        fs.writeFileSync(path.join(INSTALL_DIR.toString(), "version.json"), JSON.stringify({ version: this.version, release: this.release }));
+    }
+    async install() {
+        await this.init();
+        await CamoufoxFetcher.cleanup();
+        try {
+            fs.mkdirSync(INSTALL_DIR, { recursive: true });
+            const tempDir = fs.mkdtempSync(path.join(os.tmpdir(), "camoufox-"));
+            const tempFilePath = path.join(tempDir, "camoufox.zip");
+            const tempFileStream = fs.createWriteStream(tempFilePath);
+            await webdl(this.url, "Downloading Camoufox...", true, tempFileStream);
+            await new Promise((r) => tempFileStream.close(r));
+            await this.extractZip(tempFilePath);
+            this.setVersion();
+            if (OS_NAME !== "win") {
+                execSync(`chmod -R 755 ${INSTALL_DIR}`);
+            }
+            console.log("Camoufox successfully installed.");
+        }
+        catch (e) {
+            console.error(`Error installing Camoufox: ${e}`);
+            await CamoufoxFetcher.cleanup();
+            throw e;
+        }
+    }
+    get url() {
+        if (!this._url) {
+            throw new Error("Url is not available. Make sure to run fetchLatest first.");
+        }
+        return this._url;
+    }
+    get version() {
+        if (!this._version_obj || !this._version_obj.version) {
+            throw new Error("Version is not available. Make sure to run fetchLatest first.");
+        }
+        return this._version_obj.version;
+    }
+    get release() {
+        if (!this._version_obj) {
+            throw new Error("Release information is not available. Make sure to run the installation first.");
+        }
+        return this._version_obj.release;
+    }
+    get verstr() {
+        if (!this._version_obj) {
+            throw new Error("Version is not available. Make sure to run the installation first.");
+        }
+        return this._version_obj.fullString;
+    }
+}
+function userCacheDir(appName) {
+    if (OS_NAME === "win") {
+        return path.join(os.homedir(), "AppData", "Local", appName, appName, "Cache");
+    }
+    else if (OS_NAME === "mac") {
+        return path.join(os.homedir(), "Library", "Caches", appName);
+    }
+    else {
+        return path.join(os.homedir(), ".cache", appName);
+    }
+}
+export function installedVerStr() {
+    return Version.fromPath().fullString;
+}
+export function camoufoxPath(downloadIfMissing = true) {
+    // Ensure the directory exists and is not empty
+    if (!fs.existsSync(INSTALL_DIR) || fs.readdirSync(INSTALL_DIR).length === 0) {
+        if (!downloadIfMissing) {
+            throw new Error(`Camoufox executable not found at ${INSTALL_DIR}`);
+        }
+    }
+    else if (fs.existsSync(INSTALL_DIR) &&
+        Version.isSupportedPath(INSTALL_DIR)) {
+        return INSTALL_DIR;
+    }
+    else {
+        if (!downloadIfMissing) {
+            throw new UnsupportedVersion("Camoufox executable is outdated.");
+        }
+    }
+    // Install and recheck
+    const fetcher = new CamoufoxFetcher();
+    fetcher.install().then(() => camoufoxPath());
+    return INSTALL_DIR;
+}
+export function getPath(file) {
+    if (OS_NAME === "mac") {
+        return path.resolve(camoufoxPath().toString(), "Camoufox.app", "Contents", "Resources", file);
+    }
+    return path.join(camoufoxPath().toString(), file);
+}
+export function launchPath() {
+    const launchPath = getPath(LAUNCH_FILE[OS_NAME]);
+    if (!fs.existsSync(launchPath)) {
+        throw new CamoufoxNotInstalled(`Camoufox is not installed at ${camoufoxPath()}. Please run \`camoufox fetch\` to install.`);
+    }
+    return launchPath;
+}
+export async function webdl(url, desc = "", bar = true, buffer = null, { retries } = { retries: 5 }) {
+    let attempts = 0;
+    let response;
+    while (attempts < retries) {
+        try {
+            response = await fetch(url);
+            if (response.ok)
+                break;
+        }
+        catch (e) {
+            console.error(e, `retrying (${attempts + 1}/${retries})...`);
+            await setTimeout(5e3);
+        }
+        attempts++;
+    }
+    if (!response || !response.ok) {
+        throw new Error(`Failed to download from ${url} after ${retries} attempts`);
+    }
+    const totalSize = parseInt(response.headers.get("content-length") || "0", 10);
+    const progressBar = bar
+        ? new ProgressBar(`${desc} [:bar] :percent :etas`, {
+            total: totalSize,
+            width: 40,
+        })
+        : null;
+    const chunks = [];
+    for await (const chunk of response.body) {
+        if (buffer) {
+            buffer.write(chunk);
+        }
+        else {
+            chunks.push(chunk);
+        }
+        if (progressBar) {
+            progressBar.tick(chunk.length, "X");
+        }
+    }
+    const fileBuffer = Buffer.concat(chunks);
+    return fileBuffer;
+}
+export async function unzip(zipFile, extractPath, desc, bar = true) {
+    const zip = new AdmZip(zipFile);
+    const zipEntries = zip.getEntries();
+    if (bar) {
+        console.log(desc || "Extracting files...");
+    }
+    for (const entry of zipEntries) {
+        if (bar) {
+            console.log(`Extracting ${entry.entryName}`);
+        }
+        zip.extractEntryTo(entry, extractPath, false, true);
+    }
+    if (bar) {
+        console.log("Extraction complete.");
+    }
+}

pnpm-lock.yaml

@@ -0,0 +1,2132 @@
+lockfileVersion: '9.0'
+
+settings:
+  autoInstallPeers: true
+  excludeLinksFromLockfile: false
+
+importers:
+
+  .:
+    dependencies:
+      '@inquirer/prompts':
+        specifier: ^8.0.1
+        version: 8.0.1(@types/node@24.10.1)
+      better-sqlite3:
+        specifier: ^12.5.0
+        version: 12.5.0
+      camoufox-js:
+        specifier: ^0.8.3
+        version: 0.8.3(playwright-core@1.57.0)
+      compressing:
+        specifier: ^2.0.0
+        version: 2.0.0
+      fingerprint-generator:
+        specifier: ^2.1.78
+        version: 2.1.78
+      ghost-cursor-playwright-port:
+        specifier: ^1.4.3
+        version: 1.4.3(@playwright/test@1.57.0)(playwright-core@1.57.0)(playwright@1.57.0)
+      got-scraping:
+        specifier: ^4.1.2
+        version: 4.1.2
+      playwright-core:
+        specifier: ^1.57.0
+        version: 1.57.0
+      proxy-chain:
+        specifier: ^2.6.0
+        version: 2.6.0
+      sharp:
+        specifier: ^0.34.5
+        version: 0.34.5
+      yaml:
+        specifier: ^2.8.2
+        version: 2.8.2
+
+packages:
+
+  '@eggjs/yauzl@2.11.0':
+    resolution: {integrity: sha512-Jq+k2fCZJ3i3HShb0nxLUiAgq5pwo8JTT1TrH22JoehZQ0Nm2dvByGIja1NYfNyuE4Tx5/Dns5nVsBN/mlC8yg==}
+
+  '@emnapi/runtime@1.7.1':
+    resolution: {integrity: sha512-PVtJr5CmLwYAU9PZDMITZoR5iAOShYREoR45EyyLrbntV50mdePTgUn4AmOw90Ifcj+x2kRjdzr1HP3RrNiHGA==}
+
+  '@img/colour@1.0.0':
+    resolution: {integrity: sha512-A5P/LfWGFSl6nsckYtjw9da+19jB8hkJ6ACTGcDfEJ0aE+l2n2El7dsVM7UVHZQ9s2lmYMWlrS21YLy2IR1LUw==}
+    engines: {node: '>=18'}
+
+  '@img/sharp-darwin-arm64@0.34.5':
+    resolution: {integrity: sha512-imtQ3WMJXbMY4fxb/Ndp6HBTNVtWCUI0WdobyheGf5+ad6xX8VIDO8u2xE4qc/fr08CKG/7dDseFtn6M6g/r3w==}
+    engines: {node: ^18.17.0 || ^20.3.0 || >=21.0.0}
+    cpu: [arm64]
+    os: [darwin]
+
+  '@img/sharp-darwin-x64@0.34.5':
+    resolution: {integrity: sha512-YNEFAF/4KQ/PeW0N+r+aVVsoIY0/qxxikF2SWdp+NRkmMB7y9LBZAVqQ4yhGCm/H3H270OSykqmQMKLBhBJDEw==}
+    engines: {node: ^18.17.0 || ^20.3.0 || >=21.0.0}
+    cpu: [x64]
+    os: [darwin]
+
+  '@img/sharp-libvips-darwin-arm64@1.2.4':
+    resolution: {integrity: sha512-zqjjo7RatFfFoP0MkQ51jfuFZBnVE2pRiaydKJ1G/rHZvnsrHAOcQALIi9sA5co5xenQdTugCvtb1cuf78Vf4g==}
+    cpu: [arm64]
+    os: [darwin]
+
+  '@img/sharp-libvips-darwin-x64@1.2.4':
+    resolution: {integrity: sha512-1IOd5xfVhlGwX+zXv2N93k0yMONvUlANylbJw1eTah8K/Jtpi15KC+WSiaX/nBmbm2HxRM1gZ0nSdjSsrZbGKg==}
+    cpu: [x64]
+    os: [darwin]
+
+  '@img/sharp-libvips-linux-arm64@1.2.4':
+    resolution: {integrity: sha512-excjX8DfsIcJ10x1Kzr4RcWe1edC9PquDRRPx3YVCvQv+U5p7Yin2s32ftzikXojb1PIFc/9Mt28/y+iRklkrw==}
+    cpu: [arm64]
+    os: [linux]
+    libc: [glibc]
+
+  '@img/sharp-libvips-linux-arm@1.2.4':
+    resolution: {integrity: sha512-bFI7xcKFELdiNCVov8e44Ia4u2byA+l3XtsAj+Q8tfCwO6BQ8iDojYdvoPMqsKDkuoOo+X6HZA0s0q11ANMQ8A==}
+    cpu: [arm]
+    os: [linux]
+    libc: [glibc]
+
+  '@img/sharp-libvips-linux-ppc64@1.2.4':
+    resolution: {integrity: sha512-FMuvGijLDYG6lW+b/UvyilUWu5Ayu+3r2d1S8notiGCIyYU/76eig1UfMmkZ7vwgOrzKzlQbFSuQfgm7GYUPpA==}
+    cpu: [ppc64]
+    os: [linux]
+    libc: [glibc]
+
+  '@img/sharp-libvips-linux-riscv64@1.2.4':
+    resolution: {integrity: sha512-oVDbcR4zUC0ce82teubSm+x6ETixtKZBh/qbREIOcI3cULzDyb18Sr/Wcyx7NRQeQzOiHTNbZFF1UwPS2scyGA==}
+    cpu: [riscv64]
+    os: [linux]
+    libc: [glibc]
+
+  '@img/sharp-libvips-linux-s390x@1.2.4':
+    resolution: {integrity: sha512-qmp9VrzgPgMoGZyPvrQHqk02uyjA0/QrTO26Tqk6l4ZV0MPWIW6LTkqOIov+J1yEu7MbFQaDpwdwJKhbJvuRxQ==}
+    cpu: [s390x]
+    os: [linux]
+    libc: [glibc]
+
+  '@img/sharp-libvips-linux-x64@1.2.4':
+    resolution: {integrity: sha512-tJxiiLsmHc9Ax1bz3oaOYBURTXGIRDODBqhveVHonrHJ9/+k89qbLl0bcJns+e4t4rvaNBxaEZsFtSfAdquPrw==}
+    cpu: [x64]
+    os: [linux]
+    libc: [glibc]
+
+  '@img/sharp-libvips-linuxmusl-arm64@1.2.4':
+    resolution: {integrity: sha512-FVQHuwx1IIuNow9QAbYUzJ+En8KcVm9Lk5+uGUQJHaZmMECZmOlix9HnH7n1TRkXMS0pGxIJokIVB9SuqZGGXw==}
+    cpu: [arm64]
+    os: [linux]
+    libc: [musl]
+
+  '@img/sharp-libvips-linuxmusl-x64@1.2.4':
+    resolution: {integrity: sha512-+LpyBk7L44ZIXwz/VYfglaX/okxezESc6UxDSoyo2Ks6Jxc4Y7sGjpgU9s4PMgqgjj1gZCylTieNamqA1MF7Dg==}
+    cpu: [x64]
+    os: [linux]
+    libc: [musl]
+
+  '@img/sharp-linux-arm64@0.34.5':
+    resolution: {integrity: sha512-bKQzaJRY/bkPOXyKx5EVup7qkaojECG6NLYswgktOZjaXecSAeCWiZwwiFf3/Y+O1HrauiE3FVsGxFg8c24rZg==}
+    engines: {node: ^18.17.0 || ^20.3.0 || >=21.0.0}
+    cpu: [arm64]
+    os: [linux]
+    libc: [glibc]
+
+  '@img/sharp-linux-arm@0.34.5':
+    resolution: {integrity: sha512-9dLqsvwtg1uuXBGZKsxem9595+ujv0sJ6Vi8wcTANSFpwV/GONat5eCkzQo/1O6zRIkh0m/8+5BjrRr7jDUSZw==}
+    engines: {node: ^18.17.0 || ^20.3.0 || >=21.0.0}
+    cpu: [arm]
+    os: [linux]
+    libc: [glibc]
+
+  '@img/sharp-linux-ppc64@0.34.5':
+    resolution: {integrity: sha512-7zznwNaqW6YtsfrGGDA6BRkISKAAE1Jo0QdpNYXNMHu2+0dTrPflTLNkpc8l7MUP5M16ZJcUvysVWWrMefZquA==}
+    engines: {node: ^18.17.0 || ^20.3.0 || >=21.0.0}
+    cpu: [ppc64]
+    os: [linux]
+    libc: [glibc]
+
+  '@img/sharp-linux-riscv64@0.34.5':
+    resolution: {integrity: sha512-51gJuLPTKa7piYPaVs8GmByo7/U7/7TZOq+cnXJIHZKavIRHAP77e3N2HEl3dgiqdD/w0yUfiJnII77PuDDFdw==}
+    engines: {node: ^18.17.0 || ^20.3.0 || >=21.0.0}
+    cpu: [riscv64]
+    os: [linux]
+    libc: [glibc]
+
+  '@img/sharp-linux-s390x@0.34.5':
+    resolution: {integrity: sha512-nQtCk0PdKfho3eC5MrbQoigJ2gd1CgddUMkabUj+rBevs8tZ2cULOx46E7oyX+04WGfABgIwmMC0VqieTiR4jg==}
+    engines: {node: ^18.17.0 || ^20.3.0 || >=21.0.0}
+    cpu: [s390x]
+    os: [linux]
+    libc: [glibc]
+
+  '@img/sharp-linux-x64@0.34.5':
+    resolution: {integrity: sha512-MEzd8HPKxVxVenwAa+JRPwEC7QFjoPWuS5NZnBt6B3pu7EG2Ge0id1oLHZpPJdn3OQK+BQDiw9zStiHBTJQQQQ==}
+    engines: {node: ^18.17.0 || ^20.3.0 || >=21.0.0}
+    cpu: [x64]
+    os: [linux]
+    libc: [glibc]
+
+  '@img/sharp-linuxmusl-arm64@0.34.5':
+    resolution: {integrity: sha512-fprJR6GtRsMt6Kyfq44IsChVZeGN97gTD331weR1ex1c1rypDEABN6Tm2xa1wE6lYb5DdEnk03NZPqA7Id21yg==}
+    engines: {node: ^18.17.0 || ^20.3.0 || >=21.0.0}
+    cpu: [arm64]
+    os: [linux]
+    libc: [musl]
+
+  '@img/sharp-linuxmusl-x64@0.34.5':
+    resolution: {integrity: sha512-Jg8wNT1MUzIvhBFxViqrEhWDGzqymo3sV7z7ZsaWbZNDLXRJZoRGrjulp60YYtV4wfY8VIKcWidjojlLcWrd8Q==}
+    engines: {node: ^18.17.0 || ^20.3.0 || >=21.0.0}
+    cpu: [x64]
+    os: [linux]
+    libc: [musl]
+
+  '@img/sharp-wasm32@0.34.5':
+    resolution: {integrity: sha512-OdWTEiVkY2PHwqkbBI8frFxQQFekHaSSkUIJkwzclWZe64O1X4UlUjqqqLaPbUpMOQk6FBu/HtlGXNblIs0huw==}
+    engines: {node: ^18.17.0 || ^20.3.0 || >=21.0.0}
+    cpu: [wasm32]
+
+  '@img/sharp-win32-arm64@0.34.5':
+    resolution: {integrity: sha512-WQ3AgWCWYSb2yt+IG8mnC6Jdk9Whs7O0gxphblsLvdhSpSTtmu69ZG1Gkb6NuvxsNACwiPV6cNSZNzt0KPsw7g==}
+    engines: {node: ^18.17.0 || ^20.3.0 || >=21.0.0}
+    cpu: [arm64]
+    os: [win32]
+
+  '@img/sharp-win32-ia32@0.34.5':
+    resolution: {integrity: sha512-FV9m/7NmeCmSHDD5j4+4pNI8Cp3aW+JvLoXcTUo0IqyjSfAZJ8dIUmijx1qaJsIiU+Hosw6xM5KijAWRJCSgNg==}
+    engines: {node: ^18.17.0 || ^20.3.0 || >=21.0.0}
+    cpu: [ia32]
+    os: [win32]
+
+  '@img/sharp-win32-x64@0.34.5':
+    resolution: {integrity: sha512-+29YMsqY2/9eFEiW93eqWnuLcWcufowXewwSNIT6UwZdUUCrM3oFjMWH/Z6/TMmb4hlFenmfAVbpWeup2jryCw==}
+    engines: {node: ^18.17.0 || ^20.3.0 || >=21.0.0}
+    cpu: [x64]
+    os: [win32]
+
+  '@inquirer/ansi@2.0.1':
+    resolution: {integrity: sha512-QAZUk6BBncv/XmSEZTscd8qazzjV3E0leUMrEPjxCd51QBgCKmprUGLex5DTsNtURm7LMzv+CLcd6S86xvBfYg==}
+    engines: {node: '>=23.5.0 || ^22.13.0 || ^21.7.0 || ^20.12.0'}
+
+  '@inquirer/checkbox@5.0.1':
+    resolution: {integrity: sha512-5VPFBK8jKdsjMK3DTFOlbR0+Kkd4q0AWB7VhWQn6ppv44dr3b7PU8wSJQTC5oA0f/aGW7v/ZozQJAY9zx6PKig==}
+    engines: {node: '>=23.5.0 || ^22.13.0 || ^21.7.0 || ^20.12.0'}
+    peerDependencies:
+      '@types/node': '>=18'
+    peerDependenciesMeta:
+      '@types/node':
+        optional: true
+
+  '@inquirer/confirm@6.0.1':
+    resolution: {integrity: sha512-wD+pM7IxLn1TdcQN12Q6wcFe5VpyCuh/I2sSmqO5KjWH2R4v+GkUToHb+PsDGobOe1MtAlXMwGNkZUPc2+L6NA==}
+    engines: {node: '>=23.5.0 || ^22.13.0 || ^21.7.0 || ^20.12.0'}
+    peerDependencies:
+      '@types/node': '>=18'
+    peerDependenciesMeta:
+      '@types/node':
+        optional: true
+
+  '@inquirer/core@11.0.1':
+    resolution: {integrity: sha512-Tpf49h50e4KYffVUCXzkx4gWMafUi3aDQDwfVAAGBNnVcXiwJIj4m2bKlZ7Kgyf6wjt1eyXH1wDGXcAokm4Ssw==}
+    engines: {node: '>=23.5.0 || ^22.13.0 || ^21.7.0 || ^20.12.0'}
+    peerDependencies:
+      '@types/node': '>=18'
+    peerDependenciesMeta:
+      '@types/node':
+        optional: true
+
+  '@inquirer/editor@5.0.1':
+    resolution: {integrity: sha512-zDKobHI7Ry++4noiV9Z5VfYgSVpPZoMApviIuGwLOMciQaP+dGzCO+1fcwI441riklRiZg4yURWyEoX0Zy2zZw==}
+    engines: {node: '>=23.5.0 || ^22.13.0 || ^21.7.0 || ^20.12.0'}
+    peerDependencies:
+      '@types/node': '>=18'
+    peerDependenciesMeta:
+      '@types/node':
+        optional: true
+
+  '@inquirer/expand@5.0.1':
+    resolution: {integrity: sha512-TBrTpAB6uZNnGQHtSEkbvJZIQ3dXZOrwqQSO9uUbwct3G2LitwBCE5YZj98MbQ5nzihzs5pRjY1K9RRLH4WgoA==}
+    engines: {node: '>=23.5.0 || ^22.13.0 || ^21.7.0 || ^20.12.0'}
+    peerDependencies:
+      '@types/node': '>=18'
+    peerDependenciesMeta:
+      '@types/node':
+        optional: true
+
+  '@inquirer/external-editor@2.0.1':
+    resolution: {integrity: sha512-BPYWJXCAK9w6R+pb2s3WyxUz9ts9SP/LDOUwA9fu7LeuyYgojz83i0DSRwezu736BgMwz14G63Xwj70hSzHohQ==}
+    engines: {node: '>=23.5.0 || ^22.13.0 || ^21.7.0 || ^20.12.0'}
+    peerDependencies:
+      '@types/node': '>=18'
+    peerDependenciesMeta:
+      '@types/node':
+        optional: true
+
+  '@inquirer/figures@2.0.1':
+    resolution: {integrity: sha512-KtMxyjLCuDFqAWHmCY9qMtsZ09HnjMsm8H3OvpSIpfhHdfw3/AiGWHNrfRwbyvHPtOJpumm8wGn5fkhtvkWRsg==}
+    engines: {node: '>=23.5.0 || ^22.13.0 || ^21.7.0 || ^20.12.0'}
+
+  '@inquirer/input@5.0.1':
+    resolution: {integrity: sha512-cEhEUohCpE2BCuLKtFFZGp4Ief05SEcqeAOq9NxzN5ThOQP8Rl5N/Nt9VEDORK1bRb2Sk/zoOyQYfysPQwyQtA==}
+    engines: {node: '>=23.5.0 || ^22.13.0 || ^21.7.0 || ^20.12.0'}
+    peerDependencies:
+      '@types/node': '>=18'
+    peerDependenciesMeta:
+      '@types/node':
+        optional: true
+
+  '@inquirer/number@4.0.1':
+    resolution: {integrity: sha512-4//zgBGHe8Q/FfCoUXZUrUHyK/q5dyqiwsePz3oSSPSmw1Ijo35ZkjaftnxroygcUlLYfXqm+0q08lnB5hd49A==}
+    engines: {node: '>=23.5.0 || ^22.13.0 || ^21.7.0 || ^20.12.0'}
+    peerDependencies:
+      '@types/node': '>=18'
+    peerDependenciesMeta:
+      '@types/node':
+        optional: true
+
+  '@inquirer/password@5.0.1':
+    resolution: {integrity: sha512-UJudHpd7Ia30Q+x+ctYqI9Nh6SyEkaBscpa7J6Ts38oc1CNSws0I1hJEdxbQBlxQd65z5GEJPM4EtNf6tzfWaQ==}
+    engines: {node: '>=23.5.0 || ^22.13.0 || ^21.7.0 || ^20.12.0'}
+    peerDependencies:
+      '@types/node': '>=18'
+    peerDependenciesMeta:
+      '@types/node':
+        optional: true
+
+  '@inquirer/prompts@8.0.1':
+    resolution: {integrity: sha512-MURRu/cyvLm9vchDDaVZ9u4p+ADnY0Mz3LQr0KTgihrrvuKZlqcWwlBC4lkOMvd0KKX4Wz7Ww9+uA7qEpQaqjg==}
+    engines: {node: '>=23.5.0 || ^22.13.0 || ^21.7.0 || ^20.12.0'}
+    peerDependencies:
+      '@types/node': '>=18'
+    peerDependenciesMeta:
+      '@types/node':
+        optional: true
+
+  '@inquirer/rawlist@5.0.1':
+    resolution: {integrity: sha512-vVfVHKUgH6rZmMlyd0jOuGZo0Fw1jfcOqZF96lMwlgavx7g0x7MICe316bV01EEoI+c68vMdbkTTawuw3O+Fgw==}
+    engines: {node: '>=23.5.0 || ^22.13.0 || ^21.7.0 || ^20.12.0'}
+    peerDependencies:
+      '@types/node': '>=18'
+    peerDependenciesMeta:
+      '@types/node':
+        optional: true
+
+  '@inquirer/search@4.0.1':
+    resolution: {integrity: sha512-XwiaK5xBvr31STX6Ji8iS3HCRysBXfL/jUbTzufdWTS6LTGtvDQA50oVETt1BJgjKyQBp9vt0VU6AmU/AnOaGA==}
+    engines: {node: '>=23.5.0 || ^22.13.0 || ^21.7.0 || ^20.12.0'}
+    peerDependencies:
+      '@types/node': '>=18'
+    peerDependenciesMeta:
+      '@types/node':
+        optional: true
+
+  '@inquirer/select@5.0.1':
+    resolution: {integrity: sha512-gPByrgYoezGyKMq5KjV7Tuy1JU2ArIy6/sI8sprw0OpXope3VGQwP5FK1KD4eFFqEhKu470Dwe6/AyDPmGRA0Q==}
+    engines: {node: '>=23.5.0 || ^22.13.0 || ^21.7.0 || ^20.12.0'}
+    peerDependencies:
+      '@types/node': '>=18'
+    peerDependenciesMeta:
+      '@types/node':
+        optional: true
+
+  '@inquirer/type@4.0.1':
+    resolution: {integrity: sha512-odO8YwoQAw/eVu/PSPsDDVPmqO77r/Mq7zcoF5VduVqIu2wSRWUgmYb5K9WH1no0SjLnOe8MDKtDL++z6mfo2g==}
+    engines: {node: '>=23.5.0 || ^22.13.0 || ^21.7.0 || ^20.12.0'}
+    peerDependencies:
+      '@types/node': '>=18'
+    peerDependenciesMeta:
+      '@types/node':
+        optional: true
+
+  '@isaacs/balanced-match@4.0.1':
+    resolution: {integrity: sha512-yzMTt9lEb8Gv7zRioUilSglI0c0smZ9k5D65677DLWLtWJaXIS3CqcGyUFByYKlnUj6TkjLVs54fBl6+TiGQDQ==}
+    engines: {node: 20 || >=22}
+
+  '@isaacs/brace-expansion@5.0.0':
+    resolution: {integrity: sha512-ZT55BDLV0yv0RBm2czMiZ+SqCGO7AvmOM3G/w2xhVPH+te0aKgFjmBvGlL1dH+ql2tgGO3MVrbb3jCKyvpgnxA==}
+    engines: {node: 20 || >=22}
+
+  '@keyv/serialize@1.1.1':
+    resolution: {integrity: sha512-dXn3FZhPv0US+7dtJsIi2R+c7qWYiReoEh5zUntWCf4oSpMNib8FDhSoed6m3QyZdx5hK7iLFkYk3rNxwt8vTA==}
+
+  '@playwright/test@1.57.0':
+    resolution: {integrity: sha512-6TyEnHgd6SArQO8UO2OMTxshln3QMWBtPGrOCgs3wVEmQmwyuNtB10IZMfmYDE0riwNR1cu4q+pPcxMVtaG3TA==}
+    engines: {node: '>=18'}
+    hasBin: true
+
+  '@sec-ant/readable-stream@0.4.1':
+    resolution: {integrity: sha512-831qok9r2t8AlxLko40y2ebgSDhenenCatLVeW/uBtnHPyhHOvG0C7TvfgecV+wHzIm5KUICgzmVpWS+IMEAeg==}
+
+  '@sindresorhus/is@4.6.0':
+    resolution: {integrity: sha512-t09vSN3MdfsyCHoFcTRCH/iUtG7OJ0CsjzB8cjAmKc/va/kIgeDI/TxsigdncE/4be734m0cvIYwNaV4i2XqAw==}
+    engines: {node: '>=10'}
+
+  '@sindresorhus/is@5.6.0':
+    resolution: {integrity: sha512-TV7t8GKYaJWsn00tFDqBw8+Uqmr8A0fRU1tvTQhyZzGv0sJCGRQL3JGMI3ucuKo3XIZdUP+Lx7/gh2t3lewy7g==}
+    engines: {node: '>=14.16'}
+
+  '@sindresorhus/is@7.1.1':
+    resolution: {integrity: sha512-rO92VvpgMc3kfiTjGT52LEtJ8Yc5kCWhZjLQ3LwlA4pSgPpQO7bVpYXParOD8Jwf+cVQECJo3yP/4I8aZtUQTQ==}
+    engines: {node: '>=18'}
+
+  '@types/bezier-js@4.1.3':
+    resolution: {integrity: sha512-FNVVCu5mx/rJCWBxLTcL7oOajmGtWtBTDjq6DSUWUI12GeePivrZZXz+UgE0D6VYsLEjvExRO03z4hVtu3pTEQ==}
+
+  '@types/http-cache-semantics@4.0.4':
+    resolution: {integrity: sha512-1m0bIFVc7eJWyve9S0RnuRgcQqF/Xd5QsUZAZeQFr1Q3/p9JWoQQEqmVy+DPTNpGXwhgIetAoYF8JSc33q29QA==}
+
+  '@types/node@24.10.1':
+    resolution: {integrity: sha512-GNWcUTRBgIRJD5zj+Tq0fKOJ5XZajIiBroOF0yvj2bSU1WvNdYS/dn9UxwsujGW4JX06dnHyjV2y9rRaybH0iQ==}
+
+  adm-zip@0.5.16:
+    resolution: {integrity: sha512-TGw5yVi4saajsSEgz25grObGHEUaDrniwvA2qwSC060KfqGPdglhvPMA2lPIoxs3PQIItj2iag35fONcQqgUaQ==}
+    engines: {node: '>=12.0'}
+
+  agent-base@7.1.4:
+    resolution: {integrity: sha512-MnA+YT8fwfJPgBx3m60MNqakm30XOkyIoH1y6huTQvC0PwZG7ki8NacLBcrPbNoo8vEZy7Jpuk7+jMO+CUovTQ==}
+    engines: {node: '>= 14'}
+
+  ansi-regex@6.2.2:
+    resolution: {integrity: sha512-Bq3SmSpyFHaWjPk8If9yc6svM8c56dB5BAtW4Qbw5jHTwwXXcTLoRMkpDJp6VL0XzlWaCHTXrkFURMYmD0sLqg==}
+    engines: {node: '>=12'}
+
+  ansi-styles@6.2.3:
+    resolution: {integrity: sha512-4Dj6M28JB+oAH8kFkTLUo+a2jwOFkuqb3yucU0CANcRRUbxS0cP0nZYCGjcc3BNXwRIsUVmDGgzawme7zvJHvg==}
+    engines: {node: '>=12'}
+
+  available-typed-arrays@1.0.7:
+    resolution: {integrity: sha512-wvUjBtSGN7+7SjNpq/9M2Tg350UZD3q62IFZLbRAR1bSMlCo1ZaeW+BJ+D090e4hIIZLBcTDWe4Mh4jvUDajzQ==}
+    engines: {node: '>= 0.4'}
+
+  base64-js@1.5.1:
+    resolution: {integrity: sha512-AKpaYlHn8t4SVbOHCy+b5+KKgvR4vrsD8vbvrbiQJps7fKDTkjkDry6ji0rUJjC0kzbNePLwzxq8iypo41qeWA==}
+
+  baseline-browser-mapping@2.8.30:
+    resolution: {integrity: sha512-aTUKW4ptQhS64+v2d6IkPzymEzzhw+G0bA1g3uBRV3+ntkH+svttKseW5IOR4Ed6NUVKqnY7qT3dKvzQ7io4AA==}
+    hasBin: true
+
+  better-sqlite3@12.5.0:
+    resolution: {integrity: sha512-WwCZ/5Diz7rsF29o27o0Gcc1Du+l7Zsv7SYtVPG0X3G/uUI1LqdxrQI7c9Hs2FWpqXXERjW9hp6g3/tH7DlVKg==}
+    engines: {node: 20.x || 22.x || 23.x || 24.x || 25.x}
+
+  bezier-js@6.1.4:
+    resolution: {integrity: sha512-PA0FW9ZpcHbojUCMu28z9Vg/fNkwTj5YhusSAjHHDfHDGLxJ6YUKrAN2vk1fP2MMOxVw4Oko16FMlRGVBGqLKg==}
+
+  bindings@1.5.0:
+    resolution: {integrity: sha512-p2q/t/mhvuOj/UeLlV6566GD/guowlr0hHxClI0W9m7MWYkL1F0hLo+0Aexs9HSPCtR1SXQ0TD3MMKrXZajbiQ==}
+
+  bl@1.2.3:
+    resolution: {integrity: sha512-pvcNpa0UU69UT341rO6AYy4FVAIkUHuZXRIWbq+zHnsVcRzDDjIAhGuuYoi0d//cwIwtt4pkpKycWEfjdV+vww==}
+
+  bl@4.1.0:
+    resolution: {integrity: sha512-1W07cM9gS6DcLperZfFSj+bWLtaPGSOHWhPiGzXmvVJbRLdG82sH/Kn8EtW1VqWVA54AKf2h5k5BbnIbwF3h6w==}
+
+  browserslist@4.28.0:
+    resolution: {integrity: sha512-tbydkR/CxfMwelN0vwdP/pLkDwyAASZ+VfWm4EOwlB6SWhx1sYnWLqo8N5j0rAzPfzfRaxt0mM/4wPU/Su84RQ==}
+    engines: {node: ^6 || ^7 || ^8 || ^9 || ^10 || ^11 || ^12 || >=13.7}
+    hasBin: true
+
+  buffer-alloc-unsafe@1.1.0:
+    resolution: {integrity: sha512-TEM2iMIEQdJ2yjPJoSIsldnleVaAk1oW3DBVUykyOLsEsFmEc9kn+SFFPz+gl54KQNxlDnAwCXosOS9Okx2xAg==}
+
+  buffer-alloc@1.2.0:
+    resolution: {integrity: sha512-CFsHQgjtW1UChdXgbyJGtnm+O/uLQeZdtbDo8mfUgYXCHSM1wgrVxXm6bSyrUuErEb+4sYVGCzASBRot7zyrow==}
+
+  buffer-crc32@0.2.13:
+    resolution: {integrity: sha512-VO9Ht/+p3SN7SKWqcrgEzjGbRSJYTx+Q1pTQC0wrWqHx0vpJraQ6GtHx8tvcg1rlK1byhU5gccxgOgj7B0TDkQ==}
+
+  buffer-fill@1.0.0:
+    resolution: {integrity: sha512-T7zexNBwiiaCOGDg9xNX9PBmjrubblRkENuptryuI64URkXDFum9il/JGL8Lm8wYfAXpredVXXZz7eMHilimiQ==}
+
+  buffer@5.7.1:
+    resolution: {integrity: sha512-EHcyIPBQ4BSGlvjB16k5KgAJ27CIsHY/2JBmCRReo48y9rQ3MaUzWX3KVlBa4U7MyX02HdVj0K7C3WaB3ju7FQ==}
+
+  byte-counter@0.1.0:
+    resolution: {integrity: sha512-jheRLVMeUKrDBjVw2O5+k4EvR4t9wtxHL+bo/LxfkxsVeuGMy3a5SEGgXdAFA4FSzTrU8rQXQIrsZ3oBq5a0pQ==}
+    engines: {node: '>=20'}
+
+  cacheable-lookup@7.0.0:
+    resolution: {integrity: sha512-+qJyx4xiKra8mZrcwhjMRMUhD5NR1R8esPkzIYxX96JiecFoxAXFuz/GpR3+ev4PE1WamHip78wV0vcmPQtp8w==}
+    engines: {node: '>=14.16'}
+
+  cacheable-request@13.0.15:
+    resolution: {integrity: sha512-NjiSrjv37X73FmGGU5ec/M83vWQ6q1Ae3BFe+ABfdeeMy4LOMKYTpfEjrBnLedu43clKZtsYbKrHTIQE7vKq+A==}
+    engines: {node: '>=18'}
+
+  call-bind-apply-helpers@1.0.2:
+    resolution: {integrity: sha512-Sp1ablJ0ivDkSzjcaJdxEunN5/XvksFJ2sMBFfq6x0ryhQV/2b/KwFe21cMpmHtPOSij8K99/wSfoEuTObmuMQ==}
+    engines: {node: '>= 0.4'}
+
+  call-bind@1.0.8:
+    resolution: {integrity: sha512-oKlSFMcMwpUg2ednkhQ454wfWiU/ul3CkJe/PEHcTKuiX6RpbehUiFMXu13HalGZxfUwCQzZG747YXBn1im9ww==}
+    engines: {node: '>= 0.4'}
+
+  call-bound@1.0.4:
+    resolution: {integrity: sha512-+ys997U96po4Kx/ABpBCqhA9EuxJaQWDQg7295H4hBphv3IZg0boBKuwYpt4YXp6MZ5AmZQnU/tyMTlRpaSejg==}
+    engines: {node: '>= 0.4'}
+
+  callsites@3.1.0:
+    resolution: {integrity: sha512-P8BjAsXvZS+VIDUI11hHCQEv74YT67YUi5JJFNWIqL235sBmjX4+qx9Muvls5ivyNENctx46xQLQ3aTuE7ssaQ==}
+    engines: {node: '>=6'}
+
+  callsites@4.2.0:
+    resolution: {integrity: sha512-kfzR4zzQtAE9PC7CzZsjl3aBNbXWuXiSeOCdLcPpBfGW8YuCqQHcRPFDbr/BPVmd3EEPVpuFzLyuT/cUhPr4OQ==}
+    engines: {node: '>=12.20'}
+
+  camoufox-js@0.8.3:
+    resolution: {integrity: sha512-oHFx/xWRfdDujZUsFszlWioK4hY5KNBMcIkw86S9eIQD0pLBWvvVd8FfzfuqIG0VAKdZqxGmF1m1ARsace2L1Q==}
+    engines: {node: '>= 20'}
+    hasBin: true
+    peerDependencies:
+      playwright-core: '*'
+
+  caniuse-lite@1.0.30001756:
+    resolution: {integrity: sha512-4HnCNKbMLkLdhJz3TToeVWHSnfJvPaq6vu/eRP0Ahub/07n484XHhBF5AJoSGHdVrS8tKFauUQz8Bp9P7LVx7A==}
+
+  chardet@2.1.1:
+    resolution: {integrity: sha512-PsezH1rqdV9VvyNhxxOW32/d75r01NY7TQCmOqomRo15ZSOKbpTFVsfjghxo6JloQUCGnH4k1LGu0R4yCLlWQQ==}
+
+  chownr@1.1.4:
+    resolution: {integrity: sha512-jJ0bqzaylmJtVnNgzTeSOs8DPavpbYgEr/b0YL8/2GO3xJEhInFmhKMUnEJQjZumK7KXGFhUy89PrsJWlakBVg==}
+
+  cli-width@4.1.0:
+    resolution: {integrity: sha512-ouuZd4/dm2Sw5Gmqy6bGyNNNe1qt9RpmxveLSO7KcgsTnU7RXfsw+/bukWGo1abgBiMAic068rclZsO4IWmmxQ==}
+    engines: {node: '>= 12'}
+
+  commander@14.0.2:
+    resolution: {integrity: sha512-TywoWNNRbhoD0BXs1P3ZEScW8W5iKrnbithIl0YH+uCmBd0QpPOA8yc82DS3BIE5Ma6FnBVUsJ7wVUDz4dvOWQ==}
+    engines: {node: '>=20'}
+
+  compressing@2.0.0:
+    resolution: {integrity: sha512-hRG5wpuy/lkO/oO8AEhSmLw2FVJOs2DnFPtmm0XUVWoDP6k3HAw5RVgyzbbATl0ytjJDCY03DvRiyjHkSHc1Dg==}
+    engines: {node: '>= 18.0.0'}
+
+  core-util-is@1.0.3:
+    resolution: {integrity: sha512-ZQBvi1DcpJ4GDqanjucZ2Hj3wEO5pZDS89BWbkcrvdxksJorwUDDZamX9ldFkp9aw2lmBDLgkObEA4DWNJ9FYQ==}
+
+  debug@4.4.3:
+    resolution: {integrity: sha512-RGwwWnwQvkVfavKVt22FGLw+xYSdzARwm0ru6DhTVA3umU5hZc28V3kO4stgYryrTlLpuvgI9GiijltAjNbcqA==}
+    engines: {node: '>=6.0'}
+    peerDependencies:
+      supports-color: '*'
+    peerDependenciesMeta:
+      supports-color:
+        optional: true
+
+  decompress-response@10.0.0:
+    resolution: {integrity: sha512-oj7KWToJuuxlPr7VV0vabvxEIiqNMo+q0NueIiL3XhtwC6FVOX7Hr1c0C4eD0bmf7Zr+S/dSf2xvkH3Ad6sU3Q==}
+    engines: {node: '>=20'}
+
+  decompress-response@6.0.0:
+    resolution: {integrity: sha512-aW35yZM6Bb/4oJlZncMH2LCoZtJXTRxES17vE3hoRiowU2kWHaJKFkSBDnDR+cm9J+9QhXmREyIfv0pji9ejCQ==}
+    engines: {node: '>=10'}
+
+  deep-extend@0.6.0:
+    resolution: {integrity: sha512-LOHxIOaPYdHlJRtCQfDIVZtfw/ufM8+rVj649RIHzcm/vGwQRXFt6OPqIFWsm2XEMrNIEtWR64sY1LEKD2vAOA==}
+    engines: {node: '>=4.0.0'}
+
+  define-data-property@1.1.4:
+    resolution: {integrity: sha512-rBMvIzlpA8v6E+SJZoo++HAYqsLrkg7MSfIinMPFhmkorw7X+dOXVJQs+QT69zGkzMyfDnIMN2Wid1+NbL3T+A==}
+    engines: {node: '>= 0.4'}
+
+  detect-europe-js@0.1.2:
+    resolution: {integrity: sha512-lgdERlL3u0aUdHocoouzT10d9I89VVhk0qNRmll7mXdGfJT1/wqZ2ZLA4oJAjeACPY5fT1wsbq2AT+GkuInsow==}
+
+  detect-libc@2.1.2:
+    resolution: {integrity: sha512-Btj2BOOO83o3WyH59e8MgXsxEQVcarkUOpEYrubB0urwnN10yQ364rsiByU11nZlqWYZm05i/of7io4mzihBtQ==}
+    engines: {node: '>=8'}
+
+  dot-prop@6.0.1:
+    resolution: {integrity: sha512-tE7ztYzXHIeyvc7N+hR3oi7FIbf/NIjVP9hmAt3yMXzrQ072/fpjGLx2GxNxGxUl5V73MEqYzioOMoVhGMJ5cA==}
+    engines: {node: '>=10'}
+
+  dot-prop@7.2.0:
+    resolution: {integrity: sha512-Ol/IPXUARn9CSbkrdV4VJo7uCy1I3VuSiWCaFSg+8BdUOzF9n3jefIpcgAydvUZbTdEBZs2vEiTiS9m61ssiDA==}
+    engines: {node: ^12.20.0 || ^14.13.1 || >=16.0.0}
+
+  dunder-proto@1.0.1:
+    resolution: {integrity: sha512-KIN/nDJBQRcXw0MLVhZE9iQHmG68qAVIBg9CqmUYjmQIhgij9U5MFvrqkUL5FbtyyzZuOeOt0zdeRe4UY7ct+A==}
+    engines: {node: '>= 0.4'}
+
+  electron-to-chromium@1.5.259:
+    resolution: {integrity: sha512-I+oLXgpEJzD6Cwuwt1gYjxsDmu/S/Kd41mmLA3O+/uH2pFRO/DvOjUyGozL8j3KeLV6WyZ7ssPwELMsXCcsJAQ==}
+
+  emoji-regex@10.6.0:
+    resolution: {integrity: sha512-toUI84YS5YmxW219erniWD0CIVOo46xGKColeNQRgOzDorgBi1v4D71/OFzgD9GO2UGKIv1C3Sp8DAn0+j5w7A==}
+
+  end-of-stream@1.4.5:
+    resolution: {integrity: sha512-ooEGc6HP26xXq/N+GCGOT0JKCLDGrq2bQUZrQ7gyrJiZANJ/8YDTxTpQBXGMn+WbIQXNVpyWymm7KYVICQnyOg==}
+
+  es-define-property@1.0.1:
+    resolution: {integrity: sha512-e3nRfgfUZ4rNGL232gUgX06QNyyez04KdjFrF+LTRoOXmrOgFKDg4BCdsjW8EnT69eqdYGmRpJwiPVYNrCaW3g==}
+    engines: {node: '>= 0.4'}
+
+  es-errors@1.3.0:
+    resolution: {integrity: sha512-Zf5H2Kxt2xjTvbJvP2ZWLEICxA6j+hAmMzIlypy4xcBg1vKVnx89Wy0GbS+kf5cwCVFFzdCFh2XSCFNULS6csw==}
+    engines: {node: '>= 0.4'}
+
+  es-object-atoms@1.1.1:
+    resolution: {integrity: sha512-FGgH2h8zKNim9ljj7dankFPcICIK9Cp5bm+c2gQSYePhpaG5+esrLODihIorn+Pe6FGJzWhXQotPv73jTaldXA==}
+    engines: {node: '>= 0.4'}
+
+  escalade@3.2.0:
+    resolution: {integrity: sha512-WUj2qlxaQtO4g6Pq5c29GTcWGDyd8itL8zTlipgECz3JesAiiOKotd8JU6otB3PACgG6xkJUyVhboMS+bje/jA==}
+    engines: {node: '>=6'}
+
+  expand-template@2.0.3:
+    resolution: {integrity: sha512-XYfuKMvj4O35f/pOXLObndIRvyQ+/+6AhODh+OKWj9S9498pHHn/IMszH+gt0fBCRWMNfk1ZSp5x3AifmnI2vg==}
+    engines: {node: '>=6'}
+
+  fd-slicer2@1.2.0:
+    resolution: {integrity: sha512-3lBUNUckhMZduCc4g+Pw4Ve16LD9vpX9b8qUkkKq2mgDRLYWzblszZH2luADnJqjJe+cypngjCuKRm/IW12rRw==}
+
+  file-uri-to-path@1.0.0:
+    resolution: {integrity: sha512-0Zt+s3L7Vf1biwWZ29aARiVYLx7iMGnEUl9x33fbB/j3jR81u/O2LbqK+Bm1CDSNDKVtJ/YjwY7TUd5SkeLQLw==}
+
+  fingerprint-generator@2.1.78:
+    resolution: {integrity: sha512-IsmMGYXSmh4F70ltWXMHjd454GKBYHdLm/QjCn0gWhMqkotLVhgbMHxtRq+l1IYIapteC+HZEVDAYSzj2Gs+4Q==}
+    engines: {node: '>=16.0.0'}
+
+  flushwritable@1.0.0:
+    resolution: {integrity: sha512-3VELfuWCLVzt5d2Gblk8qcqFro6nuwvxwMzHaENVDHI7rxcBRtMCwTk/E9FXcgh+82DSpavPNDueA9+RxXJoFg==}
+
+  for-each@0.3.5:
+    resolution: {integrity: sha512-dKx12eRCVIzqCxFGplyFKJMPvLEWgmNtUrpTiJIR5u97zEhRG8ySrtboPHZXx7daLxQVrl643cTzbab2tkQjxg==}
+    engines: {node: '>= 0.4'}
+
+  form-data-encoder@4.1.0:
+    resolution: {integrity: sha512-G6NsmEW15s0Uw9XnCg+33H3ViYRyiM0hMrMhhqQOR8NFc5GhYrI+6I3u7OTw7b91J2g8rtvMBZJDbcGb2YUniw==}
+    engines: {node: '>= 18'}
+
+  fs-constants@1.0.0:
+    resolution: {integrity: sha512-y6OAwoSIf7FyjMIv94u+b5rdheZEjzR63GTyZJm5qh4Bi+2YgwLCcI/fPFZkL5PSixOt6ZNKm+w+Hfp/Bciwow==}
+
+  fsevents@2.3.2:
+    resolution: {integrity: sha512-xiqMQR4xAeHTuB9uWm+fFRcIOgKBMiOBP+eXiyT7jsgVCq1bkVygt00oASowB7EdtpOHaaPgKt812P9ab+DDKA==}
+    engines: {node: ^8.16.0 || ^10.6.0 || >=11.0.0}
+    os: [darwin]
+
+  function-bind@1.1.2:
+    resolution: {integrity: sha512-7XHNxH7qX9xG5mIwxkhumTox/MIRNcOgDrxWsMt2pAr23WHp6MrRlN7FBSFpCpr+oVO0F744iUgR82nJMfG2SA==}
+
+  generative-bayesian-network@2.1.77:
+    resolution: {integrity: sha512-viU4CRPsmgiklR94LhvdMndaY73BkCH1pGjmOjWbLR/ZwcUd06gKF3TCcsS3npRl74o33YSInSixxm16wIukcA==}
+
+  generative-bayesian-network@2.1.78:
+    resolution: {integrity: sha512-c9EFbWfqkWEy4Rux23PI+QEn768VQq/au83OAst4XLs+qOR3YjmN3Jx0faMuOy1VnSS10hh49+1mOAzDiUPKbQ==}
+
+  get-east-asian-width@1.4.0:
+    resolution: {integrity: sha512-QZjmEOC+IT1uk6Rx0sX22V6uHWVwbdbxf1faPqJ1QhLdGgsRGCZoyaQBm/piRdJy/D2um6hM1UP7ZEeQ4EkP+Q==}
+    engines: {node: '>=18'}
+
+  get-intrinsic@1.3.0:
+    resolution: {integrity: sha512-9fSjSaos/fRIVIp+xSJlE6lfwhES7LNtKaCBIamHsjr2na1BiABJPo0mOjjz8GJDURarmCPGqaiVg5mfjb98CQ==}
+    engines: {node: '>= 0.4'}
+
+  get-proto@1.0.1:
+    resolution: {integrity: sha512-sTSfBjoXBp89JvIKIefqw7U2CCebsc74kiY6awiGogKtoSGbgjYE/G/+l9sF3MWFPNc9IcoOC4ODfKHfxFmp0g==}
+    engines: {node: '>= 0.4'}
+
+  get-ready@1.0.0:
+    resolution: {integrity: sha512-mFXCZPJIlcYcth+N8267+mghfYN9h3EhsDa6JSnbA3Wrhh/XFpuowviFcsDeYZtKspQyWyJqfs4O6P8CHeTwzw==}
+
+  get-stream@9.0.1:
+    resolution: {integrity: sha512-kVCxPF3vQM/N0B1PmoqVUqgHP+EeVjmZSQn+1oCRPxd2P21P2F19lIgbR3HBosbB1PUhOAoctJnfEn2GbN2eZA==}
+    engines: {node: '>=18'}
+
+  ghost-cursor-playwright-port@1.4.3:
+    resolution: {integrity: sha512-+h1skiBy3S6ItlrW91JgmexcS9qH8Vhk9XBkC20RW+jTjfiZvg0RWt73iy4AzJhUWZCy7pZWZqSFNBK4bdIahw==}
+    peerDependencies:
+      '@playwright/test': ^1.54.0
+      playwright: ^1.54.0
+      playwright-core: ^1.54.0
+
+  github-from-package@0.0.0:
+    resolution: {integrity: sha512-SyHy3T1v2NUXn29OsWdxmK6RwHD+vkj3v8en8AOBZ1wBQ/hCAQ5bAQTD02kW4W9tUp/3Qh6J8r9EvntiyCmOOw==}
+
+  glob@13.0.0:
+    resolution: {integrity: sha512-tvZgpqk6fz4BaNZ66ZsRaZnbHvP/jG3uKJvAZOwEVUL4RTA5nJeeLYfyN9/VA8NX/V3IBG+hkeuGpKjvELkVhA==}
+    engines: {node: 20 || >=22}
+
+  gopd@1.2.0:
+    resolution: {integrity: sha512-ZUKRh6/kUFoAiTAtTYPZJ3hw9wNxx+BIBOijnlG9PnrJsCcSjs1wyyD6vJpaYtgnzDrKYRSqf3OO6Rfa93xsRg==}
+    engines: {node: '>= 0.4'}
+
+  got-scraping@4.1.2:
+    resolution: {integrity: sha512-LtVwPM5YLnNY7HVT/AK/yDBUg/4yOZSlAjjug2ovrHQseS43QCmO1XosKKXcXrfc6OMX8OnDbAWIauFMcaJ5TQ==}
+    engines: {node: '>=16'}
+
+  got@14.6.4:
+    resolution: {integrity: sha512-DjsLab39NUMf5iYlK9asVCkHMhaA2hEhrlmf+qXRhjEivuuBHWYbjmty9DA3OORUwZgENTB+6vSmY2ZW8gFHVw==}
+    engines: {node: '>=20'}
+
+  has-property-descriptors@1.0.2:
+    resolution: {integrity: sha512-55JNKuIW+vq4Ke1BjOTjM2YctQIvCT7GFzHwmfZPGo5wnrgkid0YQtnAleFSqumZm4az3n2BS+erby5ipJdgrg==}
+
+  has-symbols@1.1.0:
+    resolution: {integrity: sha512-1cDNdwJ2Jaohmb3sg4OmKaMBwuC48sYni5HUw2DvsC8LjGTLK9h+eb1X6RyuOHe4hT0ULCW68iomhjUoKUqlPQ==}
+    engines: {node: '>= 0.4'}
+
+  has-tostringtag@1.0.2:
+    resolution: {integrity: sha512-NqADB8VjPFLM2V0VvHUewwwsw0ZWBaIdgo+ieHtK3hasLz4qeCRjYcqfB6AQrBggRKppKF8L52/VqdVsO47Dlw==}
+    engines: {node: '>= 0.4'}
+
+  hasown@2.0.2:
+    resolution: {integrity: sha512-0hJU9SCPvmMzIBdZFqNPXWa6dqh7WdH0cII9y+CyS8rG3nL48Bclra9HmKhVVUHyPWNH5Y7xDwAB7bfgSjkUMQ==}
+    engines: {node: '>= 0.4'}
+
+  header-generator@2.1.77:
+    resolution: {integrity: sha512-ggSG/mfkFMu8CO7xP591G8kp1IJCBvgXu7M8oxTjC9u914JsIzE6zIfoFsXzA+pf0utWJhUsdqU0oV/DtQ4DFQ==}
+    engines: {node: '>=16.0.0'}
+
+  header-generator@2.1.78:
+    resolution: {integrity: sha512-SB3tPpdYPh1wOAj/st8GGezIxUNx4COvKfWCZX87ehcnoQRJVZMNzhY93CxG4U8mP0UxrtUm1bmVT4mQ0oXdjA==}
+    engines: {node: '>=16.0.0'}
+
+  http-cache-semantics@4.2.0:
+    resolution: {integrity: sha512-dTxcvPXqPvXBQpq5dUr6mEMJX4oIEFv6bwom3FDwKRDsuIjjJGANqhBuoAn9c1RQJIdAKav33ED65E2ys+87QQ==}
+
+  http2-wrapper@2.2.1:
+    resolution: {integrity: sha512-V5nVw1PAOgfI3Lmeaj2Exmeg7fenjhRUgz1lPSezy1CuhPYbgQtbQj4jZfEAEMlaL+vupsvhjqCyjzob0yxsmQ==}
+    engines: {node: '>=10.19.0'}
+
+  iconv-lite@0.5.2:
+    resolution: {integrity: sha512-kERHXvpSaB4aU3eANwidg79K8FlrN77m8G9V+0vOR3HYaRifrlwMEpT7ZBJqLSEIHnEgJTHcWK82wwLwwKwtag==}
+    engines: {node: '>=0.10.0'}
+
+  iconv-lite@0.7.0:
+    resolution: {integrity: sha512-cf6L2Ds3h57VVmkZe+Pn+5APsT7FpqJtEhhieDCvrE2MK5Qk9MyffgQyuxQTm6BChfeZNtcOLHp9IcWRVcIcBQ==}
+    engines: {node: '>=0.10.0'}
+
+  ieee754@1.2.1:
+    resolution: {integrity: sha512-dcyqhDvX1C46lXZcVqCpK+FtMRQVdIMN6/Df5js2zouUsqG7I6sFxitIC+7KYK29KdXOLHdu9zL4sFnoVQnqaA==}
+
+  impit-darwin-arm64@0.7.1:
+    resolution: {integrity: sha512-3TqFaC+hYqC/2GnSV4qKxNak4fbMJwURkybJ2TLH1NZNWypkIFL1/Qg7NLmtcOn17D7Kfwmvt2Wcmscsmhf1uA==}
+    engines: {node: '>= 10'}
+    cpu: [arm64]
+    os: [darwin]
+
+  impit-darwin-x64@0.7.1:
+    resolution: {integrity: sha512-TYQKEV3xIN3t745yPhmEq0zPILBtSho8RcPxzL3CRwDThzgNvCfES/Zj3wvZbwiooZqXy61wscDKDYIkUKnM+A==}
+    engines: {node: '>= 10'}
+    cpu: [x64]
+    os: [darwin]
+
+  impit-linux-arm64-gnu@0.7.1:
+    resolution: {integrity: sha512-h2w42FzF7hBxNL7rRTUe/KapHeXkcUPF4vqtWLFdTa3WgEXl8RriY48JFcx2g1jqO5eLo+sepeD3asYG+YLkaw==}
+    engines: {node: '>= 10'}
+    cpu: [arm64]
+    os: [linux]
+    libc: [glibc]
+
+  impit-linux-arm64-musl@0.7.1:
+    resolution: {integrity: sha512-CkCdGnEK0AQjYBdSsNWkLw5yqT7RDpJoImekBidtRDTiSY/O5+5saBFi4K8YbElJkHeh/6F3heriLzRahiXQOA==}
+    engines: {node: '>= 10'}
+    cpu: [arm64]
+    os: [linux]
+    libc: [musl]
+
+  impit-linux-x64-gnu@0.7.1:
+    resolution: {integrity: sha512-vmTifxxCp7FPh82t1EqbVnWFpXIS6k9Ls5QKuf7FTzejj6YFNfsvPxxGsNpsTZB3C9V7zb5kIr0kTVIcEJbU/A==}
+    engines: {node: '>= 10'}
+    cpu: [x64]
+    os: [linux]
+    libc: [glibc]
+
+  impit-linux-x64-musl@0.7.1:
+    resolution: {integrity: sha512-1wgAfOgykI3SBNbVaW+KM88Fxpew5viLZBG5YQhDfALAADqty4Sk4fPECUEfOYtPzZRi4ikE9Rs0XHKWhoGgYA==}
+    engines: {node: '>= 10'}
+    cpu: [x64]
+    os: [linux]
+    libc: [musl]
+
+  impit-win32-arm64-msvc@0.7.1:
+    resolution: {integrity: sha512-6GadQitHSJfESMKnAsny8Wuv3QWCYWrIFRHOEpol59PVGTPTQI9+eu2QREqUVufgf7YEzAB2VKXyPQp4tFbCnQ==}
+    engines: {node: '>= 10'}
+    cpu: [arm64]
+    os: [win32]
+
+  impit-win32-x64-msvc@0.7.1:
+    resolution: {integrity: sha512-vl5w/7lSMVICTiJY3jPJfmj1DEfr2xPFHGJqYZj0xUVOrzocpCIN0u+JVzt2Azizjn4YC2g1GIi+uPZeil0p3Q==}
+    engines: {node: '>= 10'}
+    cpu: [x64]
+    os: [win32]
+
+  impit@0.7.1:
+    resolution: {integrity: sha512-fdnrZZFToKJGQCP9kIt+BQsk8WTTgb4MZE8FM01047U/GCcSu6b/MljAyyPFNb7N3sY2Kcl9unP2DT+/asFPNw==}
+    engines: {node: '>= 20'}
+
+  inherits@2.0.4:
+    resolution: {integrity: sha512-k/vGaX4/Yla3WzyMCvTQOXYeIHvqOKtnqBduzTHpzpQZzAskKMhZ2K+EnBiSM9zGSoIFeMpXKxa4dYeZIQqewQ==}
+
+  ini@1.3.8:
+    resolution: {integrity: sha512-JV/yugV2uzW5iMRSiZAyDtQd+nxtUnjeLt0acNdw98kKLrvuRVyB80tsREOE7yvGVgalhZ6RNXCmEHkUKBKxew==}
+
+  ip-address@10.1.0:
+    resolution: {integrity: sha512-XXADHxXmvT9+CRxhXg56LJovE+bmWnEWB78LB83VZTprKTmaC5QfruXocxzTZ2Kl0DNwKuBdlIhjL8LeY8Sf8Q==}
+    engines: {node: '>= 12'}
+
+  is-callable@1.2.7:
+    resolution: {integrity: sha512-1BC0BVFhS/p0qtw6enp8e+8OD0UrK0oFLztSjNzhcKA3WDuJxxAPXzPuPtKkjEY9UUoEWlX/8fgKeu2S8i9JTA==}
+    engines: {node: '>= 0.4'}
+
+  is-obj@2.0.0:
+    resolution: {integrity: sha512-drqDG3cbczxxEJRoOXcOjtdp1J/lyp1mNn0xaznRs8+muBhgQcrnbspox5X5fOw0HnMnbfDzvnEMEtqDEJEo8w==}
+    engines: {node: '>=8'}
+
+  is-standalone-pwa@0.1.1:
+    resolution: {integrity: sha512-9Cbovsa52vNQCjdXOzeQq5CnCbAcRk05aU62K20WO372NrTv0NxibLFCK6lQ4/iZEFdEA3p3t2VNOn8AJ53F5g==}
+
+  is-stream@4.0.1:
+    resolution: {integrity: sha512-Dnz92NInDqYckGEUJv689RbRiTSEHCQ7wOVeALbkOz999YpqT46yMRIGtSNl2iCL1waAZSx40+h59NV/EwzV/A==}
+    engines: {node: '>=18'}
+
+  is-typed-array@1.1.15:
+    resolution: {integrity: sha512-p3EcsicXjit7SaskXHs1hA91QxgTw46Fv6EFKKGS5DRFLD8yKnohjF3hxoju94b/OcMZoQukzpPpBE9uLVKzgQ==}
+    engines: {node: '>= 0.4'}
+
+  isarray@1.0.0:
+    resolution: {integrity: sha512-VLghIWNM6ELQzo7zwmcg0NmTVyWKYjvIeM83yjp0wRDTmUnrM678fQbcKBo6n2CJEF0szoG//ytg+TKla89ALQ==}
+
+  isarray@2.0.5:
+    resolution: {integrity: sha512-xHjhDr3cNBK0BzdUJSPXZntQUx/mwMS5Rw4A7lPJ90XGAO6ISP/ePDNuo0vhqOZU+UD5JoodwCAAoZQd3FeAKw==}
+
+  keyv@5.5.4:
+    resolution: {integrity: sha512-eohl3hKTiVyD1ilYdw9T0OiB4hnjef89e3dMYKz+mVKDzj+5IteTseASUsOB+EU9Tf6VNTCjDePcP6wkDGmLKQ==}
+
+  language-subtag-registry@0.3.23:
+    resolution: {integrity: sha512-0K65Lea881pHotoGEa5gDlMxt3pctLi2RplBb7Ezh4rRdLEOtgi7n4EwK9lamnUCkKBqaeKRVebTq6BAxSkpXQ==}
+
+  language-tags@2.1.0:
+    resolution: {integrity: sha512-D4CgpyCt+61f6z2jHjJS1OmZPviAWM57iJ9OKdFFWSNgS7Udj9QVWqyGs/cveVNF57XpZmhSvMdVIV5mjLA7Vg==}
+    engines: {node: '>=22'}
+
+  lodash.isequal@4.5.0:
+    resolution: {integrity: sha512-pDo3lu8Jhfjqls6GkMgpahsF9kCyayhgykjyLMNFTKWrpVdAQtYyB4muAMWozBB4ig/dtWAmsMxLEI8wuz+DYQ==}
+    deprecated: This package is deprecated. Use require('node:util').isDeepStrictEqual instead.
+
+  lowercase-keys@3.0.0:
+    resolution: {integrity: sha512-ozCC6gdQ+glXOQsveKD0YsDy8DSQFjDTz4zyzEHNV5+JP5D62LmfDZ6o1cycFx9ouG940M5dE8C8CTewdj2YWQ==}
+    engines: {node: ^12.20.0 || ^14.13.1 || >=16.0.0}
+
+  lru-cache@11.2.2:
+    resolution: {integrity: sha512-F9ODfyqML2coTIsQpSkRHnLSZMtkU8Q+mSfcaIyKwy58u+8k5nvAYeiNhsyMARvzNcXJ9QfWVrcPsC9e9rAxtg==}
+    engines: {node: 20 || >=22}
+
+  math-intrinsics@1.1.0:
+    resolution: {integrity: sha512-/IXtbwEk5HTPyEwyKX6hGkYXxM9nbj64B+ilVJnC/R6B0pH5G4V3b0pVbL7DBj4tkhBAppbQUlf6F6Xl9LHu1g==}
+    engines: {node: '>= 0.4'}
+
+  maxmind@5.0.1:
+    resolution: {integrity: sha512-hYxQxvHkBUlyF34f7IlQOb60rytezCi2oZ8H/BtZpcoodXTlcK1eLgf7kY2TofHqBC3o+Hqtvde9kS72gFQSDw==}
+    engines: {node: '>=12', npm: '>=6'}
+
+  mimic-response@3.1.0:
+    resolution: {integrity: sha512-z0yWI+4FDrrweS8Zmt4Ej5HdJmky15+L2e6Wgn3+iK5fWzb6T3fhNFq2+MeTRb064c6Wr4N/wv0DzQTjNzHNGQ==}
+    engines: {node: '>=10'}
+
+  mimic-response@4.0.0:
+    resolution: {integrity: sha512-e5ISH9xMYU0DzrT+jl8q2ze9D6eWBto+I8CNpe+VI+K2J/F/k3PdkdTdz4wvGVH4NTpo+NRYTVIuMQEMMcsLqg==}
+    engines: {node: ^12.20.0 || ^14.13.1 || >=16.0.0}
+
+  minimatch@10.1.1:
+    resolution: {integrity: sha512-enIvLvRAFZYXJzkCYG5RKmPfrFArdLv+R+lbQ53BmIMLIry74bjKzX6iHAm8WYamJkhSSEabrWN5D97XnKObjQ==}
+    engines: {node: 20 || >=22}
+
+  minimist@1.2.8:
+    resolution: {integrity: sha512-2yyAR8qBkN3YuheJanUpWC5U3bb5osDywNB8RzDVlDwDHbocAJveqqj1u8+SVD7jkWT4yvsHCpWqqWqAxb0zCA==}
+
+  minipass@7.1.2:
+    resolution: {integrity: sha512-qOOzS1cBTWYF4BH8fVePDBOO9iptMnGUEZwNc/cMWnTV2nVLZ7VoNWEPHkYczZA0pdoA7dl6e7FL659nX9S2aw==}
+    engines: {node: '>=16 || 14 >=14.17'}
+
+  mkdirp-classic@0.5.3:
+    resolution: {integrity: sha512-gKLcREMhtuZRwRAfqP3RFW+TK4JqApVBtOIftVgjuABpAtpxhPGaDcfvbhNvD0B8iD1oUr/txX35NjcaY6Ns/A==}
+
+  mmdb-lib@3.0.1:
+    resolution: {integrity: sha512-dyAyMR+cRykZd1mw5altC9f4vKpCsuywPwo8l/L5fKqDay2zmqT0mF/BvUoXnQiqGn+nceO914rkPKJoyFnGxA==}
+    engines: {node: '>=10', npm: '>=6'}
+
+  ms@2.1.3:
+    resolution: {integrity: sha512-6FlzubTLZG3J2a/NVCAleEhjzq5oxgHyaCU9yYXvcLsvoVaHJq/s5xXI6/XXP6tz7R9xAOtHnSO/tXtF3WRTlA==}
+
+  mute-stream@3.0.0:
+    resolution: {integrity: sha512-dkEJPVvun4FryqBmZ5KhDo0K9iDXAwn08tMLDinNdRBNPcYEDiWYysLcc6k3mjTMlbP9KyylvRpd4wFtwrT9rw==}
+    engines: {node: ^20.17.0 || >=22.9.0}
+
+  napi-build-utils@2.0.0:
+    resolution: {integrity: sha512-GEbrYkbfF7MoNaoh2iGG84Mnf/WZfB0GdGEsM8wz7Expx/LlWf5U8t9nvJKXSp3qr5IsEbK04cBGhol/KwOsWA==}
+
+  node-abi@3.85.0:
+    resolution: {integrity: sha512-zsFhmbkAzwhTft6nd3VxcG0cvJsT70rL+BIGHWVq5fi6MwGrHwzqKaxXE+Hl2GmnGItnDKPPkO5/LQqjVkIdFg==}
+    engines: {node: '>=10'}
+
+  node-releases@2.0.27:
+    resolution: {integrity: sha512-nmh3lCkYZ3grZvqcCH+fjmQ7X+H0OeZgP40OierEaAptX4XofMh5kwNbWh7lBduUzCcV/8kZ+NDLCwm2iorIlA==}
+
+  normalize-url@8.1.0:
+    resolution: {integrity: sha512-X06Mfd/5aKsRHc0O0J5CUedwnPmnDtLF2+nq+KN9KSDlJHkPuh0JUviWjEWMe0SW/9TDdSLVPuk7L5gGTIA1/w==}
+    engines: {node: '>=14.16'}
+
+  once@1.4.0:
+    resolution: {integrity: sha512-lNaJgI+2Q5URQBkccEKHTQOPaXdUxnZZElQTZY0MFUAuaEqe1E+Nyvgdz/aIyNi6Z9MzO5dv1H8n58/GELp3+w==}
+
+  ow@0.28.2:
+    resolution: {integrity: sha512-dD4UpyBh/9m4X2NVjA+73/ZPBRF+uF4zIMFvvQsabMiEK8x41L3rQ8EENOi35kyyoaJwNxEeJcP6Fj1H4U409Q==}
+    engines: {node: '>=12'}
+
+  ow@1.1.1:
+    resolution: {integrity: sha512-sJBRCbS5vh1Jp9EOgwp1Ws3c16lJrUkJYlvWTYC03oyiYVwS/ns7lKRWow4w4XjDyTrA2pplQv4B2naWSR6yDA==}
+    engines: {node: '>=14.16'}
+
+  p-cancelable@4.0.1:
+    resolution: {integrity: sha512-wBowNApzd45EIKdO1LaU+LrMBwAcjfPaYtVzV3lmfM3gf8Z4CHZsiIqlM8TZZ8okYvh5A1cP6gTfCRQtwUpaUg==}
+    engines: {node: '>=14.16'}
+
+  path-scurry@2.0.1:
+    resolution: {integrity: sha512-oWyT4gICAu+kaA7QWk/jvCHWarMKNs6pXOGWKDTr7cw4IGcUbW+PeTfbaQiLGheFRpjo6O9J0PmyMfQPjH71oA==}
+    engines: {node: 20 || >=22}
+
+  pend@1.2.0:
+    resolution: {integrity: sha512-F3asv42UuXchdzt+xXqfW1OGlVBe+mxa2mqI0pg5yAHZPvFmY3Y6drSf/GQ1A86WgWEN9Kzh/WrgKa6iGcHXLg==}
+
+  picocolors@1.1.1:
+    resolution: {integrity: sha512-xceH2snhtb5M9liqDsmEw56le376mTZkEX/jEb/RxNFyegNul7eNslCXP9FDj/Lcu0X8KEyMceP2ntpaHrDEVA==}
+
+  playwright-core@1.57.0:
+    resolution: {integrity: sha512-agTcKlMw/mjBWOnD6kFZttAAGHgi/Nw0CZ2o6JqWSbMlI219lAFLZZCyqByTsvVAJq5XA5H8cA6PrvBRpBWEuQ==}
+    engines: {node: '>=18'}
+    hasBin: true
+
+  playwright@1.57.0:
+    resolution: {integrity: sha512-ilYQj1s8sr2ppEJ2YVadYBN0Mb3mdo9J0wQ+UuDhzYqURwSoW4n1Xs5vs7ORwgDGmyEh33tRMeS8KhdkMoLXQw==}
+    engines: {node: '>=18'}
+    hasBin: true
+
+  possible-typed-array-names@1.1.0:
+    resolution: {integrity: sha512-/+5VFTchJDoVj3bhoqi6UeymcD00DAwb1nJwamzPvHEszJ4FpF6SNNbUbOS8yI56qHzdV8eK0qEfOSiodkTdxg==}
+    engines: {node: '>= 0.4'}
+
+  prebuild-install@7.1.3:
+    resolution: {integrity: sha512-8Mf2cbV7x1cXPUILADGI3wuhfqWvtiLA1iclTDbFRZkgRQS0NqsPZphna9V+HyTEadheuPmjaJMsbzKQFOzLug==}
+    engines: {node: '>=10'}
+    hasBin: true
+
+  process-nextick-args@2.0.1:
+    resolution: {integrity: sha512-3ouUOpQhtgrbOa17J7+uxOTpITYWaGP7/AhoR3+A+/1e9skrzelGi/dXzEYyvbxubEF6Wn2ypscTKiKJFFn1ag==}
+
+  progress@2.0.3:
+    resolution: {integrity: sha512-7PiHtLll5LdnKIMw100I+8xJXR5gW2QwWYkT6iJva0bXitZKa/XMrSbdmg3r2Xnaidz9Qumd0VPaMrZlF9V9sA==}
+    engines: {node: '>=0.4.0'}
+
+  proxy-chain@2.6.0:
+    resolution: {integrity: sha512-+NpVKSk68j8sQJG2tBbFuJxMzKTlqeCXXFbqvlyiFhnmxdcYJSv4XZzUSIfwIUwR3D0T8fEJqrA4C7yykU40Pw==}
+    engines: {node: '>=14'}
+
+  pump@3.0.3:
+    resolution: {integrity: sha512-todwxLMY7/heScKmntwQG8CXVkWUOdYxIvY2s0VWAAMh/nd8SoYiRaKjlr7+iCs984f2P8zvrfWcDDYVb73NfA==}
+
+  quick-lru@5.1.1:
+    resolution: {integrity: sha512-WuyALRjWPDGtt/wzJiadO5AXY+8hZ80hVpe6MyivgraREW751X3SbhRvG3eLKOYN+8VEvqLcf3wdnt44Z4S4SA==}
+    engines: {node: '>=10'}
+
+  quick-lru@7.3.0:
+    resolution: {integrity: sha512-k9lSsjl36EJdK7I06v7APZCbyGT2vMTsYSRX1Q2nbYmnkBqgUhRkAuzH08Ciotteu/PLJmIF2+tti7o3C/ts2g==}
+    engines: {node: '>=18'}
+
+  rc@1.2.8:
+    resolution: {integrity: sha512-y3bGgqKj3QBdxLbLkomlohkvsA8gdAiUQlSBJnBhfn+BPxg4bc62d8TcBW15wavDfgexCgccckhcZvywyQYPOw==}
+    hasBin: true
+
+  readable-stream@2.3.8:
+    resolution: {integrity: sha512-8p0AUk4XODgIewSi0l8Epjs+EVnWiK7NoDIEGU0HhE7+ZyY8D1IMY7odu5lRrFXGg71L15KG8QrPmum45RTtdA==}
+
+  readable-stream@3.6.2:
+    resolution: {integrity: sha512-9u/sniCrY3D5WdsERHzHE4G2YCXqoG5FTHUiCC4SIbr6XcLZBY05ya9EKjYek9O5xOAwjGq+1JdGBAS7Q9ScoA==}
+    engines: {node: '>= 6'}
+
+  resolve-alpn@1.2.1:
+    resolution: {integrity: sha512-0a1F4l73/ZFZOakJnQ3FvkJ2+gSTQWz/r2KE5OdDY0TxPm5h4GkqkWWfM47T7HsbnOtcJVEF4epCVy6u7Q3K+g==}
+
+  responselike@4.0.2:
+    resolution: {integrity: sha512-cGk8IbWEAnaCpdAt1BHzJ3Ahz5ewDJa0KseTsE3qIRMJ3C698W8psM7byCeWVpd/Ha7FUYzuRVzXoKoM6nRUbA==}
+    engines: {node: '>=20'}
+
+  safe-buffer@5.1.2:
+    resolution: {integrity: sha512-Gd2UZBJDkXlY7GbJxfsE8/nvKkUEU1G38c1siN6QP6a9PT9MmHB8GnpscSmMJSoF8LOIrt8ud/wPtojys4G6+g==}
+
+  safe-buffer@5.2.1:
+    resolution: {integrity: sha512-rp3So07KcdmmKbGvgaNxQSJr7bGVSVk5S9Eq1F+ppbRo70+YeaDxkw5Dd8NPN+GD6bjnYm2VuPuCXmpuYvmCXQ==}
+
+  safer-buffer@2.1.2:
+    resolution: {integrity: sha512-YZo3K82SD7Riyi0E1EQPojLz7kpepnSQI9IyPbHHg1XXXevb5dJI7tpyN2ADxGcQbHG7vcyRHk0cbwqcQriUtg==}
+
+  sax@1.4.3:
+    resolution: {integrity: sha512-yqYn1JhPczigF94DMS+shiDMjDowYO6y9+wB/4WgO0Y19jWYk0lQ4tuG5KI7kj4FTp1wxPj5IFfcrz/s1c3jjQ==}
+
+  semver@7.7.3:
+    resolution: {integrity: sha512-SdsKMrI9TdgjdweUSR9MweHA4EJ8YxHn8DFaDisvhVlUOe4BF1tLD7GAj0lIqWVl+dPb/rExr0Btby5loQm20Q==}
+    engines: {node: '>=10'}
+    hasBin: true
+
+  set-function-length@1.2.2:
+    resolution: {integrity: sha512-pgRc4hJ4/sNjWCSS9AmnS40x3bNMDTknHgL5UaMBTMyJnU90EgWh1Rz+MC9eFu4BuN/UwZjKQuY/1v3rM7HMfg==}
+    engines: {node: '>= 0.4'}
+
+  sharp@0.34.5:
+    resolution: {integrity: sha512-Ou9I5Ft9WNcCbXrU9cMgPBcCK8LiwLqcbywW3t4oDV37n1pzpuNLsYiAV8eODnjbtQlSDwZ2cUEeQz4E54Hltg==}
+    engines: {node: ^18.17.0 || ^20.3.0 || >=21.0.0}
+
+  signal-exit@4.1.0:
+    resolution: {integrity: sha512-bzyZ1e88w9O1iNJbKnOlvYTrWPDl46O1bG0D3XInv+9tkPrxrN8jUUTiFlDkkmKWgn1M6CfIA13SuGqOa9Korw==}
+    engines: {node: '>=14'}
+
+  simple-concat@1.0.1:
+    resolution: {integrity: sha512-cSFtAPtRhljv69IK0hTVZQ+OfE9nePi/rtJmw5UjHeVyVroEqJXP1sFztKUy1qU+xvz3u/sfYJLa947b7nAN2Q==}
+
+  simple-get@4.0.1:
+    resolution: {integrity: sha512-brv7p5WgH0jmQJr1ZDDfKDOSeWWg+OVypG99A/5vYGPqJ6pxiaHLy8nxtFjBA7oMa01ebA9gfh1uMCFqOuXxvA==}
+
+  smart-buffer@4.2.0:
+    resolution: {integrity: sha512-94hK0Hh8rPqQl2xXc3HsaBoOXKV20MToPkcXvwbISWLEs+64sBq5kFgn2kJDHb1Pry9yrP0dxrCI9RRci7RXKg==}
+    engines: {node: '>= 6.0.0', npm: '>= 3.0.0'}
+
+  socks-proxy-agent@8.0.5:
+    resolution: {integrity: sha512-HehCEsotFqbPW9sJ8WVYB6UbmIMv7kUUORIF2Nncq4VQvBfNBLibW9YZR5dlYCSUhwcD628pRllm7n+E+YTzJw==}
+    engines: {node: '>= 14'}
+
+  socks@2.8.7:
+    resolution: {integrity: sha512-HLpt+uLy/pxB+bum/9DzAgiKS8CX1EvbWxI4zlmgGCExImLdiad2iCwXT5Z4c9c3Eq8rP2318mPW2c+QbtjK8A==}
+    engines: {node: '>= 10.0.0', npm: '>= 3.0.0'}
+
+  streamifier@0.1.1:
+    resolution: {integrity: sha512-zDgl+muIlWzXNsXeyUfOk9dChMjlpkq0DRsxujtYPgyJ676yQ8jEm6zzaaWHFDg5BNcLuif0eD2MTyJdZqXpdg==}
+    engines: {node: '>=0.10'}
+
+  string-width@7.2.0:
+    resolution: {integrity: sha512-tsaTIkKW9b4N+AEj+SVA+WhJzV7/zMhcSu78mLKWSk7cXMOSHsBKFWUs0fWwq8QyK3MgJBQRX6Gbi4kYbdvGkQ==}
+    engines: {node: '>=18'}
+
+  string_decoder@1.1.1:
+    resolution: {integrity: sha512-n/ShnvDi6FHbbVfviro+WojiFzv+s8MPMHBczVePfUpDJLwoLT0ht1l4YwBCbi8pJAveEEdnkHyPyTP/mzRfwg==}
+
+  string_decoder@1.3.0:
+    resolution: {integrity: sha512-hkRX8U1WjJFd8LsDJ2yQ/wWWxaopEsABU1XfkM8A+j0+85JAGppt16cr1Whg6KIbb4okU6Mql6BOj+uup/wKeA==}
+
+  strip-ansi@7.1.2:
+    resolution: {integrity: sha512-gmBGslpoQJtgnMAvOVqGZpEz9dyoKTCzy2nfz/n8aIFhN/jCE/rCmcxabB6jOOHV+0WNnylOxaxBQPSvcWklhA==}
+    engines: {node: '>=12'}
+
+  strip-json-comments@2.0.1:
+    resolution: {integrity: sha512-4gB8na07fecVVkOI6Rs4e7T6NOTki5EmL7TUduTs6bu3EdnSycntVJ4re8kgZA+wx9IueI2Y11bfbgwtzuE0KQ==}
+    engines: {node: '>=0.10.0'}
+
+  tar-fs@2.1.4:
+    resolution: {integrity: sha512-mDAjwmZdh7LTT6pNleZ05Yt65HC3E+NiQzl672vQG38jIrehtJk/J3mNwIg+vShQPcLF/LV7CMnDW6vjj6sfYQ==}
+
+  tar-stream@1.6.2:
+    resolution: {integrity: sha512-rzS0heiNf8Xn7/mpdSVVSMAWAoy9bfb1WOTYC78Z0UQKeKa/CWS8FOq0lKGNa8DWKAn9gxjCvMLYc5PGXYlK2A==}
+    engines: {node: '>= 0.8.0'}
+
+  tar-stream@2.2.0:
+    resolution: {integrity: sha512-ujeqbceABgwMZxEJnk2HDY2DlnUZ+9oEcb1KzTVfYHio0UE6dG71n60d8D2I4qNvleWrrXpmjpt7vZeF1LnMZQ==}
+    engines: {node: '>=6'}
+
+  tiny-lru@11.4.5:
+    resolution: {integrity: sha512-hkcz3FjNJfKXjV4mjQ1OrXSLAehg8Hw+cEZclOVT+5c/cWQWImQ9wolzTjth+dmmDe++p3bme3fTxz6Q4Etsqw==}
+    engines: {node: '>=12'}
+
+  to-buffer@1.2.2:
+    resolution: {integrity: sha512-db0E3UJjcFhpDhAF4tLo03oli3pwl3dbnzXOUIlRKrp+ldk/VUxzpWYZENsw2SZiuBjHAk7DfB0VU7NKdpb6sw==}
+    engines: {node: '>= 0.4'}
+
+  tslib@2.8.1:
+    resolution: {integrity: sha512-oJFu94HQb+KVduSUQL7wnpmqnfmLsOA/nAh6b6EH0wCEoK0/mPeXU6c3wKDV83MkOuHPRHtSXKKU99IBazS/2w==}
+
+  tunnel-agent@0.6.0:
+    resolution: {integrity: sha512-McnNiV1l8RYeY8tBgEpuodCC1mLUdbSN+CYBL7kJsJNInOP8UjDDEwdk6Mw60vdLLrr5NHKZhMAOSrR2NZuQ+w==}
+
+  type-fest@2.19.0:
+    resolution: {integrity: sha512-RAH822pAdBgcNMAfWnCBU3CFZcfZ/i1eZjwFU/dsLKumyuuP3niueg2UAukXYF0E2AAoc82ZSSf9J0WQBinzHA==}
+    engines: {node: '>=12.20'}
+
+  type-fest@4.41.0:
+    resolution: {integrity: sha512-TeTSQ6H5YHvpqVwBRcnLDCBnDOHWYu7IvGbHT6N8AOymcr9PJGjc1GTtiWZTYg0NCgYwvnYWEkVChQAr9bjfwA==}
+    engines: {node: '>=16'}
+
+  typed-array-buffer@1.0.3:
+    resolution: {integrity: sha512-nAYYwfY3qnzX30IkA6AQZjVbtK6duGontcQm1WSG1MD94YLqK0515GNApXkoxKOWMusVssAHWLh9SeaoefYFGw==}
+    engines: {node: '>= 0.4'}
+
+  ua-is-frozen@0.1.2:
+    resolution: {integrity: sha512-RwKDW2p3iyWn4UbaxpP2+VxwqXh0jpvdxsYpZ5j/MLLiQOfbsV5shpgQiw93+KMYQPcteeMQ289MaAFzs3G9pw==}
+
+  ua-parser-js@2.0.6:
+    resolution: {integrity: sha512-EmaxXfltJaDW75SokrY4/lXMrVyXomE/0FpIIqP2Ctic93gK7rlme55Cwkz8l3YZ6gqf94fCU7AnIkidd/KXPg==}
+    hasBin: true
+
+  undici-types@7.16.0:
+    resolution: {integrity: sha512-Zz+aZWSj8LE6zoxD+xrjh4VfkIG8Ya6LvYkZqtUQGJPZjYl53ypCaUwWqo7eI0x66KBGeRo+mlBEkMSeSZ38Nw==}
+
+  update-browserslist-db@1.1.4:
+    resolution: {integrity: sha512-q0SPT4xyU84saUX+tomz1WLkxUbuaJnR1xWt17M7fJtEJigJeWUNGUqrauFXsHnqev9y9JTRGwk13tFBuKby4A==}
+    hasBin: true
+    peerDependencies:
+      browserslist: '>= 4.21.0'
+
+  util-deprecate@1.0.2:
+    resolution: {integrity: sha512-EPD5q1uXyFxJpCrLnCc1nHnq3gOa6DZBocAIiI2TaSCA7VCJ1UJDMagCzIkXNsUYfD1daK//LTEQ8xiIbrHtcw==}
+
+  vali-date@1.0.0:
+    resolution: {integrity: sha512-sgECfZthyaCKW10N0fm27cg8HYTFK5qMWgypqkXMQ4Wbl/zZKx7xZICgcoxIIE+WFAP/MBL2EFwC/YvLxw3Zeg==}
+    engines: {node: '>=0.10.0'}
+
+  which-typed-array@1.1.19:
+    resolution: {integrity: sha512-rEvr90Bck4WZt9HHFC4DJMsjvu7x+r6bImz0/BrbWb7A2djJ8hnZMrWnHo9F8ssv0OMErasDhftrfROTyqSDrw==}
+    engines: {node: '>= 0.4'}
+
+  wrap-ansi@9.0.2:
+    resolution: {integrity: sha512-42AtmgqjV+X1VpdOfyTGOYRi0/zsoLqtXQckTmqTeybT+BDIbM/Guxo7x3pE2vtpr1ok6xRqM9OpBe+Jyoqyww==}
+    engines: {node: '>=18'}
+
+  wrappy@1.0.2:
+    resolution: {integrity: sha512-l4Sp/DRseor9wL6EvV2+TuQn63dMkPjZ/sp9XkghTEbV9KlPS1xUsZ3u7/IQO4wxtcFB4bgpQPRcR3QCvezPcQ==}
+
+  xml2js@0.6.2:
+    resolution: {integrity: sha512-T4rieHaC1EXcES0Kxxj4JWgaUQHDk+qwHcYOCFHfiwKz7tOVPLq7Hjq9dM1WCMhylqMEfP7hMcOIChvotiZegA==}
+    engines: {node: '>=4.0.0'}
+
+  xmlbuilder@11.0.1:
+    resolution: {integrity: sha512-fDlsI/kFEx7gLvbecc0/ohLG50fugQp8ryHzMTuW9vSa1GJ0XYWKnhsUx7oie3G98+r56aTQIUB4kht42R3JvA==}
+    engines: {node: '>=4.0'}
+
+  xtend@4.0.2:
+    resolution: {integrity: sha512-LKYU1iAXJXUgAXn9URjiu+MWhyUXHsvfp7mcuYm9dSUKK0/CjtrUwFAxD82/mCWbtLsGjFIad0wIsod4zrTAEQ==}
+    engines: {node: '>=0.4'}
+
+  yaml@2.8.2:
+    resolution: {integrity: sha512-mplynKqc1C2hTVYxd0PU2xQAc22TI1vShAYGksCCfxbn/dFwnHTNi1bvYsBTkhdUNtGIf5xNOg938rrSSYvS9A==}
+    engines: {node: '>= 14.6'}
+    hasBin: true
+
+  yazl@2.5.1:
+    resolution: {integrity: sha512-phENi2PLiHnHb6QBVot+dJnaAZ0xosj7p3fWl+znIjBDlnMI2PsZCJZ306BPTFOaHf5qdDEI8x5qFrSOBN5vrw==}
+
+snapshots:
+
+  '@eggjs/yauzl@2.11.0':
+    dependencies:
+      buffer-crc32: 0.2.13
+      fd-slicer2: 1.2.0
+
+  '@emnapi/runtime@1.7.1':
+    dependencies:
+      tslib: 2.8.1
+    optional: true
+
+  '@img/colour@1.0.0': {}
+
+  '@img/sharp-darwin-arm64@0.34.5':
+    optionalDependencies:
+      '@img/sharp-libvips-darwin-arm64': 1.2.4
+    optional: true
+
+  '@img/sharp-darwin-x64@0.34.5':
+    optionalDependencies:
+      '@img/sharp-libvips-darwin-x64': 1.2.4
+    optional: true
+
+  '@img/sharp-libvips-darwin-arm64@1.2.4':
+    optional: true
+
+  '@img/sharp-libvips-darwin-x64@1.2.4':
+    optional: true
+
+  '@img/sharp-libvips-linux-arm64@1.2.4':
+    optional: true
+
+  '@img/sharp-libvips-linux-arm@1.2.4':
+    optional: true
+
+  '@img/sharp-libvips-linux-ppc64@1.2.4':
+    optional: true
+
+  '@img/sharp-libvips-linux-riscv64@1.2.4':
+    optional: true
+
+  '@img/sharp-libvips-linux-s390x@1.2.4':
+    optional: true
+
+  '@img/sharp-libvips-linux-x64@1.2.4':
+    optional: true
+
+  '@img/sharp-libvips-linuxmusl-arm64@1.2.4':
+    optional: true
+
+  '@img/sharp-libvips-linuxmusl-x64@1.2.4':
+    optional: true
+
+  '@img/sharp-linux-arm64@0.34.5':
+    optionalDependencies:
+      '@img/sharp-libvips-linux-arm64': 1.2.4
+    optional: true
+
+  '@img/sharp-linux-arm@0.34.5':
+    optionalDependencies:
+      '@img/sharp-libvips-linux-arm': 1.2.4
+    optional: true
+
+  '@img/sharp-linux-ppc64@0.34.5':
+    optionalDependencies:
+      '@img/sharp-libvips-linux-ppc64': 1.2.4
+    optional: true
+
+  '@img/sharp-linux-riscv64@0.34.5':
+    optionalDependencies:
+      '@img/sharp-libvips-linux-riscv64': 1.2.4
+    optional: true
+
+  '@img/sharp-linux-s390x@0.34.5':
+    optionalDependencies:
+      '@img/sharp-libvips-linux-s390x': 1.2.4
+    optional: true
+
+  '@img/sharp-linux-x64@0.34.5':
+    optionalDependencies:
+      '@img/sharp-libvips-linux-x64': 1.2.4
+    optional: true
+
+  '@img/sharp-linuxmusl-arm64@0.34.5':
+    optionalDependencies:
+      '@img/sharp-libvips-linuxmusl-arm64': 1.2.4
+    optional: true
+
+  '@img/sharp-linuxmusl-x64@0.34.5':
+    optionalDependencies:
+      '@img/sharp-libvips-linuxmusl-x64': 1.2.4
+    optional: true
+
+  '@img/sharp-wasm32@0.34.5':
+    dependencies:
+      '@emnapi/runtime': 1.7.1
+    optional: true
+
+  '@img/sharp-win32-arm64@0.34.5':
+    optional: true
+
+  '@img/sharp-win32-ia32@0.34.5':
+    optional: true
+
+  '@img/sharp-win32-x64@0.34.5':
+    optional: true
+
+  '@inquirer/ansi@2.0.1': {}
+
+  '@inquirer/checkbox@5.0.1(@types/node@24.10.1)':
+    dependencies:
+      '@inquirer/ansi': 2.0.1
+      '@inquirer/core': 11.0.1(@types/node@24.10.1)
+      '@inquirer/figures': 2.0.1
+      '@inquirer/type': 4.0.1(@types/node@24.10.1)
+    optionalDependencies:
+      '@types/node': 24.10.1
+
+  '@inquirer/confirm@6.0.1(@types/node@24.10.1)':
+    dependencies:
+      '@inquirer/core': 11.0.1(@types/node@24.10.1)
+      '@inquirer/type': 4.0.1(@types/node@24.10.1)
+    optionalDependencies:
+      '@types/node': 24.10.1
+
+  '@inquirer/core@11.0.1(@types/node@24.10.1)':
+    dependencies:
+      '@inquirer/ansi': 2.0.1
+      '@inquirer/figures': 2.0.1
+      '@inquirer/type': 4.0.1(@types/node@24.10.1)
+      cli-width: 4.1.0
+      mute-stream: 3.0.0
+      signal-exit: 4.1.0
+      wrap-ansi: 9.0.2
+    optionalDependencies:
+      '@types/node': 24.10.1
+
+  '@inquirer/editor@5.0.1(@types/node@24.10.1)':
+    dependencies:
+      '@inquirer/core': 11.0.1(@types/node@24.10.1)
+      '@inquirer/external-editor': 2.0.1(@types/node@24.10.1)
+      '@inquirer/type': 4.0.1(@types/node@24.10.1)
+    optionalDependencies:
+      '@types/node': 24.10.1
+
+  '@inquirer/expand@5.0.1(@types/node@24.10.1)':
+    dependencies:
+      '@inquirer/core': 11.0.1(@types/node@24.10.1)
+      '@inquirer/type': 4.0.1(@types/node@24.10.1)
+    optionalDependencies:
+      '@types/node': 24.10.1
+
+  '@inquirer/external-editor@2.0.1(@types/node@24.10.1)':
+    dependencies:
+      chardet: 2.1.1
+      iconv-lite: 0.7.0
+    optionalDependencies:
+      '@types/node': 24.10.1
+
+  '@inquirer/figures@2.0.1': {}
+
+  '@inquirer/input@5.0.1(@types/node@24.10.1)':
+    dependencies:
+      '@inquirer/core': 11.0.1(@types/node@24.10.1)
+      '@inquirer/type': 4.0.1(@types/node@24.10.1)
+    optionalDependencies:
+      '@types/node': 24.10.1
+
+  '@inquirer/number@4.0.1(@types/node@24.10.1)':
+    dependencies:
+      '@inquirer/core': 11.0.1(@types/node@24.10.1)
+      '@inquirer/type': 4.0.1(@types/node@24.10.1)
+    optionalDependencies:
+      '@types/node': 24.10.1
+
+  '@inquirer/password@5.0.1(@types/node@24.10.1)':
+    dependencies:
+      '@inquirer/ansi': 2.0.1
+      '@inquirer/core': 11.0.1(@types/node@24.10.1)
+      '@inquirer/type': 4.0.1(@types/node@24.10.1)
+    optionalDependencies:
+      '@types/node': 24.10.1
+
+  '@inquirer/prompts@8.0.1(@types/node@24.10.1)':
+    dependencies:
+      '@inquirer/checkbox': 5.0.1(@types/node@24.10.1)
+      '@inquirer/confirm': 6.0.1(@types/node@24.10.1)
+      '@inquirer/editor': 5.0.1(@types/node@24.10.1)
+      '@inquirer/expand': 5.0.1(@types/node@24.10.1)
+      '@inquirer/input': 5.0.1(@types/node@24.10.1)
+      '@inquirer/number': 4.0.1(@types/node@24.10.1)
+      '@inquirer/password': 5.0.1(@types/node@24.10.1)
+      '@inquirer/rawlist': 5.0.1(@types/node@24.10.1)
+      '@inquirer/search': 4.0.1(@types/node@24.10.1)
+      '@inquirer/select': 5.0.1(@types/node@24.10.1)
+    optionalDependencies:
+      '@types/node': 24.10.1
+
+  '@inquirer/rawlist@5.0.1(@types/node@24.10.1)':
+    dependencies:
+      '@inquirer/core': 11.0.1(@types/node@24.10.1)
+      '@inquirer/type': 4.0.1(@types/node@24.10.1)
+    optionalDependencies:
+      '@types/node': 24.10.1
+
+  '@inquirer/search@4.0.1(@types/node@24.10.1)':
+    dependencies:
+      '@inquirer/core': 11.0.1(@types/node@24.10.1)
+      '@inquirer/figures': 2.0.1
+      '@inquirer/type': 4.0.1(@types/node@24.10.1)
+    optionalDependencies:
+      '@types/node': 24.10.1
+
+  '@inquirer/select@5.0.1(@types/node@24.10.1)':
+    dependencies:
+      '@inquirer/ansi': 2.0.1
+      '@inquirer/core': 11.0.1(@types/node@24.10.1)
+      '@inquirer/figures': 2.0.1
+      '@inquirer/type': 4.0.1(@types/node@24.10.1)
+    optionalDependencies:
+      '@types/node': 24.10.1
+
+  '@inquirer/type@4.0.1(@types/node@24.10.1)':
+    optionalDependencies:
+      '@types/node': 24.10.1
+
+  '@isaacs/balanced-match@4.0.1': {}
+
+  '@isaacs/brace-expansion@5.0.0':
+    dependencies:
+      '@isaacs/balanced-match': 4.0.1
+
+  '@keyv/serialize@1.1.1': {}
+
+  '@playwright/test@1.57.0':
+    dependencies:
+      playwright: 1.57.0
+
+  '@sec-ant/readable-stream@0.4.1': {}
+
+  '@sindresorhus/is@4.6.0': {}
+
+  '@sindresorhus/is@5.6.0': {}
+
+  '@sindresorhus/is@7.1.1': {}
+
+  '@types/bezier-js@4.1.3': {}
+
+  '@types/http-cache-semantics@4.0.4': {}
+
+  '@types/node@24.10.1':
+    dependencies:
+      undici-types: 7.16.0
+    optional: true
+
+  adm-zip@0.5.16: {}
+
+  agent-base@7.1.4: {}
+
+  ansi-regex@6.2.2: {}
+
+  ansi-styles@6.2.3: {}
+
+  available-typed-arrays@1.0.7:
+    dependencies:
+      possible-typed-array-names: 1.1.0
+
+  base64-js@1.5.1: {}
+
+  baseline-browser-mapping@2.8.30: {}
+
+  better-sqlite3@12.5.0:
+    dependencies:
+      bindings: 1.5.0
+      prebuild-install: 7.1.3
+
+  bezier-js@6.1.4: {}
+
+  bindings@1.5.0:
+    dependencies:
+      file-uri-to-path: 1.0.0
+
+  bl@1.2.3:
+    dependencies:
+      readable-stream: 2.3.8
+      safe-buffer: 5.2.1
+
+  bl@4.1.0:
+    dependencies:
+      buffer: 5.7.1
+      inherits: 2.0.4
+      readable-stream: 3.6.2
+
+  browserslist@4.28.0:
+    dependencies:
+      baseline-browser-mapping: 2.8.30
+      caniuse-lite: 1.0.30001756
+      electron-to-chromium: 1.5.259
+      node-releases: 2.0.27
+      update-browserslist-db: 1.1.4(browserslist@4.28.0)
+
+  buffer-alloc-unsafe@1.1.0: {}
+
+  buffer-alloc@1.2.0:
+    dependencies:
+      buffer-alloc-unsafe: 1.1.0
+      buffer-fill: 1.0.0
+
+  buffer-crc32@0.2.13: {}
+
+  buffer-fill@1.0.0: {}
+
+  buffer@5.7.1:
+    dependencies:
+      base64-js: 1.5.1
+      ieee754: 1.2.1
+
+  byte-counter@0.1.0: {}
+
+  cacheable-lookup@7.0.0: {}
+
+  cacheable-request@13.0.15:
+    dependencies:
+      '@types/http-cache-semantics': 4.0.4
+      get-stream: 9.0.1
+      http-cache-semantics: 4.2.0
+      keyv: 5.5.4
+      mimic-response: 4.0.0
+      normalize-url: 8.1.0
+      responselike: 4.0.2
+
+  call-bind-apply-helpers@1.0.2:
+    dependencies:
+      es-errors: 1.3.0
+      function-bind: 1.1.2
+
+  call-bind@1.0.8:
+    dependencies:
+      call-bind-apply-helpers: 1.0.2
+      es-define-property: 1.0.1
+      get-intrinsic: 1.3.0
+      set-function-length: 1.2.2
+
+  call-bound@1.0.4:
+    dependencies:
+      call-bind-apply-helpers: 1.0.2
+      get-intrinsic: 1.3.0
+
+  callsites@3.1.0: {}
+
+  callsites@4.2.0: {}
+
+  camoufox-js@0.8.3(playwright-core@1.57.0):
+    dependencies:
+      adm-zip: 0.5.16
+      better-sqlite3: 12.5.0
+      commander: 14.0.2
+      fingerprint-generator: 2.1.78
+      glob: 13.0.0
+      impit: 0.7.1
+      language-tags: 2.1.0
+      maxmind: 5.0.1
+      playwright-core: 1.57.0
+      progress: 2.0.3
+      ua-parser-js: 2.0.6
+      xml2js: 0.6.2
+
+  caniuse-lite@1.0.30001756: {}
+
+  chardet@2.1.1: {}
+
+  chownr@1.1.4: {}
+
+  cli-width@4.1.0: {}
+
+  commander@14.0.2: {}
+
+  compressing@2.0.0:
+    dependencies:
+      '@eggjs/yauzl': 2.11.0
+      flushwritable: 1.0.0
+      get-ready: 1.0.0
+      iconv-lite: 0.5.2
+      streamifier: 0.1.1
+      tar-stream: 1.6.2
+      yazl: 2.5.1
+
+  core-util-is@1.0.3: {}
+
+  debug@4.4.3:
+    dependencies:
+      ms: 2.1.3
+
+  decompress-response@10.0.0:
+    dependencies:
+      mimic-response: 4.0.0
+
+  decompress-response@6.0.0:
+    dependencies:
+      mimic-response: 3.1.0
+
+  deep-extend@0.6.0: {}
+
+  define-data-property@1.1.4:
+    dependencies:
+      es-define-property: 1.0.1
+      es-errors: 1.3.0
+      gopd: 1.2.0
+
+  detect-europe-js@0.1.2: {}
+
+  detect-libc@2.1.2: {}
+
+  dot-prop@6.0.1:
+    dependencies:
+      is-obj: 2.0.0
+
+  dot-prop@7.2.0:
+    dependencies:
+      type-fest: 2.19.0
+
+  dunder-proto@1.0.1:
+    dependencies:
+      call-bind-apply-helpers: 1.0.2
+      es-errors: 1.3.0
+      gopd: 1.2.0
+
+  electron-to-chromium@1.5.259: {}
+
+  emoji-regex@10.6.0: {}
+
+  end-of-stream@1.4.5:
+    dependencies:
+      once: 1.4.0
+
+  es-define-property@1.0.1: {}
+
+  es-errors@1.3.0: {}
+
+  es-object-atoms@1.1.1:
+    dependencies:
+      es-errors: 1.3.0
+
+  escalade@3.2.0: {}
+
+  expand-template@2.0.3: {}
+
+  fd-slicer2@1.2.0:
+    dependencies:
+      pend: 1.2.0
+
+  file-uri-to-path@1.0.0: {}
+
+  fingerprint-generator@2.1.78:
+    dependencies:
+      generative-bayesian-network: 2.1.78
+      header-generator: 2.1.78
+      tslib: 2.8.1
+
+  flushwritable@1.0.0: {}
+
+  for-each@0.3.5:
+    dependencies:
+      is-callable: 1.2.7
+
+  form-data-encoder@4.1.0: {}
+
+  fs-constants@1.0.0: {}
+
+  fsevents@2.3.2:
+    optional: true
+
+  function-bind@1.1.2: {}
+
+  generative-bayesian-network@2.1.77:
+    dependencies:
+      adm-zip: 0.5.16
+      tslib: 2.8.1
+
+  generative-bayesian-network@2.1.78:
+    dependencies:
+      adm-zip: 0.5.16
+      tslib: 2.8.1
+
+  get-east-asian-width@1.4.0: {}
+
+  get-intrinsic@1.3.0:
+    dependencies:
+      call-bind-apply-helpers: 1.0.2
+      es-define-property: 1.0.1
+      es-errors: 1.3.0
+      es-object-atoms: 1.1.1
+      function-bind: 1.1.2
+      get-proto: 1.0.1
+      gopd: 1.2.0
+      has-symbols: 1.1.0
+      hasown: 2.0.2
+      math-intrinsics: 1.1.0
+
+  get-proto@1.0.1:
+    dependencies:
+      dunder-proto: 1.0.1
+      es-object-atoms: 1.1.1
+
+  get-ready@1.0.0: {}
+
+  get-stream@9.0.1:
+    dependencies:
+      '@sec-ant/readable-stream': 0.4.1
+      is-stream: 4.0.1
+
+  ghost-cursor-playwright-port@1.4.3(@playwright/test@1.57.0)(playwright-core@1.57.0)(playwright@1.57.0):
+    dependencies:
+      '@playwright/test': 1.57.0
+      '@types/bezier-js': 4.1.3
+      bezier-js: 6.1.4
+      debug: 4.4.3
+      playwright: 1.57.0
+      playwright-core: 1.57.0
+    transitivePeerDependencies:
+      - supports-color
+
+  github-from-package@0.0.0: {}
+
+  glob@13.0.0:
+    dependencies:
+      minimatch: 10.1.1
+      minipass: 7.1.2
+      path-scurry: 2.0.1
+
+  gopd@1.2.0: {}
+
+  got-scraping@4.1.2:
+    dependencies:
+      got: 14.6.4
+      header-generator: 2.1.77
+      http2-wrapper: 2.2.1
+      mimic-response: 4.0.0
+      ow: 1.1.1
+      quick-lru: 7.3.0
+      tslib: 2.8.1
+
+  got@14.6.4:
+    dependencies:
+      '@sindresorhus/is': 7.1.1
+      byte-counter: 0.1.0
+      cacheable-lookup: 7.0.0
+      cacheable-request: 13.0.15
+      decompress-response: 10.0.0
+      form-data-encoder: 4.1.0
+      http2-wrapper: 2.2.1
+      keyv: 5.5.4
+      lowercase-keys: 3.0.0
+      p-cancelable: 4.0.1
+      responselike: 4.0.2
+      type-fest: 4.41.0
+
+  has-property-descriptors@1.0.2:
+    dependencies:
+      es-define-property: 1.0.1
+
+  has-symbols@1.1.0: {}
+
+  has-tostringtag@1.0.2:
+    dependencies:
+      has-symbols: 1.1.0
+
+  hasown@2.0.2:
+    dependencies:
+      function-bind: 1.1.2
+
+  header-generator@2.1.77:
+    dependencies:
+      browserslist: 4.28.0
+      generative-bayesian-network: 2.1.77
+      ow: 0.28.2
+      tslib: 2.8.1
+
+  header-generator@2.1.78:
+    dependencies:
+      browserslist: 4.28.0
+      generative-bayesian-network: 2.1.78
+      ow: 0.28.2
+      tslib: 2.8.1
+
+  http-cache-semantics@4.2.0: {}
+
+  http2-wrapper@2.2.1:
+    dependencies:
+      quick-lru: 5.1.1
+      resolve-alpn: 1.2.1
+
+  iconv-lite@0.5.2:
+    dependencies:
+      safer-buffer: 2.1.2
+
+  iconv-lite@0.7.0:
+    dependencies:
+      safer-buffer: 2.1.2
+
+  ieee754@1.2.1: {}
+
+  impit-darwin-arm64@0.7.1:
+    optional: true
+
+  impit-darwin-x64@0.7.1:
+    optional: true
+
+  impit-linux-arm64-gnu@0.7.1:
+    optional: true
+
+  impit-linux-arm64-musl@0.7.1:
+    optional: true
+
+  impit-linux-x64-gnu@0.7.1:
+    optional: true
+
+  impit-linux-x64-musl@0.7.1:
+    optional: true
+
+  impit-win32-arm64-msvc@0.7.1:
+    optional: true
+
+  impit-win32-x64-msvc@0.7.1:
+    optional: true
+
+  impit@0.7.1:
+    optionalDependencies:
+      impit-darwin-arm64: 0.7.1
+      impit-darwin-x64: 0.7.1
+      impit-linux-arm64-gnu: 0.7.1
+      impit-linux-arm64-musl: 0.7.1
+      impit-linux-x64-gnu: 0.7.1
+      impit-linux-x64-musl: 0.7.1
+      impit-win32-arm64-msvc: 0.7.1
+      impit-win32-x64-msvc: 0.7.1
+
+  inherits@2.0.4: {}
+
+  ini@1.3.8: {}
+
+  ip-address@10.1.0: {}
+
+  is-callable@1.2.7: {}
+
+  is-obj@2.0.0: {}
+
+  is-standalone-pwa@0.1.1: {}
+
+  is-stream@4.0.1: {}
+
+  is-typed-array@1.1.15:
+    dependencies:
+      which-typed-array: 1.1.19
+
+  isarray@1.0.0: {}
+
+  isarray@2.0.5: {}
+
+  keyv@5.5.4:
+    dependencies:
+      '@keyv/serialize': 1.1.1
+
+  language-subtag-registry@0.3.23: {}
+
+  language-tags@2.1.0:
+    dependencies:
+      language-subtag-registry: 0.3.23
+
+  lodash.isequal@4.5.0: {}
+
+  lowercase-keys@3.0.0: {}
+
+  lru-cache@11.2.2: {}
+
+  math-intrinsics@1.1.0: {}
+
+  maxmind@5.0.1:
+    dependencies:
+      mmdb-lib: 3.0.1
+      tiny-lru: 11.4.5
+
+  mimic-response@3.1.0: {}
+
+  mimic-response@4.0.0: {}
+
+  minimatch@10.1.1:
+    dependencies:
+      '@isaacs/brace-expansion': 5.0.0
+
+  minimist@1.2.8: {}
+
+  minipass@7.1.2: {}
+
+  mkdirp-classic@0.5.3: {}
+
+  mmdb-lib@3.0.1: {}
+
+  ms@2.1.3: {}
+
+  mute-stream@3.0.0: {}
+
+  napi-build-utils@2.0.0: {}
+
+  node-abi@3.85.0:
+    dependencies:
+      semver: 7.7.3
+
+  node-releases@2.0.27: {}
+
+  normalize-url@8.1.0: {}
+
+  once@1.4.0:
+    dependencies:
+      wrappy: 1.0.2
+
+  ow@0.28.2:
+    dependencies:
+      '@sindresorhus/is': 4.6.0
+      callsites: 3.1.0
+      dot-prop: 6.0.1
+      lodash.isequal: 4.5.0
+      vali-date: 1.0.0
+
+  ow@1.1.1:
+    dependencies:
+      '@sindresorhus/is': 5.6.0
+      callsites: 4.2.0
+      dot-prop: 7.2.0
+      lodash.isequal: 4.5.0
+      vali-date: 1.0.0
+
+  p-cancelable@4.0.1: {}
+
+  path-scurry@2.0.1:
+    dependencies:
+      lru-cache: 11.2.2
+      minipass: 7.1.2
+
+  pend@1.2.0: {}
+
+  picocolors@1.1.1: {}
+
+  playwright-core@1.57.0: {}
+
+  playwright@1.57.0:
+    dependencies:
+      playwright-core: 1.57.0
+    optionalDependencies:
+      fsevents: 2.3.2
+
+  possible-typed-array-names@1.1.0: {}
+
+  prebuild-install@7.1.3:
+    dependencies:
+      detect-libc: 2.1.2
+      expand-template: 2.0.3
+      github-from-package: 0.0.0
+      minimist: 1.2.8
+      mkdirp-classic: 0.5.3
+      napi-build-utils: 2.0.0
+      node-abi: 3.85.0
+      pump: 3.0.3
+      rc: 1.2.8
+      simple-get: 4.0.1
+      tar-fs: 2.1.4
+      tunnel-agent: 0.6.0
+
+  process-nextick-args@2.0.1: {}
+
+  progress@2.0.3: {}
+
+  proxy-chain@2.6.0:
+    dependencies:
+      socks: 2.8.7
+      socks-proxy-agent: 8.0.5
+      tslib: 2.8.1
+    transitivePeerDependencies:
+      - supports-color
+
+  pump@3.0.3:
+    dependencies:
+      end-of-stream: 1.4.5
+      once: 1.4.0
+
+  quick-lru@5.1.1: {}
+
+  quick-lru@7.3.0: {}
+
+  rc@1.2.8:
+    dependencies:
+      deep-extend: 0.6.0
+      ini: 1.3.8
+      minimist: 1.2.8
+      strip-json-comments: 2.0.1
+
+  readable-stream@2.3.8:
+    dependencies:
+      core-util-is: 1.0.3
+      inherits: 2.0.4
+      isarray: 1.0.0
+      process-nextick-args: 2.0.1
+      safe-buffer: 5.1.2
+      string_decoder: 1.1.1
+      util-deprecate: 1.0.2
+
+  readable-stream@3.6.2:
+    dependencies:
+      inherits: 2.0.4
+      string_decoder: 1.3.0
+      util-deprecate: 1.0.2
+
+  resolve-alpn@1.2.1: {}
+
+  responselike@4.0.2:
+    dependencies:
+      lowercase-keys: 3.0.0
+
+  safe-buffer@5.1.2: {}
+
+  safe-buffer@5.2.1: {}
+
+  safer-buffer@2.1.2: {}
+
+  sax@1.4.3: {}
+
+  semver@7.7.3: {}
+
+  set-function-length@1.2.2:
+    dependencies:
+      define-data-property: 1.1.4
+      es-errors: 1.3.0
+      function-bind: 1.1.2
+      get-intrinsic: 1.3.0
+      gopd: 1.2.0
+      has-property-descriptors: 1.0.2
+
+  sharp@0.34.5:
+    dependencies:
+      '@img/colour': 1.0.0
+      detect-libc: 2.1.2
+      semver: 7.7.3
+    optionalDependencies:
+      '@img/sharp-darwin-arm64': 0.34.5
+      '@img/sharp-darwin-x64': 0.34.5
+      '@img/sharp-libvips-darwin-arm64': 1.2.4
+      '@img/sharp-libvips-darwin-x64': 1.2.4
+      '@img/sharp-libvips-linux-arm': 1.2.4
+      '@img/sharp-libvips-linux-arm64': 1.2.4
+      '@img/sharp-libvips-linux-ppc64': 1.2.4
+      '@img/sharp-libvips-linux-riscv64': 1.2.4
+      '@img/sharp-libvips-linux-s390x': 1.2.4
+      '@img/sharp-libvips-linux-x64': 1.2.4
+      '@img/sharp-libvips-linuxmusl-arm64': 1.2.4
+      '@img/sharp-libvips-linuxmusl-x64': 1.2.4
+      '@img/sharp-linux-arm': 0.34.5
+      '@img/sharp-linux-arm64': 0.34.5
+      '@img/sharp-linux-ppc64': 0.34.5
+      '@img/sharp-linux-riscv64': 0.34.5
+      '@img/sharp-linux-s390x': 0.34.5
+      '@img/sharp-linux-x64': 0.34.5
+      '@img/sharp-linuxmusl-arm64': 0.34.5
+      '@img/sharp-linuxmusl-x64': 0.34.5
+      '@img/sharp-wasm32': 0.34.5
+      '@img/sharp-win32-arm64': 0.34.5
+      '@img/sharp-win32-ia32': 0.34.5
+      '@img/sharp-win32-x64': 0.34.5
+
+  signal-exit@4.1.0: {}
+
+  simple-concat@1.0.1: {}
+
+  simple-get@4.0.1:
+    dependencies:
+      decompress-response: 6.0.0
+      once: 1.4.0
+      simple-concat: 1.0.1
+
+  smart-buffer@4.2.0: {}
+
+  socks-proxy-agent@8.0.5:
+    dependencies:
+      agent-base: 7.1.4
+      debug: 4.4.3
+      socks: 2.8.7
+    transitivePeerDependencies:
+      - supports-color
+
+  socks@2.8.7:
+    dependencies:
+      ip-address: 10.1.0
+      smart-buffer: 4.2.0
+
+  streamifier@0.1.1: {}
+
+  string-width@7.2.0:
+    dependencies:
+      emoji-regex: 10.6.0
+      get-east-asian-width: 1.4.0
+      strip-ansi: 7.1.2
+
+  string_decoder@1.1.1:
+    dependencies:
+      safe-buffer: 5.1.2
+
+  string_decoder@1.3.0:
+    dependencies:
+      safe-buffer: 5.2.1
+
+  strip-ansi@7.1.2:
+    dependencies:
+      ansi-regex: 6.2.2
+
+  strip-json-comments@2.0.1: {}
+
+  tar-fs@2.1.4:
+    dependencies:
+      chownr: 1.1.4
+      mkdirp-classic: 0.5.3
+      pump: 3.0.3
+      tar-stream: 2.2.0
+
+  tar-stream@1.6.2:
+    dependencies:
+      bl: 1.2.3
+      buffer-alloc: 1.2.0
+      end-of-stream: 1.4.5
+      fs-constants: 1.0.0
+      readable-stream: 2.3.8
+      to-buffer: 1.2.2
+      xtend: 4.0.2
+
+  tar-stream@2.2.0:
+    dependencies:
+      bl: 4.1.0
+      end-of-stream: 1.4.5
+      fs-constants: 1.0.0
+      inherits: 2.0.4
+      readable-stream: 3.6.2
+
+  tiny-lru@11.4.5: {}
+
+  to-buffer@1.2.2:
+    dependencies:
+      isarray: 2.0.5
+      safe-buffer: 5.2.1
+      typed-array-buffer: 1.0.3
+
+  tslib@2.8.1: {}
+
+  tunnel-agent@0.6.0:
+    dependencies:
+      safe-buffer: 5.2.1
+
+  type-fest@2.19.0: {}
+
+  type-fest@4.41.0: {}
+
+  typed-array-buffer@1.0.3:
+    dependencies:
+      call-bound: 1.0.4
+      es-errors: 1.3.0
+      is-typed-array: 1.1.15
+
+  ua-is-frozen@0.1.2: {}
+
+  ua-parser-js@2.0.6:
+    dependencies:
+      detect-europe-js: 0.1.2
+      is-standalone-pwa: 0.1.1
+      ua-is-frozen: 0.1.2
+
+  undici-types@7.16.0:
+    optional: true
+
+  update-browserslist-db@1.1.4(browserslist@4.28.0):
+    dependencies:
+      browserslist: 4.28.0
+      escalade: 3.2.0
+      picocolors: 1.1.1
+
+  util-deprecate@1.0.2: {}
+
+  vali-date@1.0.0: {}
+
+  which-typed-array@1.1.19:
+    dependencies:
+      available-typed-arrays: 1.0.7
+      call-bind: 1.0.8
+      call-bound: 1.0.4
+      for-each: 0.3.5
+      get-proto: 1.0.1
+      gopd: 1.2.0
+      has-tostringtag: 1.0.2
+
+  wrap-ansi@9.0.2:
+    dependencies:
+      ansi-styles: 6.2.3
+      string-width: 7.2.0
+      strip-ansi: 7.1.2
+
+  wrappy@1.0.2: {}
+
+  xml2js@0.6.2:
+    dependencies:
+      sax: 1.4.3
+      xmlbuilder: 11.0.1
+
+  xmlbuilder@11.0.1: {}
+
+  xtend@4.0.2: {}
+
+  yaml@2.8.2: {}
+
+  yazl@2.5.1:
+    dependencies:
+      buffer-crc32: 0.2.13

pnpm-workspace.yaml

@@ -0,0 +1,5 @@
+ignoredBuiltDependencies:
+  - better-sqlite3
+
+packages:
+  - '!webui/**'

public/index.html

@@ -0,0 +1,206 @@
+<!DOCTYPE html>
+<html lang="zh-CN">
+<head>
+    <meta charset="UTF-8">
+    <meta name="viewport" content="width=device-width, initial-scale=1.0">
+    <title>WebAI2API - Hugging Face Space</title>
+    <style>
+        * {
+            margin: 0;
+            padding: 0;
+            box-sizing: border-box;
+        }
+        body {
+            font-family: -apple-system, BlinkMacSystemFont, 'Segoe UI', Roboto, Oxygen, Ubuntu, Cantarell, sans-serif;
+            background: linear-gradient(135deg, #667eea 0%, #764ba2 100%);
+            min-height: 100vh;
+            display: flex;
+            align-items: center;
+            justify-content: center;
+            padding: 20px;
+        }
+        .container {
+            background: white;
+            border-radius: 20px;
+            box-shadow: 0 20px 60px rgba(0, 0, 0, 0.3);
+            max-width: 800px;
+            width: 100%;
+            padding: 40px;
+        }
+        .header {
+            text-align: center;
+            margin-bottom: 30px;
+        }
+        .logo {
+            font-size: 60px;
+            margin-bottom: 10px;
+        }
+        h1 {
+            color: #333;
+            font-size: 32px;
+            margin-bottom: 10px;
+        }
+        .status {
+            display: inline-block;
+            background: #10b981;
+            color: white;
+            padding: 8px 20px;
+            border-radius: 20px;
+            font-size: 14px;
+            font-weight: 600;
+        }
+        .info {
+            background: #f3f4f6;
+            border-radius: 10px;
+            padding: 20px;
+            margin: 20px 0;
+        }
+        .info h2 {
+            color: #667eea;
+            font-size: 20px;
+            margin-bottom: 15px;
+        }
+        .info p {
+            color: #666;
+            line-height: 1.6;
+            margin-bottom: 10px;
+        }
+        .info ul {
+            color: #666;
+            line-height: 1.8;
+            padding-left: 20px;
+        }
+        .buttons {
+            display: flex;
+            gap: 15px;
+            margin-top: 30px;
+            flex-wrap: wrap;
+        }
+        .btn {
+            flex: 1;
+            min-width: 200px;
+            padding: 15px 30px;
+            border: none;
+            border-radius: 10px;
+            font-size: 16px;
+            font-weight: 600;
+            cursor: pointer;
+            transition: all 0.3s;
+            text-decoration: none;
+            text-align: center;
+        }
+        .btn-primary {
+            background: #667eea;
+            color: white;
+        }
+        .btn-primary:hover {
+            background: #5568d3;
+            transform: translateY(-2px);
+        }
+        .btn-secondary {
+            background: #e5e7eb;
+            color: #374151;
+        }
+        .btn-secondary:hover {
+            background: #d1d5db;
+            transform: translateY(-2px);
+        }
+        .footer {
+            text-align: center;
+            margin-top: 30px;
+            color: #9ca3af;
+            font-size: 14px;
+        }
+        .api-endpoints {
+            background: #1f2937;
+            color: #e5e7eb;
+            border-radius: 10px;
+            padding: 20px;
+            margin: 20px 0;
+            font-family: 'Courier New', monospace;
+            font-size: 14px;
+        }
+        .api-endpoints code {
+            background: #374151;
+            padding: 2px 6px;
+            border-radius: 4px;
+        }
+        @media (max-width: 600px) {
+            .container {
+                padding: 20px;
+            }
+            h1 {
+                font-size: 24px;
+            }
+            .buttons {
+                flex-direction: column;
+            }
+        }
+    </style>
+</head>
+<body>
+    <div class="container">
+        <div class="header">
+            <div class="logo">🤖</div>
+            <h1>WebAI2API</h1>
+            <span class="status">✓ 服务运行中</span>
+        </div>
+
+        <div class="info">
+            <h2>📝 项目简介</h2>
+            <p>WebAI2API 是一个基于 Camoufox (Playwright) 的网页版 AI 服务转通用 API 的工具。通过模拟人类操作与 LMArena、Gemini 等网站交互，提供兼容 OpenAI 格式的接口服务。</p>
+        </div>
+
+        <div class="info">
+            <h2>🌐 API 端点</h2>
+            <div class="api-endpoints">
+                <p>• <code>GET /v1/models</code> - 获取模型列表</p>
+                <p>• <code>POST /v1/chat/completions</code> - 文本对话</p>
+                <p>• <code>GET /v1/cookies</code> - 获取 Cookies</p>
+            </div>
+        </div>
+
+        <div class="info">
+            <h2>✨ 主要特性</h2>
+            <ul>
+                <li>🤖 拟人交互：模拟人类打字与鼠标轨迹</li>
+                <li>🔄 接口兼容：提供标准 OpenAI 格式接口</li>
+                <li>🚀 并发隔离：支持多窗口并发执行</li>
+                <li>🛡️ 稳定防护：内��任务队列、负载均衡</li>
+                <li>🎨 网页管理：提供可视化管理界面</li>
+            </ul>
+        </div>
+
+        <div class="buttons">
+            <a href="/webui/" class="btn btn-primary">🎨 访问 WebUI</a>
+            <a href="/v1/models" class="btn btn-secondary">📋 查看模型列表</a>
+        </div>
+
+        <div class="info" style="margin-top: 30px;">
+            <h2>⚠️ 注意事项</h2>
+            <p>首次使用需要：</p>
+            <ul>
+                <li>访问 WebUI 完成账号登录初始化</li>
+                <li>配置 API Token（在 Space Settings 中设置 AUTH_TOKEN）</li>
+                <li>监控日志查看运行状态（Space Logs 页面）</li>
+            </ul>
+        </div>
+
+        <div class="footer">
+            <p>Powered by Hugging Face Spaces | 🙏 感谢 Hugging Face 提供托管服务</p>
+        </div>
+    </div>
+
+    <script>
+        // 简单的健康检查
+        fetch('/v1/models')
+            .then(response => response.json())
+            .then(data => {
+                console.log('API 运行正常，可用模型数量:', data.data?.length || 0);
+            })
+            .catch(error => {
+                console.log('API 检查失败:', error);
+            });
+    </script>
+</body>
+</html>

scripts/clear-data.js

@@ -0,0 +1,92 @@
+#!/usr/bin/env node
+
+/**
+ * 清除本地浏览器数据
+ * 
+ * 使用方法：
+ *   node scripts/clear-data.js
+ * 
+ * 注意：
+ *   此操作不可逆，请谨慎使用
+ */
+
+import fs from 'fs';
+import path from 'path';
+import { fileURLToPath } from 'url';
+
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = path.dirname(__filename);
+
+// 数据目录
+const DATA_DIR = path.join(__dirname, '../data/camoufoxUserData');
+
+console.log('==========================================');
+console.log('WebAI2API - 数据清除脚本');
+console.log('==========================================');
+console.log('');
+
+// 检查数据目录是否存在
+if (!fs.existsSync(DATA_DIR)) {
+    console.log('✅ 数据目录不存在，无需清除');
+    process.exit(0);
+}
+
+console.log('⚠️  警告：此操作将删除所有浏览器数据！');
+console.log('📁 数据目录:', DATA_DIR);
+console.log('');
+console.log('包含的内容：');
+
+// 显示将要删除的文件
+const files = getAllFiles(DATA_DIR);
+if (files.length === 0) {
+    console.log('  (空目录)');
+} else {
+    files.forEach(file => {
+        const relativePath = path.relative(DATA_DIR, file);
+        const stats = fs.statSync(file);
+        const size = (stats.size / 1024).toFixed(2);
+        console.log(`  - ${relativePath} (${size} KB)`);
+    });
+}
+
+console.log('');
+console.log('⏳ 5 秒后自动取消，按 Ctrl+C 立即取消...');
+console.log('');
+
+// 等待 5 秒
+setTimeout(() => {
+    console.log('⏱️  倒计时结束，开始删除...');
+    console.log('');
+
+    try {
+        // 删除数据目录
+        fs.rmSync(DATA_DIR, { recursive: true, force: true });
+        
+        console.log('✅ 数据清除成功！');
+        console.log('');
+        console.log('下次启动时将使用新的浏览器实例。');
+        console.log('如需恢复数据，请运行：npm run restore-data');
+
+    } catch (error) {
+        console.error('');
+        console.error('❌ 清除失败:', error.message);
+        process.exit(1);
+    }
+}, 5000);
+
+/**
+ * 递归获取所有文件
+ */
+function getAllFiles(dir, fileList = []) {
+    const files = fs.readdirSync(dir);
+    files.forEach(file => {
+        const filePath = path.join(dir, file);
+        const stat = fs.statSync(filePath);
+        if (stat.isDirectory()) {
+            getAllFiles(filePath, fileList);
+        } else {
+            fileList.push(filePath);
+        }
+    });
+    return fileList;
+}

scripts/genkey.js

@@ -0,0 +1,21 @@
+/**
+ * @fileoverview 生成 API Key（CLI）
+ * @description 输出一个新的 `server.auth` Key，供写入 `config.yaml` 使用。
+ *
+ * 用法：`npm run genkey`
+ */
+
+import crypto from 'crypto';
+
+/**
+ * 生成随机 API Key（用于 `config.yaml` 的 `server.auth`）
+ * 格式：sk-{48位十六进制字符}
+ * @returns {string} API Key
+ */
+function generateApiKey() {
+    return 'sk-' + crypto.randomBytes(24).toString('hex');
+}
+
+console.log('>>> [GenAPIKey] 生成新的 API Key:');
+console.log(generateApiKey());
+console.log('\n>>> 请将此 Key 复制到 config.yaml 文件的 server.auth 字段中。');

scripts/init.js

@@ -0,0 +1,747 @@
+/**
+ * @fileoverview 运行环境初始化脚本（CLI）
+ * @description 用于下载/准备运行所需依赖（如 Camoufox、better-sqlite3 等）。
+ *
+ * 用法：
+ *   npm run init                     # 自动初始化（无代理）
+ *   npm run init -- -proxy           # 自动初始化（交互式输入代理）
+ *   npm run init -- -proxy=http://127.0.0.1:7890
+ *   npm run init -- -proxy=socks5://user:pass@127.0.0.1:1080
+ *   npm run init -- -custom          # 自定义模式
+ */
+
+import fs from 'fs';
+import path from 'path';
+import os from 'os';
+import https from 'https';
+import http from 'http';
+import { fileURLToPath } from 'url';
+import compressing from 'compressing';
+import { logger } from '../src/utils/logger.js';
+import { select, input } from '@inquirer/prompts';
+import { anonymizeProxy, closeAnonymizedProxy } from 'proxy-chain';
+
+const __dirname = path.dirname(fileURLToPath(import.meta.url));
+const PROJECT_ROOT = path.join(__dirname, '..');
+const TEMP_DIR = path.join(PROJECT_ROOT, 'data', 'temp');
+
+/**
+ * 解析命令行代理参数
+ * @returns {Promise<string|null>} 代理 URL
+ */
+async function parseProxyArg() {
+    // 查找 -proxy 或 -proxy=xxx 参数
+    const proxyArg = process.argv.find(arg => arg.startsWith('-proxy'));
+
+    if (!proxyArg) {
+        return null;
+    }
+
+    // -proxy=http://... 格式
+    if (proxyArg.includes('=')) {
+        const proxyUrl = proxyArg.split('=')[1];
+        if (proxyUrl) {
+            logger.info('初始化', `使用代理: ${proxyUrl}`);
+            return proxyUrl;
+        }
+    }
+
+    // -proxy 不带参数，交互式输入
+    logger.info('初始化', '请输入代理配置...');
+
+    const proxyType = await select({
+        message: '代理类型',
+        choices: [
+            { name: 'HTTP', value: 'http' },
+            { name: 'SOCKS5', value: 'socks5' }
+        ]
+    });
+
+    const host = await input({
+        message: '代理服务器地址',
+        default: '127.0.0.1',
+        validate: (val) => val.trim().length > 0 || '地址不能为空'
+    });
+
+    const port = await input({
+        message: '代理端口',
+        default: '7890',
+        validate: (val) => {
+            const num = parseInt(val, 10);
+            return (num > 0 && num <= 65535) || '端口必须是 1-65535 的数字';
+        }
+    });
+
+    const username = await input({
+        message: '用户名 (可选，回车跳过)',
+    });
+
+    const password = await input({
+        message: '密码 (可选，回车跳过)',
+    });
+
+    // 构建代理 URL
+    let proxyUrl = `${proxyType}://`;
+    if (username && password) {
+        proxyUrl += `${encodeURIComponent(username)}:${encodeURIComponent(password)}@`;
+    } else if (username) {
+        proxyUrl += `${encodeURIComponent(username)}@`;
+    }
+    proxyUrl += `${host}:${port}`;
+
+    logger.info('初始化', `使用代理: ${proxyUrl}`);
+    return proxyUrl;
+}
+
+// 确保临时目录存在
+if (!fs.existsSync(TEMP_DIR)) {
+    fs.mkdirSync(TEMP_DIR, { recursive: true });
+}
+
+/**
+ * 获取 Node.js ABI 版本
+ */
+function getNodeABI() {
+    return process.versions.modules;
+}
+
+/**
+ * 获取平台信息
+ */
+function getPlatformInfo() {
+    const platform = os.platform();
+    const arch = os.arch();
+    const nodeVersion = process.version;
+    const abi = getNodeABI();
+
+    return { platform, arch, nodeVersion, abi };
+}
+
+/**
+ * 验证平台支持
+ */
+function validatePlatform(platform, arch) {
+    const supported = {
+        'win32': ['x64'],
+        'darwin': ['x64', 'arm64'],
+        'linux': ['x64', 'arm64']
+    };
+
+    if (!supported[platform] || !supported[platform].includes(arch)) {
+        return false;
+    }
+
+    return true;
+}
+
+/**
+ * 验证 Node.js ABI 版本支持
+ */
+function validateABI(abi) {
+    const supportedABIs = [115, 121, 123, 125, 127, 128, 130, 131, 132, 133, 135, 136, 137, 139, 140, 141];
+    return supportedABIs.includes(parseInt(abi, 10));
+}
+
+/**
+ * 下载文件（带进度，流式，支持重试）
+ * @param {string} url - 下载地址
+ * @param {string} destPath - 目标文件路径
+ * @param {string|null} proxyUrl - 代理 URL（支持 http:// 和 socks5://）
+ * @param {number} maxRetries - 最大重试次数
+ */
+async function downloadFile(url, destPath, proxyUrl = null, maxRetries = 3) {
+    // 如果是 SOCKS5 代理，先转换为本地 HTTP 代理
+    let effectiveProxyUrl = proxyUrl;
+    let anonymizedProxy = null;
+
+    if (proxyUrl && proxyUrl.startsWith('socks5://')) {
+        try {
+            logger.info('初始化', `检测到 SOCKS5 代理，正在转换为 HTTP 代理...`);
+            anonymizedProxy = await anonymizeProxy(proxyUrl);
+            effectiveProxyUrl = anonymizedProxy;
+            logger.info('初始化', `SOCKS5 代理已转换: ${anonymizedProxy}`);
+        } catch (error) {
+            logger.error('初始化', `SOCKS5 代理转换失败: ${error.message}`);
+            throw error;
+        }
+    }
+
+    try {
+        for (let attempt = 1; attempt <= maxRetries; attempt++) {
+            try {
+                if (attempt > 1) {
+                    logger.info('初始化', `第 ${attempt}/${maxRetries} 次尝试下载...`);
+                    // 删除之前失败的文件
+                    try {
+                        if (fs.existsSync(destPath)) {
+                            fs.unlinkSync(destPath);
+                        }
+                    } catch (e) { }
+                } else {
+                    logger.info('初始化', `开始下载: ${url}`);
+                }
+
+                await downloadFileOnce(url, destPath, effectiveProxyUrl);
+                return destPath;
+            } catch (error) {
+                logger.error('初始化', `下载失败 (尝试 ${attempt}/${maxRetries}): ${error.message}`);
+
+                if (attempt === maxRetries) {
+                    throw error;
+                }
+
+                // 等待后重试（递增延迟）
+                const delay = attempt * 2000;
+                logger.info('初始化', `${delay / 1000} 秒后重试...`);
+                await new Promise(resolve => setTimeout(resolve, delay));
+            }
+        }
+    } finally {
+        // 清理 SOCKS5 代理资源
+        if (anonymizedProxy) {
+            try {
+                await closeAnonymizedProxy(anonymizedProxy, true);
+                logger.debug('初始化', '已关闭临时代理桥接');
+            } catch (e) { }
+        }
+    }
+}
+
+/**
+ * 单次下载尝试（内部函数）
+ * 使用 Node.js 原生 http/https 模块，手动管理超时
+ * 只有在指定时间内没有任何数据传输才会触发超时
+ */
+async function downloadFileOnce(url, destPath, proxyUrl = null) {
+    const IDLE_TIMEOUT = 180000; // 3 分钟无数据传输才超时
+
+    return new Promise((resolve, reject) => {
+        const urlObj = new URL(url);
+        const isHttps = urlObj.protocol === 'https:';
+
+        let requestOptions = {
+            hostname: urlObj.hostname,
+            port: urlObj.port || (isHttps ? 443 : 80),
+            path: urlObj.pathname + urlObj.search,
+            method: 'GET',
+            headers: {
+                'User-Agent': 'Wget/1.21.4 (linux-gnu)',
+                'Accept': '*/*',
+                'Accept-Encoding': 'identity',
+                'Connection': 'keep-alive'
+            }
+        };
+
+        // 如果有 HTTP 代理（注意：这里只支持 HTTP 代理，SOCKS 需要额外处理）
+        let httpModule = isHttps ? https : http;
+        if (proxyUrl && proxyUrl.startsWith('http')) {
+            const proxyUrlObj = new URL(proxyUrl);
+            // 使用 CONNECT 隧道代理
+            requestOptions = {
+                hostname: proxyUrlObj.hostname,
+                port: proxyUrlObj.port || 80,
+                method: 'CONNECT',
+                path: `${urlObj.hostname}:${urlObj.port || (isHttps ? 443 : 80)}`,
+                headers: {
+                    'Host': `${urlObj.hostname}:${urlObj.port || (isHttps ? 443 : 80)}`
+                }
+            };
+            if (proxyUrlObj.username) {
+                const auth = Buffer.from(`${proxyUrlObj.username}:${proxyUrlObj.password || ''}`).toString('base64');
+                requestOptions.headers['Proxy-Authorization'] = `Basic ${auth}`;
+            }
+            httpModule = http; // 代理连接始终是 HTTP
+        }
+
+        const fileStream = fs.createWriteStream(destPath);
+        let downloadedSize = 0;
+        let totalSize = 0;
+        let lastLogTime = Date.now();
+        let finished = false;
+        let idleTimer = null;
+        let req = null;
+
+        const resetIdleTimer = () => {
+            if (idleTimer) clearTimeout(idleTimer);
+            idleTimer = setTimeout(() => {
+                if (!finished) {
+                    const error = new Error(`下载超时: ${IDLE_TIMEOUT / 1000} 秒内没有收到任何数据`);
+                    cleanup();
+                    reject(error);
+                }
+            }, IDLE_TIMEOUT);
+        };
+
+        const cleanup = () => {
+            finished = true;
+            if (idleTimer) clearTimeout(idleTimer);
+            if (req) {
+                try { req.destroy(); } catch (e) { }
+            }
+            fileStream.close();
+        };
+
+        const handleResponse = (res) => {
+            resetIdleTimer();
+
+            // 处理重定向
+            if (res.statusCode >= 300 && res.statusCode < 400 && res.headers.location) {
+                cleanup();
+                try { fs.unlinkSync(destPath); } catch (e) { }
+                logger.info('初始化', `重定向到: ${res.headers.location}`);
+                // 递归调用处理重定向
+                downloadFileOnce(res.headers.location, destPath, proxyUrl)
+                    .then(resolve)
+                    .catch(reject);
+                return;
+            }
+
+            if (res.statusCode !== 200) {
+                cleanup();
+                try { fs.unlinkSync(destPath); } catch (e) { }
+                reject(new Error(`HTTP 错误: ${res.statusCode}`));
+                return;
+            }
+
+            totalSize = parseInt(res.headers['content-length'] || '0', 10);
+            if (totalSize > 0) {
+                logger.info('初始化', `文件大小: ${(totalSize / 1024 / 1024).toFixed(2)} MB`);
+            }
+
+            res.on('data', (chunk) => {
+                resetIdleTimer();
+                downloadedSize += chunk.length;
+
+                const now = Date.now();
+                if (totalSize > 0 && now - lastLogTime > 100) {  // 100ms 更新一次，更流畅
+                    const percent = ((downloadedSize / totalSize) * 100).toFixed(1);
+                    const downloadedMB = (downloadedSize / 1024 / 1024).toFixed(2);
+                    const totalMB = (totalSize / 1024 / 1024).toFixed(2);
+                    // 使用 \r 回到行首，实现单行刷新
+                    process.stdout.write(`\r下载进度: ${percent}% (${downloadedMB}MB / ${totalMB}MB)    `);
+                    lastLogTime = now;
+                }
+            });
+
+            res.on('error', (error) => {
+                if (finished) return;
+                cleanup();
+                try { fs.unlinkSync(destPath); } catch (e) { }
+                reject(error);
+            });
+
+            res.pipe(fileStream);
+
+            fileStream.on('error', (error) => {
+                if (finished) return;
+                cleanup();
+                reject(error);
+            });
+
+            fileStream.on('finish', () => {
+                if (finished) return;
+                finished = true;
+                if (idleTimer) clearTimeout(idleTimer);
+
+                const finalSize = (downloadedSize / 1024 / 1024).toFixed(2);
+
+                if (totalSize > 0 && downloadedSize !== totalSize) {
+                    process.stdout.write('\n');  // 换行，避免与进度条混在一起
+                    const errorMsg = `下载不完整: 预期 ${(totalSize / 1024 / 1024).toFixed(2)} MB, 实际 ${finalSize} MB`;
+                    logger.error('初始化', errorMsg);
+                    try { fs.unlinkSync(destPath); } catch (e) { }
+                    reject(new Error(errorMsg));
+                    return;
+                }
+
+                process.stdout.write('\n');  // 换行，结束进度条
+                logger.info('初始化', `下载完成: ${finalSize} MB`);
+                resolve(destPath);
+            });
+        };
+
+        resetIdleTimer();
+
+        // 如果使用代理，先建立隧道
+        if (proxyUrl && proxyUrl.startsWith('http')) {
+            req = http.request(requestOptions);
+            req.on('connect', (res, socket) => {
+                if (res.statusCode !== 200) {
+                    cleanup();
+                    reject(new Error(`代理连接失败: ${res.statusCode}`));
+                    return;
+                }
+
+                // 通过隧道发起真正的 HTTPS 请求
+                const tunnelOptions = {
+                    hostname: urlObj.hostname,
+                    port: urlObj.port || (isHttps ? 443 : 80),
+                    path: urlObj.pathname + urlObj.search,
+                    method: 'GET',
+                    headers: {
+                        'User-Agent': 'Wget/1.21.4 (linux-gnu)',
+                        'Accept': '*/*',
+                        'Accept-Encoding': 'identity',
+                        'Connection': 'keep-alive',
+                        'Host': urlObj.host
+                    },
+                    socket: socket,
+                    agent: false
+                };
+
+                const tunnelReq = (isHttps ? https : http).request(tunnelOptions, handleResponse);
+                tunnelReq.on('error', (error) => {
+                    if (finished) return;
+                    cleanup();
+                    try { fs.unlinkSync(destPath); } catch (e) { }
+                    reject(error);
+                });
+                tunnelReq.end();
+            });
+            req.on('error', (error) => {
+                if (finished) return;
+                cleanup();
+                try { fs.unlinkSync(destPath); } catch (e) { }
+                reject(error);
+            });
+            req.end();
+        } else {
+            // 直连模式
+            req = httpModule.request(requestOptions, handleResponse);
+            req.on('error', (error) => {
+                if (finished) return;
+                cleanup();
+                try { fs.unlinkSync(destPath); } catch (e) { }
+                reject(error);
+            });
+            req.end();
+        }
+    });
+}
+
+/**
+ * 构建 better-sqlite3 下载 URL
+ */
+function getBetterSqlite3Url(platform, arch, abi) {
+    const version = '12.5.0';
+    const platformMap = {
+        'win32': 'win32',
+        'darwin': 'darwin',
+        'linux': 'linux'
+    };
+
+    const platformName = platformMap[platform];
+    const archName = arch; // x64 或 arm64
+
+    return `https://github.com/WiseLibs/better-sqlite3/releases/download/v${version}/better-sqlite3-v${version}-node-v${abi}-${platformName}-${archName}.tar.gz`;
+}
+
+/**
+ * 下载并安装 better-sqlite3
+ */
+async function installBetterSqlite3(platform, arch, abi, proxyUrl) {
+    logger.info('初始化', '开始安装 better-sqlite3...');
+
+    const url = getBetterSqlite3Url(platform, arch, abi);
+    const downloadPath = path.join(TEMP_DIR, 'better-sqlite3.tar.gz');
+
+    // 下载
+    await downloadFile(url, downloadPath, proxyUrl);
+
+    // 解压 .tar.gz 文件
+    logger.info('初始化', '正在解压 better-sqlite3...');
+    await compressing.tgz.uncompress(downloadPath, TEMP_DIR);
+
+    // 查找 better_sqlite3.node
+    const files = fs.readdirSync(TEMP_DIR, { recursive: true });
+    const nodeFile = files.find(f => f.endsWith('better_sqlite3.node'));
+    if (!nodeFile) {
+        throw new Error('未找到 better_sqlite3.node 文件');
+    }
+
+    // 复制到 node_modules
+    const buildDir = path.join(PROJECT_ROOT, 'node_modules', 'better-sqlite3', 'build', 'Release');
+    if (!fs.existsSync(buildDir)) {
+        fs.mkdirSync(buildDir, { recursive: true });
+    }
+
+    const sourcePath = path.join(TEMP_DIR, nodeFile);
+    const destPath = path.join(buildDir, 'better_sqlite3.node');
+    fs.copyFileSync(sourcePath, destPath);
+
+    logger.info('初始化', `better-sqlite3 安装成功: ${destPath}`);
+
+    // 清理
+    fs.unlinkSync(downloadPath);
+    // 清理解压后的所有文件
+    files.forEach(f => {
+        const filePath = path.join(TEMP_DIR, f);
+        try {
+            if (fs.existsSync(filePath)) {
+                const stat = fs.statSync(filePath);
+                if (stat.isDirectory()) {
+                    fs.rmSync(filePath, { recursive: true, force: true });
+                } else {
+                    fs.unlinkSync(filePath);
+                }
+            }
+        } catch (e) { }
+    });
+}
+
+/**
+ * 构建 Camoufox 下载 URL
+ */
+function getCamoufoxUrl(platform, arch) {
+    const version = '135.0.1-beta.24';
+    const platformMap = {
+        'win32': 'win',
+        'darwin': 'mac',
+        'linux': 'lin'
+    };
+
+    const archMap = {
+        'x64': 'x86_64',
+        'arm64': 'arm64'
+    };
+
+    const platformName = platformMap[platform];
+    const archName = archMap[arch];
+
+    return `https://github.com/daijro/camoufox/releases/download/v${version}/camoufox-${version}-${platformName}.${archName}.zip`;
+}
+
+/**
+ * 下载并安装 Camoufox
+ */
+async function installCamoufox(platform, arch, proxyUrl) {
+    logger.info('初始化', '开始安装 Camoufox 浏览器...');
+
+    const url = getCamoufoxUrl(platform, arch);
+    const downloadPath = path.join(TEMP_DIR, 'camoufox.zip');
+
+    // 下载
+    await downloadFile(url, downloadPath, proxyUrl);
+
+    // 解压 .zip 文件到 camoufox 目录
+    logger.info('初始化', '正在解压 Camoufox...');
+    const camoufoxDir = path.join(PROJECT_ROOT, 'camoufox');
+    if (!fs.existsSync(camoufoxDir)) {
+        fs.mkdirSync(camoufoxDir, { recursive: true });
+    }
+
+    await compressing.zip.uncompress(downloadPath, camoufoxDir);
+
+    // macOS 专用：复制 properties.json 到 MacOS 目录
+    if (platform === 'darwin') {
+        const resourcesPath = path.join(camoufoxDir, 'Camoufox.app', 'Contents', 'Resources', 'properties.json');
+        const macOSDir = path.join(camoufoxDir, 'Camoufox.app', 'Contents', 'MacOS');
+        const macOSPath = path.join(macOSDir, 'properties.json');
+
+        if (fs.existsSync(resourcesPath)) {
+            // 确保目标目录存在
+            if (!fs.existsSync(macOSDir)) {
+                fs.mkdirSync(macOSDir, { recursive: true });
+            }
+            fs.copyFileSync(resourcesPath, macOSPath);
+            logger.info('初始化', `已复制 properties.json 到 MacOS 目录`);
+        } else {
+            logger.warn('初始化', `未找到 properties.json: ${resourcesPath}`);
+        }
+    }
+
+    logger.info('初始化', `Camoufox 安装成功: ${camoufoxDir}`);
+
+    // 创建 version.json
+    const versionJsonPath = path.join(camoufoxDir, 'version.json');
+    const versionData = {
+        version: "135.0",
+        release: "beta.24"
+    };
+    fs.writeFileSync(versionJsonPath, JSON.stringify(versionData, null, 2), 'utf8');
+    logger.info('初始化', `已生成 version.json: ${versionJsonPath}`);
+
+    // 清理
+    fs.unlinkSync(downloadPath);
+}
+
+
+/**
+ * 主流程
+ */
+(async () => {
+    try {
+        logger.info('初始化', '========================================');
+        logger.info('初始化', '依赖初始化脚本启动');
+        logger.info('初始化', '========================================');
+
+        // 代理使用提示
+        if (!process.argv.some(arg => arg.startsWith('-proxy'))) {
+            logger.warn('初始化', '该脚本需连接 GitHub 下载资源。若网络受限，请使用代理：');
+            logger.warn('初始化', ' - 用法: npm run init -- -proxy 可交互式填写代理信息');
+            logger.warn('初始化', ' - 同时支持直接传入参数或者使用带鉴权的代理 (支持HTTP和SOCKS5)');
+            logger.warn('初始化', ' - 示例: npm run init -- -proxy=http://username:passwd@127.0.0.1:7890');
+        }
+
+        // 显示系统信息
+        const { platform, arch, nodeVersion, abi } = getPlatformInfo();
+        logger.info('初始化', `操作系统: ${platform}`);
+        logger.info('初始化', `芯片架构: ${arch}`);
+        logger.info('初始化', `Node.js 版本: ${nodeVersion}`);
+        logger.info('初始化', `Node.js ABI 版本: ${abi}`);
+
+        // 验证平台支持
+        if (!validatePlatform(platform, arch)) {
+            logger.error('初始化', '不支持的平台！');
+            logger.error('初始化', `因该项目使用了 Camoufox 浏览器，没有您设备可用的预编译版本`);
+            logger.error('初始化', `支持的平台: Windows x64, macOS x64/arm64, Linux x64/arm64`);
+            process.exit(1);
+        }
+
+        logger.info('初始化', '平台支持检查通过');
+
+        // 验证 ABI 版本支持
+        if (!validateABI(abi)) {
+            logger.error('初始化', '不支持的 Node.js ABI 版本！');
+            logger.error('初始化', `当前 ABI 版本: ${abi}`);
+            logger.error('初始化', `支持的 ABI 版本: 115, 121, 123, 125, 127, 128, 130, 131, 132, 133, 135, 136, 137, 139, 140, 141`);
+            logger.error('初始化', `建议使用 Node.js 20.10.0 或更高版本`);
+            process.exit(1);
+        }
+
+        logger.info('初始化', 'ABI 版本检查通过');
+
+        // 解析代理参数
+        const proxyUrl = await parseProxyArg();
+
+        // 检查是否为自定义模式
+        const isCustomMode = process.argv.includes('-custom');
+
+        if (isCustomMode) {
+            // 自定义模式：交互式选择步骤
+            const action = await select({
+                message: '请选择要执行的操作:',
+                choices: [
+                    { name: '安装 better-sqlite3 预编译文件', value: 'sqlite' },
+                    { name: '安装 Camoufox 浏览器', value: 'camoufox' },
+                    { name: '安装 GeoLite2-City.mmdb 数据库', value: 'geolite' },
+                    { name: '修复 macOS 环境下的 properties.json', value: 'macos_fix' },
+                    { name: '修复 version.json 缺失', value: 'version_fix' },
+                    { name: '退出', value: 'exit' }
+                ]
+            });
+
+            switch (action) {
+                case 'sqlite':
+                    await installBetterSqlite3(platform, arch, abi, proxyUrl);
+                    break;
+                case 'camoufox':
+                    await installCamoufox(platform, arch, proxyUrl);
+                    break;
+                case 'geolite':
+                    await downloadGeoLiteDb(proxyUrl, true); // 强制下载
+                    break;
+                case 'macos_fix':
+                    fixMacOSProperties();
+                    break;
+                case 'version_fix':
+                    fixVersionJson();
+                    break;
+                case 'exit':
+                    logger.info('初始化', '已退出');
+                    break;
+            }
+        } else {
+            // 正常模式：执行所有步骤
+            await installBetterSqlite3(platform, arch, abi, proxyUrl);
+            await installCamoufox(platform, arch, proxyUrl);
+            await downloadGeoLiteDb(proxyUrl);
+        }
+
+        logger.info('初始化', '========================================');
+        logger.info('初始化', '操作完成！');
+        logger.info('初始化', '========================================');
+        process.exit(0);
+
+    } catch (err) {
+        logger.error('初始化', '初始化失败', { error: err.message });
+        process.exit(1);
+    }
+})();
+
+/**
+ * 下载 GeoLite2-City.mmdb 到 camoufox 目录
+ * @param {string|null} proxyUrl - 代理 URL
+ * @param {boolean} [force=false] - 是否强制下载（忽略已存在检查）
+ */
+async function downloadGeoLiteDb(proxyUrl, force = false) {
+    const camoufoxDir = path.join(PROJECT_ROOT, 'camoufox');
+    const destPath = path.join(camoufoxDir, 'GeoLite2-City.mmdb');
+
+    // 确保目录存在
+    if (!fs.existsSync(camoufoxDir)) {
+        fs.mkdirSync(camoufoxDir, { recursive: true });
+    }
+
+    // 如果已存在且非强制模式，跳过下载
+    if (!force && fs.existsSync(destPath)) {
+        logger.info('初始化', 'GeoLite2-City.mmdb 已存在，跳过下载');
+        return;
+    }
+
+    logger.info('初始化', '开始下载 GeoLite2-City.mmdb...');
+    const url = 'https://github.com/P3TERX/GeoLite.mmdb/releases/latest/download/GeoLite2-City.mmdb';
+    await downloadFile(url, destPath, proxyUrl);
+    logger.info('初始化', `GeoLite2-City.mmdb 下载完成: ${destPath}`);
+}
+
+/**
+ * 修复 macOS 环境下的 properties.json
+ */
+function fixMacOSProperties() {
+    const platform = os.platform();
+    if (platform !== 'darwin') {
+        logger.warn('初始化', '此操作仅适用于 macOS 系统');
+        return;
+    }
+
+    const camoufoxDir = path.join(PROJECT_ROOT, 'camoufox');
+    const resourcesPath = path.join(camoufoxDir, 'Camoufox.app', 'Contents', 'Resources', 'properties.json');
+    const macOSDir = path.join(camoufoxDir, 'Camoufox.app', 'Contents', 'MacOS');
+    const macOSPath = path.join(macOSDir, 'properties.json');
+
+    if (!fs.existsSync(resourcesPath)) {
+        logger.error('初始化', `源文件不存在: ${resourcesPath}`);
+        logger.error('初始化', '请先安装 Camoufox 浏览器');
+        return;
+    }
+
+    if (!fs.existsSync(macOSDir)) {
+        fs.mkdirSync(macOSDir, { recursive: true });
+    }
+
+    fs.copyFileSync(resourcesPath, macOSPath);
+    logger.info('初始化', `已复制 properties.json 到 MacOS 目录: ${macOSPath}`);
+}
+
+/**
+ * 修复 version.json 缺失
+ */
+function fixVersionJson() {
+    const camoufoxDir = path.join(PROJECT_ROOT, 'camoufox');
+    const versionJsonPath = path.join(camoufoxDir, 'version.json');
+
+    if (!fs.existsSync(camoufoxDir)) {
+        logger.error('初始化', `camoufox 目录不存在: ${camoufoxDir}`);
+        logger.error('初始化', '请先安装 Camoufox 浏览器');
+        return;
+    }
+
+    const versionData = {
+        version: "135.0",
+        release: "beta.24"
+    };
+
+    fs.writeFileSync(versionJsonPath, JSON.stringify(versionData, null, 2), 'utf8');
+    logger.info('初始化', `已生成 version.json: ${versionJsonPath}`);
+}

scripts/postinstall.js

@@ -0,0 +1,63 @@
+/**
+ * @fileoverview npm postinstall 钩子脚本
+ * @description 在 `npm install` 后自动应用 camoufox-js 补丁。
+ *
+ * 用法：在 package.json scripts 中配置 "postinstall": "node scripts/postinstall.js"
+ */
+
+import fs from 'fs';
+import path from 'path';
+import { fileURLToPath } from 'url';
+
+const __dirname = path.dirname(fileURLToPath(import.meta.url));
+const PROJECT_ROOT = path.join(__dirname, '..');
+
+// 简易日志
+const log = (msg) => console.log(`[postinstall] ${msg}`);
+const warn = (msg) => console.warn(`[postinstall] ⚠️ ${msg}`);
+const error = (msg) => console.error(`[postinstall] ❌ ${msg}`);
+
+/**
+ * 复制 camoufox-js 补丁文件到 node_modules
+ */
+function patchCamoufoxJs() {
+    log('正在应用 camoufox-js 补丁...');
+
+    const patchDir = path.join(PROJECT_ROOT, 'patches');
+    const targetDir = path.join(PROJECT_ROOT, 'node_modules', 'camoufox-js', 'dist');
+
+    // 检查目标目录是否存在
+    if (!fs.existsSync(targetDir)) {
+        warn(`目标目录不存在: ${targetDir}`);
+        warn('camoufox-js 可能未安装，跳过补丁。');
+        return;
+    }
+
+    // 补丁文件映射: 源文件名 -> 目标文件名
+    const patches = {
+        'camoufox-js@0.8.3.locale.patched.js': 'locale.js',
+        'camoufox-js@0.8.3.pkgman.patched.js': 'pkgman.js'
+    };
+
+    for (const [srcName, destName] of Object.entries(patches)) {
+        const srcPath = path.join(patchDir, srcName);
+        const destPath = path.join(targetDir, destName);
+
+        if (!fs.existsSync(srcPath)) {
+            warn(`补丁文件不存在: ${srcPath}`);
+            continue;
+        }
+
+        try {
+            fs.copyFileSync(srcPath, destPath);
+            log(`已应用补丁: ${srcName} -> ${destName}`);
+        } catch (e) {
+            error(`应用补丁失败: ${e.message}`);
+        }
+    }
+
+    log('补丁应用完成。');
+}
+
+// 执行
+patchCamoufoxJs();

scripts/restore-data-webdav.js

@@ -0,0 +1,149 @@
+#!/usr/bin/env node
+
+/**
+ * 从 WebDAV 恢复浏览器数据
+ * 
+ * 使用方法：
+ *   node scripts/restore-data-webdav.js
+ * 
+ * 环境变量：
+ *   WEBDAV_URL: WebDAV 服务器地址
+ *   WEBDAV_USER: WebDAV 用户名
+ *   WEBDAV_PASS: WebDAV 密码
+ */
+
+import fs from 'fs';
+import path from 'path';
+import { fileURLToPath } from 'url';
+import { createClient } from 'webdav';
+
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = path.dirname(__filename);
+
+// 数据目录
+const DATA_DIR = path.join(__dirname, '../data/camoufoxUserData');
+
+// 环境变量
+const WEBDAV_URL = process.env.WEBDAV_URL;
+const WEBDAV_USER = process.env.WEBDAV_USER;
+const WEBDAV_PASS = process.env.WEBDAV_PASS;
+
+console.log('==========================================');
+console.log('WebAI2API - WebDAV 数据恢复脚本');
+console.log('==========================================');
+
+// 检查环境变量
+if (!WEBDAV_URL || !WEBDAV_USER || !WEBDAV_PASS) {
+    console.error('❌ 错误：未设置 WebDAV 环境变量');
+    console.error('请在 Space Settings 中添加：');
+    console.error('  - WEBDAV_URL: https://rebun.infini-cloud.net/dav');
+    console.error('  - WEBDAV_USER: iyougame');
+    console.error('  - WEBDAV_PASS: exzgmqInkoFADbjOx1ak_reGVIf_ptIZxYUtBFp3mLw');
+    process.exit(1);
+}
+
+console.log('🌐 WebDAV URL:', WEBDAV_URL);
+console.log('👤 用户:', WEBDAV_USER);
+console.log('📁 数据目录:', DATA_DIR);
+console.log('');
+
+try {
+    // 1. 创建 WebDAV 客户端
+    console.log('🔗 连接 WebDAV 服务器...');
+    const client = createClient(WEBDAV_URL, {
+        username: WEBDAV_USER,
+        password: WEBDAV_PASS
+    });
+
+    // 2. 检查远程目录是否存在
+    const remoteDir = '/webai2api-data';
+    console.log('🔍 检查远程目录:', remoteDir);
+    
+    try {
+        await client.getDirectoryContents(remoteDir);
+    } catch (err) {
+        console.warn('⚠️  远程目录不存在，跳过恢复');
+        console.warn('将使用新的浏览器实例（需要重新登录）');
+        process.exit(0);
+    }
+
+    console.log('✅ 远程目录存在');
+    console.log('');
+
+    // 3. 创建本地数据目录
+    console.log('📁 创建本地数据目录...');
+    if (fs.existsSync(DATA_DIR)) {
+        fs.rmSync(DATA_DIR, { recursive: true, force: true });
+    }
+    fs.mkdirSync(DATA_DIR, { recursive: true });
+
+    // 4. 下载文件
+    console.log('📥 开始下载文件...');
+    let downloadedFiles = 0;
+    let totalSize = 0;
+
+    const downloadFile = async (remotePath, localPath) => {
+        try {
+            const content = await client.getFileContents(remotePath, { format: 'text' });
+            
+            // 检查是否是目录（通过检查是否抛出错误）
+            const stats = await client.stat(remotePath);
+            
+            if (stats.type === 'directory') {
+                // 创建本地目录
+                fs.mkdirSync(localPath, { recursive: true });
+                
+                // 递归下载子文件
+                const contents = await client.getDirectoryContents(remotePath);
+                for (const item of contents) {
+                    await downloadFile(
+                        path.join(remotePath, item.basename),
+                        path.join(localPath, item.basename)
+                    );
+                }
+            } else {
+                // 下载文件
+                fs.writeFileSync(localPath, content);
+                downloadedFiles++;
+                totalSize += stats.size;
+                console.log(`  ✓ ${path.relative(DATA_DIR, localPath)} (${(stats.size / 1024).toFixed(2)} KB)`);
+            }
+        } catch (err) {
+            console.error(`  ✗ ${remotePath}: ${err.message}`);
+            throw err;
+        }
+    };
+
+    const contents = await client.getDirectoryContents(remoteDir);
+    for (const item of contents) {
+        await downloadFile(
+            path.join(remoteDir, item.basename),
+            path.join(DATA_DIR, item.basename)
+        );
+    }
+
+    console.log('');
+    console.log('==========================================');
+    console.log('✅ 数据恢复成功！');
+    console.log('==========================================');
+    console.log('📊 下载统计:');
+    console.log(`  - 文件数量: ${downloadedFiles}`);
+    console.log(`  - 总大小: ${(totalSize / 1024).toFixed(2)} KB`);
+    console.log(`  - 远程目录: ${remoteDir}`);
+    console.log('');
+    console.log('浏览器将使用恢复的登录状态。');
+
+} catch (error) {
+    console.error('');
+    console.error('❌ 恢复失败:', error.message);
+    console.error('');
+    console.error('可能的原因：');
+    console.error('1. WebDAV 配置错误');
+    console.error('2. 网络连接问题');
+    console.error('3. WebDAV 服务器不可用');
+    console.error('4. 用户名或密码错误');
+    console.error('5. 远程数据损坏');
+    console.error('');
+    console.error('将使用新的浏览器实例（需要重新登录）');
+    process.exit(0); // 不退出，允许继续启动
+}

scripts/restore-data.js

@@ -0,0 +1,139 @@
+#!/usr/bin/env node
+
+/**
+ * 从 Hugging Face Dataset 恢复浏览器数据
+ * 
+ * 使用方法：
+ *   node scripts/restore-data.js
+ * 
+ * 环境变量：
+ *   HF_DATASET_REPO: Dataset 仓库（如：iudd/webai2api-data）
+ *   HF_TOKEN: Hugging Face Token（需要 read 权限）
+ */
+
+import { execSync } from 'child_process';
+import fs from 'fs';
+import path from 'path';
+import { fileURLToPath } from 'url';
+
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = path.dirname(__filename);
+
+// 数据目录
+const DATA_DIR = path.join(__dirname, '../data/camoufoxUserData');
+const TEMP_DIR = '/tmp/webai2api-data-restore';
+
+// 环境变量
+const HF_DATASET_REPO = process.env.HF_DATASET_REPO;
+const HF_TOKEN = process.env.HF_TOKEN;
+
+console.log('==========================================');
+console.log('WebAI2API - 数据恢复脚本');
+console.log('==========================================');
+
+// 检查环境变量
+if (!HF_DATASET_REPO) {
+    console.error('❌ 错误：未设置 HF_DATASET_REPO 环境变量');
+    console.error('请在 Space Settings 中添加：HF_DATASET_REPO=YOUR_USERNAME/webai2api-data');
+    process.exit(1);
+}
+
+if (!HF_TOKEN) {
+    console.error('❌ 错误：未设置 HF_TOKEN 环境变量');
+    console.error('请在 Space Settings 中添加：HF_TOKEN（需要 read 权限）');
+    process.exit(1);
+}
+
+console.log('📦 Dataset:', HF_DATASET_REPO);
+console.log('📁 数据目录:', DATA_DIR);
+console.log('');
+
+try {
+    // 1. 创建临时目录
+    console.log('📂 创建临时目录...');
+    if (fs.existsSync(TEMP_DIR)) {
+        execSync(`rm -rf ${TEMP_DIR}`);
+    }
+    fs.mkdirSync(TEMP_DIR, { recursive: true });
+
+    // 2. 克隆 Dataset
+    console.log('🔽 克隆 Dataset...');
+    const repoUrl = `https://hf.co/${HF_DATASET_REPO}`;
+    execSync(`cd ${TEMP_DIR} && git clone https://user:${HF_TOKEN}@${repoUrl} .`, { 
+        stdio: 'inherit',
+        timeout: 60000 // 60 秒超时
+    });
+
+    // 3. 检查是否有数据
+    console.log('🔍 检查数据...');
+    const files = fs.readdirSync(TEMP_DIR);
+    if (files.length === 0 || (files.length === 1 && files[0] === '.git')) {
+        console.warn('⚠️  Dataset 中没有数据');
+        console.warn('跳过恢复，将使用新的浏览器实例');
+        process.exit(0);
+    }
+
+    // 4. 创建数据目录
+    console.log('📁 创建数据目录...');
+    if (fs.existsSync(DATA_DIR)) {
+        execSync(`rm -rf ${DATA_DIR}`);
+    }
+    fs.mkdirSync(DATA_DIR, { recursive: true });
+
+    // 5. 复制数据
+    console.log('📋 恢复数据...');
+    execSync(`cp -r ${TEMP_DIR}/* ${DATA_DIR}/`);
+    console.log('✅ 数据恢复完成');
+    console.log('');
+
+    // 6. 显示恢复的文件
+    console.log('📄 恢复的文件：');
+    const restoredFiles = getAllFiles(DATA_DIR);
+    restoredFiles.forEach(file => {
+        const relativePath = path.relative(DATA_DIR, file);
+        const stats = fs.statSync(file);
+        const size = (stats.size / 1024).toFixed(2);
+        console.log(`  - ${relativePath} (${size} KB)`);
+    });
+
+    console.log('');
+    console.log('✅ 数据恢复成功！');
+    console.log('📍 Dataset:', `https://huggingface.co/datasets/${HF_DATASET_REPO}`);
+    console.log('');
+    console.log('浏览器将使用恢复的登录状态。');
+
+} catch (error) {
+    console.error('');
+    console.error('❌ 恢复失败:', error.message);
+    console.error('');
+    console.error('可能的原因：');
+    console.error('1. Dataset 不存在或为空');
+    console.error('2. HF_TOKEN 权限不足（需要 read 权限）');
+    console.error('3. HF_DATASET_REPO 名称错误');
+    console.error('4. 网络连接问题');
+    console.error('');
+    console.error('将使用新的浏览器实例（需要重新登录）');
+    process.exit(0); // 不退出，允许继续启动
+} finally {
+    // 清理临时目录
+    if (fs.existsSync(TEMP_DIR)) {
+        execSync(`rm -rf ${TEMP_DIR}`);
+    }
+}
+
+/**
+ * 递归获取所有文件
+ */
+function getAllFiles(dir, fileList = []) {
+    const files = fs.readdirSync(dir);
+    files.forEach(file => {
+        const filePath = path.join(dir, file);
+        const stat = fs.statSync(filePath);
+        if (stat.isDirectory()) {
+            getAllFiles(filePath, fileList);
+        } else {
+            fileList.push(filePath);
+        }
+    });
+    return fileList;
+}

scripts/save-data-webdav.js

@@ -0,0 +1,148 @@
+#!/usr/bin/env node
+
+/**
+ * 使用 WebDAV 保存浏览器数据
+ * 
+ * 使用方法：
+ *   node scripts/save-data-webdav.js
+ * 
+ * 环境变量：
+ *   WEBDAV_URL: WebDAV 服务器地址
+ *   WEBDAV_USER: WebDAV 用户名
+ *   WEBDAV_PASS: WebDAV 密码
+ */
+
+import fs from 'fs';
+import path from 'path';
+import { fileURLToPath } from 'url';
+import { createClient } from 'webdav';
+
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = path.dirname(__filename);
+
+// 数据目录
+const DATA_DIR = path.join(__dirname, '../data/camoufoxUserData');
+const TEMP_DIR = '/tmp/webai2api-data-webdav';
+
+// 环境变量
+const WEBDAV_URL = process.env.WEBDAV_URL;
+const WEBDAV_USER = process.env.WEBDAV_USER;
+const WEBDAV_PASS = process.env.WEBDAV_PASS;
+
+console.log('==========================================');
+console.log('WebAI2API - WebDAV 数据保存脚本');
+console.log('==========================================');
+
+// 检查环境变量
+if (!WEBDAV_URL || !WEBDAV_USER || !WEBDAV_PASS) {
+    console.error('❌ 错误：未设置 WebDAV 环境变量');
+    console.error('请在 Space Settings 中添加：');
+    console.error('  - WEBDAV_URL: https://rebun.infini-cloud.net/dav');
+    console.error('  - WEBDAV_USER: iyougame');
+    console.error('  - WEBDAV_PASS: exzgmqInkoFADbjOx1ak_reGVIf_ptIZxYUtBFp3mLw');
+    process.exit(1);
+}
+
+// 检查数据目录是否存在
+if (!fs.existsSync(DATA_DIR)) {
+    console.error('❌ 错误：数据目录不存在', DATA_DIR);
+    console.error('请先启动服务并完成登录');
+    process.exit(1);
+}
+
+console.log('🌐 WebDAV URL:', WEBDAV_URL);
+console.log('👤 用户:', WEBDAV_USER);
+console.log('📁 数据目录:', DATA_DIR);
+console.log('');
+
+try {
+    // 1. 创建 WebDAV 客户端
+    console.log('🔗 连接 WebDAV 服务器...');
+    const client = createClient(WEBDAV_URL, {
+        username: WEBDAV_USER,
+        password: WEBDAV_PASS
+    });
+
+    // 2. 测试连接
+    await client.getDirectoryContents('/');
+    console.log('✅ WebDAV 连接成功');
+    console.log('');
+
+    // 3. 创建远程目录
+    const remoteDir = '/webai2api-data';
+    console.log('📁 创建远程目录:', remoteDir);
+    try {
+        await client.createDirectory(remoteDir);
+    } catch (err) {
+        // 目录可能已存在，忽略错误
+        if (!err.message.includes('405')) {
+            throw err;
+        }
+    }
+    console.log('✅ 远程目录准备完成');
+    console.log('');
+
+    // 4. 遍历本地文件并上传
+    console.log('📤 开始上传文件...');
+    let uploadedFiles = 0;
+    let totalSize = 0;
+
+    const uploadFile = async (localPath, remotePath) => {
+        const stats = fs.statSync(localPath);
+        if (stats.isDirectory()) {
+            // 创建远程目录
+            try {
+                await client.createDirectory(remotePath);
+            } catch (err) {
+                if (!err.message.includes('405')) {
+                    throw err;
+                }
+            }
+            // 递归上传子文件
+            const files = fs.readdirSync(localPath);
+            for (const file of files) {
+                await uploadFile(
+                    path.join(localPath, file),
+                    path.join(remotePath, file)
+                );
+            }
+        } else {
+            // 上传文件
+            const content = fs.readFileSync(localPath);
+            await client.putFileContents(remotePath, content);
+            uploadedFiles++;
+            totalSize += stats.size;
+            console.log(`  ✓ ${path.relative(DATA_DIR, localPath)} (${(stats.size / 1024).toFixed(2)} KB)`);
+        }
+    };
+
+    const files = fs.readdirSync(DATA_DIR);
+    for (const file of files) {
+        await uploadFile(
+            path.join(DATA_DIR, file),
+            path.join(remoteDir, file)
+        );
+    }
+
+    console.log('');
+    console.log('==========================================');
+    console.log('✅ 数据保存成功！');
+    console.log('==========================================');
+    console.log('📊 上传统计:');
+    console.log(`  - 文件数量: ${uploadedFiles}`);
+    console.log(`  - 总大小: ${(totalSize / 1024).toFixed(2)} KB`);
+    console.log(`  - 远程目录: ${remoteDir}`);
+    console.log('');
+    console.log('下次启动时，数据将自动恢复。');
+
+} catch (error) {
+    console.error('');
+    console.error('❌ 保存失败:', error.message);
+    console.error('');
+    console.error('可能的原因：');
+    console.error('1. WebDAV 配置错误');
+    console.error('2. 网络连接问题');
+    console.error('3. WebDAV 服务器不可用');
+    console.error('4. 用户名或密码错误');
+    process.exit(1);
+}

scripts/save-data.js

@@ -0,0 +1,117 @@
+#!/usr/bin/env node
+
+/**
+ * 保存浏览器数据到 Hugging Face Dataset
+ * 
+ * 使用方法：
+ *   node scripts/save-data.js
+ * 
+ * 环境变量：
+ *   HF_DATASET_REPO: Dataset 仓库（如：iudd/webai2api-data）
+ *   HF_TOKEN: Hugging Face Token（需要 write 权限）
+ */
+
+import { execSync } from 'child_process';
+import fs from 'fs';
+import path from 'path';
+import { fileURLToPath } from 'url';
+
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = path.dirname(__filename);
+
+// 数据目录
+const DATA_DIR = path.join(__dirname, '../data/camoufoxUserData');
+const TEMP_DIR = '/tmp/webai2api-data';
+
+// 环境变量
+const HF_DATASET_REPO = process.env.HF_DATASET_REPO;
+const HF_TOKEN = process.env.HF_TOKEN;
+
+console.log('==========================================');
+console.log('WebAI2API - 数据保存脚本');
+console.log('==========================================');
+
+// 检查环境变量
+if (!HF_DATASET_REPO) {
+    console.error('❌ 错误：未设置 HF_DATASET_REPO 环境变量');
+    console.error('请在 Space Settings 中添加：HF_DATASET_REPO=YOUR_USERNAME/webai2api-data');
+    process.exit(1);
+}
+
+if (!HF_TOKEN) {
+    console.error('❌ 错误：未设置 HF_TOKEN 环境变量');
+    console.error('请在 Space Settings 中添加：HF_TOKEN（需要 write 权限）');
+    process.exit(1);
+}
+
+// 检查数据目录是否存在
+if (!fs.existsSync(DATA_DIR)) {
+    console.error('❌ 错误：数据目录不存在', DATA_DIR);
+    console.error('请先启动服务并完成登录');
+    process.exit(1);
+}
+
+console.log('📦 Dataset:', HF_DATASET_REPO);
+console.log('📁 数据目录:', DATA_DIR);
+console.log('');
+
+try {
+    // 1. 创建临时目录
+    console.log('📂 创建临时目录...');
+    if (fs.existsSync(TEMP_DIR)) {
+        execSync(`rm -rf ${TEMP_DIR}`);
+    }
+    fs.mkdirSync(TEMP_DIR, { recursive: true });
+
+    // 2. 复制数据到临时目录
+    console.log('📋 复制数据...');
+    execSync(`cp -r ${DATA_DIR}/* ${TEMP_DIR}/`);
+    console.log('✅ 数据复制完成');
+    console.log('');
+
+    // 3. 初始化 Git 仓库
+    console.log('🔧 初始化 Git 仓库...');
+    execSync(`cd ${TEMP_DIR} && git init`, { stdio: 'inherit' });
+    execSync(`cd ${TEMP_DIR} && git config user.name "WebAI2API"`, { stdio: 'inherit' });
+    execSync(`cd ${TEMP_DIR} && git config user.email "webai2api@huggingface.co"`, { stdio: 'inherit' });
+
+    // 4. 添加远程仓库
+    console.log('🔗 添加远程仓库...');
+    const repoUrl = `https://hf.co/${HF_DATASET_REPO}`;
+    execSync(`cd ${TEMP_DIR} && git remote add origin https://user:${HF_TOKEN}@${repoUrl}`, { stdio: 'inherit' });
+
+    // 5. 添加文件
+    console.log('📝 添加文件...');
+    execSync(`cd ${TEMP_DIR} && git add .`, { stdio: 'inherit' });
+
+    // 6. 提交
+    console.log('💾 提交更改...');
+    const timestamp = new Date().toISOString();
+    execSync(`cd ${TEMP_DIR} && git commit -m "Save browser data - ${timestamp}"`, { stdio: 'inherit' });
+
+    // 7. 推送
+    console.log('🚀 推送到 Hugging Face Dataset...');
+    execSync(`cd ${TEMP_DIR} && git push -u origin main --force`, { stdio: 'inherit' });
+
+    console.log('');
+    console.log('✅ 数据保存成功！');
+    console.log('📍 Dataset:', `https://huggingface.co/datasets/${HF_DATASET_REPO}`);
+    console.log('');
+    console.log('下次启动时，数据将自动恢复。');
+
+} catch (error) {
+    console.error('');
+    console.error('❌ 保存失败:', error.message);
+    console.error('');
+    console.error('可能的原因：');
+    console.error('1. HF_TOKEN 权限不足（需要 write 权限）');
+    console.error('2. HF_DATASET_REPO 名称错误');
+    console.error('3. 网络连接问题');
+    console.error('4. Dataset 不存在或无权限访问');
+    process.exit(1);
+} finally {
+    // 清理临时目录
+    if (fs.existsSync(TEMP_DIR)) {
+        execSync(`rm -rf ${TEMP_DIR}`);
+    }
+}

src/backend/adapter/chatgpt.js

@@ -0,0 +1,208 @@
+/**
+ * @fileoverview ChatGPT 图片生成适配器
+ */
+
+import {
+    sleep,
+    safeClick,
+    uploadFilesViaChooser
+} from '../engine/utils.js';
+import {
+    fillPrompt,
+    normalizePageError,
+    moveMouseAway,
+    waitForInput,
+    gotoWithCheck,
+    waitApiResponse,
+    useContextDownload
+} from '../utils/index.js';
+import { logger } from '../../utils/logger.js';
+
+// --- 配置常量 ---
+const TARGET_URL = 'https://chatgpt.com/images/';
+const INPUT_SELECTOR = '.ProseMirror';
+
+/**
+ * 执行生图任务
+ * @param {object} context - 浏览器上下文 { page, config }
+ * @param {string} prompt - 提示词
+ * @param {string[]} imgPaths - 图片路径数组
+ * @param {string} [modelId] - 模型 ID (此适配器未使用)
+ * @param {object} [meta={}] - 日志元数据
+ * @returns {Promise<{image?: string, error?: string}>}
+ */
+async function generate(context, prompt, imgPaths, modelId, meta = {}) {
+    const { page } = context;
+    const sendBtnLocator = page.getByRole('button', { name: 'Send prompt' });
+
+    try {
+        logger.info('适配器', '开启新会话...', meta);
+        await gotoWithCheck(page, TARGET_URL);
+
+        // 1. 等待输入框加载
+        await waitForInput(page, INPUT_SELECTOR, { click: false });
+        await sleep(1500, 2500);
+
+        // 2. 上传图片
+        if (imgPaths && imgPaths.length > 0) {
+            const expectedUploads = imgPaths.length;
+            let uploadedCount = 0;
+            let processedCount = 0;
+
+            logger.debug('适配器', '点击添加文件按钮...', meta);
+            const addFilesBtn = page.getByRole('button', { name: 'Add files and more' });
+
+            await uploadFilesViaChooser(page, addFilesBtn, imgPaths, {
+                uploadValidator: (response) => {
+                    const url = response.url();
+                    if (response.status() === 200) {
+                        // 上传请求
+                        if (url.includes('backend-api/files') && !url.includes('process_upload_stream')) {
+                            uploadedCount++;
+                            logger.debug('适配器', `图片上传进度: ${uploadedCount}/${expectedUploads}`, meta);
+                            return false;
+                        }
+                        // 处理完成请求
+                        if (url.includes('backend-api/files/process_upload_stream')) {
+                            processedCount++;
+                            logger.info('适配器', `图片处理进度: ${processedCount}/${expectedUploads}`, meta);
+
+                            if (processedCount >= expectedUploads) {
+                                return true;
+                            }
+                        }
+                    }
+                    return false;
+                }
+            });
+
+            await sleep(1000, 2000);
+        }
+
+        // 3. 填写提示词
+        await safeClick(page, INPUT_SELECTOR, { bias: 'input' });
+        await fillPrompt(page, INPUT_SELECTOR, prompt, meta);
+        await sleep(500, 1000);
+
+        // 4. 点击发送
+        logger.debug('适配器', '点击发送...', meta);
+        await safeClick(page, sendBtnLocator, { bias: 'button' });
+
+        logger.info('适配器', '等待生成结果...', meta);
+
+        // 5. 等待 conversation API 返回
+        let conversationResponse;
+        try {
+            conversationResponse = await waitApiResponse(page, {
+                urlMatch: 'backend-api/f/conversation',
+                method: 'POST',
+                timeout: 180000,  // 图片生成可能较慢
+                meta
+            });
+        } catch (e) {
+            const pageError = normalizePageError(e, meta);
+            if (pageError) return pageError;
+            throw e;
+        }
+
+        // 检查响应状态
+        if (conversationResponse.status() !== 200) {
+            logger.error('适配器', `API 返回错误: HTTP ${conversationResponse.status()}`, meta);
+            return { error: `API 返回错误: HTTP ${conversationResponse.status()}` };
+        }
+
+        logger.info('适配器', '生成中，等待图片就绪...', meta);
+
+        // 6. 监听文件状态接口，等待图片生成完成
+        // 通过 file_name 是否包含 .part 判断是否生成完成
+        let downloadUrl = null;
+        let fileName = null;
+
+        try {
+            await page.waitForResponse(async (response) => {
+                const url = response.url();
+                if (!url.includes('backend-api/files/download/file_')) return false;
+                if (response.status() !== 200) return false;
+
+                try {
+                    const json = await response.json();
+                    const fn = json.file_name;
+                    const dl = json.download_url;
+
+                    // 检查是否生成完成：
+                    // 1. 必须有 file_name
+                    // 2. file_name 不能包含 .part（表示中间状态）
+                    // 3. 必须有 download_url
+                    if (fn && !fn.includes('.part') && dl) {
+                        fileName = fn;
+                        downloadUrl = dl;
+                        logger.info('适配器', `图片生成完成: ${fn}`, meta);
+                        return true;
+                    } else {
+                        logger.debug('适配器', `图片生成中: ${fn || '无文件名'}`, meta);
+                        return false;
+                    }
+                } catch {
+                    return false;
+                }
+            }, { timeout: 120000 });
+        } catch (e) {
+            const pageError = normalizePageError(e, meta);
+            if (pageError) return pageError;
+            throw e;
+        }
+
+        if (!downloadUrl) {
+            logger.error('适配器', '未获取到图片下载链接', meta);
+            return { error: '未获取到图片下载链接' };
+        }
+
+        logger.info('适配器', '正在下载图片...', meta);
+
+        // 7. 使用 useContextDownload 下载图片
+        const result = await useContextDownload(downloadUrl, page);
+        if (result.error) {
+            logger.error('适配器', result.error, meta);
+            return result;
+        }
+
+        logger.info('适配器', '已获取图片，任务完成', meta);
+        return result;
+
+    } catch (err) {
+        // 顶层错误处理
+        const pageError = normalizePageError(err, meta);
+        if (pageError) return pageError;
+
+        logger.error('适配器', '生成任务失败', { ...meta, error: err.message });
+        return { error: `生成任务失败: ${err.message}` };
+    } finally {
+        // 任务结束，将鼠标移至安全区域
+        await moveMouseAway(page);
+    }
+}
+
+/**
+ * 适配器 manifest
+ */
+export const manifest = {
+    id: 'chatgpt',
+    displayName: 'ChatGPT (图片生成)',
+    description: '使用 ChatGPT 官网生成图片，支持参考图片上传。需要已登录的 ChatGPT 账户，请使用会员账号 (包含 K12 教师认证)，非会员账号会有速率限制。',
+
+    // 入口 URL
+    getTargetUrl(config, workerConfig) {
+        return TARGET_URL;
+    },
+
+    // 模型列表
+    models: [
+        { id: 'gpt-image-1', imagePolicy: 'optional' }
+    ],
+
+    // 无需导航处理器
+    navigationHandlers: [],
+
+    // 核心生图方法
+    generate
+};

src/backend/adapter/chatgpt_text.js

@@ -0,0 +1,290 @@
+/**
+ * @fileoverview ChatGPT 文本生成适配器
+ */
+
+import {
+    sleep,
+    safeClick,
+    uploadFilesViaChooser
+} from '../engine/utils.js';
+import {
+    fillPrompt,
+    normalizePageError,
+    moveMouseAway,
+    waitForInput,
+    gotoWithCheck,
+    waitApiResponse
+} from '../utils/index.js';
+import { logger } from '../../utils/logger.js';
+
+// --- 配置常量 ---
+const TARGET_URL = 'https://chatgpt.com/';
+const INPUT_SELECTOR = '.ProseMirror';
+
+/**
+ * 通过 UI 选择模型
+ * @param {import('playwright-core').Page} page - 页面对象
+ * @param {string} codeName - 模型 codeName
+ * @param {object} meta - 日志元数据
+ * @returns {Promise<boolean>} 是否成功选择了模型
+ */
+async function selectModel(page, codeName, meta = {}) {
+    try {
+        // 1. 点击 Model selector 按钮
+        const modelSelectorBtn = page.getByRole('button', { name: /^Model selector/ });
+        const btnExists = await modelSelectorBtn.count();
+        if (btnExists === 0) {
+            logger.debug('适配器', '未找到模型选择器按钮，跳过选择模型', meta);
+            return false;
+        }
+
+        await modelSelectorBtn.waitFor({ timeout: 5000 });
+        await sleep(300, 500);
+        await safeClick(page, modelSelectorBtn, { bias: 'button' });
+        await sleep(500, 800);
+
+        // 2. 检查是否有 Legacy models 选项
+        const legacyMenuItem = page.getByRole('menuitem', { name: /^Legacy models/ });
+        const legacyExists = await legacyMenuItem.count();
+        if (legacyExists > 0) {
+            logger.debug('适配器', '发现 Legacy models 选项，正在点击...', meta);
+            await safeClick(page, legacyMenuItem, { bias: 'button' });
+            await sleep(500, 800);
+        }
+
+        // 3. 查找匹配 codeName 开头的 menuitem
+        const targetMenuItem = page.getByRole('menuitem', { name: new RegExp(`^${codeName}`) });
+        const targetExists = await targetMenuItem.count();
+        if (targetExists > 0) {
+            logger.info('适配器', `正在选择模型: ${codeName}`, meta);
+            await safeClick(page, targetMenuItem, { bias: 'button' });
+            await sleep(500, 1000);
+            return true;
+        } else {
+            logger.debug('适配器', `未找到模型 ${codeName}，使用默认模型`, meta);
+            // 点击空白区域关闭菜单
+            await page.keyboard.press('Escape');
+            await sleep(300, 500);
+            return false;
+        }
+    } catch (e) {
+        logger.warn('适配器', `选择模型失败: ${e.message}`, meta);
+        // 尝试关闭菜单
+        await page.keyboard.press('Escape').catch(() => { });
+        return false;
+    }
+}
+
+/**
+ * 执行文本生成任务
+ * @param {object} context - 浏览器上下文 { page, config }
+ * @param {string} prompt - 提示词
+ * @param {string[]} imgPaths - 图片路径数组
+ * @param {string} [modelId] - 模型 ID
+ * @param {object} [meta={}] - 日志元数据
+ * @returns {Promise<{text?: string, error?: string}>}
+ */
+async function generate(context, prompt, imgPaths, modelId, meta = {}) {
+    const { page } = context;
+    const sendBtnLocator = page.getByRole('button', { name: 'Send prompt' });
+
+    try {
+        logger.info('适配器', '开启新会话...', meta);
+        await gotoWithCheck(page, TARGET_URL);
+
+        // 1. 等待输入框加载
+        await waitForInput(page, INPUT_SELECTOR, { click: false });
+        await sleep(1500, 2500);
+
+        // 2. 选择模型
+        const modelConfig = manifest.models.find(m => m.id === modelId);
+        const targetModel = modelConfig?.codeName || modelId;
+        if (targetModel) {
+            await selectModel(page, targetModel, meta);
+        }
+
+        // 3. 上传图片 (双击 Add files and more 按钮)
+        if (imgPaths && imgPaths.length > 0) {
+            const expectedUploads = imgPaths.length;
+            let uploadedCount = 0;
+            let processedCount = 0;
+
+            logger.debug('适配器', '双击添加文件按钮...', meta);
+            const addFilesBtn = page.getByRole('button', { name: 'Add files and more' });
+
+            await uploadFilesViaChooser(page, addFilesBtn, imgPaths, {
+                clickAction: 'dblclick',  // 使用双击
+                uploadValidator: (response) => {
+                    const url = response.url();
+                    if (response.status() === 200) {
+                        // 上传请求
+                        if (url.includes('backend-api/files') && !url.includes('process_upload_stream')) {
+                            uploadedCount++;
+                            logger.debug('适配器', `图片上传进度: ${uploadedCount}/${expectedUploads}`, meta);
+                            return false;
+                        }
+                        // 处理完成请求
+                        if (url.includes('backend-api/files/process_upload_stream')) {
+                            processedCount++;
+                            logger.info('适配器', `图片处理进度: ${processedCount}/${expectedUploads}`, meta);
+
+                            if (processedCount >= expectedUploads) {
+                                return true;
+                            }
+                        }
+                    }
+                    return false;
+                }
+            });
+
+            await sleep(1000, 2000);
+        }
+
+        // 4. 填写提示词
+        await safeClick(page, INPUT_SELECTOR, { bias: 'input' });
+        await fillPrompt(page, INPUT_SELECTOR, prompt, meta);
+        await sleep(500, 1000);
+
+        // 5. 点击发送
+        logger.debug('适配器', '点击发送...', meta);
+        await safeClick(page, sendBtnLocator, { bias: 'button' });
+
+        logger.info('适配器', '等待生成结果...', meta);
+
+        // 6. 监听 conversation API 的 SSE 流，解析文本内容
+        logger.info('适配器', '监听 SSE 流获取文本...', meta);
+
+        let textContent = '';
+        let isComplete = false;
+        let targetMessageId = null;  // 追踪目标消息 ID
+
+        try {
+            await page.waitForResponse(async (response) => {
+                const url = response.url();
+                if (!url.includes('backend-api/f/conversation')) return false;
+                if (response.request().method() !== 'POST') return false;
+                if (response.status() !== 200) return false;
+
+                try {
+                    const body = await response.text();
+                    const lines = body.split('\n');
+
+                    for (const line of lines) {
+                        // 跳过空行和事件行
+                        if (!line.startsWith('data: ')) continue;
+
+                        const dataStr = line.slice(6).trim();
+                        if (dataStr === '[DONE]') {
+                            isComplete = true;
+                            continue;
+                        }
+
+                        try {
+                            const data = JSON.parse(dataStr);
+
+                            // 检测目标消息 (assistant 角色, channel: "final", content_type: "text")
+                            if (data.v?.message?.author?.role === 'assistant' &&
+                                data.v?.message?.channel === 'final' &&
+                                data.v?.message?.content?.content_type === 'text') {
+                                targetMessageId = data.v.message.id;
+                                // 初始内容
+                                const parts = data.v.message.content.parts;
+                                if (parts && parts[0]) {
+                                    textContent = parts[0];
+                                }
+                            }
+
+                            // 累积 delta 内容 (append 操作)
+                            if (data.o === 'append' && data.p === '/message/content/parts/0' && data.v) {
+                                textContent += data.v;
+                            }
+
+                            // 简单的 delta 追加 (没有 p/o，只有 v)
+                            if (data.v && typeof data.v === 'string' && !data.o && !data.p && targetMessageId) {
+                                textContent += data.v;
+                            }
+
+                            // patch 操作中的 append
+                            if (data.o === 'patch' && Array.isArray(data.v)) {
+                                for (const patch of data.v) {
+                                    if (patch.o === 'append' && patch.p === '/message/content/parts/0' && patch.v) {
+                                        textContent += patch.v;
+                                    }
+                                    // 检查是否完成
+                                    if (patch.p === '/message/status' && patch.v === 'finished_successfully') {
+                                        isComplete = true;
+                                    }
+                                }
+                            }
+
+                            // message_stream_complete 表示完成
+                            if (data.type === 'message_stream_complete') {
+                                isComplete = true;
+                            }
+                        } catch {
+                            // 忽略解析错误
+                        }
+                    }
+
+                    return isComplete;
+                } catch {
+                    return false;
+                }
+            }, { timeout: 180000 });
+        } catch (e) {
+            const pageError = normalizePageError(e, meta);
+            if (pageError) return pageError;
+            throw e;
+        }
+
+        if (!textContent || textContent.trim() === '') {
+            logger.warn('适配器', '回复内容为空', meta);
+            return { error: '回复内容为空' };
+        }
+
+        logger.info('适配器', `已获取文本内容 (${textContent.length} ���符)`, meta);
+        logger.info('适配器', '文本生成完成，任务完成', meta);
+        return { text: textContent.trim() };
+
+    } catch (err) {
+        // 顶层错误处理
+        const pageError = normalizePageError(err, meta);
+        if (pageError) return pageError;
+
+        logger.error('适配器', '生成任务失败', { ...meta, error: err.message });
+        return { error: `生成任务失败: ${err.message}` };
+    } finally {
+        // 任务结束，将鼠标移至安全区域
+        await moveMouseAway(page);
+    }
+}
+
+/**
+ * 适配器 manifest
+ */
+export const manifest = {
+    id: 'chatgpt_text',
+    displayName: 'ChatGPT (文本生成)',
+    description: '使用 ChatGPT 官网生成文本，支持多模型切换和图片上传。需要已登录的 ChatGPT 账户，若需要选择模型，请使用会员账号 (包含 K12 教室认证账号)。',
+
+    // 入口 URL
+    getTargetUrl(config, workerConfig) {
+        return TARGET_URL;
+    },
+
+    // 模型列表
+    models: [
+        { id: 'gpt-5.2', codeName: 'GPT-5.2 Instant', imagePolicy: 'optional' },
+        { id: 'gpt-5.2-thinking', codeName: 'GPT-5.2 Thinking', imagePolicy: 'optional' },
+        { id: 'gpt-5.1', codeName: 'GPT-5.1 Instant', imagePolicy: 'optional' },
+        { id: 'gpt-5.1-thinking', codeName: 'GPT-5.1 Thinking', imagePolicy: 'optional' },
+        { id: 'gpt-5', codeName: 'GPT-5 Instant', imagePolicy: 'optional' },
+        { id: 'gpt-5-thinking', codeName: 'GPT-5 Thinking', imagePolicy: 'optional' },
+    ],
+
+    // 无需导航处理器
+    navigationHandlers: [],
+
+    // 核心文本生成方法
+    generate
+};

src/backend/adapter/deepseek_text.js

@@ -0,0 +1,297 @@
+/**
+ * @fileoverview DeepSeek 文本生成适配器
+ */
+
+import {
+    sleep,
+    safeClick
+} from '../engine/utils.js';
+import {
+    fillPrompt,
+    normalizePageError,
+    moveMouseAway,
+    waitForInput,
+    gotoWithCheck
+} from '../utils/index.js';
+import { logger } from '../../utils/logger.js';
+
+// --- 配置常量 ---
+const TARGET_URL = 'https://chat.deepseek.com/';
+const INPUT_SELECTOR = 'textarea';
+
+/**
+ * 切换功能按钮状态
+ * @param {import('playwright-core').Page} page - 页面对象
+ * @param {string} buttonName - 按钮名称 (DeepThink / Search)
+ * @param {boolean} targetState - 目标状态 (true=开启, false=关闭)
+ * @param {object} meta - 日志元数据
+ * @returns {Promise<boolean>} 是否成功切换
+ */
+async function toggleButton(page, buttonName, targetState, meta = {}) {
+    try {
+        const btn = page.getByRole('button', { name: buttonName });
+        const btnCount = await btn.count();
+        if (btnCount === 0) {
+            logger.debug('适配器', `未找到 ${buttonName} 按钮`, meta);
+            return false;
+        }
+
+        // 获取当前状态 (检查 class 是否包含 ds-toggle-button--selected)
+        const isSelected = await btn.evaluate(el => el.classList.contains('ds-toggle-button--selected'));
+
+        if (isSelected !== targetState) {
+            logger.info('适配器', `切换 ${buttonName}: ${isSelected} -> ${targetState}`, meta);
+            await safeClick(page, btn, { bias: 'button' });
+            await sleep(300, 500);
+            return true;
+        } else {
+            logger.debug('适配器', `${buttonName} 已是目标状态: ${targetState}`, meta);
+            return true;
+        }
+    } catch (e) {
+        logger.warn('适配器', `切换 ${buttonName} 失败: ${e.message}`, meta);
+        return false;
+    }
+}
+
+/**
+ * 配置模型功能 (thinking / search)
+ * @param {import('playwright-core').Page} page - 页面对象
+ * @param {object} modelConfig - 模型配置
+ * @param {object} meta - 日志元数据
+ */
+async function configureModel(page, modelConfig, meta = {}) {
+    const thinking = modelConfig?.thinking || false;
+    const search = modelConfig?.search || false;
+
+    // 切换 DeepThink 状态
+    await toggleButton(page, 'DeepThink', thinking, meta);
+    await sleep(200, 400);
+
+    // 切换 Search 状态
+    await toggleButton(page, 'Search', search, meta);
+    await sleep(200, 400);
+}
+
+/**
+ * 执行文本生成任务
+ * @param {object} context - 浏览器上下文 { page, config }
+ * @param {string} prompt - 提示词
+ * @param {string[]} imgPaths - 图片路径数组 (此适配器不支持)
+ * @param {string} [modelId] - 模型 ID
+ * @param {object} [meta={}] - 日志元数据
+ * @returns {Promise<{text?: string, error?: string}>}
+ */
+async function generate(context, prompt, imgPaths, modelId, meta = {}) {
+    const { page } = context;
+
+    try {
+        logger.info('适配器', '开启新会话...', meta);
+        await gotoWithCheck(page, TARGET_URL);
+
+        // 1. 等待输入框加载
+        await waitForInput(page, INPUT_SELECTOR, { click: false });
+        await sleep(1500, 2500);
+
+        // 2. 配置模型功能 (thinking / search)
+        const modelConfig = manifest.models.find(m => m.id === modelId);
+        if (modelConfig) {
+            await configureModel(page, modelConfig, meta);
+        }
+
+        // 3. 填写提示词
+        await safeClick(page, INPUT_SELECTOR, { bias: 'input' });
+        await fillPrompt(page, INPUT_SELECTOR, prompt, meta);
+        await sleep(500, 1000);
+
+        // 4. 按回车发送
+        logger.debug('适配器', '按回车发送...', meta);
+        await page.keyboard.press('Enter');
+
+        logger.info('适配器', '等待生成结果...', meta);
+
+        // 5. 监听 chat/completion SSE 流，解析文本内容
+        logger.info('适配器', '监听 SSE 流获取文本...', meta);
+
+        let textContent = '';
+        let isComplete = false;
+        let responseFragmentIndex = -1;  // RESPONSE 类型 fragment 的数组索引
+        let currentFragmentIndex = -1;   // 当前正在追加内容的 fragment 数组索引
+        let fragmentCount = 0;           // fragments 数组的当前长度
+
+        try {
+            await page.waitForResponse(async (response) => {
+                const url = response.url();
+                if (!url.includes('chat/completion')) return false;
+                if (response.request().method() !== 'POST') return false;
+                if (response.status() !== 200) return false;
+
+                try {
+                    const body = await response.text();
+                    const lines = body.split('\n');
+
+                    for (const line of lines) {
+                        // 跳过事件行和空行
+                        if (line.startsWith('event:') || !line.startsWith('data:')) continue;
+
+                        const dataStr = line.slice(5).trim();
+                        if (!dataStr || dataStr === '{}') continue;
+
+                        try {
+                            const data = JSON.parse(dataStr);
+
+                            // 初始响应中可能已有 fragments (如 SEARCH)
+                            if (data.v?.response?.fragments && Array.isArray(data.v.response.fragments)) {
+                                for (const fragment of data.v.response.fragments) {
+                                    const idx = fragmentCount++;
+                                    if (fragment.type === 'RESPONSE') {
+                                        responseFragmentIndex = idx;
+                                        currentFragmentIndex = idx;
+                                        if (fragment.content) {
+                                            textContent += fragment.content;
+                                        }
+                                    } else {
+                                        currentFragmentIndex = idx;
+                                    }
+                                }
+                            }
+
+                            // 简单的文本追加 (只有 v 字符串，没有 p 和 o)
+                            // 只有当前活跃的 fragment 是 RESPONSE 类型时才收集
+                            if (data.v && typeof data.v === 'string' && !data.p && !data.o) {
+                                if (currentFragmentIndex === responseFragmentIndex && responseFragmentIndex >= 0) {
+                                    textContent += data.v;
+                                }
+                            }
+
+                            // 带路径的 APPEND 操作 (如 response/fragments/1/content)
+                            if (data.o === 'APPEND' && data.p && typeof data.v === 'string') {
+                                const match = data.p.match(/response\/fragments\/(\d+)\/content/);
+                                if (match) {
+                                    const fragIdx = parseInt(match[1], 10);
+                                    currentFragmentIndex = fragIdx;
+                                    if (fragIdx === responseFragmentIndex) {
+                                        textContent += data.v;
+                                    }
+                                }
+                            }
+
+                            // 不带操作符的路径设置 (如 {"v": "xxx", "p": "response/fragments/1/content"})
+                            if (data.p && typeof data.v === 'string' && !data.o) {
+                                const match = data.p.match(/response\/fragments\/(\d+)\/content/);
+                                if (match) {
+                                    const fragIdx = parseInt(match[1], 10);
+                                    currentFragmentIndex = fragIdx;
+                                    if (fragIdx === responseFragmentIndex) {
+                                        textContent += data.v;
+                                    }
+                                }
+                            }
+
+                            // fragments APPEND - 新增 fragment (非 BATCH)
+                            if (data.p === 'response/fragments' && data.o === 'APPEND' && Array.isArray(data.v)) {
+                                for (const fragment of data.v) {
+                                    const idx = fragmentCount++;
+                                    if (fragment.type === 'RESPONSE') {
+                                        responseFragmentIndex = idx;
+                                        currentFragmentIndex = idx;
+                                        if (fragment.content) {
+                                            textContent += fragment.content;
+                                        }
+                                    } else {
+                                        // THINK 或 SEARCH
+                                        currentFragmentIndex = idx;
+                                    }
+                                }
+                            }
+
+                            // BATCH 操作中的 fragments
+                            if (data.o === 'BATCH' && data.p === 'response' && Array.isArray(data.v)) {
+                                for (const item of data.v) {
+                                    // fragments 追加
+                                    if (item.p === 'fragments' && item.o === 'APPEND' && Array.isArray(item.v)) {
+                                        for (const fragment of item.v) {
+                                            const idx = fragmentCount++;
+                                            if (fragment.type === 'RESPONSE') {
+                                                responseFragmentIndex = idx;
+                                                currentFragmentIndex = idx;
+                                                if (fragment.content) {
+                                                    textContent += fragment.content;
+                                                }
+                                            } else {
+                                                // THINK 或 SEARCH
+                                                currentFragmentIndex = idx;
+                                            }
+                                        }
+                                    }
+                                    // 检查是否完成
+                                    if (item.p === 'status' && item.v === 'FINISHED') {
+                                        isComplete = true;
+                                    }
+                                }
+                            }
+                        } catch {
+                            // 忽略解析错误
+                        }
+                    }
+
+                    return isComplete;
+                } catch {
+                    return false;
+                }
+            }, { timeout: 180000 });
+        } catch (e) {
+            const pageError = normalizePageError(e, meta);
+            if (pageError) return pageError;
+            throw e;
+        }
+
+        if (!textContent || textContent.trim() === '') {
+            logger.warn('适配器', '回复内容为空', meta);
+            return { error: '回复内容为空' };
+        }
+
+        logger.info('适配器', `已获取文本内容 (${textContent.length} 字符)`, meta);
+        logger.info('适配器', '文本生成完成，任务完成', meta);
+        return { text: textContent.trim() };
+
+    } catch (err) {
+        // 顶层错误处理
+        const pageError = normalizePageError(err, meta);
+        if (pageError) return pageError;
+
+        logger.error('适配器', '生成任务失败', { ...meta, error: err.message });
+        return { error: `生成任务失败: ${err.message}` };
+    } finally {
+        // 任务结束，将鼠标移至安全区域
+        await moveMouseAway(page);
+    }
+}
+
+/**
+ * 适配器 manifest
+ */
+export const manifest = {
+    id: 'deepseek_text',
+    displayName: 'DeepSeek (文本生成)',
+    description: '使用 DeepSeek 官网生成文本，支持 DeepThink 深度思考和 Search 搜索模式。需要已登录的 DeepSeek 账户。',
+
+    // 入口 URL
+    getTargetUrl(config, workerConfig) {
+        return TARGET_URL;
+    },
+
+    // 模型列表
+    models: [
+        { id: 'deepseek-v3.2', imagePolicy: 'forbidden' },
+        { id: 'deepseek-v3.2-thinking', imagePolicy: 'forbidden', thinking: true },
+        { id: 'deepseek-v3.2-search', imagePolicy: 'forbidden', search: true },
+        { id: 'deepseek-v3.2-thinking-search', imagePolicy: 'forbidden', thinking: true, search: true },
+    ],
+
+    // 无需导航处理器
+    navigationHandlers: [],
+
+    // 核心文本生成方法
+    generate
+};

src/backend/adapter/doubao.js

@@ -0,0 +1,253 @@
+/**
+ * @fileoverview 豆包 (Doubao) 图片生成适配器
+ */
+
+import {
+    sleep,
+    safeClick,
+    uploadFilesViaChooser
+} from '../engine/utils.js';
+import {
+    fillPrompt,
+    normalizePageError,
+    moveMouseAway,
+    waitForInput,
+    gotoWithCheck,
+    useContextDownload
+} from '../utils/index.js';
+import { logger } from '../../utils/logger.js';
+
+// --- 配置常量 ---
+const TARGET_URL = 'https://www.doubao.com/chat/';
+
+/**
+ * 执行图片生成任务
+ * @param {object} context - 浏览器上下文 { page, config }
+ * @param {string} prompt - 提示词
+ * @param {string[]} imgPaths - 图片路径数组
+ * @param {string} [modelId] - 模型 ID
+ * @param {object} [meta={}] - 日志元数据
+ * @returns {Promise<{image?: string, error?: string}>}
+ */
+async function generate(context, prompt, imgPaths, modelId, meta = {}) {
+    const { page } = context;
+
+    // 获取模型配置
+    const modelConfig = manifest.models.find(m => m.id === modelId) || manifest.models[0];
+    const { codeName } = modelConfig;
+
+    try {
+        logger.info('适配器', '开启新会话...', meta);
+        await gotoWithCheck(page, TARGET_URL);
+        await sleep(1500, 2500);
+
+        // 1. 点击进入图片生成模式
+        logger.debug('适配器', '进入图片生成模式...', meta);
+        const skillBtn = page.locator('button[data-testid="skill_bar_button_3"]');
+        await skillBtn.waitFor({ state: 'visible', timeout: 30000 });
+        await safeClick(page, skillBtn, { bias: 'button' });
+        await sleep(1000, 1500);
+
+        // 2. 选择模型
+        logger.debug('适配器', `选择模型: ${codeName}...`, meta);
+        const modelBtn = page.locator('button[data-testid="image-creation-chat-input-picture-model-button"]');
+        await modelBtn.waitFor({ state: 'visible', timeout: 10000 });
+        await safeClick(page, modelBtn, { bias: 'button' });
+        await sleep(500, 800);
+
+        const modelOption = page.getByRole('menuitem', { name: codeName });
+        await modelOption.waitFor({ state: 'visible', timeout: 5000 });
+        await safeClick(page, modelOption, { bias: 'button' });
+        await sleep(500, 800);
+
+        // 3. 上传参考图片 (如果有)
+        if (imgPaths && imgPaths.length > 0) {
+            logger.info('适配器', `开始上传 ${imgPaths.length} 张参考图片...`, meta);
+
+            const uploadBtn = page.locator('button[data-testid="image-creation-chat-input-picture-reference-button"]');
+            await uploadBtn.waitFor({ state: 'visible', timeout: 10000 });
+
+            await uploadFilesViaChooser(page, uploadBtn, imgPaths, {
+                uploadValidator: (response) => {
+                    const url = response.url();
+                    return response.status() === 200 &&
+                        url.includes('bytedanceapi.com') &&
+                        url.includes('Action=CommitImageUpload');
+                }
+            });
+
+            logger.info('适配器', '参考图片上传完成', meta);
+            await sleep(1000, 1500);
+        }
+
+        // 4. 填写提示词
+        const inputLocator = page.locator('div[data-testid="chat_input_input"][role="textbox"]');
+        await waitForInput(page, inputLocator, { click: true });
+        await fillPrompt(page, inputLocator, prompt, meta);
+        await sleep(500, 1000);
+
+        // 5. 设置 SSE 监听
+        logger.debug('适配器', '启动 SSE 监听...', meta);
+
+        let imageUrl = null;
+        let isResolved = false;
+
+        const resultPromise = new Promise((resolve, reject) => {
+            const timeout = setTimeout(() => {
+                if (!isResolved) {
+                    isResolved = true;
+                    reject(new Error('API_TIMEOUT: 响应超时 (180秒)'));
+                }
+            }, 180000);
+
+            const handleResponse = async (response) => {
+                try {
+                    const url = response.url();
+                    if (!url.includes('chat/completion')) return;
+
+                    const contentType = response.headers()['content-type'] || '';
+                    if (!contentType.includes('text/event-stream')) return;
+
+                    const body = await response.text();
+                    const extractedUrl = parseSSEForImage(body);
+
+                    if (extractedUrl) {
+                        imageUrl = extractedUrl;
+                        if (!isResolved) {
+                            isResolved = true;
+                            clearTimeout(timeout);
+                            page.off('response', handleResponse);
+                            resolve();
+                        }
+                    }
+                } catch (e) {
+                    // 忽略解析错误
+                }
+            };
+
+            page.on('response', handleResponse);
+        });
+
+        // 6. 点击发送
+        const sendBtn = page.locator('button[data-testid="chat_input_send_button"]');
+        await sendBtn.waitFor({ state: 'visible', timeout: 10000 });
+        logger.info('适配器', '点击发送...', meta);
+        await safeClick(page, sendBtn, { bias: 'button' });
+
+        // 7. 等待响应
+        logger.info('适配器', '等待图片生成...', meta);
+        await resultPromise;
+
+        if (!imageUrl) {
+            return { error: '未能从响应中提取图片链接' };
+        }
+
+        logger.info('适配器', '已获取图片链接，开始下载...', meta);
+
+        // 8. 下载图片
+        const downloadResult = await useContextDownload(imageUrl, page);
+        if (downloadResult.error) {
+            logger.error('适配器', downloadResult.error, meta);
+            return downloadResult;
+        }
+
+        logger.info('适配器', '图片生成完成', meta);
+        return { image: downloadResult.image };
+
+    } catch (err) {
+        const pageError = normalizePageError(err, meta);
+        if (pageError) return pageError;
+
+        logger.error('适配器', '生成任务失败', { ...meta, error: err.message });
+        return { error: `生成任务失败: ${err.message}` };
+    } finally {
+        await moveMouseAway(page);
+    }
+}
+
+/**
+ * 解析 SSE 响应，提取图片链接
+ * @param {string} body - SSE 响应体
+ * @returns {string|null} 图片 URL
+ */
+function parseSSEForImage(body) {
+    const lines = body.split('\n');
+
+    for (let i = 0; i < lines.length; i++) {
+        const line = lines[i].trim();
+
+        if (line.startsWith('data:')) {
+            const dataLine = line.substring(5).trim();
+            if (!dataLine || dataLine === '{}') continue;
+
+            try {
+                const data = JSON.parse(dataLine);
+                const url = extractRawImage(data);
+                if (url) return url;
+            } catch (e) {
+                // JSON 解析失败，跳过
+            }
+        }
+    }
+
+    return null;
+}
+
+/**
+ * 从 SSE 消息数据中提取原图 Raw 链接
+ * @param {Object} sseData - 解析后的 data JSON 对象
+ * @returns {string|null} - 返回图片 URL 或 null
+ */
+function extractRawImage(sseData) {
+    if (!sseData || !sseData.patch_op || !Array.isArray(sseData.patch_op)) {
+        return null;
+    }
+
+    for (const op of sseData.patch_op) {
+        const contentBlocks = op.patch_value?.content_block;
+
+        if (Array.isArray(contentBlocks)) {
+            for (const block of contentBlocks) {
+                // block_type 2074 代表生成卡片
+                if (block.block_type === 2074) {
+                    const creations = block.content?.creation_block?.creations;
+
+                    if (Array.isArray(creations)) {
+                        for (const creation of creations) {
+                            // 提取 image_ori_raw，只有图片生成完成时才会出现
+                            const rawUrl = creation.image?.image_ori_raw?.url;
+                            if (rawUrl) {
+                                return rawUrl;
+                            }
+                        }
+                    }
+                }
+            }
+        }
+    }
+
+    return null;
+}
+
+/**
+ * 适配器 manifest
+ */
+export const manifest = {
+    id: 'doubao',
+    displayName: '豆包 (图片生成)',
+    description: '使用字节跳动豆包生成图片，支持多种模型和参考图片上传。需要已登录的豆包账户。',
+
+    getTargetUrl(config, workerConfig) {
+        return TARGET_URL;
+    },
+
+    models: [
+        { id: 'seedream-4.5', codeName: 'Seedream 4.5', imagePolicy: 'optional' },
+        { id: 'seedream-4.0', codeName: 'Seedream 4.0', imagePolicy: 'optional' },
+        { id: 'seedream-3.0', codeName: 'Seedream 3.0', imagePolicy: 'optional' }
+    ],
+
+    navigationHandlers: [],
+
+    generate
+};

src/backend/adapter/doubao_text.js

@@ -0,0 +1,273 @@
+/**
+ * @fileoverview 豆包 (Doubao) 文本生成适配器
+ */
+
+import {
+    sleep,
+    safeClick,
+    uploadFilesViaChooser
+} from '../engine/utils.js';
+import {
+    fillPrompt,
+    normalizePageError,
+    moveMouseAway,
+    waitForInput,
+    gotoWithCheck
+} from '../utils/index.js';
+import { logger } from '../../utils/logger.js';
+
+// --- 配置常量 ---
+const TARGET_URL = 'https://www.doubao.com/chat/';
+
+/**
+ * 执行文本生成任务
+ * @param {object} context - 浏览器上下文 { page, config }
+ * @param {string} prompt - 提示词
+ * @param {string[]} imgPaths - 图片路径数组
+ * @param {string} [modelId] - 模型 ID
+ * @param {object} [meta={}] - 日志元数据
+ * @returns {Promise<{text?: string, reasoning?: string, error?: string}>}
+ */
+async function generate(context, prompt, imgPaths, modelId, meta = {}) {
+    const { page } = context;
+
+    // 是否使用深度思考模式
+    const useThinking = modelId === 'seed-thinking';
+
+    try {
+        logger.info('适配器', '开启新会话...', meta);
+        await gotoWithCheck(page, TARGET_URL);
+        await sleep(1500, 2500);
+
+        // 1. 等待输入框加载
+        const inputLocator = page.locator('textarea[data-testid="chat_input_input"]');
+        await waitForInput(page, inputLocator, { click: false });
+        await sleep(500, 1000);
+
+        // 2. 上传图片 (如果有)
+        if (imgPaths && imgPaths.length > 0) {
+            logger.info('适配器', `开始上传 ${imgPaths.length} 张图片...`, meta);
+
+            // 点击上传菜单按钮
+            const uploadMenuBtn = page.locator('button[aria-haspopup="menu"]').first();
+            await safeClick(page, uploadMenuBtn, { bias: 'button' });
+            await sleep(500, 1000);
+
+            // 点击上传文件选项
+            const uploadItem = page.locator('div[data-testid="upload_file_panel_upload_item"][role="menuitem"]');
+            await uploadFilesViaChooser(page, uploadItem, imgPaths, {
+                uploadValidator: (response) => {
+                    const url = response.url();
+                    return response.status() === 200 &&
+                        url.includes('bytedanceapi.com') &&
+                        url.includes('Action=CommitImageUpload');
+                }
+            });
+
+            logger.info('适配器', '图片上传完成', meta);
+            await sleep(1000, 1500);
+        }
+
+        // 3. 切换深度思考模式 (如需)
+        const deepThinkBtn = page.locator('div[data-testid="use-deep-thinking-switch-btn"] button');
+        const btnExists = await deepThinkBtn.count() > 0;
+
+        if (btnExists) {
+            const isChecked = await deepThinkBtn.getAttribute('data-checked') === 'true';
+
+            if (useThinking && !isChecked) {
+                logger.debug('适配器', '启用深度思考模式...', meta);
+                await safeClick(page, deepThinkBtn, { bias: 'button' });
+                await sleep(500, 800);
+            } else if (!useThinking && isChecked) {
+                logger.debug('适配器', '关闭深度思考模式...', meta);
+                await safeClick(page, deepThinkBtn, { bias: 'button' });
+                await sleep(500, 800);
+            }
+        }
+
+        // 4. 填写提示词
+        await safeClick(page, inputLocator, { bias: 'input' });
+        await fillPrompt(page, inputLocator, prompt, meta);
+        await sleep(500, 1000);
+
+        // 5. 设置 SSE 监听
+        logger.debug('适配器', '启动 SSE 监听...', meta);
+
+        let resultText = '';
+        let reasoningText = '';
+        let isResolved = false;
+
+        const resultPromise = new Promise((resolve, reject) => {
+            const timeout = setTimeout(() => {
+                if (!isResolved) {
+                    isResolved = true;
+                    reject(new Error('API_TIMEOUT: 响应超时 (120秒)'));
+                }
+            }, 120000);
+
+            // 监听页面响应
+            const handleResponse = async (response) => {
+                try {
+                    const url = response.url();
+                    // 只处理 chat/completion 接口的 SSE 响应
+                    if (!url.includes('chat/completion')) return;
+
+                    const contentType = response.headers()['content-type'] || '';
+                    if (!contentType.includes('text/event-stream')) return;
+
+                    // 读取响应体并解析 SSE
+                    const body = await response.text();
+                    const result = parseSSEResponse(body, useThinking);
+
+                    if (result.text) {
+                        resultText = result.text;
+                        reasoningText = result.reasoning || '';
+
+                        if (!isResolved) {
+                            isResolved = true;
+                            clearTimeout(timeout);
+                            page.off('response', handleResponse);
+                            resolve();
+                        }
+                    }
+                } catch (e) {
+                    // 忽略解析错误，继续等待
+                }
+            };
+
+            page.on('response', handleResponse);
+        });
+
+        // 6. 点击发送
+        const sendBtn = page.locator('button[data-testid="chat_input_send_button"]');
+        await sendBtn.waitFor({ state: 'visible', timeout: 10000 });
+        logger.info('适配器', '点击发送...', meta);
+        await safeClick(page, sendBtn, { bias: 'button' });
+
+        // 7. 等待响应
+        logger.info('适配器', '等待生成结果...', meta);
+        await resultPromise;
+
+        if (resultText) {
+            logger.info('适配器', `生成完成，文本长度: ${resultText.length}`, meta);
+            const result = { text: resultText };
+            if (reasoningText) {
+                result.reasoning = reasoningText;
+            }
+            return result;
+        } else {
+            return { error: '未能从响应中提取文本' };
+        }
+
+    } catch (err) {
+        const pageError = normalizePageError(err, meta);
+        if (pageError) return pageError;
+
+        logger.error('适配器', '生成任务失败', { ...meta, error: err.message });
+        return { error: `生成任务失败: ${err.message}` };
+    } finally {
+        await moveMouseAway(page);
+    }
+}
+
+/**
+ * 解析 SSE 响应体，提取最终文本
+ * @param {string} body - SSE 响应体
+ * @param {boolean} useThinking - 是否使用深度思考模式
+ * @returns {{text: string, reasoning?: string}}
+ */
+function parseSSEResponse(body, useThinking) {
+    const lines = body.split('\n');
+    let resultText = '';
+    let reasoningText = '';
+    let inThinkingBlock = false;
+    let thinkingBlockId = null;
+
+    for (let i = 0; i < lines.length; i++) {
+        const line = lines[i].trim();
+
+        // 解析事件类型
+        if (line.startsWith('event:')) {
+            const eventType = line.substring(6).trim();
+
+            // 找到对应的 data 行
+            if (i + 1 < lines.length && lines[i + 1].startsWith('data:')) {
+                const dataLine = lines[i + 1].substring(5).trim();
+                if (!dataLine || dataLine === '{}') continue;
+
+                try {
+                    const data = JSON.parse(dataLine);
+
+                    // SSE_REPLY_END with end_type: 1 包含完整回复
+                    if (eventType === 'SSE_REPLY_END' && data.end_type === 1) {
+                        resultText = data.msg_finish_attr?.brief || '';
+                    }
+
+                    // STREAM_MSG_NOTIFY 检测深度思考块
+                    if (eventType === 'STREAM_MSG_NOTIFY' && useThinking) {
+                        const blocks = data.content?.content_block || [];
+                        for (const block of blocks) {
+                            if (block.block_type === 10040 && block.content?.thinking_block) {
+                                inThinkingBlock = true;
+                                thinkingBlockId = block.block_id;
+                            }
+                        }
+                    }
+
+                    // STREAM_CHUNK 处理内容块
+                    if (eventType === 'STREAM_CHUNK' && useThinking && data.patch_op) {
+                        for (const op of data.patch_op) {
+                            if (op.patch_object === 1 && op.patch_value?.content_block) {
+                                for (const block of op.patch_value.content_block) {
+                                    // 如果有 parent_id 指向 thinking_block，则是思考内容
+                                    if (block.parent_id === thinkingBlockId) {
+                                        const text = block.content?.text_block?.text || '';
+                                        if (text) reasoningText += text;
+                                    }
+                                    // 思考块结束标记
+                                    if (block.block_type === 10040 && block.is_finish) {
+                                        inThinkingBlock = false;
+                                    }
+                                }
+                            }
+                        }
+                    }
+
+                    // CHUNK_DELTA 增量文本 (思考过程中的增量)
+                    if (eventType === 'CHUNK_DELTA' && useThinking && inThinkingBlock) {
+                        const text = data.text || '';
+                        if (text) reasoningText += text;
+                    }
+
+                } catch (e) {
+                    // JSON 解析失败，跳过
+                }
+            }
+        }
+    }
+
+    return { text: resultText, reasoning: reasoningText };
+}
+
+/**
+ * 适配器 manifest
+ */
+export const manifest = {
+    id: 'doubao_text',
+    displayName: '豆包 (文本生成)',
+    description: '使用字节跳动豆包生成文本，支持深度思考模式和图片上传。需要已登录的豆包账户。',
+
+    getTargetUrl(config, workerConfig) {
+        return TARGET_URL;
+    },
+
+    models: [
+        { id: 'seed', imagePolicy: 'optional', type: 'text' },
+        { id: 'seed-thinking', imagePolicy: 'optional', type: 'text' }
+    ],
+
+    navigationHandlers: [],
+
+    generate
+};

src/backend/adapter/gemini.js

@@ -0,0 +1,430 @@
+/**
+ * @fileoverview Google Gemini 图片、视频生成适配器
+ */
+
+import {
+    sleep,
+    safeClick,
+    uploadFilesViaChooser
+} from '../engine/utils.js';
+import {
+    fillPrompt,
+    normalizePageError,
+    normalizeHttpError,
+    moveMouseAway,
+    waitForInput,
+    gotoWithCheck,
+    waitApiResponse,
+    useContextDownload
+} from '../utils/index.js';
+import { logger } from '../../utils/logger.js';
+
+// --- 配置常量 ---
+const TARGET_URL = 'https://gemini.google.com/app?hl=en';
+
+
+/**
+ * 执行生图任务
+ * @param {object} context - 浏览器上下文 { page, config }
+ * @param {string} prompt - 提示词
+ * @param {string[]} imgPaths - 图片路径数组
+ * @param {string} [modelId] - 模型 ID (此适配器未使用)
+ * @param {object} [meta={}] - 日志元数据
+ * @returns {Promise<{image?: string, error?: string}>}
+ */
+async function generate(context, prompt, imgPaths, modelId, meta = {}) {
+    const { page } = context;
+    const inputLocator = page.getByRole('textbox');
+    const sendBtnLocator = page.getByRole('button', { name: 'Send message' });
+
+    try {
+        logger.info('适配器', '开启新会话...', meta);
+        await gotoWithCheck(page, TARGET_URL);
+
+        // 1. 等待输入框加载
+        await waitForInput(page, inputLocator, { click: false });
+        await sleep(1500, 2500);
+
+        // 2. 上传图片 (使用 filechooser 事件，因为 Firefox 不会创建 DOM input 元素)
+        if (imgPaths && imgPaths.length > 0) {
+            // 点击加号按钮打开菜单
+            logger.debug('适配器', '点击加号按钮...', meta);
+            const uploadMenuBtn = page.getByRole('button', { name: 'Open upload file menu' });
+            await safeClick(page, uploadMenuBtn, { bias: 'button' });
+            await sleep(500, 1000);
+
+            // 使用公共函数上传文件
+            const uploadFilesBtn = page.getByRole('button', { name: /Upload files/ });
+            await uploadFilesViaChooser(page, uploadFilesBtn, imgPaths, {
+                uploadValidator: (response) => {
+                    const url = response.url();
+                    return response.status() === 200 &&
+                        url.includes('google.com/upload/') &&
+                        url.includes('upload_id=');
+                }
+            });
+
+            await sleep(1000, 2000);
+        }
+
+        // 3. 填写提示词
+        await safeClick(page, inputLocator, { bias: 'input' });
+        await fillPrompt(page, inputLocator, prompt, meta);
+        await sleep(500, 1000);
+
+        // 4. 点击 Tools 按钮启用图片/视频生成
+        logger.debug('适配器', '点击 Tools 按钮...', meta);
+        const toolsBtn = page.getByRole('button', { name: 'Tools' });
+        await safeClick(page, toolsBtn, { bias: 'button' });
+        await sleep(500, 1000);
+
+        // 检测是否是视频模型
+        const isVideoModel = modelId && modelId.startsWith('veo-');
+
+        // 5. 点击 Create images / Create videos 按钮
+        if (isVideoModel) {
+            logger.debug('适配器', '点击 Create videos 按钮...', meta);
+            const createVideosBtn = page.getByRole('button', { name: /^Create videos/ });
+
+            // 检查按钮是否存在（有些账号可能没有视频生成功能）
+            const btnCount = await createVideosBtn.count();
+            if (btnCount === 0) {
+                logger.error('适配器', '未找到 Create videos 按钮，该账号可能不支持视频生成', meta);
+                return { error: '该账号不支持视频生成功能 (未找到 Create videos 按钮)' };
+            }
+
+            await safeClick(page, createVideosBtn, { bias: 'button' });
+        } else {
+            logger.debug('适配器', '点击 Create images 按钮...', meta);
+            const createImagesBtn = page.getByRole('button', { name: 'Create images' });
+            await safeClick(page, createImagesBtn, { bias: 'button' });
+        }
+        await sleep(500, 1000);
+
+        // 6. 点击发送
+        logger.debug('适配器', '点击发送...', meta);
+        await safeClick(page, sendBtnLocator, { bias: 'button' });
+
+        logger.info('适配器', '等待生成结果...', meta);
+
+        // 7. 等待 StreamGenerate API
+        let streamApiResponse;
+        try {
+            streamApiResponse = await waitApiResponse(page, {
+                urlMatch: 'assistant.lamda.BardFrontendService/StreamGenerate',
+                method: 'POST',
+                timeout: 120000,
+                meta
+            });
+        } catch (e) {
+            const pageError = normalizePageError(e, meta);
+            if (pageError) return pageError;
+            throw e;
+        }
+
+        // 检查 HTTP 错误
+        const httpError = normalizeHttpError(streamApiResponse);
+        if (httpError) {
+            logger.error('适配器', `API 返回错误: ${httpError.error}`, meta);
+            return { error: `API 返回错误: ${httpError.error}` };
+        }
+
+        // 8. 等待图片/视频响应
+        if (isVideoModel) {
+            // 视频模式：等待视频下载链接
+            logger.info('适配器', '生成请求成功，等待视频...', meta);
+
+            let videoResponse;
+            try {
+                videoResponse = await waitApiResponse(page, {
+                    urlMatch: 'contribution.usercontent.google.com/download',
+                    urlContains: 'filename=video.mp4',
+                    method: 'GET',
+                    timeout: 180000,  // 视频生成可能更慢
+                    meta
+                });
+            } catch (e) {
+                const pageError = normalizePageError(e, meta);
+                if (pageError) return pageError;
+                throw e;
+            }
+
+            // 获取视频数据
+            const buffer = await videoResponse.body();
+            const base64 = buffer.toString('base64');
+            const contentType = videoResponse.headers()['content-type'] || 'video/mp4';
+            const videoData = `data:${contentType};base64,${base64}`;
+
+            logger.info('适配器', '已获取视频，任务完成', meta);
+            return { image: videoData };
+
+        } else {
+            // 图片模式：直接从 StreamGenerate 响应体解析图片 URL
+            logger.info('适配器', '生成请求成功，正在解析响应...', meta);
+
+            // 解析响应体，提取图片 URL
+            const bodyBuffer = await streamApiResponse.body();
+            const imageUrls = extractImageUrlsFromResponse(bodyBuffer);
+
+            if (imageUrls.length === 0) {
+                // 没有找到图片 URL，尝试提取文本作为错误信息
+                const errorText = extractAiTextFromResponse(bodyBuffer);
+                const errorMsg = errorText.substring(0, 150) || '生成失败，响应中未包含图片';
+                logger.error('适配器', `未找到图片: ${errorMsg}`, meta);
+                return { error: errorMsg };
+            }
+
+            // 取第一张图片，追加 =s1024-rj 获取高分辨率
+            const imageUrl = imageUrls[0] + '=s1024-rj';
+            logger.info('适配器', `找到 ${imageUrls.length} 张图片，开始下载...`, meta);
+
+            // 使用封装的下载函数
+            const result = await useContextDownload(imageUrl, page);
+            if (result.error) {
+                logger.error('适配器', result.error, meta);
+                return result;
+            }
+
+            logger.info('适配器', '已获取图片，任务完成', meta);
+            return result;
+        }
+
+    } catch (err) {
+        // 顶层错误处理
+        const pageError = normalizePageError(err, meta);
+        if (pageError) return pageError;
+
+        logger.error('适配器', '生成任务失败', { ...meta, error: err.message });
+        return { error: `生成任务失败: ${err.message}` };
+    } finally {
+        // 任务结束，将鼠标移至安全区域
+        await moveMouseAway(page);
+    }
+}
+
+/**
+ * 适配器 manifest
+ */
+export const manifest = {
+    id: 'gemini',
+    displayName: 'Google Gemini (图片、视频生成)',
+    description: '使用 Google Gemini 官网生成图片和视频，支持参考图片上传。需要已登录的 Google 账户，免费账户图片生成有速率限制，视频生成必须为会员账户才可使用。',
+
+    // 入口 URL
+    getTargetUrl(config, workerConfig) {
+        return TARGET_URL;
+    },
+
+    // 模型列表
+    models: [
+        { id: 'gemini-3-pro-image-preview', imagePolicy: 'optional' },
+        { id: 'veo-3.1-generate-preview', imagePolicy: 'optional' }
+    ],
+
+    // 无需导航处理器
+    navigationHandlers: [],
+
+    // 核心生图方法
+    generate
+};
+
+// ==========================================
+// 解析 gRPC Batchexecute 响应
+// ==========================================
+
+/**
+ * 解析 batchexecute/batch RPC 响应（直接操作 Buffer）
+ * @param {Buffer} buf - 响应体 Buffer
+ */
+function parseLenFramedResponse(buf) {
+    let i = 0;
+
+    // 去掉 )]}' 这种 XSSI 前缀（通常是第一行）
+    if (buf.length >= 4 && buf[0] === 0x29 && buf[1] === 0x5d && buf[2] === 0x7d) {
+        const firstNl = buf.indexOf(0x0a);
+        if (firstNl !== -1) i = firstNl + 1;
+    }
+
+    const frames = [];
+
+    const readLineBuf = () => {
+        if (i >= buf.length) return null;
+        const nl = buf.indexOf(0x0a, i);
+        let line;
+        if (nl === -1) {
+            line = buf.slice(i);
+            i = buf.length;
+        } else {
+            line = buf.slice(i, nl);
+            i = nl + 1;
+        }
+        if (line.length && line[line.length - 1] === 0x0d) line = line.slice(0, -1);
+        return line;
+    };
+
+    let pendingLen = null;
+
+    while (true) {
+        const lineBuf = readLineBuf();
+        if (lineBuf === null) break;
+
+        const lineStr = lineBuf.toString('utf8').trim();
+        if (!lineStr) continue;
+
+        if (pendingLen === null) {
+            if (/^\d+$/.test(lineStr)) pendingLen = Number(lineStr);
+            continue;
+        }
+
+        let chunkBuf = lineBuf;
+        let chunkStr = chunkBuf.toString('utf8').trim();
+
+        while (true) {
+            try {
+                frames.push(JSON.parse(chunkStr));
+                break;
+            } catch (e) {
+                const msg = String(e && e.message || '');
+                const looksTruncated = /Unexpected end of JSON input|Unterminated string/.test(msg);
+
+                if (!looksTruncated) break;
+
+                const savedPos = i;
+                const next = readLineBuf();
+                if (next === null) break;
+
+                const nextStr = next.toString('utf8').trim();
+                if (/^\d+$/.test(nextStr)) {
+                    i = savedPos;
+                    break;
+                }
+
+                chunkBuf = Buffer.concat([chunkBuf, Buffer.from('\n'), next]);
+                chunkStr = chunkBuf.toString('utf8').trim();
+            }
+        }
+
+        pendingLen = null;
+    }
+
+    return frames;
+}
+
+/**
+ * 把 frame 里的 payload 再 parse 一次
+ */
+function extractPayloads(frames) {
+    const payloads = [];
+    for (const frame of frames) {
+        if (!Array.isArray(frame)) continue;
+
+        for (const item of frame) {
+            if (!Array.isArray(item)) continue;
+            const payloadStr = item[2];
+            if (typeof payloadStr !== 'string') continue;
+
+            try {
+                payloads.push(JSON.parse(payloadStr));
+            } catch {
+                // ignore
+            }
+        }
+    }
+    return payloads;
+}
+
+/**
+ * 深度遍历，查找 googleusercontent.com/gg-dl 开头的图片 URL
+ * @param {any} root - 要遍历的对象
+ * @returns {string[]} 图片 URL 数组
+ */
+function collectImageUrlsDeep(root) {
+    const urls = [];
+    const stack = [root];
+
+    while (stack.length) {
+        const cur = stack.pop();
+        if (!cur) continue;
+
+        if (typeof cur === 'string') {
+            // 匹配 googleusercontent.com/gg-dl 图片 URL
+            if (cur.includes('googleusercontent.com/gg-dl')) {
+                urls.push(cur);
+            }
+        } else if (Array.isArray(cur)) {
+            for (const v of cur) stack.push(v);
+        } else if (typeof cur === 'object') {
+            for (const v of Object.values(cur)) stack.push(v);
+        }
+    }
+
+    return urls;
+}
+
+/**
+ * 深度遍历，查找 rc_ 开头的文本内容
+ */
+function collectRcTextsDeep(root) {
+    const bestByRc = new Map();
+    const stack = [root];
+
+    while (stack.length) {
+        const cur = stack.pop();
+        if (!cur) continue;
+
+        if (Array.isArray(cur)) {
+            const maybeRc = cur[0];
+            const maybeArr = cur[1];
+            if (typeof maybeRc === 'string' && maybeRc.startsWith('rc_') && Array.isArray(maybeArr)) {
+                const text = maybeArr.filter(v => typeof v === 'string').join('');
+                if (text) {
+                    const prev = bestByRc.get(maybeRc) || '';
+                    if (text.length >= prev.length) bestByRc.set(maybeRc, text);
+                }
+            }
+            for (const v of cur) stack.push(v);
+        } else if (typeof cur === 'object') {
+            for (const v of Object.values(cur)) stack.push(v);
+        }
+    }
+
+    return bestByRc;
+}
+
+/**
+ * 从响应体 Buffer 中提取图片 URL
+ * @param {Buffer} bodyBuffer - 响应体 Buffer
+ * @returns {string[]} 图片 URL 数组
+ */
+function extractImageUrlsFromResponse(bodyBuffer) {
+    const frames = parseLenFramedResponse(bodyBuffer);
+    const payloads = extractPayloads(frames);
+
+    const allUrls = [];
+    for (const payload of payloads) {
+        const urls = collectImageUrlsDeep(payload);
+        allUrls.push(...urls);
+    }
+
+    // 去重
+    return [...new Set(allUrls)];
+}
+
+/**
+ * 从响应体 Buffer 中提取 AI 文本（用于错误提示）
+ * @param {Buffer} bodyBuffer - 响应体 Buffer
+ * @returns {string}
+ */
+function extractAiTextFromResponse(bodyBuffer) {
+    const frames = parseLenFramedResponse(bodyBuffer);
+    const payloads = extractPayloads(frames);
+
+    let best = '';
+    for (const payload of payloads) {
+        const m = collectRcTextsDeep(payload);
+        for (const text of m.values()) {
+            if (text.length > best.length) best = text;
+        }
+    }
+    return best;
+}

src/backend/adapter/gemini_biz.js

@@ -0,0 +1,317 @@
+/**
+ * @fileoverview Gemini Business 文本生成适配器
+ */
+
+import {
+    sleep,
+    safeClick,
+    pasteImages
+} from '../engine/utils.js';
+import {
+    fillPrompt,
+    submit,
+    normalizePageError,
+    normalizeHttpError,
+    waitApiResponse,
+    moveMouseAway,
+    waitForPageAuth,
+    lockPageAuth,
+    unlockPageAuth,
+    isPageAuthLocked,
+    waitForInput,
+    gotoWithCheck,
+    scrollToElement
+} from '../utils/index.js';
+import { logger } from '../../utils/logger.js';
+
+// Gemini Biz 输入框选择器
+const INPUT_SELECTOR = 'ucs-prosemirror-editor .ProseMirror';
+
+/**
+ * 处理账户选择页面跳转
+ * @param {import('playwright-core').Page} page - Playwright 页面对象
+ * @param {string} targetUrl - 目标 URL，用于判断跳转完成
+ * @returns {Promise<boolean>} 是否处理了跳转
+ */
+async function handleAccountChooser(page) {
+    // 防止重复处理
+    if (isPageAuthLocked(page)) return false;
+
+    try {
+        const currentUrl = page.url();
+        if (currentUrl.includes('auth.business.gemini.google/account-chooser')) {
+            lockPageAuth(page);
+            logger.info('适配器', '[登录器(gemini_biz)] 检测到账户选择页面，尝试自动确认...');
+
+            // 尝试查找提交按钮 (通常是标准的 button[type="submit"])
+            const submitBtn = await page.$('button[type="submit"]');
+            if (submitBtn) {
+                // 确保按钮在可视区域
+                await submitBtn.scrollIntoViewIfNeeded();
+                await sleep(300, 500);
+
+                // 使用 safeClick 模拟人类点击行为
+                logger.info('适配器', '[登录器(gemini_biz)] 正在点击确认按钮...');
+                await safeClick(page, submitBtn, { bias: 'button' });
+
+                // 点击后等待跳转回目标页面
+                logger.info('适配器', '[登录器(gemini_biz)] 等待跳转回目标页面...');
+                try {
+                    await page.waitForFunction(() => {
+                        const href = window.location.href;
+                        return !href.includes('accounts.google.com') &&
+                            !href.includes('auth.business.gemini.google') &&
+                            href.includes('business.gemini.google');
+                    }, { timeout: 60000, polling: 1000 });
+
+                    logger.info('适配器', `[登录器(gemini_biz)] 已跳转回目标页面`);
+                } catch (timeoutErr) {
+                    const finalUrl = page.url();
+                    logger.warn('适配器', `[登录器(gemini_biz)] 等待跳转回目标页面超时，尝试继续... 当前URL: ${finalUrl}`);
+                }
+
+                // 额外缓冲时间，确保页面完全加载
+                await sleep(2000, 3000);
+                unlockPageAuth(page);
+                return true;
+            } else {
+                // 按钮还没加载出来，保持锁，等待下次检查
+                logger.debug('适配器', '[登录器(gemini_biz)] 按钮尚未加载，等待中...');
+                await sleep(500, 1000);
+                unlockPageAuth(page); // 释放锁让下次尝试
+                return true; // 返回 true 表示"仍在处理中"
+            }
+        }
+    } catch (err) {
+        logger.warn('适配器', `[登录器(gemini_biz)] 处理账户选择页面失败: ${err.message}`);
+        unlockPageAuth(page);
+    }
+    return false;
+}
+
+
+/**
+ * 生成图片
+ * @param {object} context - 浏览器上下文 { page, client, config }
+ * @param {string} prompt - 提示词
+ * @param {string[]} imgPaths - 参考图片路径数组
+ * @param {string} modelId - 模型 ID (目前未使用,固定为 gemini-3-pro-preview)
+ * @returns {Promise<{image?: string, error?: string}>} 生成结果
+ */
+async function generate(context, prompt, imgPaths, modelId, meta = {}) {
+    const { page, config } = context;
+
+    try {
+        // 支持新路径 adapter.gemini_biz.entryUrl，向下兼容旧路径 geminiBiz.entryUrl
+        const targetUrl = config.backend?.adapter?.gemini_biz?.entryUrl || config.backend?.geminiBiz?.entryUrl;
+
+        if (!targetUrl) {
+            throw new Error('GeminiBiz backend missing entry URL');
+        }
+
+        // 开启新对话 - 先等待可能正在进行的登录处理完成
+        await waitForPageAuth(page);
+
+        logger.info('适配器', '开启新会话', meta);
+        await gotoWithCheck(page, targetUrl);
+
+        // 如果触发了账户选择跳转，等待全局处理器完成
+        await waitForPageAuth(page);
+
+        // 1. 等待输入框加载
+        logger.debug('适配器', '正在寻找输入框...', meta);
+        await waitForInput(page, INPUT_SELECTOR, { click: false });
+        await sleep(1500, 2500);
+
+        // 2. 上传图片 (uploadImages - 使用自定义验证器)
+        if (imgPaths && imgPaths.length > 0) {
+            const expectedUploads = imgPaths.length;
+            let uploadedCount = 0;
+            let metadataCount = 0;
+
+            await pasteImages(page, INPUT_SELECTOR, imgPaths, {
+                uploadValidator: (response) => {
+                    const url = response.url();
+                    if (response.status() === 200) {
+                        if (url.includes('global/widgetAddContextFile')) {
+                            uploadedCount++;
+                            logger.debug('适配器', `图片上传进度 (Add): ${uploadedCount}/${expectedUploads}`, meta);
+                            return false;
+                        } else if (url.includes('global/widgetListSessionFileMetadata')) {
+                            metadataCount++;
+                            logger.info('适配器', `图片上传进度: ${metadataCount}/${expectedUploads}`, meta);
+
+                            if (uploadedCount >= expectedUploads && metadataCount >= expectedUploads) {
+                                return true;
+                            }
+                        }
+                    }
+                    return false;
+                }
+            });
+
+            await sleep(1000, 2000);
+        }
+
+        // 3. 填写提示词 (fillPrompt)
+        await safeClick(page, INPUT_SELECTOR, { bias: 'input' });
+        await fillPrompt(page, INPUT_SELECTOR, prompt, meta);
+        await sleep(500, 1000);
+
+        // 4. 设置拦截器
+        logger.debug('适配器', '已启用请求拦截', meta);
+        await page.unroute('**/*').catch(() => { });
+
+        await page.route(url => url.href.includes('global/widgetStreamAssist'), async (route) => {
+            const request = route.request();
+            if (request.method() !== 'POST') return route.continue();
+
+            try {
+                const postData = request.postDataJSON();
+                if (postData) {
+                    logger.debug('适配器', '已拦截请求，正在修改...', meta);
+                    if (!postData.streamAssistRequest) postData.streamAssistRequest = {};
+                    if (!postData.streamAssistRequest.assistGenerationConfig) postData.streamAssistRequest.assistGenerationConfig = {};
+
+                    // 根据模型 ID 选择 toolsSpec
+                    if (modelId && modelId.startsWith('veo-')) {
+                        postData.streamAssistRequest.toolsSpec = { videoGenerationSpec: {} };
+                        logger.info('适配器', '已拦截请求，使用视频生成规格', meta);
+                    } else {
+                        postData.streamAssistRequest.toolsSpec = { imageGenerationSpec: {} };
+                        logger.info('适配器', '已拦截请求，使用图片生成规格', meta);
+                    }
+
+                    await route.continue({ postData: JSON.stringify(postData) });
+                    return;
+                }
+            } catch (e) {
+                logger.error('适配器', '请求拦截处理失败', { ...meta, error: e.message });
+            }
+            await route.continue();
+        });
+
+        // 5. 提交
+        logger.debug('适配器', '点击发送...', meta);
+        await submit(page, {
+            btnSelector: 'md-icon-button.send-button.submit, button[aria-label="提交"], button[aria-label="Send"], .send-button',
+            inputTarget: INPUT_SELECTOR,
+            meta
+        });
+
+        logger.info('适配器', '等待生成结果中...', meta);
+
+        // 6. 等待 API 响应
+        let apiResponse;
+        try {
+            apiResponse = await waitApiResponse(page, {
+                urlMatch: 'global/widgetStreamAssist',
+                method: 'POST',
+                timeout: 120000,
+                errorText: ['modelArmorViolation'],
+                meta
+            });
+        } catch (e) {
+            const pageError = normalizePageError(e, meta);
+            if (pageError) return pageError;
+            throw e;
+        }
+
+        // 检查 API 响应状态
+        const httpError = normalizeHttpError(apiResponse);
+        if (httpError) {
+            logger.error('适配器', `请求生成时返回错误: ${httpError.error}`, meta);
+            return { error: `请求生成时返回错误: ${httpError.error}` };
+        }
+
+        // 7. 等待图片下载响应 
+        logger.info('适配器', '已获取结果，正在下载图片...', meta);
+
+        let imageResponse;
+        try {
+            // 先启动监听器，再滚动触发懒加载，避免错过请求
+            const imageResponsePromise = waitApiResponse(page, {
+                urlMatch: 'download/v1alpha/projects',
+                method: 'GET',
+                timeout: 120000,
+                errorText: ['is unable to reply as the prompt'],
+                meta
+            });
+
+            // 等待图片元素出现并滚动到可视范围，触发懒加载
+            await scrollToElement(page, 'ucs-markdown-image', { timeout: 20000 });
+
+            imageResponse = await imageResponsePromise;
+        } catch (e) {
+            const pageError = normalizePageError(e, meta);
+            if (pageError) {
+                if (e.name === 'TimeoutError') {
+                    return { error: '已获取结果, 但图片下载时超时 (120秒)' };
+                }
+                return pageError;
+            }
+            throw e;
+        }
+
+
+        const base64 = await imageResponse.text();
+
+        // 从响应头获取内容类型
+        const contentType = imageResponse.headers()['x-goog-safety-content-type'] || 'image/png';
+        logger.info('适配器', `已下载内容，类型: ${contentType}`, meta);
+
+        const dataUri = `data:${contentType};base64,${base64}`;
+        return { image: dataUri };
+
+
+    } catch (err) {
+        // 顶层错误处理
+        const pageError = normalizePageError(err, meta);
+        if (pageError) return pageError;
+
+        logger.error('适配器', '生成任务失败', { ...meta, error: err.message });
+        return { error: `生成任务失败: ${err.message}` };
+    } finally {
+        // 清理拦截器
+        await page.unroute('**/*').catch(() => { });
+        // 任务结束，将鼠标移至安全区域
+        await moveMouseAway(page);
+    }
+}
+
+/**
+ * 适配器 manifest
+ */
+export const manifest = {
+    id: 'gemini_biz',
+    displayName: 'Gemini Business (图片、视频生成)',
+    description: '使用 Gemini Business 企业版生成图片和视频。需要提供入口 URL 并已登录企业账户 (每个谷歌账户首次可以在官网点击免费试用获取30天使用资格)。',
+
+    // 配置表单定义
+    configSchema: [
+        {
+            key: 'entryUrl',
+            label: '入口 URL',
+            type: 'string',
+            required: true,
+            placeholder: 'https://business.gemini.google/home/cid/8888a888-b6e0-88be-86e1-888cf3ee8cf4'
+        }
+    ],
+
+    // 入口 URL (从配置读取，支持新旧路径)
+    getTargetUrl(config, workerConfig) {
+        return config?.backend?.adapter?.gemini_biz?.entryUrl || config?.backend?.geminiBiz?.entryUrl || null;
+    },
+
+    // 模型列表
+    models: [
+        { id: 'gemini-3-pro-image-preview', imagePolicy: 'optional' },
+        { id: 'veo-3.1-generate-preview', imagePolicy: 'optional' },
+    ],
+
+    // 导航处理器
+    navigationHandlers: [handleAccountChooser],
+
+    // 核心生图方法
+    generate
+};

src/backend/adapter/gemini_biz_text.js

@@ -0,0 +1,348 @@
+/**
+ * @fileoverview Gemini Business 图片、视频生成适配器
+ */
+
+import {
+    sleep,
+    safeClick,
+    pasteImages
+} from '../engine/utils.js';
+import {
+    fillPrompt,
+    submit,
+    normalizePageError,
+    normalizeHttpError,
+    waitApiResponse,
+    moveMouseAway,
+    waitForPageAuth,
+    lockPageAuth,
+    unlockPageAuth,
+    isPageAuthLocked,
+    waitForInput,
+    gotoWithCheck
+} from '../utils/index.js';
+import { logger } from '../../utils/logger.js';
+
+// Gemini Biz 输入框选择器
+const INPUT_SELECTOR = 'ucs-prosemirror-editor .ProseMirror';
+
+/**
+ * 处理账户选择页面跳转
+ * @param {import('playwright-core').Page} page - Playwright 页面对象
+ * @param {string} targetUrl - 目标 URL，用于判断跳转完成
+ * @returns {Promise<boolean>} 是否处理了跳转
+ */
+async function handleAccountChooser(page) {
+    // 防止重复处理
+    if (isPageAuthLocked(page)) return false;
+
+    try {
+        const currentUrl = page.url();
+        if (currentUrl.includes('auth.business.gemini.google/account-chooser')) {
+            lockPageAuth(page);
+            logger.info('适配器', '[登录器(gemini_biz)] 检测到账户选择页面，尝试自动确认...');
+
+            // 尝试查找提交按钮 (通常是标准的 button[type="submit"])
+            const submitBtn = await page.$('button[type="submit"]');
+            if (submitBtn) {
+                // 确保按钮在可视区域
+                await submitBtn.scrollIntoViewIfNeeded();
+                await sleep(300, 500);
+
+                // 使用 safeClick 模拟人类点击行为
+                logger.info('适配器', '[登录器(gemini_biz)] 正在点击确认按钮...');
+                await safeClick(page, submitBtn, { bias: 'button' });
+
+                // 点击后等待跳转回目标页面
+                logger.info('适配器', '[登录器(gemini_biz)] 等待跳转回目标页面...');
+                try {
+                    await page.waitForFunction(() => {
+                        const href = window.location.href;
+                        return !href.includes('accounts.google.com') &&
+                            !href.includes('auth.business.gemini.google') &&
+                            href.includes('business.gemini.google');
+                    }, { timeout: 60000, polling: 1000 });
+
+                    logger.info('适配器', `[登录器(gemini_biz)] 已跳转回目标页面`);
+                } catch (timeoutErr) {
+                    const finalUrl = page.url();
+                    logger.warn('适配器', `[登录器(gemini_biz)] 等待跳转回目标页面超时，尝试继续... 当前URL: ${finalUrl}`);
+                }
+
+                // 额外缓冲时间，确保页面完全加载
+                await sleep(2000, 3000);
+                unlockPageAuth(page);
+                return true;
+            } else {
+                // 按钮还没加载出来，保持锁，等待下次检查
+                logger.debug('适配器', '[登录器(gemini_biz)] 按钮尚未加载，等待中...');
+                await sleep(500, 1000);
+                unlockPageAuth(page); // 释放锁让下次尝试
+                return true; // 返回 true 表示"仍在处理中"
+            }
+        }
+    } catch (err) {
+        logger.warn('适配器', `[登录器(gemini_biz)] 处理账户选择页面失败: ${err.message}`);
+        unlockPageAuth(page);
+    }
+    return false;
+}
+
+
+/**
+ * 生成图片
+ * @param {object} context - 浏览器上下文 { page, client, config }
+ * @param {string} prompt - 提示词
+ * @param {string[]} imgPaths - 参考图片路径数组
+ * @param {string} modelId - 模型 ID (目前未使用,固定为 gemini-3-pro-preview)
+ * @returns {Promise<{image?: string, error?: string}>} 生成结果
+ */
+async function generate(context, prompt, imgPaths, modelId, meta = {}) {
+    const { page, config } = context;
+
+    try {
+        // 支持新路径 adapter.gemini_biz.entryUrl，向下兼容旧路径 geminiBiz.entryUrl
+        const targetUrl = config.backend?.adapter?.gemini_biz?.entryUrl || config.backend?.geminiBiz?.entryUrl;
+
+        if (!targetUrl) {
+            throw new Error('GeminiBiz backend missing entry URL');
+        }
+
+        // 开启新对话 - 先等待可能正在进行的登录处理完成
+        await waitForPageAuth(page);
+
+        logger.info('适配器', '开启新会话', meta);
+        await gotoWithCheck(page, targetUrl);
+
+        // 如果触发了账户选择跳转，等待全局处理器完成
+        await waitForPageAuth(page);
+
+        // 1. 等待输入框加载
+        logger.debug('适配器', '正在寻找输入框...', meta);
+        await waitForInput(page, INPUT_SELECTOR, { click: false });
+        await sleep(1500, 2500);
+
+        // 2. 上传图片 (uploadImages - 使用自定义验证器)
+        if (imgPaths && imgPaths.length > 0) {
+            const expectedUploads = imgPaths.length;
+            let uploadedCount = 0;
+            let metadataCount = 0;
+
+            await pasteImages(page, INPUT_SELECTOR, imgPaths, {
+                uploadValidator: (response) => {
+                    const url = response.url();
+                    if (response.status() === 200) {
+                        if (url.includes('global/widgetAddContextFile')) {
+                            uploadedCount++;
+                            logger.debug('适配器', `图片上传进度 (Add): ${uploadedCount}/${expectedUploads}`, meta);
+                            return false;
+                        } else if (url.includes('global/widgetListSessionFileMetadata')) {
+                            metadataCount++;
+                            logger.info('适配器', `图片上传进度: ${metadataCount}/${expectedUploads}`, meta);
+
+                            if (uploadedCount >= expectedUploads && metadataCount >= expectedUploads) {
+                                return true;
+                            }
+                        }
+                    }
+                    return false;
+                }
+            });
+
+            await sleep(1000, 2000);
+        }
+
+        // 3. 填写提示词 (fillPrompt)
+        await safeClick(page, INPUT_SELECTOR, { bias: 'input' });
+        await fillPrompt(page, INPUT_SELECTOR, prompt, meta);
+        await sleep(500, 1000);
+
+        // 4. 设置请求拦截器（根据模型类型修改请求）
+        logger.debug('适配器', '已启用请求拦截', meta);
+        await page.unroute('**/*').catch(() => { });
+
+        // 判断是否为 grounding 模式
+        const isGrounding = modelId.endsWith('-grounding');
+        const actualModelId = isGrounding ? modelId.replace('-grounding', '') : modelId;
+
+        await page.route(url => url.href.includes('global/widgetStreamAssist'), async (route) => {
+            const request = route.request();
+            if (request.method() !== 'POST') return route.continue();
+
+            try {
+                const postData = request.postDataJSON();
+                if (postData) {
+                    logger.debug('适配器', '已拦截请求，正在修改...', meta);
+                    if (!postData.streamAssistRequest) postData.streamAssistRequest = {};
+                    if (!postData.streamAssistRequest.assistGenerationConfig) postData.streamAssistRequest.assistGenerationConfig = {};
+
+                    // 设置模型 ID
+                    postData.streamAssistRequest.assistGenerationConfig.modelId = actualModelId;
+
+                    // 根据模式设置 toolsSpec
+                    if (isGrounding) {
+                        postData.streamAssistRequest.toolsSpec = { webGroundingSpec: {} };
+                        logger.info('适配器', `已拦截请求，使用 Grounding 模式 (模型: ${actualModelId})`, meta);
+                    } else {
+                        // 文本模式不需要额外工具
+                        postData.streamAssistRequest.toolsSpec = {};
+                        logger.info('适配器', `已拦截请求，使用文本模式 (模型: ${actualModelId})`, meta);
+                    }
+
+                    await route.continue({ postData: JSON.stringify(postData) });
+                    return;
+                }
+            } catch (e) {
+                logger.error('适配器', '请求拦截处理失败', { ...meta, error: e.message });
+            }
+            await route.continue();
+        });
+
+        // 5. 提交 (submit - 使用公共函数)
+        logger.debug('适配器', '点击发送...', meta);
+        await submit(page, {
+            btnSelector: 'md-icon-button.send-button.submit, button[aria-label="提交"], button[aria-label="Send"], .send-button',
+            inputTarget: INPUT_SELECTOR,
+            meta
+        });
+
+        logger.info('适配器', '等待生成结果中...', meta);
+
+        // 6. 等待 API 响应
+        let apiResponse;
+        try {
+            apiResponse = await waitApiResponse(page, {
+                urlMatch: 'global/widgetStreamAssist',
+                method: 'POST',
+                timeout: 120000,
+                errorText: ['modelArmorViolation'],
+                meta
+            });
+        } catch (e) {
+            const pageError = normalizePageError(e, meta);
+            if (pageError) return pageError;
+            throw e;
+        }
+
+        // 检查 API 响应状态
+        const httpError = normalizeHttpError(apiResponse);
+        if (httpError) {
+            logger.error('适配器', `请求生成时返回错误: ${httpError.error}`, meta);
+            return { error: `请求生成时返回错误: ${httpError.error}` };
+        }
+
+        // 7. 解析文本响应
+        const content = await apiResponse.text();
+        logger.debug('适配器', `收到响应，长度: ${content.length}`, meta);
+
+        // 解析 JSON 数组响应
+        // 格式: [{uToken, streamAssistResponse: {answer: {replies: [...], state: "..."}}}, ...]
+        let fullText = '';
+        try {
+            const parsed = JSON.parse(content);
+
+            if (!Array.isArray(parsed)) {
+                logger.error('适配器', '响应不是数组格式', meta);
+                return { error: '响应格式错误：不是数组' };
+            }
+
+            for (const item of parsed) {
+                const response = item?.streamAssistResponse;
+                const answer = response?.answer;
+                const state = answer?.state;
+
+                // 如果是 SUCCEEDED 状态，跳过（只是告知会话结束）
+                if (state === 'SUCCEEDED') {
+                    continue;
+                }
+
+                // 只处理 IN_PROGRESS 状态
+                if (state === 'IN_PROGRESS') {
+                    const replies = answer?.replies;
+                    if (replies && replies.length > 0) {
+                        const groundedContent = replies[0]?.groundedContent?.content;
+
+                        // 如果是思考过程，跳过
+                        if (groundedContent?.thought === true) {
+                            continue;
+                        }
+
+                        // 提取文本内容
+                        const text = groundedContent?.text;
+                        if (text) {
+                            fullText += text;
+                        }
+                    }
+                }
+            }
+        } catch (e) {
+            logger.error('适配器', '解析响应失败', { ...meta, error: e.message });
+            return { error: `解析响应失败: ${e.message}` };
+        }
+
+        if (fullText) {
+            logger.info('适配器', `获取文本成功，长度: ${fullText.length}`, meta);
+            return { text: fullText };
+        } else {
+            logger.warn('适配器', '未解析到有效文本内容', { ...meta, preview: content.substring(0, 200) });
+            return { error: '未解析到有效文本内容' };
+        }
+
+    } catch (err) {
+        // 顶层错误处理
+        const pageError = normalizePageError(err, meta);
+        if (pageError) return pageError;
+
+        logger.error('适配器', '生成任务失败', { ...meta, error: err.message });
+        return { error: `生成任务失败: ${err.message}` };
+    } finally {
+        // 清理拦截器
+        await page.unroute('**/*').catch(() => { });
+        // 任务结束，将鼠标移至安全区域
+        await moveMouseAway(page);
+    }
+}
+
+/**
+ * 适配器 manifest
+ */
+export const manifest = {
+    id: 'gemini_biz_text',
+    displayName: 'Gemini Business (文本生成)',
+    description: '使用 Gemini Business 企业版生成文本，支持 Grounding 搜索模式。需要提供入口 URL 并已登录企业账户 (每个谷歌账户首次可以在官网点击免费试用获取30天使用资格)，与 gemini_biz 共享配置。',
+
+    // 配置表单定义（与 gemini_biz 共享配置）
+    configSchema: [
+        {
+            key: 'entryUrl',
+            label: '入口 URL',
+            type: 'string',
+            required: true,
+            placeholder: 'https://business.gemini.google/home/cid/8888a888-b6e0-88be-86e1-888cf3ee8cf4',
+            note: '与 gemini_biz 共享配置'
+        }
+    ],
+
+    // 入口 URL (从配置读取，与 gemini_biz 共享)
+    getTargetUrl(config, workerConfig) {
+        return config?.backend?.adapter?.gemini_biz?.entryUrl || config?.backend?.geminiBiz?.entryUrl || null;
+    },
+
+    // 模型列表
+    models: [
+        { id: 'gemini-3-pro', imagePolicy: 'optional', type: 'text' },
+        { id: 'gemini-2.5-pro', imagePolicy: 'optional', type: 'text' },
+        { id: 'gemini-3-flash-preview', imagePolicy: 'optional', type: 'text' },
+        { id: 'gemini-2.5-flash', imagePolicy: 'optional', type: 'text' },
+        { id: 'gemini-3-pro-grounding', imagePolicy: 'optional', type: 'text' },
+        { id: 'gemini-2.5-pro-grounding', imagePolicy: 'optional', type: 'text' },
+        { id: 'gemini-2.5-flash-grounding', imagePolicy: 'optional', type: 'text' },
+        { id: 'gemini-3-flash-preview-grounding', imagePolicy: 'optional', type: 'text' },
+    ],
+
+    // 导航处理器
+    navigationHandlers: [handleAccountChooser],
+
+    // 核心生图方法
+    generate
+};

src/backend/adapter/gemini_text.js

@@ -0,0 +1,429 @@
+/**
+ * @fileoverview Google Gemini 文本生成适配器
+ */
+
+import {
+    sleep,
+    safeClick,
+    uploadFilesViaChooser
+} from '../engine/utils.js';
+import {
+    fillPrompt,
+    normalizePageError,
+    normalizeHttpError,
+    moveMouseAway,
+    waitForInput,
+    gotoWithCheck,
+    waitApiResponse
+} from '../utils/index.js';
+import { logger } from '../../utils/logger.js';
+
+// --- 配置常量 ---
+const TARGET_URL = 'https://gemini.google.com/app?hl=en';
+
+/**
+ * 执行文本生成任务
+ * @param {object} context - 浏览器上下文 { page, config }
+ * @param {string} prompt - 提示词
+ * @param {string[]} imgPaths - 图片路径数组
+ * @param {string} [modelId] - 模型 ID (此适配器未使用)
+ * @param {object} [meta={}] - 日志元数据
+ * @returns {Promise<{text?: string, error?: string}>}
+ */
+async function generate(context, prompt, imgPaths, modelId, meta = {}) {
+    const { page } = context;
+    const inputLocator = page.getByRole('textbox');
+    const sendBtnLocator = page.getByRole('button', { name: 'Send message' });
+
+    try {
+        logger.info('适配器', '开启新会话...', meta);
+        await gotoWithCheck(page, TARGET_URL);
+
+        // 1. 等待输入框加载
+        await waitForInput(page, inputLocator, { click: false });
+        await sleep(1500, 2500);
+
+        // 2. 上传图片
+        if (imgPaths && imgPaths.length > 0) {
+            logger.debug('适配器', '点击加号按钮...', meta);
+            const uploadMenuBtn = page.getByRole('button', { name: 'Open upload file menu' });
+            await safeClick(page, uploadMenuBtn, { bias: 'button' });
+            await sleep(500, 1000);
+
+            const uploadFilesBtn = page.getByRole('button', { name: /Upload files/ });
+            await uploadFilesViaChooser(page, uploadFilesBtn, imgPaths, {
+                uploadValidator: (response) => {
+                    const url = response.url();
+                    return response.status() === 200 &&
+                        url.includes('google.com/upload/') &&
+                        url.includes('upload_id=');
+                }
+            });
+
+            await sleep(1000, 2000);
+        }
+
+        // 3. 填写提示词
+        await safeClick(page, inputLocator, { bias: 'input' });
+        await fillPrompt(page, inputLocator, prompt, meta);
+        await sleep(500, 1000);
+
+        // 4. 选择模型（如果指定了 modelId）
+        if (modelId) {
+            try {
+                logger.debug('适配器', `准备选择模型: ${modelId}`, meta);
+
+                // 点击输入框确保焦点
+                await inputLocator.focus();
+                await sleep(300, 500);
+
+                // 按 3 次 Tab 键到达模型选择按钮
+                await page.keyboard.press('Tab');
+                await sleep(100, 200);
+                await page.keyboard.press('Tab');
+                await sleep(100, 200);
+                await page.keyboard.press('Tab');
+                await sleep(200, 300);
+
+                // 按回车打开模型菜单
+                await page.keyboard.press('Enter');
+                await sleep(500, 800);
+
+                // 获取所有 menuitemradio 选项
+                const menuItems = await page.getByRole('menuitemradio').all();
+
+                if (menuItems.length === 0) {
+                    logger.warn('适配器', '未找到模型选项，使用默认模型', meta);
+                } else {
+                    // 获取所有选项的文本（去除前后空白）
+                    const itemTexts = [];
+                    for (const item of menuItems) {
+                        const text = await item.textContent();
+                        itemTexts.push((text || '').trim());
+                    }
+
+                    logger.debug('适配器', `可用模型选项: [${itemTexts.join('], [')}]`, meta);
+
+                    // 判断是否有 Pro 选项
+                    const hasPro = itemTexts.some(text => text.startsWith('Pro'));
+
+                    // 确定要选择的目标选项文本前缀
+                    let targetPrefix = null;
+
+                    if (hasPro) {
+                        // 有 Pro 选项的情况
+                        if (modelId === 'gemini-3-pro' || modelId === 'gemini-exp-1206') {
+                            targetPrefix = 'Pro';
+                        } else if (modelId === 'gemini-3-flash' || modelId === 'gemini-2.0-flash-exp') {
+                            targetPrefix = 'Thinking';
+                        } else {
+                            targetPrefix = 'Fast';
+                        }
+                    } else {
+                        // 没有 Pro 选项的情况
+                        if (modelId === 'gemini-3-pro' || modelId === 'gemini-exp-1206') {
+                            targetPrefix = 'Thinking';
+                        } else {
+                            targetPrefix = 'Fast';
+                        }
+                    }
+
+                    logger.debug('适配器', `目标模型前缀: "${targetPrefix}"`, meta);
+
+                    // 查找并点击对应的选项
+                    let found = false;
+                    for (let i = 0; i < menuItems.length; i++) {
+                        if (itemTexts[i].startsWith(targetPrefix)) {
+                            await safeClick(page, menuItems[i], { bias: 'button' });
+                            logger.info('适配器', `已选择模型: "${itemTexts[i]}"`, meta);
+                            found = true;
+                            break;
+                        }
+                    }
+
+                    if (!found) {
+                        logger.warn('适配器', `未找到匹配的模型选项 (${targetPrefix})，使用默认模型`, meta);
+                        // 按 Escape 关闭菜单
+                        await page.keyboard.press('Escape');
+                    }
+
+                    await sleep(300, 500);
+                }
+            } catch (e) {
+                logger.warn('适配器', `模型选择失败: ${e.message}，继续使用默认模型`, meta);
+                // 尝试关闭可能打开的菜单
+                try {
+                    await page.keyboard.press('Escape');
+                } catch { }
+            }
+        }
+
+        // 5. 点击发送
+        logger.debug('适配器', '点击发送...', meta);
+        await safeClick(page, sendBtnLocator, { bias: 'button' });
+
+        logger.info('适配器', '等待生成结果...', meta);
+
+        // 5. 等待 API 响应
+        let apiResponse;
+        try {
+            apiResponse = await waitApiResponse(page, {
+                urlMatch: 'assistant.lamda.BardFrontendService/StreamGenerate',
+                method: 'POST',
+                timeout: 120000,
+                meta
+            });
+        } catch (e) {
+            const pageError = normalizePageError(e, meta);
+            if (pageError) return pageError;
+            throw e;
+        }
+
+        // 检查 HTTP 错误
+        const httpError = normalizeHttpError(apiResponse);
+        if (httpError) {
+            logger.error('适配器', `API 返回错误: ${httpError.error}`, meta);
+            return { error: `API 返回错误: ${httpError.error}` };
+        }
+
+        // 6. 解析响应体
+        const bodyBuffer = await apiResponse.body();
+        logger.debug('适配器', `收到响应体，字节数: ${bodyBuffer.length}`, meta);
+
+        const text = getFinalAiTextFromResponse(bodyBuffer);
+
+        if (text) {
+            logger.info('适配器', `解析成功，文本长度: ${text.length}`, meta);
+            return { text };
+        } else {
+            return { error: '未能从响应中提取文本' };
+        }
+
+    } catch (err) {
+        const pageError = normalizePageError(err, meta);
+        if (pageError) return pageError;
+
+        logger.error('适配器', '生成任务失败', { ...meta, error: err.message });
+        return { error: `生成任务失败: ${err.message}` };
+    } finally {
+        await moveMouseAway(page);
+    }
+}
+
+/**
+ * 适配器 manifest
+ */
+export const manifest = {
+    id: 'gemini_text',
+    displayName: 'Google Gemini (文本生成)',
+    description: '使用 Google Gemini 官网生成文本，支持多模型切换和图片上传。需要已登录的 Google 账户。',
+
+    getTargetUrl(config, workerConfig) {
+        return TARGET_URL;
+    },
+
+    models: [
+        { id: 'gemini-2.0-flash-exp', imagePolicy: 'optional', type: 'text' },
+        { id: 'gemini-exp-1206', imagePolicy: 'optional', type: 'text' },
+        { id: 'gemini-3-pro', imagePolicy: 'optional', type: 'text' },
+        { id: 'gemini-3-flash', imagePolicy: 'optional', type: 'text' }
+    ],
+
+    navigationHandlers: [],
+
+    generate
+};
+
+// ==========================================
+// 解析 gRPC Batchexecute
+// ==========================================
+
+/**
+ * 解析 batchexecute/batch RPC 响应（直接操作 Buffer）
+ * @param {Buffer} buf - 响应体 Buffer
+ */
+function parseLenFramedResponse(buf) {
+    let i = 0;
+
+    // 去掉 )]}\' 这种 XSSI 前缀（通常是第一行）
+    if (buf.length >= 4 && buf[0] === 0x29 && buf[1] === 0x5d && buf[2] === 0x7d) {
+        const firstNl = buf.indexOf(0x0a);
+        if (firstNl !== -1) i = firstNl + 1;
+    }
+
+    const frames = [];
+
+    const readLineBuf = () => {
+        if (i >= buf.length) return null;
+        const nl = buf.indexOf(0x0a, i);
+        let line;
+        if (nl === -1) {
+            line = buf.slice(i);
+            i = buf.length;
+        } else {
+            line = buf.slice(i, nl);
+            i = nl + 1;
+        }
+        // strip trailing \r
+        if (line.length && line[line.length - 1] === 0x0d) line = line.slice(0, -1);
+        return line;
+    };
+
+    let pendingLen = null;
+
+    while (true) {
+        const lineBuf = readLineBuf();
+        if (lineBuf === null) break;
+
+        const lineStr = lineBuf.toString('utf8').trim();
+        if (!lineStr) continue;
+
+        // 先找长度行（纯数字）
+        if (pendingLen === null) {
+            if (/^\d+$/.test(lineStr)) pendingLen = Number(lineStr);
+            continue;
+        }
+
+        // 读到 payload 行；大多数情况下 payload 是单行 JSON。
+        // 这里**不依赖** pendingLen 的数值（它有时会不准），而是：
+        //   1) 先尝试解析当前行
+        //   2) 若报“JSON 未结束”一类错误，再把后续行拼上重试（极少见）
+        let chunkBuf = lineBuf;
+        let chunkStr = chunkBuf.toString('utf8').trim();
+
+        while (true) {
+            try {
+                frames.push(JSON.parse(chunkStr));
+                break;
+            } catch (e) {
+                // 只有在明显是“截断/未结束”的情况下，才继续拼下一行
+                const msg = String(e && e.message || '');
+                const looksTruncated = /Unexpected end of JSON input|Unterminated string/.test(msg);
+
+                if (!looksTruncated) {
+                    const head = chunkStr.slice(0, 220);
+                    const tail = chunkStr.slice(-220);
+                    throw new Error(
+                        `Chunk JSON parse failed: ${msg}\n` +
+                        `Chunk head: ${head}\n` +
+                        `Chunk tail: ${tail}\n` +
+                        `LenHeader: ${pendingLen} | ActualBytes: ${Buffer.byteLength(chunkStr, 'utf8')}`
+                    );
+                }
+
+                // 读取下一行进行拼接，但如果下一行是“纯数字长度行”，不要吞掉它
+                const savedPos = i;
+                const next = readLineBuf();
+                if (next === null) {
+                    const head = chunkStr.slice(0, 220);
+                    const tail = chunkStr.slice(-220);
+                    throw new Error(
+                        `Chunk JSON parse failed: ${msg} (EOF)\n` +
+                        `Chunk head: ${head}\n` +
+                        `Chunk tail: ${tail}\n` +
+                        `LenHeader: ${pendingLen} | ActualBytes: ${Buffer.byteLength(chunkStr, 'utf8')}`
+                    );
+                }
+
+                const nextStr = next.toString('utf8').trim();
+                if (/^\d+$/.test(nextStr)) {
+                    // 回退，交给外层当作下一段的 length line
+                    i = savedPos;
+                    const head = chunkStr.slice(0, 220);
+                    const tail = chunkStr.slice(-220);
+                    throw new Error(
+                        `Chunk JSON parse failed: ${msg} (hit next length line)\n` +
+                        `Chunk head: ${head}\n` +
+                        `Chunk tail: ${tail}\n` +
+                        `LenHeader: ${pendingLen} | ActualBytes: ${Buffer.byteLength(chunkStr, 'utf8')}`
+                    );
+                }
+
+                // 把分隔符 \n 加回去
+                chunkBuf = Buffer.concat([chunkBuf, Buffer.from('\n'), next]);
+                chunkStr = chunkBuf.toString('utf8').trim();
+            }
+        }
+
+        pendingLen = null;
+    }
+
+    return frames;
+}
+
+/**
+ * 把 frame 里的 payload 再 parse 一次
+ */
+function extractPayloads(frames) {
+    const payloads = [];
+    for (const frame of frames) {
+        if (!Array.isArray(frame)) continue;
+
+        // frame 可能是 [["wrb.fr", null, "<jsonstr>"]] 也可能有多个 item
+        for (const item of frame) {
+            if (!Array.isArray(item)) continue;
+            const payloadStr = item[2];
+            if (typeof payloadStr !== "string") continue;
+
+            try {
+                payloads.push(JSON.parse(payloadStr));
+            } catch {
+                // ignore non-payload frames
+            }
+        }
+    }
+    return payloads;
+}
+
+/**
+ * 在任意嵌套结构里，找形如 ["rc_xxx", ["text..."], ...] 的节点
+ */
+function collectRcTextsDeep(root) {
+    const bestByRc = new Map();
+
+    const stack = [root];
+    while (stack.length) {
+        const cur = stack.pop();
+        if (!cur) continue;
+
+        if (Array.isArray(cur)) {
+            const maybeRc = cur[0];
+            const maybeArr = cur[1];
+            if (
+                typeof maybeRc === "string" &&
+                maybeRc.startsWith("rc_") &&
+                Array.isArray(maybeArr)
+            ) {
+                const text = maybeArr.filter(v => typeof v === "string").join("");
+                if (text) {
+                    const prev = bestByRc.get(maybeRc) || "";
+                    if (text.length >= prev.length) bestByRc.set(maybeRc, text);
+                }
+            }
+
+            for (const v of cur) stack.push(v);
+        } else if (typeof cur === "object") {
+            for (const v of Object.values(cur)) stack.push(v);
+        }
+    }
+
+    return bestByRc;
+}
+
+/**
+ * 从响应体 Buffer 中提取最终 AI 文本
+ * @param {Buffer} bodyBuffer - 响应体 Buffer
+ */
+function getFinalAiTextFromResponse(bodyBuffer) {
+    const frames = parseLenFramedResponse(bodyBuffer);
+    const payloads = extractPayloads(frames);
+
+    let best = "";
+    for (const payload of payloads) {
+        const m = collectRcTextsDeep(payload);
+        for (const text of m.values()) {
+            if (text.length > best.length) best = text;
+        }
+    }
+    return best;
+}

src/backend/adapter/google_flow.js

@@ -0,0 +1,286 @@
+/**
+ * @fileoverview Google Flow 图片生成适配器
+ */
+
+import {
+    sleep,
+    safeClick,
+    uploadFilesViaChooser
+} from '../engine/utils.js';
+import {
+    fillPrompt,
+    normalizePageError,
+    moveMouseAway,
+    waitForInput,
+    gotoWithCheck,
+    waitApiResponse,
+    useContextDownload
+} from '../utils/index.js';
+import { logger } from '../../utils/logger.js';
+import sharp from 'sharp';
+
+// --- 配置常量 ---
+const TARGET_URL = 'https://labs.google/fx/zh/tools/flow';
+
+/**
+ * 根据图片路径检测其宽高比，返回 '16:9' 或 '9:16'
+ * @param {string} imgPath - 图片路径
+ * @returns {Promise<string>} 尺寸比例
+ */
+async function detectImageAspect(imgPath) {
+    try {
+        const metadata = await sharp(imgPath).metadata();
+        const { width, height } = metadata;
+        // 宽 >= 高 为横版，否则为竖版
+        return width >= height ? '16:9' : '9:16';
+    } catch (e) {
+        // 检测失败默认横版
+        return '16:9';
+    }
+}
+
+/**
+ * 执行图片生成任务
+ * @param {object} context - 浏览器上下文 { page, config }
+ * @param {string} prompt - 提示词
+ * @param {string[]} imgPaths - 图片路径数组
+ * @param {string} modelId - 模型 ID
+ * @param {object} [meta={}] - 日志元数据
+ * @returns {Promise<{image?: string, error?: string}>}
+ */
+async function generate(context, prompt, imgPaths, modelId, meta = {}) {
+    const { page } = context;
+
+    // 获取模型配置
+    const modelConfig = manifest.models.find(m => m.id === modelId) || manifest.models[0];
+    let { codeName, imageSize } = modelConfig;
+
+    // 如果 imageSize 为 '0'，根据第一张图片动态决定尺寸
+    if (imageSize === '0' && imgPaths && imgPaths.length > 0) {
+        imageSize = await detectImageAspect(imgPaths[0]);
+        logger.info('适配器', `根据图片检测尺寸: ${imageSize}`, meta);
+    } else if (imageSize === '0') {
+        // 没有图片时默认横版
+        imageSize = '16:9';
+    }
+
+    try {
+        // 1. 导航到入口页面
+        logger.info('适配器', '开启新会话...', meta);
+        await gotoWithCheck(page, TARGET_URL);
+        await sleep(1500, 2500);
+
+        // 2. 创建项目 - 点击 add_2 按钮
+        logger.debug('适配器', '创建新项目...', meta);
+        const addProjectBtn = page.getByRole('button', { name: /^add_2/ });
+        await addProjectBtn.waitFor({ state: 'visible', timeout: 30000 });
+        await safeClick(page, addProjectBtn, { bias: 'button' });
+        await sleep(1000, 1500);
+
+        // 3. 选择 Images 模式 (通过 combobox + option 选择)
+        logger.debug('适配器', '选择图片制作模式...', meta);
+        const modeCombo = page.getByRole('combobox').filter({
+            has: page.locator('i', { hasText: 'arrow_drop_down' })
+        });
+        await modeCombo.first().waitFor({ state: 'visible', timeout: 10000 });
+        await safeClick(page, modeCombo.first(), { bias: 'button' });
+        await sleep(500, 800);
+
+        const imageOption = page.getByRole('option').filter({
+            has: page.locator('i', { hasText: 'add_photo_alternate' })
+        });
+        await safeClick(page, imageOption.first(), { bias: 'button' });
+        await sleep(1000, 1500);
+
+        // 4. 打开 Tune 菜单进行配置
+        logger.debug('适配器', '打开设置菜单...', meta);
+        const tuneBtn = page.getByRole('button', { name: /^tune/ });
+        await tuneBtn.waitFor({ state: 'visible', timeout: 10000 });
+        await safeClick(page, tuneBtn, { bias: 'button' });
+        await sleep(800, 1200);
+
+        // 4.1 设置生成数量为 1 (链式 filter：包含数字1-4，排除模型和尺寸关键词)
+        logger.debug('适配器', '设置生成数量为 1...', meta);
+        const countCombobox = page.getByRole('combobox')
+            .filter({ hasText: /[1-4]/ })
+            .filter({ hasNotText: /Banana|Imagen/i })
+            .filter({ hasNotText: /16:9|9:16|1:1|4:3|3:4/ });
+
+        if (await countCombobox.count() > 0) {
+            await safeClick(page, countCombobox.first(), { bias: 'button' });
+            await sleep(300, 500);
+            await safeClick(page, page.getByRole('option', { name: '1' }), { bias: 'button' });
+            await sleep(300, 500);
+            logger.debug('适配器', '生成数量已设置为 1', meta);
+        } else {
+            logger.warn('适配器', '未找到数量选择 combobox，跳过', meta);
+        }
+
+        // 4.2 选择模型 (查找包含模型名称的 combobox)
+        logger.debug('适配器', `选择模型: ${codeName}...`, meta);
+        const modelCombobox = page.getByRole('combobox')
+            .filter({ hasText: /Nano Banana|Imagen 4/ });
+
+        if (await modelCombobox.count() > 0) {
+            await safeClick(page, modelCombobox.first(), { bias: 'button' });
+            await sleep(300, 500);
+            await safeClick(page, page.getByRole('option', { name: codeName, exact: true }), { bias: 'button' });
+            await sleep(300, 500);
+            logger.debug('适配器', `模型已设置为 ${codeName}`, meta);
+        }
+
+        // 4.3 选择横竖版 (查找包含比例的 combobox)
+        logger.debug('适配器', `选择尺寸: ${imageSize}...`, meta);
+        const sizeCombobox = page.getByRole('combobox')
+            .filter({ hasText: /16:9|9:16/ });
+
+        if (await sizeCombobox.count() > 0) {
+            await safeClick(page, sizeCombobox.first(), { bias: 'button' });
+            await sleep(300, 500);
+            const sizeOption = page.getByRole('option').filter({ hasText: imageSize });
+            await safeClick(page, sizeOption.first(), { bias: 'button' });
+            await sleep(300, 500);
+            logger.debug('适配器', `尺寸已设置为 ${imageSize}`, meta);
+        }
+
+        // 5. 上传图片 (如果有)
+        if (imgPaths && imgPaths.length > 0) {
+            logger.info('适配器', `开始上传 ${imgPaths.length} 张图片...`, meta);
+
+            for (let i = 0; i < imgPaths.length; i++) {
+                const imgPath = imgPaths[i];
+                logger.debug('适配器', `上传图片 ${i + 1}/${imgPaths.length}...`, meta);
+
+                // 5.1 点击 add 按钮
+                const addBtn = page.getByRole('button', { name: 'add' });
+                await addBtn.waitFor({ state: 'visible', timeout: 10000 });
+                await safeClick(page, addBtn, { bias: 'button' });
+                await sleep(500, 1000);
+
+                // 5.2 点击 upload 按钮并选择文件（不等待上传完成）
+                const uploadBtn = page.getByRole('button', { name: /^upload/ });
+                await uploadFilesViaChooser(page, uploadBtn, [imgPath]);
+                await sleep(500, 1000);
+
+                // 5.3 先启动上传监听，再点击 crop 按钮
+                const uploadResponsePromise = waitApiResponse(page, {
+                    urlMatch: 'v1:uploadUserImage',
+                    method: 'POST',
+                    timeout: 60000
+                });
+
+                const cropBtn = page.getByRole('button', { name: /^crop/ });
+                await cropBtn.waitFor({ state: 'visible', timeout: 10000 });
+                await safeClick(page, cropBtn, { bias: 'button' });
+
+                // 5.4 等待上传完成
+                await uploadResponsePromise;
+                logger.info('适配器', `图片 ${i + 1} 上传完成`, meta);
+                await sleep(1000, 1500);
+            }
+
+            logger.info('适配器', '所有图片上传完成', meta);
+        }
+
+        // 6. 输入提示词
+        logger.info('适配器', '输入提示词...', meta);
+        const textarea = page.locator('textarea[placeholder]');
+        await waitForInput(page, textarea, { click: true });
+        await fillPrompt(page, textarea, prompt, meta);
+        await sleep(500, 1000);
+
+        // 7. 先启动 API 监听，再点击发送
+        logger.debug('适配器', '启动 API 监听...', meta);
+        const apiResponsePromise = waitApiResponse(page, {
+            urlMatch: 'flowMedia:batchGenerateImages',
+            method: 'POST',
+            timeout: 120000,
+            meta
+        });
+
+        // 8. 点击发送按钮
+        logger.info('适配器', '点击发送...', meta);
+        const sendBtn = page.getByRole('button', { name: /^arrow_forward/ });
+        await sendBtn.waitFor({ state: 'visible', timeout: 10000 });
+        await safeClick(page, sendBtn, { bias: 'button' });
+
+        // 9. 等待 API 响应
+        logger.info('适配器', '等待生成结果...', meta);
+        const apiResponse = await apiResponsePromise;
+
+        // 10. 解析响应获取图片 URL
+        let imageUrl;
+        try {
+            const responseBody = await apiResponse.json();
+            imageUrl = responseBody?.media?.[0]?.image?.generatedImage?.fifeUrl;
+
+            if (!imageUrl) {
+                logger.error('适配器', '响应中没有图片 URL', meta);
+                return { error: '生成成功但响应中没有图片 URL' };
+            }
+
+            logger.info('适配器', '已获取图片链接', meta);
+        } catch (e) {
+            logger.error('适配器', '解析响应失败', { ...meta, error: e.message });
+            return { error: `解析响应失败: ${e.message}` };
+        }
+
+        // 11. 下载图片并转为 base64
+        logger.info('适配器', '正在下载图片...', meta);
+        const downloadResult = await useContextDownload(imageUrl, page);
+
+        if (downloadResult.error) {
+            logger.error('适配器', downloadResult.error, meta);
+            return downloadResult;
+        }
+
+        logger.info('适配器', '图片生成完成', meta);
+        return { image: downloadResult.image };
+
+    } catch (err) {
+        // 顶层错误处理
+        const pageError = normalizePageError(err, meta);
+        if (pageError) return pageError;
+
+        logger.error('适配器', '生成任务失败', { ...meta, error: err.message });
+        return { error: `生成任务失败: ${err.message}` };
+    } finally {
+        // 任务结束，将鼠标移至安全区域
+        await moveMouseAway(page);
+    }
+}
+
+/**
+ * 适配器 manifest
+ */
+export const manifest = {
+    id: 'google_flow',
+    displayName: 'Google Flow (图片生成)',
+    description: '使用 Google Labs Flow 工具生成图片，支持多张参考图片上传和横竖版选择。需要已登录的 Google 账户。',
+
+    // 入口 URL
+    getTargetUrl(config, workerConfig) {
+        return TARGET_URL;
+    },
+
+    // 模型列表
+    models: [
+        // 根据上传的第一张图片动态获取图片比例
+        { id: 'gemini-3-pro-image-preview', codeName: '🍌 Nano Banana Pro', imageSize: '0', imagePolicy: 'optional' },
+        { id: 'gemini-2.5-flash-image-preview', codeName: '🍌 Nano Banana', imageSize: '0', imagePolicy: 'optional' },
+        { id: 'imagen-4', codeName: 'Imagen 4', imageSize: '0', imagePolicy: 'optional' },
+        // 指定图片比例
+        { id: 'gemini-3-pro-image-preview-landspace', codeName: '🍌 Nano Banana Pro', imageSize: '16:9', imagePolicy: 'optional' },
+        { id: 'gemini-3-pro-image-preview-portrait', codeName: '🍌 Nano Banana Pro', imageSize: '9:16', imagePolicy: 'optional' },
+        { id: 'gemini-2.5-flash-image-preview-landspace', codeName: '🍌 Nano Banana', imageSize: '16:9', imagePolicy: 'optional' },
+        { id: 'gemini-2.5-flash-image-preview-portrait', codeName: '🍌 Nano Banana', imageSize: '9:16', imagePolicy: 'optional' },
+        { id: 'imagen-4-landspace', codeName: 'Imagen 4', imageSize: '16:9', imagePolicy: 'optional' },
+        { id: 'imagen-4-portrait', codeName: 'Imagen 4', imageSize: '9:16', imagePolicy: 'optional' }
+    ],
+
+    // 无需导航处理器
+    navigationHandlers: [],
+
+    // 核心图片生成方法
+    generate
+};

src/backend/adapter/lmarena.js

@@ -0,0 +1,238 @@
+/**
+ * @fileoverview LMArena 图片生成适配器
+ */
+
+import {
+    sleep,
+    safeClick,
+    pasteImages
+} from '../engine/utils.js';
+import {
+    fillPrompt,
+    submit,
+    waitApiResponse,
+    normalizePageError,
+    normalizeHttpError,
+    moveMouseAway,
+    waitForInput,
+    gotoWithCheck,
+    useContextDownload
+} from '../utils/index.js';
+import { logger } from '../../utils/logger.js';
+
+// --- 配置常量 ---
+const TARGET_URL = 'https://lmarena.ai/c/new?mode=direct&chat-modality=image';
+
+/**
+ * 从响应文本中提取图片 URL
+ * @param {string} text - 响应文本内容
+ * @returns {string|null} 提取到的图片 URL，如果未找到则返回 null
+ */
+function extractImage(text) {
+    if (!text) return null;
+    const lines = text.split('\n');
+    for (const line of lines) {
+        if (line.startsWith('a2:')) {
+            try {
+                const data = JSON.parse(line.substring(3));
+                if (data?.[0]?.image) return data[0].image;
+            } catch (e) { }
+        }
+    }
+    return null;
+}
+
+
+/**
+ * 执行生图任务
+ * @param {object} context - 浏览器上下文 { page, client }
+ * @param {string} prompt - 提示词
+ * @param {string[]} imgPaths - 图片路径数组
+ * @param {string} [modelId] - 指定的模型 ID (可选)
+ * @param {object} [meta={}] - 日志元数据
+ * @returns {Promise<{image?: string, text?: string, error?: string}>} 生成结果
+ */
+async function generate(context, prompt, imgPaths, modelId, meta = {}) {
+    const { page, config } = context;
+    const textareaSelector = 'textarea';
+
+    // Worker 已验证，直接解析模型配置
+    //const modelConfig = manifest.models.find(m => m.id === modelId);
+    //const codeName = modelConfig?.codeName;
+
+    try {
+        logger.info('适配器', '开启新会话...', meta);
+        await gotoWithCheck(page, TARGET_URL);
+
+        // 1. 等待输入框加载
+        await waitForInput(page, textareaSelector, { click: false });
+        await sleep(1500, 2500);
+
+        // 2. 选择模型(必须在上传图片之前,因为能否上传图片取决于模型 imagePolicy)
+        if (modelId) {
+            logger.debug('适配器', `选择模型: ${modelId}`, meta);
+            const modelCombobox = page.locator('#chat-area')
+                .locator('button[role="combobox"][aria-haspopup="dialog"]')
+                .last();
+
+            await modelCombobox.waitFor({ state: 'visible', timeout: 10000 });
+            await safeClick(page, modelCombobox, { bias: 'button' });
+            await sleep(500, 800);
+
+            // 模拟粘贴输入模型 ID 并回车
+            await page.evaluate((text) => {
+                document.execCommand('insertText', false, text);
+            }, modelId);
+            await sleep(300, 500);
+            await page.keyboard.press('Enter');
+            await sleep(500, 800);
+        }
+
+        // 3. 上传图片 (uploadImages)
+        if (imgPaths && imgPaths.length > 0) {
+            await pasteImages(page, textareaSelector, imgPaths);
+        }
+
+        // 4. 填写提示词 (fillPrompt)
+        await safeClick(page, textareaSelector, { bias: 'input' });
+        await fillPrompt(page, textareaSelector, prompt, meta);
+
+        // 5. 提交表单 (submit)
+        logger.debug('适配器', '点击发送...', meta);
+        await submit(page, {
+            btnSelector: 'button[type="submit"]',
+            inputTarget: textareaSelector,
+            meta
+        });
+
+        logger.info('适配器', '等待生成结果...', meta);
+
+        // 6. 等待 API 响应 (waitApiResponse)
+        let response;
+        try {
+            response = await waitApiResponse(page, {
+                urlMatch: '/nextjs-api/stream',
+                method: 'POST',
+                timeout: 120000,
+                meta
+            });
+        } catch (e) {
+            // 使用公共错误处理
+            const pageError = normalizePageError(e, meta);
+            if (pageError) return pageError;
+            throw e;
+        }
+
+        // 7. 解析响应结果
+        const content = await response.text();
+
+        // 8. 检查 HTTP 错误 (normalizeHttpError)
+        const httpError = normalizeHttpError(response, content);
+        if (httpError) {
+            logger.error('适配器', `请求生成时返回错误: ${httpError.error}`, meta);
+            return { error: `请求生成时返回错误: ${httpError.error}` };
+        }
+
+        // 9. 提取图片 URL
+        const img = extractImage(content);
+        if (img) {
+            // 检查是否配置了返回 URL
+            const returnUrl = config?.backend?.adapter?.lmarena?.returnUrl || false;
+            if (returnUrl) {
+                logger.info('适配器', '已获取结果，返回 URL', meta);
+                return { image: img };
+            }
+
+            logger.info('适配器', '已获取结果，正在下载图片...', meta);
+            const result = await useContextDownload(img, page);
+            if (result.image) {
+                logger.info('适配器', '已下载图片，任务完成', meta);
+            }
+            return result;
+        } else {
+            logger.warn('适配器', '未获得结果，响应中无图片数据', { ...meta, preview: content.substring(0, 150) });
+            return { text: `未获得结果，响应中无图片数据: ${content}` };
+        }
+
+    } catch (err) {
+        // 顶层错误处理
+        const pageError = normalizePageError(err, meta);
+        if (pageError) return pageError;
+
+        logger.error('适配器', '生成任务失败', { ...meta, error: err.message });
+        return { error: `生成任务失败: ${err.message}` };
+    } finally {
+        // 任务结束，将鼠标移至安全区域
+        await moveMouseAway(page);
+    }
+}
+
+/**
+ * 适配器 manifest
+ */
+export const manifest = {
+    id: 'lmarena',
+    displayName: 'LMArena (图片生成)',
+    description: '使用 LMArena 平台生成图片，支持多种图片生成模型。需要已登录的 LMArena 账户，若不登录会频繁弹出人机验证码且有速率限制。',
+
+    // 配置项模式
+    configSchema: [
+        {
+            key: 'returnUrl',
+            label: '返回图片 URL',
+            type: 'boolean',
+            default: false,
+            note: '开启后直接返回图片 URL (但其他不支持该选项的适配器仍然会返回 Base64)'
+        }
+    ],
+
+    // 入口 URL
+    getTargetUrl(config, workerConfig) {
+        return TARGET_URL;
+    },
+
+    // 模型列表
+    models: [
+        { id: 'gemini-3-pro-image-preview-2k', codeName: '019abc10-e78d-7932-b725-7f1563ed8a12', imagePolicy: 'optional' },
+        { id: 'gemini-3-pro-image-preview', codeName: '019aa208-5c19-7162-ae3b-0a9ddbb1e16a', imagePolicy: 'optional' },
+        { id: 'hunyuan-image-3.0', codeName: '7766a45c-1b6b-4fb8-9823-2557291e1ddd', imagePolicy: 'forbidden' },
+        { id: 'vidu-q2-image', codeName: '019adb32-afa4-749e-9992-39653b52fe13', imagePolicy: 'optional' },
+        { id: 'mai-image-1', codeName: '1b407d5c-1806-477c-90a5-e5c5a114f3bc', imagePolicy: 'forbidden' },
+        { id: 'imagen-4.0-fast-generate-001', codeName: 'f44fd4f8-af30-480f-8ce2-80b2bdfea55e', imagePolicy: 'forbidden' },
+        { id: 'flux-2-pro', codeName: '019abcf4-5600-7a8b-864d-9b8ab7ab7328', imagePolicy: 'optional' },
+        { id: 'recraft-v3', codeName: 'b88d5814-1d20-49cc-9eb6-e362f5851661', imagePolicy: 'forbidden' },
+        { id: 'flux-2-flex', codeName: '019abed6-d96e-7a2b-bf69-198c28bef281', imagePolicy: 'optional' },
+        { id: 'imagen-3.0-generate-002', codeName: '51ad1d79-61e2-414c-99e3-faeb64bb6b1b', imagePolicy: 'forbidden' },
+        { id: 'photon', codeName: 'e7c9fa2d-6f5d-40eb-8305-0980b11c7cab', imagePolicy: 'forbidden' },
+        { id: 'imagen-4.0-ultra-generate-001', codeName: '019ae6da-6438-7077-9d2d-b311a35645f8', imagePolicy: 'forbidden' },
+        { id: 'flux-2-dev', codeName: '019ae6a0-4773-77d5-8ffb-cc35813e063c', imagePolicy: 'optional' },
+        { id: 'imagen-4.0-generate-001', codeName: '019ae6da-6788-761a-8253-e0bb2bf2e3a9', imagePolicy: 'forbidden' },
+        { id: 'flux-2-max', codeName: '', imagePolicy: 'optional' },
+        { id: 'qwen-image-prompt-extend', codeName: '9fe82ee1-c84f-417f-b0e7-cab4ae4cf3f3', imagePolicy: 'forbidden' },
+        { id: 'qwen-image-edit', codeName: '995cf221-af30-466d-a809-8e0985f83649', imagePolicy: 'required' },
+        { id: 'ideogram-v3-quality', codeName: '73378be5-cdba-49e7-b3d0-027949871aa6', imagePolicy: 'forbidden' },
+        { id: 'hunyuan-image-2.1', codeName: 'a9a26426-5377-4efa-bef9-de71e29ad943', imagePolicy: 'forbidden' },
+        { id: 'qwen-image-2512', codeName: '', imagePolicy: 'forbidden' },
+        { id: 'wan2.5-t2i-preview', codeName: '019a5050-2875-78ed-ae3a-d9a51a438685', imagePolicy: 'forbidden' },
+        { id: 'reve-v1.1', codeName: '', imagePolicy: 'required' },
+        { id: 'chatgpt-image-latest', codeName: '', imagePolicy: 'optional' },
+        { id: 'seedream-4.5', codeName: '019abd43-b052-7eec-aa57-e895e45c9723', imagePolicy: 'optional' },
+        { id: 'gpt-image-1-mini', codeName: '0199c238-f8ee-7f7d-afc1-7e28fcfd21cf', imagePolicy: 'optional' },
+        { id: 'gpt-image-1', codeName: '6e855f13-55d7-4127-8656-9168a9f4dcc0', imagePolicy: 'optional' },
+        { id: 'gemini-2.0-flash-preview-image-generation', codeName: '69bbf7d4-9f44-447e-a868-abc4f7a31810', imagePolicy: 'optional' },
+        { id: 'gemini-2.5-flash-image-preview', codeName: '0199ef2a-583f-7088-b704-b75fd169401d', imagePolicy: 'optional' },
+        { id: 'seedream-3', codeName: 'd8771262-8248-4372-90d5-eb41910db034', imagePolicy: 'forbidden' },
+        { id: 'seedream-4-high-res-fal', codeName: '32974d8d-333c-4d2e-abf3-f258c0ac1310', imagePolicy: 'optional' },
+        { id: 'gpt-image-1.5', codeName: '', imagePolicy: 'optional' },
+        { id: 'flux-1-kontext-pro', codeName: '28a8f330-3554-448c-9f32-2c0a08ec6477', imagePolicy: 'optional' },
+        { id: 'wan2.5-i2i-preview', codeName: '019aeb62-c6ea-788e-88f9-19b1b48325b5', imagePolicy: 'required' },
+        { id: 'flux-1-kontext-dev', codeName: 'eb90ae46-a73a-4f27-be8b-40f090592c9a', imagePolicy: 'optional' },
+        { id: 'lucid-origin', codeName: '5a3b3520-c87d-481f-953c-1364687b6e8f', imagePolicy: 'forbidden' }
+    ],
+
+    // 无需导航处理器
+    navigationHandlers: [],
+
+    // 核心生图方法
+    generate
+};

src/backend/adapter/lmarena_text.js

@@ -0,0 +1,319 @@
+/**
+ * @fileoverview LMArena 文本生成适配器
+ */
+
+import {
+    sleep,
+    safeClick,
+    pasteImages
+} from '../engine/utils.js';
+import {
+    fillPrompt,
+    submit,
+    waitApiResponse,
+    normalizePageError,
+    normalizeHttpError,
+    moveMouseAway,
+    waitForInput,
+    gotoWithCheck
+} from '../utils/index.js';
+import { logger } from '../../utils/logger.js';
+
+// --- 配置常量 ---
+const TARGET_URL = 'https://lmarena.ai/c/new?mode=direct';
+const TARGET_URL_SEARCH = 'https://lmarena.ai/zh/c/new?mode=direct&chat-modality=search';
+
+/**
+ * 执行生图任务
+ * @param {object} context - 浏览器上下文 { page, client }
+ * @param {string} prompt - 提示词
+ * @param {string[]} imgPaths - 图片路径数组
+ * @param {string} [modelId] - 指定的模型 ID (可选)
+ * @param {object} [meta={}] - 日志元数据
+ * @returns {Promise<{image?: string, text?: string, error?: string}>} 生成结果
+ */
+async function generate(context, prompt, imgPaths, modelId, meta = {}) {
+    const { page, config } = context;
+    const textareaSelector = 'textarea';
+
+    // Worker 已验证，直接解析模型配置
+    const modelConfig = manifest.models.find(m => m.id === modelId);
+    const { codeName, search } = modelConfig || {};
+    const targetUrl = search ? TARGET_URL_SEARCH : TARGET_URL;
+
+    try {
+        logger.info('适配器', `开启新会话... (搜索模式: ${!!search})`, meta);
+        await gotoWithCheck(page, targetUrl);
+
+        // 1. 等待输入框加载
+        await waitForInput(page, textareaSelector, { click: false });
+        await sleep(1500, 2500);
+
+        // 2. 选择模型(必须在上传图片之前,因为能否上传图片取决于模型 imagePolicy)
+        if (modelId) {
+            logger.debug('适配器', `选择模型: ${modelId}`, meta);
+            const modelCombobox = page.locator('#chat-area')
+                .locator('button[role="combobox"][aria-haspopup="dialog"]')
+                .last();
+
+            await modelCombobox.waitFor({ state: 'visible', timeout: 10000 });
+            await safeClick(page, modelCombobox, { bias: 'button' });
+            await sleep(500, 800);
+
+            // 模拟粘贴输入模型 ID 并回车
+            await page.evaluate((text) => {
+                document.execCommand('insertText', false, text);
+            }, modelId);
+            await sleep(300, 500);
+            await page.keyboard.press('Enter');
+            await sleep(500, 800);
+        }
+
+        // 3. 上传图片 (uploadImages)
+        if (imgPaths && imgPaths.length > 0) {
+            await pasteImages(page, textareaSelector, imgPaths);
+        }
+
+        // 4. 填写提示词 (fillPrompt)
+        await safeClick(page, textareaSelector, { bias: 'input' });
+        await fillPrompt(page, textareaSelector, prompt, meta);
+
+        // 5. 提交表单 (submit)
+        logger.debug('适配器', '点击发送...', meta);
+        await submit(page, {
+            btnSelector: 'button[type="submit"]',
+            inputTarget: textareaSelector,
+            meta
+        });
+
+        logger.info('适配器', '等待生成结果...', meta);
+
+        // 6. 等待 API 响应 (waitApiResponse)
+        let response;
+        try {
+            response = await waitApiResponse(page, {
+                urlMatch: '/nextjs-api/stream',
+                method: 'POST',
+                timeout: 120000,
+                meta
+            });
+        } catch (e) {
+            // 使用公共错误处理
+            const pageError = normalizePageError(e, meta);
+            if (pageError) return pageError;
+            throw e;
+        }
+
+        // 7. 解析响应结果
+        const content = await response.text();
+
+        // 8. 检查 HTTP 错误
+        const httpError = normalizeHttpError(response, content);
+        if (httpError) {
+            logger.error('适配器', `请求生成时返回错误: ${httpError.error}`, meta);
+            return { error: `请求生成时返回错误: ${httpError.error}` };
+        }
+
+        // 9. 解析文本流
+        // 格式示例:
+        // a0:"Hello"
+        // a0:" World"
+        // d:{"finishReason":"stop"}
+        let fullText = '';
+        const lines = content.split('\n');
+
+        for (const line of lines) {
+            if (line.startsWith('a0:')) {
+                try {
+                    // 尝试解析 JSON 字符串内容
+                    // line.substring(3) 应该是 JSON 字符串，如 "Hello"
+                    const textPart = JSON.parse(line.substring(3));
+                    fullText += textPart;
+                } catch (e) {
+                    // 如果解析失败，可能是原生文本或其他格式
+                    logger.warn('适配器', `解析文本块失败: ${line}`, meta);
+                }
+            }
+        }
+
+        if (fullText) {
+            logger.info('适配器', `获取文本成功，长度: ${fullText.length}`, meta);
+            return { text: fullText };
+        } else {
+            logger.warn('适配器', '未解析到有效文本内容', { ...meta, preview: content.substring(0, 150) });
+            // 如果没解析到 a0，尝试直接返回原始内容防空
+            return { error: '未解析到有效文本内容' };
+        }
+
+    } catch (err) {
+        // 顶层错误处理
+        const pageError = normalizePageError(err, meta);
+        if (pageError) return pageError;
+
+        logger.error('适配器', '生成任务失败', { ...meta, error: err.message });
+        return { error: `生成任务失败: ${err.message}` };
+    } finally {
+        // 任务结束，将鼠标移至安全区域
+        await moveMouseAway(page);
+    }
+}
+
+/**
+ * 适配器 manifest
+ */
+export const manifest = {
+    id: 'lmarena_text',
+    displayName: 'LMArena (文本生成)',
+    description: '使用 LMArena 平台生成文本，支持多种大语言模型和搜索模式。需要已登录的 LMArena 账户，若不登录会频繁弹出人机验证码且有速率限制。',
+
+    // 入口 URL
+    getTargetUrl(config, workerConfig) {
+        return TARGET_URL;
+    },
+
+    // 模型列表（根据最新支持列表整理）
+    models: [
+        // --- 文本模型 ---
+        { id: 'claude-opus-4-5-20251101-thinking-32k', codeName: '019ab8b2-9bcf-79b5-9fb5-149a7c67b7c0', imagePolicy: 'forbidden', type: 'text' },
+        { id: 'claude-opus-4-5-20251101', codeName: '019adbec-8396-71cc-87d5-b47f8431a6a6', imagePolicy: 'forbidden', type: 'text' },
+        { id: 'gemini-3-pro', codeName: '019a98f7-afcd-779f-8dcb-856cc3b3f078', imagePolicy: 'optional', type: 'text' },
+        { id: 'grok-4.1-thinking', codeName: '019a9389-a9d3-77a8-afbb-4fe4dd3d8630', imagePolicy: 'forbidden', type: 'text' },
+        { id: 'grok-4.1', codeName: '019a9389-a4d8-748d-9939-b4640198302e', imagePolicy: 'forbidden', type: 'text' },
+        { id: 'gpt-5.1-high', codeName: '019a8548-a2b1-70ce-b1be-eba096d41f58', imagePolicy: 'optional', type: 'text' },
+        { id: 'gemini-2.5-pro', codeName: '0199f060-b306-7e1f-aeae-0ebb4e3f1122', imagePolicy: 'optional', type: 'text' },
+        { id: 'claude-sonnet-4-5-20250929-thinking-32k', codeName: 'b0ea1407-2f92-4515-b9cc-b22a6d6c14f2', imagePolicy: 'forbidden', type: 'text' },
+        { id: 'claude-opus-4-1-20250805-thinking-16k', codeName: 'f1a2eb6f-fc30-4806-9e00-1efd0d73cbc4', imagePolicy: 'forbidden', type: 'text' },
+        { id: 'claude-sonnet-4-5-20250929', codeName: '019a2d13-28a5-7205-908c-0a58de904617', imagePolicy: 'forbidden', type: 'text' },
+        { id: 'claude-opus-4-1-20250805', codeName: '96ae95fd-b70d-49c3-91cc-b58c7da1090b', imagePolicy: 'forbidden', type: 'text' },
+        { id: 'chatgpt-4o-latest-20250326', codeName: '0199c1e0-3720-742d-91c8-787788b0a19b', imagePolicy: 'optional', type: 'text' },
+        { id: 'gpt-5.1', codeName: '019a7ebf-0f3f-7518-8899-fca13e32d9dc', imagePolicy: 'optional', type: 'text' },
+        { id: 'gpt-5-high', codeName: '983bc566-b783-4d28-b24c-3c8b08eb1086', imagePolicy: 'optional', type: 'text' },
+        { id: 'o3-2025-04-16', codeName: 'cb0f1e24-e8e9-4745-aabc-b926ffde7475', imagePolicy: 'optional', type: 'text' },
+        { id: 'qwen3-max-preview', codeName: '812c93cc-5f88-4cff-b9ca-c11a26599b0e', imagePolicy: 'forbidden', type: 'text' },
+        { id: 'grok-4-1-fast-reasoning', codeName: '019aa41a-0a13-714a-beb1-be4a918a4b56', imagePolicy: 'forbidden', type: 'text' },
+        { id: 'ernie-5.0-preview-1103', codeName: '019a4ca9-720d-75f5-9012-883ce8ff61df', imagePolicy: 'forbidden', type: 'text' },
+        { id: 'kimi-k2-thinking-turbo', codeName: '019a59bc-8bb8-7933-92eb-fe143770c211', imagePolicy: 'forbidden', type: 'text' },
+        { id: 'gpt-5-chat', codeName: '4b11c78c-08c8-461c-938e-5fc97d56a40d', imagePolicy: 'optional', type: 'text' },
+        { id: 'glm-4.6', codeName: 'f595e6f1-6175-4880-a9eb-377e390819e4', imagePolicy: 'forbidden', type: 'text' },
+        { id: 'qwen3-max-2025-09-23', codeName: '98ad8b8b-12cd-46cd-98de-99edde7e03eb', imagePolicy: 'forbidden', type: 'text' },
+        { id: 'claude-opus-4-20250514-thinking-16k', codeName: '3b5e9593-3dc0-4492-a3da-19784c4bde75', imagePolicy: 'forbidden', type: 'text' },
+        { id: 'qwen3-235b-a22b-instruct-2507', codeName: 'ee7cb86e-8601-4585-b1d0-7c7380f8f6f4', imagePolicy: 'forbidden', type: 'text' },
+        { id: 'grok-4-fast-chat', codeName: 'grok-4-fast-chat', imagePolicy: 'forbidden', type: 'text' },
+        { id: 'deepseek-v3.2-thinking', codeName: '019adb32-bb7a-77eb-882f-b8e3aaa2b2fd', imagePolicy: 'forbidden', type: 'text' },
+        { id: 'kimi-k2-0905-preview', codeName: 'b88e983b-9459-473d-8bf1-753932f1679a', imagePolicy: 'forbidden', type: 'text' },
+        { id: 'kimi-k2-0711-preview', codeName: '7a3626fc-4e64-4c9e-821f-b449a4b43b6a', imagePolicy: 'forbidden', type: 'text' },
+        { id: 'deepseek-v3.2', codeName: '019adb32-b716-7591-9a2f-c6882973e340', imagePolicy: 'forbidden', type: 'text' },
+        { id: 'qwen3-vl-235b-a22b-instruct', codeName: '716aa8ca-d729-427f-93ab-9579e4a13e98', imagePolicy: 'optional', type: 'text' },
+        { id: 'mistral-large-3', codeName: '019acbac-df7c-73dc-9716-ebe040daaa4e', imagePolicy: 'forbidden', type: 'text' },
+        { id: 'gpt-4.1-2025-04-14', codeName: '14e9311c-94d2-40c2-8c54-273947e208b0', imagePolicy: 'optional', type: 'text' },
+        { id: 'claude-opus-4-20250514', codeName: 'ee116d12-64d6-48a8-88e5-b2d06325cdd2', imagePolicy: 'forbidden', type: 'text' },
+        { id: 'mistral-medium-2508', codeName: '27035fb8-a25b-4ec9-8410-34be18328afd', imagePolicy: 'optional', type: 'text' },
+        { id: 'grok-4-0709', codeName: 'b9edb8e9-4e98-49e7-8aaf-ae67e9797a11', imagePolicy: 'optional', type: 'text' },
+        { id: 'glm-4.5', codeName: 'd079ef40-3b20-4c58-ab5e-243738dbada5', imagePolicy: 'forbidden', type: 'text' },
+        { id: 'gemini-2.5-flash', codeName: '0199f059-3877-7cfe-bc80-e01b1a4a83de', imagePolicy: 'optional', type: 'text' },
+        { id: 'gemini-2.5-flash-preview-09-2025', codeName: 'fc700d46-c4c1-4fec-88b5-f086876ae0bb', imagePolicy: 'optional', type: 'text' },
+        { id: 'claude-haiku-4-5-20251001', codeName: '0199e8e9-01ed-73e0-96ba-cf43b286bf10', imagePolicy: 'forbidden', type: 'text' },
+        { id: 'qwen3-next-80b-a3b-instruct', codeName: '351fe482-eb6c-4536-857b-909e16c0bf52', imagePolicy: 'forbidden', type: 'text' },
+        { id: 'longcat-flash-chat', codeName: '6fcbe051-f521-4dc7-8986-c429eb6191bf', imagePolicy: 'forbidden', type: 'text' },
+        { id: 'qwen3-235b-a22b-no-thinking', codeName: '1a400d9a-f61c-4bc2-89b4-a9b7e77dff12', imagePolicy: 'forbidden', type: 'text' },
+        { id: 'qwen3-235b-a22b-thinking-2507', codeName: '16b8e53a-cc7b-4608-a29a-20d4dac77cf2', imagePolicy: 'forbidden', type: 'text' },
+        { id: 'qwen3-vl-235b-a22b-thinking', codeName: '03c511f5-0d35-4751-aae6-24f918b0d49e', imagePolicy: 'optional', type: 'text' },
+        { id: 'gpt-5-mini-high', codeName: '5fd3caa8-fe4c-41a5-a22c-0025b58f4b42', imagePolicy: 'optional', type: 'text' },
+        { id: 'deepseek-v3-0324', codeName: '2f5253e4-75be-473c-bcfc-baeb3df0f8ad', imagePolicy: 'forbidden', type: 'text' },
+        { id: 'hunyuan-vision-1.5-thinking', codeName: '6a3a1e04-050e-4cb4-9052-b9ac4bec0c38', imagePolicy: 'optional', type: 'text' },
+        { id: 'o4-mini-2025-04-16', codeName: 'f1102bbf-34ca-468f-a9fc-14bcf63f315b', imagePolicy: 'optional', type: 'text' },
+        { id: 'claude-sonnet-4-20250514', codeName: 'ac44dd10-0666-451c-b824-386ccfea7bcc', imagePolicy: 'forbidden', type: 'text' },
+        { id: 'claude-3-7-sonnet-20250219-thinking-32k', codeName: 'be98fcfd-345c-4ae1-9a82-a19123ebf1d2', imagePolicy: 'forbidden', type: 'text' },
+        { id: 'qwen3-coder-480b-a35b-instruct', codeName: 'af033cbd-ec6c-42cc-9afa-e227fc12efe8', imagePolicy: 'forbidden', type: 'text' },
+        { id: 'hunyuan-t1-20250711', codeName: 'ba8c2392-4c47-42af-bfee-c6c057615a91', imagePolicy: 'forbidden', type: 'text' },
+        { id: 'mistral-medium-2505', codeName: '27b9f8c6-3ee1-464a-9479-a8b3c2a48fd4', imagePolicy: 'optional', type: 'text' },
+        { id: 'qwen3-30b-a3b-instruct-2507', codeName: 'a8d1d310-e485-4c50-8f27-4bff18292a99', imagePolicy: 'forbidden', type: 'text' },
+        { id: 'gpt-4.1-mini-2025-04-14', codeName: '6a5437a7-c786-467b-b701-17b0bc8c8231', imagePolicy: 'optional', type: 'text' },
+        { id: 'gemini-2.5-flash-lite-preview-09-2025-no-thinking', codeName: '75555628-8c14-402a-8d6e-43c19cb40116', imagePolicy: 'optional', type: 'text' },
+        { id: 'gemini-2.5-flash-lite-preview-06-17-thinking', codeName: '04ec9a17-c597-49df-acf0-963da275c246', imagePolicy: 'optional', type: 'text' },
+        { id: 'qwen3-235b-a22b', codeName: '2595a594-fa54-4299-97cd-2d7380d21c80', imagePolicy: 'forbidden', type: 'text' },
+        { id: 'claude-3-5-sonnet-20241022', codeName: 'f44e280a-7914-43ca-a25d-ecfcc5d48d09', imagePolicy: 'forbidden', type: 'text' },
+        { id: 'claude-3-7-sonnet-20250219', codeName: 'c5a11495-081a-4dc6-8d9a-64a4fd6f7bbc', imagePolicy: 'forbidden', type: 'text' },
+        { id: 'glm-4.5-air', codeName: '7bfb254a-5d32-4ce2-b6dc-2c7faf1d5fe8', imagePolicy: 'forbidden', type: 'text' },
+        { id: 'qwen3-next-80b-a3b-thinking', codeName: '73cf8705-98c8-4b75-8d04-e3746e1c1565', imagePolicy: 'forbidden', type: 'text' },
+        { id: 'minimax-m1', codeName: '87e8d160-049e-4b4e-adc4-7f2511348539', imagePolicy: 'forbidden', type: 'text' },
+        { id: 'gemma-3-27b-it', codeName: '789e245f-eafe-4c72-b563-d135e93988fc', imagePolicy: 'optional', type: 'text' },
+        { id: 'grok-3-mini-high', codeName: '149619f1-f1d5-45fd-a53e-7d790f156f20', imagePolicy: 'forbidden', type: 'text' },
+        { id: 'gemini-2.0-flash-001', codeName: '7a55108b-b997-4cff-a72f-5aa83beee918', imagePolicy: 'optional', type: 'text' },
+        { id: 'grok-3-mini-beta', codeName: '7699c8d4-0742-42f9-a117-d10e84688dab', imagePolicy: 'forbidden', type: 'text' },
+        { id: 'mistral-small-2506', codeName: 'bbad1d17-6aa5-4321-949c-d11fb6289241', imagePolicy: 'optional', type: 'text' },
+        { id: 'gpt-oss-120b', codeName: '6ee9f901-17b5-4fbe-9cc2-13c16497c23b', imagePolicy: 'forbidden', type: 'text' },
+        { id: 'glm-4.5v', codeName: '9dab0475-a0cc-4524-84a2-3fd25aa8c768', imagePolicy: 'optional', type: 'text' },
+        { id: 'command-a-03-2025', codeName: '0f785ba1-efcb-472d-961e-69f7b251c7e3', imagePolicy: 'forbidden', type: 'text' },
+        { id: 'amazon-nova-experimental-chat-10-20', codeName: '019a4c75-256c-790b-9088-4694cc63c507', imagePolicy: 'forbidden', type: 'text' },
+        { id: 'intellect-3', codeName: '019aebfd-af0e-7f0c-8f0d-96c588e4cd3b', imagePolicy: 'forbidden', type: 'text' },
+        { id: 'o3-mini', codeName: 'c680645e-efac-4a81-b0af-da16902b2541', imagePolicy: 'forbidden', type: 'text' },
+        { id: 'ling-flash-2.0', codeName: '71f96ca9-4cf8-4be7-bac2-2231613930a6', imagePolicy: 'forbidden', type: 'text' },
+        { id: 'minimax-m2', codeName: '019a27e0-e7d8-7b0b-877c-a2106c6eb87d', imagePolicy: 'forbidden', type: 'text' },
+        { id: 'step-3', codeName: '1ea13a81-93a7-4804-bcdd-693cd72e302d', imagePolicy: 'forbidden', type: 'text' },
+        { id: 'gpt-5-nano-high', codeName: '2dc249b3-98da-44b4-8d1e-6666346a8012', imagePolicy: 'optional', type: 'text' },
+        { id: 'nova-2-lite', codeName: '019ae300-83b7-7717-a1e0-31accd1ff6fa', imagePolicy: 'forbidden', type: 'text' },
+        { id: 'qwq-32b', codeName: '885976d3-d178-48f5-a3f4-6e13e0718872', imagePolicy: 'forbidden', type: 'text' },
+        { id: 'llama-4-maverick-17b-128e-instruct', codeName: 'b5ad3ab7-fc56-4ecd-8921-bd56b55c1159', imagePolicy: 'optional', type: 'text' },
+        { id: 'qwen3-30b-a3b', codeName: '9a066f6a-7205-4325-8d0b-d81cc4b049c0', imagePolicy: 'forbidden', type: 'text' },
+        { id: 'claude-3-5-haiku-20241022', codeName: 'claude-3-5-haiku-20241022', imagePolicy: 'forbidden', type: 'text' },
+        { id: 'ring-flash-2.0', codeName: '11ad4114-c868-4fed-b6e7-d535dc9c62f8', imagePolicy: 'forbidden', type: 'text' },
+        { id: 'llama-3.3-70b-instruct', codeName: 'dcbd7897-5a37-4a34-93f1-76a24c7bb028', imagePolicy: 'forbidden', type: 'text' },
+        { id: 'gemma-3n-e4b-it', codeName: '896a3848-ae03-4651-963b-7d8f54b61ae8', imagePolicy: 'forbidden', type: 'text' },
+        { id: 'gpt-oss-20b', codeName: 'ec3beb4b-7229-4232-bab9-670ee52dd711', imagePolicy: 'forbidden', type: 'text' },
+        { id: 'mercury', codeName: '019a6f77-e20d-7c1d-a7cd-8bd926e7395d', imagePolicy: 'forbidden', type: 'text' },
+        { id: 'olmo-3-32b-think', codeName: '019ac2ef-27e1-769f-8258-d131f79e28ef', imagePolicy: 'forbidden', type: 'text' },
+        { id: 'mistral-small-3.1-24b-instruct-2503', codeName: '69f5d38a-45f5-4d3a-9320-b866a4035ed9', imagePolicy: 'optional', type: 'text' },
+        { id: 'ibm-granite-h-small', codeName: '4ddb69f5-391a-4f78-af92-7d7328c18ab1', imagePolicy: 'forbidden', type: 'text' },
+        { id: 'qwen3-vl-8b-thinking', codeName: '0199e3d1-a308-77b9-a650-41453e8ef2fb', imagePolicy: 'optional', type: 'text' },
+        { id: 'qwen3-vl-8b-instruct', codeName: '0199e3d1-a713-7de2-a5dd-a1583cad9532', imagePolicy: 'optional', type: 'text' },
+        { id: 'amazon.nova-pro-v1:0', codeName: 'a14546b5-d78d-4cf6-bb61-ab5b8510a9d6', imagePolicy: 'optional', type: 'text' },
+        { id: 'glm-4.6v', codeName: '019b151a-7c3b-72a2-8811-0bf9317c2ef5', imagePolicy: 'optional', type: 'text' },
+        { id: 'gpt-5.2-high', codeName: '019b1448-dafa-7f92-90c3-50e159c2263c', imagePolicy: 'optional', type: 'text' },
+        { id: 'gpt-5.2', codeName: '019b1448-d548-78f4-8b98-788d72cbd057', imagePolicy: 'optional', type: 'text' },
+        { id: 'glm-4.6v-flash', codeName: '019b1536-49c0-73b2-8d45-403b8571568d', imagePolicy: 'optional', type: 'text' },
+        { id: 'mimo-vl-7b-rl-2508', codeName: '1c0259b5-dff7-48ce-bca1-b6957675463b', imagePolicy: 'optional', type: 'text' },
+        { id: 'minimax-m2.1-preview', codeName: '', imagePolicy: 'forbidden', type: 'text' },
+        { id: 'mimo-v2-flash (thinking)', codeName: '', imagePolicy: 'forbidden', type: 'text' },
+        { id: 'glm-4.7', codeName: '', imagePolicy: 'forbidden', type: 'text' },
+        { id: 'amazon-nova-experimental-chat-11-10', codeName: '', imagePolicy: 'forbidden', type: 'text' },
+        { id: 'grok-4-1-fast-non-reasoning', codeName: '', imagePolicy: 'forbidden', type: 'text' },
+        { id: 'gemini-3-flash', codeName: '', imagePolicy: 'optional', type: 'text' },
+        { id: 'nvidia-nemotron-3-nano-30b-a3b-bf16', codeName: '', imagePolicy: 'forbidden', type: 'text' },
+        { id: 'olmo-3.1-32b-instruct', codeName: '', imagePolicy: 'forbidden', type: 'text' },
+        { id: 'olmo-3.1-32b-think', codeName: '', imagePolicy: 'forbidden', type: 'text' },
+        { id: 'gemini-3-flash (thinking-minimal)', codeName: '', imagePolicy: 'forbidden', type: 'text' },
+        { id: 'mimo-v2-flash', codeName: '', imagePolicy: 'optional', type: 'text' },
+        { id: 'ernie-5.0-preview-1220', codeName: '', imagePolicy: 'forbidden', type: 'text' },
+        { id: 'qwen3-max-2025-09-26', codeName: '', imagePolicy: 'forbidden', type: 'text' },
+        { id: 'ernie-5.0-preview-1203', codeName: '', imagePolicy: 'forbidden', type: 'text' },
+        { id: 'mimo-7b', codeName: '', imagePolicy: 'forbidden', type: 'text' },
+        { id: 'qwen-vl-max-2025-08-13', codeName: '', imagePolicy: 'optional', type: 'text' },
+        { id: 'claude-sonnet-4-20250514-thinking-32k', codeName: '', imagePolicy: 'forbidden', type: 'text' },
+        { id: 'minimax-m2-preview', codeName: '', imagePolicy: 'forbidden', type: 'text' },
+        { id: 'ernie-5.0-preview-1120', codeName: '', imagePolicy: 'forbidden', type: 'text' },
+        { id: 'gpt-5-high-new-system-prompt', codeName: '', imagePolicy: 'optional', type: 'text' },
+
+        // --- 搜索模型 ---
+        { id: 'gemini-3-pro-grounding', codeName: '019abdb7-6957-71c1-96a2-bfa79e8a094f', imagePolicy: 'forbidden', type: 'text', search: true },
+        { id: 'gpt-5.1-search', codeName: '019abdb7-50a5-7c05-9308-4491d069578b', imagePolicy: 'forbidden', type: 'text', search: true },
+        { id: 'grok-4-fast-search', codeName: '9217ac2d-91bc-4391-aa07-b8f9e2cf11f2', imagePolicy: 'forbidden', type: 'text', search: true },
+        { id: 'gemini-2.5-pro-grounding', codeName: 'b222be23-bd55-4b20-930b-a30cc84d3afd', imagePolicy: 'forbidden', type: 'text', search: true },
+        { id: 'o3-search', codeName: 'fbe08e9a-3805-4f9f-a085-7bc38e4b51d1', imagePolicy: 'forbidden', type: 'text', search: true },
+        { id: 'grok-4-search', codeName: '86d767b0-2574-4e47-a256-a22bcace9f56', imagePolicy: 'forbidden', type: 'text', search: true },
+        { id: 'ppl-sonar-reasoning-pro-high', codeName: '24145149-86c9-4690-b7c9-79c7db216e5c', imagePolicy: 'forbidden', type: 'text', search: true },
+        { id: 'claude-opus-4-1-search', codeName: 'd942b564-191c-41c5-ae22-400a930a2cfe', imagePolicy: 'forbidden', type: 'text', search: true },
+        { id: 'gpt-5-search', codeName: 'd14d9b23-1e46-4659-b157-a3804ba7e2ef', imagePolicy: 'forbidden', type: 'text', search: true },
+        { id: 'claude-opus-4-search', codeName: '25bcb878-749e-49f4-ac05-de84d964bcee', imagePolicy: 'forbidden', type: 'text', search: true },
+        { id: 'diffbot-small-xl', codeName: '0862885e-ef53-4d0d-b9c4-4c8f68f453ce', imagePolicy: 'forbidden', type: 'text', search: true },
+        { id: 'grok-4-1-fast-search', codeName: '019af19c-0658-7566-9c60-112ae5bdb8db', imagePolicy: 'forbidden', type: 'text', search: true },
+        { id: 'gpt-5.2-search', codeName: '019b1448-f74a-72de-b25d-8666618f8c5a', imagePolicy: 'forbidden', type: 'text', search: true },
+        { id: 'gpt-5.1-search-sp', codeName: '', imagePolicy: 'forbidden', type: 'text', search: true }
+    ],
+
+    // 无需导航处理器
+    navigationHandlers: [],
+
+    // 核心生图方法
+    generate
+};

src/backend/adapter/nanobananafree_ai.js

@@ -0,0 +1,156 @@
+/**
+ * @fileoverview NanoBananaFree 图片生成适配器
+ */
+
+import {
+    sleep,
+    safeClick,
+    pasteImages
+} from '../engine/utils.js';
+import {
+    fillPrompt,
+    submit,
+    waitApiResponse,
+    normalizePageError,
+    normalizeHttpError,
+    moveMouseAway,
+    waitForInput,
+    gotoWithCheck
+} from '../utils/index.js';
+import { logger } from '../../utils/logger.js';
+
+// --- 配置常量 ---
+const TARGET_URL = 'https://nanobananafree.ai/';
+
+
+/**
+ * 执行生图任务
+ * @param {object} context - 浏览器上下文 { page, client }
+ * @param {string} prompt - 提示词
+ * @param {string[]} imgPaths - 图片路径数组 (仅取第一张)
+ * @param {string} [modelId] - 指定的模型 ID (可选，目前未使用)
+ * @param {object} [meta={}] - 日志元数据
+ * @returns {Promise<{image?: string, text?: string, error?: string}>} 生成结果
+ */
+async function generate(context, prompt, imgPaths, modelId, meta = {}) {
+    const { page } = context;
+    const textareaSelector = 'textarea';
+
+    try {
+        logger.info('适配器', '开启新会话', meta);
+        await gotoWithCheck(page, TARGET_URL);
+
+        // 1. 等待输入框加载
+        await waitForInput(page, textareaSelector, { click: false });
+        await sleep(1500, 2500);
+
+        // 2. 上传图片 (uploadImages - 仅取第一张)
+        if (imgPaths && imgPaths.length > 0) {
+            const singleImage = [imgPaths[0]];
+            if (imgPaths.length > 1) {
+                logger.warn('适配器', `此后端仅支持1张图片, 已丢弃 ${imgPaths.length - 1} 张`, meta);
+            }
+            await pasteImages(page, textareaSelector, singleImage);
+        }
+
+        // 3. 填写提示词 (fillPrompt)
+        await safeClick(page, textareaSelector, { bias: 'input' });
+        await fillPrompt(page, textareaSelector, prompt, meta);
+
+        // 4. 提交表单 (submit)
+        logger.debug('适配器', '点击发送...', meta);
+        await submit(page, {
+            btnSelector: 'div[class*="_sendButton_"]',
+            inputTarget: textareaSelector,
+            meta
+        });
+
+        logger.info('适配器', '等待生成结果...', meta);
+
+        // 5. 等待 API 响应 (waitApiResponse)
+        let response;
+        try {
+            response = await waitApiResponse(page, {
+                urlMatch: 'v1/generateContent',
+                method: 'POST',
+                timeout: 120000,
+                meta
+            });
+        } catch (e) {
+            // 使用公共错误处理
+            const pageError = normalizePageError(e, meta);
+            if (pageError) return pageError;
+            throw e;
+        }
+
+        // 6. 解析响应结果
+        // 先尝试获取响应内容用于错误解析
+        let content = null;
+        try {
+            content = await response.text();
+        } catch (e) { }
+
+        // 检查 HTTP 错误
+        const httpError = normalizeHttpError(response, content);
+        if (httpError) {
+            logger.error('适配器', `请求生成时返回错误: ${httpError.error}`, meta);
+            return { error: `请求生成时返回错误: ${httpError.error}` };
+        }
+
+        // 解析成功响应（使用已读取的 content）
+        let body;
+        try {
+            body = JSON.parse(content);
+        } catch (e) {
+            logger.error('适配器', '解析响应JSON时出错', meta);
+            return { error: '解析响应JSON时出错' };
+        }
+
+        // 7. 提取 base64 图片
+        const inlineData = body?.data?.candidates?.[0]?.content?.parts?.[0]?.inlineData?.data;
+
+        if (inlineData) {
+            logger.info('适配器', '已获取生结果, 且已获取图片数据', meta);
+            return { image: `data:image/png;base64,${inlineData}` };
+        } else {
+            logger.info('适配器', 'AI 返回非图片响应', { ...meta, preview: JSON.stringify(body).substring(0, 150) });
+            return { text: JSON.stringify(body) };
+        }
+
+    } catch (err) {
+        // 顶层错误处理
+        const pageError = normalizePageError(err, meta);
+        if (pageError) return pageError;
+
+        logger.error('适配器', '生成任务失败', { ...meta, error: err.message });
+        return { error: `生成任务失败: ${err.message}` };
+    } finally {
+        // 任务结束，将鼠标移至安全区域
+        await moveMouseAway(page);
+    }
+}
+
+/**
+ * 适配器 manifest
+ */
+export const manifest = {
+    id: 'nanobananafree_ai',
+    displayName: 'NanoBananaFree (图片生成)',
+    description: '使用 NanoBananaFree 平台生成图片，仅支持上传单张图片。需要已登录的 Google 账户。',
+
+    // 入口 URL
+    getTargetUrl(config, workerConfig) {
+        return TARGET_URL;
+    },
+
+    // 模型列表
+    models: [
+        { id: 'gemini-2.5-flash-image', imagePolicy: 'optional' }
+    ],
+
+    // 无需导航处理器
+    navigationHandlers: [],
+
+    // 核心生���方法
+    generate
+};

src/backend/adapter/sora.js

@@ -0,0 +1,250 @@
+/**
+ * @fileoverview Sora 视频生成适配器
+ */
+
+import {
+    sleep,
+    safeClick,
+    uploadFilesViaChooser
+} from '../engine/utils.js';
+import {
+    fillPrompt,
+    normalizePageError,
+    moveMouseAway,
+    waitForInput,
+    gotoWithCheck,
+    useContextDownload
+} from '../utils/index.js';
+import { logger } from '../../utils/logger.js';
+
+// --- 配置常量 ---
+const TARGET_URL = 'https://sora.chatgpt.com/profile';
+const INPUT_SELECTOR = 'textarea';
+
+/**
+ * 执行视频生成任务
+ * @param {object} context - 浏览器上下文 { page, config }
+ * @param {string} prompt - 提示词
+ * @param {string[]} imgPaths - 图片路径数组 (只使用第一张)
+ * @param {string} [modelId] - 模型 ID (此适配器未使用)
+ * @param {object} [meta={}] - 日志元数据
+ * @returns {Promise<{video?: string, error?: string}>}
+ */
+async function generate(context, prompt, imgPaths, modelId, meta = {}) {
+    const { page } = context;
+
+    // 只使用第一张图片
+    const singleImgPath = imgPaths && imgPaths.length > 0 ? [imgPaths[0]] : [];
+    if (imgPaths && imgPaths.length > 1) {
+        logger.warn('适配器', `Sora 只支持一张图片，已丢弃 ${imgPaths.length - 1} 张`, meta);
+    }
+
+    // 用于存储任务 ID 和视频 URL
+    let taskId = null;
+    let videoUrl = null;
+
+    try {
+        logger.info('适配器', '开启新会话...', meta);
+        await gotoWithCheck(page, TARGET_URL);
+
+        // 1. 等待输入框加载
+        await waitForInput(page, INPUT_SELECTOR, { click: false });
+        await sleep(1500, 2500);
+
+        // 2. 上传图片 (如果有)
+        if (singleImgPath.length > 0) {
+            logger.debug('适配器', '点击上传文件按钮...', meta);
+            const attachBtn = page.getByRole('button', { name: 'Attach media' });
+
+            await uploadFilesViaChooser(page, attachBtn, singleImgPath, {
+                uploadValidator: (response) => {
+                    const url = response.url();
+                    if (response.status() === 200 && url.includes('project_y/file/upload')) {
+                        logger.info('适配器', '图片上传完成', meta);
+                        return true;
+                    }
+                    return false;
+                }
+            });
+
+            await sleep(1000, 2000);
+        }
+
+        // 3. 填写提示词
+        await safeClick(page, INPUT_SELECTOR, { bias: 'input' });
+        await fillPrompt(page, INPUT_SELECTOR, prompt, meta);
+        await sleep(500, 1000);
+
+        // 4. 提前设置响应监听器 (drafts 接口)
+        // 因为 drafts 请求在 pending/v2 检测到任务消失后立即出现，需要提前监听
+        let draftsResponsePromise = null;
+        const startDraftsListener = () => {
+            draftsResponsePromise = page.waitForResponse(async (response) => {
+                const url = response.url();
+                if (!url.includes('project_y/profile/drafts')) return false;
+                if (response.request().method() !== 'GET') return false;
+                if (response.status() !== 200) return false;
+                return true;
+            }, { timeout: 600000 });  // 10 分钟超时
+        };
+
+        // 5. 点击 Create video 按钮并监听 nf/create 请求
+        logger.debug('适配器', '点击创建视频...', meta);
+        const createBtn = page.getByRole('button', { name: 'Create video' });
+
+        // 设置 create 请求监听
+        const createResponsePromise = page.waitForResponse(async (response) => {
+            const url = response.url();
+            if (!url.includes('nf/create')) return false;
+            if (response.request().method() !== 'POST') return false;
+            if (response.status() !== 200) return false;
+            return true;
+        }, { timeout: 60000 });
+
+        await safeClick(page, createBtn, { bias: 'button' });
+
+        // 等待 create 响应
+        logger.info('适配器', '等待创建任务...', meta);
+        const createResponse = await createResponsePromise;
+
+        try {
+            const createBody = await createResponse.json();
+            taskId = createBody.id;
+            if (!taskId) {
+                logger.error('适配器', '创建响应中没有 id', meta);
+                return { error: '创建任务失败：响应中没有 id' };
+            }
+            logger.info('适配器', `任务已创建, id: ${taskId}`, meta);
+        } catch (e) {
+            logger.error('适配器', '解析 create 响应失败', { ...meta, error: e.message });
+            return { error: '解析创建响应失败' };
+        }
+
+        // 6. 启动 drafts 监听器 (提前监听)
+        startDraftsListener();
+
+        // 7. 监听 nf/pending/v2 等待任务完成
+        logger.info('适配器', '等待视频生成完成...', meta);
+
+        let taskCompleted = false;
+        const maxWaitTime = 300000; // 5 分钟
+        const startTime = Date.now();
+
+        while (!taskCompleted && (Date.now() - startTime) < maxWaitTime) {
+            try {
+                const pendingResponse = await page.waitForResponse(async (response) => {
+                    const url = response.url();
+                    if (!url.includes('nf/pending/v2')) return false;
+                    if (response.request().method() !== 'GET') return false;
+                    if (response.status() !== 200) return false;
+                    return true;
+                }, { timeout: 30000 });
+
+                const pendingBody = await pendingResponse.json();
+
+                // 检查任务是否还在列表中
+                const taskInList = pendingBody.find(item => item.id === taskId);
+
+                if (taskInList) {
+                    const status = taskInList.status;
+                    logger.debug('适配器', `任务状态: ${status}`, meta);
+                    // preprocessing, queued, running, processing 都表示进行中
+                } else {
+                    // 任务不在列表中，说明已完成
+                    logger.info('适配器', '任务已完成，等待获取视频链接...', meta);
+                    taskCompleted = true;
+                }
+            } catch (e) {
+                // 超时重试
+                if (e.name === 'TimeoutError') {
+                    logger.debug('适配器', '等待 pending 响应超时，继续等待...', meta);
+                } else {
+                    throw e;
+                }
+            }
+        }
+
+        if (!taskCompleted) {
+            logger.error('适配器', '等待视频生成超时 (5分钟)', meta);
+            return { error: '等待视频生成超时 (5分钟)' };
+        }
+
+        // 8. 获取 drafts 响应中的视频 URL
+        logger.debug('适配器', '获取视频链接...', meta);
+
+        try {
+            const draftsResponse = await draftsResponsePromise;
+            const draftsBody = await draftsResponse.json();
+
+            // 在 items 数组中查找 task_id 匹配的项目
+            const items = draftsBody.items || draftsBody;
+            const targetItem = (Array.isArray(items) ? items : []).find(
+                item => item.task_id === taskId
+            );
+
+            if (!targetItem) {
+                logger.error('适配器', '未找到匹配的视频任务', meta);
+                return { error: '未找到匹配的视频任务' };
+            }
+
+            videoUrl = targetItem.url;
+            if (!videoUrl) {
+                logger.error('适配器', '视频项目中没有 url', meta);
+                return { error: '视频项目中没有 url' };
+            }
+
+            logger.info('适配器', '已获取视频链接', meta);
+        } catch (e) {
+            logger.error('适配器', '获取视频链接失败', { ...meta, error: e.message });
+            return { error: `获取视频链接失败: ${e.message}` };
+        }
+
+        // 9. 下载视频并转为 base64
+        logger.info('适配器', '正在下载视频...', meta);
+        const downloadResult = await useContextDownload(videoUrl, page);
+
+        if (downloadResult.error) {
+            logger.error('适配器', downloadResult.error, meta);
+            return downloadResult;
+        }
+
+        logger.info('适配器', '视频生成完成，任务完成', meta);
+        return { image: downloadResult.image };  // 复用 image 字段存储 base64
+
+    } catch (err) {
+        // 顶层错误处理
+        const pageError = normalizePageError(err, meta);
+        if (pageError) return pageError;
+
+        logger.error('适配器', '生成任务失败', { ...meta, error: err.message });
+        return { error: `生成任务失败: ${err.message}` };
+    } finally {
+        // 任务结束，将鼠标移至安全区域
+        await moveMouseAway(page);
+    }
+}
+
+/**
+ * 适配器 manifest
+ */
+export const manifest = {
+    id: 'sora',
+    displayName: 'Sora (视频生成)',
+    description: '使用 OpenAI Sora 生成视频，仅支持上传单张参考图片。需要已登录的 ChatGPT 账户。',
+
+    // 入口 URL
+    getTargetUrl(config, workerConfig) {
+        return TARGET_URL;
+    },
+
+    // 模型列表
+    models: [
+        { id: 'sora-2', imagePolicy: 'optional' }
+    ],
+
+    // 无需导航处理器
+    navigationHandlers: [],
+
+    // 核心视频生成方法
+    generate
+};

src/backend/adapter/test.js

@@ -0,0 +1,191 @@
+/**
+ * @fileoverview 浏览器测试适配器
+ * 提供多种浏览器测试功能，包括 Cloudflare Turnstile 验证、指纹检测等
+ * 
+ * 模型类型:
+ * - cloudflare-turnstile: 点击验证后截屏
+ * - 其他 image 类型: 加载页面后截屏
+ * - text 类型: 返回页面文本内容
+ */
+
+import { sleep } from '../engine/utils.js';
+import {
+    gotoWithCheck,
+    normalizePageError,
+    moveMouseAway,
+} from '../utils/index.js';
+import { clickTurnstile } from '../utils/CloudflareBypass.js';
+import { logger } from '../../utils/logger.js';
+
+/**
+ * 执行 Turnstile 验证并截屏
+ */
+async function handleTurnstile(page, meta) {
+    const TARGET_URL = 'https://nopecha.com/captcha/turnstile';
+    const HOST_SELECTOR = '#example-container5';
+
+    logger.info('适配器', '开启 Turnstile 测试...', meta);
+    await gotoWithCheck(page, TARGET_URL);
+
+    // 等待页面加载
+    await sleep(3000, 4000);
+
+    // 使用通用 Cloudflare 验证码点击器
+    const result = await clickTurnstile(page, HOST_SELECTOR, {
+        timeout: 10000,
+        waitAfterClick: 3000,
+        meta
+    });
+
+    if (!result.success) {
+        return { error: result.error };
+    }
+
+    // 截屏并返回
+    logger.info('适配器', '正在截屏...', meta);
+    const screenshot = await page.screenshot({ type: 'png', fullPage: true });
+    const base64 = screenshot.toString('base64');
+
+    return { image: `data:image/png;base64,${base64}` };
+}
+
+/**
+ * 处理普通 image 类型：加载页面后截屏
+ */
+async function handleImagePage(page, url, meta) {
+    logger.info('适配器', `正在加载页面: ${url}`, meta);
+    await gotoWithCheck(page, url);
+
+    // 等待页面加载完成
+    await sleep(3000, 5000);
+
+    // 截屏并返回
+    logger.info('适配器', '正在截屏...', meta);
+    const screenshot = await page.screenshot({ type: 'png', fullPage: true });
+    const base64 = screenshot.toString('base64');
+
+    return { image: `data:image/png;base64,${base64}` };
+}
+
+/**
+ * 处理 ping0.cc：检测并处理 Cloudflare 验证后截屏
+ */
+async function handlePing0(page, url, meta) {
+    logger.info('适配器', `正在加载页面: ${url}`, meta);
+    await gotoWithCheck(page, url);
+
+    // 等待页面加载
+    await sleep(2000, 3000);
+
+    // 检测是否有 Cloudflare 验证码
+    const cfElement = await page.$('#captcha-element');
+    if (cfElement) {
+        logger.info('适配器', '检测到 Cloudflare 验证码，正在处理...', meta);
+
+        const result = await clickTurnstile(page, '#captcha-element', {
+            timeout: 10000,
+            waitAfterClick: 5000,
+            meta
+        });
+
+        if (!result.success) {
+            logger.warn('适配器', `Cloudflare 验证失败: ${result.error}`, meta);
+            // 继续截屏，可能验证页面也有价值
+        }
+
+        // 等待页面跳转或刷新
+        await sleep(3000, 5000);
+    }
+
+    // 截屏并返回
+    logger.info('适配器', '正在截屏...', meta);
+    const screenshot = await page.screenshot({ type: 'png', fullPage: true });
+    const base64 = screenshot.toString('base64');
+
+    return { image: `data:image/png;base64,${base64}` };
+}
+
+/**
+ * 处理 text 类型：返回页面文本内容
+ */
+async function handleTextPage(page, url, meta) {
+    logger.info('适配器', `正在加载页面: ${url}`, meta);
+    await gotoWithCheck(page, url);
+
+    // 等待页面加载完成
+    await sleep(1000, 2000);
+
+    // 获取页面文本内容
+    const textContent = await page.evaluate(() => document.body.innerText);
+    logger.info('适配器', `获取文本内容，长度: ${textContent.length}`, meta);
+
+    return { text: textContent.trim() };
+}
+
+/**
+ * 主生成函数
+ */
+async function generate(context, prompt, imgPaths, modelId, meta = {}) {
+    const { page } = context;
+
+    try {
+        // 查找模型配置
+        const modelConfig = manifest.models.find(m => m.id === modelId);
+        if (!modelConfig) {
+            return { error: `未找到模型配置: ${modelId}` };
+        }
+
+        const { url, type } = modelConfig;
+
+        // 根据模型 ID 和类型分发处理
+        if (modelId === 'cloudflare-turnstile') {
+            // Turnstile 验证特殊处理
+            return await handleTurnstile(page, meta);
+        } else if (modelId === 'ping0') {
+            // ping0.cc 需要 Cloudflare 验证
+            return await handlePing0(page, url, meta);
+        } else if (type === 'text') {
+            // text 类型返回页面文本
+            return await handleTextPage(page, url, meta);
+        } else {
+            // 其他 image 类型截屏返回
+            return await handleImagePage(page, url, meta);
+        }
+
+    } catch (err) {
+        const pageError = normalizePageError(err, meta);
+        if (pageError) return pageError;
+
+        logger.error('适配器', '任务失败', { ...meta, error: err.message });
+        return { error: `任务失败: ${err.message}` };
+    } finally {
+        await moveMouseAway(page);
+    }
+}
+
+/**
+ * 适配器 manifest
+ */
+export const manifest = {
+    id: 'test',
+    displayName: '浏览器检测，仅供调试使用',
+    description: '包含 Cloudflare Turnstile 验证测试、浏览器指纹检测、IP 纯净度查询等功能，仅供调试使用。',
+
+    getTargetUrl(config, workerConfig) {
+        return 'https://abrahamjuliot.github.io/creepjs/';
+    },
+
+    models: [
+        { id: 'cloudflare-turnstile', imagePolicy: 'forbidden', type: 'image', url: 'https://nopecha.com/captcha/turnstile' },
+        { id: 'creepjs', imagePolicy: 'forbidden', type: 'image', url: 'https://abrahamjuliot.github.io/creepjs/' },
+        { id: 'antibot', imagePolicy: 'forbidden', type: 'image', url: 'https://bot.sannysoft.com/' },
+        { id: 'browserleaks-js', imagePolicy: 'forbidden', type: 'image', url: 'https://browserleaks.com/javascript' },
+        { id: 'browserleaks-ip', imagePolicy: 'forbidden', type: 'image', url: 'https://browserleaks.com/ip' },
+        { id: 'ip', imagePolicy: 'forbidden', type: 'text', url: 'https://api.ip.sb/ip' },
+        { id: 'webgl', imagePolicy: 'forbidden', type: 'image', url: 'https://get.webgl.org/' },
+        { id: 'ping0', imagePolicy: 'forbidden', type: 'image', url: 'https://ping0.cc/' },
+    ],
+
+    navigationHandlers: [],
+    generate
+};

src/backend/adapter/zai_is.js

@@ -0,0 +1,411 @@
+/**
+ * @fileoverview zAI 图片生成适配器
+ */
+
+import {
+    sleep,
+    safeClick,
+    pasteImages
+} from '../engine/utils.js';
+import {
+    fillPrompt,
+    submit,
+    normalizePageError,
+    normalizeHttpError,
+    waitApiResponse,
+    moveMouseAway,
+    useContextDownload,
+    waitForPageAuth,
+    lockPageAuth,
+    unlockPageAuth,
+    isPageAuthLocked,
+    waitForInput,
+    gotoWithCheck
+} from '../utils/index.js';
+import { logger } from '../../utils/logger.js';
+
+// zai.is 输入框选择器
+const INPUT_SELECTOR = '.tiptap.ProseMirror';
+
+// 入口 URL
+const TARGET_URL = 'https://zai.is/';
+
+/**
+ * 处理 Discord OAuth2 登录流程
+ * @param {import('playwright-core').Page} page
+ * @returns {Promise<boolean>} 是否处理了登录
+ */
+async function handleDiscordAuth(page) {
+    // 防止重复处理
+    if (isPageAuthLocked(page)) return false;
+
+    const currentUrl = page.url();
+
+    // 1. 检查是否在 zai.is/auth 页面
+    if (currentUrl.includes('zai.is/auth')) {
+        lockPageAuth(page);
+        logger.info('适配器', '[登录器(zai_is)] 检测到登录页面，正在处理 Discord 登录...');
+
+        try {
+            // 等待页面加载完成，点击唯一的 button 标签
+            await page.waitForSelector('button', { timeout: 30000 });
+            await sleep(1000, 1500);
+            await safeClick(page, 'button', { bias: 'button' });
+            logger.info('适配器', '[登录器(zai_is)] 已点击登录按钮，等待跳转到 Discord...');
+
+            // 2. 等待跳转到 Discord OAuth2 授权页面
+            await page.waitForURL(url => url.href.includes('discord.com/oauth2/authorize'), { timeout: 60000 });
+            logger.info('适配器', '[登录器(zai_is)] 已到达 Discord 授权页面');
+            await sleep(2000, 3000);
+
+            // 3. 使用鼠标滚轮滚动 main 元素，直到授权按钮可用
+            // 授权按钮选择器: data-align="stretch" 的 div 中的最后一个按钮 (授权按钮在右边)
+            const authorizeBtnSelector = 'div[data-align="stretch"] button:last-child';
+
+            for (let i = 0; i < 15; i++) {
+                const authorizeBtn = await page.$(authorizeBtnSelector);
+                if (authorizeBtn) {
+                    const isDisabled = await authorizeBtn.evaluate(el => el.disabled).catch(() => true);
+                    if (!isDisabled) {
+                        logger.info('适配器', '[登录器(zai_is)] 授权按钮已可用，正在点击...');
+                        await sleep(500, 1000);
+                        await safeClick(page, authorizeBtn, { bias: 'button' });
+                        break;
+                    }
+                }
+                // 使用鼠标滚轮在 main 元素中滚动
+                const mainElement = await page.$('main');
+                if (mainElement) {
+                    const box = await mainElement.boundingBox();
+                    if (box) {
+                        // 将鼠标移动到 main 元素中心并滚动
+                        await page.mouse.move(box.x + box.width / 2, box.y + box.height / 2);
+                        await page.mouse.wheel(0, 200);
+                    }
+                }
+                await sleep(800, 1200);
+            }
+
+            // 4. 等待跳转回 zai.is (不包含 auth 和 discord)
+            logger.info('适配器', '[登录器(zai_is)] 等待跳转回目标页面...');
+            await page.waitForURL(url => {
+                const href = url.href;
+                return href.includes('zai.is') &&
+                    !href.includes('/auth') &&
+                    !href.includes('discord.com');
+            }, { timeout: 60000 });
+
+            logger.info('适配器', '[登录器(zai_is)] Discord 登录完成');
+            await sleep(2000, 3000);
+            unlockPageAuth(page);
+            return true;
+        } catch (err) {
+            logger.warn('适配器', `[登录器(zai_is)] Discord 登录处理失败: ${err.message}`);
+            unlockPageAuth(page);
+        }
+    }
+
+
+    return false;
+}
+
+
+/**
+ * 生成图片
+ * @param {object} context - 浏览器上下文 { page, client, config }
+ * @param {string} prompt - 提示词
+ * @param {string[]} imgPaths - 参考图片路径数组
+ * @param {string} modelId - 模型 ID
+ * @param {object} meta - 日志元数据
+ * @returns {Promise<{image?: string, error?: string}>} 生成结果
+ */
+async function generate(context, prompt, imgPaths, modelId, meta = {}) {
+    const { page, config } = context;
+
+    try {
+        // 开启新对话 - 先等待可能正在进行的登录处理完成
+        await waitForPageAuth(page);
+
+        logger.info('适配器', '开启新会话', meta);
+        await gotoWithCheck(page, TARGET_URL);
+
+        // 如果触发了登录跳转，等待全局处理器完成
+        await waitForPageAuth(page);
+
+        // 1. 等待输入框加载
+        logger.debug('适配器', '正在寻找输入框...', meta);
+        await waitForInput(page, INPUT_SELECTOR, { click: false });
+        await sleep(1500, 2500);
+
+        // 2. 上传图片
+        if (imgPaths && imgPaths.length > 0) {
+            await pasteImages(page, INPUT_SELECTOR, imgPaths, {
+                uploadValidator: (response) => {
+                    const url = response.url();
+                    return response.status() === 200 && url.includes('v1/files');
+                }
+            });
+            await sleep(500, 1000);
+        }
+
+        // 3. 填写提示词
+        await safeClick(page, INPUT_SELECTOR, { bias: 'input' });
+        await fillPrompt(page, INPUT_SELECTOR, prompt, meta);
+        await sleep(500, 1000);
+
+        // 4. 通过 UI 交互选择模型
+        const modelConfig = manifest.models.find(m => m.id === modelId);
+        const targetModel = modelConfig?.codeName || modelId;
+
+        logger.debug('适配器', `正在选择模型: ${targetModel}`, meta);
+
+        // 点击 "Select a models" 按钮
+        const selectModelBtn = page.getByRole('button', { name: 'Select a model' });
+        await selectModelBtn.waitFor({ timeout: 5000 });
+        await sleep(300, 500);
+        await safeClick(page, selectModelBtn, { bias: 'button' });
+        await sleep(500, 800);
+
+        // 在 "Search In Models" 文本框中输入模型名称
+        const searchInput = page.getByRole('textbox', { name: 'Search In Models' });
+        await searchInput.waitFor({ timeout: 5000 });
+        await searchInput.fill(targetModel);
+        await sleep(300, 500);
+
+        // 按回车确认选择
+        await searchInput.press('Enter');
+        await sleep(500, 1000);
+
+        logger.info('适配器', `已选择模型: ${targetModel}`, meta);
+
+        // 5. 检查 GIF Generation 按钮状态，确保为 OFF
+        const gifBtn = page.getByRole('button', { name: /^GIF Generation/ });
+        const gifBtnExists = await gifBtn.count();
+        if (gifBtnExists > 0) {
+            const gifState = await gifBtn.evaluate(el => {
+                const generic = el.querySelector('[role="generic"]') || el;
+                return generic.textContent?.trim() || '';
+            });
+
+            if (!gifState.includes('OFF')) {
+                logger.debug('适配器', `GIF Generation 当前为 ${gifState}，正在切换为 OFF`, meta);
+                await safeClick(page, gifBtn, { bias: 'button' });
+                await sleep(300, 500);
+            }
+        }
+
+        // 6. 设置图片大小 (如果模型配置了 imageSize)
+        if (modelConfig?.imageSize) {
+            const targetSize = modelConfig.imageSize;  // 例如 "1K", "2K", "4K"
+            logger.debug('适配器', `正在设置图片大小: ${targetSize}`, meta);
+
+            const imageSizeBtn = page.getByRole('button', { name: /^Image Size/ });
+            const btnExists = await imageSizeBtn.count();
+
+            if (btnExists > 0) {
+                // 最多点击 4 次切换
+                for (let i = 0; i < 4; i++) {
+                    // 获取当前图片大小 (从按钮下的 generic 元素中的 text leaf 获取)
+                    const currentSize = await imageSizeBtn.evaluate(el => {
+                        const generic = el.querySelector('[role="generic"]') || el;
+                        return generic.textContent?.trim() || '';
+                    });
+
+                    if (currentSize.includes(targetSize)) {
+                        logger.info('适配器', `图片大小已设置为: ${targetSize}`, meta);
+                        break;
+                    }
+
+                    // 点击切换
+                    await safeClick(page, imageSizeBtn, { bias: 'button' });
+                    await sleep(300, 500);
+                }
+            } else {
+                logger.debug('适配器', '未找到 Image Size 按钮', meta);
+            }
+        }
+
+        // 7. 提交
+        logger.debug('适配器', '点击发送...', meta);
+        await submit(page, {
+            btnSelector: 'button[type="submit"]',
+            inputTarget: INPUT_SELECTOR,
+            meta
+        });
+
+        logger.info('适配器', '等待生成结果中...', meta);
+
+        // 8. 等待 v1/chats/new 响应 (状态码 200 且响应体中有 id)
+        let chatsNewResponse;
+        try {
+            chatsNewResponse = await waitApiResponse(page, {
+                urlMatch: 'v1/chats/new',
+                method: 'POST',
+                timeout: 60000,
+                meta
+            });
+        } catch (e) {
+            const pageError = normalizePageError(e, meta);
+            if (pageError) return pageError;
+            throw e;
+        }
+
+        // 检查 chats/new 响应
+        const httpError = normalizeHttpError(chatsNewResponse);
+        if (httpError) {
+            logger.error('适配器', `创建对话失败: ${httpError.error}`, meta);
+            return { error: `创建对话失败: ${httpError.error}` };
+        }
+
+        try {
+            const chatsNewBody = await chatsNewResponse.json();
+            if (!chatsNewBody.id) {
+                logger.error('适配器', '创建对话响应中没有无 id', meta);
+                return { error: '创建对话响应中没有 id' };
+            }
+            logger.debug('适配器', `对话创建成功, id: ${chatsNewBody.id}`, meta);
+        } catch (e) {
+            logger.error('适配器', '解析 chats/new 响应失败', { ...meta, error: e.message });
+            return { error: '解析对话响应失败' };
+        }
+
+
+        // 9. 等待 chat/completions 响应 (状态码 200 且 status: true)
+        let completionsResponse;
+        try {
+            completionsResponse = await waitApiResponse(page, {
+                urlMatch: 'chat/completions',
+                method: 'POST',
+                timeout: 120000,
+                errorText: ['Model is unable to process your request', 'Rate limit reached'],
+                meta
+            });
+        } catch (e) {
+            const pageError = normalizePageError(e, meta);
+            if (pageError) return pageError;
+            throw e;
+        }
+
+        const completionsHttpError = normalizeHttpError(completionsResponse);
+        if (completionsHttpError) {
+            logger.error('适配器', `生成请求失败: ${completionsHttpError.error}`, meta);
+            return { error: `生成请求失败: ${completionsHttpError.error}` };
+        }
+
+        try {
+            const completionsBody = await completionsResponse.json();
+            if (!completionsBody.status) {
+                logger.error('适配器', '生成响应 status 不为 true', meta);
+                return { error: '生成失败，响应状态异常' };
+            }
+            logger.debug('适配器', '生成请求成功', meta);
+        } catch (e) {
+            logger.error('适配器', '解析 completions 响应失败', { ...meta, error: e.message });
+            return { error: '解析生成响应失败' };
+        }
+
+        // 10. 等待 chat/completed 响应，从中提取图片链接
+        logger.debug('适配器', '正在等待完成响应...', meta);
+
+        let completedResponse;
+        try {
+            completedResponse = await waitApiResponse(page, {
+                urlMatch: 'chat/completed',
+                method: 'POST',
+                timeout: 120000,
+                errorText: ['Model is unable to process your request', 'Rate limit reached'],
+                meta
+            });
+        } catch (e) {
+            const pageError = normalizePageError(e, meta);
+            if (pageError) {
+                if (e.name === 'TimeoutError') {
+                    return { error: '等待完成响应超时 (120秒)' };
+                }
+                return pageError;
+            }
+            throw e;
+        }
+
+        // 解析 chat/completed 响应
+        let completedBody;
+        try {
+            completedBody = await completedResponse.json();
+        } catch (e) {
+            logger.error('适配器', '解析 chat/completed 响应失败', { ...meta, error: e.message });
+            return { error: '解析完成响应失败' };
+        }
+
+        // 在 messages 数组中查找匹配的消息 (id 与响应体的 id 相同)
+        const targetMessage = (completedBody.messages || []).find(msg => msg.id === completedBody.id);
+        if (!targetMessage) {
+            logger.error('适配器', `未找到匹配的消息`, meta);
+            return { error: '未找到匹配的消息' };
+        }
+
+        // 检查 content
+        const content = targetMessage.content;
+        if (!content || content.trim() === '') {
+            logger.warn('适配器', '回复内容为空可能触发违规/限流', meta);
+            return { error: '回复内容为空可能触发违规/限流' };
+        }
+
+        // 从 content 中提取图片链接 (格式: ![...](https://zai.is/...))
+        const imageUrlMatch = content.match(/!\[.*?\]\((https:\/\/zai\.is\/[^)]+)\)/);
+        if (!imageUrlMatch || !imageUrlMatch[1]) {
+            logger.warn('适配器', '回复中未找到图片链接', meta);
+            return { error: '回复中未找到图片链接' };
+        }
+
+        const imageUrl = imageUrlMatch[1];
+        logger.info('适配器', `已提取图片链接: ${imageUrl}`, meta);
+
+        // 下载图片
+        const downloadResult = await useContextDownload(imageUrl, page);
+        if (downloadResult.error) {
+            return downloadResult;
+        }
+
+        logger.info('适配器', '已下载图片，任务完成', meta);
+        return { image: downloadResult.image };
+
+    } catch (err) {
+        // 顶层错误处理
+        const pageError = normalizePageError(err, meta);
+        if (pageError) return pageError;
+
+        logger.error('适配器', '生成任务失败', { ...meta, error: err.message });
+        return { error: `生成任务失败: ${err.message}` };
+    } finally {
+        // 任务结束，将鼠标移至安全区域
+        await moveMouseAway(page);
+    }
+}
+
+/**
+ * 适配器 manifest
+ */
+export const manifest = {
+    id: 'zai_is',
+    displayName: 'zAI (图片生成)',
+    description: '使用 zAI 平台生成图片，支持多种图片生成模型和分辨率选择。需要 Discord 账户登录授权。',
+
+    // 入口 URL
+    getTargetUrl(config, workerConfig) {
+        return TARGET_URL;
+    },
+
+    // 模型列表
+    models: [
+        { id: 'gemini-3-pro-image-preview', codeName: 'Nano Banana Pro', imagePolicy: 'optional', imageSize: '1K' },
+        { id: 'gemini-3-pro-image-preview-2k', codeName: 'Nano Banana Pro', imagePolicy: 'optional', imageSize: '2K' },
+        { id: 'gemini-3-pro-image-preview-4k', codeName: 'Nano Banana Pro', imagePolicy: 'optional', imageSize: '4K' },
+        { id: 'gemini-2.5-flash-image', codeName: 'Nano Banana', imagePolicy: 'optional' }
+    ],
+
+    // 导航处理器
+    navigationHandlers: [handleDiscordAuth],
+
+    // 核心生图方法
+    generate
+};

src/backend/adapter/zai_is_text.js

@@ -0,0 +1,396 @@
+/**
+ * @fileoverview zAI 文本生成适配器
+ */
+
+import {
+    sleep,
+    safeClick,
+    pasteImages
+} from '../engine/utils.js';
+import {
+    fillPrompt,
+    submit,
+    normalizePageError,
+    normalizeHttpError,
+    waitApiResponse,
+    moveMouseAway,
+    waitForPageAuth,
+    lockPageAuth,
+    unlockPageAuth,
+    isPageAuthLocked,
+    waitForInput,
+    gotoWithCheck
+} from '../utils/index.js';
+import { logger } from '../../utils/logger.js';
+
+// zai.is 输入框选择器
+const INPUT_SELECTOR = '.tiptap.ProseMirror';
+
+// 入口 URL
+const TARGET_URL = 'https://zai.is/';
+
+/**
+ * 处理 Discord OAuth2 登录流程
+ * @param {import('playwright-core').Page} page
+ * @returns {Promise<boolean>} 是否处理了登录
+ */
+async function handleDiscordAuth(page) {
+    // 防止重复处理
+    if (isPageAuthLocked(page)) return false;
+
+    const currentUrl = page.url();
+
+    // 1. 检查是否在 zai.is/auth 页面
+    if (currentUrl.includes('zai.is/auth')) {
+        lockPageAuth(page);
+        logger.info('适配器', '[登录器(zai)] 检测到登录页面，正在处理 Discord 登录...');
+
+        try {
+            // 等待页面加载完成，点击唯一的 button 标签
+            await page.waitForSelector('button', { timeout: 30000 });
+            await sleep(1000, 1500);
+            await safeClick(page, 'button', { bias: 'button' });
+            logger.info('适配器', '[登录器(zai)] 已点击登录按钮，等待跳转到 Discord...');
+
+            // 2. 等待跳转到 Discord OAuth2 授权页面
+            await page.waitForURL(url => url.href.includes('discord.com/oauth2/authorize'), { timeout: 60000 });
+            logger.info('适配器', '[登录器(zai)] 已到达 Discord 授权页面');
+            await sleep(2000, 3000);
+
+            // 3. 使用鼠标滚轮滚动 main 元素，直到授权按钮可用
+            // 授权按钮选择器: data-align="stretch" 的 div 中的最后一个按钮 (授权按钮在右边)
+            const authorizeBtnSelector = 'div[data-align="stretch"] button:last-child';
+
+            for (let i = 0; i < 15; i++) {
+                const authorizeBtn = await page.$(authorizeBtnSelector);
+                if (authorizeBtn) {
+                    const isDisabled = await authorizeBtn.evaluate(el => el.disabled).catch(() => true);
+                    if (!isDisabled) {
+                        logger.info('适配器', '[登录器(zai)] 授权按钮已可用，正在点击...');
+                        await sleep(500, 1000);
+                        await safeClick(page, authorizeBtn, { bias: 'button' });
+                        break;
+                    }
+                }
+                // 使用鼠标滚轮在 main 元素中滚动
+                const mainElement = await page.$('main');
+                if (mainElement) {
+                    const box = await mainElement.boundingBox();
+                    if (box) {
+                        // 将鼠标移动到 main 元素中心并滚动
+                        await page.mouse.move(box.x + box.width / 2, box.y + box.height / 2);
+                        await page.mouse.wheel(0, 200);
+                    }
+                }
+                await sleep(800, 1200);
+            }
+
+            // 4. 等待跳转回 zai.is (不包含 auth 和 discord)
+            logger.info('适配器', '[登录器(zai)] 等待跳转回目标页面...');
+            await page.waitForURL(url => {
+                const href = url.href;
+                return href.includes('zai.is') &&
+                    !href.includes('/auth') &&
+                    !href.includes('discord.com');
+            }, { timeout: 60000 });
+
+            logger.info('适配器', '[登录器(zai)] Discord 登录完成');
+            await sleep(2000, 3000);
+            unlockPageAuth(page);
+            return true;
+        } catch (err) {
+            logger.warn('适配器', `[登录器(zai)] Discord 登录处理失败: ${err.message}`);
+            unlockPageAuth(page);
+        }
+    }
+
+
+    return false;
+}
+
+/**
+ * 从 content 中移除开头的 <details> 思考块
+ * @param {string} content - 原始内容
+ * @returns {string} 处理后的内容
+ */
+function extractTextContent(content) {
+    if (!content) return '';
+
+    // 匹配开头的 <details type="reasoning" ...>...</details> 块
+    // 使用非贪婪匹配和 dotAll 模式 (s flag)
+    const detailsPattern = /^<details\s+type="reasoning"[^>]*>[\s\S]*?<\/details>\s*/;
+
+    // 移除开头的 details 块，返回剩余内容
+    const result = content.replace(detailsPattern, '').trim();
+
+    return result;
+}
+
+
+/**
+ * 生成文本
+ * @param {object} context - 浏览器上下文 { page, client, config }
+ * @param {string} prompt - 提示词
+ * @param {string[]} imgPaths - 参考图片路径数组
+ * @param {string} modelId - 模型 ID
+ * @param {object} meta - 日志元数据
+ * @returns {Promise<{text?: string, error?: string}>} 生成结果
+ */
+async function generate(context, prompt, imgPaths, modelId, meta = {}) {
+    const { page, config } = context;
+
+    try {
+        // 开启新对话 - 先等待可能正在进行的登录处理完成
+        await waitForPageAuth(page);
+
+        logger.info('适配器', '开启新会话', meta);
+        await gotoWithCheck(page, TARGET_URL);
+
+        // 如果触发了登录跳转，等待全局处理器完成
+        await waitForPageAuth(page);
+
+        // 1. 等待输入框加载
+        logger.debug('适配器', '正在寻找输入框...', meta);
+        await waitForInput(page, INPUT_SELECTOR, { click: false });
+        await sleep(1500, 2500);
+
+        // 2. 上传图片 (如果有多张图片，会一张一张上传，每次都是 v1/files POST 请求)
+        if (imgPaths && imgPaths.length > 0) {
+            const expectedUploads = imgPaths.length;
+            let uploadedCount = 0;
+
+            await pasteImages(page, INPUT_SELECTOR, imgPaths, {
+                uploadValidator: (response) => {
+                    const url = response.url();
+                    if (response.status() === 200 && url.includes('v1/files')) {
+                        uploadedCount++;
+                        logger.info('适配器', `图片上传进度: ${uploadedCount}/${expectedUploads}`, meta);
+                        if (uploadedCount >= expectedUploads) {
+                            return true;
+                        }
+                    }
+                    return false;
+                }
+            });
+
+            await sleep(1000, 2000);
+        }
+
+        // 3. 填写提示词
+        await safeClick(page, INPUT_SELECTOR, { bias: 'input' });
+        await fillPrompt(page, INPUT_SELECTOR, prompt, meta);
+        await sleep(500, 1000);
+
+        // 4. 通过 UI 交互选择模型
+        const modelConfig = manifest.models.find(m => m.id === modelId);
+        const targetModel = modelConfig?.codeName || modelId;
+
+        logger.debug('适配器', `正在选择模型: ${targetModel}`, meta);
+
+        // 点击 "Select a models" 按钮
+        const selectModelBtn = page.getByRole('button', { name: 'Select a model' });
+        await selectModelBtn.waitFor({ timeout: 5000 });
+        await sleep(300, 500);
+        await safeClick(page, selectModelBtn, { bias: 'button' });
+        await sleep(500, 800);
+
+        // 在 "Search In Models" 文本框中输入模型名称
+        const searchInput = page.getByRole('textbox', { name: 'Search In Models' });
+        await searchInput.waitFor({ timeout: 5000 });
+        await searchInput.fill(targetModel);
+        await sleep(300, 500);
+
+        // 按回车确认选择
+        await searchInput.press('Enter');
+        await sleep(500, 1000);
+
+        logger.info('适配器', `已选择模型: ${targetModel}`, meta);
+
+        // 5. 提交
+        logger.debug('适配器', '点击发送...', meta);
+        await submit(page, {
+            btnSelector: 'button[type="submit"]',
+            inputTarget: INPUT_SELECTOR,
+            meta
+        });
+
+        logger.info('适配器', '等待生成结果中...', meta);
+
+        // 6. 等待 v1/chats/new 响应 (状态码 200 且响应体中有 id)
+        let chatsNewResponse;
+        try {
+            chatsNewResponse = await waitApiResponse(page, {
+                urlMatch: 'v1/chats/new',
+                method: 'POST',
+                timeout: 60000,
+                meta
+            });
+        } catch (e) {
+            const pageError = normalizePageError(e, meta);
+            if (pageError) return pageError;
+            throw e;
+        }
+
+        // 检查 chats/new 响应
+        const httpError = normalizeHttpError(chatsNewResponse);
+        if (httpError) {
+            logger.error('适配器', `创建对话失败: ${httpError.error}`, meta);
+            return { error: `创建对话失败: ${httpError.error}` };
+        }
+
+        try {
+            const chatsNewBody = await chatsNewResponse.json();
+            if (!chatsNewBody.id) {
+                logger.error('适配器', '创建对话响应中没有无 id', meta);
+                return { error: '创建对话响应中没有 id' };
+            }
+            logger.debug('适配器', `对话创建成功, id: ${chatsNewBody.id}`, meta);
+        } catch (e) {
+            logger.error('适配器', '解析 chats/new 响应失败', { ...meta, error: e.message });
+            return { error: '解析对话响应失败' };
+        }
+
+        // 7. 等待 chat/completions 响应 (状态码 200 且 status: true)
+        let completionsResponse;
+        try {
+            completionsResponse = await waitApiResponse(page, {
+                urlMatch: 'chat/completions',
+                method: 'POST',
+                timeout: 120000,
+                errorText: ['Model is unable to process your request', 'Rate limit reached'],
+                meta
+            });
+        } catch (e) {
+            const pageError = normalizePageError(e, meta);
+            if (pageError) return pageError;
+            throw e;
+        }
+
+        const completionsHttpError = normalizeHttpError(completionsResponse);
+        if (completionsHttpError) {
+            logger.error('适配器', `生成请求失败: ${completionsHttpError.error}`, meta);
+            return { error: `生成请求失败: ${completionsHttpError.error}` };
+        }
+
+        try {
+            const completionsBody = await completionsResponse.json();
+            if (!completionsBody.status) {
+                logger.error('适配器', '生成响应 status 不为 true', meta);
+                return { error: '生成失败，响应状态异常' };
+            }
+            logger.debug('适配器', '生成请求成功', meta);
+        } catch (e) {
+            logger.error('适配器', '解析 completions 响应失败', { ...meta, error: e.message });
+            return { error: '解析生成响应失败' };
+        }
+
+        // 8. 等待 chat/completed 响应，从中提取文本内容
+        logger.debug('适配器', '正在等待完成响应...', meta);
+
+        let completedResponse;
+        try {
+            completedResponse = await waitApiResponse(page, {
+                urlMatch: 'chat/completed',
+                method: 'POST',
+                timeout: 120000,
+                errorText: ['Model is unable to process your request', 'Rate limit reached'],
+                meta
+            });
+        } catch (e) {
+            const pageError = normalizePageError(e, meta);
+            if (pageError) {
+                if (e.name === 'TimeoutError') {
+                    return { error: '等待完成响应超时 (120秒)' };
+                }
+                return pageError;
+            }
+            throw e;
+        }
+
+        // 解析 chat/completed 响应
+        let completedBody;
+        try {
+            completedBody = await completedResponse.json();
+        } catch (e) {
+            logger.error('适配器', '解析 chat/completed 响应失败', { ...meta, error: e.message });
+            return { error: '解析完成响应失败' };
+        }
+
+        // 在 messages 数组中查找匹配的消息 (id 与响应体的 id 相同)
+        const targetMessage = (completedBody.messages || []).find(msg => msg.id === completedBody.id);
+        if (!targetMessage) {
+            logger.error('适配器', `未找到匹配的消息`, meta);
+            return { error: '未找到匹配的消息' };
+        }
+
+        // 检查 content
+        const content = targetMessage.content;
+        if (!content || content.trim() === '') {
+            logger.warn('适配器', '回复内容为空可能触发违规/限流', meta);
+            return { error: '回复内容为空可能触发违规/限流' };
+        }
+
+        // 提取文本内容 (移除开头的 <details> 思考块)
+        const textContent = extractTextContent(content);
+        if (!textContent) {
+            logger.warn('适配器', '提取文本内容为空', meta);
+            return { error: '提取文本内容为空' };
+        }
+
+        logger.info('适配器', `已提取文本内容 (${textContent.length} 字符)`, meta);
+        logger.info('适配器', '文本生成完成，任务完成', meta);
+        return { text: textContent };
+
+    } catch (err) {
+        // 顶层错误处理
+        const pageError = normalizePageError(err, meta);
+        if (pageError) return pageError;
+
+        logger.error('适配器', '生成任务失败', { ...meta, error: err.message });
+        return { error: `生成任务失败: ${err.message}` };
+    } finally {
+        // 任务结束，将鼠标移至安全区域
+        await moveMouseAway(page);
+    }
+}
+
+/**
+ * 适配器 manifest
+ */
+export const manifest = {
+    id: 'zai_is_text',
+    displayName: 'zAI (文本生成)',
+    description: '使用 zAI 平台生成文本，支持多种大语言模型。需要 Discord 账户登录授权。',
+
+    // 入口 URL
+    getTargetUrl(config, workerConfig) {
+        return TARGET_URL;
+    },
+
+    // 模型列表 - 文本生成模型
+    models: [
+        { id: 'glm-4.6', codeName: 'GLM 4.6', imagePolicy: 'optional' },
+        { id: 'gemini-3-pro-preview', codeName: 'Gemini 3 Pro Preview', imagePolicy: 'optional' },
+        { id: 'gemini-2.5-pro', codeName: 'Gemini 2.5 Pro', imagePolicy: 'optional' },
+        { id: 'gemini-3-flash-preview', codeName: 'Gemini 3 Flash Preview', imagePolicy: 'optional' },
+        { id: 'claude-sonnet-4.5', codeName: 'Claude Sonnet 4.5', imagePolicy: 'optional' },
+        { id: 'claude-sonnet-4', codeName: 'Claude Sonnet 4', imagePolicy: 'optional' },
+        { id: 'claude-haiku-4.5', codeName: 'Claude Haiku 4.5', imagePolicy: 'optional' },
+        { id: 'gpt-5.1', codeName: 'GPT-5.1', imagePolicy: 'optional' },
+        { id: 'gpt-5', codeName: 'GPT-5', imagePolicy: 'optional' },
+        { id: 'gpt-4.1', codeName: 'GPT-4.1', imagePolicy: 'optional' },
+        { id: 'gpt-5.2', codeName: 'GPT-5.2 Chat', imagePolicy: 'optional' },
+        { id: 'o3-high', codeName: 'o3-high', imagePolicy: 'optional' },
+        { id: 'o3-mini', codeName: 'o3-mini', imagePolicy: 'optional' },
+        { id: 'o4-mini', codeName: 'o4-mini', imagePolicy: 'optional' },
+        { id: 'grok-4.1-fast', codeName: 'Grok 4.1 Fast', imagePolicy: 'optional' },
+        { id: 'grok-4', codeName: 'Grok 4', imagePolicy: 'optional' },
+        { id: 'kimi-k2-thinking', codeName: 'Kimi K2 Thinking', imagePolicy: 'optional' },
+    ],
+
+    // 导航处理器
+    navigationHandlers: [handleDiscordAuth],
+
+    // 核心文本生成方法
+    generate
+};

src/backend/adapter/zenmux_ai_text.js

@@ -0,0 +1,302 @@
+/**
+ * @fileoverview ZenMux 文本生成适配器
+ */
+
+import {
+    sleep,
+    safeClick,
+    pasteImages
+} from '../engine/utils.js';
+import {
+    fillPrompt,
+    submit,
+    normalizePageError,
+    normalizeHttpError,
+    waitApiResponse,
+    moveMouseAway,
+    waitForInput,
+    gotoWithCheck
+} from '../utils/index.js';
+import { logger } from '../../utils/logger.js';
+
+// Zenmux AI 输入框选择器
+const INPUT_SELECTOR = '.chat-input-container textarea';
+const SEND_BUTTON_SELECTOR = '.input-actions-send button';
+
+/**
+ * 生成文本
+ * @param {object} context - 浏览器上下文 { page, client, config }
+ * @param {string} prompt - 提示词
+ * @param {string[]} imgPaths - 参考图片路径数组
+ * @param {string} modelId - 模型 ID
+ * @returns {Promise<{text?: string, error?: string}>} 生成结果
+ */
+async function generate(context, prompt, imgPaths, modelId, meta = {}) {
+    const { page } = context;
+
+    try {
+        const targetUrl = 'https://zenmux.ai/settings/chat';
+
+        // 解析模型ID
+        const modelConfig = manifest.models.find(m => m.id === modelId);
+        const { codeName, providers } = modelConfig;
+
+        // 导航到目标页面
+        logger.info('适配器', '开启新会话', meta);
+        await gotoWithCheck(page, targetUrl);
+
+        // 点击 New Chat 按钮开启新对话
+        try {
+            const newChatBtn = page.locator('span').filter({ hasText: /New Chat/ }).locator('..').first();
+            // 等待按钮出现（最多等待 5 秒）
+            await newChatBtn.waitFor({ state: 'visible', timeout: 5000 });
+            await safeClick(page, newChatBtn, { bias: 'button' });
+            logger.debug('适配器', '已点击 New Chat 按钮', meta);
+            await sleep(500, 1000);
+        } catch (e) {
+            logger.debug('适配器', `New Chat 按钮未找到或已在新会话中: ${e.message}`, meta);
+        }
+
+        // 1. 等待输入框加载
+        logger.debug('适配器', '正在寻找输入框...', meta);
+        await waitForInput(page, INPUT_SELECTOR, { click: false });
+        await sleep(1000, 1500);
+
+        // 2. 上传图片 (如果有)
+        if (imgPaths && imgPaths.length > 0) {
+            const expectedUploads = imgPaths.length;
+            let uploadedCount = 0;
+
+            logger.info('适配器', `准备上传 ${expectedUploads} 张图片`, meta);
+
+            await pasteImages(page, INPUT_SELECTOR, imgPaths, {
+                uploadValidator: (response) => {
+                    const url = response.url();
+                    // 监听 oss/upload POST 请求
+                    if (response.request().method() === 'POST' && url.includes('oss/upload')) {
+                        if (response.status() === 200) {
+                            uploadedCount++;
+                            logger.info('适配器', `图片上传进度: ${uploadedCount}/${expectedUploads}`, meta);
+
+                            // 所有图片上传完成
+                            if (uploadedCount >= expectedUploads) {
+                                return true;
+                            }
+                        }
+                    }
+                    return false;
+                }
+            });
+
+            await sleep(1000, 2000);
+            logger.info('适配器', '图片上传完成', meta);
+        }
+
+        // 3. 填写提示词
+        await safeClick(page, INPUT_SELECTOR, { bias: 'input' });
+        await fillPrompt(page, INPUT_SELECTOR, prompt, meta);
+        await sleep(500, 1000);
+
+        // 4. 设置请求拦截器（修改模型ID和providers）
+        logger.debug('适配器', '已启用请求拦截', meta);
+        await page.unroute('**/*').catch(() => { });
+
+        await page.route(url => url.href.includes('v1/chat/completions'), async (route) => {
+            const request = route.request();
+            if (request.method() !== 'POST') return route.continue();
+
+            try {
+                const postData = request.postDataJSON();
+                if (postData) {
+                    let modified = false;
+
+                    // 修改模型 ID（使用 codeName）
+                    if (postData.model) {
+                        logger.info('适配器', `已拦截请求，修改模型 ID: ${postData.model} -> ${codeName}`, meta);
+                        postData.model = codeName;
+                        modified = true;
+                    }
+
+                    // 修改 providers（如果模型配置中有 providers）
+                    if (providers && providers.length > 0) {
+                        if (!postData.provider) postData.provider = {};
+                        if (!postData.provider.routing) postData.provider.routing = {};
+
+                        logger.info('适配器', `已拦截请求，修改 providers: ${JSON.stringify(postData.provider.routing.providers)} -> ${JSON.stringify(providers)}`, meta);
+                        postData.provider.routing.providers = providers;
+                        modified = true;
+                    }
+
+                    if (modified) {
+                        await route.continue({ postData: JSON.stringify(postData) });
+                        return;
+                    }
+                }
+            } catch (e) {
+                logger.error('适配器', '请求拦截处理失败', { ...meta, error: e.message });
+            }
+            await route.continue();
+        });
+
+        // 5. 提交
+        logger.debug('适配器', '点击发送...', meta);
+        await submit(page, {
+            btnSelector: SEND_BUTTON_SELECTOR,
+            inputTarget: INPUT_SELECTOR,
+            meta
+        });
+
+        logger.info('适配器', '等待生成结果中...', meta);
+
+        // 5. 等待 API 响应
+        let apiResponse;
+        try {
+            apiResponse = await waitApiResponse(page, {
+                urlMatch: 'v1/chat/completions',
+                method: 'POST',
+                timeout: 120000,
+                meta
+            });
+        } catch (e) {
+            const pageError = normalizePageError(e, meta);
+            if (pageError) return pageError;
+            throw e;
+        }
+
+        // 检查 API 响应状态
+        const httpError = normalizeHttpError(apiResponse);
+        if (httpError) {
+            logger.error('适配器', `请求生成时返回错误: ${httpError.error}`, meta);
+            return { error: `请求生成时返回错误: ${httpError.error}` };
+        }
+
+        // 6. 解析流式响应
+        const content = await apiResponse.text();
+        logger.debug('适配器', `收到响应，长度: ${content.length}`, meta);
+
+        // 解析 EventStream 格式响应
+        let fullText = '';
+        try {
+            const lines = content.split('\n');
+
+            for (const line of lines) {
+                // 跳过空行和 [DONE] 标记
+                if (!line.trim() || line.includes('[DONE]')) {
+                    continue;
+                }
+
+                // 解析 data: 开头的行
+                if (line.startsWith('data: ')) {
+                    const jsonStr = line.substring(6); // 去掉 "data: " 前缀
+
+                    try {
+                        const parsed = JSON.parse(jsonStr);
+
+                        // 提取 choices 中的 content
+                        if (parsed.choices && Array.isArray(parsed.choices)) {
+                            for (const choice of parsed.choices) {
+                                const content = choice?.delta?.content;
+
+                                // 只提取有内容的文本（跳过空字符串和思考过程）
+                                if (content && content.trim()) {
+                                    fullText += content;
+                                }
+                            }
+                        }
+                    } catch (parseErr) {
+                        // 单个 JSON 解析失败不影响整体
+                        logger.debug('适配器', `解析单个数据块失败: ${parseErr.message}`, meta);
+                    }
+                }
+            }
+        } catch (e) {
+            logger.error('适配器', '解析响应失败', { ...meta, error: e.message });
+            return { error: `解析响应失败: ${e.message}` };
+        }
+
+        if (fullText) {
+            logger.info('适配器', `获取文本成功，长度: ${fullText.length}`, meta);
+            return { text: fullText };
+        } else {
+            logger.warn('适配器', '未解析到有效文本内容', { ...meta, preview: content.substring(0, 200) });
+            return { error: '未解析到有效文本内容' };
+        }
+
+    } catch (err) {
+        // 顶层错误处理
+        const pageError = normalizePageError(err, meta);
+        if (pageError) return pageError;
+
+        logger.error('适配器', '生成任务失败', { ...meta, error: err.message });
+        return { error: `生成任务失败: ${err.message}` };
+    } finally {
+        // 清理拦截器
+        await page.unroute('**/*').catch(() => { });
+        // 任务结束，将鼠标移至安全区域
+        await moveMouseAway(page);
+    }
+}
+
+/**
+ * 适配器 manifest
+ */
+export const manifest = {
+    id: 'zenmux_ai',
+    displayName: 'Zenmux AI (文本生成)',
+    description: '使用 Zenmux AI 平台生成文本，支持多种大语言模型。需要已登录的 ZenMux 账户。',
+
+    // 无需额外配置
+    configSchema: [],
+
+    // 入口 URL
+    getTargetUrl() {
+        return 'https://zenmux.ai/settings/chat';
+    },
+
+    // 模型列表（仅支持非会员账户可用的模型）
+    models: [
+        { id: 'gemini-3-flash-preview', codeName: 'google/gemini-3-flash-preview-free', imagePolicy: 'optional', type: 'text', providers: ["google-vertex"] },
+        { id: 'mimo-v2-flash', codeName: 'xiaomi/mimo-v2-flash', imagePolicy: 'forbidden', type: 'text', providers: ["xiaomi"] },
+        { id: 'glm-4.6v-flash', codeName: 'z-ai/glm-4.6v-flash', imagePolicy: 'optional', type: 'text', providers: ["z-ai"] },
+        { id: 'mistral-large-2512', codeName: 'mistralai/mistral-large-2512', imagePolicy: 'optional', type: 'text', providers: ["azure"] },
+        { id: 'deepseek-v3.2', codeName: 'deepseek/deepseek-chat', imagePolicy: 'forbidden', type: 'text', providers: ["deepseek"] },
+        { id: 'deepseek-v3.2-thinking', codeName: 'deepseek/deepseek-reasoner', imagePolicy: 'forbidden', type: 'text', providers: ["deepseek"] },
+        { id: 'grok-4.1-fast', codeName: 'x-ai/grok-4.1-fast', imagePolicy: 'optional', type: 'text', providers: ["x-ai"] },
+        { id: 'grok-4.1-fast-non-reasoning', codeName: 'x-ai/grok-4.1-fast-non-reasoning', imagePolicy: 'optional', type: 'text', providers: ["x-ai"] },
+        { id: 'gpt-5.1-codex-mini', codeName: 'openai/gpt-5.1-codex-mini', imagePolicy: 'optional', type: 'text', providers: ["openai"] },
+        { id: 'ernie-5.0-thinking-preview', codeName: 'baidu/ernie-5.0-thinking-preview', imagePolicy: 'optional', type: 'text', providers: ["baidu"] },
+        { id: 'doubao-seed-code', codeName: 'volcengine/doubao-seed-code', imagePolicy: 'optional', type: 'text', providers: ["volcengine"] },
+        { id: 'kimi-k2-thinking', codeName: 'moonshotai/kimi-k2-thinking', imagePolicy: 'forbidden', type: 'text', providers: ["moonshotai"] },
+        { id: 'minimax-m2', codeName: 'minimax/minimax-m2', imagePolicy: 'forbidden', type: 'text', providers: ["minimax"] },
+        { id: 'kat-coder-pro-v1', codeName: 'kuaishou/kat-coder-pro-v1', imagePolicy: 'forbidden', type: 'text', providers: ["streamlake"] },
+        { id: 'glm-4.6', codeName: 'z-ai/glm-4.6', imagePolicy: 'forbidden', type: 'text', providers: ["z-ai"] },
+        { id: 'claude-sonnet-4.5', codeName: 'anthropic/claude-sonnet-4.5', imagePolicy: 'optional', type: 'text', providers: ["anthropic"] },
+        { id: 'qwen3-max', codeName: 'qwen/qwen3-max', imagePolicy: 'forbidden', type: 'text', providers: ["alibaba"] },
+        { id: 'grok-4-fast', codeName: 'x-ai/grok-4-fast', imagePolicy: 'optional', type: 'text', providers: ["x-ai"] },
+        { id: 'grok-4-fast-non-reasoning', codeName: 'x-ai/grok-4-fast-non-reasoning', imagePolicy: 'optional', type: 'text', providers: ["x-ai"] },
+        { id: 'grok-code-fast-1', codeName: 'x-ai/grok-code-fast-1', imagePolicy: 'forbidden', type: 'text', providers: ["x-ai"] },
+        { id: 'deepseek-v3.1', codeName: 'deepseek/deepseek-chat-v3.1', imagePolicy: 'forbidden', type: 'text', providers: ["theta"] },
+        { id: 'gpt-5-mini', codeName: 'openai/gpt-5-mini', imagePolicy: 'optional', type: 'text', providers: ["openai"] },
+        { id: 'gpt-5-nano', codeName: 'openai/gpt-5-nano', imagePolicy: 'optional', type: 'text', providers: ["openai"] },
+        { id: 'glm-4.5-air', codeName: 'z-ai/glm-4.5-air', imagePolicy: 'forbidden', type: 'text', providers: ["z-ai"] },
+        { id: 'gemini-2.5-flash-lite', codeName: 'google/gemini-2.5-flash-lite', imagePolicy: 'optional', type: 'text', providers: ["google-vertex"] },
+        { id: 'gemini-2.5-flash', codeName: 'google/gemini-2.5-flash', imagePolicy: 'optional', type: 'text', providers: ["google-vertex"] },
+        { id: 'deepseek-r1-0528', codeName: 'deepseek/deepseek-r1-0528', imagePolicy: 'forbidden', type: 'text', providers: ["theta"] },
+        { id: 'claude-sonnet-4', codeName: 'anthropic/claude-sonnet-4', imagePolicy: 'optional', type: 'text', providers: ["anthropic"] },
+        { id: 'qwen3-14b', codeName: 'qwen/qwen3-14b', imagePolicy: 'optional', type: 'text', providers: ["theta"] },
+        { id: 'o4-mini', codeName: 'openai/o4-mini', imagePolicy: 'optional', type: 'text', providers: ["openai"] },
+        { id: 'gpt-4.1-mini', codeName: 'openai/gpt-4.1-mini', imagePolicy: 'optional', type: 'text', providers: ["openai"] },
+        { id: 'gpt-4.1-nano', codeName: 'openai/gpt-4.1-nano', imagePolicy: 'optional', type: 'text', providers: ["openai"] },
+        { id: 'gemini-2.0-flash-lite', codeName: 'google/gemini-2.0-flash-lite-001', imagePolicy: 'optional', type: 'text', providers: ["google-vertex"] },
+        { id: 'claude-3.7-sonnet', codeName: 'anthropic/claude-3.7-sonnet', imagePolicy: 'optional', type: 'text', providers: ["anthropic"] },
+        { id: 'gemini-2.0-flash', codeName: 'google/gemini-2.0-flash', imagePolicy: 'optional', type: 'text', providers: ["google-vertex"] },
+        { id: 'claude-3.5-sonnet', codeName: 'anthropic/claude-3.5-sonnet', imagePolicy: 'optional', type: 'text', providers: ["anthropic"] },
+    ],
+
+
+    // 无需导航处理器
+    navigationHandlers: [],
+
+    // 核心生成方法
+    generate
+};

src/backend/engine/launcher.js

@@ -0,0 +1,363 @@
+/**
+ * @fileoverview 浏览器启动与生命周期管理
+ * @description 负责启动 Camoufox（Playwright 内核）、注入指纹与代理，并在进程退出时做资源清理。
+ *              导航和预热行为由工作池负责，本模块只负责启动浏览器。
+ *
+ * 约定：
+ * - 登录模式会尽量保留 Profile（用户数据目录）
+ * - 清理采用三级退出：Playwright close -> SIGTERM -> SIGKILL
+ */
+
+import { Camoufox } from 'camoufox-js';
+import { sampleWebGL } from 'camoufox-js/dist/webgl/sample.js';
+import { FingerprintGenerator } from 'fingerprint-generator';
+import fs from 'fs';
+import path from 'path';
+import os from 'os';
+import { createCursor } from 'ghost-cursor-playwright-port';
+import { getRealViewport, clamp, random, sleep } from './utils.js';
+import { logger } from '../../utils/logger.js';
+import { getBrowserProxy, cleanupProxy } from '../../utils/proxy.js';
+
+// 全局状态：用于在登录模式下管理残留进程与复用上下文
+let globalBrowserProcess = null;
+let globalContext = null; // 替代 globalBrowser
+
+/**
+ * 清理浏览器资源和进程
+ * 实现三级退出机制: Playwright close -> SIGTERM -> SIGKILL
+ * @returns {Promise<void>}
+ */
+export async function cleanup() {
+
+    // Level 1: 通过 Playwright 协议优雅关闭 Context，保存 Profile
+    if (globalContext) {
+        try {
+            logger.debug('浏览器', '正在断开远程调试连接并保存 Profile...');
+            await globalContext.close();
+            globalContext = null;
+            logger.debug('浏览器', '已关闭浏览器上下文');
+        } catch (e) {
+            logger.warn('浏览器', `关闭上下文失败: ${e.message}`);
+        }
+    }
+
+    // Level 2 & 3: 处理残留进程 (主要用于登录模式)
+    if (globalBrowserProcess && !globalBrowserProcess.killed) {
+        logger.info('浏览器', '正在终止浏览器进程...');
+        try {
+            // Level 2: 发送 SIGTERM (软杀)
+            globalBrowserProcess.kill('SIGTERM');
+
+            // 等待进程退出
+            const start = Date.now();
+            while (Date.now() - start < 2000) {
+                try {
+                    process.kill(globalBrowserProcess.pid, 0);
+                    await new Promise(r => setTimeout(r, 200));
+                } catch (e) {
+                    break;
+                }
+            }
+        } catch (e) { }
+
+        // Level 3: 强制查杀 (SIGKILL)
+        try {
+            process.kill(globalBrowserProcess.pid, 0);
+            logger.debug('浏览器', '浏览器进程无响应，执行强制终止 (SIGKILL)...');
+            process.kill(-globalBrowserProcess.pid, 'SIGKILL');
+        } catch (e) { }
+
+        globalBrowserProcess = null;
+        logger.info('浏览器', '浏览器进程已终止');
+    }
+
+    // 清理代理
+    await cleanupProxy();
+}
+
+// 防止重复注册
+let signalHandlersRegistered = false;
+
+/**
+ * 注册进程退出信号处理
+ * @private
+ */
+function registerCleanupHandlers() {
+    if (signalHandlersRegistered) return;
+
+    process.on('exit', () => {
+        if (globalBrowserProcess) globalBrowserProcess.kill();
+    });
+
+    process.on('SIGINT', async () => {
+        await cleanup();
+        process.exit();
+    });
+
+    process.on('SIGTERM', async () => {
+        await cleanup();
+        process.exit();
+    });
+
+    signalHandlersRegistered = true;
+}
+
+/**
+ * 获取当前操作系统名称
+ * 将 Node.js 的 platform 转换为 Camoufox/FingerprintGenerator 支持的格式
+ */
+function getCurrentOS() {
+    const platform = os.platform();
+    if (platform === 'win32') return 'windows';
+    if (platform === 'darwin') return 'macos';
+    // 其他情况默认为 linux
+    return 'linux';
+}
+
+/**
+ * 获取 WebGL 平台标识
+ * 将操作系统名称转换为 sampleWebGL 支持的格式
+ */
+function getWebGLPlatform(osName) {
+    if (osName === 'windows') return 'win';
+    if (osName === 'macos') return 'mac';
+    return 'lin';
+}
+
+/**
+ * 获取或生成持久化指纹 (含 WebGL 配置校验)
+ * @param {string} filePath - JSON文件保存路径
+ */
+async function getPersistentFingerprint(filePath) {
+    // 确保 data 目录存在
+    const dir = path.dirname(filePath);
+    if (!fs.existsSync(dir)) {
+        fs.mkdirSync(dir, { recursive: true });
+    }
+
+    let fingerprintData = null;
+    let webglPair = null;
+    let shouldSave = false;
+    const currentOS = getCurrentOS();
+    const targetWebGLOS = getWebGLPlatform(currentOS);
+
+    // 1. 尝试读取现有指纹
+    if (fs.existsSync(filePath)) {
+        try {
+            const fileContent = fs.readFileSync(filePath, 'utf8');
+            fingerprintData = JSON.parse(fileContent);
+        } catch (e) {
+            logger.warn('浏览器', `指纹文件损坏: ${e.message}`);
+        }
+    }
+
+    // 2. 校验 WebGL 配置的有效性 (从 videoCard 读取)
+    if (fingerprintData?.videoCard?.['webGl:vendor'] && fingerprintData?.videoCard?.['webGl:renderer']) {
+        const savedVendor = fingerprintData.videoCard['webGl:vendor'];
+        const savedRenderer = fingerprintData.videoCard['webGl:renderer'];
+        try {
+            // 拿着保存的配置，去数据库里"试探"一下是否存在
+            await sampleWebGL(targetWebGLOS, savedVendor, savedRenderer);
+
+            // 如果没报错，说明配置有效，保留使用
+            webglPair = [savedVendor, savedRenderer];
+            logger.debug('浏览器', `加载 WebGL 配置成功: ${savedRenderer}`);
+        } catch (e) {
+            // 数据库里没找到 -> 配置失效
+            logger.warn('浏览器', `保存的 WebGL 配置与当前系统(${targetWebGLOS})不匹配，将重新生成`);
+            webglPair = null;
+            shouldSave = true;
+        }
+    }
+
+    // 3. 如果指纹完全不存在，生成新的基础指纹
+    if (!fingerprintData) {
+        logger.info('浏览器', `正在为系统 [${currentOS}] 生成新指纹...`);
+        const generatorOptions = {
+            browsers: ['firefox'],
+            operatingSystems: [currentOS],
+            devices: ['desktop'],
+            locales: ['en-US'],
+            screen: { minWidth: 1280, maxWidth: 1366, minHeight: 720, maxHeight: 768 }
+        };
+        const generator = new FingerprintGenerator(generatorOptions);
+        fingerprintData = generator.getFingerprint().fingerprint;
+
+        // 清洗 UA 版本
+        if (fingerprintData.navigator) {
+            let ua = fingerprintData.navigator.userAgent;
+            const TARGET_VERSION = "135.0";
+            ua = ua.replace(/rv:[\d\.]+/g, `rv:${TARGET_VERSION}`);
+            ua = ua.replace(/Firefox\/[\d\.]+/g, `Firefox/${TARGET_VERSION}`);
+            fingerprintData.navigator.userAgent = ua;
+        }
+
+        // 清洗插件数据
+        if (fingerprintData.pluginsData) {
+            fingerprintData.pluginsData.plugins = [];
+            fingerprintData.pluginsData.mimeTypes = [];
+        }
+
+        shouldSave = true;
+    }
+
+    // 4. 如果 WebGL 配置为空，重新生成
+    if (!webglPair) {
+        try {
+            logger.info('浏览器', `正在生成新的 WebGL 配置 (${targetWebGLOS})...`);
+            const webglData = await sampleWebGL(targetWebGLOS);
+            webglPair = [webglData['webGl:vendor'], webglData['webGl:renderer']];
+
+            // 覆盖 videoCard
+            fingerprintData.videoCard = {
+                'webGl:vendor': webglPair[0],
+                'webGl:renderer': webglPair[1]
+            };
+
+            shouldSave = true;
+        } catch (e) {
+            logger.error('浏览器', `致命错误：无法生成 WebGL 配置: ${e.message}`);
+        }
+    }
+
+    // 5. 如果 Canvas 噪点不存在，生成新的
+    if (fingerprintData.canvasOffset === undefined) {
+        const offset = Math.floor(Math.random() * 41) - 20;
+        fingerprintData.canvasOffset = offset;
+        logger.info('浏览器', `已生成 Canvas 噪点偏移: ${offset}`);
+        shouldSave = true;
+    }
+
+    // 5. 如果有变动，保存回文件
+    if (shouldSave) {
+        fs.writeFileSync(filePath, JSON.stringify(fingerprintData, null, 2));
+        logger.info('浏览器', `指纹已更新并保存至: ${filePath}`);
+    }
+
+    return fingerprintData;
+}
+
+/**
+ * 启动浏览器实例 (仅负责启动，不负责导航和预热)
+ * 
+ * 导航到目标页面、注册导航处理器、预热行为由工作池 (pool.js) 负责。
+ * 
+ * @param {object} config - 全局配置对象
+ * @param {object} options - 启动选项
+ * @param {string} options.userDataDir - 用户数据目录路径
+ * @param {string} [options.userDataMark] - 用户数据目录标识 (用于日志显示)
+ * @param {object} [options.proxyConfig] - Worker 级代理配置
+ * @returns {Promise<{context: object, page: object}>} 浏览器上下文和初始页面
+ */
+export async function initBrowserBase(config, options = {}) {
+    const {
+        userDataDir,
+        instanceName = null,
+        proxyConfig = null
+    } = options;
+
+    // 日志标识 (优先使用实例名称)
+    const markLabel = instanceName || '默认';
+
+    // 检测登录模式和 Xvfb 模式
+    const isLoginMode = process.argv.some(arg => arg.startsWith('-login'));
+    const isXvfbMode = process.env.XVFB_RUNNING === 'true';
+    const headlessMode = config?.browser?.headless && !isLoginMode && !isXvfbMode;
+
+    // 如果配置了无头模式但被强制禁用，输出原因
+    if (config?.browser?.headless && !headlessMode) {
+        const reasons = [];
+        if (isLoginMode) reasons.push('登录模式');
+        if (isXvfbMode) reasons.push('Xvfb 模式');
+        logger.info('浏览器', `[${markLabel}] 无头模式已被禁用 (${reasons.join(' + ')})`);
+    }
+
+    logger.info('浏览器', `[${markLabel}] 启动浏览器实例...`);
+
+    const browserConfig = config?.browser || {};
+
+    // 获取指纹对象（指纹文件放在对应的 userDataDir 内）
+    const fingerprintPath = path.join(userDataDir, 'fingerprint.json');
+    const myFingerprint = await getPersistentFingerprint(fingerprintPath);
+
+    // 构造 Camoufox 启动选项
+    const currentOS = getCurrentOS();
+    const camoufoxLaunchOptions = {
+        executable_path: browserConfig.path || undefined,
+        headless: headlessMode,
+        user_data_dir: userDataDir,
+        ff_version: 135,
+        fingerprint: myFingerprint,
+        os: currentOS,
+        i_know_what_im_doing: true,
+        webgl_config: myFingerprint.videoCard ? [myFingerprint.videoCard['webGl:vendor'], myFingerprint.videoCard['webGl:renderer']] : undefined,
+        block_webrtc: true,
+        exclude_addons: ['UBO'],
+        geoip: true,
+        config: {
+            forceScopeAccess: true,
+            // Canvas 抗指纹：注入固定噪点偏移
+            'canvas:aaOffset': myFingerprint.canvasOffset ?? 0,
+            'canvas:aaCapOffset': true
+        },
+        // 关闭动画减轻资源压力
+        firefox_user_prefs: {
+            // 禁用背景模糊滤镜 (高 CPU 消耗)
+            'layout.css.backdrop-filter.enabled': false,
+            // 告诉网页用户倾向于减少动画 (触发网页自身的优化)
+            'ui.prefersReducedMotion': 1,
+            // 站点隔离
+            ...(browserConfig.fission === false ? { 'fission.autostart': false } : {})
+        }
+    };
+
+    // 代理配置
+    const proxyObj = await getBrowserProxy(proxyConfig);
+    if (proxyObj) {
+        camoufoxLaunchOptions.proxy = proxyObj;
+    }
+
+    // 启动 Camoufox
+    const context = await Camoufox(camoufoxLaunchOptions);
+    globalContext = context;
+
+    // 构建状态描述
+    const statusParts = [];
+    statusParts.push(`无头模式: ${headlessMode ? '是' : '否'}`);
+    if (proxyObj) statusParts.push('代理: 已配置');
+    logger.info('浏览器', `[${markLabel}] 浏览器已启动 (${statusParts.join(', ')})`);
+
+    // 注册清理处理器
+    registerCleanupHandlers();
+
+    // 注册断开连接事件
+    context.on('close', async () => {
+        logger.warn('浏览器', `[${markLabel}] 浏览器已断开连接`);
+        await cleanup();
+        process.exit(0);
+    });
+
+    // 获取或创建 Page
+    let page;
+    const existingPages = context.pages();
+    if (existingPages.length > 0) {
+        page = existingPages[0];
+    } else {
+        page = await context.newPage();
+    }
+
+    // 强制刷新视口大小 (使用指纹中的屏幕尺寸)
+    const screenWidth = myFingerprint.screen?.availWidth || 1366;
+    const screenHeight = myFingerprint.screen?.availHeight || 768;
+    await page.setViewportSize({ width: screenWidth, height: screenHeight });
+
+    // 返回 context 和 page（导航、预热、cursor 初始化由工作池负责）
+    return {
+        context,
+        page
+    };
+}
+
+// 导出工具函数供 pool.js 使用
+export { createCursor, getRealViewport, clamp, random, sleep };

src/backend/engine/utils.js

@@ -0,0 +1,607 @@
+/**
+ * @fileoverview 浏览器自动化工具函数
+ * @description 封装 Playwright 页面常用操作，供后端适配器复用。
+ *
+ * 职责边界：
+ * - 浏览器原子操作（点击、输入、上传等）
+ * - 页面状态检测（isPageValid、createPageCloseWatcher）
+ * - 拟人化交互（humanType、safeClick、safeScroll）
+ * - 工具函数（random、sleep、getMimeType）
+ *
+ * 注意：业务逻辑应放在 backend/utils.js
+ *
+ * 主要函数：
+ * - `random` / `sleep`：随机与延迟工具
+ * - `getMimeType`：根据文件扩展名推断 MIME
+ * - `getRealViewport` / `clamp`：视口与坐标工具（防止越界）
+ * - `queryDeep`：深层查询（包含 Shadow DOM / iframe）
+ * - `safeClick` / `humanType`：拟人化点击与输入
+ * - `pasteImages` / `uploadFilesViaChooser`：图片粘贴/上传辅助
+ * - `isPageValid` / `createPageCloseWatcher`：页面有效性与关闭/崩溃监听
+ */
+
+import path from 'path';
+import { logger } from '../../utils/logger.js';
+
+/**
+ * 生成指定范围内的随机数
+ * @param {number} min - 最小值
+ * @param {number} max - 最大值
+ * @returns {number} 随机数
+ */
+export function random(min, max) {
+    return Math.random() * (max - min) + min;
+}
+
+/**
+ * 随机休眠一段时间
+ * @param {number} min - 最小毫秒数
+ * @param {number} max - 最大毫秒数
+ * @returns {Promise<void>}
+ */
+export function sleep(min, max) {
+    return new Promise(r => setTimeout(r, Math.floor(random(min, max))));
+}
+
+/**
+ * 根据文件扩展名获取 MIME 类型
+ * @param {string} filePath - 文件路径
+ * @returns {string} MIME 类型
+ */
+export function getMimeType(filePath) {
+    const ext = path.extname(filePath).toLowerCase();
+    const map = {
+        '.png': 'image/png',
+        '.jpg': 'image/jpeg',
+        '.jpeg': 'image/jpeg',
+        '.gif': 'image/gif',
+        '.webp': 'image/webp'
+    };
+    return map[ext] || 'application/octet-stream';
+}
+
+/**
+ * 无痕获取当前页面实时视口
+ * 使用纯净的匿名函数执行，不污染 Global Scope
+ * @param {import('playwright-core').Page} page - Playwright 页面实例
+ * @returns {Promise<{width: number, height: number, safeWidth: number, safeHeight: number}>} 视口尺寸及安全区域
+ */
+export async function getRealViewport(page) {
+    try {
+        return await page.evaluate(() => {
+            // 仅读取标准属性，不进行任何写入操作
+            const w = window.innerWidth;
+            const h = window.innerHeight;
+            return {
+                width: w,
+                height: h,
+                // 预留 20px 缓冲，防止鼠标移到滚动条上或贴边触发浏览器原生手势
+                safeWidth: w - 20,
+                safeHeight: h
+            };
+        });
+    } catch (e) {
+        // Fallback: 如果上下文丢失，返回安全保守值
+        return { width: 1280, height: 720, safeWidth: 1260, safeHeight: 720 };
+    }
+}
+
+/**
+ * 坐标钳位函数
+ * 强制将坐标限制在合法视口范围内，防止 "Node is not visible" 报错
+ * @param {number} value - 原始坐标值
+ * @param {number} min - 最小值
+ * @param {number} max - 最大值
+ * @returns {number} 修正后的坐标值
+ */
+export function clamp(value, min, max) {
+    return Math.min(Math.max(value, min), max);
+}
+
+/**
+ * 深度查找 Shadow DOM 中的元素
+ * @param {import('playwright-core').Page} page - Playwright 页面实例
+ * @param {string} selector - CSS 选择器
+ * @param {import('playwright-core').ElementHandle} [rootHandle=null] - 可选的根节点句柄
+ * @returns {Promise<import('playwright-core').ElementHandle|null>} 找到的元素句柄或 null
+ */
+export async function queryDeep(page, selector, rootHandle = null) {
+    // Playwright evaluateHandle 只接受一个参数，包装成数组传递
+    return await page.evaluateHandle(([sel, root]) => {
+        function find(node, s) {
+            if (!node) return null;
+            if (node instanceof Element && node.matches(s)) return node;
+            let found = node.querySelector(s);
+            if (found) return found;
+            if (node.shadowRoot) {
+                found = find(node.shadowRoot, s);
+                if (found) return found;
+            }
+            const walker = document.createTreeWalker(node, NodeFilter.SHOW_ELEMENT, null, false);
+            while (walker.nextNode()) {
+                const child = walker.currentNode;
+                if (child.shadowRoot) {
+                    found = find(child.shadowRoot, s);
+                    if (found) return found;
+                }
+            }
+            return null;
+        }
+        return find(root || document.body, sel);
+    }, [selector, rootHandle]);
+}
+
+/**
+ * 计算拟人化的随机点击坐标
+ * @param {object} box - 元素边界框 {x, y, width, height}
+ * @param {string} [type='random'] - 点击类型: 'input'(偏左) 或 'random'/'button'(随机)
+ * @returns {{x: number, y: number}} ��算出的坐标
+ */
+export function getHumanClickPoint(box, type = 'random') {
+    let x, y;
+    if (type === 'input') {
+        // 输入框: 偏左 (5% - 40% 宽度), 垂直居中附近 (20% - 80% 高度)
+        x = box.x + box.width * random(0.05, 0.4);
+        y = box.y + box.height * random(0.2, 0.8);
+    } else {
+        // 按钮/其他: 中心附近随机 (20% - 80% 宽度/高度)
+        x = box.x + box.width * random(0.2, 0.8);
+        y = box.y + box.height * random(0.2, 0.8);
+    }
+    return { x, y };
+}
+
+/**
+ * 安全点击元素 (包含拟人化移动和点击)
+ * 支持 CSS selector、ElementHandle 和 Locator 三种输入
+ * @param {import('playwright-core').Page} page - Playwright 页面对象
+ * @param {string|import('playwright-core').ElementHandle|import('playwright-core').Locator} target - CSS 选择器、元素句柄或 Locator
+ * @param {object} [options] - 点击选项
+ * @param {string} [options.bias='random'] - 偏移偏好: 'input' 或 'random'
+ * @returns {Promise<void>}
+ */
+export async function safeClick(page, target, options = {}) {
+    try {
+        let el;
+
+        // 判断输入类型
+        if (typeof target === 'string') {
+            // CSS selector
+            el = await page.$(target);
+            if (!el) throw new Error(`未找到: ${target}`);
+        } else if (typeof target.elementHandle === 'function') {
+            // Locator (来自 page.getByRole, page.getByText 等)
+            el = await target.elementHandle();
+            if (!el) throw new Error(`Locator 未匹配到元素`);
+        } else {
+            // ElementHandle
+            el = target;
+            if (!el || !el.asElement()) throw new Error(`Element handle invalid`);
+        }
+
+        // 使用 ghost-cursor 点击
+        if (page.cursor) {
+            const box = await el.boundingBox();
+            if (box) {
+                const { x, y } = getHumanClickPoint(box, options.bias || 'random');
+                await page.cursor.moveTo({ x, y });
+                await page.mouse.click(x, y);
+                return;
+            }
+            // 如果无法获取 box，降级到默认点击
+            await page.cursor.click(el);
+            return;
+        }
+
+        // 降级逻辑
+        await el.click();
+    } catch (err) {
+        throw err;
+    }
+}
+
+/**
+ * 安全滚动 (包含拟人化移动和滚轮滚动)
+ * 支持 CSS selector、ElementHandle 和 Locator 三种输入
+ * @param {import('playwright-core').Page} page - Playwright 页面对象
+ * @param {string|import('playwright-core').ElementHandle|import('playwright-core').Locator} target - CSS 选择器、元素句柄或 Locator
+ * @param {object} [options] - 滚动选项
+ * @param {number} [options.deltaX=0] - 水平滚动距离 (正值向右)
+ * @param {number} [options.deltaY=0] - 垂直滚动距离 (正值向下)
+ * @param {string} [options.bias='random'] - 偏移偏好: 'input' 或 'random'
+ * @returns {Promise<void>}
+ */
+export async function safeScroll(page, target, options = {}) {
+    try {
+        let el;
+
+        // 判断输入类型
+        if (typeof target === 'string') {
+            // CSS selector
+            el = await page.$(target);
+            if (!el) throw new Error(`未找到: ${target}`);
+        } else if (typeof target.elementHandle === 'function') {
+            // Locator (来自 page.getByRole, page.getByText 等)
+            el = await target.elementHandle();
+            if (!el) throw new Error(`Locator 未匹配到元素`);
+        } else {
+            // ElementHandle
+            el = target;
+            if (!el || !el.asElement()) throw new Error(`Element handle invalid`);
+        }
+
+        const deltaX = options.deltaX || 0;
+        const deltaY = options.deltaY || 0;
+
+        // 使用 ghost-cursor hover 后滚动
+        if (page.cursor) {
+            const box = await el.boundingBox();
+            if (box) {
+                const { x, y } = getHumanClickPoint(box, options.bias || 'random');
+                await page.cursor.moveTo({ x, y });
+                await page.mouse.wheel(deltaX, deltaY);
+                return;
+            }
+            // 如果无法获取 box，降级到元素中心点滚动
+            await page.cursor.move(el);
+            await page.mouse.wheel(deltaX, deltaY);
+            return;
+        }
+
+        // 降级逻辑: 直接在元素上 hover 并滚动
+        await el.hover();
+        await page.mouse.wheel(deltaX, deltaY);
+    } catch (err) {
+        throw err;
+    }
+}
+
+/**
+ * 模拟人类键盘输入
+ * 支持 CSS selector 和 ElementHandle 两种输入
+ * @param {import('playwright-core').Page} page - Playwright 页面对象
+ * @param {string|import('playwright-core').ElementHandle|null} target - CSS 选择器、元素句柄，或 null（需配合 skipFocus 使用）
+ * @param {string} text - 要输入的文本
+ * @param {object} [options] - 可选配置
+ * @param {boolean} [options.skipFocus=false] - 跳过元素定位和 focus，直接输入（适用于已获得焦点的场景）
+ * @returns {Promise<void>}
+ */
+export async function humanType(page, target, text, options = {}) {
+    const { skipFocus = false } = options;
+
+    // 如果不跳过 focus，需要定位并聚焦元素
+    if (!skipFocus) {
+        let el;
+
+        // 判断是 selector 还是 ElementHandle
+        if (typeof target === 'string') {
+            el = await page.$(target);
+            if (!el) throw new Error(`Element not found: ${target}`);
+        } else {
+            el = target;
+            if (!el) throw new Error(`Element handle invalid`);
+        }
+
+        await el.focus();
+    }
+
+    // 智能输入策略
+    if (text.length < 50) {
+        // 短文本: 保持拟人化逐字输入
+        for (let i = 0; i < text.length; i++) {
+            const char = text[i];
+            const nextChar = text[i + 1];
+
+            // 处理换行符 (避免触发发送)
+            if (char === '\r' && nextChar === '\n') {
+                // Windows 换行符 (\r\n)
+                await page.keyboard.down('Shift');
+                await page.keyboard.press('Enter');
+                await page.keyboard.up('Shift');
+                i++; // 跳过 \n
+                await sleep(30, 100);
+                continue;
+            } else if (char === '\n' || char === '\r') {
+                // Unix/Mac 换行符 (\n 或 \r)
+                await page.keyboard.down('Shift');
+                await page.keyboard.press('Enter');
+                await page.keyboard.up('Shift');
+                await sleep(30, 100);
+                continue;
+            }
+
+            // 模拟错字 (5% 概率)
+            if (Math.random() < 0.05) {
+                await page.keyboard.type('x', { delay: random(50, 150) });
+                await sleep(100, 300);
+                await page.keyboard.press('Backspace', { delay: random(50, 100) });
+            }
+            await page.keyboard.type(char, { delay: random(30, 100) });
+            // 随机击键间隔
+            await sleep(30, 100);
+        }
+    } else {
+        // 长文本: 假装打字 -> 停顿 -> 粘贴
+        const fakeCount = Math.floor(random(3, 8));
+        const fakeText = text.substring(0, fakeCount);
+
+        // 1. 假装打字几个字符
+        for (let i = 0; i < fakeText.length; i++) {
+            await page.keyboard.type(fakeText[i], { delay: random(30, 100) });
+        }
+
+        // 2. 停顿思考
+        await sleep(500, 1000);
+
+        // 3. 全选删除 (macOS 使用 Meta/Command, Windows/Linux 使用 Control)
+        const modifierKey = process.platform === 'darwin' ? 'Meta' : 'Control';
+        await page.keyboard.down(modifierKey);
+        await page.keyboard.press('A');
+        await page.keyboard.up(modifierKey);
+        await sleep(100, 300);
+        await page.keyboard.press('Backspace');
+        await sleep(100, 300);
+
+        // 4. 瞬间粘贴全部文本 (始终使用已获取的 ElementHandle，支持 Shadow DOM)
+        await page.evaluate((content) => {
+            document.execCommand('insertText', false, content);
+        }, text);
+    }
+}
+
+/**
+ * 查找页面上所有的文件输入框 (包括 Shadow DOM)
+ * @private
+ * @param {import('playwright-core').Page} page - Playwright 页面对象
+ * @returns {Promise<import('playwright-core').ElementHandle[]>} 文件输入框 ElementHandle 数组
+ */
+async function findAllFileInputs(page) {
+    // 使用 Playwright 的 evaluateHandle 在浏览器上下文中深度遍历
+    const inputsHandle = await page.evaluateHandle(() => {
+        const inputs = [];
+
+        function traverse(root) {
+            if (!root) return;
+
+            // 1. 检查当前节点下的 input
+            const nodes = root.querySelectorAll('input[type="file"]');
+            nodes.forEach(n => inputs.push(n));
+
+            // 2. 遍历 Shadow DOM
+            const walker = document.createTreeWalker(root, NodeFilter.SHOW_ELEMENT, null, false);
+            while (walker.nextNode()) {
+                const node = walker.currentNode;
+                if (node.shadowRoot) {
+                    traverse(node.shadowRoot);
+                }
+            }
+        }
+
+        traverse(document.body);
+        return inputs;
+    });
+
+    const properties = await inputsHandle.getProperties();
+    const handles = [];
+    for (const prop of properties.values()) {
+        const elementHandle = prop.asElement();
+        if (elementHandle) handles.push(elementHandle);
+    }
+    return handles;
+}
+
+/**
+ * 统一图片上传入口 (Camoufox/Playwright 专用稳定版)
+ * 策略: 深度搜索原生 input[type="file"] -> setInputFiles
+ * @param {import('playwright-core').Page} page - Playwright 页面对象
+ * @param {string|import('playwright-core').ElementHandle} target - CSS 选择器或元素句柄 (用于聚焦)
+ * @param {string[]} filePaths - 图片文件路径数组
+ * @param {Object} [options] - 可选配置
+ * @param {Function} [options.uploadValidator] - 自定义上传确认回调函数, 接收 response 参数
+ * @returns {Promise<void>}
+ */
+export async function pasteImages(page, target, filePaths, options = {}) {
+    if (!filePaths || filePaths.length === 0) return;
+    logger.info('浏览器', `正在处理 ${filePaths.length} 张图片...`);
+
+    // 1. 拟人化: 先点击一下目标区域 (让后台看起来像是用户聚焦了输入框)
+    await safeClick(page, target, { bias: 'input' });
+    await sleep(500, 1000);
+
+    try {
+        logger.debug('浏览器', '正在深度扫描文件上传控件...');
+        const fileInputs = await findAllFileInputs(page);
+
+        if (fileInputs.length === 0) {
+            throw new Error('未找到任何 input[type="file"] 控件,无法上传');
+        }
+
+        logger.info('浏览器', `找到 ${fileInputs.length} 个文件输入框,尝试上传...`);
+
+        // LMArena 通常只有一个用于聊天的上传控件，或者我们尝试第一个可用的
+        // 如果有多个，通常最后一个是当前对话框的，或者我们可以尝试全部 (比较暴力但有效)
+        let uploaded = false;
+
+        for (const handle of fileInputs) {
+            try {
+                // 检查元素是否连接在 DOM 上
+                const isConnected = await handle.evaluate(el => el.isConnected);
+                if (!isConnected) continue;
+
+                // 使用 Playwright 原生上传 (绕过所有事件拦截)
+                await handle.setInputFiles(filePaths);
+                uploaded = true;
+                logger.debug('浏览器', '已通过原生控件提交图片');
+                break; // 只要有一个成功就停止
+            } catch (e) {
+                // 忽略不可操作的 input (比如被禁用的)
+                logger.debug('浏览器', `跳过不可用的文件输入框: ${e.message}`);
+            }
+        }
+
+        if (!uploaded) {
+            throw new Error('所有文件控件均无法接受输入');
+        }
+
+        // 如果提供了自定义的上传确认函数，使用它
+        if (options.uploadValidator && typeof options.uploadValidator === 'function') {
+            const expectedUploads = filePaths.length;
+            let validatedCount = 0;
+
+            const uploadPromise = new Promise((resolve) => {
+                const timeout = setTimeout(() => {
+                    cleanup();
+                    logger.warn('浏览器', `图片上传等待超时 (已确认: ${validatedCount}/${expectedUploads})`);
+                    resolve();
+                }, 60000); // 60s 超时
+
+                const onResponse = (response) => {
+                    if (options.uploadValidator(response)) {
+                        validatedCount++;
+                        logger.info('浏览器', `图片上传进度: ${validatedCount}/${expectedUploads}`);
+                        if (validatedCount >= expectedUploads) {
+                            cleanup();
+                            resolve();
+                        }
+                    }
+                };
+
+                const cleanup = () => {
+                    clearTimeout(timeout);
+                    page.off('response', onResponse);
+                };
+
+                page.on('response', onResponse);
+            });
+
+            logger.info('浏览器', `已提交图片, 正在等待上传确认...`);
+            await uploadPromise;
+            logger.info('浏览器', `所有图片上传完成`);
+        } else {
+            // 默认行为: 等待上传预览出现
+            logger.info('浏览器', `已提交图片, 等待预览生成...`);
+            await sleep(2000, 4000);
+        }
+
+    } catch (e) {
+        logger.error('浏览器', `上传失败: ${e.message}`);
+        throw e;
+    }
+}
+
+/**
+ * 通过 filechooser 事件上传文件 (适用于无 DOM input 元素的场景，如 Firefox)
+ * @param {import('playwright-core').Page} page - Playwright 页面对象
+ * @param {string|import('playwright-core').ElementHandle|import('playwright-core').Locator} triggerTarget - 触发文件选择的按钮
+ * @param {string[]} filePaths - 文件路径数组
+ * @param {Object} [options] - 可选配置
+ * @param {Function} [options.uploadValidator] - 自定义上传确认回调函数, 接收 response 参数，返回 true 表示该响应代表一次成功上传
+ * @param {number} [options.timeout=60000] - 上传超时时间 (毫秒)
+ * @returns {Promise<void>}
+ */
+export async function uploadFilesViaChooser(page, triggerTarget, filePaths, options = {}) {
+    if (!filePaths || filePaths.length === 0) return;
+
+    const timeout = options.timeout || 60000;
+    const expectedUploads = filePaths.length;
+    let uploadedCount = 0;
+
+    logger.info('浏览器', `正在处理 ${filePaths.length} 张图片 (filechooser 模式)...`);
+
+    // 设置上传确认监听
+    const uploadPromise = new Promise((resolve) => {
+        if (!options.uploadValidator) {
+            // 无验证器，直接 resolve
+            resolve();
+            return;
+        }
+
+        const timeoutId = setTimeout(() => {
+            cleanup();
+            logger.warn('浏览器', `图片上传等待超时 (已确认: ${uploadedCount}/${expectedUploads})`);
+            resolve();
+        }, timeout);
+
+        const onResponse = (response) => {
+            if (options.uploadValidator(response)) {
+                uploadedCount++;
+                logger.info('浏览器', `图片上传进度: ${uploadedCount}/${expectedUploads}`);
+                if (uploadedCount >= expectedUploads) {
+                    cleanup();
+                    resolve();
+                }
+            }
+        };
+
+        const cleanup = () => {
+            clearTimeout(timeoutId);
+            page.off('response', onResponse);
+        };
+
+        page.on('response', onResponse);
+    });
+
+    // 设置等待 filechooser 事件（在点击之前）
+    const fileChooserPromise = page.waitForEvent('filechooser');
+
+    // 点击触发按钮
+    await safeClick(page, triggerTarget, { bias: 'button' });
+
+    // 等待 filechooser 事件并设置文件
+    const fileChooser = await fileChooserPromise;
+    await fileChooser.setFiles(filePaths);
+    logger.debug('浏览器', '已通过 filechooser 提交文件');
+
+    // 等待上传完成（如果有验证器）
+    if (options.uploadValidator) {
+        await uploadPromise;
+        logger.info('浏览器', '所有图片上传完成');
+    }
+}
+
+/**
+ * 检查页面是否有效
+ * @param {import('playwright-core').Page} page
+ * @returns {boolean}
+ */
+export function isPageValid(page) {
+    try {
+        return page && !page.isClosed();
+    } catch {
+        return false;
+    }
+}
+
+/**
+ * 创建页面关闭/崩溃监听Promise
+ * @param {import('playwright-core').Page} page
+ * @returns {{promise: Promise, cleanup: Function}}
+ */
+export function createPageCloseWatcher(page) {
+    let closeHandler, crashHandler;
+
+    const promise = new Promise((_, reject) => {
+        closeHandler = () => reject(new Error('PAGE_CLOSED'));
+        crashHandler = () => reject(new Error('PAGE_CRASHED'));
+
+        page.once('close', closeHandler);
+        page.once('crash', crashHandler);
+    });
+
+    const cleanup = () => {
+        if (closeHandler) page.off('close', closeHandler);
+        if (crashHandler) page.off('crash', crashHandler);
+    };
+
+    return { promise, cleanup };
+}
+
+/**
+ * 获取当前页面的所有 Cookies (实时从浏览器获取)
+ * @param {import('playwright-core').Page} page - Playwright 页面实例
+ * @returns {Promise<object[]>} Cookies 数组 (JSON 格式)
+ */
+export async function getCookies(page) {
+    const context = page.context();
+    return await context.cookies();
+}

src/backend/index.js

@@ -0,0 +1,140 @@
+/**
+ * @fileoverview 后端适配器入口
+ * @description 基于 Pool 架构统一管理多浏览器实例，提供统一的对外接口。
+ *
+ * 对外统一能力：
+ * - `initBrowser(cfg)` → 初始化 Pool
+ * - `generate(ctx, prompt, imagePaths, modelId, meta)`
+ * - `getModels()` / `getImagePolicy(modelKey)` / `getModelType(modelKey)`
+ * - `getCookies(workerName, domain)` - 获取指定 Worker 的 Cookies
+ */
+
+import fs from 'fs';
+import path from 'path';
+import { loadConfig } from '../config/index.js';
+import { PoolManager } from './pool/index.js';
+import { logger } from '../utils/logger.js';
+
+// --- 集中管理的路径常量 ---
+const TEMP_DIR = path.join(process.cwd(), 'data', 'temp');
+
+// 确保临时目录存在
+if (!fs.existsSync(TEMP_DIR)) {
+    fs.mkdirSync(TEMP_DIR, { recursive: true });
+}
+
+// 全局 PoolManager 实例
+let poolManager = null;
+
+/**
+ * 获取后端接口
+ * @returns {object} 后端统一接口
+ */
+export function getBackend() {
+    const config = loadConfig();
+
+    // 将临时目录路径注入 config 对象
+    config.paths = {
+        tempDir: TEMP_DIR
+    };
+
+    return {
+        name: 'pool',
+        config,
+        TEMP_DIR,
+
+        /**
+         * 初始化 Pool
+         * @param {object} cfg - 配置对象
+         * @returns {Promise<{poolManager: PoolManager, config: object}>}
+         */
+        initBrowser: async (cfg) => {
+            if (poolManager && poolManager.initialized) {
+                return { poolManager, config: cfg };
+            }
+
+            poolManager = new PoolManager(cfg);
+            await poolManager.initAll();
+
+            return { poolManager, config: cfg };
+        },
+
+        /**
+         * 生成图片
+         * @param {object} ctx - 浏览器上下文 (来自 initBrowser 返回)
+         * @param {string} prompt - 提示词
+         * @param {string[]} paths - 图片路径
+         * @param {string} modelId - 模型 ID
+         * @param {object} meta - 元信息
+         */
+        generate: async (ctx, prompt, paths, modelId, meta) => {
+            if (!poolManager) {
+                return { error: 'Pool 未初始化' };
+            }
+            return await poolManager.generate(ctx, prompt, paths, modelId, meta);
+        },
+
+        /**
+         * 获取模型列表
+         * @returns {object}
+         */
+        getModels: () => {
+            if (!poolManager) {
+                return { object: 'list', data: [] };
+            }
+            return poolManager.getModels();
+        },
+
+        /**
+         * 获取图片策略
+         * @param {string} modelKey - 模型 key
+         * @returns {string}
+         */
+        getImagePolicy: (modelKey) => {
+            if (!poolManager) {
+                return 'optional';
+            }
+            return poolManager.getImagePolicy(modelKey);
+        },
+
+        /**
+         * 获取模型类型
+         * @param {string} modelKey - 模型 key
+         * @returns {string} 'text' | 'image'
+         */
+        getModelType: (modelKey) => {
+            if (!poolManager) {
+                return 'image';
+            }
+            return poolManager.getModelType(modelKey);
+        },
+
+        /**
+         * 获取 Cookies
+         * @param {string} [workerName] - Worker 名称
+         * @param {string} [domain] - 域名
+         * @returns {Promise<{worker: string, cookies: object[]}>}
+         */
+        getCookies: async (workerName, domain) => {
+            if (!poolManager) {
+                throw new Error('Pool 未初始化');
+            }
+            return await poolManager.getCookies(workerName, domain);
+        },
+
+        /**
+         * 触发监控导航（空闲时）
+         */
+        navigateToMonitor: async () => {
+            if (poolManager) {
+                await poolManager.navigateToMonitor();
+            }
+        },
+
+        /**
+         * 获取 PoolManager 实例
+         * @returns {PoolManager|null}
+         */
+        getPoolManager: () => poolManager
+    };
+}

src/backend/pool/PoolManager.js

@@ -0,0 +1,316 @@
+/**
+ * @fileoverview PoolManager 类
+ * @description 管理 Worker 池，负责初始化、任务分发和故障转移
+ */
+
+import { logger } from '../../utils/logger.js';
+import { registry } from '../registry.js';
+import { createStrategySelector } from '../strategies/index.js';
+import { executeWithFailover } from '../strategies/failover.js';
+import { normalizeError } from '../utils/error.js';
+import { Worker } from './Worker.js';
+
+/**
+ * PoolManager 类 - 管理 Worker 池
+ */
+export class PoolManager {
+    /**
+     * @param {object} config - 全局配置
+     */
+    constructor(config) {
+        this.config = config;
+        this.workers = [];
+        this.strategy = config.backend.pool.strategy || 'least_busy';
+        this.strategySelector = createStrategySelector(this.strategy);
+        this.initialized = false;
+    }
+
+    /**
+     * 初始化所有 Worker
+     */
+    async initAll() {
+        if (this.initialized) return;
+
+        // 先加载所有适配器
+        await registry.loadAll();
+
+        // 注入适配器配置（用于模型过滤）
+        const adapterConfig = this.config.backend?.adapter || {};
+        registry.setAdapterConfig(adapterConfig);
+
+        // 解析登录模式参数
+        let loginWorkerName = null;
+        const loginArg = process.argv.find(arg => arg.startsWith('-login'));
+        const isLoginMode = !!loginArg;
+        if (loginArg && loginArg.includes('=')) {
+            loginWorkerName = loginArg.split('=')[1];
+            logger.info('工作池', `登录模式: 仅初始化 Worker "${loginWorkerName}"`);
+        } else if (isLoginMode) {
+            loginWorkerName = this.config.backend.pool.workers[0]?.name || null;
+            logger.info('工作池', `登录模式: 仅初始化第一个 Worker "${loginWorkerName}"`);
+        }
+
+        const workerConfigs = this.config.backend.pool.workers;
+
+        if (isLoginMode) {
+            logger.info('工作池', `登录模式: 从 ${workerConfigs.length} 个 Worker 中筛选...`);
+        } else {
+            logger.info('工作池', `正在初始化 ${workerConfigs.length} 个 Worker...`);
+        }
+
+        // 过滤并创建 Worker 实例
+        const validWorkers = [];
+        for (const workerConfig of workerConfigs) {
+            if (isLoginMode && workerConfig.name !== loginWorkerName) {
+                logger.debug('工作池', `[${workerConfig.name}] 跳过 (不匹配登录目标)`);
+                continue;
+            }
+
+            if (workerConfig.type !== 'merge' && !registry.hasAdapter(workerConfig.type)) {
+                logger.error('工作池', `Worker [${workerConfig.name}] 的类型 "${workerConfig.type}" 无对应适配器，跳过`);
+                continue;
+            }
+
+            if (workerConfig.type === 'merge') {
+                const invalidTypes = (workerConfig.mergeTypes || []).filter(t => !registry.hasAdapter(t));
+                if (invalidTypes.length > 0) {
+                    logger.error('工作池', `Worker [${workerConfig.name}] 的 mergeTypes 包含无效类型: ${invalidTypes.join(', ')}`);
+                    continue;
+                }
+            }
+
+            validWorkers.push(new Worker(this.config, workerConfig));
+        }
+
+        if (isLoginMode && validWorkers.length === 0) {
+            const availableNames = workerConfigs.map(w => w.name).join(', ');
+            throw new Error(`登录模式未找到 Worker "${loginWorkerName}"。可用的 Worker: ${availableNames}`);
+        }
+
+        // 按 userDataDir 分组
+        const browserMap = new Map();
+
+        for (const worker of validWorkers) {
+            try {
+                const existing = browserMap.get(worker.userDataDir);
+
+                if (existing) {
+                    const workerProxy = JSON.stringify(worker.proxyConfig || null);
+                    const existingProxy = JSON.stringify(existing.proxyConfig || null);
+                    if (workerProxy !== existingProxy) {
+                        logger.warn('工作池', `[${worker.name}] 代理配置与 [${existing.firstWorkerName}] 不一致，将使用后者的配置`);
+                    }
+
+                    logger.debug('工作池', `[${worker.name}] 将与其他 Worker 共享浏览器 (${worker.userDataDir})`);
+                    await worker.init(existing.browser);
+                } else {
+                    await worker.init();
+                    browserMap.set(worker.userDataDir, {
+                        browser: worker.browser,
+                        proxyConfig: worker.proxyConfig,
+                        firstWorkerName: worker.name
+                    });
+                }
+
+                this.workers.push(worker);
+            } catch (e) {
+                logger.error('工作池', `[${worker.name}] 初始化失败，跳过该 Worker`, { error: e.message });
+            }
+        }
+
+        if (this.workers.length === 0) {
+            throw new Error('所有 Worker 初始化都失败了，无法启动���务');
+        }
+
+        this.initialized = true;
+        logger.info('工作池', `工作池初始化完成，共 ${this.workers.length} 个 Worker 就绪 (${browserMap.size} 个浏览器实例)`);
+    }
+
+    /**
+     * 根据模型选择 Worker
+     */
+    selectWorker(modelId) {
+        const candidates = this.workers.filter(w => w.supports(modelId));
+
+        if (candidates.length === 0) {
+            throw new Error(`没有 Worker 支持模型: ${modelId}`);
+        }
+
+        if (candidates.length === 1) {
+            return candidates[0];
+        }
+
+        switch (this.strategy) {
+            case 'round_robin': {
+                const idx = this.roundRobinIndex % candidates.length;
+                this.roundRobinIndex++;
+                return candidates[idx];
+            }
+            case 'random': {
+                const idx = Math.floor(Math.random() * candidates.length);
+                return candidates[idx];
+            }
+            case 'least_busy':
+            default: {
+                return candidates.reduce((min, w) => w.busyCount < min.busyCount ? w : min, candidates[0]);
+            }
+        }
+    }
+
+    /**
+     * 分发生图任务（支持故障转移）
+     */
+    async generate(ctx, prompt, paths, modelId, meta) {
+        const failoverConfig = this.config.backend?.pool?.failover || {};
+        const failoverEnabled = failoverConfig.enabled !== false;
+        const maxRetries = failoverConfig.maxRetries || 2;
+
+        let candidates = this.workers.filter(w => w.supports(modelId));
+
+        if (candidates.length === 0) {
+            return { error: `没有 Worker 支持模型: ${modelId}` };
+        }
+
+        // 如果请求包含图片，优先选择 imagePolicy 为 optional 的 Worker
+        const hasImages = paths && paths.length > 0;
+        if (hasImages && candidates.length > 1) {
+            const optionalCandidates = candidates.filter(w => {
+                const policy = w.getImagePolicy(modelId);
+                return policy === 'optional' || policy === 'required';
+            });
+
+            if (optionalCandidates.length > 0) {
+                logger.debug('工作池', `请求包含图片，优先选择支持图片的 Worker (${optionalCandidates.length}/${candidates.length} 个)`);
+                candidates = optionalCandidates;
+            } else {
+                logger.warn('工作池', `请求包含图片，但没有 Worker 的 imagePolicy 为 optional`);
+            }
+        }
+
+        const sortedCandidates = this.strategySelector.sort(candidates);
+
+        if (!failoverEnabled) {
+            const worker = sortedCandidates[0];
+            logger.debug('工作池', `任务分发至: ${worker.name} (busy: ${worker.busyCount})`);
+            return await this._safeExecuteWorker(worker, ctx, prompt, paths, modelId, meta);
+        }
+
+        return await executeWithFailover(
+            sortedCandidates,
+            async (worker) => {
+                logger.debug('工作池', `任务分发至: ${worker.name} (busy: ${worker.busyCount})`);
+                return await this._safeExecuteWorker(worker, ctx, prompt, paths, modelId, meta);
+            },
+            {
+                maxRetries,
+                meta,
+                onRetry: (worker, error) => {
+                    logger.warn('工作池', `[${worker.name}] 失败，尝试下一个 Worker...`, { error, ...meta });
+                }
+            }
+        );
+    }
+
+    /**
+     * 安全执行 Worker（带错误边界）
+     * @private
+     */
+    async _safeExecuteWorker(worker, ctx, prompt, paths, modelId, meta) {
+        try {
+            return await worker.generate(ctx, prompt, paths, modelId, meta);
+        } catch (err) {
+            logger.error('工作池', `[${worker.name}] 执行异常`, { error: err.message, ...meta });
+            return normalizeError(err.message || '执行异常');
+        }
+    }
+
+    /**
+     * 获取所有模型列表
+     */
+    getModels() {
+        const allModels = [];
+        const seenIds = new Set();
+
+        for (const worker of this.workers) {
+            const models = worker.getModels();
+            for (const m of models) {
+                if (!seenIds.has(m.id)) {
+                    seenIds.add(m.id);
+                    allModels.push(m);
+                }
+            }
+        }
+
+        return { object: 'list', data: allModels };
+    }
+
+    /**
+     * 获取图片策略（宽松策略：只要有一个 Worker 支持 optional 就返回 optional）
+     */
+    getImagePolicy(modelKey) {
+        const policies = new Set();
+
+        for (const worker of this.workers) {
+            if (worker.supports(modelKey)) {
+                policies.add(worker.getImagePolicy(modelKey));
+            }
+        }
+
+        // 宽松策略：只要有一个 optional 就返回 optional
+        if (policies.has('optional')) return 'optional';
+        if (policies.has('required')) return 'required';
+        if (policies.has('forbidden')) return 'forbidden';
+        return 'optional';
+    }
+
+    /**
+     * 获取模型类型
+     */
+    getModelType(modelKey) {
+        for (const worker of this.workers) {
+            if (worker.supports(modelKey)) {
+                return worker.getModelType(modelKey);
+            }
+        }
+        return 'image';
+    }
+
+    /**
+     * 获取指定实例的 Cookies
+     */
+    async getCookies(instanceName, domain) {
+        let worker;
+        if (instanceName) {
+            worker = this.workers.find(w => w.instanceName === instanceName);
+            if (!worker) {
+                throw new Error(`浏览器实例不存在: ${instanceName}`);
+            }
+        } else {
+            worker = this.workers[0];
+            if (!worker) {
+                throw new Error('工作池中没有可用的 Worker');
+            }
+        }
+
+        const cookies = await worker.getCookies(domain);
+        return { instance: worker.instanceName, cookies };
+    }
+
+    /**
+     * 触发所有 merge Worker 的监控导航
+     */
+    async navigateToMonitor() {
+        for (const worker of this.workers) {
+            if (worker.type === 'merge' && worker.busyCount === 0) {
+                await worker.navigateToMonitor();
+            }
+        }
+    }
+
+    /**
+     * 获取第一个 Worker 的 page
+     */
+    getFirstPage() {
+        return this.workers[0]?.page || null;
+    }
+}

src/backend/pool/Worker.js

@@ -0,0 +1,494 @@
+/**
+ * @fileoverview Worker 类
+ * @description 封装单个浏览器实例，提供模型匹配和任务执行能力
+ */
+
+import fs from 'fs';
+import { logger } from '../../utils/logger.js';
+import { initBrowserBase, createCursor } from '../engine/launcher.js';
+import { registry } from '../registry.js';
+import { tryGotoWithCheck } from '../utils/page.js';
+
+/**
+ * Worker 类 - 封装单个浏览器实例
+ */
+export class Worker {
+    /**
+     * @param {object} globalConfig - 全局配置
+     * @param {object} workerConfig - Worker 配置
+     */
+    constructor(globalConfig, workerConfig) {
+        this.name = workerConfig.name;
+        this.type = workerConfig.type;
+        this.instanceName = workerConfig.instanceName || null;
+        this.userDataDir = workerConfig.userDataDir;
+        this.proxyConfig = workerConfig.resolvedProxy;
+        this.globalConfig = globalConfig;
+        this.workerConfig = workerConfig;
+
+        // Merge 模式专属
+        this.mergeTypes = workerConfig.mergeTypes || [];
+        this.mergeMonitor = workerConfig.mergeMonitor || null;
+
+        // 运行时状态
+        this.browser = null;
+        this.page = null;
+        this.busyCount = 0;
+        this.initialized = false;
+    }
+
+    /**
+     * 初始化浏览器实例
+     * @param {object} [sharedBrowser] - 可选，共享的浏览器实例
+     */
+    async init(sharedBrowser = null) {
+        if (this.initialized) return;
+
+        // 确保用户数据目录存在
+        if (!fs.existsSync(this.userDataDir)) {
+            fs.mkdirSync(this.userDataDir, { recursive: true });
+        }
+
+        // 获取目标 URL
+        let targetUrl = 'about:blank';
+        if (this.type === 'merge') {
+            const firstType = this.mergeTypes[0];
+            targetUrl = registry.getTargetUrl(firstType, this.globalConfig, this.workerConfig) || 'about:blank';
+        } else {
+            targetUrl = registry.getTargetUrl(this.type, this.globalConfig, this.workerConfig) || 'about:blank';
+        }
+
+        // 登录模式下不注册导航处理器，避免自动登录干预用户操作
+        const isLoginMode = process.argv.some(arg => arg.startsWith('-login'));
+        let navigationHandler = null;
+
+        if (!isLoginMode) {
+            // 收集导航处理器
+            const handlers = [];
+            const typesToHandle = this.type === 'merge' ? this.mergeTypes : [this.type];
+            for (const type of typesToHandle) {
+                const typeHandlers = registry.getNavigationHandlers(type);
+                handlers.push(...typeHandlers);
+            }
+
+            navigationHandler = handlers.length > 0
+                ? async (page) => {
+                    for (const handler of handlers) {
+                        try { await handler(page); } catch (e) { /* ignore */ }
+                    }
+                }
+                : null;
+        }
+
+        logger.info('工作池', `[${this.name}] 正在初始化浏览器...`);
+        if (this.proxyConfig) {
+            logger.debug('工作池', `[${this.name}] 使用代理: ${this.proxyConfig.type}://${this.proxyConfig.host}:${this.proxyConfig.port}`);
+        } else {
+            logger.debug('工作池', `[${this.name}] 直连模式（无代理）`);
+        }
+
+        if (sharedBrowser) {
+            await this._initWithSharedBrowser(sharedBrowser, targetUrl, navigationHandler);
+        } else {
+            await this._initNewBrowser(targetUrl, navigationHandler);
+        }
+
+        this.initialized = true;
+    }
+
+    /**
+     * 使用共享浏览器初始化
+     * @private
+     */
+    async _initWithSharedBrowser(sharedBrowser, targetUrl, navigationHandler) {
+        logger.info('工作池', `[${this.name}] 复用已有浏览器，创建新标签页...`);
+        this.browser = sharedBrowser;
+        this.page = await sharedBrowser.newPage();
+        this.page.authState = { isHandlingAuth: false };
+        this.page.cursor = createCursor(this.page);
+
+        await this._navigateToTarget(targetUrl);
+
+        if (navigationHandler) {
+            this.page.on('framenavigated', async () => {
+                try { await navigationHandler(this.page); } catch (e) { /* ignore */ }
+            });
+        }
+
+        logger.info('工作池', `[${this.name}] 初始化完成`);
+    }
+
+    /**
+     * 启动新浏览器初始化
+     * @private
+     */
+    async _initNewBrowser(targetUrl, navigationHandler) {
+        const base = await initBrowserBase(this.globalConfig, {
+            userDataDir: this.userDataDir,
+            instanceName: this.instanceName,
+            proxyConfig: this.proxyConfig
+        });
+
+        this.browser = base.context;
+        this.page = base.page;
+        this.page.authState = { isHandlingAuth: false };
+        this.page.cursor = createCursor(this.page);
+
+        if (navigationHandler) {
+            this.page.on('framenavigated', async () => {
+                try { await navigationHandler(this.page); } catch (e) { /* ignore */ }
+            });
+        }
+
+        logger.info('工作池', `[${this.name}] 正在连接目标页面...`);
+        await this._navigateToTarget(targetUrl);
+
+        // 登录模式：注册浏览器关闭事件（不阻塞）
+        const isLoginMode = process.argv.some(arg => arg.startsWith('-login'));
+        if (isLoginMode) {
+            logger.info('工作池', `[${this.name}] 登录模式已就绪，请在浏览器中完成登录`);
+            this.browser.on('close', () => {
+                logger.info('工作池', `[${this.name}] 浏览器已关闭，登录模式结束`);
+                process.exit(0);
+            });
+        }
+
+        logger.info('工作池', `[${this.name}] 初始化完成`);
+    }
+
+    /**
+     * 导航到目标 URL
+     * @private
+     */
+    async _navigateToTarget(targetUrl) {
+        if (this.type === 'merge') {
+            let gotoSuccess = false;
+            for (const type of this.mergeTypes) {
+                const url = registry.getTargetUrl(type, this.globalConfig, this.workerConfig);
+                if (!url) continue;
+                const gotoResult = await tryGotoWithCheck(this.page, url, { timeout: 30000 });
+                if (!gotoResult.error) {
+                    gotoSuccess = true;
+                    logger.debug('工作池', `[${this.name}] 使用 ${type} 适配器初始化成功`);
+                    break;
+                }
+                logger.warn('工作池', `[${this.name}] ${type} 网站不可用，尝试下一个...`, { error: gotoResult.error });
+            }
+            if (!gotoSuccess) {
+                logger.warn('工作池', `[${this.name}] 所有适配器网站当前不可用，但 Worker 仍将初始化（请求时可能会失败）`);
+            }
+        } else {
+            const gotoResult = await tryGotoWithCheck(this.page, targetUrl, { timeout: 60000 });
+            if (gotoResult.error) {
+                logger.warn('工作池', `[${this.name}] 目标网站当前不可用: ${gotoResult.error}，但 Worker 仍将初始化`);
+            }
+        }
+    }
+
+    /**
+     * 检查是否支持指定模型
+     */
+    supports(modelId) {
+        if (this.type === 'merge') {
+            // 检查任一适配器是否支持该模型
+            for (const type of this.mergeTypes) {
+                if (registry.supportsModel(type, modelId)) return true;
+            }
+            // 支持 type/model 格式
+            if (modelId.includes('/')) {
+                const [specifiedType, actualModel] = modelId.split('/', 2);
+                if (this.mergeTypes.includes(specifiedType)) {
+                    return registry.supportsModel(specifiedType, actualModel);
+                }
+            }
+            return false;
+        } else {
+            // 支持 type/model 格式
+            if (modelId.includes('/')) {
+                const [specifiedType, actualModel] = modelId.split('/', 2);
+                if (specifiedType === this.type) {
+                    return registry.supportsModel(this.type, actualModel);
+                }
+                return false;
+            }
+            return registry.supportsModel(this.type, modelId);
+        }
+    }
+
+    /**
+     * 确定模型对应的适配器类型（内部辅助方法）
+     * @private
+     */
+    _getAdapterType(modelKey) {
+        if (this.type === 'merge') {
+            if (modelKey.includes('/')) {
+                const [specifiedType] = modelKey.split('/', 2);
+                return this.mergeTypes.includes(specifiedType) ? specifiedType : this.mergeTypes[0];
+            }
+            // 找到第一个支持该模型的适配器
+            for (const type of this.mergeTypes) {
+                if (registry.supportsModel(type, modelKey)) return type;
+            }
+            return this.mergeTypes[0];
+        }
+        return this.type;
+    }
+
+    /**
+     * 生成图片
+     */
+    async generate(ctx, prompt, paths, modelId, meta) {
+        const failoverConfig = this.globalConfig.backend?.pool?.failover || {};
+        const failoverEnabled = failoverConfig.enabled !== false;
+
+        if (this.type === 'merge' && failoverEnabled) {
+            return this._generateWithFailover(ctx, prompt, paths, modelId, meta, failoverConfig);
+        }
+
+        // 验证是否支持该模型
+        if (!this.supports(modelId)) {
+            return { error: `Worker [${this.name}] 不支持模型: ${modelId}` };
+        }
+
+        // 确定适配器类型
+        const type = this._getAdapterType(modelId);
+
+        // 处理 type/model 格式，提取实际 modelId
+        let actualModelId = modelId;
+        if (modelId.includes('/')) {
+            const parts = modelId.split('/', 2);
+            actualModelId = parts[1];
+        }
+
+        // 传递原始 modelId 给适配器，由适配器自己解析
+        return this._executeAdapter(ctx, type, actualModelId, prompt, paths, meta);
+    }
+
+    /**
+     * Merge 模式下的故障转移生成
+     * @private
+     */
+    async _generateWithFailover(ctx, prompt, paths, modelId, meta, failoverConfig = {}) {
+        const maxRetries = failoverConfig.maxRetries || 2;
+        const candidateTypes = this._getCandidateTypes(modelId);
+
+        if (candidateTypes.length === 0) {
+            return { error: `Worker [${this.name}] 不支持模型: ${modelId}` };
+        }
+
+        const maxAttempts = maxRetries === 0 ? candidateTypes.length : Math.min(maxRetries + 1, candidateTypes.length);
+        let lastError = null;
+
+        for (let i = 0; i < maxAttempts; i++) {
+            const { type, modelId: actualModelId } = candidateTypes[i];
+            const result = await this._executeAdapter(ctx, type, actualModelId, prompt, paths, meta);
+
+            if (!result.error) {
+                return result;
+            }
+
+            lastError = result.error;
+            if (i < maxAttempts - 1) {
+                logger.warn('工作池', `[${this.name}] ${type} 失败，尝试下一个适配器...`, { error: lastError, ...meta });
+            }
+        }
+
+        return { error: `所有支持该模型的适配器都无法使用: ${lastError}` };
+    }
+
+    /**
+     * 获取支持指定模型的候选适配器类型列表
+     * @private
+     */
+    _getCandidateTypes(modelKey) {
+        const candidates = [];
+
+        if (modelKey.includes('/')) {
+            const [specifiedType, actualModel] = modelKey.split('/', 2);
+            if (this.mergeTypes.includes(specifiedType) && registry.supportsModel(specifiedType, actualModel)) {
+                candidates.push({ type: specifiedType, modelId: actualModel });
+            }
+            return candidates;
+        }
+
+        // 收集所有支持该模型的适配器
+        for (const type of this.mergeTypes) {
+            if (registry.supportsModel(type, modelKey)) {
+                candidates.push({ type, modelId: modelKey });
+            }
+        }
+
+        return candidates;
+    }
+
+    /**
+     * 执行单个适配器
+     * @private
+     */
+    async _executeAdapter(ctx, type, modelId, prompt, paths, meta) {
+        const adapter = registry.getAdapter(type);
+        if (!adapter) {
+            return { error: `适配器不存在: ${type}` };
+        }
+
+        logger.info('工作池', `[${this.name}] 执行任务 -> ${type}/${modelId}`, meta);
+
+        const subContext = {
+            ...ctx,
+            page: this.page,
+            config: this.globalConfig,
+            proxyConfig: this.proxyConfig,
+            userDataDir: this.userDataDir
+        };
+
+        this.busyCount++;
+        try {
+            // 传递原始 modelId，由适配器自己解析
+            return await adapter.generate(subContext, prompt, paths, modelId, meta);
+        } finally {
+            this.busyCount--;
+        }
+    }
+
+    /**
+     * 获取支持的模型列表
+     */
+    getModels() {
+        if (this.type === 'merge') {
+            const allModels = [];
+            const seenIds = new Set();
+
+            for (const type of this.mergeTypes) {
+                const result = registry.getModelsForAdapter(type);
+                if (result?.data) {
+                    for (const m of result.data) {
+                        if (!seenIds.has(m.id)) {
+                            seenIds.add(m.id);
+                            allModels.push({ ...m, owned_by: 'internal_server' });
+                        }
+                    }
+                }
+            }
+
+            for (const type of this.mergeTypes) {
+                const result = registry.getModelsForAdapter(type);
+                if (result?.data) {
+                    for (const m of result.data) {
+                        allModels.push({
+                            ...m,
+                            id: `${type}/${m.id}`,
+                            owned_by: type
+                        });
+                    }
+                }
+            }
+
+            return allModels;
+        } else {
+            const result = registry.getModelsForAdapter(this.type);
+            const models = result?.data || [];
+            const allModels = [];
+
+            for (const m of models) {
+                allModels.push({ ...m, owned_by: 'internal_server' });
+            }
+
+            for (const m of models) {
+                allModels.push({
+                    ...m,
+                    id: `${this.type}/${m.id}`,
+                    owned_by: this.type
+                });
+            }
+
+            return allModels;
+        }
+    }
+
+    /**
+     * 获取图片策略（宽松策略：只要有一个适配器支持 optional 就返回 optional）
+     */
+    getImagePolicy(modelKey) {
+        const policies = new Set();
+
+        if (this.type === 'merge') {
+            if (modelKey.includes('/')) {
+                const [specifiedType, actualModel] = modelKey.split('/', 2);
+                if (this.mergeTypes.includes(specifiedType)) {
+                    return registry.getImagePolicy(specifiedType, actualModel);
+                }
+            }
+            // 收集所有支持该模型的适配器的 imagePolicy
+            for (const type of this.mergeTypes) {
+                if (registry.supportsModel(type, modelKey)) {
+                    policies.add(registry.getImagePolicy(type, modelKey));
+                }
+            }
+        } else {
+            return registry.getImagePolicy(this.type, modelKey);
+        }
+
+        // 宽松策略：只要有一个 optional 就返回 optional
+        if (policies.has('optional')) return 'optional';
+        if (policies.has('required')) return 'required';
+        if (policies.has('forbidden')) return 'forbidden';
+        return 'optional';
+    }
+
+    /**
+     * 获取模型类型
+     */
+    getModelType(modelKey) {
+        if (this.type === 'merge') {
+            if (modelKey.includes('/')) {
+                const [specifiedType, actualModel] = modelKey.split('/', 2);
+                if (this.mergeTypes.includes(specifiedType)) {
+                    return registry.getModelType(specifiedType, actualModel);
+                }
+            }
+            for (const type of this.mergeTypes) {
+                if (registry.supportsModel(type, modelKey)) {
+                    return registry.getModelType(type, modelKey);
+                }
+            }
+            return 'image';
+        } else {
+            return registry.getModelType(this.type, modelKey);
+        }
+    }
+
+    /**
+     * 导航到监控页面（空闲时）
+     */
+    async navigateToMonitor() {
+        if (this.type !== 'merge' || !this.mergeMonitor) return;
+        if (!this.page || this.page.isClosed()) return;
+
+        const targetUrl = registry.getTargetUrl(this.mergeMonitor, this.globalConfig, this.workerConfig);
+        if (!targetUrl) return;
+
+        const currentUrl = this.page.url();
+        try {
+            if (currentUrl.includes(new URL(targetUrl).hostname)) return;
+        } catch (e) { return; }
+
+        logger.info('工作池', `[${this.name}] 空闲，跳转监控: ${this.mergeMonitor}`);
+        try {
+            await this.page.goto(targetUrl, { waitUntil: 'domcontentloaded', timeout: 30000 });
+        } catch (e) {
+            logger.warn('工作池', `[${this.name}] 监控跳转失败: ${e.message}`);
+        }
+    }
+
+    /**
+     * 获取 Cookies
+     */
+    async getCookies(domain) {
+        if (!this.page) throw new Error(`Worker [${this.name}] 未初始化`);
+        const context = this.page.context();
+        if (domain) {
+            return await context.cookies(domain.startsWith('http') ? domain : `https://${domain}`);
+        }
+        return await context.cookies();
+    }
+}