deploy: clean start with hf metadata

.env.example

@@ -0,0 +1,36 @@
+# ============================================
+# Gemini Business2API 配置示例
+# ============================================
+
+# 管理员密钥（必需，用于登录管理面板）
+# 明文示例：
+ADMIN_KEY=your-admin-secret-key
+
+# 服务端口（可选，默认 7860）
+# PORT=7860
+
+# ============================================
+# 数据库配置（可选，用于无持久化存储的环境如 HF Spaces）
+# ============================================
+# 支持 PostgreSQL 数据库存储（账户/设置/统计）
+# 未设置时使用本地文件存储（原有行为）
+#
+# 示例（Neon PostgreSQL）：
+# DATABASE_URL=postgresql://user:password@ep-xxx.aws.neon.tech/dbname?sslmode=require
+#
+# 注意：使用数据库存储需要安装 asyncpg：pip install asyncpg
+# DATABASE_URL=
+
+# ============================================
+# 其他配置请在管理面板的"系统设置"中配置
+# 包括：API密钥、代理、图片生成、重试策略等
+# 配置保存在 data/settings.yaml
+# ============================================
+
+# ============================================
+# 账户配置
+# ============================================
+# 使用 accounts.json 文件
+# 账户配置保存在 accounts.json 文件中
+# 首次启动时会自动创建空配置
+# 请在管理面板中添加账户，或直接编辑 accounts.json

.gitattributes

@@ -0,0 +1,2 @@
+# Auto detect text files and perform LF normalization
+* text=auto

.github/workflows/docker-build.yml

@@ -0,0 +1,55 @@
+name: Build Multi-Arch Docker Image
+
+on:
+  push:
+    branches:
+      - main
+    tags:
+      - "v*"
+  workflow_dispatch:
+
+jobs:
+  build:
+    runs-on: ubuntu-latest
+    steps:
+      - name: Checkout code
+        uses: actions/checkout@v4
+
+      - name: Set up QEMU
+        uses: docker/setup-qemu-action@v3
+
+      - name: Set up Docker Buildx
+        uses: docker/setup-buildx-action@v3
+
+      - name: Login to Docker Hub
+        uses: docker/login-action@v3
+        with:
+          username: ${{ secrets.DOCKERHUB_USERNAME }}
+          password: ${{ secrets.DOCKERHUB_TOKEN }}
+
+      - name: Extract metadata
+        id: meta
+        uses: docker/metadata-action@v5
+        with:
+          images: ${{ secrets.DOCKERHUB_USERNAME }}/gemini-business2api
+          tags: |
+            type=ref,event=branch
+            type=ref,event=pr
+            type=semver,pattern={{version}}
+            type=semver,pattern={{major}}.{{minor}}
+            type=raw,value=latest,enable={{is_default_branch}}
+
+      - name: Build and push
+        uses: docker/build-push-action@v5
+        with:
+          context: .
+          platforms: linux/amd64,linux/arm64
+          push: true
+          tags: ${{ steps.meta.outputs.tags }}
+          labels: ${{ steps.meta.outputs.labels }}
+          cache-from: type=gha
+          cache-to: type=gha,mode=max
+          # 优化构建参数
+          build-args: |
+            BUILDKIT_INLINE_CACHE=1
+          provenance: false

.gitignore

@@ -0,0 +1,50 @@
+# Python
+__pycache__/
+*.py[cod]
+*$py.class
+*.so
+.Python
+build/
+develop-eggs/
+dist/
+downloads/
+eggs/
+.eggs/
+lib64/
+parts/
+sdist/
+var/
+wheels/
+*.egg-info/
+.installed.cfg
+*.egg
+
+# Python lib directory (but not frontend/src/lib)
+/lib/
+
+# Virtual Environment
+venv/
+env/
+ENV/
+.venv
+# IDE
+.vscode/
+.idea/
+*.swp
+*.swo
+*~
+
+# Project specific
+.env
+*.log
+
+# Generated files
+data/
+logs/
+static/
+
+# OS
+.DS_Store
+Thumbs.db
+old_version.py
+docs/img/

Dockerfile

@@ -0,0 +1,68 @@
+# Stage 1: 构建前端
+FROM node:20-slim AS frontend-builder
+WORKDIR /app/frontend
+
+# 先复制 package 文件利用 Docker 缓存
+COPY frontend/package.json frontend/package-lock.json ./
+RUN npm install --silent
+
+# 复制前端源码并构建
+COPY frontend/ ./
+RUN npm run build
+
+# Stage 2: 最终运行时镜像
+FROM python:3.11-slim
+WORKDIR /app
+
+ENV PYTHONDONTWRITEBYTECODE=1 \
+    PYTHONUNBUFFERED=1 \
+    TZ=Asia/Shanghai
+
+# 安装 Python 依赖和浏览器依赖（合并为单一 RUN 指令以减少层数）
+COPY requirements.txt .
+RUN apt-get update && \
+    apt-get install -y --no-install-recommends \
+        gcc \
+        curl \
+        tzdata \
+        chromium chromium-driver \
+        dbus dbus-x11 \
+        xvfb xauth \
+        libglib2.0-0 libnss3 libnspr4 libatk1.0-0 libatk-bridge2.0-0 \
+        libcups2 libdrm2 libxkbcommon0 libxcomposite1 libxdamage1 \
+        libxfixes3 libxrandr2 libgbm1 libasound2 libpango-1.0-0 \
+        libcairo2 fonts-liberation fonts-noto-cjk && \
+    ln -snf /usr/share/zoneinfo/$TZ /etc/localtime && echo $TZ > /etc/timezone && \
+    pip install --no-cache-dir -r requirements.txt && \
+    apt-get purge -y gcc && \
+    apt-get autoremove -y && \
+    rm -rf /var/lib/apt/lists/* /tmp/* /var/tmp/*
+
+# 复制后端代码
+COPY main.py .
+COPY core ./core
+COPY util ./util
+COPY scripts ./scripts
+
+# 从 builder 阶段只复制构建好的静态文件
+COPY --from=frontend-builder /app/static ./static
+
+# 创建数据目录
+RUN mkdir -p ./data
+
+# 复制启动脚本
+COPY entrypoint.sh .
+RUN chmod +x entrypoint.sh
+
+# 声明数据卷
+VOLUME ["/app/data"]
+
+# 声明端口
+EXPOSE 7860
+
+# 健康检查
+HEALTHCHECK --interval=30s --timeout=10s --start-period=10s --retries=3 \
+    CMD curl -f http://localhost:7860/health || exit 1
+
+# 启动服务
+CMD ["./entrypoint.sh"]

LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025 yu
+
+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.

README.md

@@ -0,0 +1,388 @@
+---
+title: Gemini Business2api
+emoji: ♊
+colorFrom: blue
+colorTo: green
+sdk: docker
+pinned: false
+---
+
+<p align="center">
+  <img src="docs/logo.svg" width="120" alt="Gemini Business2API logo" />
+</p>
+<h1 align="center">Gemini Business2API</h1>
+<p align="center">赋予硅基生物以灵魂</p>
+<p align="center">当时明月在 · 曾照彩云归</p>
+<p align="center">
+  <strong>简体中文</strong> | <a href="docs/README_EN.md">English</a>
+</p>
+<p align="center"><img src="https://img.shields.io/badge/License-MIT-yellow.svg" /> <img src="https://img.shields.io/badge/Python-3.11-3776AB?logo=python&logoColor=white" /> <img src="https://img.shields.io/badge/FastAPI-0.110-009688?logo=fastapi&logoColor=white" /> <img src="https://img.shields.io/badge/Vue-3-4FC08D?logo=vue.js&logoColor=white" /> <img src="https://img.shields.io/badge/Vite-7-646CFF?logo=vite&logoColor=white" /> <img src="https://img.shields.io/badge/Docker-ready-2496ED?logo=docker&logoColor=white" /></p>
+
+<p align="center">将 Gemini Business 转换为 OpenAI 兼容接口，支持多账号负载均衡、图像生成、视频生成、多模态能力与内置管理面板。</p>
+
+---
+
+## 📜 开源协议与声明
+
+**开源协议**: MIT License - 查看 [LICENSE](LICENSE) 文件了解详情
+
+### ⚠️ 严禁滥用：禁止将本工具用于商业用途或任何形式的滥用（无论规模大小）
+
+**本工具严禁用于以下行为：**
+- 商业用途或盈利性使用
+- 任何形式的批量操作或自动化滥用（无论规模大小）
+- 破坏市场秩序或恶意竞争
+- 违反 Google 服务条款的任何行为
+- 违反 Microsoft 服务条款的任何行为
+
+**违规后果**：滥用行为可能导致账号永久封禁、法律追责，一切后果由使用者自行承担。
+
+**合法用途**：本项目仅限个人学习、技术研究与非商业性技术交流。
+
+📖 **完整声明与免责条款**：[DISCLAIMER.md](docs/DISCLAIMER.md)
+
+---
+
+## ✨ 功能特性
+
+- ✅ OpenAI API 完全兼容 - 无缝对接现有工具
+- ✅ 多账号负载均衡 - 轮询与故障自动切换
+- ✅ 自动化账号管理 - 支持自动注册与登录，集成多种临时邮箱，支持无头浏览器模式
+- ✅ 流式输出 - 实时响应
+- ✅ 多模态输入 - 100+ 文件类型（图片、PDF、Office 文档、音频、视频、代码等）
+- ✅ 图片生成 & 图生图 - 模型可配置，Base64 或 URL 返回
+- ✅ 视频生成 - 专用模型，支持 HTML/URL/Markdown 输出格式
+- ✅ 智能文件处理 - 自动识别文件类型，支持 URL 与 Base64
+- ✅ 日志与监控 - 实时状态与统计信息
+- ✅ 代理支持 - 通过设置面板配置
+- ✅ 内置管理面板 - 在线配置与账号管理
+- ✅ PostgreSQL / SQLite 存储 - 账户/设置/统计持久化
+
+## 🤖 模型功能
+
+| 模型ID                   | 识图 | 原生联网 | 文件多模态 | 图片生成 | 视频生成 |
+| ------------------------ | ---- | -------- | ---------- | -------- | -------- |
+| `gemini-auto`            | ✅    | ✅        | ✅          | 可选     | -        |
+| `gemini-2.5-flash`       | ✅    | ✅        | ✅          | 可选     | -        |
+| `gemini-2.5-pro`         | ✅    | ✅        | ✅          | 可选     | -        |
+| `gemini-3-flash-preview` | ✅    | ✅        | ✅          | 可选     | -        |
+| `gemini-3-pro-preview`   | ✅    | ✅        | ✅          | 可选     | -        |
+| `gemini-3.1-pro-preview` | ✅    | ✅        | ✅          | 可选     | -        |
+| `gemini-imagen`          | ✅    | ✅        | ✅          | ✅        | -        |
+| `gemini-veo`             | ✅    | ✅        | ✅          | -        | ✅        |
+
+> `gemini-imagen`：专用图片生成模型 · `gemini-veo`：专用视频生成模型
+
+---
+
+## 🚀 快速开始
+
+### 方式一：Docker Compose（推荐）
+
+**支持 ARM64 和 AMD64 架构**
+
+```bash
+git clone https://github.com/Dreamy-rain/gemini-business2api.git
+cd gemini-business2api
+cp .env.example .env
+# 编辑 .env 设置 ADMIN_KEY
+
+docker-compose up -d
+
+# 查看日志
+docker-compose logs -f
+
+# 更新到最新版本
+docker-compose pull && docker-compose up -d
+```
+
+---
+
+### 方式二：安装脚本
+
+> **前置要求**：Git、Node.js & npm（构建前端用）。脚本会自动安装 Python 3.11 和 uv。
+
+**Linux / macOS / WSL：**
+```bash
+git clone https://github.com/Dreamy-rain/gemini-business2api.git
+cd gemini-business2api
+bash setup.sh
+# 编辑 .env 设置 ADMIN_KEY
+source .venv/bin/activate
+python main.py
+# pm2 后台运行
+pm2 start main.py --name gemini-api --interpreter ./.venv/bin/python3
+```
+
+**Windows：**
+```cmd
+git clone https://github.com/Dreamy-rain/gemini-business2api.git
+cd gemini-business2api
+setup.bat
+# 编辑 .env 设置 ADMIN_KEY
+.venv\Scripts\activate.bat
+python main.py
+# pm2 后台运行
+pm2 start main.py --name gemini-api --interpreter ./.venv/Scripts/python.exe
+```
+
+安装脚本会自动完成：uv 安装、Python 3.11 下载、依赖安装、前端构建、`.env` 创建。
+更新项目时重新运行同一脚本即可。
+
+---
+
+### 方式三：手动部署
+
+```bash
+git clone https://github.com/Dreamy-rain/gemini-business2api.git
+cd gemini-business2api
+
+curl -LsSf https://astral.sh/uv/install.sh | sh
+uv python install 3.11
+
+cd frontend && npm install && npm run build && cd ..
+
+uv venv --python 3.11 .venv
+source .venv/bin/activate  # Windows: .venv\Scripts\activate.bat
+uv pip install -r requirements.txt
+
+cp .env.example .env
+# 编辑 .env 设置 ADMIN_KEY
+python main.py
+```
+
+---
+
+### 访问方式
+
+- **管理面板**：`http://localhost:7860/`（使用 `ADMIN_KEY` 登录）
+- **API 接口**：`http://localhost:7860/v1/chat/completions`
+
+---
+
+## 🗄️ 数据库持久化
+
+设置 `DATABASE_URL` 可将账户、设置、统计写入数据库，避免容器重启丢数据。未设置时自动使用 SQLite（本地 `data.db`）。
+
+**配置方式：**
+- 本地部署 → 写入 `.env`
+- 云平台 → 在平台环境变量中设置
+
+```
+DATABASE_URL=postgresql://user:password@host/dbname?sslmode=require
+```
+
+**免费 PostgreSQL 推荐：**
+
+| 服务 | 免费额度 | 获取方式 |
+|------|---------|---------|
+| [Neon](https://neon.tech) | 512MB 存储 / 100 CPUH 月 | 注册 → Create Project → 复制 Connection string |
+| [Aiven](https://aiven.io) | 额度更充裕 | 注册 → 创建 PostgreSQL 服务 → 复制连接串 |
+
+> `postgres://` 和 `postgresql://` 两种格式均可直接使用，无需手动转换。
+
+<details>
+<summary>⚠️ 常见问题：定期保存失败 / ConnectionDoesNotExistError</summary>
+
+如果日志出现类似以下错误：
+
+```
+ERROR [COOLDOWN] 冷却期保存失败: connection was closed in the middle of operation
+asyncpg.exceptions.ConnectionDoesNotExistError: connection was closed in the middle of operation
+```
+
+这是因为部分免费 PostgreSQL 服务（如 Aiven 免费版）会主动关闭长时间空闲的连接。**不影响正常使用**，下次操作会自动重新连接。如频繁出现，建议换用 [Neon](https://neon.tech) 或升级数据库套餐。
+
+</details>
+
+<details>
+<summary>📦 数据库迁移（从旧版升级）</summary>
+
+如果有旧的本地文件（`accounts.json` / `settings.yaml` / `stats.json`），运行迁移脚本：
+
+```bash
+python scripts/migrate_to_database.py
+```
+
+迁移脚本会自动检测环境（PostgreSQL / SQLite），迁移完成后自动重命名旧文件。
+
+
+</details>
+
+---
+
+## 📡 API 接口
+
+完全兼容 OpenAI API 格式，可直接对接 ChatGPT-Next-Web、LobeChat、OpenCat 等客户端。
+
+| 接口 | 方法 | 说明 |
+|------|------|------|
+| `/v1/chat/completions` | POST | 对话补全（支持流式） |
+| `/v1/models` | GET | 获取可用模型列表 |
+| `/v1/images/generations` | POST | 图片生成（文生图） |
+| `/v1/images/edits` | POST | 图片编辑（图生图） |
+| `/health` | GET | 健康检查 |
+
+**调用示例：**
+
+```bash
+curl http://localhost:7860/v1/chat/completions \
+  -H "Authorization: Bearer your-api-key" \
+  -H "Content-Type: application/json" \
+  -d '{
+    "model": "gemini-2.5-flash",
+    "messages": [{"role": "user", "content": "你好"}],
+    "stream": true
+  }'
+```
+
+> `API_KEY` 在管理面板 → 系统设置中配置，留空则公开访问，支持多个 Key 逗号分隔。
+
+---
+
+## 📧 邮箱提供商配置
+
+项目支持 4 种临时邮箱，用于自动注册账号。在 **管理面板 → 系统设置 → 临时邮箱提供商** 中切换。
+
+### Moemail（默认推荐）
+
+开源临时邮箱服务，开箱即用。
+
+- **项目地址**：[github.com/beilunyang/moemail](https://github.com/beilunyang/moemail)
+- **官网**：[moemail.app](https://moemail.app)
+- **配置项**：API 地址 + API Key + 域名（可选）
+
+### DuckMail
+
+临时邮箱 API 服务，推荐配置自定义域名。
+
+- **域名管理**：[domain.duckmail.sbs](https://domain.duckmail.sbs/)
+- **配置项**：API 地址 + API Key + 注册域名
+
+### GPTMail
+
+临时邮箱 API 服务，无需密码即可使用。
+
+- **默认地址**：`https://mail.chatgpt.org.uk`
+- **默认 API Key**：`gpt-test`
+- **配置项**：API 地址 + API Key + 域名（可选）
+
+### Freemail
+
+需要自行搭建的临时邮箱服务，适合有服务器的用户。
+
+- **项目地址**：[github.com/idinging/freemail](https://github.com/idinging/freemail)
+- **配置项**：自部署服务地址 + JWT Token + 域名（可选）
+
+> **提示**：所有邮箱配置均在管理面板中完成，无需手动编辑配置文件。Microsoft 邮箱登录也在管理面板中操作。
+
+---
+
+## 🌐 推荐部署平台
+
+除本地 Docker Compose 外，以下平台均支持 Docker 镜像部署：
+
+| 平台 | 免费额度 | 特点 |
+|------|---------|------|
+| [Render](https://render.com) | ✅ 有 | 支持 Docker、自动 SSL、免费 PostgreSQL |
+| [Railway](https://railway.app) | $5/月额度 | 一键 Docker 部署、自带��据库 |
+| [Fly.io](https://fly.io) | ✅ 有 | 全球边缘部署、支持持久化卷 |
+| [Claw Cloud](https://claw.cloud) | ✅ 有 | 容器云平台，简单易用 |
+| 自建 VPS（推荐） | — | 完全可控，配合 Docker Compose |
+
+> Docker 镜像：`cooooookk/gemini-business2api:latest`
+>
+> 部署时设置环境变量 `ADMIN_KEY` 和 `DATABASE_URL` 即可。
+
+### Zeabur 部署教程
+
+1. Fork 本仓库到你的 GitHub
+2. 登录 [Zeabur](https://zeabur.com) → **创建项目** → **共享集群** → **部署新服务** → **连接 GitHub** → 选择 Fork 的仓库
+3. 添加环境变量：
+
+   | 变量名 | 必填 | 说明 |
+   |--------|------|------|
+   | `ADMIN_KEY` | ✅ | 管理面板登录密钥 |
+   | `DATABASE_URL` | 可选 | PostgreSQL 连接串（推荐配置，避免重启丢数据） |
+
+4. **持久化挂载目录**（重要）：
+
+   在服务设置中添加持久化存储：
+
+   | 硬盘 ID | 挂载目录 |
+   |---------|---------|
+   | `data` | `/app/data` |
+
+5. 点击 **重新部署** 使配置生效
+
+**更新方式**：GitHub 仓库 → **Sync fork** → **Update branch**，Zeabur 会自动重新部署。
+
+---
+
+## 🔄 独立刷新服务
+
+如果需要将账号刷新服务单独部署（与主 API 分离），可使用 [`refresh-worker` 分支](https://github.com/Dreamy-rain/gemini-business2api/tree/refresh-worker)：
+
+```bash
+git clone -b refresh-worker https://github.com/Dreamy-rain/gemini-business2api.git gemini-refresh-worker
+cd gemini-refresh-worker
+cp .env.example .env
+# 编辑 .env 设置 DATABASE_URL
+docker-compose up -d
+```
+
+该服务从数据库读取账号，独立执行定时刷新，支持 cron 调度、分批执行、冷却防重复。适合需要刷新服务与 API 服务分离部署的场景。
+
+---
+
+## 🌐 Socks5 免费代理池
+
+自动注册/刷新账号时可配置代理以提高成功率。推荐使用免费 Socks5 代理池：
+
+- **项目地址**：[github.com/Dreamy-rain/socks5-proxy](https://github.com/Dreamy-rain/socks5-proxy)
+- **说明**：免费代理不太稳定，但能一定程度提高注册成功率
+- **使用方式**：在管理面板 → 系统设置 → 代理设置中配置
+
+---
+
+## 📸 功能展示
+
+### 管理系统
+
+<table>
+  <tr>
+    <td><img src="docs/img/1.png" alt="管理系统 1" /></td>
+    <td><img src="docs/img/2.png" alt="管理系统 2" /></td>
+  </tr>
+  <tr>
+    <td><img src="docs/img/3.png" alt="管理系统 3" /></td>
+    <td><img src="docs/img/4.png" alt="管理系统 4" /></td>
+  </tr>
+  <tr>
+    <td><img src="docs/img/5.png" alt="管理系统 5" /></td>
+    <td><img src="docs/img/6.png" alt="管理系统 6" /></td>
+  </tr>
+</table>
+
+### 图片效果
+
+<table>
+  <tr>
+    <td><img src="docs/img/img_1.png" alt="图片效果 1" /></td>
+    <td><img src="docs/img/img_2.png" alt="图片效果 2" /></td>
+  </tr>
+  <tr>
+    <td><img src="docs/img/img_3.png" alt="图片效果 3" /></td>
+    <td><img src="docs/img/img_4.png" alt="图片效果 4" /></td>
+  </tr>
+</table>
+
+### 更多文档
+
+- 支持的文件类型：[SUPPORTED_FILE_TYPES.md](docs/SUPPORTED_FILE_TYPES.md)
+
+## ⭐ Star History
+
+[![Star History Chart](https://api.star-history.com/svg?repos=Dreamy-rain/gemini-business2api&type=date&legend=top-left)](https://www.star-history.com/#Dreamy-rain/gemini-business2api&type=date&legend=top-left)
+
+**如果这个项目对你有帮助，请给个 ⭐ Star!**

core/__init__.py

@@ -0,0 +1,6 @@
+"""
+Core 模块
+包含认证、模板生成等核心功能
+"""
+
+__all__ = ['auth', 'templates']

core/account.py

@@ -0,0 +1,1185 @@
+"""账户管理模块
+
+负责账户配置、多账户协调和会话缓存管理
+"""
+import asyncio
+import json
+import logging
+import os
+import random
+import threading
+import time
+from dataclasses import dataclass
+from datetime import datetime, timedelta, timezone
+from typing import Dict, List, Optional, TYPE_CHECKING, Iterable
+
+from fastapi import HTTPException
+
+# 导入存储层（支持数据库）
+from core import storage
+
+if TYPE_CHECKING:
+    from core.jwt import JWTManager
+
+logger = logging.getLogger(__name__)
+
+# HTTP错误名称映射
+HTTP_ERROR_NAMES = {
+    400: "参数错误",
+    401: "认证错误",
+    403: "权限错误",
+    429: "限流",
+    502: "网关错误",
+    503: "服务不可用"
+}
+
+# 配额类型定义
+QUOTA_TYPES = {
+    "text": "对话",
+    "images": "绘图",
+    "videos": "视频"
+}
+
+@dataclass
+class AccountConfig:
+    """单个账户配置"""
+    account_id: str
+    secure_c_ses: str
+    host_c_oses: Optional[str]
+    csesidx: str
+    config_id: str
+    expires_at: Optional[str] = None  # 账户过期时间 (格式: "2025-12-23 10:59:21")
+    disabled: bool = False  # 手动禁用状态
+    mail_provider: Optional[str] = None
+    mail_address: Optional[str] = None
+    mail_password: Optional[str] = None
+    mail_client_id: Optional[str] = None
+    mail_refresh_token: Optional[str] = None
+    mail_tenant: Optional[str] = None
+    # 邮箱自定义配置字段（用于账户级别的邮箱服务配置）
+    mail_base_url: Optional[str] = None
+    mail_jwt_token: Optional[str] = None
+    mail_verify_ssl: Optional[bool] = None
+    mail_domain: Optional[str] = None
+    mail_api_key: Optional[str] = None
+    trial_end: Optional[str] = None  # 试用到期日 (格式: "2026-03-25"，独立于cookie过期)
+
+    def get_remaining_hours(self) -> Optional[float]:
+        """计算账户剩余小时数"""
+        if not self.expires_at:
+            return None
+        try:
+            # 解析过期时间（假设为北京时间）
+            beijing_tz = timezone(timedelta(hours=8))
+            expire_time = datetime.strptime(self.expires_at, "%Y-%m-%d %H:%M:%S")
+            expire_time = expire_time.replace(tzinfo=beijing_tz)
+
+            # 当前时间（北京时间）
+            now = datetime.now(beijing_tz)
+
+            # 计算剩余时间
+            remaining = (expire_time - now).total_seconds() / 3600
+            return remaining
+        except Exception:
+            return None
+
+    def is_expired(self) -> bool:
+        """检查账户是否已过期"""
+        remaining = self.get_remaining_hours()
+        if remaining is None:
+            return False  # 未设置过期时间，默认不过期
+        return remaining <= 0
+
+    def get_trial_days_remaining(self) -> Optional[int]:
+        """计算试用期剩余天数（基于 trial_end 字段）"""
+        if not self.trial_end:
+            return None
+        try:
+            beijing_tz = timezone(timedelta(hours=8))
+            end_date = datetime.strptime(self.trial_end, "%Y-%m-%d")
+            end_date = end_date.replace(tzinfo=beijing_tz)
+            now = datetime.now(beijing_tz)
+            remaining = (end_date.date() - now.date()).days
+            return max(0, remaining)
+        except Exception:
+            return None
+
+
+@dataclass(frozen=True)
+class CooldownConfig:
+    text: int
+    images: int
+    videos: int
+
+
+@dataclass(frozen=True)
+class RetryPolicy:
+    cooldowns: CooldownConfig
+
+
+def format_account_expiration(remaining_hours: Optional[float]) -> tuple:
+    """
+    格式化账户过期时间显示（基于12小时过期周期）
+
+    Args:
+        remaining_hours: 剩余小时数（None表示未设置过期时间）
+
+    Returns:
+        (status, status_color, expire_display) 元组
+    """
+    if remaining_hours is None:
+        # 未设置过期时间时显示为"未设置"
+        return ("未设置", "#9e9e9e", "未设置")
+    elif remaining_hours <= 0:
+        return ("已过期", "#f44336", "已过期")
+    elif remaining_hours < 3:  # 少于3小时
+        return ("即将过期", "#ff9800", f"{remaining_hours:.1f} 小时")
+    else:  # 3小时及以上，统一显示小时
+        return ("正常", "#4caf50", f"{remaining_hours:.1f} 小时")
+
+
+class AccountManager:
+    """单个账户管理器"""
+    def __init__(
+        self,
+        config: AccountConfig,
+        http_client,
+        user_agent: str,
+        retry_policy: RetryPolicy,
+    ):
+        self.config = config
+        self.http_client = http_client
+        self.user_agent = user_agent
+        # 冷却时间配置
+        self.rate_limit_cooldown_seconds = retry_policy.cooldowns.text  # 向后兼容
+        self.text_rate_limit_cooldown_seconds = retry_policy.cooldowns.text
+        self.images_rate_limit_cooldown_seconds = retry_policy.cooldowns.images
+        self.videos_rate_limit_cooldown_seconds = retry_policy.cooldowns.videos
+        self.jwt_manager: Optional['JWTManager'] = None  # 延迟初始化
+        self.is_available = True
+        self.last_error_time = 0.0  # 保留用于统计
+        self.quota_cooldowns: Dict[str, float] = {}  # 按配额类型的冷却时间戳
+        self.daily_usage: Dict[str, int] = {"text": 0, "images": 0, "videos": 0}  # 每日使用计数
+        self.daily_usage_date: str = ""  # 计数日期（北京时间，格式 "2026-02-24"）
+        self.conversation_count = 0  # 累计成功次数（用于统计展示）
+        self.failure_count = 0  # 累计失败次数（用于统计展示）
+        self.session_usage_count = 0  # 本次启动后使用次数（用于均衡轮询）
+        self.disabled_reason: Optional[str] = None  # 自动禁用原因（如 "403 Access Restricted"）
+
+    def handle_non_http_error(self, error_context: str = "", request_id: str = "", quota_type: Optional[str] = None) -> None:
+        """
+        统一处理非HTTP错误（网络错误、解析错误等）- 只记录日志，不触发冷却
+
+        Args:
+            error_context: 错误上下文（如"JWT获取"、"聊天请求"）
+            request_id: 请求ID（用于日志）
+            quota_type: 配额类型（保留参数以保持接口兼容性）
+
+        注意：网络错误、超时等是临时问题，应该直接切换账户重试，不标记配额冷却
+        """
+        req_tag = f"[req_{request_id}] " if request_id else ""
+
+        # 只记录日志，不触发冷却
+        # 网络错误是临时的，应该直接切换账户重试
+        logger.warning(
+            f"[ACCOUNT] [{self.config.account_id}] {req_tag}"
+            f"{error_context}失败，将切换账户重试（不触发冷却）"
+        )
+
+    def _get_quota_cooldown_seconds(self, quota_type: Optional[str]) -> int:
+        if quota_type == "images":
+            return self.images_rate_limit_cooldown_seconds
+        if quota_type == "videos":
+            return self.videos_rate_limit_cooldown_seconds
+        return self.text_rate_limit_cooldown_seconds
+
+    def apply_retry_policy(self, retry_policy: RetryPolicy) -> None:
+        """Apply updated retry policy to this account manager."""
+        self.rate_limit_cooldown_seconds = retry_policy.cooldowns.text  # 向后兼容
+        self.text_rate_limit_cooldown_seconds = retry_policy.cooldowns.text
+        self.images_rate_limit_cooldown_seconds = retry_policy.cooldowns.images
+        self.videos_rate_limit_cooldown_seconds = retry_policy.cooldowns.videos
+
+    def _get_quota_period(self) -> str:
+        """获取当前配额周期标识（北京时间16:00为分界，对齐Google太平洋时间午夜重置）"""
+        beijing_tz = timezone(timedelta(hours=8))
+        now = datetime.now(beijing_tz)
+        # 16:00前属于前一天的配额周期，16:00后属于当天的配额周期
+        if now.hour < 16:
+            period_date = now.date() - timedelta(days=1)
+        else:
+            period_date = now.date()
+        return period_date.strftime("%Y-%m-%d")
+
+    def _reset_daily_usage_if_needed(self) -> None:
+        """跨配额周期自动重置每日计数器（懒重置，北京时间16:00刷新）"""
+        period = self._get_quota_period()
+        if self.daily_usage_date != period:
+            self.daily_usage = {"text": 0, "images": 0, "videos": 0}
+            self.daily_usage_date = period
+
+    def increment_daily_usage(self, quota_type: str) -> None:
+        """请求成功后增加每日使用计数"""
+        if quota_type not in QUOTA_TYPES:
+            return
+        self._reset_daily_usage_if_needed()
+        self.daily_usage[quota_type] += 1
+
+    def handle_http_error(self, status_code: int, error_detail: str = "", request_id: str = "", quota_type: Optional[str] = None) -> None:
+        """
+        统一处理HTTP错误 - 按错误类型分类处理
+
+        Args:
+            status_code: HTTP状态码
+            error_detail: 错误详情
+            request_id: 请求ID（用于日志）
+            quota_type: 配额类型（"text", "images", "videos"），用于按类型冷却
+
+        处理逻辑：
+            - 400: 参数错误，不计入失败（客户端问题）
+            - 401/403: 认证错误，冷却 text 配额（等效冷却整个账户）
+            - 429: 按配额类型冷却（配额耗尽）
+            - 502/503/504/其他: 只记录日志，不触发冷却（临时服务器错误，应直接切换账户重试）
+        """
+        req_tag = f"[req_{request_id}] " if request_id else ""
+
+        # 400参数错误：不计入失败（客户端问题）
+        if status_code == 400:
+            logger.warning(
+                f"[ACCOUNT] [{self.config.account_id}] {req_tag}"
+                f"HTTP 400参数错误（不计入失败）{': ' + error_detail[:100] if error_detail else ''}"
+            )
+            return
+
+        # 403权限错误：Google 返回 403 意味着账户被限制访问，自动禁用
+        # （JWT 刷新或 API 调用返回 403 都是永久性封禁，非���时问题）
+        if status_code == 403:
+            self.config.disabled = True
+            self.disabled_reason = "403 Access Restricted"
+            logger.error(
+                f"[ACCOUNT] [{self.config.account_id}] {req_tag}"
+                f"⛔ 账户遇到 403 权限错误，已自动禁用"
+                f"{': ' + error_detail[:200] if error_detail else ''}"
+            )
+            return
+
+        # 401认证错误：冷却 text 配额（等效冷却整个账户，但可自动恢复）
+        if status_code == 401:
+            self.quota_cooldowns["text"] = time.time()
+            cooldown_seconds = self.text_rate_limit_cooldown_seconds
+            logger.warning(
+                f"[ACCOUNT] [{self.config.account_id}] {req_tag}"
+                f"遇到认证错误，账户将休息{cooldown_seconds}秒后自动恢复"
+                f"{': ' + error_detail[:100] if error_detail else ''}"
+            )
+            return
+
+        # 429配额错误：按配额类型冷却
+        if status_code == 429:
+            if not quota_type or quota_type not in QUOTA_TYPES:
+                quota_type = "text"
+
+            self.quota_cooldowns[quota_type] = time.time()
+            cooldown_seconds = self._get_quota_cooldown_seconds(quota_type)
+            logger.warning(
+                f"[ACCOUNT] [{self.config.account_id}] {req_tag}"
+                f"遇到429配额错误，{QUOTA_TYPES[quota_type]}配额将休息{cooldown_seconds}秒后自动恢复"
+                f"{': ' + error_detail[:100] if error_detail else ''}"
+            )
+            return
+
+        # 502/503/504/其他错误：只记录日志，不触发冷却
+        # 这些是临时服务器错误，应该直接重试切换账户，不标记配额
+        error_type = HTTP_ERROR_NAMES.get(status_code, f"HTTP {status_code}")
+        logger.warning(
+            f"[ACCOUNT] [{self.config.account_id}] {req_tag}"
+            f"遇到{error_type}错误，将切换账户重试（不触发冷却）"
+            f"{': ' + error_detail[:100] if error_detail else ''}"
+        )
+
+    def is_quota_available(self, quota_type: str) -> bool:
+        """检查指定配额是否可用（先检查每日上限，再检查冷却）。"""
+        if quota_type not in QUOTA_TYPES:
+            return True
+
+        # 主动配额计数检查
+        from core.config import config
+        quota_limits = config.quota_limits
+        if quota_limits.enabled:
+            self._reset_daily_usage_if_needed()
+            limit = getattr(quota_limits, f"{quota_type}_daily_limit", 0)
+            if limit > 0 and self.daily_usage.get(quota_type, 0) >= limit:
+                return False
+
+        # 被动冷却检查（兜底）
+        cooldown_time = self.quota_cooldowns.get(quota_type)
+        if not cooldown_time:
+            return True
+
+        elapsed = time.time() - cooldown_time
+        cooldown_seconds = self._get_quota_cooldown_seconds(quota_type)
+        if elapsed < cooldown_seconds:
+            return False
+
+        # 冷却已过期，清理
+        del self.quota_cooldowns[quota_type]
+        return True
+
+    def are_quotas_available(self, quota_types: Optional[Iterable[str]] = None) -> bool:
+        """
+        检查多个配额类型是否都可用。
+
+        注意：如果对话配额受限，所有配额都不可用（对话是基础功能）
+        """
+        if not quota_types:
+            return True
+        if isinstance(quota_types, str):
+            quota_types = [quota_types]
+
+        # 如果对话配额受限，所有配额都不可用
+        if not self.is_quota_available("text"):
+            return False
+
+        # 检查其他配额
+        return all(self.is_quota_available(qt) for qt in quota_types if qt != "text")
+
+    async def get_jwt(self, request_id: str = "") -> str:
+        """获取 JWT token (带错误处理)"""
+        # 检查账户是否过期
+        if self.config.is_expired():
+            self.is_available = False
+            logger.warning(f"[ACCOUNT] [{self.config.account_id}] 账户已过期，已自动禁用")
+            raise HTTPException(403, f"Account {self.config.account_id} has expired")
+
+        try:
+            if self.jwt_manager is None:
+                # 延迟初始化 JWTManager (避免循环依赖)
+                from core.jwt import JWTManager
+                self.jwt_manager = JWTManager(self.config, self.http_client, self.user_agent)
+            jwt = await self.jwt_manager.get(request_id)
+            self.is_available = True
+            return jwt
+        except Exception as e:
+            # 使用统一的错误处理入口
+            if isinstance(e, HTTPException):
+                self.handle_http_error(e.status_code, str(e.detail) if hasattr(e, 'detail') else "", request_id)
+            else:
+                self.handle_non_http_error("JWT获取", request_id)
+            raise
+
+    def should_retry(self) -> bool:
+        """检查账户是否可重试 - 简化版：账户始终可用（由配额冷却控制）"""
+        # 账户本身始终可用，具体功能由配额冷却控制
+        return True
+
+    def get_cooldown_info(self) -> tuple[int, str | None]:
+        """获取账户冷却信息（只有配额冷却）"""
+        current_time = time.time()
+
+        # 检查配额冷却（找出最长的剩余冷却时间）
+        max_quota_remaining = 0
+        limited_quota_types = []  # 存储配额类型（text/images/videos）
+        quota_icons = {"text": "💬", "images": "🎨", "videos": "🎬"}
+
+        for quota_type in QUOTA_TYPES:
+            if quota_type in self.quota_cooldowns:
+                cooldown_time = self.quota_cooldowns[quota_type]
+                elapsed = current_time - cooldown_time
+                cooldown_seconds = self._get_quota_cooldown_seconds(quota_type)
+                if elapsed < cooldown_seconds:
+                    remaining = int(cooldown_seconds - elapsed)
+                    if remaining > max_quota_remaining:
+                        max_quota_remaining = remaining
+                    limited_quota_types.append(quota_type)
+
+        # 如果有配额冷却，返回最长的冷却时间和简化的描述
+        if max_quota_remaining > 0:
+            # 生成 emoji 图标组合
+            icons = "".join([quota_icons[qt] for qt in limited_quota_types])
+
+            # 判断是否全部冷却
+            if len(limited_quota_types) == 3:
+                return (max_quota_remaining, f"{icons} 全部冷却")
+            elif len(limited_quota_types) == 1:
+                # 单个配额冷却
+                quota_name = QUOTA_TYPES[limited_quota_types[0]]
+                return (max_quota_remaining, f"{icons} {quota_name}冷却")
+            else:
+                # 多个配额冷却（但不是全部）
+                quota_names = "/".join([QUOTA_TYPES[qt] for qt in limited_quota_types])
+                return (max_quota_remaining, f"{icons} {quota_names}冷却")
+
+        # 没有冷却，返回正常状态
+        return (0, None)
+
+    def get_quota_status(self) -> Dict[str, any]:
+        """
+        获取配额状态（被动检测 + 主动计数）
+
+        Returns:
+            {
+                "quotas": {
+                    "text": {"available": bool, "remaining_seconds": int, "daily_used": int, "daily_limit": int},
+                    "images": {"available": bool, "remaining_seconds": int, "daily_used": int, "daily_limit": int},
+                    "videos": {"available": bool, "remaining_seconds": int, "daily_used": int, "daily_limit": int}
+                },
+                "limited_count": int,  # 受限配额数量
+                "total_count": int,    # 总配额数量
+                "is_expired": bool     # 账户是否过期/禁用
+            }
+        """
+        # 获取配额上限配置
+        from core.config import config as app_config
+        quota_limits = app_config.quota_limits
+
+        # 检查账户是否过期或被禁用
+        is_expired = self.config.is_expired() or self.config.disabled
+        if is_expired:
+            # 账户过期或被禁用，所有配额不可用
+            quotas = {quota_type: {"available": False} for quota_type in QUOTA_TYPES}
+            return {
+                "quotas": quotas,
+                "limited_count": len(QUOTA_TYPES),
+                "total_count": len(QUOTA_TYPES),
+                "is_expired": True
+            }
+
+        current_time = time.time()
+        self._reset_daily_usage_if_needed()
+
+        quotas = {}
+        limited_count = 0
+        expired_quotas = []  # 收集已过期的配额类型
+        text_limited = False  # 对话配额是否受限
+
+        # 第一遍：检查所有配额状态
+        for quota_type in QUOTA_TYPES:
+            quota_info: Dict[str, any] = {}
+
+            # 添加每日使用量信息
+            if quota_limits.enabled:
+                daily_limit = getattr(quota_limits, f"{quota_type}_daily_limit", 0)
+                quota_info["daily_used"] = self.daily_usage.get(quota_type, 0)
+                quota_info["daily_limit"] = daily_limit
+
+                # 检查每日上限
+                if daily_limit > 0 and quota_info["daily_used"] >= daily_limit:
+                    quota_info["available"] = False
+                    quota_info["reason"] = "每日配额已用完"
+                    limited_count += 1
+                    if quota_type == "text":
+                        text_limited = True
+                    quotas[quota_type] = quota_info
+                    continue
+
+            # 检查被动冷却
+            if quota_type in self.quota_cooldowns:
+                cooldown_time = self.quota_cooldowns[quota_type]
+                elapsed = current_time - cooldown_time
+                cooldown_seconds = self._get_quota_cooldown_seconds(quota_type)
+                if elapsed < cooldown_seconds:
+                    remaining = int(cooldown_seconds - elapsed)
+                    quota_info["available"] = False
+                    quota_info["remaining_seconds"] = remaining
+                    limited_count += 1
+                    if quota_type == "text":
+                        text_limited = True
+                    quotas[quota_type] = quota_info
+                    continue
+                else:
+                    expired_quotas.append(quota_type)
+
+            quota_info["available"] = True
+            quotas[quota_type] = quota_info
+
+        # 统一删除已过期的配额冷却
+        for quota_type in expired_quotas:
+            del self.quota_cooldowns[quota_type]
+
+        # 如果对话配额受限，所有配额都标记为不可用（对话是基础功能）
+        if text_limited:
+            for quota_type in QUOTA_TYPES:
+                if quota_type != "text" and quotas[quota_type].get("available", False):
+                    quotas[quota_type]["available"] = False
+                    quotas[quota_type]["reason"] = "对话配额受限"
+                    limited_count += 1
+
+        return {
+            "quotas": quotas,
+            "limited_count": limited_count,
+            "total_count": len(QUOTA_TYPES),
+            "is_expired": False
+        }
+
+
+class MultiAccountManager:
+    """多账户协调器"""
+    def __init__(self, session_cache_ttl_seconds: int):
+        self.accounts: Dict[str, AccountManager] = {}
+        self.account_list: List[str] = []  # 账户ID列表 (用于轮询)
+        self.current_index = 0
+        self._cache_lock = asyncio.Lock()  # 缓存操作专用锁
+        self._counter_lock = threading.Lock()  # 轮询计数器锁
+        self._request_counter = 0  # 请求计数器
+        self._last_account_count = 0  # 可用账户数量
+        # 全局会话缓存：{conv_key: {"account_id": str, "session_id": str, "updated_at": float}}
+        self.global_session_cache: Dict[str, dict] = {}
+        self.cache_max_size = 1000  # 最大缓存条目数
+        self.cache_ttl = session_cache_ttl_seconds  # 缓存过期时间（秒）
+        # Session级别锁：防止同一对话的并发请求冲突
+        self._session_locks: Dict[str, asyncio.Lock] = {}
+        self._session_locks_lock = asyncio.Lock()  # 保护锁字典的锁
+        self._session_locks_max_size = 2000  # 最大锁数量
+
+    def _clean_expired_cache(self):
+        """清理过期的缓存条目"""
+        current_time = time.time()
+        expired_keys = [
+            key for key, value in self.global_session_cache.items()
+            if current_time - value["updated_at"] > self.cache_ttl
+        ]
+        for key in expired_keys:
+            del self.global_session_cache[key]
+        if expired_keys:
+            logger.info(f"[CACHE] 清理 {len(expired_keys)} 个过期会话缓存")
+
+    def _ensure_cache_size(self):
+        """确保缓存不超过最大大小（LRU策略）"""
+        if len(self.global_session_cache) > self.cache_max_size:
+            # 按更新时间排序，删除最旧的20%
+            sorted_items = sorted(
+                self.global_session_cache.items(),
+                key=lambda x: x[1]["updated_at"]
+            )
+            remove_count = len(sorted_items) - int(self.cache_max_size * 0.8)
+            for key, _ in sorted_items[:remove_count]:
+                del self.global_session_cache[key]
+            logger.info(f"[CACHE] LRU清理 {remove_count} 个最旧会话缓存")
+
+    async def start_background_cleanup(self):
+        """启动后台缓存清理任务（每5分钟执行一次）"""
+        try:
+            while True:
+                await asyncio.sleep(300)  # 5分钟
+                async with self._cache_lock:
+                    self._clean_expired_cache()
+                    self._ensure_cache_size()
+        except asyncio.CancelledError:
+            logger.info("[CACHE] 后台清理任务已停止")
+        except Exception as e:
+            logger.error(f"[CACHE] 后台清理任务异常: {e}")
+
+    async def set_session_cache(self, conv_key: str, account_id: str, session_id: str):
+        """线程安全地设置会话缓存"""
+        async with self._cache_lock:
+            self.global_session_cache[conv_key] = {
+                "account_id": account_id,
+                "session_id": session_id,
+                "updated_at": time.time()
+            }
+            # 检查缓存大小
+            self._ensure_cache_size()
+
+    async def update_session_time(self, conv_key: str):
+        """线程安全地更新会话时间戳"""
+        async with self._cache_lock:
+            if conv_key in self.global_session_cache:
+                self.global_session_cache[conv_key]["updated_at"] = time.time()
+
+    async def acquire_session_lock(self, conv_key: str) -> asyncio.Lock:
+        """获取指定对话的锁（用于防止同一对话的并发请求冲突）"""
+        async with self._session_locks_lock:
+            # 清理过多的锁（LRU策略：删除不在缓存中的锁）
+            if len(self._session_locks) > self._session_locks_max_size:
+                # 只保留���前缓存中存在的锁
+                valid_keys = set(self.global_session_cache.keys())
+                keys_to_remove = [k for k in self._session_locks if k not in valid_keys]
+                for k in keys_to_remove[:len(keys_to_remove)//2]:  # 删除一半无效锁
+                    del self._session_locks[k]
+
+            if conv_key not in self._session_locks:
+                self._session_locks[conv_key] = asyncio.Lock()
+            return self._session_locks[conv_key]
+
+    def update_http_client(self, http_client):
+        """更新所有账户使用的 http_client（用于代理变更后重建客户端）"""
+        for account_mgr in self.accounts.values():
+            account_mgr.http_client = http_client
+            if account_mgr.jwt_manager is not None:
+                account_mgr.jwt_manager.http_client = http_client
+
+    def add_account(
+        self,
+        config: AccountConfig,
+        http_client,
+        user_agent: str,
+        retry_policy: RetryPolicy,
+        global_stats: dict,
+    ):
+        """添加账户"""
+        manager = AccountManager(config, http_client, user_agent, retry_policy)
+        # 从统计数据加载对话次数
+        if "account_conversations" in global_stats:
+            manager.conversation_count = global_stats["account_conversations"].get(config.account_id, 0)
+        if "account_failures" in global_stats:
+            manager.failure_count = global_stats["account_failures"].get(config.account_id, 0)
+        self.accounts[config.account_id] = manager
+        self.account_list.append(config.account_id)
+        logger.debug(f"[MULTI] [ACCOUNT] 添加账户: {config.account_id}")
+
+    def get_available_accounts(
+        self,
+        required_quota_types: Optional[Iterable[str]] = None
+    ) -> List[AccountManager]:
+        """获取可用账户列表（过滤掉禁用、过期、冷却中的账户）
+
+        Args:
+            required_quota_types: 需要的配额类型列表（如 ["text"], ["images"], ["text", "videos"]）
+
+        Returns:
+            可用账户列表
+
+        过滤规则：
+            1. disabled=True → 跳过（手动禁用）
+            2. is_expired() → 跳过（账户过期）
+            3. are_quotas_available() → 跳过（配额冷却中）
+        """
+        available = []
+
+        for acc in self.accounts.values():
+            # 1. 检查手动禁用
+            if acc.config.disabled:
+                continue
+
+            # 2. 检查账户过期
+            if acc.config.is_expired():
+                continue
+
+            # 3. 检查配额可用性（包括冷却检查）
+            if not acc.are_quotas_available(required_quota_types):
+                continue
+
+            available.append(acc)
+
+        return available
+
+    async def get_account(
+        self,
+        account_id: Optional[str] = None,
+        request_id: str = "",
+        required_quota_types: Optional[Iterable[str]] = None
+    ) -> AccountManager:
+        """获取账户 - Round-Robin轮询
+
+        Args:
+            account_id: 指定账户ID（可选，如果指定则直接返回该账户）
+            request_id: 请求ID（用于日志）
+            required_quota_types: 需要的配额类型列表
+
+        Returns:
+            可用的账户管理器
+
+        Raises:
+            HTTPException(404): 指定的账户不存在
+            HTTPException(503): 没有可用账户
+        """
+        req_tag = f"[req_{request_id}] " if request_id else ""
+
+        # 指定账户ID时直接返回
+        if account_id:
+            if account_id not in self.accounts:
+                raise HTTPException(404, f"Account {account_id} not found")
+            account = self.accounts[account_id]
+            if not account.should_retry():
+                raise HTTPException(503, f"Account {account_id} temporarily unavailable")
+            if not account.are_quotas_available(required_quota_types):
+                raise HTTPException(503, f"Account {account_id} quota temporarily unavailable")
+            return account
+
+        # 获取可用账户列表
+        available_accounts = self.get_available_accounts(required_quota_types)
+
+        if not available_accounts:
+            raise HTTPException(503, "No available accounts")
+
+        # 轮询选择
+        with self._counter_lock:
+            if len(available_accounts) != self._last_account_count:
+                self._request_counter = random.randint(0, 999999)
+                self._last_account_count = len(available_accounts)
+            index = self._request_counter % len(available_accounts)
+            self._request_counter += 1
+
+        selected = available_accounts[index]
+        selected.session_usage_count += 1
+
+        logger.info(f"[MULTI] [ACCOUNT] {req_tag}选择账户: {selected.config.account_id} "
+                    f"(索引: {index}/{len(available_accounts)}, 使用: {selected.session_usage_count})")
+        return selected
+
+
+# ---------- 配置管理 ----------
+
+def save_accounts_to_file(accounts_data: list):
+    """保存账户配置（仅数据库模式）。"""
+    if not storage.is_database_enabled():
+        raise RuntimeError("Database is not enabled")
+    saved = storage.save_accounts_sync(accounts_data)
+    if not saved:
+        raise RuntimeError("Database write failed")
+
+
+def load_accounts_from_source() -> list:
+    """从环境变量或数据库加载账户配置。"""
+    env_accounts = os.environ.get('ACCOUNTS_CONFIG')
+    if env_accounts:
+        try:
+            accounts_data = json.loads(env_accounts)
+            if accounts_data:
+                logger.info(f"[CONFIG] 从环境变量加载配置，共 {len(accounts_data)} 个账户")
+            else:
+                logger.warning("[CONFIG] 环境变量 ACCOUNTS_CONFIG 为空")
+            return accounts_data
+        except Exception as e:
+            logger.error(f"[CONFIG] 环境变量加载失败: {str(e)}")
+
+    if storage.is_database_enabled():
+        try:
+            accounts_data = storage.load_accounts_sync()
+
+            # 严格模式：数据库连接失败时抛出异常，阻止应用启动
+            if accounts_data is None:
+                logger.error("[CONFIG] ❌ 数据库连接失败")
+                logger.error("[CONFIG] 请检查 DATABASE_URL 配置或网络连接")
+                raise RuntimeError("数据库连接失败，应用无法启动")
+
+            if accounts_data:
+                logger.info(f"[CONFIG] 从数据库加载配置，共 {len(accounts_data)} 个账户")
+            else:
+                logger.warning("[CONFIG] 数据库中账户配置为空")
+                logger.warning("[CONFIG] 如需迁移数据，请运行: python scripts/migrate_to_database.py")
+
+            return accounts_data
+        except RuntimeError:
+            # 重新抛出 RuntimeError（数据库连接失败）
+            raise
+        except Exception as e:
+            logger.error(f"[CONFIG] ❌ 数据库加载失败: {e}")
+            raise RuntimeError(f"数据库加载失败: {e}")
+
+    logger.error("[CONFIG] 未启用数据库且未提供 ACCOUNTS_CONFIG")
+    return []
+
+
+def get_account_id(acc: dict, index: int) -> str:
+    """获取账户ID（有显式ID则使用，否则生成默认ID）"""
+    return acc.get("id", f"account_{index}")
+
+
+def load_multi_account_config(
+    http_client,
+    user_agent: str,
+    retry_policy: RetryPolicy,
+    session_cache_ttl_seconds: int,
+    global_stats: dict
+) -> MultiAccountManager:
+    """从文件或环境变量加载多账户配置"""
+    manager = MultiAccountManager(session_cache_ttl_seconds)
+
+    accounts_data = load_accounts_from_source()
+
+    for i, acc in enumerate(accounts_data, 1):
+        # 验证必需字段
+        required_fields = ["secure_c_ses", "csesidx", "config_id"]
+        missing_fields = [f for f in required_fields if f not in acc]
+        if missing_fields:
+            raise ValueError(f"账户 {i} 缺少必需字段: {', '.join(missing_fields)}")
+
+        config = AccountConfig(
+            account_id=get_account_id(acc, i),
+            secure_c_ses=acc["secure_c_ses"],
+            host_c_oses=acc.get("host_c_oses"),
+            csesidx=acc["csesidx"],
+            config_id=acc["config_id"],
+            expires_at=acc.get("expires_at"),
+            disabled=acc.get("disabled", False),  # 读取手动禁用状态，默认为False
+            mail_provider=acc.get("mail_provider"),
+            mail_address=acc.get("mail_address"),
+            mail_password=acc.get("mail_password") or acc.get("email_password"),
+            mail_client_id=acc.get("mail_client_id"),
+            mail_refresh_token=acc.get("mail_refresh_token"),
+            mail_tenant=acc.get("mail_tenant"),
+            trial_end=acc.get("trial_end"),
+        )
+
+        # 检查账户是否已过期（已过期也加载到管理面板）
+        is_expired = config.is_expired()
+        if is_expired:
+            logger.debug(f"[CONFIG] 账户 {config.account_id} 已过期，仍加载用于展示")
+
+        manager.add_account(config, http_client, user_agent, retry_policy, global_stats)
+
+        # 从数据库恢复冷却状态和统计数据
+        account_mgr = manager.accounts[config.account_id]
+        if "quota_cooldowns" in acc:
+            account_mgr.quota_cooldowns = dict(acc["quota_cooldowns"])
+        if "conversation_count" in acc:
+            account_mgr.conversation_count = int(acc.get("conversation_count", 0))
+        if "failure_count" in acc:
+            account_mgr.failure_count = int(acc.get("failure_count", 0))
+        if "daily_usage" in acc:
+            account_mgr.daily_usage = dict(acc["daily_usage"])
+        if "daily_usage_date" in acc:
+            account_mgr.daily_usage_date = str(acc.get("daily_usage_date", ""))
+
+        if is_expired:
+            manager.accounts[config.account_id].is_available = False
+
+    if not manager.accounts:
+        logger.warning(f"[CONFIG] 没有有效的账户配置，服务将启动但无法处理请���，请在管理面板添加账户")
+    else:
+        logger.info(f"[CONFIG] 成功加载 {len(manager.accounts)} 个账户")
+    return manager
+
+
+def reload_accounts(
+    multi_account_mgr: MultiAccountManager,
+    http_client,
+    user_agent: str,
+    retry_policy: RetryPolicy,
+    session_cache_ttl_seconds: int,
+    global_stats: dict
+) -> MultiAccountManager:
+    """Reload account config and preserve runtime cooldown/error state."""
+    # Preserve stats + runtime state to avoid clearing cooldowns on reload.
+    old_stats = {}
+    for account_id, account_mgr in multi_account_mgr.accounts.items():
+        old_stats[account_id] = {
+            "conversation_count": account_mgr.conversation_count,
+            "failure_count": account_mgr.failure_count,
+            "is_available": account_mgr.is_available,
+            "last_error_time": account_mgr.last_error_time,
+            "session_usage_count": account_mgr.session_usage_count,
+            "quota_cooldowns": dict(account_mgr.quota_cooldowns),
+            "daily_usage": dict(account_mgr.daily_usage),
+            "daily_usage_date": account_mgr.daily_usage_date,
+        }
+
+    # Clear session cache and reload config.
+    multi_account_mgr.global_session_cache.clear()
+    new_mgr = load_multi_account_config(
+        http_client,
+        user_agent,
+        retry_policy,
+        session_cache_ttl_seconds,
+        global_stats
+    )
+
+    # Restore stats + runtime state.
+    for account_id, stats in old_stats.items():
+        if account_id in new_mgr.accounts:
+            account_mgr = new_mgr.accounts[account_id]
+            account_mgr.conversation_count = stats["conversation_count"]
+            account_mgr.failure_count = stats.get("failure_count", 0)
+            account_mgr.last_error_time = stats.get("last_error_time", 0.0)
+            account_mgr.session_usage_count = stats.get("session_usage_count", 0)
+            account_mgr.daily_usage = stats.get("daily_usage", {"text": 0, "images": 0, "videos": 0})
+            account_mgr.daily_usage_date = stats.get("daily_usage_date", "")
+
+            # Smart restore: consider new config's expired/disabled state
+            old_available = stats.get("is_available", True)
+            old_cooldowns = stats.get("quota_cooldowns", {})
+            if account_mgr.config.is_expired() or account_mgr.config.disabled:
+                # Still expired/disabled → preserve old state
+                account_mgr.is_available = False
+                account_mgr.quota_cooldowns = old_cooldowns
+            elif not old_available and not old_cooldowns:
+                # Was unavailable with no cooldowns (i.e. expired/disabled),
+                # now recovered → mark available and clear cooldowns
+                account_mgr.is_available = True
+                account_mgr.quota_cooldowns = {}
+                logger.info(f"[CONFIG] Account {account_id} recovered from expired state, cooldowns cleared")
+            else:
+                # Normal case: preserve runtime state (e.g. quota cooldowns)
+                account_mgr.is_available = old_available
+                account_mgr.quota_cooldowns = old_cooldowns
+
+            logger.debug(f"[CONFIG] Account {account_id} refreshed; runtime state preserved")
+
+    logger.info(
+        f"[CONFIG] Reloaded config; accounts={len(new_mgr.accounts)}; cooldown/error state preserved"
+    )
+    return new_mgr
+
+
+def update_accounts_config(
+    accounts_data: list,
+    multi_account_mgr: MultiAccountManager,
+    http_client,
+    user_agent: str,
+    retry_policy: RetryPolicy,
+    session_cache_ttl_seconds: int,
+    global_stats: dict
+) -> MultiAccountManager:
+    """更新账户配置（保存到文件并重新加载）"""
+    save_accounts_to_file(accounts_data)
+    return reload_accounts(
+        multi_account_mgr,
+        http_client,
+        user_agent,
+        retry_policy,
+        session_cache_ttl_seconds,
+        global_stats
+    )
+
+
+def delete_account(
+    account_id: str,
+    multi_account_mgr: MultiAccountManager,
+    http_client,
+    user_agent: str,
+    retry_policy: RetryPolicy,
+    session_cache_ttl_seconds: int,
+    global_stats: dict
+) -> MultiAccountManager:
+    """删除单个账户"""
+    if storage.is_database_enabled():
+        deleted = storage.delete_accounts_sync([account_id])
+        if deleted <= 0:
+            raise ValueError(f"账户 {account_id} 不存在")
+        return reload_accounts(
+            multi_account_mgr,
+            http_client,
+            user_agent,
+            retry_policy,
+            session_cache_ttl_seconds,
+            global_stats
+        )
+
+    accounts_data = load_accounts_from_source()
+
+    filtered = [
+        acc for i, acc in enumerate(accounts_data, 1)
+        if get_account_id(acc, i) != account_id
+    ]
+
+    if len(filtered) == len(accounts_data):
+        raise ValueError(f"账户 {account_id} 不存在")
+
+    save_accounts_to_file(filtered)
+    return reload_accounts(
+        multi_account_mgr,
+        http_client,
+        user_agent,
+        retry_policy,
+        session_cache_ttl_seconds,
+        global_stats
+    )
+
+
+def update_account_disabled_status(
+    account_id: str,
+    disabled: bool,
+    multi_account_mgr: MultiAccountManager,
+) -> MultiAccountManager:
+    """更新账户的禁用状态（优化版：优先数据库直写）。"""
+    if storage.is_database_enabled():
+        updated = storage.update_account_disabled_sync(account_id, disabled)
+        if not updated:
+            raise ValueError(f"账户 {account_id} 不存在")
+        if account_id in multi_account_mgr.accounts:
+            multi_account_mgr.accounts[account_id].config.disabled = disabled
+        return multi_account_mgr
+
+    if account_id not in multi_account_mgr.accounts:
+        raise ValueError(f"账户 {account_id} 不存在")
+    account_mgr = multi_account_mgr.accounts[account_id]
+    account_mgr.config.disabled = disabled
+
+    accounts_data = load_accounts_from_source()
+    for i, acc in enumerate(accounts_data, 1):
+        if get_account_id(acc, i) == account_id:
+            acc["disabled"] = disabled
+            break
+
+    save_accounts_to_file(accounts_data)
+
+    status_text = "已禁用" if disabled else "已启用"
+    logger.info(f"[CONFIG] 账户 {account_id} {status_text}")
+    return multi_account_mgr
+
+
+def bulk_update_account_disabled_status(
+    account_ids: list[str],
+    disabled: bool,
+    multi_account_mgr: MultiAccountManager,
+) -> tuple[int, list[str]]:
+    """批量更新账户禁用状态，单次最多20个。"""
+    if storage.is_database_enabled():
+        updated, missing = storage.bulk_update_accounts_disabled_sync(account_ids, disabled)
+        for account_id in account_ids:
+            if account_id in multi_account_mgr.accounts:
+                multi_account_mgr.accounts[account_id].config.disabled = disabled
+        errors = [f"{account_id}: 账户不存在" for account_id in missing]
+        status_text = "已禁用" if disabled else "已启用"
+        logger.info(f"[CONFIG] 批量{status_text} {updated}/{len(account_ids)} 个账户")
+        return updated, errors
+
+    success_count = 0
+    errors = []
+
+    for account_id in account_ids:
+        if account_id not in multi_account_mgr.accounts:
+            errors.append(f"{account_id}: 账户不存在")
+            continue
+        account_mgr = multi_account_mgr.accounts[account_id]
+        account_mgr.config.disabled = disabled
+        success_count += 1
+
+    accounts_data = load_accounts_from_source()
+    account_id_set = set(account_ids)
+
+    for i, acc in enumerate(accounts_data, 1):
+        acc_id = get_account_id(acc, i)
+        if acc_id in account_id_set:
+            acc["disabled"] = disabled
+
+    save_accounts_to_file(accounts_data)
+
+    status_text = "已禁用" if disabled else "已启用"
+    logger.info(f"[CONFIG] 批量{status_text} {success_count}/{len(account_ids)} 个账户")
+    return success_count, errors
+
+
+def bulk_delete_accounts(
+    account_ids: list[str],
+    multi_account_mgr: MultiAccountManager,
+    http_client,
+    user_agent: str,
+    retry_policy: RetryPolicy,
+    session_cache_ttl_seconds: int,
+    global_stats: dict
+) -> tuple[MultiAccountManager, int, list[str]]:
+    """批量删除账户，单次最多20个。"""
+    if storage.is_database_enabled():
+        existing_ids = set(multi_account_mgr.accounts.keys())
+        missing = [account_id for account_id in account_ids if account_id not in existing_ids]
+        deleted = storage.delete_accounts_sync(account_ids)
+        errors = [f"{account_id}: 账户不存在" for account_id in missing]
+        if deleted > 0:
+            multi_account_mgr = reload_accounts(
+                multi_account_mgr,
+                http_client,
+                user_agent,
+                retry_policy,
+                session_cache_ttl_seconds,
+                global_stats
+            )
+        logger.info(f"[CONFIG] 批量删除 {deleted}/{len(account_ids)} 个账户")
+        return multi_account_mgr, deleted, errors
+
+    errors = []
+    account_id_set = set(account_ids)
+
+    accounts_data = load_accounts_from_source()
+    kept: list[dict] = []
+    deleted_ids: list[str] = []
+
+    for i, acc in enumerate(accounts_data, 1):
+        acc_id = get_account_id(acc, i)
+        if acc_id in account_id_set:
+            deleted_ids.append(acc_id)
+            continue
+        kept.append(acc)
+
+    missing = account_id_set.difference(deleted_ids)
+    for account_id in missing:
+        errors.append(f"{account_id}: 账户不存在")
+
+    if deleted_ids:
+        save_accounts_to_file(kept)
+        multi_account_mgr = reload_accounts(
+            multi_account_mgr,
+            http_client,
+            user_agent,
+            retry_policy,
+            session_cache_ttl_seconds,
+            global_stats
+        )
+
+    success_count = len(deleted_ids)
+    logger.info(f"[CONFIG] 批量删除 {success_count}/{len(account_ids)} 个账户")
+    return multi_account_mgr, success_count, errors
+
+
+async def save_account_cooldown_state(account_id: str, account_mgr: AccountManager) -> bool:
+    """保存单个账户的冷却状态到数据库（优化版：单条更新）"""
+    if not storage.is_database_enabled():
+        return False
+
+    try:
+        cooldown_data = {
+            "quota_cooldowns": dict(account_mgr.quota_cooldowns),
+            "conversation_count": account_mgr.conversation_count,
+            "failure_count": account_mgr.failure_count,
+            "daily_usage": dict(account_mgr.daily_usage),
+            "daily_usage_date": account_mgr.daily_usage_date,
+        }
+
+        success = await storage.update_account_cooldown(account_id, cooldown_data)
+        if success:
+            logger.debug(f"[COOLDOWN] 账户 {account_id} 冷却状态已保存")
+        else:
+            logger.warning(f"[COOLDOWN] 账户 {account_id} 不存在")
+        return success
+    except Exception as e:
+        logger.error(f"[COOLDOWN] 保存账户 {account_id} 冷却状态失败: {e}")
+        return False
+
+
+def save_account_cooldown_state_sync(account_id: str, account_mgr: AccountManager) -> bool:
+    """保存单个账户的冷却状态到数据库（同步版本）"""
+    try:
+        return asyncio.run(save_account_cooldown_state(account_id, account_mgr))
+    except Exception as e:
+        logger.error(f"[COOLDOWN] 同步保存账户 {account_id} 冷却状态失败: {e}")
+        return False
+
+
+async def save_all_cooldown_states(multi_account_mgr: MultiAccountManager) -> int:
+    """保存有冷却状态的账户到数据库（优化版：批量更新）"""
+    if not storage.is_database_enabled():
+        return 0
+
+    # 收集需要保存的账户
+    updates = []
+    for account_id, account_mgr in multi_account_mgr.accounts.items():
+        has_cooldown = (
+            account_mgr.quota_cooldowns or
+            account_mgr.conversation_count > 0 or
+            account_mgr.failure_count > 0 or
+            any(v > 0 for v in account_mgr.daily_usage.values())
+        )
+
+        if has_cooldown:
+            cooldown_data = {
+                "quota_cooldowns": dict(account_mgr.quota_cooldowns),
+                "conversation_count": account_mgr.conversation_count,
+                "failure_count": account_mgr.failure_count,
+                "daily_usage": dict(account_mgr.daily_usage),
+                "daily_usage_date": account_mgr.daily_usage_date,
+            }
+            updates.append((account_id, cooldown_data))
+
+    if not updates:
+        logger.info(f"[COOLDOWN] 无需保存：所有账户无冷却状态")
+        return 0
+
+    success_count, missing = await storage.bulk_update_accounts_cooldown(updates)
+
+    if missing:
+        logger.warning(f"[COOLDOWN] {len(missing)} 个账户不存在: {missing[:5]}")
+
+    logger.info(f"[COOLDOWN] 批量保存冷却状态: {success_count}/{len(updates)} 个账户（跳过 {len(multi_account_mgr.accounts) - len(updates)} 个无状态账户）")
+    return success_count
+

core/auth.py

@@ -0,0 +1,53 @@
+"""
+API认证模块
+提供API Key验证功能（用于API端点）
+管理端点使用Session认证（见core/session_auth.py）
+"""
+from typing import Optional
+from fastapi import HTTPException
+
+
+def verify_api_key(api_key_value: str, authorization: Optional[str] = None) -> bool:
+    """
+    验证 API Key（支持多个密钥，用逗号分隔）
+
+    Args:
+        api_key_value: 配置的API Key值（如果为空则跳过验证，多个密钥用逗号分隔）
+        authorization: Authorization Header中的值
+
+    Returns:
+        验证通过返回True，否则抛出HTTPException
+
+    支持格式：
+    1. Bearer YOUR_API_KEY
+    2. YOUR_API_KEY
+
+    多密钥配置示例：
+    API_KEY=key1,key2,key3
+    """
+    # 如果未配置 API_KEY，则跳过验证
+    if not api_key_value:
+        return True
+
+    # 检查 Authorization header
+    if not authorization:
+        raise HTTPException(
+            status_code=401,
+            detail="Missing Authorization header"
+        )
+
+    # 提取token（支持Bearer格式）
+    token = authorization
+    if authorization.startswith("Bearer "):
+        token = authorization[7:]
+
+    # 解析多个密钥（用逗号分隔）
+    valid_keys = [key.strip() for key in api_key_value.split(",") if key.strip()]
+
+    if token not in valid_keys:
+        raise HTTPException(
+            status_code=401,
+            detail="Invalid API Key"
+        )
+
+    return True

core/base_task_service.py

@@ -0,0 +1,338 @@
+"""
+基础任务服务类
+提供通用的任务管理、日志记录和账户更新功能
+"""
+import asyncio
+import logging
+import threading
+import time
+from concurrent.futures import ThreadPoolExecutor
+from dataclasses import dataclass, field
+from enum import Enum
+from typing import Any, Awaitable, Callable, Deque, Dict, Generic, List, Optional, TypeVar
+from collections import deque
+
+from core.account import RetryPolicy, update_accounts_config
+
+logger = logging.getLogger("gemini.base_task")
+
+
+class TaskCancelledError(Exception):
+    """用于在线程/回调中快速中断任务执行。"""
+
+
+class TaskStatus(str, Enum):
+    """任务状态枚举"""
+    PENDING = "pending"
+    RUNNING = "running"
+    SUCCESS = "success"
+    FAILED = "failed"
+    CANCELLED = "cancelled"
+
+
+@dataclass
+class BaseTask:
+    """基础任务数据类"""
+    id: str
+    status: TaskStatus = TaskStatus.PENDING
+    progress: int = 0
+    success_count: int = 0
+    fail_count: int = 0
+    created_at: float = field(default_factory=time.time)
+    finished_at: Optional[float] = None
+    results: List[Dict[str, Any]] = field(default_factory=list)
+    error: Optional[str] = None
+    logs: List[Dict[str, str]] = field(default_factory=list)
+    cancel_requested: bool = False
+    cancel_reason: Optional[str] = None
+
+    def to_dict(self) -> dict:
+        """转换为字典"""
+        return {
+            "id": self.id,
+            "status": self.status.value,
+            "progress": self.progress,
+            "success_count": self.success_count,
+            "fail_count": self.fail_count,
+            "created_at": self.created_at,
+            "finished_at": self.finished_at,
+            "results": self.results,
+            "error": self.error,
+            "logs": self.logs,
+            "cancel_requested": self.cancel_requested,
+            "cancel_reason": self.cancel_reason,
+        }
+
+
+T = TypeVar('T', bound=BaseTask)
+
+
+class BaseTaskService(Generic[T]):
+    """
+    基础任务服务类
+    提供通用的任务管理、日志记录和账户更新功能
+    """
+
+    def __init__(
+        self,
+        multi_account_mgr,
+        http_client,
+        user_agent: str,
+        retry_policy: RetryPolicy,
+        session_cache_ttl_seconds: int,
+        global_stats_provider: Callable[[], dict],
+        set_multi_account_mgr: Optional[Callable[[Any], None]] = None,
+        log_prefix: str = "TASK",
+    ) -> None:
+        """
+        初始化基础任务服务
+
+        Args:
+            multi_account_mgr: 多账户管理器
+            http_client: HTTP客户端
+            user_agent: 用户代理
+            retry_policy: 重试策略
+            session_cache_ttl_seconds: 会话缓存TTL秒数
+            global_stats_provider: 全局统计提供者
+            set_multi_account_mgr: 设置多账户管理器的回调
+            log_prefix: 日志前缀
+        """
+        self._executor = ThreadPoolExecutor(max_workers=1)
+        self._tasks: Dict[str, T] = {}
+        self._current_task_id: Optional[str] = None
+        self._last_task_id: Optional[str] = None
+        self._lock = asyncio.Lock()
+        self._log_lock = threading.Lock()
+        self._log_prefix = log_prefix
+        self._pending_task_ids: Deque[str] = deque()
+        self._worker_task: Optional[asyncio.Task] = None
+        self._current_asyncio_task: Optional[asyncio.Task] = None
+        self._cancel_hooks: Dict[str, List[Callable[[], None]]] = {}
+        self._cancel_hooks_lock = threading.Lock()
+
+        self.multi_account_mgr = multi_account_mgr
+        self.http_client = http_client
+        self.user_agent = user_agent
+        self.retry_policy = retry_policy
+        self.session_cache_ttl_seconds = session_cache_ttl_seconds
+        self.global_stats_provider = global_stats_provider
+        self.set_multi_account_mgr = set_multi_account_mgr
+
+    def get_task(self, task_id: str) -> Optional[T]:
+        """获取指定任务"""
+        return self._tasks.get(task_id)
+
+    def get_current_task(self) -> Optional[T]:
+        """获取当前任务"""
+        if self._current_task_id:
+            current = self._tasks.get(self._current_task_id)
+            if current:
+                return current
+        # 若当前无运行任务，返回队列中最早的 pending 任务（用于前端显示“等待中”）
+        for task_id in list(self._pending_task_ids):
+            task = self._tasks.get(task_id)
+            if task and task.status == TaskStatus.PENDING:
+                return task
+        return None
+
+    def get_pending_task_ids(self) -> List[str]:
+        """返回待执行任务ID列表（调试/展示用）。"""
+        return list(self._pending_task_ids)
+
+    async def cancel_task(self, task_id: str, reason: str = "cancelled") -> Optional[T]:
+        """请求取消任务（支持 pending/running）。"""
+        async with self._lock:
+            task = self._tasks.get(task_id)
+            if not task:
+                return None
+
+            if task.status == TaskStatus.PENDING:
+                # 从队列移除并直接标记取消
+                try:
+                    self._pending_task_ids.remove(task_id)
+                except ValueError:
+                    pass
+                task.cancel_requested = True
+                task.cancel_reason = reason
+                task.status = TaskStatus.CANCELLED
+                task.finished_at = time.time()
+                self._append_log(task, "warning", f"task cancelled while pending: {reason}")
+                self._save_task_history_best_effort(task)
+                self._last_task_id = task.id
+                return task
+
+            if task.status == TaskStatus.RUNNING:
+                task.cancel_requested = True
+                task.cancel_reason = reason
+                self._append_log(task, "warning", f"cancel requested: {reason}")
+                # 尝试立即触发取消回调（例如关闭浏览器）
+                self._fire_cancel_hooks(task_id)
+                # 尝试取消当前 await（例如 run_in_executor 等待点）
+                if self._current_asyncio_task and not self._current_asyncio_task.done():
+                    self._current_asyncio_task.cancel()
+                return task
+
+            return task
+
+    async def _enqueue_task(self, task: T) -> None:
+        """将任务加入队列并启动 worker。"""
+        self._pending_task_ids.append(task.id)
+        if not self._worker_task or self._worker_task.done():
+            self._worker_task = asyncio.create_task(self._run_worker())
+
+    async def _run_worker(self) -> None:
+        """串行执行队列任务（单线程 executor + 单 worker）。"""
+        while True:
+            async with self._lock:
+                next_task: Optional[T] = None
+                # 清理不存在/非pending的ID
+                while self._pending_task_ids:
+                    task_id = self._pending_task_ids[0]
+                    task = self._tasks.get(task_id)
+                    if not task or task.status != TaskStatus.PENDING:
+                        self._pending_task_ids.popleft()
+                        continue
+                    next_task = task
+                    self._pending_task_ids.popleft()
+                    self._current_task_id = task.id
+                    break
+
+            if not next_task:
+                break
+
+            await self._run_one_task(next_task)
+
+            async with self._lock:
+                if self._current_task_id == next_task.id:
+                    self._current_task_id = None
+
+    async def _run_one_task(self, task: T) -> None:
+        """执行单个任务，处理取消/异常/收尾。"""
+        if task.status != TaskStatus.PENDING:
+            return
+        if task.cancel_requested:
+            task.status = TaskStatus.CANCELLED
+            task.finished_at = time.time()
+            return
+
+        task.status = TaskStatus.RUNNING
+        self._append_log(task, "info", "task started")
+        try:
+            coro = self._execute_task(task)
+            self._current_asyncio_task = asyncio.create_task(coro)
+            await self._current_asyncio_task
+        except asyncio.CancelledError:
+            # 外部请求取消（或关闭时）会触发
+            task.cancel_requested = True
+            task.status = TaskStatus.CANCELLED
+            task.finished_at = time.time()
+            self._append_log(task, "warning", f"task cancelled: {task.cancel_reason or 'cancelled'}")
+        except TaskCancelledError:
+            task.cancel_requested = True
+            task.status = TaskStatus.CANCELLED
+            task.finished_at = time.time()
+            self._append_log(task, "warning", f"task cancelled: {task.cancel_reason or 'cancelled'}")
+        except Exception as exc:
+            task.status = TaskStatus.FAILED
+            task.error = str(exc)
+            task.finished_at = time.time()
+            self._append_log(task, "error", f"task error: {type(exc).__name__}: {str(exc)[:200]}")
+        finally:
+            self._current_asyncio_task = None
+            self._clear_cancel_hooks(task.id)
+            if task.status in (TaskStatus.SUCCESS, TaskStatus.FAILED, TaskStatus.CANCELLED) and task.finished_at:
+                self._save_task_history_best_effort(task)
+                self._last_task_id = task.id
+
+    def _add_cancel_hook(self, task_id: str, hook: Callable[[], None]) -> None:
+        """注册取消回调（线程安全）。"""
+        with self._cancel_hooks_lock:
+            self._cancel_hooks.setdefault(task_id, []).append(hook)
+
+    def _fire_cancel_hooks(self, task_id: str) -> None:
+        """触发取消回调（尽力而为）。"""
+        with self._cancel_hooks_lock:
+            hooks = list(self._cancel_hooks.get(task_id) or [])
+        for hook in hooks:
+            try:
+                hook()
+            except Exception as exc:
+                logger.warning("[%s] cancel hook error: %s", self._log_prefix, str(exc)[:120])
+
+    def _clear_cancel_hooks(self, task_id: str) -> None:
+        with self._cancel_hooks_lock:
+            self._cancel_hooks.pop(task_id, None)
+
+    # --- 子类需要实现 ---
+    def _execute_task(self, task: T) -> Awaitable[None]:
+        """子类实现：执行任务主体（需自行更新 progress/success/fail/finished_at 等）。"""
+        raise NotImplementedError
+
+    def _append_log(self, task: T, level: str, message: str) -> None:
+        """
+        添加日志到任务
+
+        Args:
+            task: 任务对象
+            level: 日志级别 (info, warning, error)
+            message: 日志消息
+        """
+        entry = {
+            "time": time.strftime("%Y-%m-%d %H:%M:%S", time.localtime()),
+            "level": level,
+            "message": message,
+        }
+        with self._log_lock:
+            task.logs.append(entry)
+            if len(task.logs) > 200:
+                task.logs = task.logs[-200:]
+
+        log_message = f"[{self._log_prefix}] {message}"
+        if level == "warning":
+            logger.warning(log_message)
+        elif level == "error":
+            logger.error(log_message)
+        else:
+            logger.info(log_message)
+
+        # 协作式取消：一旦请求取消，阻断后续通过 log_callback 的执行路径
+        # 允许“取消请求/取消完成”相关日志正常写入
+        if task.cancel_requested:
+            safe_messages = (
+                "cancel requested:",
+                "task cancelled",
+                "task cancelled while pending",
+                "login task cancelled:",
+                "register task cancelled:",
+            )
+            if not any(message.startswith(x) for x in safe_messages):
+                raise TaskCancelledError(task.cancel_reason or "cancelled")
+
+    def _save_task_history_best_effort(self, task: T) -> None:
+        try:
+            from main import save_task_to_history
+            task_type = "login" if self._log_prefix == "REFRESH" else "register"
+            save_task_to_history(task_type, task.to_dict())
+        except Exception:
+            pass
+
+    def _apply_accounts_update(self, accounts_data: list) -> None:
+        """
+        应用账户更新
+
+        Args:
+            accounts_data: 账户数据列表
+        """
+        global_stats = self.global_stats_provider() or {}
+        new_mgr = update_accounts_config(
+            accounts_data,
+            self.multi_account_mgr,
+            self.http_client,
+            self.user_agent,
+            self.retry_policy,
+            self.session_cache_ttl_seconds,
+            global_stats,
+        )
+        self.multi_account_mgr = new_mgr
+        if self.set_multi_account_mgr:
+            self.set_multi_account_mgr(new_mgr)

core/cfmail_client.py

@@ -0,0 +1,331 @@
+"""
+Cloudflare Temp Email 临时邮箱客户端
+
+API 文档参考 (基于 Hono 框架，JWT 认证):
+- 获取公开配置: GET /open_api/settings
+- 创建新邮箱:   POST /api/new_address  body: {name, domain}  → {address, jwt}
+- 获取邮件列表: GET /api/mails          Authorization: Bearer {jwt}
+- 获取邮件详情: GET /api/mail/:mail_id  Authorization: Bearer {jwt}
+"""
+
+import random
+import string
+import time
+from datetime import datetime
+from typing import Optional
+
+import requests
+
+from core.mail_utils import extract_verification_code
+from core.proxy_utils import request_with_proxy_fallback
+
+
+class CloudflareMailClient:
+    """Cloudflare Temp Email 临时邮箱客户端"""
+
+    def __init__(
+        self,
+        base_url: str = "",
+        proxy: str = "",
+        api_key: str = "",
+        domain: str = "",
+        verify_ssl: bool = True,
+        log_callback=None,
+    ) -> None:
+        self.base_url = (base_url or "").rstrip("/")
+        self.proxy_url = (proxy or "").strip()
+        self.api_key = (api_key or "").strip()   # x-custom-auth 密码
+        self.domain = (domain or "").strip()
+        self.verify_ssl = verify_ssl
+        self.log_callback = log_callback
+
+        self.email: Optional[str] = None
+        self.password: Optional[str] = None   # 兼容接口，存储 JWT token
+        self.jwt_token: Optional[str] = None  # 创建地址时返回的 JWT
+
+        self._available_domains: list = []
+
+    # ------------------------------------------------------------------
+    # 内部工具
+    # ------------------------------------------------------------------
+
+    def _log(self, level: str, message: str) -> None:
+        if self.log_callback:
+            try:
+                self.log_callback(level, message)
+            except Exception:
+                pass
+
+    def _request(self, method: str, url: str, **kwargs) -> requests.Response:
+        headers = kwargs.pop("headers", None) or {}
+
+        # 实例密码认证（admin 路由使用 x-admin-auth）
+        if self.api_key and "x-admin-auth" not in {k.lower() for k in headers}:
+            headers["x-admin-auth"] = self.api_key
+
+        # 邮件操作时使用 JWT Bearer 认证
+        if self.jwt_token and "authorization" not in {k.lower() for k in headers}:
+            headers["Authorization"] = f"Bearer {self.jwt_token}"
+
+        kwargs["headers"] = headers
+
+        self._log("info", f"📤 发送 {method} 请求: {url}")
+        if "json" in kwargs and kwargs["json"] is not None:
+            self._log("info", f"📦 请求体: {kwargs['json']}")
+
+        proxies = {"http": self.proxy_url, "https": self.proxy_url} if self.proxy_url else None
+
+        try:
+            res = request_with_proxy_fallback(
+                requests.request,
+                method,
+                url,
+                proxies=proxies,
+                verify=self.verify_ssl,
+                timeout=kwargs.pop("timeout", 30),
+                **kwargs,
+            )
+            self._log("info", f"📥 收到响应: HTTP {res.status_code}")
+            if res.content and res.status_code >= 400:
+                try:
+                    self._log("error", f"📄 响应内容: {res.text[:500]}")
+                except Exception:
+                    pass
+            return res
+        except Exception as e:
+            self._log("error", f"❌ 网络请求失败: {e}")
+            raise
+
+    # ------------------------------------------------------------------
+    # 公开接口
+    # ------------------------------------------------------------------
+
+    def set_credentials(self, email: str, password: str = "") -> None:
+        """设置凭据（兼容接口）。password 存储 JWT token。"""
+        self.email = email
+        self.password = password
+        if password:
+            self.jwt_token = password
+
+    def _get_available_domains(self) -> list:
+        """GET /open_api/settings 获取可用域名列表"""
+        if self._available_domains:
+            return self._available_domains
+
+        try:
+            res = self._request("GET", f"{self.base_url}/open_api/settings")
+            if res.status_code == 200:
+                data = res.json() if res.content else {}
+                domains = data.get("domains", [])
+                if isinstance(domains, list) and domains:
+                    self._available_domains = [str(d).strip() for d in domains if d]
+                    self._log("info", f"🌐 CFMail 可用域名: {self._available_domains}")
+                    return self._available_domains
+        except Exception as e:
+            self._log("error", f"❌ 获取可用域名失败: {e}")
+
+        return self._available_domains
+
+    def register_account(self, domain: Optional[str] = None) -> bool:
+        """POST /api/new_address 创建新邮箱地址"""
+        if not self.base_url:
+            self._log("error", "❌ cfmail_base_url 未配置")
+            return False
+
+        # 确定域名
+        selected_domain = domain or self.domain
+        if not selected_domain:
+            available = self._get_available_domains()
+            if available:
+                selected_domain = random.choice(available)
+
+        # 生成随机用户名
+        rand = "".join(random.choices(string.ascii_lowercase + string.digits, k=10))
+        timestamp = str(int(time.time()))[-4:]
+        name = f"t{timestamp}{rand}"
+
+        payload = {"name": name}
+        if selected_domain:
+            payload["domain"] = selected_domain
+            self._log("info", f"📧 使用域名: {selected_domain}")
+
+        self._log("info", f"🎲 创建邮箱: {name}")
+
+        try:
+            res = self._request("POST", f"{self.base_url}/admin/new_address", json=payload)
+
+            if res.status_code in (200, 201):
+                data = res.json() if res.content else {}
+                address = data.get("address", "")
+                jwt = data.get("jwt", "")
+
+                if address:
+                    self.email = address
+                    self.jwt_token = jwt
+                    self.password = jwt  # 兼容接口
+                    self._log("info", f"✅ CFMail 注册成功: {self.email}")
+                    return True
+
+            self._log("error", f"❌ CFMail 注册失败: HTTP {res.status_code}")
+            return False
+
+        except Exception as e:
+            self._log("error", f"❌ CFMail 注册异常: {e}")
+            return False
+
+    def login(self) -> bool:
+        """无需登录，直接返回 True"""
+        return True
+
+    @staticmethod
+    def _extract_body_from_raw(raw: str) -> str:
+        """从原始邮件中提取正文（text/plain + text/html），跳过 header"""
+        if not raw:
+            return ""
+        import email as _email
+        try:
+            msg = _email.message_from_string(raw)
+            parts = []
+            if msg.is_multipart():
+                for part in msg.walk():
+                    ct = part.get_content_type()
+                    if ct in ("text/plain", "text/html"):
+                        payload = part.get_payload(decode=True)
+                        if payload:
+                            charset = part.get_content_charset() or "utf-8"
+                            parts.append(payload.decode(charset, errors="replace"))
+            else:
+                payload = msg.get_payload(decode=True)
+                if payload:
+                    charset = msg.get_content_charset() or "utf-8"
+                    parts.append(payload.decode(charset, errors="replace"))
+            return "".join(parts)
+        except Exception:
+            return ""
+
+    def fetch_verification_code(self, since_time: Optional[datetime] = None) -> Optional[str]:
+        """GET /api/mails 获取邮件列表，再 GET /api/mail/:id 获取详情，提取验证码"""
+        if not self.jwt_token:
+            self._log("error", "❌ 缺少 JWT token，无法获取邮件")
+            return None
+
+        try:
+            self._log("info", "📬 正在拉取 CFMail 邮件列表...")
+            res = self._request("GET", f"{self.base_url}/api/mails", params={"limit": 20, "offset": 0})
+
+            if res.status_code != 200:
+                self._log("error", f"❌ 获取邮件列表失败: HTTP {res.status_code}")
+                return None
+
+            data = res.json() if res.content else {}
+            # 响应格式: {"results": [...], "total": N}
+            messages = data.get("results", [])
+            if not isinstance(messages, list):
+                messages = []
+
+            if not messages:
+                self._log("info", "📭 邮箱为空，暂无邮件")
+                return None
+
+            self._log("info", f"📨 收到 {len(messages)} 封邮件，开始检查验证码...")
+
+            # 按 id 降序（新邮件优先）
+            try:
+                messages = sorted(messages, key=lambda m: int(m.get("id") or 0), reverse=True)
+            except Exception:
+                pass
+
+            for idx, msg in enumerate(messages, 1):
+                msg_id = msg.get("id")
+                if not msg_id:
+                    continue
+
+                # 时间过滤
+                if since_time:
+                    raw_time = msg.get("created_at") or msg.get("createdAt")
+                    if raw_time:
+                        try:
+                            if isinstance(raw_time, (int, float)):
+                                ts = float(raw_time)
+                                if ts > 1e12:
+                                    ts /= 1000.0
+                                msg_time = datetime.fromtimestamp(ts)
+                            else:
+                                import re
+                                raw_time = re.sub(r"(\.\d{6})\d+", r"\1", str(raw_time))
+                                # cfmail 的 created_at 是 UTC 无时区标记，显式加 +00:00 再转本地时间
+                                if not raw_time.endswith("Z") and "+" not in raw_time and raw_time.count("-") <= 2:
+                                    raw_time = raw_time + "+00:00"
+                                msg_time = datetime.fromisoformat(raw_time.replace("Z", "+00:00")).astimezone().replace(tzinfo=None)
+                            if msg_time < since_time:
+                                continue
+                        except Exception:
+                            pass
+
+                # 列表响应已包含 raw 字段，直接解析正文提取验证码
+                raw_in_list = msg.get("raw") or ""
+                if raw_in_list:
+                    body = self._extract_body_from_raw(raw_in_list)
+                    code = extract_verification_code(body)
+                    if code:
+                        self._log("info", f"✅ 找到验证码: {code}")
+                        return code
+
+                # 兜底：尝试从其他摘要字段提取
+                summary = (msg.get("subject") or "") + (msg.get("text") or "") + (msg.get("html") or "")
+                if summary:
+                    code = extract_verification_code(summary)
+                    if code:
+                        self._log("info", f"✅ 找到验证码: {code}")
+                        return code
+
+                # 获取邮件详情
+                self._log("info", f"🔍 正在读取邮件 {idx}/{len(messages)} 详情...")
+                detail_res = self._request("GET", f"{self.base_url}/api/mail/{msg_id}")
+
+                if detail_res.status_code != 200:
+                    self._log("warning", f"⚠️ 读取邮件详情失败: HTTP {detail_res.status_code}")
+                    continue
+
+                detail = detail_res.json() if detail_res.content else {}
+                content = self._extract_body_from_raw(detail.get("raw") or "")
+                if content:
+                    code = extract_verification_code(content)
+                    if code:
+                        self._log("info", f"✅ 找到验证码: {code}")
+                        return code
+                    else:
+                        self._log("info", f"❌ 邮件 {idx} 中未找到验证码")
+
+            self._log("warning", "⚠️ 所有邮件中均未找到验证码")
+            return None
+
+        except Exception as e:
+            self._log("error", f"❌ 获取验证码异常: {e}")
+            return None
+
+    def poll_for_code(
+        self,
+        timeout: int = 120,
+        interval: int = 4,
+        since_time: Optional[datetime] = None,
+    ) -> Optional[str]:
+        """轮询获取验证码"""
+        if not self.email:
+            return None
+
+        max_retries = max(1, timeout // interval)
+        self._log("info", f"⏱️ 开始轮询验证码 (超时 {timeout}秒, 间隔 {interval}秒, 最多 {max_retries} 次)")
+
+        for i in range(1, max_retries + 1):
+            self._log("info", f"🔄 第 {i}/{max_retries} 次轮询...")
+            code = self.fetch_verification_code(since_time=since_time)
+            if code:
+                self._log("info", f"🎉 验证码获取成功: {code}")
+                return code
+            if i < max_retries:
+                self._log("info", f"⏳ 等待 {interval} 秒后重试...")
+                time.sleep(interval)
+
+        self._log("error", f"⏰ 验证码获取超时 ({timeout}秒)")
+        return None

core/child_reaper.py

@@ -0,0 +1,84 @@
+"""
+Child process reaper (Linux/Unix).
+
+When third-party libraries spawn subprocesses and do not `wait()` them properly,
+the exited children become zombie processes (<defunct>) until the parent reaps.
+
+This module installs a SIGCHLD handler that reaps all exited children with
+os.waitpid(-1, WNOHANG) to prevent zombie accumulation in long-running services.
+"""
+
+from __future__ import annotations
+
+import errno
+import os
+import signal
+from typing import Callable, Optional, Union
+
+
+_InstalledHandler = Union[int, Callable[[int, object], None], None]
+
+
+def install_child_reaper(log: Optional[Callable[[str], None]] = None) -> bool:
+    """
+    Install a SIGCHLD handler to reap zombie processes.
+
+    Returns True if a handler was installed, otherwise False.
+    Safe to call multiple times; it will simply re-install the handler.
+    """
+    # Windows has no SIGCHLD; only do this on POSIX.
+    if os.name != "posix":
+        return False
+
+    if not hasattr(signal, "SIGCHLD"):
+        return False
+
+    try:
+        old_handler: _InstalledHandler = signal.getsignal(signal.SIGCHLD)
+    except Exception:
+        old_handler = None
+
+    def _log(msg: str) -> None:
+        if log:
+            try:
+                log(msg)
+            except Exception:
+                pass
+
+    def _reap_all_children() -> None:
+        # Reap all already-exited child processes (non-blocking).
+        while True:
+            try:
+                pid, _status = os.waitpid(-1, os.WNOHANG)
+            except ChildProcessError:
+                # No child processes.
+                return
+            except OSError as e:
+                if e.errno == errno.ECHILD:
+                    return
+                # Any other error: stop to avoid spinning.
+                _log(f"[CHILD-REAPER] waitpid failed: {e}")
+                return
+
+            if pid == 0:
+                return
+
+    def _handler(signum: int, frame) -> None:
+        # 1) First reap everything we can to prevent zombies.
+        _reap_all_children()
+
+        # 2) Chain previous handler (if it was a Python callable).
+        try:
+            if callable(old_handler):
+                old_handler(signum, frame)
+        except Exception:
+            # Never let exceptions escape a signal handler.
+            pass
+
+    try:
+        signal.signal(signal.SIGCHLD, _handler)
+        return True
+    except Exception as e:
+        _log(f"[CHILD-REAPER] failed to install SIGCHLD handler: {e}")
+        return False
+

core/config.py

@@ -0,0 +1,554 @@
+"""
+统一配置管理系统
+
+优先级规则：
+1. 安全配置：仅环境变量（ADMIN_KEY, SESSION_SECRET_KEY）
+2. 业务配置：数据库 > 默认值
+
+配置分类：
+- 安全配置：仅从环境变量读取，不可热更新（ADMIN_KEY, SESSION_SECRET_KEY）
+- 业务配置：仅从数据库读取，支持热更新（API_KEY, BASE_URL, PROXY, 重试策略等）
+"""
+
+import os
+import shutil
+import yaml
+import secrets
+from pathlib import Path
+from typing import Optional, List
+from pydantic import BaseModel, Field, validator
+from dotenv import load_dotenv
+
+from core import storage
+
+# 加载 .env 文件
+load_dotenv()
+
+def _parse_bool(value, default: bool) -> bool:
+    if isinstance(value, bool):
+        return value
+    if value is None:
+        return default
+    if isinstance(value, (int, float)):
+        return value != 0
+    if isinstance(value, str):
+        lowered = value.strip().lower()
+        if lowered in ("1", "true", "yes", "y", "on"):
+            return True
+        if lowered in ("0", "false", "no", "n", "off"):
+            return False
+    return default
+
+
+# ==================== 配置模型定义 ====================
+
+class BasicConfig(BaseModel):
+    """基础配置"""
+    api_key: str = Field(default="", description="API访问密钥（留空则公开访问，多个密钥用逗号分隔）")
+    base_url: str = Field(default="", description="服务器URL（留空则自动检测）")
+    proxy_for_auth: str = Field(default="", description="账户操作代理地址（注册/登录/刷新，留空则不使用代理）")
+    proxy_for_chat: str = Field(default="", description="对话操作代理地址（JWT/会话/消息，留空则不使用代理）")
+    duckmail_base_url: str = Field(default="https://api.duckmail.sbs", description="DuckMail API地址")
+    duckmail_api_key: str = Field(default="", description="DuckMail API key")
+    duckmail_verify_ssl: bool = Field(default=True, description="DuckMail SSL校验")
+    temp_mail_provider: str = Field(default="duckmail", description="临时邮箱提供商: duckmail/moemail/freemail/gptmail/cfmail")
+    moemail_base_url: str = Field(default="https://moemail.app", description="Moemail API地址")
+    moemail_api_key: str = Field(default="", description="Moemail API key")
+    moemail_domain: str = Field(default="", description="Moemail 邮箱域名（可选，留空则随机选择）")
+    freemail_base_url: str = Field(default="http://your-freemail-server.com", description="Freemail API地址")
+    freemail_jwt_token: str = Field(default="", description="Freemail JWT Token")
+    freemail_verify_ssl: bool = Field(default=True, description="Freemail SSL校验")
+    freemail_domain: str = Field(default="", description="Freemail 邮箱域名（可选，留空则随机选择）")
+    mail_proxy_enabled: bool = Field(default=False, description="是否启用临时邮箱代理（使用账户操作代理）")
+    gptmail_base_url: str = Field(default="https://mail.chatgpt.org.uk", description="GPTMail API地址")
+    gptmail_api_key: str = Field(default="gpt-test", description="GPTMail API key")
+    gptmail_verify_ssl: bool = Field(default=True, description="GPTMail SSL校验")
+    gptmail_domain: str = Field(default="", description="GPTMail 邮箱域名（可选，留空则随机选择）")
+    cfmail_base_url: str = Field(default="", description="Cloudflare Mail API地址")
+    cfmail_api_key: str = Field(default="", description="Cloudflare Mail 访问密码（x-custom-auth）")
+    cfmail_verify_ssl: bool = Field(default=True, description="Cloudflare Mail SSL校验")
+    cfmail_domain: str = Field(default="", description="Cloudflare Mail 邮箱域名（可选，留空随机）")
+    browser_engine: str = Field(default="dp", description="浏览器引擎")
+    browser_headless: bool = Field(default=False, description="自动化浏览器无头模式")
+    refresh_window_hours: int = Field(default=1, ge=0, le=24, description="过期刷新窗口（小时）")
+    register_default_count: int = Field(default=1, ge=1, description="默认注册数量")
+    register_domain: str = Field(default="", description="DuckMail 域名（推荐）")
+    image_expire_hours: int = Field(default=12, ge=-1, le=720, description="图片/视频过期时间（小时），-1为永不删除")
+
+
+class ImageGenerationConfig(BaseModel):
+    """图片生成配置"""
+    enabled: bool = Field(default=False, description="是否启用图片生成")
+    supported_models: List[str] = Field(
+        default=[],
+        description="支持图片生成的模型列表"
+    )
+    output_format: str = Field(default="base64", description="图片输出格式：base64 或 url")
+
+
+class VideoGenerationConfig(BaseModel):
+    """视频生成配置"""
+    output_format: str = Field(default="html", description="视频输出格式：html/url/markdown")
+
+    @validator("output_format")
+    def validate_output_format(cls, v):
+        allowed = ["html", "url", "markdown"]
+        if v not in allowed:
+            raise ValueError(f"output_format 必须是 {allowed} 之一")
+        return v
+
+
+class RetryConfig(BaseModel):
+    """重试策略配置"""
+    max_account_switch_tries: int = Field(default=5, ge=1, le=20, description="账户切换尝试次数")
+    rate_limit_cooldown_seconds: int = Field(default=7200, ge=3600, le=43200, description="429冷却时间（秒）")
+    text_rate_limit_cooldown_seconds: int = Field(default=7200, ge=3600, le=86400, description="对话配额冷却（秒）")
+    images_rate_limit_cooldown_seconds: int = Field(default=14400, ge=3600, le=86400, description="绘图配额冷却（秒）")
+    videos_rate_limit_cooldown_seconds: int = Field(default=14400, ge=3600, le=86400, description="视频配额冷却（秒）")
+    session_cache_ttl_seconds: int = Field(default=3600, ge=0, le=86400, description="会话缓存时间（秒，0表示禁用缓存）")
+    auto_refresh_accounts_seconds: int = Field(default=60, ge=0, le=600, description="自动刷新账号间隔（秒，0禁用）")
+    # 定时刷新配置
+    scheduled_refresh_enabled: bool = Field(default=False, description="是否启用定时刷新任务")
+    scheduled_refresh_cron: str = Field(default="08:00,20:00", description="刷新时间，如 '08:00,20:00' 或 '*/120'(每120分钟)")
+    refresh_batch_size: int = Field(default=5, ge=1, le=20, description="每批刷新账号数")
+    refresh_batch_interval_minutes: int = Field(default=30, ge=5, le=120, description="批次间等待时间(分钟)")
+    refresh_cooldown_hours: float = Field(default=12.0, ge=1, le=48, description="同一账号刷新冷却期(小时)")
+    # 向后兼容：旧配置可能只有这个字段，读取时自动转换为 */N cron 格式
+    scheduled_refresh_interval_minutes: int = Field(default=0, ge=0, le=720, description="(旧字段，已废弃) 定时刷新检测间隔")
+
+class QuotaLimitsConfig(BaseModel):
+    """每日配额上限配置（基于 Google 官方限额，用于主动配额计数）"""
+    enabled: bool = Field(default=True, description="是否启用主动配额计数")
+    text_daily_limit: int = Field(default=120, ge=0, le=9999, description="对话每日上限（0=不限制）")
+    images_daily_limit: int = Field(default=2, ge=0, le=9999, description="绘图每日上限（0=不限制）")
+    videos_daily_limit: int = Field(default=1, ge=0, le=9999, description="视频每日上限（0=不限制）")
+
+
+class PublicDisplayConfig(BaseModel):
+    """公开展示配置"""
+    logo_url: str = Field(default="", description="Logo URL")
+    chat_url: str = Field(default="", description="开始对话链接")
+
+
+class SessionConfig(BaseModel):
+    """Session配置"""
+    expire_hours: int = Field(default=24, ge=1, le=168, description="Session过期时间（小时）")
+
+
+class SecurityConfig(BaseModel):
+    """安全配置（仅从环境变量读取，不可热更新）"""
+    admin_key: str = Field(default="", description="管理员密钥（必需）")
+    session_secret_key: str = Field(..., description="Session密钥")
+
+
+class AppConfig(BaseModel):
+    """应用配置（统一管理）"""
+    # 安全配置（仅从环境变量）
+    security: SecurityConfig
+
+    # 业务配置（环境变量 > 数据库 > 默认值）
+    basic: BasicConfig
+    image_generation: ImageGenerationConfig
+    video_generation: VideoGenerationConfig = Field(default_factory=VideoGenerationConfig)
+    retry: RetryConfig
+    quota_limits: QuotaLimitsConfig = Field(default_factory=QuotaLimitsConfig)
+    public_display: PublicDisplayConfig
+    session: SessionConfig
+
+
+# ==================== 配置管理器 ====================
+
+class ConfigManager:
+    """配置管理器（单例）"""
+
+    def __init__(self, yaml_path: str = None):
+        # 自动检测环境并设置默认路径
+        if yaml_path is None:
+            yaml_path = ""
+        self.yaml_path = Path(yaml_path)
+        self._config: Optional[AppConfig] = None
+        self.load()
+
+    def load(self):
+        """
+        加载配置
+
+        优先级规则：
+        1. 安全配置（ADMIN_KEY, SESSION_SECRET_KEY）：仅从环境变量读取
+        2. 业务配置：数据库 > 默认值
+        """
+        # 1. 从数据库加载配置
+        yaml_data = self._load_yaml()
+
+        # 2. 加载安全配置（仅从环境变量，不允许 Web 修改）
+        security_config = SecurityConfig(
+            admin_key=os.getenv("ADMIN_KEY", ""),
+            session_secret_key=os.getenv("SESSION_SECRET_KEY", self._generate_secret())
+        )
+
+        # 3. 加载基础配置（数据库 > 默认值）
+        basic_data = yaml_data.get("basic", {})
+        refresh_window_raw = basic_data.get("refresh_window_hours", 1)
+        register_default_raw = basic_data.get("register_default_count", 1)
+        register_domain_raw = basic_data.get("register_domain", "")
+        duckmail_api_key_raw = basic_data.get("duckmail_api_key", "")
+
+        # 兼容旧配置：如果存在旧的 proxy 字段，迁移到新字段
+        old_proxy = basic_data.get("proxy", "")
+        old_proxy_for_auth_bool = basic_data.get("proxy_for_auth")
+        old_proxy_for_chat_bool = basic_data.get("proxy_for_chat")
+
+        # 新配置优先，如果没有新配置则从旧配置迁移
+        proxy_for_auth = basic_data.get("proxy_for_auth", "")
+        proxy_for_chat = basic_data.get("proxy_for_chat", "")
+
+        # 如果新配置为空且存在旧配置，则迁移
+        if not proxy_for_auth and old_proxy:
+            # 如果旧配置中 proxy_for_auth 是布尔值且为 True，则使用旧的 proxy
+            if isinstance(old_proxy_for_auth_bool, bool) and old_proxy_for_auth_bool:
+                proxy_for_auth = old_proxy
+
+        if not proxy_for_chat and old_proxy:
+            # 如果旧配置中 proxy_for_chat 是布尔值且为 True，则使用旧的 proxy
+            if isinstance(old_proxy_for_chat_bool, bool) and old_proxy_for_chat_bool:
+                proxy_for_chat = old_proxy
+
+        basic_config = BasicConfig(
+            api_key=basic_data.get("api_key") or "",
+            base_url=basic_data.get("base_url") or "",
+            proxy_for_auth=str(proxy_for_auth or "").strip(),
+            proxy_for_chat=str(proxy_for_chat or "").strip(),
+            duckmail_base_url=basic_data.get("duckmail_base_url") or "https://api.duckmail.sbs",
+            duckmail_api_key=str(duckmail_api_key_raw or "").strip(),
+            duckmail_verify_ssl=_parse_bool(basic_data.get("duckmail_verify_ssl"), True),
+            temp_mail_provider=basic_data.get("temp_mail_provider") or "moemail",
+            moemail_base_url=basic_data.get("moemail_base_url") or "https://moemail.nanohajimi.mom",
+            moemail_api_key=str(basic_data.get("moemail_api_key") or "").strip(),
+            moemail_domain=str(basic_data.get("moemail_domain") or "").strip(),
+            freemail_base_url=basic_data.get("freemail_base_url") or "http://your-freemail-server.com",
+            freemail_jwt_token=str(basic_data.get("freemail_jwt_token") or "").strip(),
+            freemail_verify_ssl=_parse_bool(basic_data.get("freemail_verify_ssl"), True),
+            freemail_domain=str(basic_data.get("freemail_domain") or "").strip(),
+            mail_proxy_enabled=_parse_bool(basic_data.get("mail_proxy_enabled"), False),
+            gptmail_base_url=str(basic_data.get("gptmail_base_url") or "https://mail.chatgpt.org.uk").strip(),
+            gptmail_api_key=str(basic_data.get("gptmail_api_key") or "").strip(),
+            gptmail_verify_ssl=_parse_bool(basic_data.get("gptmail_verify_ssl"), True),
+            gptmail_domain=str(basic_data.get("gptmail_domain") or "").strip(),
+            cfmail_base_url=str(basic_data.get("cfmail_base_url") or "").strip(),
+            cfmail_api_key=str(basic_data.get("cfmail_api_key") or "").strip(),
+            cfmail_verify_ssl=_parse_bool(basic_data.get("cfmail_verify_ssl"), True),
+            cfmail_domain=str(basic_data.get("cfmail_domain") or "").strip(),
+            browser_engine=basic_data.get("browser_engine") or "dp",
+            browser_headless=_parse_bool(basic_data.get("browser_headless"), False),
+            refresh_window_hours=int(refresh_window_raw),
+            register_default_count=int(register_default_raw),
+            register_domain=str(register_domain_raw or "").strip(),
+            image_expire_hours=int(basic_data.get("image_expire_hours", 12)),
+        )
+
+        # 4. 加载其他配置（从数据库，带容错处理）
+        try:
+            image_generation_config = ImageGenerationConfig(
+                **yaml_data.get("image_generation", {})
+            )
+        except Exception as e:
+            print(f"[WARN] 图片生成配置加载失败，使用默认值: {e}")
+            image_generation_config = ImageGenerationConfig()
+
+        # 加载视频生成配置
+        try:
+            video_generation_config = VideoGenerationConfig(
+                **yaml_data.get("video_generation", {})
+            )
+        except Exception as e:
+            print(f"[WARN] 视频生成配置加载失败，使用默认值: {e}")
+            video_generation_config = VideoGenerationConfig()
+
+        # 加载重试配置（Pydantic 会自动验证范围）
+        try:
+            retry_config = RetryConfig(**yaml_data.get("retry", {}))
+        except Exception as e:
+            print(f"[WARN] 重试配置加载失败，使用默认值: {e}")
+            retry_config = RetryConfig()
+
+        # 加载配额上限配置
+        try:
+            quota_limits_config = QuotaLimitsConfig(**yaml_data.get("quota_limits", {}))
+        except Exception as e:
+            print(f"[WARN] 配额上限配置加载失败，使用默认值: {e}")
+            quota_limits_config = QuotaLimitsConfig()
+
+        try:
+            public_display_config = PublicDisplayConfig(
+                **yaml_data.get("public_display", {})
+            )
+        except Exception as e:
+            print(f"[WARN] 公开展示配置加载失败，使用默认值: {e}")
+            public_display_config = PublicDisplayConfig()
+
+        try:
+            session_config = SessionConfig(
+                **yaml_data.get("session", {})
+            )
+        except Exception as e:
+            print(f"[WARN] Session配置加载失败，使用默认值: {e}")
+            session_config = SessionConfig()
+
+        # 5. 构建完整配置
+        self._config = AppConfig(
+            security=security_config,
+            basic=basic_config,
+            image_generation=image_generation_config,
+            video_generation=video_generation_config,
+            retry=retry_config,
+            quota_limits=quota_limits_config,
+            public_display=public_display_config,
+            session=session_config
+        )
+
+    def _load_yaml(self) -> dict:
+        """从数据库加载配置（允许空配置）。"""
+        if storage.is_database_enabled():
+            try:
+                data = storage.load_settings_sync()
+
+                # 允许空库启动：None 可能是空配置或连接异常
+                if data is None:
+                    print("[WARN] 未读取到 settings（可能为空库或连接异常），将使用默认配置启动")
+                    return {}
+
+                if isinstance(data, dict):
+                    return data
+
+                return {}
+            except RuntimeError:
+                # 重新抛出 RuntimeError
+                raise
+            except Exception as e:
+                print(f"[ERROR] 数据库加载失败: {e}")
+                raise RuntimeError(f"数据库加载失败: {e}")
+
+        print("[ERROR] 未启用数据库")
+        raise RuntimeError("未配置 DATABASE_URL，应用无法启动")
+
+    def _generate_secret(self) -> str:
+        """生成随机密钥"""
+        return secrets.token_urlsafe(32)
+
+    def save_yaml(self, data: dict):
+        """保存配置到数据库（先验证再保存）"""
+        if not storage.is_database_enabled():
+            raise RuntimeError("Database is not enabled")
+
+        # 先验证数据是否符合 Pydantic 模型要求
+        try:
+            # 构建临时配置进行验证
+            security_config = SecurityConfig(
+                admin_key=os.getenv("ADMIN_KEY", ""),
+                session_secret_key=os.getenv("SESSION_SECRET_KEY", self._generate_secret())
+            )
+
+            basic_data = data.get("basic", {})
+            basic_config = BasicConfig(**basic_data)
+
+            image_generation_config = ImageGenerationConfig(
+                **data.get("image_generation", {})
+            )
+
+            video_generation_config = VideoGenerationConfig(
+                **data.get("video_generation", {})
+            )
+
+            retry_config = RetryConfig(**data.get("retry", {}))
+
+            quota_limits_config = QuotaLimitsConfig(**data.get("quota_limits", {}))
+
+            public_display_config = PublicDisplayConfig(
+                **data.get("public_display", {})
+            )
+
+            session_config = SessionConfig(
+                **data.get("session", {})
+            )
+
+            # 验证通过，构建完整配置
+            test_config = AppConfig(
+                security=security_config,
+                basic=basic_config,
+                image_generation=image_generation_config,
+                video_generation=video_generation_config,
+                retry=retry_config,
+                quota_limits=quota_limits_config,
+                public_display=public_display_config,
+                session=session_config
+            )
+        except Exception as e:
+            # 验证失败，不保存到数据库
+            raise ValueError(f"配置验证失败: {str(e)}")
+
+        # 验证通过后才保存到数据库
+        try:
+            saved = storage.save_settings_sync(data)
+            if saved:
+                return
+        except Exception as e:
+            print(f"[WARN] 数据库保存失败: {e}")
+        raise RuntimeError("Database write failed")
+
+    def reload(self):
+        """重新加载配置（热更新）"""
+        self.load()
+
+    @property
+    def config(self) -> AppConfig:
+        """获取配置"""
+        return self._config
+
+    # ==================== 便捷访问属性 ====================
+
+    @property
+    def api_key(self) -> str:
+        """API访问密钥"""
+        return self._config.basic.api_key
+
+    @property
+    def admin_key(self) -> str:
+        """管理员密钥"""
+        return self._config.security.admin_key
+
+    @property
+    def session_secret_key(self) -> str:
+        """Session密钥"""
+        return self._config.security.session_secret_key
+
+    @property
+    def proxy_for_auth(self) -> str:
+        """账户操作代理地址"""
+        return self._config.basic.proxy_for_auth
+
+    @property
+    def proxy_for_chat(self) -> str:
+        """对话操作代理地址"""
+        return self._config.basic.proxy_for_chat
+
+    @property
+    def base_url(self) -> str:
+        """服务器URL"""
+        return self._config.basic.base_url
+
+    @property
+    def logo_url(self) -> str:
+        """Logo URL"""
+        return self._config.public_display.logo_url
+
+    @property
+    def chat_url(self) -> str:
+        """开始对话链接"""
+        return self._config.public_display.chat_url
+
+    @property
+    def image_generation_enabled(self) -> bool:
+        """是否启用图片生成"""
+        return self._config.image_generation.enabled
+
+    @property
+    def image_generation_models(self) -> List[str]:
+        """支持图片生成的模型列表"""
+        return self._config.image_generation.supported_models
+
+    @property
+    def image_output_format(self) -> str:
+        """图片输出格式"""
+        return self._config.image_generation.output_format
+
+    @property
+    def video_output_format(self) -> str:
+        """视频输出格式"""
+        return self._config.video_generation.output_format
+
+    @property
+    def session_expire_hours(self) -> int:
+        """Session过期时间（小时）"""
+        return self._config.session.expire_hours
+
+    @property
+    def max_account_switch_tries(self) -> int:
+        """账户切换尝试次数"""
+        return self._config.retry.max_account_switch_tries
+
+    @property
+    def rate_limit_cooldown_seconds(self) -> int:
+        # 429 cooldown (seconds)
+        if hasattr(self._config.retry, 'text_rate_limit_cooldown_seconds'):
+            return self._config.retry.text_rate_limit_cooldown_seconds
+        return self._config.retry.rate_limit_cooldown_seconds
+
+    @property
+    def text_rate_limit_cooldown_seconds(self) -> int:
+        return self._config.retry.text_rate_limit_cooldown_seconds
+
+    @property
+    def images_rate_limit_cooldown_seconds(self) -> int:
+        return self._config.retry.images_rate_limit_cooldown_seconds
+
+    @property
+    def videos_rate_limit_cooldown_seconds(self) -> int:
+        return self._config.retry.videos_rate_limit_cooldown_seconds
+
+    @property
+    def session_cache_ttl_seconds(self) -> int:
+        # Session cache TTL (seconds)
+        return self._config.retry.session_cache_ttl_seconds
+
+    @property
+    def auto_refresh_accounts_seconds(self) -> int:
+        # Auto refresh accounts interval (seconds)
+        return self._config.retry.auto_refresh_accounts_seconds
+
+
+# ==================== 全局配置管理器 ====================
+
+config_manager = ConfigManager()
+
+# 注意：不要直接引用 config_manager.config，因为 reload() 后引用会失效
+# 应该始终通过 config_manager.config 访问配置
+def get_config() -> AppConfig:
+    """获取当前配置（支持热更新）"""
+    return config_manager.config
+
+# 为了向后兼容，保留 config 变量，但使用属性访问
+class _ConfigProxy:
+    """配置代理，确保始终访问最新配置"""
+    @property
+    def basic(self):
+        return config_manager.config.basic
+
+    @property
+    def security(self):
+        return config_manager.config.security
+
+    @property
+    def image_generation(self):
+        return config_manager.config.image_generation
+
+    @property
+    def video_generation(self):
+        return config_manager.config.video_generation
+
+    @property
+    def retry(self):
+        return config_manager.config.retry
+
+    @property
+    def quota_limits(self):
+        return config_manager.config.quota_limits
+
+    @property
+    def public_display(self):
+        return config_manager.config.public_display
+
+    @property
+    def session(self):
+        return config_manager.config.session
+
+config = _ConfigProxy()

core/database.py

@@ -0,0 +1,191 @@
+"""
+统计数据库操作 - 使用 storage.py 的统一数据库连接
+"""
+import time
+from datetime import datetime
+from typing import Dict, Tuple
+import asyncio
+from collections import defaultdict
+from core.storage import _get_sqlite_conn, _sqlite_lock
+
+
+class StatsDatabase:
+    """统计数据库管理类 - 使用统一的 data.db"""
+
+    async def insert_request_log(
+        self, timestamp: float, model: str, ttfb_ms: int = None,
+        total_ms: int = None, status: str = "success", status_code: int = None
+    ):
+        """插入请求记录"""
+        def _insert():
+            conn = _get_sqlite_conn()
+            with _sqlite_lock:
+                conn.execute(
+                    """
+                    INSERT INTO request_logs
+                    (timestamp, model, ttfb_ms, total_ms, status, status_code)
+                    VALUES (?, ?, ?, ?, ?, ?)
+                    """,
+                    (int(timestamp), model, ttfb_ms, total_ms, status, status_code)
+                )
+                conn.commit()
+
+        await asyncio.to_thread(_insert)
+
+    async def get_stats_by_time_range(self, time_range: str = "24h") -> Dict:
+        """按时间范围获取统计数据"""
+        def _query():
+            now = time.time()
+            if time_range == "24h":
+                start_time = now - 24 * 3600
+                bucket_size = 3600
+            elif time_range == "7d":
+                start_time = now - 7 * 24 * 3600
+                bucket_size = 6 * 3600
+            elif time_range == "30d":
+                start_time = now - 30 * 24 * 3600
+                bucket_size = 24 * 3600
+            else:
+                start_time = now - 24 * 3600
+                bucket_size = 3600
+
+            conn = _get_sqlite_conn()
+            with _sqlite_lock:
+                rows = conn.execute(
+                    """
+                    SELECT timestamp, model, ttfb_ms, total_ms, status, status_code
+                    FROM request_logs
+                    WHERE timestamp >= ?
+                    ORDER BY timestamp
+                    """,
+                    (int(start_time),)
+                ).fetchall()
+
+            # 数据分桶
+            buckets = defaultdict(lambda: {
+                "total": 0, "failed": 0, "rate_limited": 0,
+                "models": defaultdict(int),
+                "model_ttfb": defaultdict(list),
+                "model_total": defaultdict(list)
+            })
+
+            for row in rows:
+                ts, model, ttfb, total, status, status_code = row
+                bucket_key = int((ts - start_time) // bucket_size)
+                bucket = buckets[bucket_key]
+
+                bucket["total"] += 1
+                bucket["models"][model] += 1
+
+                if status != "success":
+                    bucket["failed"] += 1
+                    if status_code == 429:
+                        bucket["rate_limited"] += 1
+
+                if status == "success" and ttfb is not None and total is not None:
+                    bucket["model_ttfb"][model].append(ttfb)
+                    bucket["model_total"][model].append(total)
+
+            # 生成结果
+            num_buckets = int((now - start_time) // bucket_size) + 1
+            labels = []
+            total_requests = []
+            failed_requests = []
+            rate_limited_requests = []
+
+            # 先收集所有出现过的模型
+            all_models = set()
+            for bucket in buckets.values():
+                all_models.update(bucket["models"].keys())
+                all_models.update(bucket["model_ttfb"].keys())
+                all_models.update(bucket["model_total"].keys())
+
+            # 初始化每个模型的数据列表
+            model_requests = {model: [] for model in all_models}
+            model_ttfb_times = {model: [] for model in all_models}
+            model_total_times = {model: [] for model in all_models}
+
+            # 遍历每个时间桶
+            for i in range(num_buckets):
+                bucket_time = start_time + i * bucket_size
+                dt = datetime.fromtimestamp(bucket_time)
+
+                if time_range == "24h":
+                    labels.append(dt.strftime("%H:00"))
+                elif time_range == "7d":
+                    labels.append(dt.strftime("%m-%d %H:00"))
+                else:
+                    labels.append(dt.strftime("%m-%d"))
+
+                bucket = buckets[i]
+                total_requests.append(bucket["total"])
+                failed_requests.append(bucket["failed"])
+                rate_limited_requests.append(bucket["rate_limited"])
+
+                # 为每个模型添加数据（存在则添加实际值，不存在则添加0）
+                for model in all_models:
+                    # 请求数
+                    model_requests[model].append(bucket["models"].get(model, 0))
+
+                    # TTFB平均时间
+                    if model in bucket["model_ttfb"] and bucket["model_ttfb"][model]:
+                        avg_ttfb = sum(bucket["model_ttfb"][model]) / len(bucket["model_ttfb"][model])
+                        model_ttfb_times[model].append(avg_ttfb)
+                    else:
+                        model_ttfb_times[model].append(0)
+
+                    # 总响应平均时间
+                    if model in bucket["model_total"] and bucket["model_total"][model]:
+                        avg_total = sum(bucket["model_total"][model]) / len(bucket["model_total"][model])
+                        model_total_times[model].append(avg_total)
+                    else:
+                        model_total_times[model].append(0)
+
+            # 数据已经是按时间顺序（旧→新），不需要反转
+            # ECharts 从左到右渲染，所以最旧的在左边，最新的在右边
+
+            return {
+                "labels": labels,
+                "total_requests": total_requests,
+                "failed_requests": failed_requests,
+                "rate_limited_requests": rate_limited_requests,
+                "model_requests": dict(model_requests),
+                "model_ttfb_times": dict(model_ttfb_times),
+                "model_total_times": dict(model_total_times)
+            }
+
+        return await asyncio.to_thread(_query)
+
+    async def get_total_counts(self) -> Tuple[int, int]:
+        """获取总成功和失败次数"""
+        def _query():
+            conn = _get_sqlite_conn()
+            with _sqlite_lock:
+                success = conn.execute(
+                    "SELECT COUNT(*) FROM request_logs WHERE status = 'success'"
+                ).fetchone()[0]
+                failed = conn.execute(
+                    "SELECT COUNT(*) FROM request_logs WHERE status != 'success'"
+                ).fetchone()[0]
+            return success, failed
+
+        return await asyncio.to_thread(_query)
+
+    async def cleanup_old_data(self, days: int = 30):
+        """清理过期数据 - 默认保留30天"""
+        def _cleanup():
+            cutoff_time = int(time.time() - days * 24 * 3600)
+            conn = _get_sqlite_conn()
+            with _sqlite_lock:
+                cursor = conn.execute(
+                    "DELETE FROM request_logs WHERE timestamp < ?",
+                    (cutoff_time,)
+                )
+                conn.commit()
+                return cursor.rowcount
+
+        return await asyncio.to_thread(_cleanup)
+
+
+# 全局实例
+stats_db = StatsDatabase()

core/duckmail_client.py

@@ -0,0 +1,304 @@
+import os
+import random
+import string
+import time
+from typing import Optional
+
+import requests
+
+from core.mail_utils import extract_verification_code
+from core.proxy_utils import request_with_proxy_fallback
+
+
+class DuckMailClient:
+    """DuckMail客户端"""
+
+    def __init__(
+        self,
+        base_url: str = "https://api.duckmail.sbs",
+        proxy: str = "",
+        verify_ssl: bool = True,
+        api_key: str = "",
+        log_callback=None,
+    ) -> None:
+        self.base_url = base_url.rstrip("/")
+        self.verify_ssl = verify_ssl
+        self.proxies = {"http": proxy, "https": proxy} if proxy else None
+        self.api_key = api_key.strip()
+        self.log_callback = log_callback
+
+        self.email: Optional[str] = None
+        self.password: Optional[str] = None
+        self.account_id: Optional[str] = None
+        self.token: Optional[str] = None
+
+    def set_credentials(self, email: str, password: str) -> None:
+        self.email = email
+        self.password = password
+
+    def _request(self, method: str, url: str, **kwargs) -> requests.Response:
+        """发送请求并打印详细日志"""
+        headers = kwargs.pop("headers", None) or {}
+        if self.api_key and "Authorization" not in headers:
+            headers["Authorization"] = f"Bearer {self.api_key}"
+        kwargs["headers"] = headers
+        self._log("info", f"📤 发送 {method} 请求: {url}")
+        if "json" in kwargs:
+            self._log("info", f"📦 请求体: {kwargs['json']}")
+
+        try:
+            res = request_with_proxy_fallback(
+                requests.request,
+                method,
+                url,
+                proxies=self.proxies,
+                verify=self.verify_ssl,
+                timeout=kwargs.pop("timeout", 15),
+                **kwargs,
+            )
+            self._log("info", f"📥 收到响应: HTTP {res.status_code}")
+            log_body = os.getenv("DUCKMAIL_LOG_BODY", "").strip().lower() in ("1", "true", "yes", "y", "on")
+            if res.content and (log_body or res.status_code >= 400):
+                try:
+                    self._log("info", f"📄 响应内容: {res.text[:500]}")
+                except Exception:
+                    pass
+            return res
+        except Exception as e:
+            self._log("error", f"❌ 网络请求失败: {e}")
+            raise
+
+    def register_account(self, domain: Optional[str] = None) -> bool:
+        """注册新邮箱账号"""
+        # 获取域名
+        if not domain:
+            self._log("info", "🔍 正在获取可用域名...")
+            domain = self._get_domain()
+        self._log("info", f"📧 使用域名: {domain}")
+
+        # 生成随机邮箱和密码
+        rand = "".join(random.choices(string.ascii_lowercase + string.digits, k=10))
+        timestamp = str(int(time.time()))[-4:]
+        self.email = f"t{timestamp}{rand}@{domain}"
+        self.password = f"Pwd{rand}{timestamp}"
+        self._log("info", f"🎲 生成邮箱: {self.email}")
+        self._log("info", f"🔑 生成密码: {self.password}")
+
+        try:
+            self._log("info", "📤 正在向 DuckMail 发送注册请求...")
+            res = self._request(
+                "POST",
+                f"{self.base_url}/accounts",
+                json={"address": self.email, "password": self.password},
+            )
+            if res.status_code in (200, 201):
+                data = res.json() if res.content else {}
+                self.account_id = data.get("id")
+                self._log("info", f"✅ DuckMail 注册成功，账户ID: {self.account_id}")
+                return True
+            else:
+                self._log("error", f"❌ DuckMail 注册失败: HTTP {res.status_code}")
+        except Exception as e:
+            self._log("error", f"❌ DuckMail 注册异常: {e}")
+            return False
+
+        self._log("error", "❌ DuckMail 注册失败")
+        return False
+
+    def login(self) -> bool:
+        """登录获取token"""
+        if not self.email or not self.password:
+            self._log("error", "❌ 邮箱或密码未设置")
+            return False
+
+        try:
+            self._log("info", f"🔐 正在登录 DuckMail: {self.email}")
+            res = self._request(
+                "POST",
+                f"{self.base_url}/token",
+                json={"address": self.email, "password": self.password},
+            )
+            if res.status_code == 200:
+                data = res.json() if res.content else {}
+                token = data.get("token")
+                if token:
+                    self.token = token
+                    self._log("info", f"✅ DuckMail 登录成功，Token: {token[:20]}...")
+                    return True
+                else:
+                    self._log("error", "❌ 响应中未找到 Token")
+            else:
+                self._log("error", f"❌ DuckMail 登录失败: HTTP {res.status_code}")
+        except Exception as e:
+            self._log("error", f"❌ DuckMail 登录异常: {e}")
+            return False
+
+        self._log("error", "❌ DuckMail 登录失败")
+        return False
+
+    def fetch_verification_code(self, since_time=None) -> Optional[str]:
+        """获取验证码"""
+        if not self.token:
+            self._log("info", "🔐 Token 不存在，尝试重新登录...")
+            if not self.login():
+                self._log("error", "❌ 登录失败，无法获取验证码")
+                return None
+
+        try:
+            self._log("info", "📬 正在拉取邮件列表...")
+            # 获取邮件列表
+            res = self._request(
+                "GET",
+                f"{self.base_url}/messages",
+                headers={"Authorization": f"Bearer {self.token}"},
+            )
+
+            if res.status_code != 200:
+                self._log("error", f"❌ 获取邮件列表失败: HTTP {res.status_code}")
+                return None
+
+            data = res.json() if res.content else {}
+            messages = data.get("hydra:member", [])
+
+            if not messages:
+                self._log("info", "📭 邮箱为空，暂无邮件")
+                return None
+
+            self._log("info", f"📨 收到 {len(messages)} 封邮件，开始检查验证码...")
+
+            from datetime import datetime
+            import re
+
+            def _parse_message_time(msg_obj) -> Optional[datetime]:
+                created_at = msg_obj.get("createdAt")
+                if created_at is None:
+                    return None
+
+                if isinstance(created_at, (int, float)):
+                    timestamp = float(created_at)
+                    if timestamp > 1e12:
+                        timestamp = timestamp / 1000.0
+                    return datetime.fromtimestamp(timestamp).astimezone().replace(tzinfo=None)
+
+                if isinstance(created_at, str):
+                    raw = created_at.strip()
+                    if not raw:
+                        return None
+                    if raw.isdigit():
+                        timestamp = float(raw)
+                        if timestamp > 1e12:
+                            timestamp = timestamp / 1000.0
+                        return datetime.fromtimestamp(timestamp).astimezone().replace(tzinfo=None)
+
+                    # 截断纳秒到微秒（fromisoformat 只支持6位小数）
+                    raw = re.sub(r"(\.\d{6})\d+", r"\1", raw)
+                    return datetime.fromisoformat(raw.replace("Z", "+00:00")).astimezone().replace(tzinfo=None)
+
+                return None
+
+            # 按时间倒序，优先检查最新邮件
+            messages_with_time = [(msg, _parse_message_time(msg)) for msg in messages]
+            if any(item[1] is not None for item in messages_with_time):
+                messages_with_time.sort(key=lambda item: item[1] or datetime.min, reverse=True)
+                messages = [item[0] for item in messages_with_time]
+
+            # 遍历邮件，过滤时间
+            for idx, msg in enumerate(messages, 1):
+                msg_id = msg.get("id")
+                if not msg_id:
+                    continue
+
+                # 时间过滤
+                if since_time:
+                    msg_time = _parse_message_time(msg)
+                    if msg_time and msg_time < since_time:
+                        continue
+
+                self._log("info", f"🔍 正在读取邮件 {idx}/{len(messages)} (ID: {msg_id[:10]}...)")
+                detail = self._request(
+                    "GET",
+                    f"{self.base_url}/messages/{msg_id}",
+                    headers={"Authorization": f"Bearer {self.token}"},
+                )
+
+                if detail.status_code != 200:
+                    self._log("warning", f"⚠️ 读取邮件详情失败: HTTP {detail.status_code}")
+                    continue
+
+                payload = detail.json() if detail.content else {}
+
+                # 获取邮件内容
+                text_content = payload.get("text") or ""
+                html_content = payload.get("html") or ""
+
+                if isinstance(html_content, list):
+                    html_content = "".join(str(item) for item in html_content)
+                if isinstance(text_content, list):
+                    text_content = "".join(str(item) for item in text_content)
+
+                content = text_content + html_content
+                self._log("info", f"📄 邮件内容预览: {content[:200]}...")
+
+                code = extract_verification_code(content)
+                if code:
+                    self._log("info", f"✅ 找到验证码: {code}")
+                    return code
+                else:
+                    self._log("info", f"❌ 邮件 {idx} 中未找到验证码")
+
+            self._log("warning", "⚠️ 所有邮件中均未找到验证码")
+            return None
+
+        except Exception as e:
+            self._log("error", f"❌ 获取验证码异常: {e}")
+            return None
+
+    def poll_for_code(
+        self,
+        timeout: int = 120,
+        interval: int = 4,
+        since_time=None,
+    ) -> Optional[str]:
+        """轮询获取验证码"""
+        if not self.token:
+            self._log("info", "🔐 Token 不存在，尝试登录...")
+            if not self.login():
+                self._log("error", "❌ 登录失败，无法轮询验证码")
+                return None
+
+        max_retries = max(1, timeout // interval)
+        self._log("info", f"⏱️ 开始轮询验证码 (超时 {timeout}秒, 间隔 {interval}秒, 最多 {max_retries} 次)")
+
+        for i in range(1, max_retries + 1):
+            self._log("info", f"🔄 第 {i}/{max_retries} 次轮询...")
+            code = self.fetch_verification_code(since_time=since_time)
+            if code:
+                self._log("info", f"🎉 验证码获取成功: {code}")
+                return code
+
+            if i < max_retries:
+                self._log("info", f"⏳ 等待 {interval} 秒后重试...")
+                time.sleep(interval)
+
+        self._log("error", f"⏰ 验证码获取超时 ({timeout}秒)")
+        return None
+
+    def _get_domain(self) -> str:
+        """获取可用域名"""
+        try:
+            res = self._request("GET", f"{self.base_url}/domains")
+            if res.status_code == 200:
+                data = res.json() if res.content else {}
+                members = data.get("hydra:member", [])
+                if members:
+                    return members[0].get("domain") or "duck.com"
+        except Exception:
+            pass
+        return "duck.com"
+
+    def _log(self, level: str, message: str) -> None:
+        if self.log_callback:
+            try:
+                self.log_callback(level, message)
+            except Exception:
+                pass

core/freemail_client.py

@@ -0,0 +1,325 @@
+import random
+import string
+import time
+from typing import Optional
+
+import requests
+
+from core.mail_utils import extract_verification_code
+from core.proxy_utils import request_with_proxy_fallback
+
+
+class FreemailClient:
+    """Freemail 临时邮箱客户端"""
+
+    def __init__(
+        self,
+        base_url: str = "http://your-freemail-server.com",
+        jwt_token: str = "",
+        proxy: str = "",
+        verify_ssl: bool = True,
+        log_callback=None,
+    ) -> None:
+        self.base_url = base_url.rstrip("/")
+        self.jwt_token = jwt_token.strip()
+        self.verify_ssl = verify_ssl
+        self.proxies = {"http": proxy, "https": proxy} if proxy else None
+        self.log_callback = log_callback
+
+        self.email: Optional[str] = None
+
+    def set_credentials(self, email: str, password: str = None) -> None:
+        """设置邮箱凭证（Freemail 不需要密码）"""
+        self.email = email
+
+    def _request(self, method: str, url: str, **kwargs) -> requests.Response:
+        """发送请求并打印日志"""
+        self._log("info", f"📤 发送 {method} 请求: {url}")
+        if "params" in kwargs:
+            self._log("info", f"🔎 参数: {kwargs['params']}")
+
+        try:
+            res = request_with_proxy_fallback(
+                requests.request,
+                method,
+                url,
+                proxies=self.proxies,
+                verify=self.verify_ssl,
+                timeout=kwargs.pop("timeout", 15),
+                **kwargs,
+            )
+            self._log("info", f"📥 收到响应: HTTP {res.status_code}")
+            if res.status_code >= 400:
+                try:
+                    self._log("error", f"📄 响应内容: {res.text[:500]}")
+                except Exception:
+                    pass
+            return res
+        except Exception as e:
+            self._log("error", f"❌ 网络请求失败: {e}")
+            raise
+
+    def register_account(self, domain: Optional[str] = None) -> bool:
+        """创建新的临时邮箱"""
+        try:
+            params = {"admin_token": self.jwt_token}
+            if domain:
+                params["domain"] = domain
+                self._log("info", f"📧 使用域名: {domain}")
+            else:
+                self._log("info", "🔍 自动选择域名...")
+
+            res = self._request(
+                "POST",
+                f"{self.base_url}/api/generate",
+                params=params,
+            )
+
+            if res.status_code in (200, 201):
+                data = res.json() if res.content else {}
+                # Freemail API 返回的字段是 "email" 或 "mailbox"
+                email = data.get("email") or data.get("mailbox")
+                if email:
+                    self.email = email
+                    self._log("info", f"✅ Freemail 邮箱创建成功: {self.email}")
+                    return True
+                else:
+                    self._log("error", "❌ 响应中缺少 email 字段")
+                    return False
+            elif res.status_code in (401, 403):
+                self._log("error", "❌ Freemail 认证失败 (JWT Token 无效)")
+                return False
+            else:
+                self._log("error", f"❌ Freemail 创建失败: HTTP {res.status_code}")
+                return False
+
+        except Exception as e:
+            self._log("error", f"❌ Freemail 注册异常: {e}")
+            return False
+
+    def login(self) -> bool:
+        """登录（Freemail 不需要登录，直接返回 True）"""
+        return True
+
+    def fetch_verification_code(self, since_time=None) -> Optional[str]:
+        """获取验证码"""
+        if not self.email:
+            self._log("error", "❌ 邮箱地址未设置")
+            return None
+
+        try:
+            self._log("info", "📬 正在拉取 Freemail 邮件列表...")
+            params = {
+                "mailbox": self.email,
+                "admin_token": self.jwt_token,
+            }
+
+            res = self._request(
+                "GET",
+                f"{self.base_url}/api/emails",
+                params=params,
+            )
+
+            if res.status_code == 401 or res.status_code == 403:
+                self._log("error", "❌ Freemail 认证失败")
+                return None
+
+            if res.status_code != 200:
+                self._log("error", f"❌ 获取邮件列表失败: HTTP {res.status_code}")
+                return None
+
+            emails = res.json() if res.content else []
+            if not isinstance(emails, list):
+                self._log("error", "❌ 响应格式错误（不是列表）")
+                return None
+
+            if not emails:
+                self._log("info", "📭 邮箱为空，暂无邮件")
+                return None
+
+            self._log("info", f"📨 收到 {len(emails)} 封邮件，开始检查验证码...")
+
+            from datetime import datetime, timezone
+            import re
+
+            def _parse_email_time(email_obj) -> Optional[datetime]:
+                time_keys = (
+                    "created_at",
+                    "createdAt",
+                    "received_at",
+                    "receivedAt",
+                    "sent_at",
+                    "sentAt",
+                )
+
+                raw_time = None
+                for key in time_keys:
+                    if email_obj.get(key) is not None:
+                        raw_time = email_obj.get(key)
+                        break
+
+                if raw_time is None:
+                    return None
+
+                if isinstance(raw_time, (int, float)):
+                    timestamp = float(raw_time)
+                    if timestamp > 1e12:
+                        timestamp = timestamp / 1000.0
+                    return datetime.fromtimestamp(timestamp).astimezone().replace(tzinfo=None)
+
+                if isinstance(raw_time, str):
+                    raw = raw_time.strip()
+                    if not raw:
+                        return None
+                    if raw.isdigit():
+                        timestamp = float(raw)
+                        if timestamp > 1e12:
+                            timestamp = timestamp / 1000.0
+                        return datetime.fromtimestamp(timestamp).astimezone().replace(tzinfo=None)
+
+                    # 截断纳秒到微秒（fromisoformat 只支持6位小数）
+                    raw = re.sub(r"(\.\d{6})\d+", r"\1", raw)
+
+                    try:
+                        parsed = datetime.fromisoformat(raw.replace("Z", "+00:00"))
+                        if parsed.tzinfo:
+                            return parsed.astimezone().replace(tzinfo=None)
+                        return parsed.replace(tzinfo=timezone.utc).astimezone().replace(tzinfo=None)
+                    except Exception:
+                        return None
+
+                return None
+
+            # 按时间倒序，优先检查最新邮件
+            emails_with_time = [(email_item, _parse_email_time(email_item)) for email_item in emails]
+            if any(item[1] is not None for item in emails_with_time):
+                emails_with_time.sort(key=lambda item: item[1] or datetime.min, reverse=True)
+                emails = [item[0] for item in emails_with_time]
+
+            skipped_no_time_indexes = []
+            skipped_expired_indexes = []
+
+            def _format_indexes(indexes: list[int]) -> str:
+                if len(indexes) <= 10:
+                    return ",".join(str(index) for index in indexes)
+                preview = ",".join(str(index) for index in indexes[:10])
+                return f"{preview}...(+{len(indexes) - 10})"
+
+            def _log_skip_summary() -> None:
+                if skipped_no_time_indexes:
+                    self._log(
+                        "info",
+                        f"⏭️ 已跳过 {len(skipped_no_time_indexes)} 封缺少可解析时间的邮件"
+                        f"（序号: {_format_indexes(skipped_no_time_indexes)}）",
+                    )
+                if skipped_expired_indexes:
+                    self._log(
+                        "info",
+                        f"⏭️ 已跳过 {len(skipped_expired_indexes)} 封过期邮件"
+                        f"（序号: {_format_indexes(skipped_expired_indexes)}）",
+                    )
+
+            # 从最新一封邮件开始查找
+            for idx, email_data in enumerate(emails, 1):
+                # 时间过滤
+                if since_time:
+                    email_time = _parse_email_time(email_data)
+                    if email_time is None:
+                        skipped_no_time_indexes.append(idx)
+                        continue
+                    if email_time < since_time:
+                        skipped_expired_indexes.append(idx)
+                        continue
+
+                # 获取邮件完整内容
+                email_id = email_data.get("id")
+                if email_id:
+                    # 调用详情接口获取完整内容
+                    detail_res = self._request(
+                        "GET",
+                        f"{self.base_url}/api/email/{email_id}",
+                        params={"admin_token": self.jwt_token},
+                    )
+                    if detail_res.status_code == 200:
+                        detail_data = detail_res.json()
+                        content = detail_data.get("content") or ""
+                        html_content = detail_data.get("html_content") or ""
+                    else:
+                        # 降级：如果详情接口失败，使用列表中的字段
+                        content = email_data.get("content") or ""
+                        html_content = email_data.get("html_content") or ""
+                        preview = email_data.get("preview") or ""
+                        content = content + " " + preview
+                else:
+                    # 降级：没有 ID，使用列表中的字���
+                    content = email_data.get("content") or ""
+                    html_content = email_data.get("html_content") or ""
+                    preview = email_data.get("preview") or ""
+                    content = content + " " + preview
+
+                subject = email_data.get("subject") or ""
+                full_content = subject + " " + content + " " + html_content
+                code = extract_verification_code(full_content)
+                if code:
+                    _log_skip_summary()
+                    self._log("info", f"✅ 找到验证码: {code}")
+                    return code
+                else:
+                    self._log("info", f"❌ 邮件 {idx} 中未找到验证码")
+
+            _log_skip_summary()
+            self._log("warning", "⚠️ 所有邮件中均未找到验证码")
+            return None
+
+        except Exception as e:
+            self._log("error", f"❌ 获取验证码异常: {e}")
+            return None
+
+    def poll_for_code(
+        self,
+        timeout: int = 120,
+        interval: int = 4,
+        since_time=None,
+    ) -> Optional[str]:
+        """轮询获取验证码"""
+        max_retries = max(1, timeout // interval)
+        self._log("info", f"⏱️ 开始轮询验证码 (超时 {timeout}秒, 间隔 {interval}秒, 最多 {max_retries} 次)")
+
+        for i in range(1, max_retries + 1):
+            self._log("info", f"🔄 第 {i}/{max_retries} 次轮询...")
+            code = self.fetch_verification_code(since_time=since_time)
+            if code:
+                self._log("info", f"🎉 验证码获取成功: {code}")
+                return code
+
+            if i < max_retries:
+                self._log("info", f"⏳ 等待 {interval} 秒后重试...")
+                time.sleep(interval)
+
+        self._log("error", f"⏰ 验证码获取超时 ({timeout}秒)")
+        return None
+
+    def _get_domain(self) -> str:
+        """获取可用域名"""
+        try:
+            params = {"admin_token": self.jwt_token}
+            res = self._request(
+                "GET",
+                f"{self.base_url}/api/domains",
+                params=params,
+            )
+            if res.status_code == 200:
+                domains = res.json() if res.content else []
+                if isinstance(domains, list) and domains:
+                    return domains[0]
+        except Exception:
+            pass
+        return ""
+
+    def _log(self, level: str, message: str) -> None:
+        """日志回调"""
+        if self.log_callback:
+            try:
+                self.log_callback(level, message)
+            except Exception:
+                pass

core/gemini_automation.py

@@ -0,0 +1,1103 @@
+"""
+Gemini自动化登录模块（用于新账号注册）
+"""
+import os
+import json
+import random
+import re
+import string
+import time
+from datetime import datetime, timedelta, timezone
+from typing import Optional
+from urllib.parse import quote
+
+from DrissionPage import ChromiumPage, ChromiumOptions
+from core.base_task_service import TaskCancelledError
+
+
+# 常量
+AUTH_HOME_URL = "https://auth.business.gemini.google/login"
+
+# Linux 下常见的 Chromium 路径
+CHROMIUM_PATHS = [
+    "/usr/bin/chromium",
+    "/usr/bin/chromium-browser",
+    "/usr/bin/google-chrome",
+    "/usr/bin/google-chrome-stable",
+]
+
+# 注册时随机使用的真实英文姓名（避免明显的机器人特征）
+REGISTER_NAMES = [
+    "James Smith", "John Johnson", "Robert Williams", "Michael Brown", "William Jones",
+    "David Garcia", "Mary Miller", "Patricia Davis", "Jennifer Rodriguez", "Linda Martinez",
+    "Barbara Anderson", "Susan Thomas", "Jessica Jackson", "Sarah White", "Karen Harris",
+    "Lisa Martin", "Nancy Thompson", "Betty Garcia", "Margaret Martinez", "Sandra Robinson",
+    "Ashley Clark", "Dorothy Rodriguez", "Emma Lewis", "Olivia Lee", "Ava Walker",
+    "Emily Hall", "Abigail Allen", "Madison Young", "Elizabeth Hernandez", "Charlotte King",
+]
+
+# 常见桌面分辨率（避免固定 1280x800 成为指纹）
+COMMON_VIEWPORTS = [
+    (1366, 768), (1440, 900), (1536, 864), (1280, 720),
+    (1920, 1080), (1600, 900), (1280, 800), (1360, 768),
+]
+
+
+def _find_chromium_path() -> Optional[str]:
+    """查找可用的 Chromium/Chrome 浏览器路径"""
+    for path in CHROMIUM_PATHS:
+        if os.path.isfile(path) and os.access(path, os.X_OK):
+            return path
+    return None
+
+
+class GeminiAutomation:
+    """Gemini自动化登录"""
+
+    def __init__(
+        self,
+        user_agent: str = "",
+        proxy: str = "",
+        headless: bool = True,
+        timeout: int = 60,
+        log_callback=None,
+    ) -> None:
+        self.user_agent = user_agent or self._get_ua()
+        self.proxy = proxy
+        self.headless = headless
+        self.timeout = timeout
+        self.log_callback = log_callback
+        self._page = None
+        self._user_data_dir = None
+        self._last_send_error = ""
+
+    def stop(self) -> None:
+        """外部请求停止：尽力关闭浏览器实例。"""
+        page = self._page
+        if page:
+            try:
+                page.quit()
+            except Exception:
+                pass
+
+    def login_and_extract(self, email: str, mail_client, is_new_account: bool = False) -> dict:
+        """执行登录并提取配置"""
+        page = None
+        user_data_dir = None
+        try:
+            page = self._create_page()
+            user_data_dir = getattr(page, 'user_data_dir', None)
+            self._page = page
+            self._user_data_dir = user_data_dir
+            return self._run_flow(page, email, mail_client, is_new_account=is_new_account)
+        except TaskCancelledError:
+            raise
+        except Exception as exc:
+            self._log("error", f"automation error: {exc}")
+            return {"success": False, "error": str(exc)}
+        finally:
+            if page:
+                try:
+                    page.quit()
+                except Exception:
+                    pass
+            self._page = None
+            self._cleanup_user_data(user_data_dir)
+            self._user_data_dir = None
+
+    def _create_page(self) -> ChromiumPage:
+        """创建浏览器页面"""
+        options = ChromiumOptions()
+
+        # 自动检测 Chromium 浏览器路径（Linux/Docker 环境）
+        chromium_path = _find_chromium_path()
+        if chromium_path:
+            options.set_browser_path(chromium_path)
+
+        options.set_argument("--incognito")
+        options.set_argument("--no-sandbox")
+        options.set_argument("--disable-dev-shm-usage")
+        options.set_argument("--disable-setuid-sandbox")
+        options.set_argument("--disable-blink-features=AutomationControlled")
+
+        # 随机窗口尺寸（避免固定分辨率成为指纹）
+        vw, vh = random.choice(COMMON_VIEWPORTS)
+        options.set_argument(f"--window-size={vw},{vh}")
+        options.set_user_agent(self.user_agent)
+
+        # 防止 WebRTC 泄露真实 IP（即使使用代理也可能暴露）
+        options.set_argument("--disable-webrtc")
+        options.set_argument("--enforce-webrtc-ip-handling-policy")
+        options.set_pref("webrtc.ip_handling_policy", "disable_non_proxied_udp")
+        options.set_pref("webrtc.multiple_routes_enabled", False)
+        options.set_pref("webrtc.nonproxied_udp_enabled", False)
+
+        # 语言设置（确保使用中文界面）
+        options.set_argument("--lang=zh-CN")
+        options.set_pref("intl.accept_languages", "zh-CN,zh")
+
+        if self.proxy:
+            options.set_argument(f"--proxy-server={self.proxy}")
+
+        if self.headless:
+            # 使用新版无头模式，更接近��实浏览器
+            options.set_argument("--headless=new")
+            options.set_argument("--disable-gpu")
+            options.set_argument("--no-first-run")
+            options.set_argument("--disable-extensions")
+            # 反检测参数
+            options.set_argument("--disable-infobars")
+            options.set_argument("--enable-features=NetworkService,NetworkServiceInProcess")
+
+
+
+        options.auto_port()
+        page = ChromiumPage(options)
+        page.set.timeouts(self.timeout)
+
+        # 最小化 JS 注入：只设置 window.chrome（不使用 Object.defineProperty，避免被 reCAPTCHA 检测）
+        # 注意：DrissionPage 不像 Selenium 那样暴露 navigator.webdriver，无需额外隐藏
+        try:
+            page.run_cdp("Page.addScriptToEvaluateOnNewDocument", source="""
+                // 确保 window.chrome 存在（headless 模式下可能缺失）
+                if (!window.chrome) {
+                    window.chrome = {runtime: {}, loadTimes: function(){return {}}, csi: function(){return {}}};
+                }
+            """)
+        except Exception:
+            pass
+
+        return page
+
+    def _extract_xsrf_token(self, page) -> str:
+        """从页面中提取真实的 XSRF Token（避免硬编码被标黑）"""
+        try:
+            html = page.html or ""
+            # 尝试从 meta 标签提取
+            m = re.search(r'name=["\']xsrf-token["\']\s+content=["\']([^"\']+)["\']', html, re.IGNORECASE)
+            if m:
+                self._log("info", "🔑 从 meta 标签提取到 XSRF token")
+                return m.group(1)
+            # 尝试从隐藏 input 提取
+            m = re.search(r'name=["\']xsrfToken["\'][^>]*value=["\']([A-Za-z0-9_-]{20,})["\']', html)
+            if m:
+                self._log("info", "🔑 从 input 提取到 XSRF token")
+                return m.group(1)
+            # 尝试从 JS 变量提取
+            m = re.search(r'xsrfToken["\']?\s*[=:]\s*["\']([A-Za-z0-9_-]{20,})["\']', html)
+            if m:
+                self._log("info", "🔑 从 JS 提取到 XSRF token")
+                return m.group(1)
+            # 尝试从 URL 参数提取
+            m = re.search(r'xsrfToken=([A-Za-z0-9_-]{20,})', html)
+            if m:
+                self._log("info", "🔑 从 URL 参数提取到 XSRF token")
+                return m.group(1)
+        except Exception as e:
+            self._log("warning", f"⚠️ XSRF token 提取异常: {e}")
+        self._log("warning", "⚠️ 未能从页面提取 XSRF token，使用备用值")
+        return "GXO_B0wnNhs6UQJZMcrSbTsbEEs"
+
+    def _run_flow(self, page, email: str, mail_client, is_new_account: bool = False) -> dict:
+        """执行登录流程（is_new_account=True 时启用注册专用的增强用户名处理）"""
+
+        # 记录任务开始时间，用于邮件时间过滤（全流程固定，不随重发更新）
+        from datetime import datetime
+        task_start_time = datetime.now()
+
+        # Step 1: 导航到登录页面
+        self._log("info", f"🌐 打开登录页面: {email}")
+        page.get(AUTH_HOME_URL, timeout=self.timeout)
+        time.sleep(random.uniform(2, 4))
+
+        # 从页面动态提取 XSRF token（避免硬编码被 Google 标黑）
+        xsrf_token = self._extract_xsrf_token(page)
+
+        # 设置 XSRF Cookie
+        try:
+            self._log("info", "🍪 设置 XSRF Cookie...")
+            page.set.cookies({
+                "name": "__Host-AP_SignInXsrf",
+                "value": xsrf_token,
+                "url": AUTH_HOME_URL,
+                "path": "/",
+                "secure": True,
+            })
+        except Exception as e:
+            self._log("warning", f"⚠️ Cookie 设置失败: {e}")
+
+        # Step 1.5: 通过 URL 方式提交邮箱（稳定，不触发风控）
+        login_hint = quote(email, safe="")
+        login_url = f"https://auth.business.gemini.google/login/email?continueUrl=https%3A%2F%2Fbusiness.gemini.google%2F&loginHint={login_hint}&xsrfToken={xsrf_token}"
+
+        # 先启动网络监听，再导航（避免漏掉页面加载期间的请求）
+        try:
+            page.listen.start(
+                targets=["batchexecute"],
+                is_regex=False,
+                method=("POST",),
+                res_type=("XHR", "FETCH"),
+            )
+        except Exception:
+            pass
+
+        self._log("info", "📧 使用 URL 方式提交邮箱...")
+        page.get(login_url, timeout=self.timeout)
+        time.sleep(random.uniform(3, 5))
+
+        # 模拟真实用户行为：页面加载后随机滚动
+        self._random_scroll(page)
+
+        # Step 2: 检查当前页面状态
+        current_url = page.url
+        self._log("info", f"📍 当前 URL: {current_url}")
+
+        # 检测 signin-error 页面（极端情况，一般 URL 方式不会触发）
+        if "signin-error" in current_url:
+            self._log("error", "❌ 进入 signin-error 页面，可能是代理���网络问题")
+            self._save_screenshot(page, "signin_error")
+            return {"success": False, "error": "signin-error: token rejected by Google, try changing proxy"}
+
+        has_business_params = "business.gemini.google" in current_url and "csesidx=" in current_url and "/cid/" in current_url
+
+        if has_business_params:
+            self._log("info", "✅ 已登录，提取配置")
+            return self._extract_config(page, email)
+
+        # 检测 403 Access Restricted（刷新/登录时账户可能已被封禁）
+        access_error = self._check_access_restricted(page, email)
+        if access_error:
+            return access_error
+
+        # Step 3: 点击发送验证码按钮（最多5轮，适度退避间隔）
+        self._log("info", "📧 发送验证码...")
+        max_send_rounds = 5
+        send_round_delays = [10, 10, 15, 15, 20]
+        send_round = 0
+        while True:
+            send_round += 1
+            if self._click_send_code_button(page):
+                break
+            if send_round >= max_send_rounds:
+                self._log("error", "❌ 验证码发送失败（可能触发风控），建议更换代理IP")
+                self._save_screenshot(page, "send_code_button_failed")
+                return {"success": False, "error": "send code failed after retries"}
+            delay = send_round_delays[min(send_round - 1, len(send_round_delays) - 1)]
+            self._log("warning", f"⚠️ 发送失败，{delay}秒后重试 ({send_round}/{max_send_rounds})")
+            time.sleep(delay)
+
+        # Step 4: 等待验证码输入框出现
+        code_input = self._wait_for_code_input(page)
+        if not code_input:
+            self._log("error", "❌ 验证码输入框未出现")
+            self._save_screenshot(page, "code_input_missing")
+            return {"success": False, "error": "code input not found"}
+
+        # Step 5: 轮询邮件获取验证码（3次，每次5秒间隔）
+        self._log("info", "📬 等待邮箱验证码...")
+        code = mail_client.poll_for_code(timeout=15, interval=5, since_time=task_start_time)
+
+        if not code:
+            self._log("warning", "⚠️ 验证码超时，等待后重新发送...")
+            time.sleep(random.uniform(12, 18))
+            # 尝试点击重新发送按钮
+            if self._click_resend_code_button(page):
+                # 再次轮询验证码（3次，每次5秒间隔）
+                code = mail_client.poll_for_code(timeout=15, interval=5, since_time=task_start_time)
+                if not code:
+                    self._log("error", "❌ 重新发送后仍未收到验证码")
+                    self._save_screenshot(page, "code_timeout_after_resend")
+                    return {"success": False, "error": "verification code timeout after resend"}
+            else:
+                self._log("error", "❌ 验证码超时且未找到重新发送按钮")
+                self._save_screenshot(page, "code_timeout")
+                return {"success": False, "error": "verification code timeout"}
+
+        self._log("info", f"✅ 收到验证码: {code}")
+
+        # Step 6: 输入验证码并提交
+        code_input = page.ele("css:input[jsname='ovqh0b']", timeout=3) or \
+                     page.ele("css:input[type='tel']", timeout=2)
+
+        if not code_input:
+            self._log("error", "❌ 验证码输入框已失效")
+            return {"success": False, "error": "code input expired"}
+
+        # 尝试模拟人类输入，失败则降级到直接注入
+        self._log("info", "⌨️ 输入验证码...")
+        if not self._simulate_human_input(code_input, code):
+            self._log("warning", "⚠️ 模拟输入失败，降级为直接输入")
+            code_input.input(code, clear=True)
+            time.sleep(random.uniform(0.4, 0.8))
+
+        # 提交验证码：先回车，再找验证按钮兜底
+        self._log("info", "⏎ 提交验证码")
+        code_input.input("\n")
+        time.sleep(random.uniform(1, 2))
+        # 如果回车没触发，找验证按钮点击
+        if "verify-oob-code" in page.url:
+            verify_btn = self._find_verify_button(page)
+            if verify_btn:
+                try:
+                    verify_btn.click()
+                    self._log("info", "✅ 已点击验证按钮（兜底）")
+                except Exception:
+                    pass
+
+        # [注册专用] 验证码提交后先等几秒让页面跳转，再检查 403
+        if is_new_account:
+            time.sleep(3)
+            access_error = self._check_access_restricted(page, email)
+            if access_error:
+                return access_error
+            self._log("info", "📝 [注册] 验证码已提交，等待姓名输入页面...")
+            if self._handle_username_setup(page, is_new_account=True):
+                self._log("info", "✅ 姓名填写完成，等待工作台 URL...")
+                if self._wait_for_business_params(page, timeout=45):
+                    self._log("info", "🎊 注册成功，提取配置...")
+                    return self._extract_config(page, email)
+            # 姓名步骤失败或未出现，继续走通用流程兜底
+            self._log("info", "⚠️ 姓名步骤未完成，走通用流程兜底...")
+
+        # Step 7: 等待页面自动重定向（提交验证码后 Google 会自动跳转）
+        self._log("info", "⏳ 等待验证后跳转...")
+        time.sleep(random.uniform(10, 15))
+
+        # 记录当前 URL 状态
+        current_url = page.url
+        self._log("info", f"📍 验证后 URL: {current_url}")
+
+        # 检查是否还停留在验证码页面（说明提交失败）
+        if "verify-oob-code" in current_url:
+            self._log("error", "❌ 验证码提交失败")
+            self._save_screenshot(page, "verification_submit_failed")
+            return {"success": False, "error": "verification code submission failed"}
+
+        # Step 8: 处理协议页面（如果有）
+        self._handle_agreement_page(page)
+
+        # Step 8.5: 检测 403 Access Restricted 页面
+        access_error = self._check_access_restricted(page, email)
+        if access_error:
+            return access_error
+
+        # Step 9: 检查是否已经在正确的页面
+        current_url = page.url
+        has_business_params = "business.gemini.google" in current_url and "csesidx=" in current_url and "/cid/" in current_url
+
+        if has_business_params:
+            return self._extract_config(page, email)
+
+        # Step 10: 如果不在正确的页面，尝试导航
+        if "business.gemini.google" not in current_url:
+            page.get("https://business.gemini.google/", timeout=self.timeout)
+            time.sleep(random.uniform(4, 7))
+
+        # Step 11: 检查是否需要设置用户名（仅登录刷新走此路径，注册已在早期处理）
+        if not is_new_account and "cid" not in page.url:
+            if self._handle_username_setup(page):
+                time.sleep(random.uniform(4, 7))
+
+        # Step 12: 再次检测 403（导航后可能出现）
+        access_error = self._check_access_restricted(page, email)
+        if access_error:
+            return access_error
+
+        # Step 13: 等待 URL 参数生成（csesidx 和 cid）
+        if not self._wait_for_business_params(page):
+            page.refresh()
+            time.sleep(random.uniform(4, 7))
+            if not self._wait_for_business_params(page):
+                self._log("error", "❌ URL 参数生成失败")
+                self._save_screenshot(page, "params_missing")
+                return {"success": False, "error": "URL parameters not found"}
+
+        # Step 13: 提取配置
+        self._log("info", "🎊 登录成功，提取配置...")
+        return self._extract_config(page, email)
+
+    def _click_send_code_button(self, page) -> bool:
+        """点击发送验证码按钮（如果需要）"""
+        time.sleep(random.uniform(1.5, 3))
+        max_send_attempts = 5
+        # 适度退避延迟序列（秒）
+        retry_delays = [10, 10, 15, 15, 20]
+
+        # 方法1: 直接通过ID查找
+        direct_btn = page.ele("#sign-in-with-email", timeout=5)
+        if direct_btn:
+            for attempt in range(1, max_send_attempts + 1):
+                try:
+                    self._last_send_error = ""
+                    self._human_click(page, direct_btn)
+                    if self._verify_code_send_by_network(page) or self._verify_code_send_status(page):
+                        self._stop_listen(page)
+                        return True
+                    delay = retry_delays[min(attempt - 1, len(retry_delays) - 1)]
+                    if self._last_send_error == "captcha_check_failed":
+                        self._log("error", f"❌ 触发风控，建议更换代理IP ({attempt}/{max_send_attempts})")
+                    else:
+                        self._log("warning", f"⚠️ 发送失败，{delay}秒后重试 ({attempt}/{max_send_attempts})")
+                    time.sleep(delay)
+                except Exception as e:
+                    self._log("warning", f"⚠️ 点击失败: {e}")
+            self._stop_listen(page)
+            return False
+
+        # 方法2: 通过关键词查找
+        keywords = ["通过电子邮件发送验证码", "通过电子邮件发送", "email", "Email", "Send code", "Send verification", "Verification code"]
+        try:
+            buttons = page.eles("tag:button")
+            for btn in buttons:
+                text = (btn.text or "").strip()
+                if text and any(kw in text for kw in keywords):
+                    for attempt in range(1, max_send_attempts + 1):
+                        try:
+                            self._last_send_error = ""
+                            self._human_click(page, btn)
+                            if self._verify_code_send_by_network(page) or self._verify_code_send_status(page):
+                                self._stop_listen(page)
+                                return True
+                            delay = retry_delays[min(attempt - 1, len(retry_delays) - 1)]
+                            if self._last_send_error == "captcha_check_failed":
+                                self._log("error", f"❌ 触发风控，建议更换代理IP ({attempt}/{max_send_attempts})")
+                            else:
+                                self._log("warning", f"⚠️ 发送失败，{delay}秒后重试 ({attempt}/{max_send_attempts})")
+                            time.sleep(delay)
+                        except Exception as e:
+                            self._log("warning", f"⚠️ 点击失败: {e}")
+                    self._stop_listen(page)
+                    return False
+        except Exception as e:
+            self._log("warning", f"⚠️ 搜索按钮异常: {e}")
+
+        # 检查是否在 signin-error 页面（不应该继续尝试发送）
+        if "signin-error" in (page.url or ""):
+            self._stop_listen(page)
+            self._log("error", "❌ 在 signin-error 页面，无法发送验证码")
+            return False
+
+        # 检查是否已经在验证码输入页面
+        code_input = page.ele("css:input[jsname='ovqh0b']", timeout=2) or page.ele("css:input[name='pinInput']", timeout=1)
+        if code_input:
+            self._stop_listen(page)
+            self._log("info", "✅ 已在验证码输入页面")
+
+            # 直接点击重新发送按钮（不管之前是否发送过）
+            if self._click_resend_code_button(page):
+                self._log("info", "✅ 已点击重新发送按钮")
+                return True
+            else:
+                self._log("warning", "⚠️ 未找到重新发送按钮，继续流程")
+                return True
+
+        self._stop_listen(page)
+        self._log("error", "❌ 未找到发送验证码按钮")
+        return False
+
+    def _stop_listen(self, page) -> None:
+        """安全地停止网络监听"""
+        try:
+            if hasattr(page, 'listen') and page.listen:
+                page.listen.stop()
+        except Exception:
+            pass
+
+    def _verify_code_send_by_network(self, page) -> bool:
+        """通过监听网络请求验证验证码是否成功发送"""
+        try:
+            time.sleep(1)
+
+            packets = []
+            max_wait_seconds = 6
+            deadline = time.time() + max_wait_seconds
+            try:
+                while time.time() < deadline:
+                    got_any = False
+                    for packet in page.listen.steps(timeout=1, gap=1):
+                        packets.append(packet)
+                        got_any = True
+                    if got_any:
+                        time.sleep(0.2)
+                    else:
+                        break
+            except Exception:
+                return False
+
+            if not packets:
+                return False
+
+            # 保存网络日志（仅用于调试）
+            self._save_network_packets(packets)
+
+            found_batchexecute = False
+            found_batchexecute_error = False
+
+            for packet in packets:
+                try:
+                    url = str(packet.url) if hasattr(packet, 'url') else str(packet)
+
+                    if 'batchexecute' in url:
+                        found_batchexecute = True
+
+                        try:
+                            response = packet.response if hasattr(packet, 'response') else None
+                            if response and hasattr(response, 'raw_body'):
+                                body = response.raw_body
+                                raw_body_str = str(body)
+                                if "CAPTCHA_CHECK_FAILED" in raw_body_str:
+                                    found_batchexecute_error = True
+                                    self._last_send_error = "captcha_check_failed"
+                                elif "SendEmailOtpError" in raw_body_str:
+                                    found_batchexecute_error = True
+                                    self._last_send_error = "send_email_otp_error"
+                        except Exception:
+                            pass
+
+                except Exception:
+                    continue
+
+            if found_batchexecute:
+                if found_batchexecute_error:
+                    return False
+                return True
+            else:
+                return False
+
+        except Exception:
+            return False
+
+    def _verify_code_send_status(self, page) -> bool:
+        """检测页面提示判断是否发送成功"""
+        time.sleep(random.uniform(1.5, 3))
+        try:
+            success_keywords = ["验证码已发送", "code sent", "email sent", "check your email", "已发送"]
+            error_keywords = [
+                "出了点问题",
+                "something went wrong",
+                "error",
+                "failed",
+                "try again",
+                "稍后再试",
+                "选择其他登录方法"
+            ]
+            selectors = [
+                "css:.zyTWof-gIZMF",
+                "css:[role='alert']",
+                "css:aside",
+            ]
+            for selector in selectors:
+                try:
+                    elements = page.eles(selector, timeout=1)
+                    for elem in elements[:20]:
+                        text = (elem.text or "").strip()
+                        if not text:
+                            continue
+                        if any(kw in text for kw in error_keywords):
+                            return False
+                        if any(kw in text for kw in success_keywords):
+                            return True
+                except Exception:
+                    continue
+            return True
+        except Exception:
+            return True
+
+    def _truncate_text(self, text: str, max_len: int = 2000) -> str:
+        if text is None:
+            return ""
+        if len(text) <= max_len:
+            return text
+        return text[:max_len] + f"...(truncated, total={len(text)})"
+
+    def _save_network_packets(self, packets) -> None:
+        """保存网络日志（仅用于调试）"""
+        try:
+            from core.storage import _data_file_path
+            base_dir = _data_file_path(os.path.join("logs", "network"))
+            os.makedirs(base_dir, exist_ok=True)
+            ts = datetime.now().strftime("%Y%m%d-%H%M%S")
+            file_path = os.path.join(base_dir, f"network-{ts}.jsonl")
+
+            def safe_str(value):
+                try:
+                    return value if isinstance(value, str) else str(value)
+                except Exception:
+                    return "<unprintable>"
+
+            with open(file_path, "a", encoding="utf-8") as f:
+                for packet in packets:
+                    try:
+                        req = packet.request if hasattr(packet, "request") else None
+                        resp = packet.response if hasattr(packet, "response") else None
+                        fail = packet.fail_info if hasattr(packet, "fail_info") else None
+
+                        item = {
+                            "url": safe_str(packet.url) if hasattr(packet, "url") else safe_str(packet),
+                            "method": safe_str(packet.method) if hasattr(packet, "method") else "UNKNOWN",
+                            "resourceType": safe_str(packet.resourceType) if hasattr(packet, "resourceType") else "",
+                            "is_failed": bool(packet.is_failed) if hasattr(packet, "is_failed") else False,
+                            "fail_info": safe_str(fail) if fail else "",
+                            "request": {
+                                "headers": req.headers if req and hasattr(req, "headers") else {},
+                                "postData": req.postData if req and hasattr(req, "postData") else "",
+                            },
+                            "response": {
+                                "status": resp.status if resp and hasattr(resp, "status") else 0,
+                                "headers": resp.headers if resp and hasattr(resp, "headers") else {},
+                                "raw_body": resp.raw_body if resp and hasattr(resp, "raw_body") else "",
+                            },
+                        }
+                        f.write(json.dumps(item, ensure_ascii=False) + "\n")
+                    except Exception as e:
+                        f.write(json.dumps({"error": safe_str(e)}, ensure_ascii=False) + "\n")
+        except Exception:
+            pass
+
+    def _wait_for_code_input(self, page, timeout: int = 30):
+        """等待验证码输入框出现"""
+        selectors = [
+            "css:input[jsname='ovqh0b']",
+            "css:input[type='tel']",
+            "css:input[name='pinInput']",
+            "css:input[autocomplete='one-time-code']",
+        ]
+        for _ in range(timeout // 2):
+            for selector in selectors:
+                try:
+                    el = page.ele(selector, timeout=1)
+                    if el:
+                        return el
+                except Exception:
+                    continue
+            time.sleep(2)
+        return None
+
+    def _simulate_human_input(self, element, text: str) -> bool:
+        """模拟人类输入（逐字符输入，带非均匀延迟）
+
+        Args:
+            element: 输入框元素
+            text: 要输入的文本
+
+        Returns:
+            bool: 是否成功
+        """
+        try:
+            # 先点击输入框获取焦点
+            element.click()
+            time.sleep(random.uniform(0.2, 0.5))
+
+            # 逐字符输入，模拟真实打字节奏
+            for i, char in enumerate(text):
+                element.input(char)
+                # 基础延迟 80-180ms（正常打字速度）
+                delay = random.uniform(0.08, 0.18)
+                # 每3-5个字符偶尔有更长的停顿（模拟犹豫/看屏幕）
+                if i > 0 and random.random() < 0.2:
+                    delay += random.uniform(0.2, 0.5)
+                time.sleep(delay)
+
+            # 输入完成后停顿（模拟核对）
+            time.sleep(random.uniform(0.3, 0.8))
+            return True
+        except Exception:
+            return False
+
+    def _human_click(self, page, element) -> None:
+        """模拟人类点击：先移动鼠标到元素附近，再点击"""
+        try:
+            # 尝试用 actions 链模拟鼠标移动 + 点击
+            page.actions.move_to(element)
+            time.sleep(random.uniform(0.1, 0.3))
+            page.actions.click()
+        except Exception:
+            # 降级为直接点击
+            element.click()
+
+    def _random_scroll(self, page) -> None:
+        """模拟真实用户的页面滚动行为"""
+        try:
+            scroll_amount = random.randint(50, 200)
+            page.run_js(f"window.scrollBy(0, {scroll_amount})")
+            time.sleep(random.uniform(0.3, 0.8))
+            # 有时候滚回去一点
+            if random.random() < 0.3:
+                page.run_js(f"window.scrollBy(0, -{random.randint(20, 80)})")
+                time.sleep(random.uniform(0.2, 0.5))
+        except Exception:
+            pass
+
+    def _find_verify_button(self, page):
+        """查找验证按钮（排除重新发送按钮）"""
+        try:
+            buttons = page.eles("tag:button")
+            for btn in buttons:
+                text = (btn.text or "").strip().lower()
+                if text and "重新" not in text and "发送" not in text and "resend" not in text and "send" not in text:
+                    return btn
+        except Exception:
+            pass
+        return None
+
+    def _click_resend_code_button(self, page) -> bool:
+        """点击重新发送验证码按钮"""
+        time.sleep(random.uniform(1.5, 3))
+
+        # 查找包含重新发送关键词的按钮（与 _find_verify_button 相反）
+        try:
+            buttons = page.eles("tag:button")
+            for btn in buttons:
+                text = (btn.text or "").strip().lower()
+                if text and ("重新" in text or "resend" in text):
+                    try:
+                        self._log("info", f"🔄 点击重新发送按钮")
+                        self._human_click(page, btn)
+                        time.sleep(random.uniform(1.5, 3))
+                        return True
+                    except Exception:
+                        pass
+        except Exception:
+            pass
+
+        return False
+
+    def _check_access_restricted(self, page, email: str = "") -> dict | None:
+        """检测 403 Access Restricted 页面，返回错误 dict 或 None"""
+        domain = email.split("@")[1] if "@" in email else "unknown"
+        error_msg = f"403 域名封禁 ({domain})"
+
+        # 方法1: 搜索 h1 标签
+        try:
+            h1 = page.ele("tag:h1", timeout=2)
+            h1_text = h1.text if h1 else ""
+            if h1_text and "Access Restricted" in h1_text:
+                self._log("error", "⛔ 403 Access Restricted: email banned by Google")
+                self._log("error", f"⛔ 403 访问受限，域名 {domain} 可能已被 Google 封禁")
+                self._save_screenshot(page, "access_restricted_403")
+                return {"success": False, "error": error_msg}
+        except Exception:
+            pass
+
+        # 方法2: body 文本
+        try:
+            body = page.ele("tag:body", timeout=2)
+            body_text = (body.text or "")[:500] if body else ""
+            if "Access Restricted" in body_text:
+                self._log("error", "⛔ 403 Access Restricted: email banned by Google")
+                self._log("error", f"⛔ 403 访问受限，域名 {domain} 可能已被 Google 封禁")
+                self._save_screenshot(page, "access_restricted_403")
+                return {"success": False, "error": error_msg}
+        except Exception:
+            pass
+
+        # 方法3: page.html 源码
+        try:
+            html = (page.html or "")[:2000]
+            if "Access Restricted" in html:
+                self._log("error", "⛔ 403 Access Restricted: email banned by Google")
+                self._log("error", f"⛔ 403 访问受限，域名 {domain} 可能已被 Google 封禁")
+                self._save_screenshot(page, "access_restricted_403")
+                return {"success": False, "error": error_msg}
+        except Exception:
+            pass
+
+        return None
+
+    def _handle_agreement_page(self, page) -> None:
+        """处理协议页面"""
+        if "/admin/create" in page.url:
+            agree_btn = page.ele("css:button.agree-button", timeout=5)
+            if agree_btn:
+                self._human_click(page, agree_btn)
+                time.sleep(random.uniform(2, 4))
+
+    def _wait_for_cid(self, page, timeout: int = 10) -> bool:
+        """等待URL包含cid"""
+        for _ in range(timeout):
+            if "cid" in page.url:
+                return True
+            time.sleep(1)
+        return False
+
+    def _wait_for_business_params(self, page, timeout: int = 30) -> bool:
+        """等待业务页面参数生成（csesidx 和 cid）"""
+        for _ in range(timeout):
+            url = page.url
+            if "csesidx=" in url and "/cid/" in url:
+                return True
+            time.sleep(1)
+        return False
+
+    def _handle_username_setup(self, page, is_new_account: bool = False) -> bool:
+        """处理用户名设置页面（is_new_account=True 时启用按钮兜底和延长超时）"""
+        current_url = page.url
+
+        if "auth.business.gemini.google/login" in current_url:
+            return False
+
+        # 精准选择器（参考实际页面 DOM，优先级从高到低）
+        selectors = [
+            "css:input[formcontrolname='fullName']",
+            "css:input#mat-input-0",
+            "css:input[placeholder='全名']",
+            "css:input[placeholder='Full name']",
+            "css:input[name='displayName']",
+            "css:input[aria-label*='用户名' i]",
+            "css:input[aria-label*='display name' i]",
+            "css:input[type='text']",
+        ]
+
+        # 轮询等待输入框出现（最多30秒，每秒检查一次）
+        # 与参考代码对齐：页面加载慢时不会过早放弃
+        username_input = None
+        self._log("info", "⏳ 等待用户名输入框出现（最多30秒）...")
+        for i in range(30):
+            for selector in selectors:
+                try:
+                    el = page.ele(selector, timeout=1)
+                    if el:
+                        username_input = el
+                        self._log("info", f"✅ 找到用户名输入框: {selector}")
+                        break
+                except Exception:
+                    continue
+            if username_input:
+                break
+            time.sleep(1)
+
+        if not username_input:
+            self._log("warning", "⚠️ 30秒内未找到用户名输入框，跳过此步骤")
+            return False
+
+        name = random.choice(REGISTER_NAMES)
+        self._log("info", f"✏️ 输入姓名: {name}")
+
+        try:
+            # 清空输入框
+            username_input.click()
+            time.sleep(random.uniform(0.2, 0.5))
+            username_input.clear()
+            time.sleep(random.uniform(0.1, 0.3))
+
+            # 尝试模拟人类输入，失败则降级到直接注入
+            if not self._simulate_human_input(username_input, name):
+                username_input.input(name)
+                time.sleep(0.3)
+
+            # 回车提交
+            username_input.input("\n")
+
+            if is_new_account:
+                # 注册专用：回车后等待1.5秒，若未跳转则用按钮兜底
+                time.sleep(random.uniform(1.5, 3))
+                if "cid" not in page.url:
+                    self._log("info", "⌨️ 回车未跳转，尝试点击提交按钮...")
+                    try:
+                        for btn in page.eles("tag:button"):
+                            try:
+                                if btn.is_displayed() and btn.is_enabled():
+                                    btn.click()
+                                    self._log("info", "✅ 已点击提交按钮（兜底）")
+                                    time.sleep(1)
+                                    break
+                            except Exception:
+                                continue
+                    except Exception as e:
+                        self._log("warning", f"⚠️ 按钮兜底失败: {e}")
+
+                # 注册专用：等待45秒，失败则刷新再等15秒
+                if not self._wait_for_cid(page, timeout=45):
+                    self._log("warning", "⚠️ 用户名提交后未检测到 cid 参数，尝试刷新...")
+                    page.refresh()
+                    time.sleep(random.uniform(2, 4))
+                    if not self._wait_for_cid(page, timeout=15):
+                        self._log("error", "❌ 刷新后仍未检测到 cid 参数")
+                        self._save_screenshot(page, "step7_after_verify")
+                        return False
+            else:
+                # 登录刷新：原有30秒逻辑
+                if not self._wait_for_cid(page, timeout=30):
+                    self._log("warning", "⚠️ 用户名提交后未检测到 cid 参数")
+                    return False
+
+            return True
+        except Exception as e:
+            self._log("warning", f"⚠️ 用户名设置异常: {e}")
+            return False
+
+    def _extract_config(self, page, email: str) -> dict:
+        """提取配置（轮询等待 cookie 到位）"""
+        try:
+            if "cid/" not in page.url:
+                page.get("https://business.gemini.google/", timeout=self.timeout)
+                time.sleep(random.uniform(2, 4))
+
+            url = page.url
+            if "cid/" not in url:
+                return {"success": False, "error": "cid not found"}
+
+            config_id = url.split("cid/")[1].split("?")[0].split("/")[0]
+            csesidx = url.split("csesidx=")[1].split("&")[0] if "csesidx=" in url else ""
+
+            # 轮询等待关键 cookie 到位（最多10秒）
+            ses = None
+            host = None
+            ses_obj = None
+            for _ in range(10):
+                cookies = page.cookies()
+                ses = next((c["value"] for c in cookies if c["name"] == "__Secure-C_SES"), None)
+                host = next((c["value"] for c in cookies if c["name"] == "__Host-C_OSES"), None)
+                ses_obj = next((c for c in cookies if c["name"] == "__Secure-C_SES"), None)
+                if ses and host:
+                    break
+                time.sleep(1)
+
+            if not ses or not host:
+                self._log("warning", f"⚠️ Cookie 不完整 (ses={'有' if ses else '无'}, host={'有' if host else '无'})")
+
+            # 使用北京时区，确保时间计算正确（Cookie expiry 是 UTC 时间戳）
+            beijing_tz = timezone(timedelta(hours=8))
+            if ses_obj and "expiry" in ses_obj:
+                cookie_expire_beijing = datetime.fromtimestamp(ses_obj["expiry"], tz=beijing_tz)
+                expires_at = (cookie_expire_beijing - timedelta(hours=12)).strftime("%Y-%m-%d %H:%M:%S")
+            else:
+                expires_at = (datetime.now(beijing_tz) + timedelta(hours=12)).strftime("%Y-%m-%d %H:%M:%S")
+
+            config = {
+                "id": email,
+                "csesidx": csesidx,
+                "config_id": config_id,
+                "secure_c_ses": ses,
+                "host_c_oses": host,
+                "expires_at": expires_at,
+            }
+
+            # 提取试用期信息
+            trial_end = self._extract_trial_end(page, csesidx, config_id)
+            if trial_end:
+                config["trial_end"] = trial_end
+
+            return {"success": True, "config": config}
+        except Exception as e:
+            return {"success": False, "error": str(e)}
+
+    def _extract_trial_end(self, page, csesidx: str, config_id: str) -> Optional[str]:
+        """从页面中提取试用期到期日期，不跳转到可能 400 的深层路径"""
+        # re 已在文件顶部导入
+        try:
+            self._log("info", "📅 获取试用期信息...")
+
+            def _days_to_end_date(days: int) -> str:
+                end_date = (datetime.now(timezone(timedelta(hours=8))) + timedelta(days=days)).strftime("%Y-%m-%d")
+                self._log("info", f"📅 试用期剩余 {days} 天，到期日: {end_date}")
+                return end_date
+
+            def _search_page_source(source: str) -> Optional[str]:
+                """在页面源码中搜索试用期信息"""
+                # 格式1: "daysLeft":29 (JSON数据)
+                m = re.search(r'"daysLeft"\s*:\s*(\d+)', source)
+                if m:
+                    return _days_to_end_date(int(m.group(1)))
+                # 格式2: "trialDaysRemaining":29
+                m = re.search(r'"trialDaysRemaining"\s*:\s*(\d+)', source)
+                if m:
+                    return _days_to_end_date(int(m.group(1)))
+                # 格式3: 日期数组 "[2026,3,25]" 形式 (batchexecute格式)
+                m = re.search(r'\[(\d{4}),(\d{1,2}),(\d{1,2})\].*?\[(\d{4}),(\d{1,2}),(\d{1,2})\]', source)
+                if m:
+                    # 取第二个日期（结束日期）
+                    try:
+                        end_date = f"{m.group(4):0>4}-{int(m.group(5)):02d}-{int(m.group(6)):02d}"
+                        # 简单校验年份合理
+                        if 2025 <= int(m.group(4)) <= 2030:
+                            self._log("info", f"📅 试用期到期日: {end_date}")
+                            return end_date
+                    except Exception:
+                        pass
+                # 格式4: "29 days left" 或 "还剩29天"
+                m = re.search(r'(\d+)\s*days?\s*left', source, re.IGNORECASE)
+                if m:
+                    return _days_to_end_date(int(m.group(1)))
+                m = re.search(r'还剩\s*(\d+)\s*天', source)
+                if m:
+                    return _days_to_end_date(int(m.group(1)))
+                return None
+
+            # ——— 方式1: 当前页面（刚登录完，不需要跳转）———
+            try:
+                source = page.html
+                result = _search_page_source(source or "")
+                if result:
+                    return result
+            except Exception:
+                pass
+
+            # ——— 方式2: 跳转到 /settings（不带 billing/plans 后缀，SPA可以处理）———
+            try:
+                settings_url = f"https://business.gemini.google/cid/{config_id}/settings?csesidx={csesidx}"
+                page.get(settings_url, timeout=self.timeout)
+                time.sleep(random.uniform(1.5, 3))
+                source = page.html
+                result = _search_page_source(source or "")
+                if result:
+                    return result
+            except Exception:
+                pass
+
+            # ——— 方式3: 跳转到主页（最保险）———
+            try:
+                main_url = f"https://business.gemini.google/cid/{config_id}?csesidx={csesidx}"
+                page.get(main_url, timeout=self.timeout)
+                time.sleep(random.uniform(1.5, 3))
+                source = page.html
+                result = _search_page_source(source or "")
+                if result:
+                    return result
+            except Exception:
+                pass
+
+            self._log("warning", "⚠️ 未能获取试用期信息（页面中未找到相关数据）")
+            return None
+        except Exception as e:
+            self._log("warning", f"⚠️ 获取试用期失败: {e}")
+            return None
+
+    def _save_screenshot(self, page, name: str) -> None:
+        """保存截图"""
+        try:
+            from core.storage import _data_file_path
+            screenshot_dir = _data_file_path("automation")
+            os.makedirs(screenshot_dir, exist_ok=True)
+            path = os.path.join(screenshot_dir, f"{name}_{int(time.time())}.png")
+            page.get_screenshot(path=path)
+        except Exception:
+            pass
+
+    def _log(self, level: str, message: str) -> None:
+        """记录日志"""
+        if self.log_callback:
+            try:
+                self.log_callback(level, message)
+            except TaskCancelledError:
+                raise
+            except Exception:
+                pass
+
+    def _cleanup_user_data(self, user_data_dir: Optional[str]) -> None:
+        """清理浏览器用户数据目录"""
+        if not user_data_dir:
+            return
+        try:
+            import shutil
+            if os.path.exists(user_data_dir):
+                shutil.rmtree(user_data_dir, ignore_errors=True)
+        except Exception:
+            pass
+
+    @staticmethod
+    def _get_ua() -> str:
+        """生成随机User-Agent（使用当前主流 Chrome 版本）"""
+        major = random.choice([132, 133, 134, 135])
+        v = f"{major}.0.{random.randint(6800, 6950)}.{random.randint(50, 150)}"
+        return f"Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/{v} Safari/537.36"

core/google_api.py

@@ -0,0 +1,339 @@
+"""Google API交互模块
+
+负责与Google Gemini Business API的所有交互操作
+"""
+import asyncio
+import json
+import logging
+import os
+import re
+import time
+import uuid
+from datetime import datetime, timedelta, timezone
+from typing import TYPE_CHECKING, List
+
+import httpx
+from fastapi import HTTPException
+
+if TYPE_CHECKING:
+    from main import AccountManager
+
+logger = logging.getLogger(__name__)
+
+# Google API 基础URL
+GEMINI_API_BASE = "https://biz-discoveryengine.googleapis.com/v1alpha"
+
+
+
+def get_common_headers(jwt: str, user_agent: str) -> dict:
+    """生成通用请求头"""
+    return {
+        "accept": "*/*",
+        "accept-encoding": "gzip, deflate, br, zstd",
+        "accept-language": "zh-CN,zh;q=0.9,en;q=0.8",
+        "authorization": f"Bearer {jwt}",
+        "content-type": "application/json",
+        "origin": "https://business.gemini.google",
+        "referer": "https://business.gemini.google/",
+        "user-agent": user_agent,
+        "x-server-timeout": "1800",
+        "sec-ch-ua": '"Chromium";v="124", "Google Chrome";v="124", "Not-A.Brand";v="99"',
+        "sec-ch-ua-mobile": "?0",
+        "sec-ch-ua-platform": '"Windows"',
+        "sec-fetch-dest": "empty",
+        "sec-fetch-mode": "cors",
+        "sec-fetch-site": "cross-site",
+    }
+
+
+async def make_request_with_jwt_retry(
+    account_mgr: "AccountManager",
+    method: str,
+    url: str,
+    http_client: httpx.AsyncClient,
+    user_agent: str,
+    request_id: str = "",
+    **kwargs
+) -> httpx.Response:
+    """通用HTTP请求，自动处理JWT过期重试
+
+    Args:
+        account_mgr: AccountManager实例
+        method: HTTP方法 (GET/POST)
+        url: 请求URL
+        http_client: httpx客户端
+        user_agent: User-Agent字符串
+        request_id: 请求ID（用于日志）
+        **kwargs: 传递给httpx的其他参数（如json, headers等）
+
+    Returns:
+        httpx.Response对象
+    """
+    jwt = await account_mgr.get_jwt(request_id)
+    headers = get_common_headers(jwt, user_agent)
+
+    # 合并用户提供的headers（如果有）
+    extra_headers = kwargs.pop("headers", None)
+    if extra_headers:
+        headers.update(extra_headers)
+
+    # 提取timeout参数（如果有），单独传给httpx
+    req_timeout = kwargs.pop("timeout", None)
+
+    # 发起请求
+    req_kwargs = {**kwargs}
+    if req_timeout is not None:
+        req_kwargs["timeout"] = req_timeout
+
+    if method.upper() == "GET":
+        resp = await http_client.get(url, headers=headers, **req_kwargs)
+    elif method.upper() == "POST":
+        resp = await http_client.post(url, headers=headers, **req_kwargs)
+    else:
+        raise ValueError(f"Unsupported HTTP method: {method}")
+
+    # 如果401，刷新JWT后重试一次
+    if resp.status_code == 401:
+        jwt = await account_mgr.get_jwt(request_id)
+        headers = get_common_headers(jwt, user_agent)
+        if extra_headers:
+            headers.update(extra_headers)
+
+        if method.upper() == "GET":
+            resp = await http_client.get(url, headers=headers, **req_kwargs)
+        elif method.upper() == "POST":
+            resp = await http_client.post(url, headers=headers, **req_kwargs)
+
+    return resp
+
+
+async def create_google_session(
+    account_manager: "AccountManager",
+    http_client: httpx.AsyncClient,
+    user_agent: str,
+    request_id: str = ""
+) -> str:
+    """创建Google Session"""
+    jwt = await account_manager.get_jwt(request_id)
+    headers = get_common_headers(jwt, user_agent)
+    body = {
+        "configId": account_manager.config.config_id,
+        "additionalParams": {"token": "-"},
+        "createSessionRequest": {
+            "session": {"name": "", "displayName": ""}
+        }
+    }
+
+    req_tag = f"[req_{request_id}] " if request_id else ""
+    r = await http_client.post(
+        f"{GEMINI_API_BASE}/locations/global/widgetCreateSession",
+        headers=headers,
+        json=body,
+        timeout=30.0,
+    )
+    if r.status_code != 200:
+        logger.error(f"[SESSION] [{account_manager.config.account_id}] {req_tag}Session 创建失败: {r.status_code}")
+        raise HTTPException(r.status_code, "createSession failed")
+    sess_name = r.json()["session"]["name"]
+    logger.info(f"[SESSION] [{account_manager.config.account_id}] {req_tag}创建成功: {sess_name[-12:]}")
+    return sess_name
+
+
+async def upload_context_file(
+    session_name: str,
+    mime_type: str,
+    base64_content: str,
+    account_manager: "AccountManager",
+    http_client: httpx.AsyncClient,
+    user_agent: str,
+    request_id: str = ""
+) -> str:
+    """上传文件到指定 Session，返回 fileId"""
+    jwt = await account_manager.get_jwt(request_id)
+    headers = get_common_headers(jwt, user_agent)
+
+    # 生成随机文件名
+    ext = mime_type.split('/')[-1] if '/' in mime_type else "bin"
+    file_name = f"upload_{int(time.time())}_{uuid.uuid4().hex[:6]}.{ext}"
+
+    body = {
+        "configId": account_manager.config.config_id,
+        "additionalParams": {"token": "-"},
+        "addContextFileRequest": {
+            "name": session_name,
+            "fileName": file_name,
+            "mimeType": mime_type,
+            "fileContents": base64_content
+        }
+    }
+
+    r = await http_client.post(
+        f"{GEMINI_API_BASE}/locations/global/widgetAddContextFile",
+        headers=headers,
+        json=body,
+        timeout=60.0,
+    )
+
+    req_tag = f"[req_{request_id}] " if request_id else ""
+    if r.status_code != 200:
+        logger.error(f"[FILE] [{account_manager.config.account_id}] {req_tag}文件上传失败: {r.status_code}")
+        error_text = r.text
+        if r.status_code == 400:
+            try:
+                payload = json.loads(r.text or "{}")
+                message = payload.get("error", {}).get("message", "")
+            except Exception:
+                message = ""
+            if "Unsupported file type" in message:
+                mime_type = message.split("Unsupported file type:", 1)[-1].strip()
+                hint = f"不支持的文件类型: {mime_type}。请转换为 PDF、图片或纯文本后再上传。"
+                raise HTTPException(400, hint)
+        raise HTTPException(r.status_code, f"Upload failed: {error_text}")
+
+    data = r.json()
+    file_id = data.get("addContextFileResponse", {}).get("fileId")
+    logger.info(f"[FILE] [{account_manager.config.account_id}] {req_tag}文件上传成功: {mime_type}")
+    return file_id
+
+
+async def get_session_file_metadata(
+    account_mgr: "AccountManager",
+    session_name: str,
+    http_client: httpx.AsyncClient,
+    user_agent: str,
+    request_id: str = ""
+) -> dict:
+    """获取session中的文件元数据，包括正确的session路径"""
+    body = {
+        "configId": account_mgr.config.config_id,
+        "additionalParams": {"token": "-"},
+        "listSessionFileMetadataRequest": {
+            "name": session_name,
+            "filter": "file_origin_type = AI_GENERATED"
+        }
+    }
+
+    resp = await make_request_with_jwt_retry(
+        account_mgr,
+        "POST",
+        f"{GEMINI_API_BASE}/locations/global/widgetListSessionFileMetadata",
+        http_client,
+        user_agent,
+        request_id,
+        json=body,
+        timeout=30.0
+    )
+
+    if resp.status_code != 200:
+        logger.warning(f"[IMAGE] [{account_mgr.config.account_id}] [req_{request_id}] 获取文件元数据失败: {resp.status_code}")
+        return {}
+
+    data = resp.json()
+    result = {}
+    file_metadata_list = data.get("listSessionFileMetadataResponse", {}).get("fileMetadata", [])
+
+    for fm in file_metadata_list:
+        fid = fm.get("fileId")
+        if fid:
+            result[fid] = fm
+
+    return result
+
+
+def build_image_download_url(session_name: str, file_id: str) -> str:
+    """构造图片下载URL"""
+    return f"{GEMINI_API_BASE}/{session_name}:downloadFile?fileId={file_id}&alt=media"
+
+
+async def download_image_with_jwt(
+    account_mgr: "AccountManager",
+    session_name: str,
+    file_id: str,
+    http_client: httpx.AsyncClient,
+    user_agent: str,
+    request_id: str = "",
+    max_retries: int = 3
+) -> bytes:
+    """
+    使用JWT认证下载图片（带超时和重试机制）
+
+    Args:
+        account_mgr: 账户管理器
+        session_name: Session名称
+        file_id: 文件ID
+        http_client: httpx客户端
+        user_agent: User-Agent字符串
+        request_id: 请求ID
+        max_retries: 最大重试次数（默认3次）
+
+    Returns:
+        图片字节数据
+
+    Raises:
+        HTTPException: 下载失败
+        asyncio.TimeoutError: 超时
+    """
+    url = build_image_download_url(session_name, file_id)
+    logger.info(f"[IMAGE] [{account_mgr.config.account_id}] [req_{request_id}] 开始下载图片: {file_id[:8]}...")
+
+    for attempt in range(max_retries):
+        try:
+            # 3分钟超时（180秒）- 使用 wait_for 兼容 Python 3.10
+            resp = await asyncio.wait_for(
+                make_request_with_jwt_retry(
+                    account_mgr,
+                    "GET",
+                    url,
+                    http_client,
+                    user_agent,
+                    request_id,
+                    follow_redirects=True
+                ),
+                timeout=180
+            )
+
+            resp.raise_for_status()
+            logger.info(f"[IMAGE] [{account_mgr.config.account_id}] [req_{request_id}] 图片下载成功: {file_id[:8]}... ({len(resp.content)} bytes)")
+            return resp.content
+
+        except asyncio.TimeoutError:
+            logger.warning(f"[IMAGE] [{account_mgr.config.account_id}] [req_{request_id}] 图片下载超时 (尝试 {attempt + 1}/{max_retries}): {file_id[:8]}...")
+            if attempt == max_retries - 1:
+                raise HTTPException(504, f"Image download timeout after {max_retries} attempts")
+            await asyncio.sleep(2 ** attempt)  # 指数退避：2s, 4s, 8s
+
+        except httpx.HTTPError as e:
+            logger.warning(f"[IMAGE] [{account_mgr.config.account_id}] [req_{request_id}] 图片下载失败 (尝试 {attempt + 1}/{max_retries}): {type(e).__name__}")
+            if attempt == max_retries - 1:
+                raise HTTPException(500, f"Image download failed: {str(e)[:100]}")
+            await asyncio.sleep(2 ** attempt)  # 指数退避
+
+        except Exception as e:
+            logger.error(f"[IMAGE] [{account_mgr.config.account_id}] [req_{request_id}] 图片下载异常: {type(e).__name__}: {str(e)[:100]}")
+            raise
+
+    # 不应该到达这里
+    raise HTTPException(500, "Image download failed unexpectedly")
+
+
+def save_image_to_hf(image_data: bytes, chat_id: str, file_id: str, mime_type: str, base_url: str, image_dir: str, url_path: str = "images") -> str:
+    """保存图片到持久化存储,返回完整的公开URL"""
+    ext_map = {
+        "image/png": ".png",
+        "image/jpeg": ".jpg",
+        "image/gif": ".gif",
+        "image/webp": ".webp",
+        "video/mp4": ".mp4",
+        "video/webm": ".webm",
+        "video/quicktime": ".mov"
+    }
+    ext = ext_map.get(mime_type, ".png")
+
+    filename = f"{chat_id}_{file_id}{ext}"
+    save_path = os.path.join(image_dir, filename)
+
+    # 目录已在启动时创建,无需重复创建
+    with open(save_path, "wb") as f:
+        f.write(image_data)
+
+    return f"{base_url}/{url_path}/{filename}"

core/gptmail_client.py

@@ -0,0 +1,219 @@
+import os
+import random
+import string
+import time
+from datetime import datetime
+from typing import Any, Dict, List, Optional
+
+import requests
+
+from core.mail_utils import extract_verification_code
+from core.proxy_utils import request_with_proxy_fallback
+
+
+class GPTMailClient:
+    """GPTMail 临时邮箱客户端"""
+
+    def __init__(
+        self,
+        base_url: str = "https://mail.chatgpt.org.uk",
+        proxy: str = "",
+        verify_ssl: bool = True,
+        api_key: str = "",
+        domain: str = "",
+        log_callback=None,
+    ) -> None:
+        self.base_url = (base_url or "").rstrip("/")
+        self.verify_ssl = verify_ssl
+        self.proxy_url = (proxy or "").strip()
+        self.api_key = (api_key or "").strip()
+        self.domain = (domain or "").strip()
+        self.log_callback = log_callback
+
+        self.email: Optional[str] = None
+
+    def set_credentials(self, email: str, password: Optional[str] = None) -> None:
+        self.email = email
+
+    def _log(self, level: str, message: str) -> None:
+        if self.log_callback:
+            try:
+                self.log_callback(level, message)
+            except Exception:
+                pass
+
+    def _request(self, method: str, url: str, **kwargs) -> requests.Response:
+        headers = kwargs.pop("headers", None) or {}
+        if self.api_key and "X-API-Key" not in headers:
+            headers["X-API-Key"] = self.api_key
+        kwargs["headers"] = headers
+
+        self._log("info", f"📤 发送 {method} 请求: {url}")
+        if "params" in kwargs and kwargs["params"]:
+            self._log("info", f"🔎 Query: {kwargs['params']}")
+        if "json" in kwargs and kwargs["json"] is not None:
+            self._log("info", f"📦 请求体: {kwargs['json']}")
+
+        proxies = {"http": self.proxy_url, "https": self.proxy_url} if self.proxy_url else None
+
+        res = request_with_proxy_fallback(
+            requests.request,
+            method,
+            url,
+            proxies=proxies,
+            verify=self.verify_ssl,
+            timeout=kwargs.pop("timeout", 15),
+            **kwargs,
+        )
+        self._log("info", f"📥 收到响应: HTTP {res.status_code}")
+        log_body = os.getenv("GPTMAIL_LOG_BODY", "").strip().lower() in ("1", "true", "yes", "y", "on")
+        if res.content and (log_body or res.status_code >= 400):
+            try:
+                self._log("info", f"📄 响应内容: {res.text[:500]}")
+            except Exception:
+                pass
+        return res
+
+    def generate_email(self, domain: Optional[str] = None) -> Optional[str]:
+        """生成一个新的邮箱地址。"""
+        if not self.base_url:
+            self._log("error", "❌ GPTMail base_url 为空")
+            return None
+
+        rand = "".join(random.choices(string.ascii_lowercase + string.digits, k=10))
+        timestamp = str(int(time.time()))[-4:]
+        prefix = f"t{timestamp}{rand}"
+
+        payload: Dict[str, Any] = {"prefix": prefix}
+        # 优先使用传入的 domain，其次使用配置的 domain
+        effective_domain = domain or self.domain
+        if effective_domain:
+            payload["domain"] = effective_domain
+
+        url = f"{self.base_url}/api/generate-email"
+        try:
+            res = self._request("POST", url, json=payload)
+            if res.status_code != 200:
+                self._log("error", f"❌ 生成邮箱失败: HTTP {res.status_code}")
+                return None
+            body = res.json() if res.content else {}
+            if not body.get("success"):
+                self._log("error", f"❌ 生成邮箱失败: {body.get('error') or 'unknown error'}")
+                return None
+            email = ((body.get("data") or {}).get("email") or "").strip()
+            if not email:
+                self._log("error", "❌ 生成邮箱成功但响应缺少 email")
+                return None
+            self.email = email
+            self._log("info", f"✅ GPTMail 邮箱生成成功: {email}")
+            return email
+        except Exception as exc:
+            self._log("error", f"❌ 生成邮箱异常: {exc}")
+            return None
+
+    def register_account(self, domain: Optional[str] = None) -> bool:
+        """生成一个新的邮箱地址并视为注册成功。"""
+        return bool(self.generate_email(domain=domain))
+
+    def _list_emails(self, email: str) -> List[Dict[str, Any]]:
+        url = f"{self.base_url}/api/emails"
+        res = self._request("GET", url, params={"email": email})
+        if res.status_code != 200:
+            self._log("error", f"❌ 获取邮件列表失败: HTTP {res.status_code}")
+            return []
+        body = res.json() if res.content else {}
+        if not body.get("success"):
+            self._log("error", f"❌ 获取邮件列表失败: {body.get('error') or 'unknown error'}")
+            return []
+        return list(((body.get("data") or {}).get("emails") or []))
+
+    def _get_email(self, mail_id: str) -> Optional[Dict[str, Any]]:
+        url = f"{self.base_url}/api/email/{mail_id}"
+        res = self._request("GET", url)
+        if res.status_code != 200:
+            self._log("warning", f"⚠️ 获取邮件详情失败: HTTP {res.status_code}")
+            return None
+        body = res.json() if res.content else {}
+        if not body.get("success"):
+            self._log("warning", f"⚠️ 获取邮件详情失败: {body.get('error') or 'unknown error'}")
+            return None
+        return body.get("data") or None
+
+    def fetch_verification_code(self, since_time: Optional[datetime] = None) -> Optional[str]:
+        """获取验证码（从邮件内容提取）。"""
+        if not self.email:
+            return None
+
+        try:
+            self._log("info", "📬 正在拉取 GPTMail 邮件列表...")
+            emails = self._list_emails(self.email)
+            if not emails:
+                self._log("info", "📭 邮箱为空，暂无邮件")
+                return None
+
+            emails = sorted(emails, key=lambda item: int(item.get("timestamp") or 0), reverse=True)
+            self._log("info", f"📨 收到 {len(emails)} 封邮件，开始检查验证码...")
+
+            for msg in emails:
+                msg_id = str(msg.get("id") or "").strip()
+                if not msg_id:
+                    continue
+
+                ts = msg.get("timestamp")
+                if since_time and ts:
+                    try:
+                        msg_time = datetime.fromtimestamp(int(ts)).astimezone().replace(tzinfo=None)
+                        if msg_time < since_time:
+                            continue
+                    except Exception:
+                        pass
+
+                content = (msg.get("content") or "") + (msg.get("html_content") or "")
+                code = extract_verification_code(content)
+                if code:
+                    self._log("info", f"✅ 找到验证码: {code}")
+                    return code
+
+                detail = self._get_email(msg_id)
+                if not detail:
+                    continue
+
+                detail_text = (
+                    (detail.get("content") or "")
+                    + (detail.get("html_content") or "")
+                    + (detail.get("raw_content") or "")
+                )
+                code = extract_verification_code(detail_text)
+                if code:
+                    self._log("info", f"✅ 找到验证码: {code}")
+                    return code
+
+            self._log("warning", "⚠️ 所有邮件中均未找到验证码")
+            return None
+        except Exception as exc:
+            self._log("error", f"❌ 获取验证码异常: {exc}")
+            return None
+
+    def poll_for_code(
+        self,
+        timeout: int = 120,
+        interval: int = 4,
+        since_time: Optional[datetime] = None,
+    ) -> Optional[str]:
+        if not self.email:
+            return None
+
+        max_retries = max(1, timeout // interval)
+        self._log("info", f"⏱️ 开始轮询验证码 (超时 {timeout}秒, 间隔 {interval}秒, 最多 {max_retries} 次)")
+
+        for i in range(1, max_retries + 1):
+            self._log("info", f"🔄 第 {i}/{max_retries} 次轮询...")
+            code = self.fetch_verification_code(since_time=since_time)
+            if code:
+                self._log("info", f"🎉 验证码获取成功: {code}")
+                return code
+            if i < max_retries:
+                time.sleep(interval)
+
+        self._log("error", "❌ 验证码获取超时")
+        return None

core/jwt.py

@@ -0,0 +1,102 @@
+"""JWT管理模块
+
+负责JWT token的生成、刷新和管理
+"""
+import asyncio
+import base64
+import hashlib
+import hmac
+import json
+import logging
+import time
+from typing import TYPE_CHECKING
+
+import httpx
+from fastapi import HTTPException
+
+if TYPE_CHECKING:
+    from main import AccountConfig
+
+logger = logging.getLogger(__name__)
+
+
+def urlsafe_b64encode(data: bytes) -> str:
+    return base64.urlsafe_b64encode(data).decode().rstrip("=")
+
+def kq_encode(s: str) -> str:
+    b = bytearray()
+    for ch in s:
+        v = ord(ch)
+        if v > 255:
+            b.append(v & 255)
+            b.append(v >> 8)
+        else:
+            b.append(v)
+    return urlsafe_b64encode(bytes(b))
+
+def create_jwt(key_bytes: bytes, key_id: str, csesidx: str) -> str:
+    now = int(time.time())
+    header = {"alg": "HS256", "typ": "JWT", "kid": key_id}
+    payload = {
+        "iss": "https://business.gemini.google",
+        "aud": "https://biz-discoveryengine.googleapis.com",
+        "sub": f"csesidx/{csesidx}",
+        "iat": now,
+        "exp": now + 300,
+        "nbf": now,
+    }
+    header_b64  = kq_encode(json.dumps(header, separators=(",", ":")))
+    payload_b64 = kq_encode(json.dumps(payload, separators=(",", ":")))
+    message     = f"{header_b64}.{payload_b64}"
+    sig         = hmac.new(key_bytes, message.encode(), hashlib.sha256).digest()
+    return f"{message}.{urlsafe_b64encode(sig)}"
+
+
+class JWTManager:
+    """JWT token管理器
+
+    负责JWT的获取、刷新和缓存
+    """
+    def __init__(self, config: "AccountConfig", http_client: httpx.AsyncClient, user_agent: str) -> None:
+        self.config = config
+        self.http_client = http_client
+        self.user_agent = user_agent
+        self.jwt: str = ""
+        self.expires: float = 0
+        self._lock = asyncio.Lock()
+
+    async def get(self, request_id: str = "") -> str:
+        """获取JWT token（自动刷新）"""
+        async with self._lock:
+            if time.time() > self.expires:
+                await self._refresh(request_id)
+            return self.jwt
+
+    async def _refresh(self, request_id: str = "") -> None:
+        """刷新JWT token"""
+        cookie = f"__Secure-C_SES={self.config.secure_c_ses}"
+        if self.config.host_c_oses:
+            cookie += f"; __Host-C_OSES={self.config.host_c_oses}"
+
+        req_tag = f"[req_{request_id}] " if request_id else ""
+        r = await self.http_client.get(
+            "https://business.gemini.google/auth/getoxsrf",
+            params={"csesidx": self.config.csesidx},
+            headers={
+                "cookie": cookie,
+                "user-agent": self.user_agent,
+                "referer": "https://business.gemini.google/"
+            },
+        )
+        if r.status_code != 200:
+            error_body = r.text[:200] if r.text else ""
+            logger.error(f"[AUTH] [{self.config.account_id}] {req_tag}JWT 刷新失败: {r.status_code} {error_body}")
+            raise HTTPException(r.status_code, f"getoxsrf failed: {error_body}")
+
+        txt = r.text[4:] if r.text.startswith(")]}'") else r.text
+        data = json.loads(txt)
+
+        key_bytes = base64.urlsafe_b64decode(data["xsrfToken"] + "==")
+        self.jwt      = create_jwt(key_bytes, data["keyId"], self.config.csesidx)
+        self.expires = time.time() + 270
+        logger.info(f"[AUTH] [{self.config.account_id}] {req_tag}JWT 刷新成功")

core/login_service.py

@@ -0,0 +1,557 @@
+import asyncio
+import logging
+import os
+import time
+import uuid
+from dataclasses import dataclass, field
+from datetime import datetime, timedelta, timezone
+from typing import Any, Callable, Dict, List, Optional
+
+from core.account import load_accounts_from_source
+from core.base_task_service import BaseTask, BaseTaskService, TaskCancelledError, TaskStatus
+from core.config import config
+from core.mail_providers import create_temp_mail_client
+from core.gemini_automation import GeminiAutomation
+from core.microsoft_mail_client import MicrosoftMailClient
+from core.proxy_utils import parse_proxy_setting
+
+logger = logging.getLogger("gemini.login")
+
+# 常量定义
+CONFIG_CHECK_INTERVAL_SECONDS = 60  # 配置检查间隔（秒）
+
+
+@dataclass
+class LoginTask(BaseTask):
+    """登录任务数据类"""
+    account_ids: List[str] = field(default_factory=list)
+
+    def to_dict(self) -> dict:
+        """转换为字典"""
+        base_dict = super().to_dict()
+        base_dict["account_ids"] = self.account_ids
+        return base_dict
+
+
+class LoginService(BaseTaskService[LoginTask]):
+    """登录服务类 - 统一任务管理"""
+
+    def __init__(
+        self,
+        multi_account_mgr,
+        http_client,
+        user_agent: str,
+        retry_policy,
+        session_cache_ttl_seconds: int,
+        global_stats_provider: Callable[[], dict],
+        set_multi_account_mgr: Optional[Callable[[Any], None]] = None,
+    ) -> None:
+        super().__init__(
+            multi_account_mgr,
+            http_client,
+            user_agent,
+            retry_policy,
+            session_cache_ttl_seconds,
+            global_stats_provider,
+            set_multi_account_mgr,
+            log_prefix="REFRESH",
+        )
+        self._is_polling = False
+        # 防重复：记录每个账号最后一次成功刷新的时间戳
+        self._refresh_timestamps: Dict[str, float] = {}
+        # cron 触发记录：避免同一时间点当天重复触发
+        self._triggered_today: set = set()
+
+    def _get_running_task(self) -> Optional[LoginTask]:
+        """获取正在运行或等待中的任务"""
+        for task in self._tasks.values():
+            if isinstance(task, LoginTask) and task.status in (TaskStatus.PENDING, TaskStatus.RUNNING):
+                return task
+        return None
+
+    async def start_login(self, account_ids: List[str]) -> LoginTask:
+        """
+        启动登录任务 - 统一任务管理
+        - 如果有正在运行的任务，将新账户添加到该任务（去重）
+        - 如果没有正在运行的任务，创建新任务
+        """
+        async with self._lock:
+            if not account_ids:
+                raise ValueError("账户列表不能为空")
+
+            # 检查是否有正在运行的任务
+            running_task = self._get_running_task()
+
+            if running_task:
+                # 将新账户添加到现有任务（去重）
+                new_accounts = [aid for aid in account_ids if aid not in running_task.account_ids]
+
+                if new_accounts:
+                    running_task.account_ids.extend(new_accounts)
+                    self._append_log(
+                        running_task,
+                        "info",
+                        f"📝 添加 {len(new_accounts)} 个账户到现有任务 (总计: {len(running_task.account_ids)})"
+                    )
+                else:
+                    self._append_log(running_task, "info", "📝 所有账户已在当前任务中")
+
+                return running_task
+
+            # 创建新任务
+            task = LoginTask(id=str(uuid.uuid4()), account_ids=list(account_ids))
+            self._tasks[task.id] = task
+            self._append_log(task, "info", f"📝 创建刷新任务 (账号数量: {len(task.account_ids)})")
+
+            # 直接启动任务
+            self._current_task_id = task.id
+            asyncio.create_task(self._run_task_directly(task))
+            return task
+
+    async def _run_task_directly(self, task: LoginTask) -> None:
+        """直接执行任务"""
+        try:
+            await self._run_one_task(task)
+        finally:
+            # 任务完成后清理
+            async with self._lock:
+                if self._current_task_id == task.id:
+                    self._current_task_id = None
+
+    def _execute_task(self, task: LoginTask):
+        return self._run_login_async(task)
+
+    async def _run_login_async(self, task: LoginTask) -> None:
+        """异步执行登录任务（支持取消）。"""
+        loop = asyncio.get_running_loop()
+        self._append_log(task, "info", f"🚀 刷新任务已启动 (共 {len(task.account_ids)} 个账号)")
+
+        for idx, account_id in enumerate(task.account_ids, 1):
+            # 检查是否请求取消
+            if task.cancel_requested:
+                self._append_log(task, "warning", f"login task cancelled: {task.cancel_reason or 'cancelled'}")
+                task.status = TaskStatus.CANCELLED
+                task.finished_at = time.time()
+                return
+
+            try:
+                self._append_log(task, "info", f"📊 进度: {idx}/{len(task.account_ids)}")
+                self._append_log(task, "info", "━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━")
+                self._append_log(task, "info", f"🔄 开始刷新账号: {account_id}")
+                self._append_log(task, "info", "━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━")
+                result = await loop.run_in_executor(self._executor, self._refresh_one, account_id, task)
+            except TaskCancelledError:
+                # 线程侧已触发取消，直接结束任务
+                task.status = TaskStatus.CANCELLED
+                task.finished_at = time.time()
+                return
+            except Exception as exc:
+                result = {"success": False, "email": account_id, "error": str(exc)}
+            task.progress += 1
+            task.results.append(result)
+
+            if result.get("success"):
+                task.success_count += 1
+                # 记录刷新成功时间（防重复层 1）
+                self._refresh_timestamps[account_id] = time.time()
+                self._append_log(task, "info", "━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━")
+                self._append_log(task, "info", f"🎉 刷新成功: {account_id}")
+                self._append_log(task, "info", "━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━")
+            else:
+                task.fail_count += 1
+                error = result.get('error', '未知错误')
+                self._append_log(task, "error", "━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━")
+                self._append_log(task, "error", f"❌ 刷新失败: {account_id}")
+                self._append_log(task, "error", f"❌ 失败原因: {error}")
+                self._append_log(task, "error", "━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━")
+
+                # 403 自动禁用账户
+                if "403" in error:
+                    try:
+                        accounts = load_accounts_from_source()
+                        for acc in accounts:
+                            if acc.get("id") == account_id:
+                                acc["disabled"] = True
+                                acc["disabled_reason"] = "403 Access Restricted"
+                                break
+                        self._apply_accounts_update(accounts)
+                        # 同步到内存中的 account manager
+                        if account_id in self.multi_account_mgr.accounts:
+                            mgr = self.multi_account_mgr.accounts[account_id]
+                            mgr.config.disabled = True
+                            mgr.disabled_reason = "403 Access Restricted"
+                        self._append_log(task, "error", f"⛔ 已自动禁用账户: {account_id}")
+                    except Exception as e:
+                        self._append_log(task, "warning", f"⚠️ 自动禁用失败: {e}")
+
+            # 账号之间等待 10 秒，避免资源争抢和风控
+            if idx < len(task.account_ids) and not task.cancel_requested:
+                self._append_log(task, "info", "⏳ 等待 10 秒后处理下一个账号...")
+                await asyncio.sleep(10)
+
+        if task.cancel_requested:
+            task.status = TaskStatus.CANCELLED
+        else:
+            task.status = TaskStatus.SUCCESS if task.fail_count == 0 else TaskStatus.FAILED
+        task.finished_at = time.time()
+        self._append_log(task, "info", f"login task finished ({task.success_count}/{len(task.account_ids)})")
+        self._current_task_id = None
+        self._append_log(task, "info", f"🏁 刷新任务完成 (成功: {task.success_count}, 失败: {task.fail_count}, 总计: {len(task.account_ids)})")
+
+    def _refresh_one(self, account_id: str, task: LoginTask) -> dict:
+        """刷新单个账户"""
+        accounts = load_accounts_from_source()
+        account = next((acc for acc in accounts if acc.get("id") == account_id), None)
+        if not account:
+            return {"success": False, "email": account_id, "error": "账号不存在"}
+
+        if account.get("disabled"):
+            return {"success": False, "email": account_id, "error": "账号已禁用"}
+
+        # 获取邮件提供商
+        mail_provider = (account.get("mail_provider") or "").lower()
+        if not mail_provider:
+            if account.get("mail_client_id") or account.get("mail_refresh_token"):
+                mail_provider = "microsoft"
+            else:
+                mail_provider = "duckmail"
+
+        # 获取邮件配置
+        mail_password = account.get("mail_password") or account.get("email_password")
+        mail_client_id = account.get("mail_client_id")
+        mail_refresh_token = account.get("mail_refresh_token")
+        mail_tenant = account.get("mail_tenant") or "consumers"
+        proxy_for_auth, _ = parse_proxy_setting(config.basic.proxy_for_auth)
+
+        def log_cb(level, message):
+            self._append_log(task, level, f"[{account_id}] {message}")
+
+        log_cb("info", f"📧 邮件提供商: {mail_provider}")
+
+        # 创建邮件客户端
+        if mail_provider == "microsoft":
+            if not mail_client_id or not mail_refresh_token:
+                return {"success": False, "email": account_id, "error": "Microsoft OAuth 配置缺失"}
+            mail_address = account.get("mail_address") or account_id
+            client = MicrosoftMailClient(
+                client_id=mail_client_id,
+                refresh_token=mail_refresh_token,
+                tenant=mail_tenant,
+                proxy=proxy_for_auth,
+                log_callback=log_cb,
+            )
+            client.set_credentials(mail_address)
+        elif mail_provider in ("duckmail", "moemail", "freemail", "gptmail", "cfmail"):
+            if mail_provider not in ("freemail", "gptmail", "cfmail") and not mail_password:
+                error_message = "邮箱密码缺失" if mail_provider == "duckmail" else "mail password (email_id) missing"
+                return {"success": False, "email": account_id, "error": error_message}
+            if mail_provider == "freemail" and not account.get("mail_jwt_token") and not config.basic.freemail_jwt_token:
+                return {"success": False, "email": account_id, "error": "Freemail JWT Token 未配置"}
+
+            # 创建邮件客户端，优先使用账户级别配置
+            mail_address = account.get("mail_address") or account_id
+
+            # 构建账户级别的配置参数
+            account_config = {}
+            if account.get("mail_base_url"):
+                account_config["base_url"] = account["mail_base_url"]
+            if account.get("mail_api_key"):
+                account_config["api_key"] = account["mail_api_key"]
+            if account.get("mail_jwt_token"):
+                account_config["jwt_token"] = account["mail_jwt_token"]
+            if account.get("mail_verify_ssl") is not None:
+                account_config["verify_ssl"] = account["mail_verify_ssl"]
+            if account.get("mail_domain"):
+                account_config["domain"] = account["mail_domain"]
+
+            # 创建客户端（工厂会优先使用传入的参数，其次使用全局配置）
+            client = create_temp_mail_client(
+                mail_provider,
+                log_cb=log_cb,
+                **account_config
+            )
+            client.set_credentials(mail_address, mail_password)
+            if mail_provider == "moemail":
+                client.email_id = mail_password  # 设置 email_id 用于获取邮件
+        else:
+            return {"success": False, "email": account_id, "error": f"不支持的邮件提供商: {mail_provider}"}
+
+        headless = config.basic.browser_headless
+
+        log_cb("info", f"🌐 启动浏览器 (无头模式={headless})...")
+
+        automation = GeminiAutomation(
+            user_agent=self.user_agent,
+            proxy=proxy_for_auth,
+            headless=headless,
+            log_callback=log_cb,
+        )
+        # 允许外部取消时立刻关闭浏览器
+        self._add_cancel_hook(task.id, lambda: getattr(automation, "stop", lambda: None)())
+        try:
+            log_cb("info", "🔐 执行 Gemini 自动登录...")
+            result = automation.login_and_extract(account_id, client)
+        except Exception as exc:
+            log_cb("error", f"❌ 自动登录异常: {exc}")
+            return {"success": False, "email": account_id, "error": str(exc)}
+        if not result.get("success"):
+            error = result.get("error", "自动化流程失败")
+            log_cb("error", f"❌ 自动登录失败: {error}")
+            return {"success": False, "email": account_id, "error": error}
+
+        log_cb("info", "✅ Gemini 登录成功，正在保存配置...")
+
+        # 更新账户配置
+        config_data = result["config"]
+        config_data["mail_provider"] = mail_provider
+        if mail_provider in ("freemail", "gptmail"):
+            config_data["mail_password"] = ""
+        elif mail_provider == "cfmail":
+            config_data["mail_password"] = mail_password  # 保留 JWT token
+        else:
+            config_data["mail_password"] = mail_password
+        if mail_provider == "microsoft":
+            config_data["mail_address"] = account.get("mail_address") or account_id
+            config_data["mail_client_id"] = mail_client_id
+            config_data["mail_refresh_token"] = mail_refresh_token
+            config_data["mail_tenant"] = mail_tenant
+        config_data["disabled"] = account.get("disabled", False)
+
+        for acc in accounts:
+            if acc.get("id") == account_id:
+                acc.update(config_data)
+                break
+
+        self._apply_accounts_update(accounts)
+
+        # 清除该账户的所有冷却状态（重新登录后恢复可用）
+        if account_id in self.multi_account_mgr.accounts:
+            account_mgr = self.multi_account_mgr.accounts[account_id]
+            account_mgr.quota_cooldowns.clear()  # 清除配额冷却
+            account_mgr.is_available = True  # 恢复可用状态
+            log_cb("info", "✅ 已清除账户冷却状态")
+
+        log_cb("info", "✅ 配置已保存到数据库")
+        return {"success": True, "email": account_id, "config": config_data}
+
+
+    def _get_expiring_accounts(self) -> List[str]:
+        """获取即将过期的账户列表"""
+        accounts = load_accounts_from_source()
+        expiring = []
+        beijing_tz = timezone(timedelta(hours=8))
+        now = datetime.now(beijing_tz)
+
+        for account in accounts:
+            account_id = account.get("id")
+            if not account_id:
+                continue
+
+            if account.get("disabled"):
+                continue
+            mail_provider = (account.get("mail_provider") or "").lower()
+            if not mail_provider:
+                if account.get("mail_client_id") or account.get("mail_refresh_token"):
+                    mail_provider = "microsoft"
+                else:
+                    mail_provider = "duckmail"
+
+            mail_password = account.get("mail_password") or account.get("email_password")
+            if mail_provider == "microsoft":
+                if not account.get("mail_client_id") or not account.get("mail_refresh_token"):
+                    continue
+            elif mail_provider in ("duckmail", "moemail"):
+                if not mail_password:
+                    continue
+            elif mail_provider == "freemail":
+                if not config.basic.freemail_jwt_token:
+                    continue
+            elif mail_provider == "gptmail":
+                # GPTMail 不需要密码，允许直接刷新
+                pass
+            elif mail_provider == "cfmail":
+                # cfmail 需要 JWT token（存在 mail_password 中）或全局配置
+                if not mail_password and not config.basic.cfmail_api_key:
+                    continue
+            else:
+                continue
+            expires_at = account.get("expires_at")
+            if not expires_at:
+                continue
+
+            try:
+                expire_time = datetime.strptime(expires_at, "%Y-%m-%d %H:%M:%S")
+                expire_time = expire_time.replace(tzinfo=beijing_tz)
+                remaining = (expire_time - now).total_seconds() / 3600
+            except Exception:
+                continue
+
+            if remaining > config.basic.refresh_window_hours:
+                continue
+
+            # 冷却检查（防重复层 1）：跳过最近刚刷新过的账号
+            cooldown_seconds = config.retry.refresh_cooldown_hours * 3600
+            if account_id in self._refresh_timestamps:
+                elapsed = time.time() - self._refresh_timestamps[account_id]
+                if elapsed < cooldown_seconds:
+                    logger.debug(f"[LOGIN] skip {account_id}: refreshed {elapsed/3600:.1f}h ago, cooldown {config.retry.refresh_cooldown_hours}h")
+                    continue
+
+            if True:  # 通过所有检查
+                expiring.append(account_id)
+
+        return expiring
+
+    async def check_and_refresh(self) -> Optional[LoginTask]:
+        if os.environ.get("ACCOUNTS_CONFIG"):
+            logger.info("[LOGIN] ACCOUNTS_CONFIG set, skipping refresh")
+            return None
+        expiring_accounts = self._get_expiring_accounts()
+        if not expiring_accounts:
+            logger.debug("[LOGIN] no accounts need refresh")
+            return None
+
+        try:
+            return await self.start_login(expiring_accounts)
+        except Exception as exc:
+            logger.warning("[LOGIN] refresh enqueue failed: %s", exc)
+            return None
+
+    @staticmethod
+    def _parse_cron(cron_str: str) -> dict:
+        """解析 cron 表达式。
+        支持两种格式:
+          - '08:00,20:00' → {'mode': 'daily', 'times': ['08:00', '20:00']}
+          - '*/120'       → {'mode': 'interval', 'minutes': 120}
+        """
+        cron_str = cron_str.strip()
+        if cron_str.startswith("*/"):
+            try:
+                minutes = int(cron_str[2:])
+                return {"mode": "interval", "minutes": max(minutes, 5)}
+            except ValueError:
+                return {"mode": "interval", "minutes": 120}
+        else:
+            times = [t.strip() for t in cron_str.split(",") if t.strip()]
+            valid = []
+            for t in times:
+                parts = t.split(":")
+                if len(parts) == 2:
+                    try:
+                        h, m = int(parts[0]), int(parts[1])
+                        if 0 <= h <= 23 and 0 <= m <= 59:
+                            valid.append(f"{h:02d}:{m:02d}")
+                    except ValueError:
+                        pass
+            return {"mode": "daily", "times": valid or ["08:00", "20:00"]}
+
+    async def _wait_for_next_trigger(self) -> None:
+        """等待下一个触发时间点。
+        - interval 模式：等 N 分钟
+        - daily 模式：等到下一个匹配的 HH:MM，每个时间点每天只触发一次
+        """
+        cron_str = config.retry.scheduled_refresh_cron
+        # 向后兼容：如果旧字段有值且新字段是默认值，转换为 interval 模式
+        if (not cron_str or cron_str == "08:00,20:00") and config.retry.scheduled_refresh_interval_minutes > 0:
+            cron_str = f"*/{config.retry.scheduled_refresh_interval_minutes}"
+
+        cron = self._parse_cron(cron_str)
+
+        if cron["mode"] == "interval":
+            minutes = cron["minutes"]
+            logger.info(f"[LOGIN] 间隔模式：{minutes} 分钟后下一次检查")
+            await asyncio.sleep(minutes * 60)
+            return
+
+        # daily 模式：每秒检查一次当前时间是否命中
+        beijing_tz = timezone(timedelta(hours=8))
+        while self._is_polling:
+            now = datetime.now(beijing_tz)
+            current_time = now.strftime("%H:%M")
+            today_str = now.strftime("%Y-%m-%d")
+
+            # 新的一天，清空触发记录
+            old_keys = [k for k in self._triggered_today if not k.startswith(today_str)]
+            for k in old_keys:
+                self._triggered_today.discard(k)
+
+            for t in cron["times"]:
+                trigger_key = f"{today_str}_{t}"
+                if current_time == t and trigger_key not in self._triggered_today:
+                    self._triggered_today.add(trigger_key)
+                    logger.info(f"[LOGIN] 定时触发: {t}")
+                    return
+
+            await asyncio.sleep(30)  # 每 30 秒检查一次
+
+    async def _wait_task_complete(self, task: LoginTask) -> None:
+        """等待任务完成（防重复层 3：串行等待）"""
+        while task.status in (TaskStatus.PENDING, TaskStatus.RUNNING):
+            await asyncio.sleep(5)
+
+    async def start_polling(self) -> None:
+        if self._is_polling:
+            logger.warning("[LOGIN] polling already running")
+            return
+
+        self._is_polling = True
+        logger.info("[LOGIN] 智能刷新调度器已启动")
+        try:
+            while self._is_polling:
+                # 检查是否启用
+                if not config.retry.scheduled_refresh_enabled:
+                    logger.debug("[LOGIN] scheduled refresh disabled")
+                    await asyncio.sleep(CONFIG_CHECK_INTERVAL_SECONDS)
+                    continue
+
+                # 等待下一个触发时间点
+                await self._wait_for_next_trigger()
+                if not self._is_polling:
+                    break
+
+                # 获取所有待刷新账号（已含冷却过滤）
+                expiring = self._get_expiring_accounts()
+                if not expiring:
+                    logger.info("[LOGIN] 本轮无需刷新的账号")
+                    continue
+
+                batch_size = config.retry.refresh_batch_size
+                total_batches = (len(expiring) + batch_size - 1) // batch_size
+                logger.info(f"[LOGIN] 待刷新 {len(expiring)} 个账号，分 {total_batches} 批（每批 {batch_size} 个）")
+
+                # 分批执行
+                for i in range(0, len(expiring), batch_size):
+                    if not self._is_polling:
+                        break
+
+                    batch = expiring[i:i + batch_size]
+                    batch_num = i // batch_size + 1
+                    logger.info(f"[LOGIN] 第 {batch_num}/{total_batches} 批: {batch}")
+
+                    try:
+                        task = await self.start_login(batch)
+                        # 等待这批完成（防重复层 3）
+                        await self._wait_task_complete(task)
+                        logger.info(f"[LOGIN] 第 {batch_num} 批完成 (成功: {task.success_count}, 失败: {task.fail_count})")
+                    except Exception as exc:
+                        logger.warning(f"[LOGIN] 第 {batch_num} 批异常: {exc}")
+
+                    # 批次间等待（最后一批不等）
+                    remaining = expiring[i + batch_size:]
+                    if remaining and self._is_polling:
+                        interval = config.retry.refresh_batch_interval_minutes * 60
+                        logger.info(f"[LOGIN] 等待 {config.retry.refresh_batch_interval_minutes} 分钟后开始下一批...")
+                        await asyncio.sleep(interval)
+
+                logger.info("[LOGIN] 本轮刷新完成")
+
+        except asyncio.CancelledError:
+            logger.info("[LOGIN] polling stopped")
+        except Exception as exc:
+            logger.error("[LOGIN] polling error: %s", exc)
+        finally:
+            self._is_polling = False
+
+    def stop_polling(self) -> None:
+        self._is_polling = False
+        logger.info("[LOGIN] stopping polling")

core/mail_providers/__init__.py

@@ -0,0 +1,3 @@
+from .factory import create_temp_mail_client
+
+__all__ = ["create_temp_mail_client"]

core/mail_providers/factory.py

@@ -0,0 +1,94 @@
+from typing import Callable, Optional
+
+from core.config import config
+from core.proxy_utils import extract_host, no_proxy_matches, parse_proxy_setting
+from core.cfmail_client import CloudflareMailClient
+from core.duckmail_client import DuckMailClient
+from core.freemail_client import FreemailClient
+from core.gptmail_client import GPTMailClient
+from core.moemail_client import MoemailClient
+
+
+def create_temp_mail_client(
+    provider: str,
+    *,
+    domain: Optional[str] = None,
+    proxy: Optional[str] = None,
+    log_cb: Optional[Callable[[str, str], None]] = None,
+    base_url: Optional[str] = None,
+    api_key: Optional[str] = None,
+    jwt_token: Optional[str] = None,
+    verify_ssl: Optional[bool] = None,
+):
+    """
+    创建临时邮箱客户端
+
+    参数优先级：传入参数 > 全局配置
+    """
+    provider = (provider or "duckmail").lower()
+    if proxy is None:
+        proxy_source = config.basic.proxy_for_auth if config.basic.mail_proxy_enabled else ""
+    else:
+        proxy_source = proxy
+    proxy, no_proxy = parse_proxy_setting(proxy_source)
+
+    if provider == "moemail":
+        effective_base_url = base_url or config.basic.moemail_base_url
+        if no_proxy_matches(extract_host(effective_base_url), no_proxy):
+            proxy = ""
+        return MoemailClient(
+            base_url=effective_base_url,
+            proxy=proxy,
+            api_key=api_key or config.basic.moemail_api_key,
+            domain=domain or config.basic.moemail_domain,
+            log_callback=log_cb,
+        )
+
+    if provider == "freemail":
+        effective_base_url = base_url or config.basic.freemail_base_url
+        if no_proxy_matches(extract_host(effective_base_url), no_proxy):
+            proxy = ""
+        return FreemailClient(
+            base_url=effective_base_url,
+            jwt_token=jwt_token or config.basic.freemail_jwt_token,
+            proxy=proxy,
+            verify_ssl=verify_ssl if verify_ssl is not None else config.basic.freemail_verify_ssl,
+            log_callback=log_cb,
+        )
+
+    if provider == "gptmail":
+        effective_base_url = base_url or config.basic.gptmail_base_url
+        if no_proxy_matches(extract_host(effective_base_url), no_proxy):
+            proxy = ""
+        return GPTMailClient(
+            base_url=effective_base_url,
+            api_key=api_key or config.basic.gptmail_api_key,
+            proxy=proxy,
+            verify_ssl=verify_ssl if verify_ssl is not None else config.basic.gptmail_verify_ssl,
+            domain=domain or config.basic.gptmail_domain,
+            log_callback=log_cb,
+        )
+
+    if provider == "cfmail":
+        effective_base_url = base_url or config.basic.cfmail_base_url
+        if no_proxy_matches(extract_host(effective_base_url), no_proxy):
+            proxy = ""
+        return CloudflareMailClient(
+            base_url=effective_base_url,
+            proxy=proxy,
+            api_key=api_key or config.basic.cfmail_api_key,
+            domain=domain or config.basic.cfmail_domain,
+            verify_ssl=verify_ssl if verify_ssl is not None else config.basic.cfmail_verify_ssl,
+            log_callback=log_cb,
+        )
+
+    effective_base_url = base_url or config.basic.duckmail_base_url
+    if no_proxy_matches(extract_host(effective_base_url), no_proxy):
+        proxy = ""
+    return DuckMailClient(
+        base_url=effective_base_url,
+        proxy=proxy,
+        verify_ssl=verify_ssl if verify_ssl is not None else config.basic.duckmail_verify_ssl,
+        api_key=api_key or config.basic.duckmail_api_key,
+        log_callback=log_cb,
+    )

core/mail_utils.py

@@ -0,0 +1,29 @@
+import re
+from typing import Optional
+
+
+def extract_verification_code(text: str) -> Optional[str]:
+    """提取验证码"""
+    if not text:
+        return None
+
+    # 策略1: 上下文关键词匹配（中英文冒号）
+    context_pattern = r"(?:验证码|code|verification|passcode|pin).*?[:：]\s*([A-Za-z0-9]{4,8})\b"
+    match = re.search(context_pattern, text, re.IGNORECASE)
+    if match:
+        candidate = match.group(1)
+        # 排除 CSS 单位值
+        if not re.match(r"^\d+(?:px|pt|em|rem|vh|vw|%)$", candidate, re.IGNORECASE):
+            return candidate
+
+    # 策略2: 6位字母数字混合（与测试代码一致，优先级提高）
+    match = re.search(r"[A-Z0-9]{6}", text)
+    if match:
+        return match.group(0)
+
+    # 策略3: 6位数字（降级为备选）
+    digits = re.findall(r"\b\d{6}\b", text)
+    if digits:
+        return digits[0]
+
+    return None

core/message.py

@@ -0,0 +1,154 @@
+"""消息处理模块
+
+负责消息的解析、文本提取和会话指纹生成
+"""
+import asyncio
+import base64
+import hashlib
+import logging
+import re
+from typing import List, TYPE_CHECKING
+
+import httpx
+
+if TYPE_CHECKING:
+    from main import Message
+
+logger = logging.getLogger(__name__)
+
+
+def get_conversation_key(messages: List[dict], client_identifier: str = "") -> str:
+    """
+    生成对话指纹（使用前3条消息+客户端标识，确保唯一性）
+
+    策略：
+    1. 使用前3条消息生成指纹（而非仅第1条）
+    2. 加入客户端标识（IP或request_id）避免不同用户冲突
+    3. 保持Session复用能力（同一用户的后续消息仍能找到同一Session）
+
+    Args:
+        messages: 消息列表
+        client_identifier: 客户端标识（如IP地址或request_id），用于区分不同用户
+    """
+    if not messages:
+        return f"{client_identifier}:empty" if client_identifier else "empty"
+
+    # 提取前3条消息的关键信息（角色+内容）
+    message_fingerprints = []
+    for msg in messages[:3]:  # 只取前3条
+        role = msg.get("role", "")
+        content = msg.get("content", "")
+
+        # 统一处理内容格式（字符串或数组）
+        if isinstance(content, list):
+            # 多模态消息：只提取文本部分
+            text = extract_text_from_content(content)
+        else:
+            text = str(content)
+
+        # 标准化：去除首尾空白，转小写
+        text = text.strip().lower()
+
+        # 组合角色和内容
+        message_fingerprints.append(f"{role}:{text}")
+
+    # 使用前3条消息+客户端标识生成指纹
+    conversation_prefix = "|".join(message_fingerprints)
+    if client_identifier:
+        conversation_prefix = f"{client_identifier}|{conversation_prefix}"
+
+    return hashlib.md5(conversation_prefix.encode()).hexdigest()
+
+
+def extract_text_from_content(content) -> str:
+    """
+    从消息 content 中提取文本内容
+    统一处理字符串和多模态数组格式
+    """
+    if isinstance(content, str):
+        return content
+    elif isinstance(content, list):
+        # 多模态消息：只提取文本部分
+        return "".join([x.get("text", "") for x in content if x.get("type") == "text"])
+    else:
+        return str(content)
+
+
+async def parse_last_message(messages: List['Message'], http_client: httpx.AsyncClient, request_id: str = ""):
+    """解析最后一条消息，分离文本和文件（支持图片、PDF、文档等，base64 和 URL）"""
+    if not messages:
+        return "", []
+
+    last_msg = messages[-1]
+    content = last_msg.content
+
+    text_content = ""
+    images = [] # List of {"mime": str, "data": str_base64} - 兼容变量名，实际支持所有文件
+    image_urls = []  # 需要下载的 URL - 兼容变量名，实际支持所有文件
+
+    if isinstance(content, str):
+        text_content = content
+    elif isinstance(content, list):
+        for part in content:
+            if part.get("type") == "text":
+                text_content += part.get("text", "")
+            elif part.get("type") == "image_url":
+                url = part.get("image_url", {}).get("url", "")
+                # 解析 Data URI: data:mime/type;base64,xxxxxx (支持所有 MIME 类型)
+                match = re.match(r"data:([^;]+);base64,(.+)", url)
+                if match:
+                    images.append({"mime": match.group(1), "data": match.group(2)})
+                elif url.startswith(("http://", "https://")):
+                    image_urls.append(url)
+                else:
+                    logger.warning(f"[FILE] [req_{request_id}] 不支持的文件格式: {url[:30]}...")
+
+    # 并行下载所有 URL 文件（支持图片、PDF、文档等）
+    if image_urls:
+        async def download_url(url: str):
+            try:
+                resp = await http_client.get(url, timeout=30, follow_redirects=True)
+                if resp.status_code == 404:
+                    logger.warning(f"[FILE] [req_{request_id}] URL文件已失效(404)，已跳过: {url[:50]}...")
+                    return None
+                resp.raise_for_status()
+                content_type = resp.headers.get("content-type", "application/octet-stream").split(";")[0]
+                # 移除图片类型限制，支持所有文件类型
+                b64 = base64.b64encode(resp.content).decode()
+                logger.info(f"[FILE] [req_{request_id}] URL文件下载成功: {url[:50]}... ({len(resp.content)} bytes, {content_type})")
+                return {"mime": content_type, "data": b64}
+            except httpx.HTTPStatusError as e:
+                status_code = e.response.status_code if e.response else "unknown"
+                logger.warning(f"[FILE] [req_{request_id}] URL文件下载失败({status_code}): {url[:50]}... - {e}")
+                return None
+            except Exception as e:
+                logger.warning(f"[FILE] [req_{request_id}] URL文件下���失败: {url[:50]}... - {e}")
+                return None
+
+        results = await asyncio.gather(*[download_url(u) for u in image_urls], return_exceptions=True)
+        safe_results = []
+        for result in results:
+            if isinstance(result, Exception):
+                logger.warning(f"[FILE] [req_{request_id}] URL文件下载异常: {type(result).__name__}: {str(result)[:120]}")
+                continue
+            safe_results.append(result)
+        images.extend([r for r in safe_results if r])
+
+    return text_content, images
+
+
+def build_full_context_text(messages: List['Message']) -> str:
+    """仅拼接历史文本，图片只处理当次请求的"""
+    prompt = ""
+    for msg in messages:
+        role = "User" if msg.role in ["user", "system"] else "Assistant"
+        content_str = extract_text_from_content(msg.content)
+
+        # 为多模态消息添加图片标记
+        if isinstance(msg.content, list):
+            image_count = sum(1 for part in msg.content if part.get("type") == "image_url")
+            if image_count > 0:
+                content_str += "[图片]" * image_count
+
+        prompt += f"{role}: {content_str}\n\n"
+    return prompt

core/microsoft_mail_client.py

@@ -0,0 +1,221 @@
+import imaplib
+import time
+from datetime import datetime, timedelta
+from email import message_from_bytes
+from email.utils import parsedate_to_datetime
+from typing import Optional
+
+import requests
+
+from core.mail_utils import extract_verification_code
+
+# 常量定义
+CANCELLATION_CHECK_INTERVAL_SECONDS = 5  # 取消检查间隔（秒）
+
+
+class MicrosoftMailClient:
+    def __init__(
+        self,
+        client_id: str,
+        refresh_token: str,
+        tenant: str = "consumers",
+        proxy: str = "",
+        log_callback=None,
+    ) -> None:
+        self.client_id = client_id
+        self.refresh_token = refresh_token
+        self.tenant = tenant or "consumers"
+        self.proxies = {"http": proxy, "https": proxy} if proxy else None
+        self.log_callback = log_callback
+        self.email: Optional[str] = None
+
+    def set_credentials(self, email: str, password: Optional[str] = None) -> None:
+        self.email = email
+
+    def _get_access_token(self) -> Optional[str]:
+        url = f"https://login.microsoftonline.com/{self.tenant}/oauth2/v2.0/token"
+        data = {
+            "client_id": self.client_id,
+            "grant_type": "refresh_token",
+            "refresh_token": self.refresh_token,
+        }
+        try:
+            self._log("info", f"🔑 正在获取 Microsoft OAuth 令牌...")
+            res = requests.post(url, data=data, proxies=self.proxies, timeout=15)
+            if res.status_code != 200:
+                self._log("error", f"❌ Microsoft 令牌获取失败: HTTP {res.status_code}")
+                return None
+            payload = res.json() if res.content else {}
+            token = payload.get("access_token")
+            if not token:
+                self._log("error", "❌ Microsoft 令牌响应中缺少 access_token")
+                return None
+            self._log("info", "✅ Microsoft OAuth 令牌获取成功")
+            return token
+        except Exception as exc:
+            self._log("error", f"❌ Microsoft 令牌获取异常: {exc}")
+            return None
+
+    def fetch_verification_code(self, since_time: Optional[datetime] = None) -> Optional[str]:
+        if not self.email:
+            return None
+
+        self._log("info", "📬 正在获取验证码...")
+        token = self._get_access_token()
+        if not token:
+            self._log("error", "❌ 无法获取访问令牌，跳过邮箱检查")
+            return None
+
+        auth_string = f"user={self.email}\x01auth=Bearer {token}\x01\x01".encode()
+        client = imaplib.IMAP4_SSL("outlook.office365.com", 993)
+        try:
+            self._log("info", f"🔐 正在使用 IMAP XOAUTH2 认证: {self.email}")
+            client.authenticate("XOAUTH2", lambda _: auth_string)
+            self._log("info", "✅ IMAP 认证成功，已连接到邮箱")
+        except Exception as exc:
+            self._log("error", f"❌ IMAP 认证失败: {exc}")
+            try:
+                client.logout()
+            except Exception:
+                pass
+            return None
+
+        search_since = since_time or (datetime.now() - timedelta(minutes=5))
+        self._log("info", f"🔍 搜索 {search_since.strftime('%Y-%m-%d %H:%M:%S')} 之后的邮件")
+
+        try:
+            for mailbox in ("INBOX", "Junk"):
+                try:
+                    status, _ = client.select(mailbox, readonly=True)
+                    if status != "OK":
+                        self._log("warning", f"⚠️ 无法选择邮箱: {mailbox}")
+                        continue
+                    self._log("info", f"📂 正在检查邮箱: {mailbox}")
+                except Exception as e:
+                    self._log("warning", f"⚠️ 选择邮箱 {mailbox} 时出错: {e}")
+                    continue
+
+                # 搜索所有邮件
+                status, data = client.search(None, "ALL")
+                if status != "OK" or not data or not data[0]:
+                    self._log("info", f"📭 邮箱 {mailbox} 中没有邮件")
+                    continue
+
+                ids = data[0].split()[-5:]  # 只检查最近 5 封
+                self._log("info", f"📨 在 {mailbox} 中发现 {len(ids)} 封邮件")
+
+                checked_count = 0
+                for msg_id in reversed(ids):
+                    status, msg_data = client.fetch(msg_id, "(RFC822)")
+                    if status != "OK" or not msg_data:
+                        continue
+                    raw_bytes = None
+                    for item in msg_data:
+                        if isinstance(item, tuple) and len(item) > 1:
+                            raw_bytes = item[1]
+                            break
+                    if not raw_bytes:
+                        continue
+
+                    msg = message_from_bytes(raw_bytes)
+                    msg_date = self._parse_message_date(msg.get("Date"))
+
+                    # 按时间过滤（静默跳过旧邮件）
+                    if msg_date and msg_date < search_since:
+                        continue
+
+                    checked_count += 1
+                    content = self._message_to_text(msg)
+                    import re
+                    match = re.search(r'[A-Z0-9]{6}', content)
+                    if match:
+                        code = match.group(0)
+                        self._log("info", f"🎉 在 {mailbox} 中找到验证码: {code}")
+                        return code
+
+                if checked_count > 0:
+                    self._log("info", f"🔍 已检查 {mailbox} 中 {checked_count} 封近期邮件，未找到验证码")
+
+            self._log("warning", "⚠️ 所有邮箱中均未找到验证码")
+        finally:
+            try:
+                client.logout()
+            except Exception:
+                pass
+
+        return None
+
+    def poll_for_code(
+        self,
+        timeout: int = 120,
+        interval: int = 4,
+        since_time: Optional[datetime] = None,
+    ) -> Optional[str]:
+        if not self.email:
+            return None
+
+        max_retries = max(1, timeout // interval)
+        self._log("info", f"⏱️ 开始轮询验证码 (超时 {timeout}秒, 间隔 {interval}秒, 最多 {max_retries} 次)")
+
+        for i in range(1, max_retries + 1):
+            # 检查任务是否被取消（通过 log 触发 TaskCancelledError）
+            self._log("info", f"🔄 第 {i}/{max_retries} 次轮询...")
+            code = self.fetch_verification_code(since_time=since_time)
+            if code:
+                self._log("info", f"🎉 验证码获取成功: {code}")
+                return code
+            if i < max_retries:
+                # 分段 sleep，每5秒检查一次取消状态
+                for _ in range(interval // CANCELLATION_CHECK_INTERVAL_SECONDS):
+                    time.sleep(CANCELLATION_CHECK_INTERVAL_SECONDS)
+                    # 通过 log 检查取消状态（使用有意义的日志）
+                    self._log("debug", f"等待验证码中... ({(_ + 1) * CANCELLATION_CHECK_INTERVAL_SECONDS}/{interval}秒)")
+                # 处理剩余的秒数
+                remaining = interval % CANCELLATION_CHECK_INTERVAL_SECONDS
+                if remaining > 0:
+                    time.sleep(remaining)
+
+        self._log("error", "❌ 验证码获取超时")
+        return None
+
+    @staticmethod
+    def _message_to_text(msg) -> str:
+        if msg.is_multipart():
+            parts = []
+            for part in msg.walk():
+                content_type = part.get_content_type()
+                if content_type not in ("text/plain", "text/html"):
+                    continue
+                payload = part.get_payload(decode=True)
+                if not payload:
+                    continue
+                charset = part.get_content_charset() or "utf-8"
+                parts.append(payload.decode(charset, errors="ignore"))
+            return "".join(parts)
+        payload = msg.get_payload(decode=True)
+        if isinstance(payload, bytes):
+            return payload.decode(msg.get_content_charset() or "utf-8", errors="ignore")
+        return str(payload) if payload else ""
+
+    @staticmethod
+    def _parse_message_date(value: Optional[str]) -> Optional[datetime]:
+        if not value:
+            return None
+        try:
+            parsed = parsedate_to_datetime(value)
+            if parsed is None:
+                return None
+            if parsed.tzinfo:
+                return parsed.astimezone(tz=None).replace(tzinfo=None)
+            return parsed
+        except Exception:
+            return None
+
+    def _log(self, level: str, message: str) -> None:
+        if self.log_callback:
+            try:
+                self.log_callback(level, message)
+            except TaskCancelledError:
+                raise
+            except Exception:
+                pass

core/moemail_client.py

@@ -0,0 +1,355 @@
+"""
+Moemail临时邮箱客户端
+
+API文档参考:
+- 获取系统配置: GET /api/config
+- 生成临时邮箱: POST /api/emails/generate
+- 获取邮件列表: GET /api/emails/{emailId}
+- 获取单封邮件: GET /api/emails/{emailId}/{messageId}
+"""
+
+import random
+import string
+import time
+from typing import Optional
+
+import requests
+
+from core.mail_utils import extract_verification_code
+from core.proxy_utils import request_with_proxy_fallback
+
+
+class MoemailClient:
+    """Moemail临时邮箱客户端"""
+
+    def __init__(
+        self,
+        base_url: str = "https://moemail.nanohajimi.mom",
+        proxy: str = "",
+        api_key: str = "",
+        domain: str = "",
+        log_callback=None,
+    ) -> None:
+        self.base_url = base_url.rstrip("/")
+        self.proxies = {"http": proxy, "https": proxy} if proxy else None
+        self.api_key = api_key.strip()
+        self.domain = domain.strip() if domain else ""
+        self.log_callback = log_callback
+
+        self.email: Optional[str] = None
+        self.email_id: Optional[str] = None
+        self.password: Optional[str] = None  # 兼容 DuckMailClient 接口
+
+        # 缓存可用域名列表
+        self._available_domains: list = []
+
+    def set_credentials(self, email: str, password: str = "") -> None:
+        """设置凭据（兼容 DuckMailClient 接口）"""
+        self.email = email
+        self.password = password
+
+    def _request(self, method: str, url: str, **kwargs) -> requests.Response:
+        """发送请求并打印详细日志"""
+        headers = kwargs.pop("headers", None) or {}
+        if self.api_key and "X-API-Key" not in headers:
+            headers["X-API-Key"] = self.api_key
+        headers.setdefault("Content-Type", "application/json")
+        kwargs["headers"] = headers
+
+        self._log("info", f"📤 发送 {method} 请求: {url}")
+        if "json" in kwargs:
+            self._log("info", f"📦 请求体: {kwargs['json']}")
+
+        try:
+            res = request_with_proxy_fallback(
+                requests.request,
+                method,
+                url,
+                proxies=self.proxies,
+                timeout=kwargs.pop("timeout", 30),
+                **kwargs,
+            )
+            self._log("info", f"📥 收到响应: HTTP {res.status_code}")
+            if res.content and res.status_code >= 400:
+                try:
+                    self._log("error", f"📄 响应内容: {res.text[:500]}")
+                except Exception:
+                    pass
+            return res
+        except Exception as e:
+            self._log("error", f"❌ 网络请求失败: {e}")
+            raise
+
+    def _get_available_domains(self) -> list:
+        """获取可用的邮箱域名列表"""
+        if self._available_domains:
+            return self._available_domains
+
+        try:
+            res = self._request("GET", f"{self.base_url}/api/config")
+            if res.status_code == 200:
+                data = res.json()
+                email_domains_str = data.get("emailDomains", "")
+                if email_domains_str:
+                    self._available_domains = [d.strip() for d in email_domains_str.split(",") if d.strip()]
+                    self._log("info", f"🌐 Moemail 可用域名: {self._available_domains}")
+                    return self._available_domains
+        except Exception as e:
+            self._log("error", f"❌ 获取可用域名失败: {e}")
+
+        # 默认域名
+        self._available_domains = ["moemail.app"]
+        return self._available_domains
+
+    def register_account(self, domain: Optional[str] = None) -> bool:
+        """注册新邮箱账号
+
+        API: POST /api/emails/generate
+        """
+        # 确定使用的域名
+        selected_domain = domain
+        if not selected_domain:
+            selected_domain = self.domain
+
+        if not selected_domain:
+            # 从可用域名中随机选择
+            available = self._get_available_domains()
+            if available:
+                selected_domain = random.choice(available)
+            else:
+                selected_domain = "moemail.app"
+
+        self._log("info", f"📧 使用域名: {selected_domain}")
+
+        # 生成随机邮箱名称
+        rand = "".join(random.choices(string.ascii_lowercase + string.digits, k=10))
+        timestamp = str(int(time.time()))[-4:]
+        name = f"t{timestamp}{rand}"
+
+        self._log("info", f"🎲 生成邮箱: {name}@{selected_domain}")
+
+        try:
+            # 设置为 0 表示永久有效
+            self._log("info", f"⏰ 设置过期时间: 永久有效")
+
+            res = self._request(
+                "POST",
+                f"{self.base_url}/api/emails/generate",
+                json={
+                    "name": name,
+                    "expiryTime": 0,
+                    "domain": selected_domain,
+                },
+            )
+
+            if res.status_code in (200, 201):
+                data = res.json() if res.content else {}
+                self.email = data.get("email", "")
+                self.email_id = data.get("id", "")
+                self.password = self.email_id  # 用 email_id 作为 password 存储
+
+                if self.email and self.email_id:
+                    self._log("info", f"✅ Moemail 注册成功: {self.email}")
+                    self._log("info", f"🔑 Email ID: {self.email_id}")
+                    return True
+
+            self._log("error", f"❌ Moemail 注册失败: HTTP {res.status_code}")
+            if res.content:
+                self._log("error", f"📄 响应内容: {res.text[:500]}")
+            return False
+
+        except Exception as e:
+            self._log("error", f"❌ Moemail 注册异常: {e}")
+            return False
+
+    def login(self) -> bool:
+        """登录（Moemail 无需登录，返回 True）"""
+        # Moemail 使用 API Key 认证，无需单独登录
+        return True
+
+    def fetch_verification_code(self, since_time=None) -> Optional[str]:
+        """获取验证码
+
+        API: GET /api/emails/{emailId}
+        API: GET /api/emails/{emailId}/{messageId}
+        """
+        if not self.email_id:
+            self._log("error", "❌ 缺少 email_id，无法获取邮件")
+            return None
+
+        try:
+            self._log("info", "📬 正在拉取 Moemail 邮件列表...")
+
+            # 获取邮件列表
+            res = self._request(
+                "GET",
+                f"{self.base_url}/api/emails/{self.email_id}",
+            )
+
+            if res.status_code != 200:
+                self._log("error", f"❌ 获取邮件列表失败: HTTP {res.status_code}")
+                return None
+
+            data = res.json() if res.content else {}
+            messages = data.get("messages", [])
+
+            if not messages:
+                self._log("info", "📭 邮箱为空，暂无邮件")
+                return None
+
+            self._log("info", f"📨 收到 {len(messages)} 封邮件，开始检查验证码...")
+
+            from datetime import datetime
+
+            def _parse_message_time(msg_obj) -> Optional[datetime]:
+                import re
+
+                time_keys = [
+                    "createdAt",
+                    "receivedAt",
+                    "sentAt",
+                    "created_at",
+                    "received_at",
+                    "sent_at",
+                ]
+                raw_time = None
+                for key in time_keys:
+                    if msg_obj.get(key) is not None:
+                        raw_time = msg_obj.get(key)
+                        break
+
+                if raw_time is None:
+                    return None
+
+                if isinstance(raw_time, (int, float)):
+                    timestamp = float(raw_time)
+                    if timestamp > 1e12:
+                        timestamp = timestamp / 1000.0
+                    return datetime.fromtimestamp(timestamp)
+
+                if isinstance(raw_time, str):
+                    raw_time = raw_time.strip()
+                    if raw_time.isdigit():
+                        timestamp = float(raw_time)
+                        if timestamp > 1e12:
+                            timestamp = timestamp / 1000.0
+                        return datetime.fromtimestamp(timestamp)
+
+                    # 处理 ISO 时间字符串
+                    try:
+                        # 截断纳秒到微秒
+                        raw_time = re.sub(r"(\.\d{6})\d+", r"\1", raw_time)
+                        return datetime.fromisoformat(raw_time.replace("Z", "+00:00")).astimezone().replace(tzinfo=None)
+                    except Exception:
+                        return None
+
+                return None
+
+            def _looks_like_verification(msg_obj) -> bool:
+                subject = (msg_obj.get("subject") or "").strip()
+                if not subject:
+                    return False
+                import re
+                return re.search(r"(验证码|验证|verification|verify|passcode|security\s*code|one[-\s]?time|otp)", subject, re.IGNORECASE) is not None
+
+            messages_with_time = [(msg, _parse_message_time(msg)) for msg in messages]
+            if any(item[1] for item in messages_with_time):
+                messages_with_time.sort(key=lambda item: item[1] or datetime.min, reverse=True)
+                messages = [item[0] for item in messages_with_time]
+
+            # 遍历邮件
+            for idx, msg in enumerate(messages, 1):
+                msg_id = msg.get("id")
+                if not msg_id:
+                    continue
+
+                # 时间过滤
+                if since_time:
+                    msg_time = _parse_message_time(msg)
+                    if msg_time:
+                        if msg_time < since_time:
+                            continue
+
+                    if not _looks_like_verification(msg):
+                        continue
+
+                # 优先从邮件列表的 content 字段提取验证码（更高效）
+                list_content = msg.get("content") or ""
+                if list_content:
+                    code = extract_verification_code(list_content)
+                    if code:
+                        self._log("info", f"✅ 找到验证码: {code}")
+                        return code
+
+                # 如果列表没有 content，则获取邮件详情
+                self._log("info", f"🔍 正在读取邮件 {idx}/{len(messages)} 详情...")
+                detail_res = self._request(
+                    "GET",
+                    f"{self.base_url}/api/emails/{self.email_id}/{msg_id}",
+                )
+
+                if detail_res.status_code != 200:
+                    self._log("warning", f"⚠️ 读取邮件详情失败: HTTP {detail_res.status_code}")
+                    continue
+
+                detail = detail_res.json() if detail_res.content else {}
+
+                # 处理 {'message': {...}} 格式
+                if "message" in detail and isinstance(detail["message"], dict):
+                    detail = detail["message"]
+
+                # 获取邮件内容
+                text_content = detail.get("text") or detail.get("textContent") or detail.get("content") or ""
+                html_content = detail.get("html") or detail.get("htmlContent") or ""
+
+                if isinstance(html_content, list):
+                    html_content = "".join(str(item) for item in html_content)
+                if isinstance(text_content, list):
+                    text_content = "".join(str(item) for item in text_content)
+
+                content = text_content + html_content
+                if content:
+                    code = extract_verification_code(content)
+                    if code:
+                        self._log("info", f"✅ 找到验证码: {code}")
+                        return code
+                    else:
+                        self._log("info", f"❌ 邮件 {idx} 中未找到验证码")
+
+            self._log("warning", "⚠️ 所有邮件中均未找到验证码")
+            return None
+
+        except Exception as e:
+            self._log("error", f"❌ 获取验证码异常: {e}")
+            return None
+
+    def poll_for_code(
+        self,
+        timeout: int = 120,
+        interval: int = 4,
+        since_time=None,
+    ) -> Optional[str]:
+        """轮询获取验证码"""
+        max_retries = max(1, timeout // interval)
+        self._log("info", f"⏱️ 开始轮询验证码 (超时 {timeout}秒, 间隔 {interval}秒, 最多 {max_retries} 次)")
+
+        for i in range(1, max_retries + 1):
+            self._log("info", f"🔄 第 {i}/{max_retries} 次轮询...")
+            code = self.fetch_verification_code(since_time=since_time)
+            if code:
+                self._log("info", f"🎉 验证码获取成功: {code}")
+                return code
+
+            if i < max_retries:
+                self._log("info", f"⏳ 等待 {interval} 秒后重试...")
+                time.sleep(interval)
+
+        self._log("error", f"⏰ 验证码获取超时 ({timeout}秒)")
+        return None
+
+    def _log(self, level: str, message: str) -> None:
+        if self.log_callback:
+            try:
+                self.log_callback(level, message)
+            except Exception:
+                pass

core/proxy_utils.py

@@ -0,0 +1,222 @@
+"""
+代理设置工具函数
+
+支持格式:
+- http://127.0.0.1:7890
+- http://user:pass@127.0.0.1:7890
+- socks5h://127.0.0.1:7890
+- socks5h://user:pass@127.0.0.1:7890 | no_proxy=localhost,127.0.0.1,.local
+
+NO_PROXY 格式:
+- 逗号分隔的主机名或域名后缀
+- 支持通配符前缀，如 .local 匹配 *.local
+"""
+
+import re
+from typing import Tuple, Callable, Any, Optional
+from urllib.parse import urlparse
+import functools
+
+
+def parse_proxy_setting(proxy_str: str) -> Tuple[str, str]:
+    """
+    解析代理设置字符串，提取代理 URL 和 NO_PROXY 列表
+
+    Args:
+        proxy_str: 代理设置字符串，格式如 "http://127.0.0.1:7890 | no_proxy=localhost,127.0.0.1"
+
+    Returns:
+        Tuple[str, str]: (proxy_url, no_proxy_list)
+        - proxy_url: 代理地址，如 "http://127.0.0.1:7890"
+        - no_proxy_list: NO_PROXY 列表字符串，如 "localhost,127.0.0.1"
+    """
+    if not proxy_str:
+        return "", ""
+
+    proxy_str = proxy_str.strip()
+    if not proxy_str:
+        return "", ""
+
+    # 检查是否包含 no_proxy 设置
+    # 支持格式: proxy_url | no_proxy=host1,host2
+    no_proxy = ""
+    proxy_url = proxy_str
+
+    # 使用 | 分隔代理和 no_proxy
+    if "|" in proxy_str:
+        parts = proxy_str.split("|", 1)
+        proxy_url = parts[0].strip()
+        no_proxy_part = parts[1].strip()
+
+        # 解析 no_proxy=xxx 格式
+        no_proxy_match = re.match(r"no_proxy\s*=\s*(.+)", no_proxy_part, re.IGNORECASE)
+        if no_proxy_match:
+            no_proxy = no_proxy_match.group(1).strip()
+
+    return normalize_proxy_url(proxy_url), no_proxy
+
+
+def extract_host(url: str) -> str:
+    """
+    从 URL 中提取主机名
+
+    Args:
+        url: 完整 URL，如 "https://mail.chatgpt.org.uk/api/emails"
+
+    Returns:
+        str: 主机名，如 "mail.chatgpt.org.uk"
+    """
+    if not url:
+        return ""
+
+    url = url.strip()
+    if not url:
+        return ""
+
+    # 如果没有协议前缀，添加一个以便解析
+    if not url.startswith(("http://", "https://", "socks5://", "socks5h://")):
+        url = "http://" + url
+
+    try:
+        parsed = urlparse(url)
+        return parsed.hostname or ""
+    except Exception:
+        return ""
+
+
+def no_proxy_matches(host: str, no_proxy: str) -> bool:
+    """
+    检查主机是否在 NO_PROXY 豁免列表中
+
+    Args:
+        host: 要检查的主机名，如 "mail.chatgpt.org.uk"
+        no_proxy: NO_PROXY 列表字符串，如 "localhost,127.0.0.1,.local"
+
+    Returns:
+        bool: 如果主机在豁免列表中返回 True，否则返回 False
+
+    匹配规则:
+        - 精确匹配: "localhost" 匹配 "localhost"
+        - 域名后缀匹配: ".local" 匹配 "foo.local", "bar.foo.local"
+        - IP 地址匹配: "127.0.0.1" 精确匹配
+    """
+    if not host or not no_proxy:
+        return False
+
+    host = host.lower().strip()
+    if not host:
+        return False
+
+    # 解析 no_proxy 列表
+    no_proxy_list = [item.strip().lower() for item in no_proxy.split(",") if item.strip()]
+
+    for pattern in no_proxy_list:
+        if not pattern:
+            continue
+
+        # 精确匹配
+        if host == pattern:
+            return True
+
+        # 域名后缀匹配 (如 .local 匹配 foo.local)
+        if pattern.startswith("."):
+            if host.endswith(pattern) or host == pattern[1:]:
+                return True
+        else:
+            # 也支持不带点的后缀匹配 (如 local 匹配 foo.local)
+            if host.endswith("." + pattern):
+                return True
+
+    return False
+
+
+def normalize_proxy_url(proxy_str: str) -> str:
+    """
+    标准化代理 URL 格式
+
+    支持的输入格式:
+    - http://127.0.0.1:7890
+    - http://user:pass@127.0.0.1:7890
+    - socks5://127.0.0.1:7890
+    - socks5h://127.0.0.1:7890
+    - 127.0.0.1:7890 (自动添加 http://)
+    - host:port:user:pass (旧格式，自动转换)
+
+    Returns:
+        str: 标准化的代理 URL
+    """
+    if not proxy_str:
+        return ""
+
+    proxy_str = proxy_str.strip()
+    if not proxy_str:
+        return ""
+
+    # 如果已经是标准 URL 格式，直接返回
+    if proxy_str.startswith(("http://", "https://", "socks5://", "socks5h://")):
+        return proxy_str
+
+    # 尝试解析旧格式 host:port:user:pass
+    parts = proxy_str.split(":")
+    if len(parts) == 4:
+        host, port, user, password = parts
+        return f"http://{user}:{password}@{host}:{port}"
+    elif len(parts) == 2:
+        # host:port 格式
+        return f"http://{proxy_str}"
+
+    # 无法识别的格式，尝试添加 http:// 前缀
+    return f"http://{proxy_str}"
+
+
+def request_with_proxy_fallback(request_func: Callable, *args, **kwargs) -> Any:
+    """
+    带代理失败回退的请求包装器
+
+    如果代理连接失败，自动禁用代理重试一次
+
+    Args:
+        request_func: 原始请求函数
+        *args, **kwargs: 传递给请求函数的参数
+
+    Returns:
+        请求响应对象
+
+    Raises:
+        原始异常（如果直连也失败）
+    """
+    # 代理相关的错误类型
+    PROXY_ERRORS = (
+        "ProxyError",
+        "ConnectTimeout",
+        "ConnectionError",
+        "407",  # Proxy Authentication Required
+        "502",  # Bad Gateway (代理问题)
+        "503",  # Service Unavailable (代理问题)
+    )
+
+    try:
+        # 首次尝试（使用代理）
+        return request_func(*args, **kwargs)
+    except Exception as e:
+        error_str = str(e)
+        error_type = type(e).__name__
+
+        # 检查是否是代理相关错误
+        is_proxy_error = any(err in error_str or err in error_type for err in PROXY_ERRORS)
+
+        if is_proxy_error and "proxies" in kwargs:
+            # 禁用代理重试
+            original_proxies = kwargs.get("proxies")
+            kwargs["proxies"] = None
+
+            try:
+                # 直连重试
+                return request_func(*args, **kwargs)
+            except Exception:
+                # 直连也失败，恢复原始代理设置并抛出原始异常
+                kwargs["proxies"] = original_proxies
+                raise e
+        else:
+            # 不是代理错误，直接抛出
+            raise

core/register_service.py

@@ -0,0 +1,289 @@
+import asyncio
+import logging
+import os
+import time
+import uuid
+from dataclasses import dataclass, field
+from typing import Any, Callable, Dict, List, Optional
+
+from core.account import load_accounts_from_source
+from core.base_task_service import BaseTask, BaseTaskService, TaskCancelledError, TaskStatus
+from core.config import config
+from core.mail_providers import create_temp_mail_client
+from core.gemini_automation import GeminiAutomation
+from core.proxy_utils import parse_proxy_setting
+
+logger = logging.getLogger("gemini.register")
+
+
+@dataclass
+class RegisterTask(BaseTask):
+    """注册任务数据类"""
+    count: int = 0
+    domain: Optional[str] = None
+    mail_provider: Optional[str] = None
+
+    def to_dict(self) -> dict:
+        """转换为字典"""
+        base_dict = super().to_dict()
+        base_dict["count"] = self.count
+        base_dict["domain"] = self.domain
+        base_dict["mail_provider"] = self.mail_provider
+        return base_dict
+
+
+class RegisterService(BaseTaskService[RegisterTask]):
+    """注册服务类"""
+
+    def __init__(
+        self,
+        multi_account_mgr,
+        http_client,
+        user_agent: str,
+        retry_policy,
+        session_cache_ttl_seconds: int,
+        global_stats_provider: Callable[[], dict],
+        set_multi_account_mgr: Optional[Callable[[Any], None]] = None,
+    ) -> None:
+        super().__init__(
+            multi_account_mgr,
+            http_client,
+            user_agent,
+            retry_policy,
+            session_cache_ttl_seconds,
+            global_stats_provider,
+            set_multi_account_mgr,
+            log_prefix="REGISTER",
+        )
+
+    def _get_running_task(self) -> Optional[RegisterTask]:
+        """获取正在运行或等待中的任务"""
+        for task in self._tasks.values():
+            if isinstance(task, RegisterTask) and task.status in (TaskStatus.PENDING, TaskStatus.RUNNING):
+                return task
+        return None
+
+    async def start_register(self, count: Optional[int] = None, domain: Optional[str] = None, mail_provider: Optional[str] = None) -> RegisterTask:
+        """
+        启动注册任务 - 统一任务管理
+        - 如果有正在运行的任务，将新数量添加到该任务
+        - 如果没有正在运行的任务，创建新任务
+        """
+        async with self._lock:
+            if os.environ.get("ACCOUNTS_CONFIG"):
+                raise ValueError("已设置 ACCOUNTS_CONFIG 环境变量，注册功能已禁用")
+
+            # 先确定使用哪个邮箱服务提供商
+            mail_provider_value = (mail_provider or "").strip().lower()
+            if not mail_provider_value:
+                mail_provider_value = (config.basic.temp_mail_provider or "duckmail").lower()
+
+            # 再确定使用哪个域名（只有 DuckMail 使用 register_domain 配置）
+            domain_value = (domain or "").strip()
+            if not domain_value:
+                if mail_provider_value == "duckmail":
+                    domain_value = (config.basic.register_domain or "").strip() or None
+                else:
+                    domain_value = None
+
+            register_count = count or config.basic.register_default_count
+            register_count = max(1, int(register_count))
+
+            # 检查是否有正在运行的任务
+            running_task = self._get_running_task()
+
+            if running_task:
+                # 将新数量添加到现有任务
+                running_task.count += register_count
+                self._append_log(
+                    running_task,
+                    "info",
+                    f"📝 添加 {register_count} 个账户到现有任务 (总计: {running_task.count})"
+                )
+                return running_task
+
+            # 创建新任务
+            task = RegisterTask(id=str(uuid.uuid4()), count=register_count, domain=domain_value, mail_provider=mail_provider_value)
+            self._tasks[task.id] = task
+            self._append_log(task, "info", f"📝 创建注册任务 (数量: {register_count}, 域名: {domain_value or 'default'}, 提供商: {mail_provider_value})")
+
+            # 直接启动任务
+            self._current_task_id = task.id
+            asyncio.create_task(self._run_task_directly(task))
+            return task
+
+    async def _run_task_directly(self, task: RegisterTask) -> None:
+        """直接执行任务"""
+        try:
+            await self._run_one_task(task)
+        finally:
+            # 任务完成后清理
+            async with self._lock:
+                if self._current_task_id == task.id:
+                    self._current_task_id = None
+
+    def _execute_task(self, task: RegisterTask):
+        return self._run_register_async(task, task.domain, task.mail_provider)
+
+    async def _run_register_async(self, task: RegisterTask, domain: Optional[str], mail_provider: Optional[str]) -> None:
+        """异步执行注册任务（支持取消）。"""
+        loop = asyncio.get_running_loop()
+        self._append_log(task, "info", f"🚀 注册任务已启动 (共 {task.count} 个账号)")
+
+        for idx in range(task.count):
+            if task.cancel_requested:
+                self._append_log(task, "warning", f"register task cancelled: {task.cancel_reason or 'cancelled'}")
+                task.status = TaskStatus.CANCELLED
+                task.finished_at = time.time()
+                return
+
+            try:
+                self._append_log(task, "info", f"📊 进度: {idx + 1}/{task.count}")
+                result = await loop.run_in_executor(self._executor, self._register_one, domain, mail_provider, task)
+            except TaskCancelledError:
+                task.status = TaskStatus.CANCELLED
+                task.finished_at = time.time()
+                return
+            except Exception as exc:
+                result = {"success": False, "error": str(exc)}
+            task.progress += 1
+            task.results.append(result)
+
+            if result.get("success"):
+                task.success_count += 1
+                email = result.get('email', '未知')
+                self._append_log(task, "info", "━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━")
+                self._append_log(task, "info", f"✅ 注册成功: {email}")
+                self._append_log(task, "info", "━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━")
+            else:
+                task.fail_count += 1
+                error = result.get('error', '未知错误')
+                self._append_log(task, "error", "━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━")
+                self._append_log(task, "error", f"❌ 注册失败: {error}")
+                self._append_log(task, "error", "━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━")
+
+            # 账号之间等待 10 秒，避免资源争抢和风控
+            if idx < task.count - 1 and not task.cancel_requested:
+                self._append_log(task, "info", "⏳ 等待 10 秒后处理下一个账号...")
+                await asyncio.sleep(10)
+
+        if task.cancel_requested:
+            task.status = TaskStatus.CANCELLED
+        else:
+            task.status = TaskStatus.SUCCESS if task.fail_count == 0 else TaskStatus.FAILED
+        task.finished_at = time.time()
+        self._current_task_id = None
+        self._append_log(task, "info", f"🏁 注册任务完成 (成功: {task.success_count}, 失败: {task.fail_count}, 总计: {task.count})")
+
+    def _register_one(self, domain: Optional[str], mail_provider: Optional[str], task: RegisterTask) -> dict:
+        """注册单个账户"""
+        log_cb = lambda level, message: self._append_log(task, level, message)
+
+        log_cb("info", "━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━")
+        log_cb("info", "🆕 开始注册新账户")
+        log_cb("info", "━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━")
+
+        # 使用传递的邮件提供商参数，如果未提供则从配置读取
+        temp_mail_provider = (mail_provider or "").strip().lower()
+        if not temp_mail_provider:
+            temp_mail_provider = (config.basic.temp_mail_provider or "duckmail").lower()
+
+        log_cb("info", f"📧 步骤 1/3: 注册临时邮箱 (提供商={temp_mail_provider})...")
+
+        if temp_mail_provider == "freemail" and not config.basic.freemail_jwt_token:
+            log_cb("error", "❌ Freemail JWT Token 未配置")
+            return {"success": False, "error": "Freemail JWT Token 未配置"}
+
+        client = create_temp_mail_client(
+            temp_mail_provider,
+            domain=domain,
+            log_cb=log_cb,
+        )
+
+        if not client.register_account(domain=domain):
+            log_cb("error", f"❌ {temp_mail_provider} 邮箱注册失败")
+            return {"success": False, "error": f"{temp_mail_provider} 注册失败"}
+
+        log_cb("info", f"✅ 邮箱注册成功: {client.email}")
+
+        headless = config.basic.browser_headless
+        proxy_for_auth, _ = parse_proxy_setting(config.basic.proxy_for_auth)
+
+        log_cb("info", f"🌐 步骤 2/3: 启动浏览器 (无头模式={headless})...")
+
+        automation = GeminiAutomation(
+            user_agent=self.user_agent,
+            proxy=proxy_for_auth,
+            headless=headless,
+            log_callback=log_cb,
+        )
+        # 允许外部取消时立刻关闭浏览器
+        self._add_cancel_hook(task.id, lambda: getattr(automation, "stop", lambda: None)())
+
+        try:
+            log_cb("info", "🔐 步骤 3/3: 执行 Gemini 自动登录...")
+            result = automation.login_and_extract(client.email, client, is_new_account=True)
+        except Exception as exc:
+            log_cb("error", f"�� 自动登录异常: {exc}")
+            return {"success": False, "error": str(exc)}
+
+        if not result.get("success"):
+            error = result.get("error", "自动化流程失败")
+            log_cb("error", f"❌ 自动登录失败: {error}")
+            return {"success": False, "error": error}
+
+        log_cb("info", "✅ Gemini 登录成功，正在保存配置...")
+
+        config_data = result["config"]
+        config_data["mail_provider"] = temp_mail_provider
+        config_data["mail_address"] = client.email
+
+        # 保存邮箱自定义配置
+        if temp_mail_provider == "freemail":
+            config_data["mail_password"] = ""
+            config_data["mail_base_url"] = config.basic.freemail_base_url
+            config_data["mail_jwt_token"] = config.basic.freemail_jwt_token
+            config_data["mail_verify_ssl"] = config.basic.freemail_verify_ssl
+            config_data["mail_domain"] = config.basic.freemail_domain
+        elif temp_mail_provider == "gptmail":
+            config_data["mail_password"] = ""
+            config_data["mail_base_url"] = config.basic.gptmail_base_url
+            config_data["mail_api_key"] = config.basic.gptmail_api_key
+            config_data["mail_verify_ssl"] = config.basic.gptmail_verify_ssl
+            config_data["mail_domain"] = config.basic.gptmail_domain
+        elif temp_mail_provider == "cfmail":
+            config_data["mail_password"] = getattr(client, "jwt_token", "") or getattr(client, "password", "")
+            config_data["mail_base_url"] = config.basic.cfmail_base_url
+            config_data["mail_api_key"] = config.basic.cfmail_api_key
+            config_data["mail_verify_ssl"] = config.basic.cfmail_verify_ssl
+            config_data["mail_domain"] = config.basic.cfmail_domain
+        elif temp_mail_provider == "moemail":
+            config_data["mail_password"] = getattr(client, "email_id", "") or getattr(client, "password", "")
+            config_data["mail_base_url"] = config.basic.moemail_base_url
+            config_data["mail_api_key"] = config.basic.moemail_api_key
+            config_data["mail_domain"] = config.basic.moemail_domain
+        elif temp_mail_provider == "duckmail":
+            config_data["mail_password"] = getattr(client, "password", "")
+            config_data["mail_base_url"] = config.basic.duckmail_base_url
+            config_data["mail_api_key"] = config.basic.duckmail_api_key
+        else:
+            config_data["mail_password"] = getattr(client, "password", "")
+
+        accounts_data = load_accounts_from_source()
+        updated = False
+        for acc in accounts_data:
+            if acc.get("id") == config_data["id"]:
+                acc.update(config_data)
+                updated = True
+                break
+        if not updated:
+            accounts_data.append(config_data)
+
+        self._apply_accounts_update(accounts_data)
+
+        log_cb("info", "✅ 配置已保存到数据库")
+        log_cb("info", "━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━")
+        log_cb("info", f"🎉 账户注册完成: {client.email}")
+        log_cb("info", "━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━")
+
+        return {"success": True, "email": client.email, "config": config_data}

core/session_auth.py

@@ -0,0 +1,68 @@
+"""
+Session认证模块
+提供基于Session的登录认证功能
+"""
+import secrets
+from functools import wraps
+from typing import Optional
+from fastapi import HTTPException, Request, Response
+from fastapi.responses import RedirectResponse
+
+
+def generate_session_secret() -> str:
+    """生成随机的session密钥"""
+    return secrets.token_hex(32)
+
+
+def is_logged_in(request: Request) -> bool:
+    """检查用户是否已登录"""
+    return request.session.get("authenticated", False)
+
+
+def login_user(request: Request):
+    """标记用户为已登录状态"""
+    request.session["authenticated"] = True
+
+
+def logout_user(request: Request):
+    """清除用户登录状态"""
+    request.session.clear()
+
+
+def require_login(redirect_to_login: bool = True):
+    """
+    要求用户登录的装饰器
+
+    Args:
+        redirect_to_login: 未登录时是否重定向到登录页面（默认True）
+                          False时返回404错误
+    """
+    def decorator(func):
+        @wraps(func)
+        async def wrapper(*args, request: Request, **kwargs):
+            if not is_logged_in(request):
+                if redirect_to_login:
+                    accept_header = (request.headers.get("accept") or "").lower()
+                    wants_html = "text/html" in accept_header or request.url.path.endswith("/html")
+
+                    if wants_html:
+                        # 清理掉 URL 中可能重复的 PATH_PREFIX
+                        # 避免重定向路径出现多层前缀
+                        path = request.url.path
+
+                        # 兼容 main 中 PATH_PREFIX 为空的情况
+                        import main
+                        prefix = main.PATH_PREFIX
+
+                        if prefix:
+                            login_url = f"/{prefix}/login"
+                        else:
+                            login_url = "/login"
+
+                        return RedirectResponse(url=login_url, status_code=302)
+
+                raise HTTPException(401, "Unauthorized")
+
+            return await func(*args, request=request, **kwargs)
+        return wrapper
+    return decorator

core/storage.py

@@ -0,0 +1,1127 @@
+"""
+Storage abstraction supporting SQLite and PostgreSQL backends.
+
+Priority:
+1) DATABASE_URL -> PostgreSQL
+2) SQLITE_PATH  -> SQLite (defaults to data.db when DATABASE_URL is empty)
+3) No file fallback
+"""
+
+import asyncio
+import json
+import logging
+import os
+import sqlite3
+import threading
+import time
+from typing import Optional
+
+from dotenv import load_dotenv
+
+load_dotenv()
+
+logger = logging.getLogger(__name__)
+
+_db_pool = None
+_db_pool_lock = None
+_db_loop = None
+_db_thread = None
+_db_loop_lock = threading.Lock()
+
+_sqlite_conn = None
+_sqlite_lock = threading.Lock()
+
+
+def _get_database_url() -> str:
+    return os.environ.get("DATABASE_URL", "").strip()
+
+def _default_sqlite_path() -> str:
+    return os.path.join("data", "data.db")
+
+def _get_sqlite_path() -> str:
+    env_path = os.environ.get("SQLITE_PATH", "").strip()
+    if env_path:
+        return env_path
+    return _default_sqlite_path()
+
+def _get_backend() -> str:
+    if _get_database_url():
+        return "postgres"
+    if _get_sqlite_path():
+        return "sqlite"
+    return ""
+
+def is_database_enabled() -> bool:
+    """Return True when a database backend is configured."""
+    return bool(_get_backend())
+
+
+def _data_file_path(name: str) -> str:
+    return os.path.join("data", name)
+
+
+def _ensure_backend_initialized() -> None:
+    backend = _get_backend()
+    if backend == "postgres":
+        _run_in_db_loop(_get_pool())
+        return
+    if backend == "sqlite":
+        _get_sqlite_conn()
+        return
+
+
+async def has_accounts() -> Optional[bool]:
+    backend = _get_backend()
+    if backend == "postgres":
+        async with _pg_acquire() as conn:
+            row = await conn.fetchrow("SELECT 1 FROM accounts LIMIT 1")
+        return bool(row)
+    if backend == "sqlite":
+        conn = _get_sqlite_conn()
+        with _sqlite_lock:
+            row = conn.execute("SELECT 1 FROM accounts LIMIT 1").fetchone()
+        return bool(row)
+    return None
+
+
+def has_accounts_sync() -> Optional[bool]:
+    return _run_in_db_loop(has_accounts())
+
+
+async def has_settings() -> Optional[bool]:
+    backend = _get_backend()
+    if backend == "postgres":
+        async with _pg_acquire() as conn:
+            row = await conn.fetchrow(
+                "SELECT 1 FROM kv_settings WHERE key = $1",
+                "settings",
+            )
+        return bool(row)
+    if backend == "sqlite":
+        conn = _get_sqlite_conn()
+        with _sqlite_lock:
+            row = conn.execute(
+                "SELECT 1 FROM kv_settings WHERE key = ?",
+                ("settings",),
+            ).fetchone()
+        return bool(row)
+    return None
+
+
+def has_settings_sync() -> Optional[bool]:
+    return _run_in_db_loop(has_settings())
+
+
+async def has_stats() -> Optional[bool]:
+    backend = _get_backend()
+    if backend == "postgres":
+        async with _pg_acquire() as conn:
+            row = await conn.fetchrow(
+                "SELECT 1 FROM kv_stats WHERE key = $1",
+                "stats",
+            )
+        return bool(row)
+    if backend == "sqlite":
+        conn = _get_sqlite_conn()
+        with _sqlite_lock:
+            row = conn.execute(
+                "SELECT 1 FROM kv_stats WHERE key = ?",
+                ("stats",),
+            ).fetchone()
+        return bool(row)
+    return None
+
+
+def has_stats_sync() -> Optional[bool]:
+    return _run_in_db_loop(has_stats())
+
+
+def _ensure_db_loop() -> asyncio.AbstractEventLoop:
+    global _db_loop, _db_thread
+    if _db_loop and _db_thread and _db_thread.is_alive():
+        return _db_loop
+    with _db_loop_lock:
+        if _db_loop and _db_thread and _db_thread.is_alive():
+            return _db_loop
+        loop = asyncio.new_event_loop()
+
+        def _runner() -> None:
+            asyncio.set_event_loop(loop)
+            loop.run_forever()
+
+        thread = threading.Thread(target=_runner, name="storage-db-loop", daemon=True)
+        thread.start()
+        _db_loop = loop
+        _db_thread = thread
+        return _db_loop
+
+
+def _run_in_db_loop(coro):
+    loop = _ensure_db_loop()
+    future = asyncio.run_coroutine_threadsafe(coro, loop)
+    return future.result()
+
+def _get_sqlite_conn():
+    """Get (or create) the SQLite connection."""
+    global _sqlite_conn
+    if _sqlite_conn is not None:
+        return _sqlite_conn
+    with _sqlite_lock:
+        if _sqlite_conn is not None:
+            return _sqlite_conn
+        sqlite_path = _get_sqlite_path()
+        if not sqlite_path:
+            raise ValueError("SQLITE_PATH is not set")
+        os.makedirs(os.path.dirname(sqlite_path) or ".", exist_ok=True)
+        conn = sqlite3.connect(sqlite_path, check_same_thread=False)
+        conn.row_factory = sqlite3.Row
+        _init_sqlite_tables(conn)
+        _sqlite_conn = conn
+        logger.info(f"[STORAGE] SQLite initialized at {sqlite_path}")
+        return _sqlite_conn
+
+
+async def _get_pool():
+    """Get (or create) the asyncpg connection pool."""
+    global _db_pool, _db_pool_lock
+    if _db_pool is not None:
+        return _db_pool
+    if _db_pool_lock is None:
+        _db_pool_lock = asyncio.Lock()
+    async with _db_pool_lock:
+        if _db_pool is not None:
+            return _db_pool
+        db_url = _get_database_url()
+        if not db_url:
+            raise ValueError("DATABASE_URL is not set")
+        try:
+            import asyncpg
+            _db_pool = await asyncpg.create_pool(
+                db_url,
+                min_size=0,
+                max_size=10,
+                command_timeout=30,
+            )
+            await _init_tables(_db_pool)
+            logger.info("[STORAGE] PostgreSQL pool initialized")
+        except ImportError:
+            logger.error("[STORAGE] asyncpg is required for database storage")
+            raise
+        except Exception as e:
+            logger.error(f"[STORAGE] Database connection failed: {e}")
+            raise
+    return _db_pool
+
+
+async def _reset_pool():
+    """Close and recreate the connection pool (called on stale connection errors)."""
+    global _db_pool
+    if _db_pool is not None:
+        try:
+            await _db_pool.close()
+        except Exception:
+            pass
+        _db_pool = None
+    return await _get_pool()
+
+
+from contextlib import asynccontextmanager
+
+@asynccontextmanager
+async def _pg_acquire():
+    """Acquire a connection with automatic retry on stale connection errors."""
+    import asyncpg
+    pool = await _get_pool()
+    try:
+        async with pool.acquire() as conn:
+            yield conn
+    except (asyncpg.ConnectionDoesNotExistError,
+            asyncpg.InterfaceError,
+            OSError) as e:
+        logger.warning(f"[STORAGE] Connection lost, resetting pool: {e}")
+        await _reset_pool()
+        raise
+
+
+async def _init_tables(pool) -> None:
+    """Initialize PostgreSQL tables."""
+    async with pool.acquire() as conn:
+        await conn.execute(
+            """
+            CREATE TABLE IF NOT EXISTS accounts (
+                account_id TEXT PRIMARY KEY,
+                position INTEGER NOT NULL,
+                data JSONB NOT NULL,
+                updated_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP
+            )
+            """
+        )
+        await conn.execute(
+            """
+            CREATE INDEX IF NOT EXISTS accounts_position_idx
+            ON accounts(position)
+            """
+        )
+        await conn.execute(
+            """
+            CREATE TABLE IF NOT EXISTS kv_settings (
+                key TEXT PRIMARY KEY,
+                value JSONB NOT NULL,
+                updated_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP
+            )
+            """
+        )
+        await conn.execute(
+            """
+            CREATE TABLE IF NOT EXISTS kv_stats (
+                key TEXT PRIMARY KEY,
+                value JSONB NOT NULL,
+                updated_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP
+            )
+            """
+        )
+        await conn.execute(
+            """
+            CREATE TABLE IF NOT EXISTS task_history (
+                id TEXT PRIMARY KEY,
+                data JSONB NOT NULL,
+                created_at DOUBLE PRECISION NOT NULL
+            )
+            """
+        )
+        await conn.execute(
+            """
+            CREATE INDEX IF NOT EXISTS task_history_created_at_idx
+            ON task_history(created_at DESC)
+            """
+        )
+        logger.info("[STORAGE] Database tables initialized")
+
+def _init_sqlite_tables(conn: sqlite3.Connection) -> None:
+    """Initialize SQLite tables."""
+    with conn:
+        conn.execute(
+            """
+            CREATE TABLE IF NOT EXISTS accounts (
+                account_id TEXT PRIMARY KEY,
+                position INTEGER NOT NULL,
+                data TEXT NOT NULL,
+                updated_at TEXT DEFAULT CURRENT_TIMESTAMP
+            )
+            """
+        )
+        conn.execute(
+            """
+            CREATE INDEX IF NOT EXISTS accounts_position_idx
+            ON accounts(position)
+            """
+        )
+        conn.execute(
+            """
+            CREATE TABLE IF NOT EXISTS kv_settings (
+                key TEXT PRIMARY KEY,
+                value TEXT NOT NULL,
+                updated_at TEXT DEFAULT CURRENT_TIMESTAMP
+            )
+            """
+        )
+        conn.execute(
+            """
+            CREATE TABLE IF NOT EXISTS kv_stats (
+                key TEXT PRIMARY KEY,
+                value TEXT NOT NULL,
+                updated_at TEXT DEFAULT CURRENT_TIMESTAMP
+            )
+            """
+        )
+        conn.execute(
+            """
+            CREATE TABLE IF NOT EXISTS task_history (
+                id TEXT PRIMARY KEY,
+                data TEXT NOT NULL,
+                created_at REAL NOT NULL
+            )
+            """
+        )
+        conn.execute(
+            """
+            CREATE INDEX IF NOT EXISTS task_history_created_at_idx
+            ON task_history(created_at)
+            """
+        )
+        conn.execute(
+            """
+            CREATE TABLE IF NOT EXISTS request_logs (
+                id INTEGER PRIMARY KEY AUTOINCREMENT,
+                timestamp INTEGER NOT NULL,
+                model TEXT NOT NULL,
+                ttfb_ms INTEGER,
+                total_ms INTEGER,
+                status TEXT NOT NULL,
+                status_code INTEGER,
+                created_at TEXT DEFAULT CURRENT_TIMESTAMP
+            )
+            """
+        )
+        conn.execute(
+            """
+            CREATE INDEX IF NOT EXISTS request_logs_timestamp_idx
+            ON request_logs(timestamp)
+            """
+        )
+        conn.execute(
+            """
+            CREATE INDEX IF NOT EXISTS request_logs_model_idx
+            ON request_logs(model)
+            """
+        )
+        conn.execute(
+            """
+            CREATE INDEX IF NOT EXISTS request_logs_status_idx
+            ON request_logs(status)
+            """
+        )
+
+
+# ==================== Accounts storage ====================
+
+def _normalize_accounts(accounts: list) -> list:
+    normalized = []
+    for index, acc in enumerate(accounts, 1):
+        if not isinstance(acc, dict):
+            continue
+        account_id = acc.get("id") or f"account_{index}"
+        next_acc = dict(acc)
+        next_acc.setdefault("id", account_id)
+        normalized.append(next_acc)
+    return normalized
+
+def _parse_account_value(value) -> Optional[dict]:
+    if value is None:
+        return None
+    if isinstance(value, str):
+        try:
+            value = json.loads(value)
+        except Exception:
+            return None
+    if isinstance(value, dict):
+        return value
+    return None
+
+async def _load_accounts_from_table() -> Optional[list]:
+    backend = _get_backend()
+    if backend == "postgres":
+        async with _pg_acquire() as conn:
+            rows = await conn.fetch(
+                "SELECT data FROM accounts ORDER BY position ASC"
+            )
+        if not rows:
+            return []
+        accounts = []
+        for row in rows:
+            value = _parse_account_value(row["data"])
+            if value is not None:
+                accounts.append(value)
+        return accounts
+    if backend == "sqlite":
+        conn = _get_sqlite_conn()
+        with _sqlite_lock:
+            rows = conn.execute(
+                "SELECT data FROM accounts ORDER BY position ASC"
+            ).fetchall()
+        if not rows:
+            return []
+        accounts = []
+        for row in rows:
+            value = _parse_account_value(row["data"])
+            if value is not None:
+                accounts.append(value)
+        return accounts
+    return None
+
+async def _save_accounts_to_table(accounts: list) -> bool:
+    backend = _get_backend()
+    if backend == "postgres":
+        normalized = _normalize_accounts(accounts)
+        async with _pg_acquire() as conn:
+            async with conn.transaction():
+                await conn.execute("DELETE FROM accounts")
+                for index, acc in enumerate(normalized, 1):
+                    await conn.execute(
+                        """
+                        INSERT INTO accounts (account_id, position, data, updated_at)
+                        VALUES ($1, $2, $3, CURRENT_TIMESTAMP)
+                        """,
+                        acc["id"],
+                        index,
+                        json.dumps(acc, ensure_ascii=False),
+                    )
+        logger.info(f"[STORAGE] Saved {len(normalized)} accounts to database")
+        return True
+    if backend == "sqlite":
+        conn = _get_sqlite_conn()
+        normalized = _normalize_accounts(accounts)
+        with _sqlite_lock, conn:
+            conn.execute("DELETE FROM accounts")
+            for index, acc in enumerate(normalized, 1):
+                conn.execute(
+                    """
+                    INSERT INTO accounts (account_id, position, data, updated_at)
+                    VALUES (?, ?, ?, CURRENT_TIMESTAMP)
+                    """,
+                    (acc["id"], index, json.dumps(acc, ensure_ascii=False)),
+                )
+        logger.info(f"[STORAGE] Saved {len(normalized)} accounts to database")
+        return True
+    return False
+
+async def load_accounts() -> Optional[list]:
+    """
+    从数据库加载账户配置（如果启用）
+
+    注意：不再自动从 kv_store 迁移
+    如需迁移，请手动运行：python scripts/migrate_to_database.py
+
+    返回 None 表示降级到文件存储
+    """
+    if not is_database_enabled():
+        return None
+    try:
+        data = await _load_accounts_from_table()
+        if data is None:
+            return None
+
+        if data:
+            logger.info(f"[STORAGE] 从数据库加载 {len(data)} 个账户")
+        else:
+            logger.info("[STORAGE] 数据库中未找到账户")
+
+        return data
+    except Exception as e:
+        logger.error(f"[STORAGE] 数据库读取失败: {e}")
+    return None
+
+
+async def get_accounts_updated_at() -> Optional[float]:
+    """
+    Get the accounts updated_at timestamp (epoch seconds).
+    Return None if database is not enabled or failed.
+    """
+    if not is_database_enabled():
+        return None
+    backend = _get_backend()
+    try:
+        if backend == "postgres":
+            async with _pg_acquire() as conn:
+                row = await conn.fetchrow(
+                    "SELECT EXTRACT(EPOCH FROM MAX(updated_at)) AS ts FROM accounts"
+                )
+                if not row or row["ts"] is None:
+                    return None
+                return float(row["ts"])
+        if backend == "sqlite":
+            conn = _get_sqlite_conn()
+            with _sqlite_lock:
+                row = conn.execute(
+                    "SELECT STRFTIME('%s', MAX(updated_at)) AS ts FROM accounts"
+                ).fetchone()
+            if not row or row["ts"] is None:
+                return None
+            return float(row["ts"])
+    except Exception as e:
+        logger.error(f"[STORAGE] Database accounts updated_at failed: {e}")
+    return None
+
+
+def get_accounts_updated_at_sync() -> Optional[float]:
+    """Sync wrapper for get_accounts_updated_at."""
+    return _run_in_db_loop(get_accounts_updated_at())
+
+
+async def save_accounts(accounts: list) -> bool:
+    """Save account configuration to database when enabled."""
+    if not is_database_enabled():
+        return False
+    try:
+        return await _save_accounts_to_table(accounts)
+    except Exception as e:
+        logger.error(f"[STORAGE] Database write failed: {e}")
+    return False
+
+
+def load_accounts_sync() -> Optional[list]:
+    """Sync wrapper for load_accounts (safe in sync/async call sites)."""
+    return _run_in_db_loop(load_accounts())
+
+
+def save_accounts_sync(accounts: list) -> bool:
+    """Sync wrapper for save_accounts (safe in sync/async call sites)."""
+    return _run_in_db_loop(save_accounts(accounts))
+
+async def _get_account_data(account_id: str) -> Optional[dict]:
+    backend = _get_backend()
+    if backend == "postgres":
+        async with _pg_acquire() as conn:
+            row = await conn.fetchrow(
+                "SELECT data FROM accounts WHERE account_id = $1",
+                account_id,
+            )
+        if not row:
+            return None
+        return _parse_account_value(row["data"])
+    if backend == "sqlite":
+        conn = _get_sqlite_conn()
+        with _sqlite_lock:
+            row = conn.execute(
+                "SELECT data FROM accounts WHERE account_id = ?",
+                (account_id,),
+            ).fetchone()
+        if not row:
+            return None
+        return _parse_account_value(row["data"])
+    return None
+
+async def _update_account_data(account_id: str, data: dict) -> bool:
+    backend = _get_backend()
+    payload = json.dumps(data, ensure_ascii=False)
+    if backend == "postgres":
+        async with _pg_acquire() as conn:
+            result = await conn.execute(
+                """
+                UPDATE accounts
+                SET data = $2, updated_at = CURRENT_TIMESTAMP
+                WHERE account_id = $1
+                """,
+                account_id,
+                payload,
+            )
+        return result.startswith("UPDATE") and not result.endswith("0")
+    if backend == "sqlite":
+        conn = _get_sqlite_conn()
+        with _sqlite_lock, conn:
+            cur = conn.execute(
+                """
+                UPDATE accounts
+                SET data = ?, updated_at = CURRENT_TIMESTAMP
+                WHERE account_id = ?
+                """,
+                (payload, account_id),
+            )
+        return cur.rowcount > 0
+    return False
+
+async def update_account_disabled(account_id: str, disabled: bool) -> bool:
+    data = await _get_account_data(account_id)
+    if data is None:
+        return False
+    data["disabled"] = disabled
+    return await _update_account_data(account_id, data)
+
+def _apply_cooldown_data(data: dict, cooldown_data: dict) -> None:
+    """应用冷却数据到账户数据（消除重复代码）"""
+    data["quota_cooldowns"] = cooldown_data.get("quota_cooldowns", {})
+    data["conversation_count"] = cooldown_data.get("conversation_count", 0)
+    data["failure_count"] = cooldown_data.get("failure_count", 0)
+    data["daily_usage"] = cooldown_data.get("daily_usage", {"text": 0, "images": 0, "videos": 0})
+    data["daily_usage_date"] = cooldown_data.get("daily_usage_date", "")
+
+async def update_account_cooldown(account_id: str, cooldown_data: dict) -> bool:
+    """更新单个账户的冷却状态和统计数据"""
+    data = await _get_account_data(account_id)
+    if data is None:
+        return False
+    _apply_cooldown_data(data, cooldown_data)
+    return await _update_account_data(account_id, data)
+
+async def bulk_update_accounts_cooldown(updates: list[tuple[str, dict]]) -> tuple[int, list[str]]:
+    """批量更新账户冷却状态"""
+    if not updates:
+        return 0, []
+
+    account_ids = [account_id for account_id, _ in updates]
+    cooldown_map = {account_id: cooldown_data for account_id, cooldown_data in updates}
+
+    backend = _get_backend()
+    existing: dict[str, dict] = {}
+    updated = 0
+
+    if backend == "postgres":
+        async with _pg_acquire() as conn:
+            # SELECT + UPDATE in one connection to avoid contention
+            rows = await conn.fetch(
+                "SELECT account_id, data FROM accounts WHERE account_id = ANY($1)",
+                account_ids,
+            )
+            for row in rows:
+                data = _parse_account_value(row["data"])
+                if data is not None:
+                    existing[row["account_id"]] = data
+
+            missing = [aid for aid in account_ids if aid not in existing]
+            if existing:
+                async with conn.transaction():
+                    for account_id, data in existing.items():
+                        cooldown_data = cooldown_map[account_id]
+                        _apply_cooldown_data(data, cooldown_data)
+                        payload = json.dumps(data, ensure_ascii=False)
+                        result = await conn.execute(
+                            """
+                            UPDATE accounts
+                            SET data = $2, updated_at = CURRENT_TIMESTAMP
+                            WHERE account_id = $1
+                            """,
+                            account_id,
+                            payload,
+                        )
+                        if result.startswith("UPDATE") and not result.endswith("0"):
+                            updated += 1
+        return updated, missing if existing else account_ids
+
+    elif backend == "sqlite":
+        conn = _get_sqlite_conn()
+        placeholders = ",".join(["?"] * len(account_ids))
+        with _sqlite_lock:
+            rows = conn.execute(
+                f"SELECT account_id, data FROM accounts WHERE account_id IN ({placeholders})",
+                tuple(account_ids),
+            ).fetchall()
+        for row in rows:
+            data = _parse_account_value(row["data"])
+            if data is not None:
+                existing[row["account_id"]] = data
+
+        missing = [aid for aid in account_ids if aid not in existing]
+        if not existing:
+            return 0, missing
+
+        with _sqlite_lock, conn:
+            for account_id, data in existing.items():
+                cooldown_data = cooldown_map[account_id]
+                _apply_cooldown_data(data, cooldown_data)
+                payload = json.dumps(data, ensure_ascii=False)
+                cur = conn.execute(
+                    """
+                    UPDATE accounts
+                    SET data = ?, updated_at = CURRENT_TIMESTAMP
+                    WHERE account_id = ?
+                    """,
+                    (payload, account_id),
+                )
+                if cur.rowcount > 0:
+                    updated += 1
+        return updated, missing
+
+    return 0, account_ids
+
+async def bulk_update_accounts_disabled(account_ids: list[str], disabled: bool) -> tuple[int, list[str]]:
+    if not account_ids:
+        return 0, []
+    backend = _get_backend()
+    existing: dict[str, dict] = {}
+    if backend == "postgres":
+        async with _pg_acquire() as conn:
+            rows = await conn.fetch(
+                "SELECT account_id, data FROM accounts WHERE account_id = ANY($1)",
+                account_ids,
+            )
+        for row in rows:
+            data = _parse_account_value(row["data"])
+            if data is not None:
+                existing[row["account_id"]] = data
+    elif backend == "sqlite":
+        conn = _get_sqlite_conn()
+        placeholders = ",".join(["?"] * len(account_ids))
+        with _sqlite_lock:
+            rows = conn.execute(
+                f"SELECT account_id, data FROM accounts WHERE account_id IN ({placeholders})",
+                tuple(account_ids),
+            ).fetchall()
+        for row in rows:
+            data = _parse_account_value(row["data"])
+            if data is not None:
+                existing[row["account_id"]] = data
+    else:
+        return 0, account_ids
+
+    missing = [account_id for account_id in account_ids if account_id not in existing]
+    if not existing:
+        return 0, missing
+
+    updated = 0
+    backend = _get_backend()
+    if backend == "postgres":
+        async with _pg_acquire() as conn:
+            async with conn.transaction():
+                for account_id, data in existing.items():
+                    data["disabled"] = disabled
+                    payload = json.dumps(data, ensure_ascii=False)
+                    result = await conn.execute(
+                        """
+                        UPDATE accounts
+                        SET data = $2, updated_at = CURRENT_TIMESTAMP
+                        WHERE account_id = $1
+                        """,
+                        account_id,
+                        payload,
+                    )
+                    if result.startswith("UPDATE") and not result.endswith("0"):
+                        updated += 1
+    elif backend == "sqlite":
+        conn = _get_sqlite_conn()
+        with _sqlite_lock, conn:
+            for account_id, data in existing.items():
+                data["disabled"] = disabled
+                payload = json.dumps(data, ensure_ascii=False)
+                cur = conn.execute(
+                    """
+                    UPDATE accounts
+                    SET data = ?, updated_at = CURRENT_TIMESTAMP
+                    WHERE account_id = ?
+                    """,
+                    (payload, account_id),
+                )
+                if cur.rowcount > 0:
+                    updated += 1
+    return updated, missing
+
+async def _renumber_account_positions() -> None:
+    backend = _get_backend()
+    if backend == "postgres":
+        async with _pg_acquire() as conn:
+            await conn.execute(
+                """
+                WITH ordered AS (
+                    SELECT account_id, ROW_NUMBER() OVER (ORDER BY position ASC) AS new_pos
+                    FROM accounts
+                )
+                UPDATE accounts AS a
+                SET position = ordered.new_pos,
+                    updated_at = CURRENT_TIMESTAMP
+                FROM ordered
+                WHERE a.account_id = ordered.account_id
+                """
+            )
+        return
+    if backend == "sqlite":
+        conn = _get_sqlite_conn()
+        with _sqlite_lock, conn:
+            rows = conn.execute(
+                "SELECT account_id FROM accounts ORDER BY position ASC"
+            ).fetchall()
+            for index, row in enumerate(rows, 1):
+                conn.execute(
+                    "UPDATE accounts SET position = ?, updated_at = CURRENT_TIMESTAMP WHERE account_id = ?",
+                    (index, row["account_id"]),
+                )
+
+async def delete_accounts(account_ids: list[str]) -> int:
+    if not account_ids:
+        return 0
+    backend = _get_backend()
+    deleted = 0
+    if backend == "postgres":
+        async with _pg_acquire() as conn:
+            result = await conn.execute(
+                "DELETE FROM accounts WHERE account_id = ANY($1)",
+                account_ids,
+            )
+        try:
+            deleted = int(result.split()[-1])
+        except Exception:
+            deleted = 0
+    elif backend == "sqlite":
+        conn = _get_sqlite_conn()
+        placeholders = ",".join(["?"] * len(account_ids))
+        with _sqlite_lock, conn:
+            cur = conn.execute(
+                f"DELETE FROM accounts WHERE account_id IN ({placeholders})",
+                tuple(account_ids),
+            )
+            deleted = cur.rowcount or 0
+    else:
+        return 0
+
+    if deleted > 0:
+        await _renumber_account_positions()
+    return deleted
+
+def update_account_disabled_sync(account_id: str, disabled: bool) -> bool:
+    return _run_in_db_loop(update_account_disabled(account_id, disabled))
+
+def update_account_cooldown_sync(account_id: str, cooldown_data: dict) -> bool:
+    return _run_in_db_loop(update_account_cooldown(account_id, cooldown_data))
+
+def bulk_update_accounts_cooldown_sync(updates: list[tuple[str, dict]]) -> tuple[int, list[str]]:
+    return _run_in_db_loop(bulk_update_accounts_cooldown(updates))
+
+def bulk_update_accounts_disabled_sync(account_ids: list[str], disabled: bool) -> tuple[int, list[str]]:
+    return _run_in_db_loop(bulk_update_accounts_disabled(account_ids, disabled))
+
+def delete_accounts_sync(account_ids: list[str]) -> int:
+    return _run_in_db_loop(delete_accounts(account_ids))
+
+
+# ==================== Settings storage ====================
+
+async def _load_kv(table_name: str, key: str) -> Optional[dict]:
+    """加载键值数据"""
+    backend = _get_backend()
+    if backend == "postgres":
+        async with _pg_acquire() as conn:
+            row = await conn.fetchrow(
+                f"SELECT value FROM {table_name} WHERE key = $1",
+                key,
+            )
+        if not row:
+            return None
+        value = row["value"]
+        if isinstance(value, str):
+            return json.loads(value)
+        return value
+
+    if backend == "sqlite":
+        conn = _get_sqlite_conn()
+        with _sqlite_lock:
+            row = conn.execute(
+                f"SELECT value FROM {table_name} WHERE key = ?",
+                (key,),
+            ).fetchone()
+        if not row:
+            return None
+        value = row["value"]
+        if isinstance(value, str):
+            return json.loads(value)
+        return value
+    return None
+
+
+async def _save_kv(table_name: str, key: str, value: dict) -> bool:
+    backend = _get_backend()
+    payload = json.dumps(value, ensure_ascii=False)
+    if backend == "postgres":
+        async with _pg_acquire() as conn:
+            await conn.execute(
+                f"""
+                INSERT INTO {table_name} (key, value, updated_at)
+                VALUES ($1, $2, CURRENT_TIMESTAMP)
+                ON CONFLICT (key) DO UPDATE SET
+                    value = EXCLUDED.value,
+                    updated_at = CURRENT_TIMESTAMP
+                """,
+                key,
+                payload,
+            )
+        return True
+    if backend == "sqlite":
+        conn = _get_sqlite_conn()
+        with _sqlite_lock, conn:
+            conn.execute(
+                f"""
+                INSERT INTO {table_name} (key, value, updated_at)
+                VALUES (?, ?, CURRENT_TIMESTAMP)
+                ON CONFLICT(key) DO UPDATE SET
+                    value = excluded.value,
+                    updated_at = CURRENT_TIMESTAMP
+                """,
+                (key, payload),
+            )
+        return True
+    return False
+
+async def load_settings() -> Optional[dict]:
+    if not is_database_enabled():
+        return None
+    try:
+        return await _load_kv("kv_settings", "settings")
+    except Exception as e:
+        logger.error(f"[STORAGE] Settings read failed: {e}")
+    return None
+
+
+async def save_settings(settings: dict) -> bool:
+    if not is_database_enabled():
+        return False
+    try:
+        saved = await _save_kv("kv_settings", "settings", settings)
+        if saved:
+            logger.info("[STORAGE] Settings saved to database")
+        return saved
+    except Exception as e:
+        logger.error(f"[STORAGE] Settings write failed: {e}")
+    return False
+
+
+# ==================== Stats storage ====================
+
+async def load_stats() -> Optional[dict]:
+    if not is_database_enabled():
+        return None
+    try:
+        return await _load_kv("kv_stats", "stats")
+    except Exception as e:
+        logger.error(f"[STORAGE] Stats read failed: {e}")
+    return None
+
+
+async def save_stats(stats: dict) -> bool:
+    if not is_database_enabled():
+        return False
+    try:
+        return await _save_kv("kv_stats", "stats", stats)
+    except Exception as e:
+        logger.error(f"[STORAGE] Stats write failed: {e}")
+    return False
+
+
+def load_settings_sync() -> Optional[dict]:
+    return _run_in_db_loop(load_settings())
+
+
+def save_settings_sync(settings: dict) -> bool:
+    return _run_in_db_loop(save_settings(settings))
+
+
+def load_stats_sync() -> Optional[dict]:
+    return _run_in_db_loop(load_stats())
+
+
+def save_stats_sync(stats: dict) -> bool:
+    return _run_in_db_loop(save_stats(stats))
+
+
+# ==================== Task history storage ====================
+
+async def save_task_history_entry(entry: dict) -> bool:
+    if not is_database_enabled():
+        return False
+    entry_id = entry.get("id")
+    if not entry_id:
+        return False
+    created_at = float(entry.get("created_at", time.time()))
+    payload = json.dumps(entry, ensure_ascii=False)
+    backend = _get_backend()
+    try:
+        if backend == "postgres":
+            async with _pg_acquire() as conn:
+                await conn.execute(
+                    """
+                    INSERT INTO task_history (id, data, created_at)
+                    VALUES ($1, $2, $3)
+                    ON CONFLICT (id) DO UPDATE SET
+                        data = EXCLUDED.data,
+                        created_at = EXCLUDED.created_at
+                    """,
+                    entry_id,
+                    payload,
+                    created_at,
+                )
+                await conn.execute(
+                    """
+                    DELETE FROM task_history
+                    WHERE id IN (
+                        SELECT id FROM task_history
+                        ORDER BY created_at DESC
+                        OFFSET 100
+                    )
+                    """
+                )
+            return True
+        if backend == "sqlite":
+            conn = _get_sqlite_conn()
+            with _sqlite_lock, conn:
+                conn.execute(
+                    """
+                    INSERT INTO task_history (id, data, created_at)
+                    VALUES (?, ?, ?)
+                    ON CONFLICT(id) DO UPDATE SET
+                        data = excluded.data,
+                        created_at = excluded.created_at
+                    """,
+                    (entry_id, payload, created_at),
+                )
+                conn.execute(
+                    """
+                    DELETE FROM task_history
+                    WHERE id IN (
+                        SELECT id FROM task_history
+                        ORDER BY created_at DESC
+                        LIMIT -1 OFFSET 100
+                    )
+                    """
+                )
+            return True
+    except Exception as e:
+        logger.error(f"[STORAGE] Task history write failed: {e}")
+    return False
+
+
+async def load_task_history(limit: int = 100) -> Optional[list]:
+    if not is_database_enabled():
+        return None
+    backend = _get_backend()
+    try:
+        if backend == "postgres":
+            async with _pg_acquire() as conn:
+                rows = await conn.fetch(
+                    """
+                    SELECT data FROM task_history
+                    ORDER BY created_at DESC
+                    LIMIT $1
+                    """,
+                    limit,
+                )
+            return [_parse_account_value(row["data"]) for row in rows if row and row["data"] is not None]
+        if backend == "sqlite":
+            conn = _get_sqlite_conn()
+            with _sqlite_lock:
+                rows = conn.execute(
+                    """
+                    SELECT data FROM task_history
+                    ORDER BY created_at DESC
+                    LIMIT ?
+                    """,
+                    (limit,),
+                ).fetchall()
+            results = []
+            for row in rows:
+                value = _parse_account_value(row["data"])
+                if value is not None:
+                    results.append(value)
+            return results
+    except Exception as e:
+        logger.error(f"[STORAGE] Task history read failed: {e}")
+    return None
+
+
+async def clear_task_history() -> int:
+    if not is_database_enabled():
+        return 0
+    backend = _get_backend()
+    try:
+        if backend == "postgres":
+            async with _pg_acquire() as conn:
+                result = await conn.execute("DELETE FROM task_history")
+            if result.startswith("DELETE"):
+                parts = result.split()
+                return int(parts[-1]) if parts else 0
+            return 0
+        if backend == "sqlite":
+            conn = _get_sqlite_conn()
+            with _sqlite_lock, conn:
+                cur = conn.execute("DELETE FROM task_history")
+                return cur.rowcount or 0
+    except Exception as e:
+        logger.error(f"[STORAGE] Task history clear failed: {e}")
+    return 0
+
+
+def save_task_history_entry_sync(entry: dict) -> bool:
+    return _run_in_db_loop(save_task_history_entry(entry))
+
+
+def load_task_history_sync(limit: int = 100) -> Optional[list]:
+    return _run_in_db_loop(load_task_history(limit))
+
+
+def clear_task_history_sync() -> int:
+    return _run_in_db_loop(clear_task_history())

core/uptime.py

@@ -0,0 +1,150 @@
+"""
+Uptime 实时监控与心跳历史持久化。
+"""
+
+from collections import deque
+from datetime import datetime, timezone, timedelta
+from typing import Dict, List, Optional
+import json
+import os
+from threading import Lock
+
+# 北京时区 UTC+8
+BEIJING_TZ = timezone(timedelta(hours=8))
+
+# 每个服务保留最近 60 条心跳
+MAX_HEARTBEATS = 60
+SLOW_THRESHOLD_MS = 40000
+WARNING_STATUS_CODES = {429}
+
+_storage_path: Optional[str] = None
+_storage_lock = Lock()
+
+# 服务注册表
+SERVICES = {
+    "api_service": {"name": "API 服务", "heartbeats": deque(maxlen=MAX_HEARTBEATS)},
+    "account_pool": {"name": "服务资源", "heartbeats": deque(maxlen=MAX_HEARTBEATS)},
+    "gemini-2.5-flash": {"name": "Gemini 2.5 Flash", "heartbeats": deque(maxlen=MAX_HEARTBEATS)},
+    "gemini-2.5-pro": {"name": "Gemini 2.5 Pro", "heartbeats": deque(maxlen=MAX_HEARTBEATS)},
+    "gemini-3-flash-preview": {"name": "Gemini 3 Flash Preview", "heartbeats": deque(maxlen=MAX_HEARTBEATS)},
+    "gemini-3-pro-preview": {"name": "Gemini 3 Pro Preview", "heartbeats": deque(maxlen=MAX_HEARTBEATS)},
+    "gemini-3.1-pro-preview": {"name": "Gemini 3.1 Pro Preview", "heartbeats": deque(maxlen=MAX_HEARTBEATS)},
+    "gemini-imagen": {"name": "Gemini Imagen", "heartbeats": deque(maxlen=MAX_HEARTBEATS)},
+    "gemini-veo": {"name": "Gemini Veo", "heartbeats": deque(maxlen=MAX_HEARTBEATS)},
+}
+
+SUPPORTED_MODELS = [
+    "gemini-2.5-flash",
+    "gemini-2.5-pro",
+    "gemini-3-flash-preview",
+    "gemini-3-pro-preview",
+    "gemini-3.1-pro-preview",
+    "gemini-imagen",
+    "gemini-veo",
+]
+
+
+def configure_storage(path: Optional[str]) -> None:
+    """配置心跳持久化路径。"""
+    global _storage_path
+    _storage_path = path
+
+
+def _classify_level(success: bool, status_code: Optional[int], latency_ms: Optional[int]) -> str:
+    if status_code in WARNING_STATUS_CODES:
+        return "warn"
+    if success and latency_ms is not None and latency_ms >= SLOW_THRESHOLD_MS:
+        return "warn"
+    return "up" if success else "down"
+
+
+def _save_heartbeats() -> None:
+    if not _storage_path:
+        return
+    try:
+        payload = {}
+        for service_id, service_data in SERVICES.items():
+            payload[service_id] = list(service_data["heartbeats"])
+        os.makedirs(os.path.dirname(_storage_path), exist_ok=True)
+        with _storage_lock, open(_storage_path, "w", encoding="utf-8") as f:
+            json.dump(payload, f, ensure_ascii=True, indent=2)
+    except Exception:
+        return
+
+
+def load_heartbeats() -> None:
+    if not _storage_path or not os.path.exists(_storage_path):
+        return
+    try:
+        with _storage_lock, open(_storage_path, "r", encoding="utf-8") as f:
+            payload = json.load(f)
+        for service_id, heartbeats in payload.items():
+            if service_id not in SERVICES:
+                continue
+            SERVICES[service_id]["heartbeats"].clear()
+            for beat in heartbeats[-MAX_HEARTBEATS:]:
+                SERVICES[service_id]["heartbeats"].append(beat)
+    except Exception:
+        return
+
+
+def record_request(
+    service: str,
+    success: bool,
+    latency_ms: Optional[int] = None,
+    status_code: Optional[int] = None
+):
+    """记录一次心跳。"""
+    if service not in SERVICES:
+        return
+
+    level = _classify_level(success, status_code, latency_ms)
+    heartbeat = {
+        "time": datetime.now(BEIJING_TZ).strftime("%H:%M:%S"),
+        "success": success,
+        "level": level,
+    }
+    if latency_ms is not None:
+        heartbeat["latency_ms"] = latency_ms
+    if status_code is not None:
+        heartbeat["status_code"] = status_code
+
+    SERVICES[service]["heartbeats"].append(heartbeat)
+    _save_heartbeats()
+
+
+def get_realtime_status() -> Dict:
+    """返回实时监控数据。"""
+    result = {"services": {}}
+
+    for service_id, service_data in SERVICES.items():
+        heartbeats = list(service_data["heartbeats"])
+        total = len(heartbeats)
+        success = sum(1 for h in heartbeats if h.get("success"))
+
+        uptime = (success / total * 100) if total > 0 else 100.0
+
+        last_status = "unknown"
+        if heartbeats:
+            last_level = heartbeats[-1].get("level")
+            if last_level in {"up", "down", "warn"}:
+                last_status = last_level
+            else:
+                last_status = "up" if heartbeats[-1].get("success") else "down"
+
+        result["services"][service_id] = {
+            "name": service_data["name"],
+            "status": last_status,
+            "uptime": round(uptime, 1),
+            "total": total,
+            "success": success,
+            "heartbeats": heartbeats[-MAX_HEARTBEATS:],
+        }
+
+    result["updated_at"] = datetime.now(BEIJING_TZ).strftime("%Y-%m-%d %H:%M:%S")
+    return result
+
+
+async def get_uptime_summary(days: int = 90) -> Dict:
+    """兼容旧接口。"""
+    return get_realtime_status()

docker-compose.yml

@@ -0,0 +1,24 @@
+services:
+  gemini-api:
+    image: cooooookk/gemini-business2api:latest
+    container_name: gemini-business2api
+    ports:
+      - "7860:7860"
+    volumes:
+      - ./data:/app/data
+    env_file:
+      - .env
+    restart: unless-stopped
+    # 健康检查
+    healthcheck:
+      test: ["CMD", "curl", "-f", "http://localhost:7860/health"]
+      interval: 30s
+      timeout: 10s
+      retries: 3
+      start_period: 10s
+    # 日志限制
+    logging:
+      driver: json-file
+      options:
+        max-size: "10m"
+        max-file: "3"

docs/DISCLAIMER.md

@@ -0,0 +1,43 @@
+# 使用声明与免责条款
+
+## ⚠️ 严禁滥用：禁止将本工具用于商业用途或任何形式的滥用（无论规模大小）
+
+**本工具严禁用于以下行为：**
+- 商业用途或盈利性使用
+- 任何形式的批量操作或自动化滥用（无论规模大小）
+- 破坏市场秩序或恶意竞争
+- 违反 Google 服务条款的任何行为
+- 违反 Microsoft 服务条款的任何行为
+
+**违规后果**：滥用行为可能导致账号永久封禁、法律追责，一切后果由使用者自行承担。
+
+## 📖 合法用途
+
+本项目仅限于以下场景：
+- 个人学习与技术研究
+- 浏览器自动化技术探索
+- 非商业性技术交流
+
+## ⚖️ 法律责任
+
+1. **使用者责任**：使用本工具产生的一切后果（包括但不限于账号封禁、数据损失、法律纠纷）由使用者完全承担
+2. **合规义务**：使用者必须遵守所在地法律法规及第三方服务条款（包括但不限于 Google Workspace、Microsoft 365 等服务条款）
+3. **作者免责**：作者不对任何违规使用、滥用行为或由此产生的后果承担责任
+
+## 📋 技术声明
+
+- **无担保**：本项目按"现状"提供，不提供任何形式的担保
+- **第三方依赖**：依赖的第三方服务（如 DuckMail API、Microsoft Graph API 等）可用性不受作者控制
+- **维护权利**：作者保留随时停止维护、变更功能或关闭项目的权利
+
+## 🔗 相关服务条款
+
+使用本工具时，您必须同时遵守以下第三方服务的条款：
+- [Google 服务条款](https://policies.google.com/terms)
+- [Google Workspace 附加条款](https://workspace.google.com/terms/service-terms.html)
+- [Microsoft 服务协议](https://www.microsoft.com/servicesagreement)
+- [Microsoft 365 使用条款](https://www.microsoft.com/licensing/terms)
+
+---
+
+**使用本工具即表示您已阅读、理解并同意遵守以上所有条款。**

docs/DISCLAIMER_EN.md

@@ -0,0 +1,34 @@
+# Terms of Use and Disclaimer
+
+## ⚠️ Abuse Prohibited
+
+**This tool is strictly prohibited for the following uses:**
+- Commercial use or profit-making activities
+- Any form of batch operations or automated abuse (regardless of scale)
+- Market disruption or malicious competition
+- Any behavior violating Google's Terms of Service
+
+**Consequences:** Abuse may result in permanent account bans, legal liability, and all consequences are borne by the user.
+
+## 📖 Legitimate Use
+
+This project is limited to the following scenarios:
+- Personal learning and technical research
+- Browser automation technology exploration
+- Non-commercial technical exchange
+
+## ⚖️ Legal Liability
+
+1. **User Responsibility**: All consequences arising from the use of this tool (including but not limited to account bans, data loss, legal disputes) are entirely borne by the user
+2. **Compliance Obligation**: Users must comply with local laws and regulations and third-party service terms
+3. **Author Disclaimer**: The author is not responsible for any violations, abuse, or consequences arising therefrom
+
+## 📋 Technical Disclaimer
+
+- **No Warranty**: This project is provided "as is" without any form of warranty
+- **Third-Party Dependencies**: Depends on third-party services (such as DuckMail API) whose availability is not controlled by the author
+- **Maintenance Rights**: The author reserves the right to stop maintenance, change functionality, or shut down the project at any time
+
+---
+
+**By using this tool, you acknowledge that you have read, understood, and agree to comply with all the above terms.**

docs/README_EN.md

@@ -0,0 +1,377 @@
+<p align="center">
+  <img src="../docs/logo.svg" width="120" alt="Gemini Business2API logo" />
+</p>
+<h1 align="center">Gemini Business2API</h1>
+<p align="center">Empowering AI with seamless integration</p>
+<p align="center">
+  <a href="../README.md">简体中文</a> | <strong>English</strong>
+</p>
+<p align="center"><img src="https://img.shields.io/badge/License-MIT-yellow.svg" /> <img src="https://img.shields.io/badge/Python-3.11-3776AB?logo=python&logoColor=white" /> <img src="https://img.shields.io/badge/FastAPI-0.110-009688?logo=fastapi&logoColor=white" /> <img src="https://img.shields.io/badge/Vue-3-4FC08D?logo=vue.js&logoColor=white" /> <img src="https://img.shields.io/badge/Vite-7-646CFF?logo=vite&logoColor=white" /> <img src="https://img.shields.io/badge/Docker-ready-2496ED?logo=docker&logoColor=white" /></p>
+
+<p align="center">Convert Gemini Business to OpenAI-compatible API with multi-account load balancing, image generation, video generation, multimodal capabilities, and built-in admin panel.</p>
+
+---
+
+## 📜 License & Disclaimer
+
+**License**: MIT License - See [LICENSE](../LICENSE) for details
+
+### ⚠️ Prohibited Use & Anti-Abuse Policy
+
+**This tool is strictly prohibited for:**
+- Commercial use or profit-making activities
+- Batch operations or automated abuse of any scale
+- Market disruption or malicious competition
+- Violations of Google's Terms of Service
+- Violations of Microsoft's Terms of Service
+
+**Consequences**: Violations may result in permanent account suspension and legal liability. All consequences are the sole responsibility of the user.
+
+**Legitimate Use Only**: Personal learning, technical research, and non-commercial educational purposes only.
+
+📖 **Full Disclaimer**: [DISCLAIMER_EN.md](DISCLAIMER_EN.md)
+
+---
+
+## ✨ Features
+
+- ✅ Full OpenAI API compatibility - Seamless integration with existing tools
+- ✅ Multi-account load balancing - Round-robin with automatic failover
+- ✅ Automated account management - Auto registration & login, multiple temp email providers, headless browser mode
+- ✅ Streaming output - Real-time responses
+- ✅ Multimodal input - 100+ file types (images, PDF, Office docs, audio, video, code, etc.)
+- ✅ Image generation & image-to-image - Configurable models, Base64 or URL output
+- ✅ Video generation - Dedicated model with HTML/URL/Markdown output formats
+- ✅ Smart file handling - Auto file type detection, supports URL and Base64
+- ✅ Logging & monitoring - Real-time status and statistics
+- ✅ Proxy support - Configure via admin settings panel
+- ✅ Built-in admin panel - Online configuration and account management
+- ✅ PostgreSQL / SQLite storage - Persistent accounts/settings/stats
+
+## 🤖 Model Capabilities
+
+| Model ID                 | Vision | Native Web | File Multimodal | Image Gen | Video Gen |
+| ------------------------ | ------ | ---------- | --------------- | --------- | --------- |
+| `gemini-auto`            | ✅      | ✅          | ✅               | Optional  | -         |
+| `gemini-2.5-flash`       | ✅      | ✅          | ✅               | Optional  | -         |
+| `gemini-2.5-pro`         | ✅      | ✅          | ✅               | Optional  | -         |
+| `gemini-3-flash-preview` | ✅      | ✅          | ✅               | Optional  | -         |
+| `gemini-3-pro-preview`   | ✅      | ✅          | ✅               | Optional  | -         |
+| `gemini-3.1-pro-preview` | ✅      | ✅          | ✅               | Optional  | -         |
+| `gemini-imagen`          | ✅      | ✅          | ✅               | ✅         | -         |
+| `gemini-veo`             | ✅      | ✅          | ✅               | -         | ✅         |
+
+> `gemini-imagen`: Dedicated image generation model · `gemini-veo`: Dedicated video generation model
+
+---
+
+## 🚀 Quick Start
+
+### Method 1: Docker Compose (Recommended)
+
+**Supports ARM64 and AMD64 architectures**
+
+```bash
+git clone https://github.com/Dreamy-rain/gemini-business2api.git
+cd gemini-business2api
+cp .env.example .env
+# Edit .env to set ADMIN_KEY
+
+docker-compose up -d
+
+# View logs
+docker-compose logs -f
+
+# Update to latest version
+docker-compose pull && docker-compose up -d
+```
+
+---
+
+### Method 2: Setup Script
+
+> **Prerequisites**: Git, Node.js & npm (for frontend build). Script auto-installs Python 3.11 and uv.
+
+**Linux / macOS / WSL:**
+```bash
+git clone https://github.com/Dreamy-rain/gemini-business2api.git
+cd gemini-business2api
+bash setup.sh
+# Edit .env to set ADMIN_KEY
+source .venv/bin/activate
+python main.py
+# Background with pm2
+pm2 start main.py --name gemini-api --interpreter ./.venv/bin/python3
+```
+
+**Windows:**
+```cmd
+git clone https://github.com/Dreamy-rain/gemini-business2api.git
+cd gemini-business2api
+setup.bat
+# Edit .env to set ADMIN_KEY
+.venv\Scripts\activate.bat
+python main.py
+# Background with pm2
+pm2 start main.py --name gemini-api --interpreter ./.venv/Scripts/python.exe
+```
+
+The script handles: uv install, Python 3.11 download, dependency install, frontend build, `.env` creation.
+To update, simply re-run the same script.
+
+---
+
+### Method 3: Manual Deployment
+
+```bash
+git clone https://github.com/Dreamy-rain/gemini-business2api.git
+cd gemini-business2api
+
+curl -LsSf https://astral.sh/uv/install.sh | sh
+uv python install 3.11
+
+cd frontend && npm install && npm run build && cd ..
+
+uv venv --python 3.11 .venv
+source .venv/bin/activate  # Windows: .venv\Scripts\activate.bat
+uv pip install -r requirements.txt
+
+cp .env.example .env
+# Edit .env to set ADMIN_KEY
+python main.py
+```
+
+---
+
+### Access
+
+- **Admin Panel**: `http://localhost:7860/` (Login with `ADMIN_KEY`)
+- **API Endpoint**: `http://localhost:7860/v1/chat/completions`
+
+---
+
+## 🗄️ Database Persistence
+
+Set `DATABASE_URL` to persist accounts, settings, and stats. Without it, SQLite (`data.db`) is used automatically.
+
+**Configuration:**
+- Local deployment → add to `.env`
+- Cloud platforms → set in platform environment variables
+
+```
+DATABASE_URL=postgresql://user:password@host/dbname?sslmode=require
+```
+
+**Free PostgreSQL Providers:**
+
+| Service | Free Tier | How to Get |
+|---------|-----------|-----------|
+| [Neon](https://neon.tech) | 512MB / 100 CPUH/month | Sign up → Create Project → Copy Connection string |
+| [Aiven](https://aiven.io) | More generous | Sign up → Create PostgreSQL service → Copy connection string |
+
+> Both `postgres://` and `postgresql://` formats are supported natively.
+
+<details>
+<summary>⚠️ FAQ: Periodic save failure / ConnectionDoesNotExistError</summary>
+
+If you see errors like:
+
+```
+ERROR [COOLDOWN] Save failed: connection was closed in the middle of operation
+asyncpg.exceptions.ConnectionDoesNotExistError: connection was closed in the middle of operation
+```
+
+This happens when free PostgreSQL providers (e.g., Aiven free tier) close idle connections. **It does not affect normal usage** — the next operation will auto-reconnect. If frequent, consider switching to [Neon](https://neon.tech) or upgrading your database plan.
+
+</details>
+
+<details>
+<summary>📦 Database Migration (Upgrading from older versions)</summary>
+
+If you have legacy local files (`accounts.json` / `settings.yaml` / `stats.json`), run:
+
+```bash
+python scripts/migrate_to_database.py
+```
+
+The script auto-detects the environment (PostgreSQL / SQLite) and renames old files after migration.
+
+</details>
+
+---
+
+## 📡 API Endpoints
+
+Fully OpenAI API compatible. Works with ChatGPT-Next-Web, LobeChat, OpenCat, and other clients.
+
+| Endpoint | Method | Description |
+|----------|--------|-------------|
+| `/v1/chat/completions` | POST | Chat completions (streaming supported) |
+| `/v1/models` | GET | List available models |
+| `/v1/images/generations` | POST | Image generation (text-to-image) |
+| `/v1/images/edits` | POST | Image editing (image-to-image) |
+| `/health` | GET | Health check |
+
+**Example:**
+
+```bash
+curl http://localhost:7860/v1/chat/completions \
+  -H "Authorization: Bearer your-api-key" \
+  -H "Content-Type: application/json" \
+  -d '{
+    "model": "gemini-2.5-flash",
+    "messages": [{"role": "user", "content": "Hello"}],
+    "stream": true
+  }'
+```
+
+> `API_KEY` is configured in Admin Panel → System Settings. Leave empty for public access. Multiple keys supported (comma-separated).
+
+---
+
+## 📧 Email Provider Configuration
+
+The project supports 4 temporary email providers for automatic account registration. Switch and configure them in **Admin Panel → System Settings → Temp Email Provider**.
+
+### Moemail (Default)
+
+Open-source temporary email service, ready to use out of the box.
+
+- **Project**: [github.com/beilunyang/moemail](https://github.com/beilunyang/moemail)
+- **Website**: [moemail.app](https://moemail.app)
+- **Config**: API URL + API Key + Domain (optional)
+
+### DuckMail
+
+Temporary email API service. Custom domain recommended.
+
+- **Domain Management**: [domain.duckmail.sbs](https://domain.duckmail.sbs/)
+- **Config**: API URL + API Key + Registration Domain
+
+### GPTMail
+
+Temporary email API service, no password required.
+
+- **Default URL**: `https://mail.chatgpt.org.uk`
+- **Default API Key**: `gpt-test`
+- **Config**: API URL + API Key + Domain (optional)
+
+### Freemail
+
+Self-hosted temporary email service, for users with their own servers.
+
+- **Project**: [github.com/idinging/freemail](https://github.com/idinging/freemail)
+- **Config**: Self-hosted service URL + JWT Token + Domain (optional)
+
+> **Tip**: All email settings are configured in the admin panel. Microsoft email login is also handled through the admin panel.
+
+---
+
+## 🌐 Recommended Deployment Platforms
+
+In addition to local Docker Compose, these platforms support Docker image deployment:
+
+| Platform | Free Tier | Features |
+|----------|-----------|----------|
+| [Render](https://render.com) | ✅ Yes | Docker support, auto SSL, free PostgreSQL |
+| [Railway](https://railway.app) | $5/month credit | One-click Docker deploy, built-in database |
+| [Fly.io](https://fly.io) | ✅ Yes | Global edge deployment, persistent volumes |
+| [Claw Cloud](https://claw.cloud) | ✅ Yes | Container cloud, simple and easy |
+| Self-hosted VPS (Recommended) | — | Full control with Docker Compose |
+
+> Docker image: `cooooookk/gemini-business2api:latest`
+>
+> Set `ADMIN_KEY` and `DATABASE_URL` environment variables when deploying.
+
+### Zeabur Deployment Guide
+
+1. Fork this repository to your GitHub
+2. Log in to [Zeabur](https://zeabur.com) → **Create Project** → **Shared Cluster** → **Deploy New Service** → **Connect GitHub** → Select your forked repo
+3. Add environment variables:
+
+   | Variable | Required | Description |
+   |----------|----------|-------------|
+   | `ADMIN_KEY` | ✅ | Admin panel login key |
+   | `DATABASE_URL` | Optional | PostgreSQL connection string (recommended to avoid data loss on restart) |
+
+4. **Persistent Storage** (Important):
+
+   Add persistent storage in service settings:
+
+   | Disk ID | Mount Path |
+   |---------|-----------|
+   | `data` | `/app/data` |
+
+5. Click **Redeploy** to apply settings
+
+**Update**: GitHub repo → **Sync fork** → **Update branch**, Zeabur will auto-redeploy.
+
+---
+
+## 🔄 Standalone Refresh Service
+
+To deploy the account refresh service separately from the main API, use the [`refresh-worker` branch](https://github.com/Dreamy-rain/gemini-business2api/tree/refresh-worker):
+
+```bash
+git clone -b refresh-worker https://github.com/Dreamy-rain/gemini-business2api.git gemini-refresh-worker
+cd gemini-refresh-worker
+cp .env.example .env
+# Edit .env to set DATABASE_URL
+docker-compose up -d
+```
+
+This service reads accounts from the database and runs scheduled credential refresh independently. Supports cron scheduling, batch processing, and cooldown deduplication.
+
+---
+
+## 🌐 Socks5 Free Proxy Pool
+
+Configure a proxy when auto-registering/refreshing accounts to improve success rates:
+
+- **Project**: [github.com/Dreamy-rain/socks5-proxy](https://github.com/Dreamy-rain/socks5-proxy)
+- **Note**: Free proxies are not very stable, but can help improve registration success rates
+- **Usage**: Configure in Admin Panel → System Settings → Proxy Settings
+
+---
+
+## 📸 Screenshots
+
+### Admin System
+
+<table>
+  <tr>
+    <td><img src="img/1.png" alt="Admin System 1" /></td>
+    <td><img src="img/2.png" alt="Admin System 2" /></td>
+  </tr>
+  <tr>
+    <td><img src="img/3.png" alt="Admin System 3" /></td>
+    <td><img src="img/4.png" alt="Admin System 4" /></td>
+  </tr>
+  <tr>
+    <td><img src="img/5.png" alt="Admin System 5" /></td>
+    <td><img src="img/6.png" alt="Admin System 6" /></td>
+  </tr>
+</table>
+
+### Image Effects
+
+<table>
+  <tr>
+    <td><img src="img/img_1.png" alt="Image Effects 1" /></td>
+    <td><img src="img/img_2.png" alt="Image Effects 2" /></td>
+  </tr>
+  <tr>
+    <td><img src="img/img_3.png" alt="Image Effects 3" /></td>
+    <td><img src="img/img_4.png" alt="Image Effects 4" /></td>
+  </tr>
+</table>
+
+### Documentation
+
+- Supported file types: [SUPPORTED_FILE_TYPES.md](SUPPORTED_FILE_TYPES.md)
+
+## ⭐ Star History
+
+[![Star History Chart](https://api.star-history.com/svg?repos=Dreamy-rain/gemini-business2api&type=date&legend=top-left)](https://www.star-history.com/#Dreamy-rain/gemini-business2api&type=date&legend=top-left)
+
+**If this project helps you, please give it a ⭐ Star!**

docs/SUPPORTED_FILE_TYPES.md

@@ -0,0 +1,383 @@
+# 支持的文件类型清单
+
+本文档列出了 Gemini 可能支持的所有文件类型（可能支持）。
+
+**支持的文件类型**（12 个分类，100+ 种格式）：
+
+- 🖼️ **图片文件** - 11 种格式（PNG, JPEG, WebP, GIF, BMP, TIFF, SVG, ICO, HEIC, HEIF, AVIF）
+- 📄 **文档文件** - 9 种格式（PDF, TXT, Markdown, HTML, XML, CSV, TSV, RTF, LaTeX）
+- 📊 **Microsoft Office** - 6 种格式（.docx, .doc, .xlsx, .xls, .pptx, .ppt）
+- 📝 **Google Workspace** - 3 种格式（Docs, Sheets, Slides）
+- 💻 **代码文件** - 19 种语言（Python, JavaScript, TypeScript, Java, C/C++, Go, Rust, PHP, Ruby, Swift, Kotlin, Scala, Shell, PowerShell, SQL, R, MATLAB 等）
+- 🎨 **Web 开发** - 8 种格式（CSS, SCSS, LESS, JSON, YAML, TOML, Vue, Svelte）
+- 🎵 **音频文件** - 10 种格式（MP3, WAV, AAC, M4A, OGG, FLAC, AIFF, WMA, OPUS, AMR）
+- 🎬 **视频文件** - 10 种格式（MP4, MOV, AVI, MPEG, WebM, FLV, WMV, MKV, 3GPP, M4V）
+- 📦 **数据文件** - 6 种格式（JSON, JSONL, CSV, TSV, Parquet, Avro）
+- 🗜️ **压缩文件** - 5 种格式（ZIP, RAR, 7Z, TAR, GZ）
+- 🔧 **配置文件** - 5 种格式（YAML, TOML, INI, ENV, Properties）
+- 📚 **电子书** - 2 种格式（EPUB, MOBI）
+
+## 🖼️ 图片文件（Image Files）
+
+| 格式 | 扩展名          | MIME 类型       | 支持状态   | 说明               |
+| ---- | --------------- | --------------- | ---------- | ------------------ |
+| PNG  | `.png`          | `image/png`     | ✅ 完全支持 | 无损压缩，支持透明 |
+| JPEG | `.jpg`, `.jpeg` | `image/jpeg`    | ✅ 完全支持 | 有损压缩，照片常用 |
+| WebP | `.webp`         | `image/webp`    | ✅ 完全支持 | 现代格式，体积小   |
+| GIF  | `.gif`          | `image/gif`     | ✅ 完全支持 | 支持动画           |
+| BMP  | `.bmp`          | `image/bmp`     | ✅ 支持     | Windows 位图       |
+| TIFF | `.tiff`, `.tif` | `image/tiff`    | ✅ 支持     | 高质量图像         |
+| SVG  | `.svg`          | `image/svg+xml` | ✅ 支持     | 矢量图形           |
+| ICO  | `.ico`          | `image/x-icon`  | ✅ 支持     | 图标文件           |
+| HEIC | `.heic`         | `image/heic`    | ✅ 支持     | Apple 高效图像格式 |
+| HEIF | `.heif`         | `image/heif`    | ✅ 支持     | 高效图像格式       |
+| AVIF | `.avif`         | `image/avif`    | ✅ 支持     | 新一代图像格式     |
+
+## 📄 文档文件（Document Files）
+
+| 格式     | 扩展名          | MIME 类型                       | 支持状态   | 说明                   |
+| -------- | --------------- | ------------------------------- | ---------- | ---------------------- |
+| PDF      | `.pdf`          | `application/pdf`               | ✅ 完全支持 | 可提取文本、图片、表格 |
+| 纯文本   | `.txt`          | `text/plain`                    | ✅ 完全支持 | 纯文本文件             |
+| Markdown | `.md`           | `text/markdown`                 | ✅ 完全支持 | 标记语言               |
+| HTML     | `.html`, `.htm` | `text/html`                     | ✅ 完全支持 | 网页文件               |
+| XML      | `.xml`          | `text/xml` 或 `application/xml` | ✅ 完全支持 | 结构化数据             |
+| CSV      | `.csv`          | `text/csv`                      | ✅ 完全支持 | 表格数据               |
+| TSV      | `.tsv`          | `text/tab-separated-values`     | ✅ 支持     | 制表符分隔             |
+| RTF      | `.rtf`          | `application/rtf`               | ✅ 支持     | 富文本格式             |
+| LaTeX    | `.tex`          | `text/x-tex`                    | ✅ 支持     | 科学文档               |
+
+## 📊 Microsoft Office 文档
+
+| 格式            | 扩展名  | MIME 类型                                                                   | 支持状态 | 说明             |
+| --------------- | ------- | --------------------------------------------------------------------------- | -------- | ---------------- |
+| Word (新)       | `.docx` | `application/vnd.openxmlformats-officedocument.wordprocessingml.document`   | ✅ 支持   | 可提取文本和格式 |
+| Word (旧)       | `.doc`  | `application/msword`                                                        | ✅ 支持   | 旧版 Word 文档   |
+| Excel (新)      | `.xlsx` | `application/vnd.openxmlformats-officedocument.spreadsheetml.sheet`         | ✅ 支持   | 可读取表格数据   |
+| Excel (旧)      | `.xls`  | `application/vnd.ms-excel`                                                  | ✅ 支持   | 旧版 Excel 文档  |
+| PowerPoint (新) | `.pptx` | `application/vnd.openxmlformats-officedocument.presentationml.presentation` | ✅ 支持   | 可提取文本和图片 |
+| PowerPoint (旧) | `.ppt`  | `application/vnd.ms-powerpoint`                                             | ✅ 支持   | 旧版 PPT 文档    |
+
+## 📝 Google Workspace 文档
+
+| 格式          | 扩展名     | MIME 类型                                  | 支持状态 | 说明         |
+| ------------- | ---------- | ------------------------------------------ | -------- | ------------ |
+| Google Docs   | `.gdoc`    | `application/vnd.google-apps.document`     | ✅ 支持   | 需要导出链接 |
+| Google Sheets | `.gsheet`  | `application/vnd.google-apps.spreadsheet`  | ✅ 支持   | 需要导出链接 |
+| Google Slides | `.gslides` | `application/vnd.google-apps.presentation` | ✅ 支持   | 需要导出链接 |
+
+## 💻 代码文件（Code Files）
+
+| 格式       | 扩展名                | MIME 类型                                     | 支持状态   | 说明            |
+| ---------- | --------------------- | --------------------------------------------- | ---------- | --------------- |
+| Python     | `.py`                 | `text/x-python` 或 `application/x-python`     | ✅ 完全支持 | Python 代码     |
+| JavaScript | `.js`                 | `text/javascript` 或 `application/javascript` | ✅ 完全支持 | JS 代码         |
+| TypeScript | `.ts`                 | `text/typescript` 或 `application/typescript` | ✅ 完全支持 | TS 代码         |
+| JSX/TSX    | `.jsx`, `.tsx`        | `text/jsx`, `text/tsx`                        | ✅ 支持     | React 组件      |
+| Java       | `.java`               | `text/x-java-source`                          | ✅ 完全支持 | Java 代码       |
+| C          | `.c`                  | `text/x-c`                                    | ✅ 支持     | C 语言          |
+| C++        | `.cpp`, `.cc`, `.cxx` | `text/x-c++`                                  | ✅ 支持     | C++ 代码        |
+| C#         | `.cs`                 | `text/x-csharp`                               | ✅ 支持     | C# 代码         |
+| Go         | `.go`                 | `text/x-go`                                   | ✅ 支持     | Go 语言         |
+| Rust       | `.rs`                 | `text/x-rust`                                 | ✅ 支持     | Rust 代码       |
+| PHP        | `.php`                | `text/x-php` 或 `application/x-php`           | ✅ 支持     | PHP 代码        |
+| Ruby       | `.rb`                 | `text/x-ruby`                                 | ✅ 支持     | Ruby 代码       |
+| Swift      | `.swift`              | `text/x-swift`                                | ✅ 支持     | Swift 代码      |
+| Kotlin     | `.kt`                 | `text/x-kotlin`                               | ✅ 支持     | Kotlin 代码     |
+| Scala      | `.scala`              | `text/x-scala`                                | ✅ 支持     | Scala 代码      |
+| Shell      | `.sh`, `.bash`        | `text/x-shellscript`                          | ✅ 支持     | Shell 脚本      |
+| PowerShell | `.ps1`                | `text/x-powershell`                           | ✅ 支持     | PowerShell 脚本 |
+| SQL        | `.sql`                | `text/x-sql` 或 `application/sql`             | ✅ 支持     | SQL 脚本        |
+| R          | `.r`, `.R`            | `text/x-r`                                    | ✅ 支持     | R 语言          |
+| MATLAB     | `.m`                  | `text/x-matlab`                               | ✅ 支持     | MATLAB 代码     |
+
+## 🎨 Web 开发文件
+
+| 格式      | 扩展名           | MIME 类型                           | 支持状态   | 说明         |
+| --------- | ---------------- | ----------------------------------- | ---------- | ------------ |
+| CSS       | `.css`           | `text/css`                          | ✅ 完全支持 | 样式表       |
+| SCSS/Sass | `.scss`, `.sass` | `text/x-scss`, `text/x-sass`        | ✅ 支持     | CSS 预处理器 |
+| LESS      | `.less`          | `text/x-less`                       | ✅ 支持     | CSS 预处理器 |
+| JSON      | `.json`          | `application/json`                  | ✅ 完全支持 | 数据交换格式 |
+| YAML      | `.yaml`, `.yml`  | `text/yaml` 或 `application/x-yaml` | ✅ 支持     | 配置文件     |
+| TOML      | `.toml`          | `application/toml`                  | ✅ 支持     | 配置文件     |
+| Vue       | `.vue`           | `text/x-vue`                        | ✅ 支持     | Vue 组件     |
+| Svelte    | `.svelte`        | `text/x-svelte`                     | ✅ 支持     | Svelte 组件  |
+
+## 🎵 音频文件（Audio Files）
+
+| 格式 | 扩展名          | MIME 类型                    | 支持状态   | 说明         |
+| ---- | --------------- | ---------------------------- | ---------- | ------------ |
+| MP3  | `.mp3`          | `audio/mpeg` 或 `audio/mp3`  | ✅ 完全支持 | 最常用格式   |
+| WAV  | `.wav`          | `audio/wav` 或 `audio/x-wav` | ✅ 完全支持 | 无损格式     |
+| AAC  | `.aac`          | `audio/aac`                  | ✅ 支持     | 高质量压缩   |
+| M4A  | `.m4a`          | `audio/m4a` 或 `audio/mp4`   | ✅ 支持     | Apple 格式   |
+| OGG  | `.ogg`          | `audio/ogg`                  | ✅ 支持     | 开源格式     |
+| FLAC | `.flac`         | `audio/flac`                 | ✅ 支持     | 无损压缩     |
+| AIFF | `.aiff`, `.aif` | `audio/aiff`                 | ✅ 支持     | Apple 格式   |
+| WMA  | `.wma`          | `audio/x-ms-wma`             | ✅ 支持     | Windows 格式 |
+| OPUS | `.opus`         | `audio/opus`                 | ✅ 支持     | 高效编码     |
+| AMR  | `.amr`          | `audio/amr`                  | ✅ 支持     | 语音编码     |
+
+**音频功能**：
+- 🎤 语音转文字（转录）
+- 🗣️ 说话人识别
+- 🌍 语言识别
+- 😊 情感分析
+- 🎵 音乐分析
+
+## 🎬 视频文件（Video Files）
+
+| 格式 | 扩展名          | MIME 类型          | 支持状态   | 说明         |
+| ---- | --------------- | ------------------ | ---------- | ------------ |
+| MP4  | `.mp4`          | `video/mp4`        | ✅ 完全支持 | 最常用格式   |
+| MOV  | `.mov`          | `video/quicktime`  | ✅ 完全支持 | Apple 格式   |
+| AVI  | `.avi`          | `video/x-msvideo`  | ✅ 支持     | Windows 格式 |
+| MPEG | `.mpeg`, `.mpg` | `video/mpeg`       | ✅ 支持     | 标准格式     |
+| WebM | `.webm`         | `video/webm`       | ✅ 支持     | 网页格式     |
+| FLV  | `.flv`          | `video/x-flv`      | ✅ 支持     | Flash 格式   |
+| WMV  | `.wmv`          | `video/x-ms-wmv`   | ✅ 支持     | Windows 格式 |
+| MKV  | `.mkv`          | `video/x-matroska` | ✅ 支持     | 开源容器     |
+| 3GPP | `.3gp`, `.3gpp` | `video/3gpp`       | ✅ 支持     | 移动格式     |
+| M4V  | `.m4v`          | `video/x-m4v`      | ✅ 支持     | Apple 格式   |
+
+**视频功能**：
+- 🎬 场景识别
+- 👤 人物检测
+- 🏷️ 对象识别
+- 📝 字幕生成
+- 🎯 动作识别
+- 📊 内容分析
+
+## 📦 数据文件（Data Files）
+
+| 格式    | 扩展名     | MIME 类型                   | 支持状态   | 说明        |
+| ------- | ---------- | --------------------------- | ---------- | ----------- |
+| JSON    | `.json`    | `application/json`          | ✅ 完全支持 | 数据交换    |
+| JSONL   | `.jsonl`   | `application/jsonlines`     | ✅ 支持     | 行分隔 JSON |
+| CSV     | `.csv`     | `text/csv`                  | ✅ 完全支持 | 表格数据    |
+| TSV     | `.tsv`     | `text/tab-separated-values` | ✅ 支持     | 制表符分隔  |
+| Parquet | `.parquet` | `application/x-parquet`     | ⚠️ 可能支持 | 列式存储    |
+| Avro    | `.avro`    | `application/avro`          | ⚠️ 可能支持 | 数据序列化  |
+
+## 🗜️ 压缩文件（Archive Files）
+
+| 格式 | 扩展名 | MIME 类型                      | 支持状态   | 说明     |
+| ---- | ------ | ------------------------------ | ---------- | -------- |
+| ZIP  | `.zip` | `application/zip`              | ⚠️ 部分支持 | 需要解压 |
+| RAR  | `.rar` | `application/x-rar-compressed` | ❌ 不支持   | 需要解压 |
+| 7Z   | `.7z`  | `application/x-7z-compressed`  | ❌ 不支持   | 需要解压 |
+| TAR  | `.tar` | `application/x-tar`            | ⚠️ 部分支持 | 需要解压 |
+| GZ   | `.gz`  | `application/gzip`             | ⚠️ 部分支持 | 需要解压 |
+
+## 🔧 配置文件（Configuration Files）
+
+| 格式       | 扩展名          | MIME 类型          | 支持状态   | 说明      |
+| ---------- | --------------- | ------------------ | ---------- | --------- |
+| YAML       | `.yaml`, `.yml` | `text/yaml`        | ✅ 完全支持 | 配置文件  |
+| TOML       | `.toml`         | `application/toml` | ✅ 支持     | 配置文件  |
+| INI        | `.ini`          | `text/plain`       | ✅ 支持     | 配置文件  |
+| ENV        | `.env`          | `text/plain`       | ✅ 支持     | 环境变量  |
+| Properties | `.properties`   | `text/plain`       | ✅ 支持     | Java 配置 |
+
+## 📚 电子书格式（E-book Formats）
+
+| 格式 | 扩展名  | MIME 类型                        | 支持状态   | 说明        |
+| ---- | ------- | -------------------------------- | ---------- | ----------- |
+| EPUB | `.epub` | `application/epub+zip`           | ⚠️ 可能支持 | 电子书格式  |
+| MOBI | `.mobi` | `application/x-mobipocket-ebook` | ⚠️ 可能支持 | Kindle 格式 |
+
+## 📊 文件大小限制
+
+| 文件类型    | 推荐大小 | 最大大小 | 处理时间   |
+| ----------- | -------- | -------- | ---------- |
+| 图片        | < 5 MB   | ~20 MB   | 秒级       |
+| PDF         | < 10 MB  | ~100 MB  | 秒到分钟   |
+| Office 文档 | < 10 MB  | ~50 MB   | 秒到分钟   |
+| 文本/代码   | < 1 MB   | ~10 MB   | 秒级       |
+| 音频        | < 20 MB  | ~100 MB  | 分钟级     |
+| 视频        | < 100 MB | ~2 GB    | 分钟到小时 |
+
+## 🎯 使用示例
+
+### 1. 图片文件
+
+```bash
+curl -X POST http://localhost:7860/v1/v1/chat/completions \
+  -H "Content-Type: application/json" \
+  -H "Authorization: Bearer your_api_key" \
+  -d '{
+    "model": "gemini-2.5-pro",
+    "messages": [{
+      "role": "user",
+      "content": [
+        {"type": "text", "text": "描述这张图片"},
+        {"type": "image_url", "image_url": {"url": "data:image/jpeg;base64,/9j/4AAQSkZJRg..."}}
+      ]
+    }]
+  }'
+```
+
+### 2. PDF 文档
+
+```bash
+curl -X POST http://localhost:7860/v1/v1/chat/completions \
+  -H "Content-Type: application/json" \
+  -H "Authorization: Bearer your_api_key" \
+  -d '{
+    "model": "gemini-2.5-pro",
+    "messages": [{
+      "role": "user",
+      "content": [
+        {"type": "text", "text": "总结这个PDF的主要内容"},
+        {"type": "image_url", "image_url": {"url": "https://example.com/report.pdf"}}
+      ]
+    }]
+  }'
+```
+
+### 3. Office 文档
+
+```bash
+# Word 文档
+curl -X POST http://localhost:7860/v1/v1/chat/completions \
+  -H "Content-Type: application/json" \
+  -H "Authorization: Bearer your_api_key" \
+  -d '{
+    "model": "gemini-2.5-pro",
+    "messages": [{
+      "role": "user",
+      "content": [
+        {"type": "text", "text": "总结这个Word文档的内容"},
+        {"type": "image_url", "image_url": {"url": "https://example.com/document.docx"}}
+      ]
+    }]
+  }'
+
+# Excel 表格
+curl -X POST http://localhost:7860/v1/v1/chat/completions \
+  -H "Content-Type: application/json" \
+  -H "Authorization: Bearer your_api_key" \
+  -d '{
+    "model": "gemini-2.5-pro",
+    "messages": [{
+      "role": "user",
+      "content": [
+        {"type": "text", "text": "分析这个Excel表格的数据"},
+        {"type": "image_url", "image_url": {"url": "https://example.com/data.xlsx"}}
+      ]
+    }]
+  }'
+
+# PowerPoint 演示文稿
+curl -X POST http://localhost:7860/v1/v1/chat/completions \
+  -H "Content-Type: application/json" \
+  -H "Authorization: Bearer your_api_key" \
+  -d '{
+    "model": "gemini-2.5-pro",
+    "messages": [{
+      "role": "user",
+      "content": [
+        {"type": "text", "text": "总结这个PPT的主要内容"},
+        {"type": "image_url", "image_url": {"url": "https://example.com/presentation.pptx"}}
+      ]
+    }]
+  }'
+```
+
+### 4. 音频文件
+
+```bash
+curl -X POST http://localhost:7860/v1/v1/chat/completions \
+  -H "Content-Type: application/json" \
+  -H "Authorization: Bearer your_api_key" \
+  -d '{
+    "model": "gemini-2.5-pro",
+    "messages": [{
+      "role": "user",
+      "content": [
+        {"type": "text", "text": "转录这段音频并总结内容"},
+        {"type": "image_url", "image_url": {"url": "https://example.com/audio.mp3"}}
+      ]
+    }]
+  }'
+```
+
+### 5. 视频文件
+
+```bash
+curl -X POST http://localhost:7860/v1/v1/chat/completions \
+  -H "Content-Type: application/json" \
+  -H "Authorization: Bearer your_api_key" \
+  -d '{
+    "model": "gemini-2.5-pro",
+    "messages": [{
+      "role": "user",
+      "content": [
+        {"type": "text", "text": "描述这个视频的主要场景"},
+        {"type": "image_url", "image_url": {"url": "https://example.com/video.mp4"}}
+      ]
+    }]
+  }'
+```
+
+### 6. 代码文件
+
+```bash
+curl -X POST http://localhost:7860/v1/v1/chat/completions \
+  -H "Content-Type: application/json" \
+  -H "Authorization: Bearer your_api_key" \
+  -d '{
+    "model": "gemini-2.5-pro",
+    "messages": [{
+      "role": "user",
+      "content": [
+        {"type": "text", "text": "审查这段代码并提出改进建议"},
+        {"type": "image_url", "image_url": {"url": "data:text/x-python;base64,ZGVmIGhlbGxvKCk6..."}}
+      ]
+    }]
+  }'
+```
+
+### 7. 混合多种文件
+
+```bash
+curl -X POST http://localhost:7860/v1/v1/chat/completions \
+  -H "Content-Type: application/json" \
+  -H "Authorization: Bearer your_api_key" \
+  -d '{
+    "model": "gemini-2.5-pro",
+    "messages": [{
+      "role": "user",
+      "content": [
+        {"type": "text", "text": "比较这些文件的内容"},
+        {"type": "image_url", "image_url": {"url": "https://example.com/image.jpg"}},
+        {"type": "image_url", "image_url": {"url": "https://example.com/document.pdf"}},
+        {"type": "image_url", "image_url": {"url": "https://example.com/audio.mp3"}}
+      ]
+    }]
+  }'
+```
+
+## ⚠️ 重要说明
+
+1. **实际支持范围**：Google Gemini API 的实际支持范围可能比官方文档更广，建议实际测试
+2. **MIME 类型**：必须正确指定 MIME 类型，否则可能处理失败
+3. **文件大小**：超大文件可能导致超时或处理失败
+4. **处理质量**：不同文件类型的处理质量可能不同
+5. **API 版本**：支持的文件类型可能随 API 版本变化
+6. **字段名称**：虽然支持所有文件类型，但仍使用 `image_url` 字段（OpenAI API 标准）
+
+## 📝 支持状态说明
+
+- ✅ **完全支持**：经过充分测试，稳定可用
+- ✅ **支持**：可以使用，但可能有限制
+- ⚠️ **可能支持**：理论上支持，需要实际测试
+- ⚠️ **部分支持**：有条件支持，可能需要特殊处理
+- ❌ **不支持**：当前不支持或需要转换
+
+## 🔗 相关链接
+
+- [项目主页](https://github.com/Dreamy-rain/gemini-business2api)
+- [API 文档](README.md)
+- [问题反馈](https://github.com/Dreamy-rain/gemini-business2api/issues)

docs/script/download.js

@@ -0,0 +1,110 @@
+    // ==UserScript==
+    // @name         Gemini Business Helper
+    // @version      2.0
+    // @description  自动下载配置
+    // @match        https://business.gemini.google/*
+    // @grant        GM_addStyle
+    // @grant        GM_cookie
+    // ==/UserScript==
+
+    (function() {
+        'use strict';
+
+        GM_addStyle(`
+            #gb-btn {
+                position: fixed;
+                bottom: 32px;
+                right: 32px;
+                width: 60px;
+                height: 60px;
+                background: #1a73e8;
+                border-radius: 50%;
+                box-shadow: 0 4px 16px rgba(0,0,0,0.2);
+                cursor: pointer;
+                z-index: 9999;
+                display: flex;
+                align-items: center;
+                justify-content: center;
+                color: white;
+                font-size: 24px;
+                transition: all 0.2s;
+            }
+            #gb-btn:hover {
+                transform: scale(1.1);
+                background: #1557b0;
+            }
+        `);
+
+        const btn = document.createElement('div');
+        btn.id = 'gb-btn';
+        btn.textContent = '⬇';
+        btn.title = '下载配置';
+        document.body.appendChild(btn);
+
+        const formatTime = (ts) => {
+            if (!ts) return null;
+            const d = new Date((ts - 43200) * 1000);
+            return `${d.getFullYear()}-${String(d.getMonth()+1).padStart(2,'0')}-${String(d.getDate()).padStart(2,'0')} ${String(d.getHours()).padStart(2,'0')}:${String(d.getMinutes()).padStart(2,'0')}:${String(d.getSeconds()).padStart(2,'0')}`;
+        };
+
+        const download = (data, filename) => {
+            const blob = new Blob([data], { type: 'application/json' });
+            const url = URL.createObjectURL(blob);
+            const a = document.createElement('a');
+            a.href = url;
+            a.download = filename;
+            document.body.appendChild(a);
+            a.click();
+            document.body.removeChild(a);
+            URL.revokeObjectURL(url);
+        };
+
+        btn.onclick = () => {
+            const pathParts = window.location.pathname.split('/');
+            const cidIndex = pathParts.indexOf('cid');
+            const config_id = (cidIndex !== -1 && pathParts[cidIndex + 1]) || null;
+            const csesidx = new URLSearchParams(window.location.search).get('csesidx');
+
+            let email = localStorage.getItem('gemini_user_email');
+            if (!email) {
+                email = prompt('请输入您的邮箱地址：');
+                if (email) {
+                    localStorage.setItem('gemini_user_email', email);
+                }
+            }
+
+            GM_cookie('list', {}, (cookies, error) => {
+                if (error || !config_id || !csesidx || !email) {
+                    alert('❌ 数据不完整');
+                    return;
+                }
+
+                const host_c_oses = (cookies.find(c => c.name === '__Host-C_OSES') || {}).value || null;
+                const sesCookie = cookies.find(c => c.name === '__Secure-C_SES') || {};
+                const secure_c_ses = sesCookie.value || null;
+
+                if (!secure_c_ses) {
+                    alert('❌ Cookie 读取失败');
+                    return;
+                }
+
+                const data = {
+                    id: email,
+                    csesidx,
+                    config_id,
+                    secure_c_ses,
+                    host_c_oses,
+                    expires_at: formatTime(sesCookie.expirationDate)
+                };
+
+                download(JSON.stringify(data, null, 2), `${email}.json`);
+
+                btn.textContent = '✓';
+                btn.style.background = '#1e8e3e';
+                setTimeout(() => {
+                    btn.textContent = '⬇';
+                    btn.style.background = '#1a73e8';
+                }, 1500);
+            });
+        };
+    })();

entrypoint.sh

@@ -0,0 +1,14 @@
+#!/bin/bash
+set -e
+
+# 启动 Xvfb 在后台
+Xvfb :99 -screen 0 1280x800x24 -ac &
+
+# 等待 Xvfb 启动
+sleep 1
+
+# 设置 DISPLAY 环境变量
+export DISPLAY=:99
+
+# 启动 Python 应用
+exec python -u main.py

frontend/.gitignore

@@ -0,0 +1,24 @@
+# Logs
+logs
+*.log
+npm-debug.log*
+yarn-debug.log*
+yarn-error.log*
+pnpm-debug.log*
+lerna-debug.log*
+
+node_modules
+dist
+dist-ssr
+*.local
+
+# Editor directories and files
+.vscode/*
+!.vscode/extensions.json
+.idea
+.DS_Store
+*.suo
+*.ntvs*
+*.njsproj
+*.sln
+*.sw?

frontend/README.md

@@ -0,0 +1,71 @@
+# Frontend - Admin Panel
+
+Modern admin panel built with Vue 3 + TypeScript + Tailwind CSS.
+
+## Tech Stack
+
+- Vue 3 + TypeScript
+- Vite
+- Vue Router + Pinia
+- Tailwind CSS
+- Axios
+- ECharts
+
+## Development
+
+```bash
+# Install dependencies
+npm install
+
+# Start dev server
+npm run dev
+```
+
+Visit: http://localhost:5174
+
+## Build
+
+```bash
+# Build for production
+npm run build
+
+# Preview build
+npm run preview
+```
+
+Build output: `dist/`
+
+## Project Structure
+
+```
+src/
+├── api/          # API requests
+├── components/   # UI components
+├── views/        # Page components
+├── stores/       # Pinia stores
+├── router/       # Vue Router
+└── types/        # TypeScript types
+```
+
+## Environment Variables
+
+Create `.env.local`:
+
+```bash
+VITE_API_BASE_URL=http://localhost:7860
+```
+
+## Docker Build
+
+The root `Dockerfile` automatically builds the frontend:
+
+```dockerfile
+FROM node:20-alpine AS frontend-builder
+WORKDIR /frontend
+COPY frontend/package*.json ./
+RUN npm ci
+COPY frontend/ ./
+RUN npm run build
+```
+
+Build artifacts are copied to `static/` directory.

frontend/index.html

@@ -0,0 +1,14 @@
+<!doctype html>
+<html lang="en">
+  <head>
+    <meta charset="UTF-8" />
+    <link rel="icon" type="image/svg+xml" href="/logo.svg" />
+    <meta name="viewport" content="width=device-width, initial-scale=1.0" />
+    <title>Gemini Business2API</title>
+  </head>
+  <body>
+    <div id="app"></div>
+    <script src="/vendor/echarts/echarts.min.js"></script>
+    <script type="module" src="/src/main.ts"></script>
+  </body>
+</html>

frontend/package-lock.json

@@ -0,0 +1,1628 @@
+{
+  "name": "gemini-business2api",
+  "version": "0.0.0",
+  "lockfileVersion": 1,
+  "requires": true,
+  "dependencies": {
+    "@alloc/quick-lru": {
+      "version": "5.2.0",
+      "resolved": "https://registry.npmjs.org/@alloc/quick-lru/-/quick-lru-5.2.0.tgz",
+      "integrity": "sha512-UrcABB+4bUrFABwbluTIBErXwvbsU/V7TZWfmbgJfbkwiBuziS9gxdODUyuiecfdGQ85jglMW6juS3+z5TsKLw==",
+      "dev": true
+    },
+    "@babel/helper-string-parser": {
+      "version": "7.27.1",
+      "resolved": "https://registry.npmjs.org/@babel/helper-string-parser/-/helper-string-parser-7.27.1.tgz",
+      "integrity": "sha512-qMlSxKbpRlAridDExk92nSobyDdpPijUq2DW6oDnUqd0iOGxmQjyqhMIihI9+zv4LPyZdRje2cavWPbCbWm3eA=="
+    },
+    "@babel/helper-validator-identifier": {
+      "version": "7.28.5",
+      "resolved": "https://registry.npmjs.org/@babel/helper-validator-identifier/-/helper-validator-identifier-7.28.5.tgz",
+      "integrity": "sha512-qSs4ifwzKJSV39ucNjsvc6WVHs6b7S03sOh2OcHF9UHfVPqWWALUsNUVzhSBiItjRZoLHx7nIarVjqKVusUZ1Q=="
+    },
+    "@babel/parser": {
+      "version": "7.29.0",
+      "resolved": "https://registry.npmjs.org/@babel/parser/-/parser-7.29.0.tgz",
+      "integrity": "sha512-IyDgFV5GeDUVX4YdF/3CPULtVGSXXMLh1xVIgdCgxApktqnQV0r7/8Nqthg+8YLGaAtdyIlo2qIdZrbCv4+7ww==",
+      "requires": {
+        "@babel/types": "^7.29.0"
+      }
+    },
+    "@babel/types": {
+      "version": "7.29.0",
+      "resolved": "https://registry.npmjs.org/@babel/types/-/types-7.29.0.tgz",
+      "integrity": "sha512-LwdZHpScM4Qz8Xw2iKSzS+cfglZzJGvofQICy7W7v4caru4EaAmyUuO6BGrbyQ2mYV11W0U8j5mBhd14dd3B0A==",
+      "requires": {
+        "@babel/helper-string-parser": "^7.27.1",
+        "@babel/helper-validator-identifier": "^7.28.5"
+      }
+    },
+    "@esbuild/aix-ppc64": {
+      "version": "0.27.3",
+      "resolved": "https://registry.npmjs.org/@esbuild/aix-ppc64/-/aix-ppc64-0.27.3.tgz",
+      "integrity": "sha512-9fJMTNFTWZMh5qwrBItuziu834eOCUcEqymSH7pY+zoMVEZg3gcPuBNxH1EvfVYe9h0x/Ptw8KBzv7qxb7l8dg==",
+      "dev": true,
+      "optional": true
+    },
+    "@esbuild/android-arm": {
+      "version": "0.27.3",
+      "resolved": "https://registry.npmjs.org/@esbuild/android-arm/-/android-arm-0.27.3.tgz",
+      "integrity": "sha512-i5D1hPY7GIQmXlXhs2w8AWHhenb00+GxjxRncS2ZM7YNVGNfaMxgzSGuO8o8SJzRc/oZwU2bcScvVERk03QhzA==",
+      "dev": true,
+      "optional": true
+    },
+    "@esbuild/android-arm64": {
+      "version": "0.27.3",
+      "resolved": "https://registry.npmjs.org/@esbuild/android-arm64/-/android-arm64-0.27.3.tgz",
+      "integrity": "sha512-YdghPYUmj/FX2SYKJ0OZxf+iaKgMsKHVPF1MAq/P8WirnSpCStzKJFjOjzsW0QQ7oIAiccHdcqjbHmJxRb/dmg==",
+      "dev": true,
+      "optional": true
+    },
+    "@esbuild/android-x64": {
+      "version": "0.27.3",
+      "resolved": "https://registry.npmjs.org/@esbuild/android-x64/-/android-x64-0.27.3.tgz",
+      "integrity": "sha512-IN/0BNTkHtk8lkOM8JWAYFg4ORxBkZQf9zXiEOfERX/CzxW3Vg1ewAhU7QSWQpVIzTW+b8Xy+lGzdYXV6UZObQ==",
+      "dev": true,
+      "optional": true
+    },
+    "@esbuild/darwin-arm64": {
+      "version": "0.27.3",
+      "resolved": "https://registry.npmjs.org/@esbuild/darwin-arm64/-/darwin-arm64-0.27.3.tgz",
+      "integrity": "sha512-Re491k7ByTVRy0t3EKWajdLIr0gz2kKKfzafkth4Q8A5n1xTHrkqZgLLjFEHVD+AXdUGgQMq+Godfq45mGpCKg==",
+      "dev": true,
+      "optional": true
+    },
+    "@esbuild/darwin-x64": {
+      "version": "0.27.3",
+      "resolved": "https://registry.npmjs.org/@esbuild/darwin-x64/-/darwin-x64-0.27.3.tgz",
+      "integrity": "sha512-vHk/hA7/1AckjGzRqi6wbo+jaShzRowYip6rt6q7VYEDX4LEy1pZfDpdxCBnGtl+A5zq8iXDcyuxwtv3hNtHFg==",
+      "dev": true,
+      "optional": true
+    },
+    "@esbuild/freebsd-arm64": {
+      "version": "0.27.3",
+      "resolved": "https://registry.npmjs.org/@esbuild/freebsd-arm64/-/freebsd-arm64-0.27.3.tgz",
+      "integrity": "sha512-ipTYM2fjt3kQAYOvo6vcxJx3nBYAzPjgTCk7QEgZG8AUO3ydUhvelmhrbOheMnGOlaSFUoHXB6un+A7q4ygY9w==",
+      "dev": true,
+      "optional": true
+    },
+    "@esbuild/freebsd-x64": {
+      "version": "0.27.3",
+      "resolved": "https://registry.npmjs.org/@esbuild/freebsd-x64/-/freebsd-x64-0.27.3.tgz",
+      "integrity": "sha512-dDk0X87T7mI6U3K9VjWtHOXqwAMJBNN2r7bejDsc+j03SEjtD9HrOl8gVFByeM0aJksoUuUVU9TBaZa2rgj0oA==",
+      "dev": true,
+      "optional": true
+    },
+    "@esbuild/linux-arm": {
+      "version": "0.27.3",
+      "resolved": "https://registry.npmjs.org/@esbuild/linux-arm/-/linux-arm-0.27.3.tgz",
+      "integrity": "sha512-s6nPv2QkSupJwLYyfS+gwdirm0ukyTFNl3KTgZEAiJDd+iHZcbTPPcWCcRYH+WlNbwChgH2QkE9NSlNrMT8Gfw==",
+      "dev": true,
+      "optional": true
+    },
+    "@esbuild/linux-arm64": {
+      "version": "0.27.3",
+      "resolved": "https://registry.npmjs.org/@esbuild/linux-arm64/-/linux-arm64-0.27.3.tgz",
+      "integrity": "sha512-sZOuFz/xWnZ4KH3YfFrKCf1WyPZHakVzTiqji3WDc0BCl2kBwiJLCXpzLzUBLgmp4veFZdvN5ChW4Eq/8Fc2Fg==",
+      "dev": true,
+      "optional": true
+    },
+    "@esbuild/linux-ia32": {
+      "version": "0.27.3",
+      "resolved": "https://registry.npmjs.org/@esbuild/linux-ia32/-/linux-ia32-0.27.3.tgz",
+      "integrity": "sha512-yGlQYjdxtLdh0a3jHjuwOrxQjOZYD/C9PfdbgJJF3TIZWnm/tMd/RcNiLngiu4iwcBAOezdnSLAwQDPqTmtTYg==",
+      "dev": true,
+      "optional": true
+    },
+    "@esbuild/linux-loong64": {
+      "version": "0.27.3",
+      "resolved": "https://registry.npmjs.org/@esbuild/linux-loong64/-/linux-loong64-0.27.3.tgz",
+      "integrity": "sha512-WO60Sn8ly3gtzhyjATDgieJNet/KqsDlX5nRC5Y3oTFcS1l0KWba+SEa9Ja1GfDqSF1z6hif/SkpQJbL63cgOA==",
+      "dev": true,
+      "optional": true
+    },
+    "@esbuild/linux-mips64el": {
+      "version": "0.27.3",
+      "resolved": "https://registry.npmjs.org/@esbuild/linux-mips64el/-/linux-mips64el-0.27.3.tgz",
+      "integrity": "sha512-APsymYA6sGcZ4pD6k+UxbDjOFSvPWyZhjaiPyl/f79xKxwTnrn5QUnXR5prvetuaSMsb4jgeHewIDCIWljrSxw==",
+      "dev": true,
+      "optional": true
+    },
+    "@esbuild/linux-ppc64": {
+      "version": "0.27.3",
+      "resolved": "https://registry.npmjs.org/@esbuild/linux-ppc64/-/linux-ppc64-0.27.3.tgz",
+      "integrity": "sha512-eizBnTeBefojtDb9nSh4vvVQ3V9Qf9Df01PfawPcRzJH4gFSgrObw+LveUyDoKU3kxi5+9RJTCWlj4FjYXVPEA==",
+      "dev": true,
+      "optional": true
+    },
+    "@esbuild/linux-riscv64": {
+      "version": "0.27.3",
+      "resolved": "https://registry.npmjs.org/@esbuild/linux-riscv64/-/linux-riscv64-0.27.3.tgz",
+      "integrity": "sha512-3Emwh0r5wmfm3ssTWRQSyVhbOHvqegUDRd0WhmXKX2mkHJe1SFCMJhagUleMq+Uci34wLSipf8Lagt4LlpRFWQ==",
+      "dev": true,
+      "optional": true
+    },
+    "@esbuild/linux-s390x": {
+      "version": "0.27.3",
+      "resolved": "https://registry.npmjs.org/@esbuild/linux-s390x/-/linux-s390x-0.27.3.tgz",
+      "integrity": "sha512-pBHUx9LzXWBc7MFIEEL0yD/ZVtNgLytvx60gES28GcWMqil8ElCYR4kvbV2BDqsHOvVDRrOxGySBM9Fcv744hw==",
+      "dev": true,
+      "optional": true
+    },
+    "@esbuild/linux-x64": {
+      "version": "0.27.3",
+      "resolved": "https://registry.npmjs.org/@esbuild/linux-x64/-/linux-x64-0.27.3.tgz",
+      "integrity": "sha512-Czi8yzXUWIQYAtL/2y6vogER8pvcsOsk5cpwL4Gk5nJqH5UZiVByIY8Eorm5R13gq+DQKYg0+JyQoytLQas4dA==",
+      "dev": true,
+      "optional": true
+    },
+    "@esbuild/netbsd-arm64": {
+      "version": "0.27.3",
+      "resolved": "https://registry.npmjs.org/@esbuild/netbsd-arm64/-/netbsd-arm64-0.27.3.tgz",
+      "integrity": "sha512-sDpk0RgmTCR/5HguIZa9n9u+HVKf40fbEUt+iTzSnCaGvY9kFP0YKBWZtJaraonFnqef5SlJ8/TiPAxzyS+UoA==",
+      "dev": true,
+      "optional": true
+    },
+    "@esbuild/netbsd-x64": {
+      "version": "0.27.3",
+      "resolved": "https://registry.npmjs.org/@esbuild/netbsd-x64/-/netbsd-x64-0.27.3.tgz",
+      "integrity": "sha512-P14lFKJl/DdaE00LItAukUdZO5iqNH7+PjoBm+fLQjtxfcfFE20Xf5CrLsmZdq5LFFZzb5JMZ9grUwvtVYzjiA==",
+      "dev": true,
+      "optional": true
+    },
+    "@esbuild/openbsd-arm64": {
+      "version": "0.27.3",
+      "resolved": "https://registry.npmjs.org/@esbuild/openbsd-arm64/-/openbsd-arm64-0.27.3.tgz",
+      "integrity": "sha512-AIcMP77AvirGbRl/UZFTq5hjXK+2wC7qFRGoHSDrZ5v5b8DK/GYpXW3CPRL53NkvDqb9D+alBiC/dV0Fb7eJcw==",
+      "dev": true,
+      "optional": true
+    },
+    "@esbuild/openbsd-x64": {
+      "version": "0.27.3",
+      "resolved": "https://registry.npmjs.org/@esbuild/openbsd-x64/-/openbsd-x64-0.27.3.tgz",
+      "integrity": "sha512-DnW2sRrBzA+YnE70LKqnM3P+z8vehfJWHXECbwBmH/CU51z6FiqTQTHFenPlHmo3a8UgpLyH3PT+87OViOh1AQ==",
+      "dev": true,
+      "optional": true
+    },
+    "@esbuild/openharmony-arm64": {
+      "version": "0.27.3",
+      "resolved": "https://registry.npmjs.org/@esbuild/openharmony-arm64/-/openharmony-arm64-0.27.3.tgz",
+      "integrity": "sha512-NinAEgr/etERPTsZJ7aEZQvvg/A6IsZG/LgZy+81wON2huV7SrK3e63dU0XhyZP4RKGyTm7aOgmQk0bGp0fy2g==",
+      "dev": true,
+      "optional": true
+    },
+    "@esbuild/sunos-x64": {
+      "version": "0.27.3",
+      "resolved": "https://registry.npmjs.org/@esbuild/sunos-x64/-/sunos-x64-0.27.3.tgz",
+      "integrity": "sha512-PanZ+nEz+eWoBJ8/f8HKxTTD172SKwdXebZ0ndd953gt1HRBbhMsaNqjTyYLGLPdoWHy4zLU7bDVJztF5f3BHA==",
+      "dev": true,
+      "optional": true
+    },
+    "@esbuild/win32-arm64": {
+      "version": "0.27.3",
+      "resolved": "https://registry.npmjs.org/@esbuild/win32-arm64/-/win32-arm64-0.27.3.tgz",
+      "integrity": "sha512-B2t59lWWYrbRDw/tjiWOuzSsFh1Y/E95ofKz7rIVYSQkUYBjfSgf6oeYPNWHToFRr2zx52JKApIcAS/D5TUBnA==",
+      "dev": true,
+      "optional": true
+    },
+    "@esbuild/win32-ia32": {
+      "version": "0.27.3",
+      "resolved": "https://registry.npmjs.org/@esbuild/win32-ia32/-/win32-ia32-0.27.3.tgz",
+      "integrity": "sha512-QLKSFeXNS8+tHW7tZpMtjlNb7HKau0QDpwm49u0vUp9y1WOF+PEzkU84y9GqYaAVW8aH8f3GcBck26jh54cX4Q==",
+      "dev": true,
+      "optional": true
+    },
+    "@esbuild/win32-x64": {
+      "version": "0.27.3",
+      "resolved": "https://registry.npmjs.org/@esbuild/win32-x64/-/win32-x64-0.27.3.tgz",
+      "integrity": "sha512-4uJGhsxuptu3OcpVAzli+/gWusVGwZZHTlS63hh++ehExkVT8SgiEf7/uC/PclrPPkLhZqGgCTjd0VWLo6xMqA==",
+      "dev": true,
+      "optional": true
+    },
+    "@iconify/types": {
+      "version": "2.0.0",
+      "resolved": "https://registry.npmjs.org/@iconify/types/-/types-2.0.0.tgz",
+      "integrity": "sha512-+wluvCrRhXrhyOmRDJ3q8mux9JkKy5SJ/v8ol2tu4FVjyYvtEzkc/3pK15ET6RKg4b4w4BmTk1+gsCUhf21Ykg==",
+      "dev": true
+    },
+    "@iconify/vue": {
+      "version": "5.0.0",
+      "resolved": "https://registry.npmjs.org/@iconify/vue/-/vue-5.0.0.tgz",
+      "integrity": "sha512-C+KuEWIF5nSBrobFJhT//JS87OZ++QDORB6f2q2Wm6fl2mueSTpFBeBsveK0KW9hWiZ4mNiPjsh6Zs4jjdROSg==",
+      "dev": true,
+      "requires": {
+        "@iconify/types": "^2.0.0"
+      }
+    },
+    "@jridgewell/gen-mapping": {
+      "version": "0.3.13",
+      "resolved": "https://registry.npmjs.org/@jridgewell/gen-mapping/-/gen-mapping-0.3.13.tgz",
+      "integrity": "sha512-2kkt/7niJ6MgEPxF0bYdQ6etZaA+fQvDcLKckhy1yIQOzaoKjBBjSj63/aLVjYE3qhRt5dvM+uUyfCg6UKCBbA==",
+      "dev": true,
+      "requires": {
+        "@jridgewell/sourcemap-codec": "^1.5.0",
+        "@jridgewell/trace-mapping": "^0.3.24"
+      }
+    },
+    "@jridgewell/resolve-uri": {
+      "version": "3.1.2",
+      "resolved": "https://registry.npmjs.org/@jridgewell/resolve-uri/-/resolve-uri-3.1.2.tgz",
+      "integrity": "sha512-bRISgCIjP20/tbWSPWMEi54QVPRZExkuD9lJL+UIxUKtwVJA8wW1Trb1jMs1RFXo1CBTNZ/5hpC9QvmKWdopKw==",
+      "dev": true
+    },
+    "@jridgewell/sourcemap-codec": {
+      "version": "1.5.5",
+      "resolved": "https://registry.npmjs.org/@jridgewell/sourcemap-codec/-/sourcemap-codec-1.5.5.tgz",
+      "integrity": "sha512-cYQ9310grqxueWbl+WuIUIaiUaDcj7WOq5fVhEljNVgRfOUhY9fy2zTvfoqWsnebh8Sl70VScFbICvJnLKB0Og=="
+    },
+    "@jridgewell/trace-mapping": {
+      "version": "0.3.31",
+      "resolved": "https://registry.npmjs.org/@jridgewell/trace-mapping/-/trace-mapping-0.3.31.tgz",
+      "integrity": "sha512-zzNR+SdQSDJzc8joaeP8QQoCQr8NuYx2dIIytl1QeBEZHJ9uW6hebsrYgbz8hJwUQao3TWCMtmfV8Nu1twOLAw==",
+      "dev": true,
+      "requires": {
+        "@jridgewell/resolve-uri": "^3.1.0",
+        "@jridgewell/sourcemap-codec": "^1.4.14"
+      }
+    },
+    "@nodelib/fs.scandir": {
+      "version": "2.1.5",
+      "resolved": "https://registry.npmjs.org/@nodelib/fs.scandir/-/fs.scandir-2.1.5.tgz",
+      "integrity": "sha512-vq24Bq3ym5HEQm2NKCr3yXDwjc7vTsEThRDnkp2DK9p1uqLR+DHurm/NOTo0KG7HYHU7eppKZj3MyqYuMBf62g==",
+      "dev": true,
+      "requires": {
+        "@nodelib/fs.stat": "2.0.5",
+        "run-parallel": "^1.1.9"
+      }
+    },
+    "@nodelib/fs.stat": {
+      "version": "2.0.5",
+      "resolved": "https://registry.npmjs.org/@nodelib/fs.stat/-/fs.stat-2.0.5.tgz",
+      "integrity": "sha512-RkhPPp2zrqDAQA/2jNhnztcPAlv64XdhIp7a7454A5ovI7Bukxgt7MX7udwAu3zg1DcpPU0rz3VV1SeaqvY4+A==",
+      "dev": true
+    },
+    "@nodelib/fs.walk": {
+      "version": "1.2.8",
+      "resolved": "https://registry.npmjs.org/@nodelib/fs.walk/-/fs.walk-1.2.8.tgz",
+      "integrity": "sha512-oGB+UxlgWcgQkgwo8GcEGwemoTFt3FIO9ababBmaGwXIoBKZ+GTy0pP185beGg7Llih/NSHSV2XAs1lnznocSg==",
+      "dev": true,
+      "requires": {
+        "@nodelib/fs.scandir": "2.1.5",
+        "fastq": "^1.6.0"
+      }
+    },
+    "@rolldown/pluginutils": {
+      "version": "1.0.0-rc.2",
+      "resolved": "https://registry.npmjs.org/@rolldown/pluginutils/-/pluginutils-1.0.0-rc.2.tgz",
+      "integrity": "sha512-izyXV/v+cHiRfozX62W9htOAvwMo4/bXKDrQ+vom1L1qRuexPock/7VZDAhnpHCLNejd3NJ6hiab+tO0D44Rgw=="
+    },
+    "@rollup/rollup-android-arm-eabi": {
+      "version": "4.59.0",
+      "resolved": "https://registry.npmjs.org/@rollup/rollup-android-arm-eabi/-/rollup-android-arm-eabi-4.59.0.tgz",
+      "integrity": "sha512-upnNBkA6ZH2VKGcBj9Fyl9IGNPULcjXRlg0LLeaioQWueH30p6IXtJEbKAgvyv+mJaMxSm1l6xwDXYjpEMiLMg==",
+      "dev": true,
+      "optional": true
+    },
+    "@rollup/rollup-android-arm64": {
+      "version": "4.59.0",
+      "resolved": "https://registry.npmjs.org/@rollup/rollup-android-arm64/-/rollup-android-arm64-4.59.0.tgz",
+      "integrity": "sha512-hZ+Zxj3SySm4A/DylsDKZAeVg0mvi++0PYVceVyX7hemkw7OreKdCvW2oQ3T1FMZvCaQXqOTHb8qmBShoqk69Q==",
+      "dev": true,
+      "optional": true
+    },
+    "@rollup/rollup-darwin-arm64": {
+      "version": "4.59.0",
+      "resolved": "https://registry.npmjs.org/@rollup/rollup-darwin-arm64/-/rollup-darwin-arm64-4.59.0.tgz",
+      "integrity": "sha512-W2Psnbh1J8ZJw0xKAd8zdNgF9HRLkdWwwdWqubSVk0pUuQkoHnv7rx4GiF9rT4t5DIZGAsConRE3AxCdJ4m8rg==",
+      "dev": true,
+      "optional": true
+    },
+    "@rollup/rollup-darwin-x64": {
+      "version": "4.59.0",
+      "resolved": "https://registry.npmjs.org/@rollup/rollup-darwin-x64/-/rollup-darwin-x64-4.59.0.tgz",
+      "integrity": "sha512-ZW2KkwlS4lwTv7ZVsYDiARfFCnSGhzYPdiOU4IM2fDbL+QGlyAbjgSFuqNRbSthybLbIJ915UtZBtmuLrQAT/w==",
+      "dev": true,
+      "optional": true
+    },
+    "@rollup/rollup-freebsd-arm64": {
+      "version": "4.59.0",
+      "resolved": "https://registry.npmjs.org/@rollup/rollup-freebsd-arm64/-/rollup-freebsd-arm64-4.59.0.tgz",
+      "integrity": "sha512-EsKaJ5ytAu9jI3lonzn3BgG8iRBjV4LxZexygcQbpiU0wU0ATxhNVEpXKfUa0pS05gTcSDMKpn3Sx+QB9RlTTA==",
+      "dev": true,
+      "optional": true
+    },
+    "@rollup/rollup-freebsd-x64": {
+      "version": "4.59.0",
+      "resolved": "https://registry.npmjs.org/@rollup/rollup-freebsd-x64/-/rollup-freebsd-x64-4.59.0.tgz",
+      "integrity": "sha512-d3DuZi2KzTMjImrxoHIAODUZYoUUMsuUiY4SRRcJy6NJoZ6iIqWnJu9IScV9jXysyGMVuW+KNzZvBLOcpdl3Vg==",
+      "dev": true,
+      "optional": true
+    },
+    "@rollup/rollup-linux-arm-gnueabihf": {
+      "version": "4.59.0",
+      "resolved": "https://registry.npmjs.org/@rollup/rollup-linux-arm-gnueabihf/-/rollup-linux-arm-gnueabihf-4.59.0.tgz",
+      "integrity": "sha512-t4ONHboXi/3E0rT6OZl1pKbl2Vgxf9vJfWgmUoCEVQVxhW6Cw/c8I6hbbu7DAvgp82RKiH7TpLwxnJeKv2pbsw==",
+      "dev": true,
+      "optional": true
+    },
+    "@rollup/rollup-linux-arm-musleabihf": {
+      "version": "4.59.0",
+      "resolved": "https://registry.npmjs.org/@rollup/rollup-linux-arm-musleabihf/-/rollup-linux-arm-musleabihf-4.59.0.tgz",
+      "integrity": "sha512-CikFT7aYPA2ufMD086cVORBYGHffBo4K8MQ4uPS/ZnY54GKj36i196u8U+aDVT2LX4eSMbyHtyOh7D7Zvk2VvA==",
+      "dev": true,
+      "optional": true
+    },
+    "@rollup/rollup-linux-arm64-gnu": {
+      "version": "4.59.0",
+      "resolved": "https://registry.npmjs.org/@rollup/rollup-linux-arm64-gnu/-/rollup-linux-arm64-gnu-4.59.0.tgz",
+      "integrity": "sha512-jYgUGk5aLd1nUb1CtQ8E+t5JhLc9x5WdBKew9ZgAXg7DBk0ZHErLHdXM24rfX+bKrFe+Xp5YuJo54I5HFjGDAA==",
+      "dev": true,
+      "optional": true
+    },
+    "@rollup/rollup-linux-arm64-musl": {
+      "version": "4.59.0",
+      "resolved": "https://registry.npmjs.org/@rollup/rollup-linux-arm64-musl/-/rollup-linux-arm64-musl-4.59.0.tgz",
+      "integrity": "sha512-peZRVEdnFWZ5Bh2KeumKG9ty7aCXzzEsHShOZEFiCQlDEepP1dpUl/SrUNXNg13UmZl+gzVDPsiCwnV1uI0RUA==",
+      "dev": true,
+      "optional": true
+    },
+    "@rollup/rollup-linux-loong64-gnu": {
+      "version": "4.59.0",
+      "resolved": "https://registry.npmjs.org/@rollup/rollup-linux-loong64-gnu/-/rollup-linux-loong64-gnu-4.59.0.tgz",
+      "integrity": "sha512-gbUSW/97f7+r4gHy3Jlup8zDG190AuodsWnNiXErp9mT90iCy9NKKU0Xwx5k8VlRAIV2uU9CsMnEFg/xXaOfXg==",
+      "dev": true,
+      "optional": true
+    },
+    "@rollup/rollup-linux-loong64-musl": {
+      "version": "4.59.0",
+      "resolved": "https://registry.npmjs.org/@rollup/rollup-linux-loong64-musl/-/rollup-linux-loong64-musl-4.59.0.tgz",
+      "integrity": "sha512-yTRONe79E+o0FWFijasoTjtzG9EBedFXJMl888NBEDCDV9I2wGbFFfJQQe63OijbFCUZqxpHz1GzpbtSFikJ4Q==",
+      "dev": true,
+      "optional": true
+    },
+    "@rollup/rollup-linux-ppc64-gnu": {
+      "version": "4.59.0",
+      "resolved": "https://registry.npmjs.org/@rollup/rollup-linux-ppc64-gnu/-/rollup-linux-ppc64-gnu-4.59.0.tgz",
+      "integrity": "sha512-sw1o3tfyk12k3OEpRddF68a1unZ5VCN7zoTNtSn2KndUE+ea3m3ROOKRCZxEpmT9nsGnogpFP9x6mnLTCaoLkA==",
+      "dev": true,
+      "optional": true
+    },
+    "@rollup/rollup-linux-ppc64-musl": {
+      "version": "4.59.0",
+      "resolved": "https://registry.npmjs.org/@rollup/rollup-linux-ppc64-musl/-/rollup-linux-ppc64-musl-4.59.0.tgz",
+      "integrity": "sha512-+2kLtQ4xT3AiIxkzFVFXfsmlZiG5FXYW7ZyIIvGA7Bdeuh9Z0aN4hVyXS/G1E9bTP/vqszNIN/pUKCk/BTHsKA==",
+      "dev": true,
+      "optional": true
+    },
+    "@rollup/rollup-linux-riscv64-gnu": {
+      "version": "4.59.0",
+      "resolved": "https://registry.npmjs.org/@rollup/rollup-linux-riscv64-gnu/-/rollup-linux-riscv64-gnu-4.59.0.tgz",
+      "integrity": "sha512-NDYMpsXYJJaj+I7UdwIuHHNxXZ/b/N2hR15NyH3m2qAtb/hHPA4g4SuuvrdxetTdndfj9b1WOmy73kcPRoERUg==",
+      "dev": true,
+      "optional": true
+    },
+    "@rollup/rollup-linux-riscv64-musl": {
+      "version": "4.59.0",
+      "resolved": "https://registry.npmjs.org/@rollup/rollup-linux-riscv64-musl/-/rollup-linux-riscv64-musl-4.59.0.tgz",
+      "integrity": "sha512-nLckB8WOqHIf1bhymk+oHxvM9D3tyPndZH8i8+35p/1YiVoVswPid2yLzgX7ZJP0KQvnkhM4H6QZ5m0LzbyIAg==",
+      "dev": true,
+      "optional": true
+    },
+    "@rollup/rollup-linux-s390x-gnu": {
+      "version": "4.59.0",
+      "resolved": "https://registry.npmjs.org/@rollup/rollup-linux-s390x-gnu/-/rollup-linux-s390x-gnu-4.59.0.tgz",
+      "integrity": "sha512-oF87Ie3uAIvORFBpwnCvUzdeYUqi2wY6jRFWJAy1qus/udHFYIkplYRW+wo+GRUP4sKzYdmE1Y3+rY5Gc4ZO+w==",
+      "dev": true,
+      "optional": true
+    },
+    "@rollup/rollup-linux-x64-gnu": {
+      "version": "4.59.0",
+      "resolved": "https://registry.npmjs.org/@rollup/rollup-linux-x64-gnu/-/rollup-linux-x64-gnu-4.59.0.tgz",
+      "integrity": "sha512-3AHmtQq/ppNuUspKAlvA8HtLybkDflkMuLK4DPo77DfthRb71V84/c4MlWJXixZz4uruIH4uaa07IqoAkG64fg==",
+      "dev": true,
+      "optional": true
+    },
+    "@rollup/rollup-linux-x64-musl": {
+      "version": "4.59.0",
+      "resolved": "https://registry.npmjs.org/@rollup/rollup-linux-x64-musl/-/rollup-linux-x64-musl-4.59.0.tgz",
+      "integrity": "sha512-2UdiwS/9cTAx7qIUZB/fWtToJwvt0Vbo0zmnYt7ED35KPg13Q0ym1g442THLC7VyI6JfYTP4PiSOWyoMdV2/xg==",
+      "dev": true,
+      "optional": true
+    },
+    "@rollup/rollup-openbsd-x64": {
+      "version": "4.59.0",
+      "resolved": "https://registry.npmjs.org/@rollup/rollup-openbsd-x64/-/rollup-openbsd-x64-4.59.0.tgz",
+      "integrity": "sha512-M3bLRAVk6GOwFlPTIxVBSYKUaqfLrn8l0psKinkCFxl4lQvOSz8ZrKDz2gxcBwHFpci0B6rttydI4IpS4IS/jQ==",
+      "dev": true,
+      "optional": true
+    },
+    "@rollup/rollup-openharmony-arm64": {
+      "version": "4.59.0",
+      "resolved": "https://registry.npmjs.org/@rollup/rollup-openharmony-arm64/-/rollup-openharmony-arm64-4.59.0.tgz",
+      "integrity": "sha512-tt9KBJqaqp5i5HUZzoafHZX8b5Q2Fe7UjYERADll83O4fGqJ49O1FsL6LpdzVFQcpwvnyd0i+K/VSwu/o/nWlA==",
+      "dev": true,
+      "optional": true
+    },
+    "@rollup/rollup-win32-arm64-msvc": {
+      "version": "4.59.0",
+      "resolved": "https://registry.npmjs.org/@rollup/rollup-win32-arm64-msvc/-/rollup-win32-arm64-msvc-4.59.0.tgz",
+      "integrity": "sha512-V5B6mG7OrGTwnxaNUzZTDTjDS7F75PO1ae6MJYdiMu60sq0CqN5CVeVsbhPxalupvTX8gXVSU9gq+Rx1/hvu6A==",
+      "dev": true,
+      "optional": true
+    },
+    "@rollup/rollup-win32-ia32-msvc": {
+      "version": "4.59.0",
+      "resolved": "https://registry.npmjs.org/@rollup/rollup-win32-ia32-msvc/-/rollup-win32-ia32-msvc-4.59.0.tgz",
+      "integrity": "sha512-UKFMHPuM9R0iBegwzKF4y0C4J9u8C6MEJgFuXTBerMk7EJ92GFVFYBfOZaSGLu6COf7FxpQNqhNS4c4icUPqxA==",
+      "dev": true,
+      "optional": true
+    },
+    "@rollup/rollup-win32-x64-gnu": {
+      "version": "4.59.0",
+      "resolved": "https://registry.npmjs.org/@rollup/rollup-win32-x64-gnu/-/rollup-win32-x64-gnu-4.59.0.tgz",
+      "integrity": "sha512-laBkYlSS1n2L8fSo1thDNGrCTQMmxjYY5G0WFWjFFYZkKPjsMBsgJfGf4TLxXrF6RyhI60L8TMOjBMvXiTcxeA==",
+      "dev": true,
+      "optional": true
+    },
+    "@rollup/rollup-win32-x64-msvc": {
+      "version": "4.59.0",
+      "resolved": "https://registry.npmjs.org/@rollup/rollup-win32-x64-msvc/-/rollup-win32-x64-msvc-4.59.0.tgz",
+      "integrity": "sha512-2HRCml6OztYXyJXAvdDXPKcawukWY2GpR5/nxKp4iBgiO3wcoEGkAaqctIbZcNB6KlUQBIqt8VYkNSj2397EfA==",
+      "dev": true,
+      "optional": true
+    },
+    "@types/estree": {
+      "version": "1.0.8",
+      "resolved": "https://registry.npmjs.org/@types/estree/-/estree-1.0.8.tgz",
+      "integrity": "sha512-dWHzHa2WqEXI/O1E9OjrocMTKJl2mSrEolh1Iomrv6U+JuNwaHXsXx9bLu5gG7BUWFIN0skIQJQ/L1rIex4X6w==",
+      "dev": true
+    },
+    "@vitejs/plugin-vue": {
+      "version": "6.0.4",
+      "resolved": "https://registry.npmjs.org/@vitejs/plugin-vue/-/plugin-vue-6.0.4.tgz",
+      "integrity": "sha512-uM5iXipgYIn13UUQCZNdWkYk+sysBeA97d5mHsAoAt1u/wpN3+zxOmsVJWosuzX+IMGRzeYUNytztrYznboIkQ==",
+      "requires": {
+        "@rolldown/pluginutils": "1.0.0-rc.2"
+      }
+    },
+    "@vue/compiler-core": {
+      "version": "3.5.29",
+      "resolved": "https://registry.npmjs.org/@vue/compiler-core/-/compiler-core-3.5.29.tgz",
+      "integrity": "sha512-cuzPhD8fwRHk8IGfmYaR4eEe4cAyJEL66Ove/WZL7yWNL134nqLddSLwNRIsFlnnW1kK+p8Ck3viFnC0chXCXw==",
+      "requires": {
+        "@babel/parser": "^7.29.0",
+        "@vue/shared": "3.5.29",
+        "entities": "^7.0.1",
+        "estree-walker": "^2.0.2",
+        "source-map-js": "^1.2.1"
+      }
+    },
+    "@vue/compiler-dom": {
+      "version": "3.5.29",
+      "resolved": "https://registry.npmjs.org/@vue/compiler-dom/-/compiler-dom-3.5.29.tgz",
+      "integrity": "sha512-n0G5o7R3uBVmVxjTIYcz7ovr8sy7QObFG8OQJ3xGCDNhbG60biP/P5KnyY8NLd81OuT1WJflG7N4KWYHaeeaIg==",
+      "requires": {
+        "@vue/compiler-core": "3.5.29",
+        "@vue/shared": "3.5.29"
+      }
+    },
+    "@vue/compiler-sfc": {
+      "version": "3.5.29",
+      "resolved": "https://registry.npmjs.org/@vue/compiler-sfc/-/compiler-sfc-3.5.29.tgz",
+      "integrity": "sha512-oJZhN5XJs35Gzr50E82jg2cYdZQ78wEwvRO6Y63TvLVTc+6xICzJHP1UIecdSPPYIbkautNBanDiWYa64QSFIA==",
+      "requires": {
+        "@babel/parser": "^7.29.0",
+        "@vue/compiler-core": "3.5.29",
+        "@vue/compiler-dom": "3.5.29",
+        "@vue/compiler-ssr": "3.5.29",
+        "@vue/shared": "3.5.29",
+        "estree-walker": "^2.0.2",
+        "magic-string": "^0.30.21",
+        "postcss": "^8.5.6",
+        "source-map-js": "^1.2.1"
+      }
+    },
+    "@vue/compiler-ssr": {
+      "version": "3.5.29",
+      "resolved": "https://registry.npmjs.org/@vue/compiler-ssr/-/compiler-ssr-3.5.29.tgz",
+      "integrity": "sha512-Y/ARJZE6fpjzL5GH/phJmsFwx3g6t2KmHKHx5q+MLl2kencADKIrhH5MLF6HHpRMmlRAYBRSvv347Mepf1zVNw==",
+      "requires": {
+        "@vue/compiler-dom": "3.5.29",
+        "@vue/shared": "3.5.29"
+      }
+    },
+    "@vue/devtools-api": {
+      "version": "7.7.9",
+      "resolved": "https://registry.npmjs.org/@vue/devtools-api/-/devtools-api-7.7.9.tgz",
+      "integrity": "sha512-kIE8wvwlcZ6TJTbNeU2HQNtaxLx3a84aotTITUuL/4bzfPxzajGBOoqjMhwZJ8L9qFYDU/lAYMEEm11dnZOD6g==",
+      "requires": {
+        "@vue/devtools-kit": "^7.7.9"
+      }
+    },
+    "@vue/devtools-kit": {
+      "version": "7.7.9",
+      "resolved": "https://registry.npmjs.org/@vue/devtools-kit/-/devtools-kit-7.7.9.tgz",
+      "integrity": "sha512-PyQ6odHSgiDVd4hnTP+aDk2X4gl2HmLDfiyEnn3/oV+ckFDuswRs4IbBT7vacMuGdwY/XemxBoh302ctbsptuA==",
+      "requires": {
+        "@vue/devtools-shared": "^7.7.9",
+        "birpc": "^2.3.0",
+        "hookable": "^5.5.3",
+        "mitt": "^3.0.1",
+        "perfect-debounce": "^1.0.0",
+        "speakingurl": "^14.0.1",
+        "superjson": "^2.2.2"
+      }
+    },
+    "@vue/devtools-shared": {
+      "version": "7.7.9",
+      "resolved": "https://registry.npmjs.org/@vue/devtools-shared/-/devtools-shared-7.7.9.tgz",
+      "integrity": "sha512-iWAb0v2WYf0QWmxCGy0seZNDPdO3Sp5+u78ORnyeonS6MT4PC7VPrryX2BpMJrwlDeaZ6BD4vP4XKjK0SZqaeA==",
+      "requires": {
+        "rfdc": "^1.4.1"
+      }
+    },
+    "@vue/reactivity": {
+      "version": "3.5.29",
+      "resolved": "https://registry.npmjs.org/@vue/reactivity/-/reactivity-3.5.29.tgz",
+      "integrity": "sha512-zcrANcrRdcLtmGZETBxWqIkoQei8HaFpZWx/GHKxx79JZsiZ8j1du0VUJtu4eJjgFvU/iKL5lRXFXksVmI+5DA==",
+      "requires": {
+        "@vue/shared": "3.5.29"
+      }
+    },
+    "@vue/runtime-core": {
+      "version": "3.5.29",
+      "resolved": "https://registry.npmjs.org/@vue/runtime-core/-/runtime-core-3.5.29.tgz",
+      "integrity": "sha512-8DpW2QfdwIWOLqtsNcds4s+QgwSaHSJY/SUe04LptianUQ/0xi6KVsu/pYVh+HO3NTVvVJjIPL2t6GdeKbS4Lg==",
+      "requires": {
+        "@vue/reactivity": "3.5.29",
+        "@vue/shared": "3.5.29"
+      }
+    },
+    "@vue/runtime-dom": {
+      "version": "3.5.29",
+      "resolved": "https://registry.npmjs.org/@vue/runtime-dom/-/runtime-dom-3.5.29.tgz",
+      "integrity": "sha512-AHvvJEtcY9tw/uk+s/YRLSlxxQnqnAkjqvK25ZiM4CllCZWzElRAoQnCM42m9AHRLNJ6oe2kC5DCgD4AUdlvXg==",
+      "requires": {
+        "@vue/reactivity": "3.5.29",
+        "@vue/runtime-core": "3.5.29",
+        "@vue/shared": "3.5.29",
+        "csstype": "^3.2.3"
+      }
+    },
+    "@vue/server-renderer": {
+      "version": "3.5.29",
+      "resolved": "https://registry.npmjs.org/@vue/server-renderer/-/server-renderer-3.5.29.tgz",
+      "integrity": "sha512-G/1k6WK5MusLlbxSE2YTcqAAezS+VuwHhOvLx2KnQU7G2zCH6KIb+5Wyt6UjMq7a3qPzNEjJXs1hvAxDclQH+g==",
+      "requires": {
+        "@vue/compiler-ssr": "3.5.29",
+        "@vue/shared": "3.5.29"
+      }
+    },
+    "@vue/shared": {
+      "version": "3.5.29",
+      "resolved": "https://registry.npmjs.org/@vue/shared/-/shared-3.5.29.tgz",
+      "integrity": "sha512-w7SR0A5zyRByL9XUkCfdLs7t9XOHUyJ67qPGQjOou3p6GvBeBW+AVjUUmlxtZ4PIYaRvE+1LmK44O4uajlZwcg=="
+    },
+    "any-promise": {
+      "version": "1.3.0",
+      "resolved": "https://registry.npmjs.org/any-promise/-/any-promise-1.3.0.tgz",
+      "integrity": "sha512-7UvmKalWRt1wgjL1RrGxoSJW/0QZFIegpeGvZG9kjp8vrRu55XTHbwnqq2GpXm9uLbcuhxm3IqX9OB4MZR1b2A==",
+      "dev": true
+    },
+    "anymatch": {
+      "version": "3.1.3",
+      "resolved": "https://registry.npmjs.org/anymatch/-/anymatch-3.1.3.tgz",
+      "integrity": "sha512-KMReFUr0B4t+D+OBkjR3KYqvocp2XaSzO55UcB6mgQMd3KbcE+mWTyvVV7D/zsdEbNnV6acZUutkiHQXvTr1Rw==",
+      "dev": true,
+      "requires": {
+        "normalize-path": "^3.0.0",
+        "picomatch": "^2.0.4"
+      }
+    },
+    "arg": {
+      "version": "5.0.2",
+      "resolved": "https://registry.npmjs.org/arg/-/arg-5.0.2.tgz",
+      "integrity": "sha512-PYjyFOLKQ9y57JvQ6QLo8dAgNqswh8M1RMJYdQduT6xbWSgK36P/Z/v+p888pM69jMMfS8Xd8F6I1kQ/I9HUGg==",
+      "dev": true
+    },
+    "asynckit": {
+      "version": "0.4.0",
+      "resolved": "https://registry.npmjs.org/asynckit/-/asynckit-0.4.0.tgz",
+      "integrity": "sha512-Oei9OH4tRh0YqU3GxhX79dM/mwVgvbZJaSNaRk+bshkj0S5cfHcgYakreBjrHwatXKbz+IoIdYLxrKim2MjW0Q=="
+    },
+    "autoprefixer": {
+      "version": "10.4.27",
+      "resolved": "https://registry.npmjs.org/autoprefixer/-/autoprefixer-10.4.27.tgz",
+      "integrity": "sha512-NP9APE+tO+LuJGn7/9+cohklunJsXWiaWEfV3si4Gi/XHDwVNgkwr1J3RQYFIvPy76GmJ9/bW8vyoU1LcxwKHA==",
+      "dev": true,
+      "requires": {
+        "browserslist": "^4.28.1",
+        "caniuse-lite": "^1.0.30001774",
+        "fraction.js": "^5.3.4",
+        "picocolors": "^1.1.1",
+        "postcss-value-parser": "^4.2.0"
+      }
+    },
+    "axios": {
+      "version": "1.13.6",
+      "resolved": "https://registry.npmjs.org/axios/-/axios-1.13.6.tgz",
+      "integrity": "sha512-ChTCHMouEe2kn713WHbQGcuYrr6fXTBiu460OTwWrWob16g1bXn4vtz07Ope7ewMozJAnEquLk5lWQWtBig9DQ==",
+      "requires": {
+        "follow-redirects": "^1.15.11",
+        "form-data": "^4.0.5",
+        "proxy-from-env": "^1.1.0"
+      }
+    },
+    "baseline-browser-mapping": {
+      "version": "2.10.0",
+      "resolved": "https://registry.npmjs.org/baseline-browser-mapping/-/baseline-browser-mapping-2.10.0.tgz",
+      "integrity": "sha512-lIyg0szRfYbiy67j9KN8IyeD7q7hcmqnJ1ddWmNt19ItGpNN64mnllmxUNFIOdOm6by97jlL6wfpTTJrmnjWAA==",
+      "dev": true
+    },
+    "binary-extensions": {
+      "version": "2.3.0",
+      "resolved": "https://registry.npmjs.org/binary-extensions/-/binary-extensions-2.3.0.tgz",
+      "integrity": "sha512-Ceh+7ox5qe7LJuLHoY0feh3pHuUDHAcRUeyL2VYghZwfpkNIy/+8Ocg0a3UuSoYzavmylwuLWQOf3hl0jjMMIw==",
+      "dev": true
+    },
+    "birpc": {
+      "version": "2.9.0",
+      "resolved": "https://registry.npmjs.org/birpc/-/birpc-2.9.0.tgz",
+      "integrity": "sha512-KrayHS5pBi69Xi9JmvoqrIgYGDkD6mcSe/i6YKi3w5kekCLzrX4+nawcXqrj2tIp50Kw/mT/s3p+GVK0A0sKxw=="
+    },
+    "braces": {
+      "version": "3.0.3",
+      "resolved": "https://registry.npmjs.org/braces/-/braces-3.0.3.tgz",
+      "integrity": "sha512-yQbXgO/OSZVD2IsiLlro+7Hf6Q18EJrKSEsdoMzKePKXct3gvD8oLcOQdIzGupr5Fj+EDe8gO/lxc1BzfMpxvA==",
+      "dev": true,
+      "requires": {
+        "fill-range": "^7.1.1"
+      }
+    },
+    "browserslist": {
+      "version": "4.28.1",
+      "resolved": "https://registry.npmjs.org/browserslist/-/browserslist-4.28.1.tgz",
+      "integrity": "sha512-ZC5Bd0LgJXgwGqUknZY/vkUQ04r8NXnJZ3yYi4vDmSiZmC/pdSN0NbNRPxZpbtO4uAfDUAFffO8IZoM3Gj8IkA==",
+      "dev": true,
+      "requires": {
+        "baseline-browser-mapping": "^2.9.0",
+        "caniuse-lite": "^1.0.30001759",
+        "electron-to-chromium": "^1.5.263",
+        "node-releases": "^2.0.27",
+        "update-browserslist-db": "^1.2.0"
+      }
+    },
+    "call-bind-apply-helpers": {
+      "version": "1.0.2",
+      "resolved": "https://registry.npmjs.org/call-bind-apply-helpers/-/call-bind-apply-helpers-1.0.2.tgz",
+      "integrity": "sha512-Sp1ablJ0ivDkSzjcaJdxEunN5/XvksFJ2sMBFfq6x0ryhQV/2b/KwFe21cMpmHtPOSij8K99/wSfoEuTObmuMQ==",
+      "requires": {
+        "es-errors": "^1.3.0",
+        "function-bind": "^1.1.2"
+      }
+    },
+    "camelcase-css": {
+      "version": "2.0.1",
+      "resolved": "https://registry.npmjs.org/camelcase-css/-/camelcase-css-2.0.1.tgz",
+      "integrity": "sha512-QOSvevhslijgYwRx6Rv7zKdMF8lbRmx+uQGx2+vDc+KI/eBnsy9kit5aj23AgGu3pa4t9AgwbnXWqS+iOY+2aA==",
+      "dev": true
+    },
+    "caniuse-lite": {
+      "version": "1.0.30001774",
+      "resolved": "https://registry.npmjs.org/caniuse-lite/-/caniuse-lite-1.0.30001774.tgz",
+      "integrity": "sha512-DDdwPGz99nmIEv216hKSgLD+D4ikHQHjBC/seF98N9CPqRX4M5mSxT9eTV6oyisnJcuzxtZy4n17yKKQYmYQOA==",
+      "dev": true
+    },
+    "chokidar": {
+      "version": "3.6.0",
+      "resolved": "https://registry.npmjs.org/chokidar/-/chokidar-3.6.0.tgz",
+      "integrity": "sha512-7VT13fmjotKpGipCW9JEQAusEPE+Ei8nl6/g4FBAmIm0GOOLMua9NDDo/DWp0ZAxCr3cPq5ZpBqmPAQgDda2Pw==",
+      "dev": true,
+      "requires": {
+        "anymatch": "~3.1.2",
+        "braces": "~3.0.2",
+        "fsevents": "~2.3.2",
+        "glob-parent": "~5.1.2",
+        "is-binary-path": "~2.1.0",
+        "is-glob": "~4.0.1",
+        "normalize-path": "~3.0.0",
+        "readdirp": "~3.6.0"
+      },
+      "dependencies": {
+        "glob-parent": {
+          "version": "5.1.2",
+          "resolved": "https://registry.npmjs.org/glob-parent/-/glob-parent-5.1.2.tgz",
+          "integrity": "sha512-AOIgSQCepiJYwP3ARnGx+5VnTu2HBYdzbGP45eLw1vr3zB3vZLeyed1sC9hnbcOc9/SrMyM5RPQrkGz4aS9Zow==",
+          "dev": true,
+          "requires": {
+            "is-glob": "^4.0.1"
+          }
+        }
+      }
+    },
+    "class-variance-authority": {
+      "version": "0.7.1",
+      "resolved": "https://registry.npmjs.org/class-variance-authority/-/class-variance-authority-0.7.1.tgz",
+      "integrity": "sha512-Ka+9Trutv7G8M6WT6SeiRWz792K5qEqIGEGzXKhAE6xOWAY6pPH8U+9IY3oCMv6kqTmLsv7Xh/2w2RigkePMsg==",
+      "dev": true,
+      "requires": {
+        "clsx": "^2.1.1"
+      }
+    },
+    "clsx": {
+      "version": "2.1.1",
+      "resolved": "https://registry.npmjs.org/clsx/-/clsx-2.1.1.tgz",
+      "integrity": "sha512-eYm0QWBtUrBWZWG0d386OGAw16Z995PiOVo2B7bjWSbHedGl5e0ZWaq65kOGgUSNesEIDkB9ISbTg/JK9dhCZA==",
+      "dev": true
+    },
+    "combined-stream": {
+      "version": "1.0.8",
+      "resolved": "https://registry.npmjs.org/combined-stream/-/combined-stream-1.0.8.tgz",
+      "integrity": "sha512-FQN4MRfuJeHf7cBbBMJFXhKSDq+2kAArBlmRBvcvFE5BB1HZKXtSFASDhdlz9zOYwxh8lDdnvmMOe/+5cdoEdg==",
+      "requires": {
+        "delayed-stream": "~1.0.0"
+      }
+    },
+    "commander": {
+      "version": "4.1.1",
+      "resolved": "https://registry.npmjs.org/commander/-/commander-4.1.1.tgz",
+      "integrity": "sha512-NOKm8xhkzAjzFx8B2v5OAHT+u5pRQc2UCa2Vq9jYL/31o2wi9mxBA7LIFs3sV5VSC49z6pEhfbMULvShKj26WA==",
+      "dev": true
+    },
+    "copy-anything": {
+      "version": "4.0.5",
+      "resolved": "https://registry.npmjs.org/copy-anything/-/copy-anything-4.0.5.tgz",
+      "integrity": "sha512-7Vv6asjS4gMOuILabD3l739tsaxFQmC+a7pLZm02zyvs8p977bL3zEgq3yDk5rn9B0PbYgIv++jmHcuUab4RhA==",
+      "requires": {
+        "is-what": "^5.2.0"
+      }
+    },
+    "cssesc": {
+      "version": "3.0.0",
+      "resolved": "https://registry.npmjs.org/cssesc/-/cssesc-3.0.0.tgz",
+      "integrity": "sha512-/Tb/JcjK111nNScGob5MNtsntNM1aCNUDipB/TkwZFhyDrrE47SOx/18wF2bbjgc3ZzCSKW1T5nt5EbFoAz/Vg==",
+      "dev": true
+    },
+    "csstype": {
+      "version": "3.2.3",
+      "resolved": "https://registry.npmjs.org/csstype/-/csstype-3.2.3.tgz",
+      "integrity": "sha512-z1HGKcYy2xA8AGQfwrn0PAy+PB7X/GSj3UVJW9qKyn43xWa+gl5nXmU4qqLMRzWVLFC8KusUX8T/0kCiOYpAIQ=="
+    },
+    "delayed-stream": {
+      "version": "1.0.0",
+      "resolved": "https://registry.npmjs.org/delayed-stream/-/delayed-stream-1.0.0.tgz",
+      "integrity": "sha512-ZySD7Nf91aLB0RxL4KGrKHBXl7Eds1DAmEdcoVawXnLD7SDhpNgtuII2aAkg7a7QS41jxPSZ17p4VdGnMHk3MQ=="
+    },
+    "didyoumean": {
+      "version": "1.2.2",
+      "resolved": "https://registry.npmjs.org/didyoumean/-/didyoumean-1.2.2.tgz",
+      "integrity": "sha512-gxtyfqMg7GKyhQmb056K7M3xszy/myH8w+B4RT+QXBQsvAOdc3XymqDDPHx1BgPgsdAA5SIifona89YtRATDzw==",
+      "dev": true
+    },
+    "dlv": {
+      "version": "1.1.3",
+      "resolved": "https://registry.npmjs.org/dlv/-/dlv-1.1.3.tgz",
+      "integrity": "sha512-+HlytyjlPKnIG8XuRG8WvmBP8xs8P71y+SKKS6ZXWoEgLuePxtDoUEiH7WkdePWrQ5JBpE6aoVqfZfJUQkjXwA==",
+      "dev": true
+    },
+    "dunder-proto": {
+      "version": "1.0.1",
+      "resolved": "https://registry.npmjs.org/dunder-proto/-/dunder-proto-1.0.1.tgz",
+      "integrity": "sha512-KIN/nDJBQRcXw0MLVhZE9iQHmG68qAVIBg9CqmUYjmQIhgij9U5MFvrqkUL5FbtyyzZuOeOt0zdeRe4UY7ct+A==",
+      "requires": {
+        "call-bind-apply-helpers": "^1.0.1",
+        "es-errors": "^1.3.0",
+        "gopd": "^1.2.0"
+      }
+    },
+    "electron-to-chromium": {
+      "version": "1.5.302",
+      "resolved": "https://registry.npmjs.org/electron-to-chromium/-/electron-to-chromium-1.5.302.tgz",
+      "integrity": "sha512-sM6HAN2LyK82IyPBpznDRqlTQAtuSaO+ShzFiWTvoMJLHyZ+Y39r8VMfHzwbU8MVBzQ4Wdn85+wlZl2TLGIlwg==",
+      "dev": true
+    },
+    "entities": {
+      "version": "7.0.1",
+      "resolved": "https://registry.npmjs.org/entities/-/entities-7.0.1.tgz",
+      "integrity": "sha512-TWrgLOFUQTH994YUyl1yT4uyavY5nNB5muff+RtWaqNVCAK408b5ZnnbNAUEWLTCpum9w6arT70i1XdQ4UeOPA=="
+    },
+    "es-define-property": {
+      "version": "1.0.1",
+      "resolved": "https://registry.npmjs.org/es-define-property/-/es-define-property-1.0.1.tgz",
+      "integrity": "sha512-e3nRfgfUZ4rNGL232gUgX06QNyyez04KdjFrF+LTRoOXmrOgFKDg4BCdsjW8EnT69eqdYGmRpJwiPVYNrCaW3g=="
+    },
+    "es-errors": {
+      "version": "1.3.0",
+      "resolved": "https://registry.npmjs.org/es-errors/-/es-errors-1.3.0.tgz",
+      "integrity": "sha512-Zf5H2Kxt2xjTvbJvP2ZWLEICxA6j+hAmMzIlypy4xcBg1vKVnx89Wy0GbS+kf5cwCVFFzdCFh2XSCFNULS6csw=="
+    },
+    "es-object-atoms": {
+      "version": "1.1.1",
+      "resolved": "https://registry.npmjs.org/es-object-atoms/-/es-object-atoms-1.1.1.tgz",
+      "integrity": "sha512-FGgH2h8zKNim9ljj7dankFPcICIK9Cp5bm+c2gQSYePhpaG5+esrLODihIorn+Pe6FGJzWhXQotPv73jTaldXA==",
+      "requires": {
+        "es-errors": "^1.3.0"
+      }
+    },
+    "es-set-tostringtag": {
+      "version": "2.1.0",
+      "resolved": "https://registry.npmjs.org/es-set-tostringtag/-/es-set-tostringtag-2.1.0.tgz",
+      "integrity": "sha512-j6vWzfrGVfyXxge+O0x5sh6cvxAog0a/4Rdd2K36zCMV5eJ+/+tOAngRO8cODMNWbVRdVlmGZQL2YS3yR8bIUA==",
+      "requires": {
+        "es-errors": "^1.3.0",
+        "get-intrinsic": "^1.2.6",
+        "has-tostringtag": "^1.0.2",
+        "hasown": "^2.0.2"
+      }
+    },
+    "esbuild": {
+      "version": "0.27.3",
+      "resolved": "https://registry.npmjs.org/esbuild/-/esbuild-0.27.3.tgz",
+      "integrity": "sha512-8VwMnyGCONIs6cWue2IdpHxHnAjzxnw2Zr7MkVxB2vjmQ2ivqGFb4LEG3SMnv0Gb2F/G/2yA8zUaiL1gywDCCg==",
+      "dev": true,
+      "requires": {
+        "@esbuild/aix-ppc64": "0.27.3",
+        "@esbuild/android-arm": "0.27.3",
+        "@esbuild/android-arm64": "0.27.3",
+        "@esbuild/android-x64": "0.27.3",
+        "@esbuild/darwin-arm64": "0.27.3",
+        "@esbuild/darwin-x64": "0.27.3",
+        "@esbuild/freebsd-arm64": "0.27.3",
+        "@esbuild/freebsd-x64": "0.27.3",
+        "@esbuild/linux-arm": "0.27.3",
+        "@esbuild/linux-arm64": "0.27.3",
+        "@esbuild/linux-ia32": "0.27.3",
+        "@esbuild/linux-loong64": "0.27.3",
+        "@esbuild/linux-mips64el": "0.27.3",
+        "@esbuild/linux-ppc64": "0.27.3",
+        "@esbuild/linux-riscv64": "0.27.3",
+        "@esbuild/linux-s390x": "0.27.3",
+        "@esbuild/linux-x64": "0.27.3",
+        "@esbuild/netbsd-arm64": "0.27.3",
+        "@esbuild/netbsd-x64": "0.27.3",
+        "@esbuild/openbsd-arm64": "0.27.3",
+        "@esbuild/openbsd-x64": "0.27.3",
+        "@esbuild/openharmony-arm64": "0.27.3",
+        "@esbuild/sunos-x64": "0.27.3",
+        "@esbuild/win32-arm64": "0.27.3",
+        "@esbuild/win32-ia32": "0.27.3",
+        "@esbuild/win32-x64": "0.27.3"
+      }
+    },
+    "escalade": {
+      "version": "3.2.0",
+      "resolved": "https://registry.npmjs.org/escalade/-/escalade-3.2.0.tgz",
+      "integrity": "sha512-WUj2qlxaQtO4g6Pq5c29GTcWGDyd8itL8zTlipgECz3JesAiiOKotd8JU6otB3PACgG6xkJUyVhboMS+bje/jA==",
+      "dev": true
+    },
+    "estree-walker": {
+      "version": "2.0.2",
+      "resolved": "https://registry.npmjs.org/estree-walker/-/estree-walker-2.0.2.tgz",
+      "integrity": "sha512-Rfkk/Mp/DL7JVje3u18FxFujQlTNR2q6QfMSMB7AvCBx91NGj/ba3kCfza0f6dVDbw7YlRf/nDrn7pQrCCyQ/w=="
+    },
+    "fast-glob": {
+      "version": "3.3.3",
+      "resolved": "https://registry.npmjs.org/fast-glob/-/fast-glob-3.3.3.tgz",
+      "integrity": "sha512-7MptL8U0cqcFdzIzwOTHoilX9x5BrNqye7Z/LuC7kCMRio1EMSyqRK3BEAUD7sXRq4iT4AzTVuZdhgQ2TCvYLg==",
+      "dev": true,
+      "requires": {
+        "@nodelib/fs.stat": "^2.0.2",
+        "@nodelib/fs.walk": "^1.2.3",
+        "glob-parent": "^5.1.2",
+        "merge2": "^1.3.0",
+        "micromatch": "^4.0.8"
+      },
+      "dependencies": {
+        "glob-parent": {
+          "version": "5.1.2",
+          "resolved": "https://registry.npmjs.org/glob-parent/-/glob-parent-5.1.2.tgz",
+          "integrity": "sha512-AOIgSQCepiJYwP3ARnGx+5VnTu2HBYdzbGP45eLw1vr3zB3vZLeyed1sC9hnbcOc9/SrMyM5RPQrkGz4aS9Zow==",
+          "dev": true,
+          "requires": {
+            "is-glob": "^4.0.1"
+          }
+        }
+      }
+    },
+    "fastq": {
+      "version": "1.20.1",
+      "resolved": "https://registry.npmjs.org/fastq/-/fastq-1.20.1.tgz",
+      "integrity": "sha512-GGToxJ/w1x32s/D2EKND7kTil4n8OVk/9mycTc4VDza13lOvpUZTGX3mFSCtV9ksdGBVzvsyAVLM6mHFThxXxw==",
+      "dev": true,
+      "requires": {
+        "reusify": "^1.0.4"
+      }
+    },
+    "fdir": {
+      "version": "6.5.0",
+      "resolved": "https://registry.npmjs.org/fdir/-/fdir-6.5.0.tgz",
+      "integrity": "sha512-tIbYtZbucOs0BRGqPJkshJUYdL+SDH7dVM8gjy+ERp3WAUjLEFJE+02kanyHtwjWOnwrKYBiwAmM0p4kLJAnXg==",
+      "dev": true
+    },
+    "fill-range": {
+      "version": "7.1.1",
+      "resolved": "https://registry.npmjs.org/fill-range/-/fill-range-7.1.1.tgz",
+      "integrity": "sha512-YsGpe3WHLK8ZYi4tWDg2Jy3ebRz2rXowDxnld4bkQB00cc/1Zw9AWnC0i9ztDJitivtQvaI9KaLyKrc+hBW0yg==",
+      "dev": true,
+      "requires": {
+        "to-regex-range": "^5.0.1"
+      }
+    },
+    "follow-redirects": {
+      "version": "1.15.11",
+      "resolved": "https://registry.npmjs.org/follow-redirects/-/follow-redirects-1.15.11.tgz",
+      "integrity": "sha512-deG2P0JfjrTxl50XGCDyfI97ZGVCxIpfKYmfyrQ54n5FO/0gfIES8C/Psl6kWVDolizcaaxZJnTS0QSMxvnsBQ=="
+    },
+    "form-data": {
+      "version": "4.0.5",
+      "resolved": "https://registry.npmjs.org/form-data/-/form-data-4.0.5.tgz",
+      "integrity": "sha512-8RipRLol37bNs2bhoV67fiTEvdTrbMUYcFTiy3+wuuOnUog2QBHCZWXDRijWQfAkhBj2Uf5UnVaiWwA5vdd82w==",
+      "requires": {
+        "asynckit": "^0.4.0",
+        "combined-stream": "^1.0.8",
+        "es-set-tostringtag": "^2.1.0",
+        "hasown": "^2.0.2",
+        "mime-types": "^2.1.12"
+      }
+    },
+    "fraction.js": {
+      "version": "5.3.4",
+      "resolved": "https://registry.npmjs.org/fraction.js/-/fraction.js-5.3.4.tgz",
+      "integrity": "sha512-1X1NTtiJphryn/uLQz3whtY6jK3fTqoE3ohKs0tT+Ujr1W59oopxmoEh7Lu5p6vBaPbgoM0bzveAW4Qi5RyWDQ==",
+      "dev": true
+    },
+    "fsevents": {
+      "version": "2.3.3",
+      "resolved": "https://registry.npmjs.org/fsevents/-/fsevents-2.3.3.tgz",
+      "integrity": "sha512-5xoDfX+fL7faATnagmWPpbFtwh/R77WmMMqqHGS65C3vvB0YHrgF+B1YmZ3441tMj5n63k0212XNoJwzlhffQw==",
+      "dev": true,
+      "optional": true
+    },
+    "function-bind": {
+      "version": "1.1.2",
+      "resolved": "https://registry.npmjs.org/function-bind/-/function-bind-1.1.2.tgz",
+      "integrity": "sha512-7XHNxH7qX9xG5mIwxkhumTox/MIRNcOgDrxWsMt2pAr23WHp6MrRlN7FBSFpCpr+oVO0F744iUgR82nJMfG2SA=="
+    },
+    "get-intrinsic": {
+      "version": "1.3.0",
+      "resolved": "https://registry.npmjs.org/get-intrinsic/-/get-intrinsic-1.3.0.tgz",
+      "integrity": "sha512-9fSjSaos/fRIVIp+xSJlE6lfwhES7LNtKaCBIamHsjr2na1BiABJPo0mOjjz8GJDURarmCPGqaiVg5mfjb98CQ==",
+      "requires": {
+        "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": {
+      "version": "1.0.1",
+      "resolved": "https://registry.npmjs.org/get-proto/-/get-proto-1.0.1.tgz",
+      "integrity": "sha512-sTSfBjoXBp89JvIKIefqw7U2CCebsc74kiY6awiGogKtoSGbgjYE/G/+l9sF3MWFPNc9IcoOC4ODfKHfxFmp0g==",
+      "requires": {
+        "dunder-proto": "^1.0.1",
+        "es-object-atoms": "^1.0.0"
+      }
+    },
+    "glob-parent": {
+      "version": "6.0.2",
+      "resolved": "https://registry.npmjs.org/glob-parent/-/glob-parent-6.0.2.tgz",
+      "integrity": "sha512-XxwI8EOhVQgWp6iDL+3b0r86f4d6AX6zSU55HfB4ydCEuXLXc5FcYeOu+nnGftS4TEju/11rt4KJPTMgbfmv4A==",
+      "dev": true,
+      "requires": {
+        "is-glob": "^4.0.3"
+      }
+    },
+    "gopd": {
+      "version": "1.2.0",
+      "resolved": "https://registry.npmjs.org/gopd/-/gopd-1.2.0.tgz",
+      "integrity": "sha512-ZUKRh6/kUFoAiTAtTYPZJ3hw9wNxx+BIBOijnlG9PnrJsCcSjs1wyyD6vJpaYtgnzDrKYRSqf3OO6Rfa93xsRg=="
+    },
+    "has-symbols": {
+      "version": "1.1.0",
+      "resolved": "https://registry.npmjs.org/has-symbols/-/has-symbols-1.1.0.tgz",
+      "integrity": "sha512-1cDNdwJ2Jaohmb3sg4OmKaMBwuC48sYni5HUw2DvsC8LjGTLK9h+eb1X6RyuOHe4hT0ULCW68iomhjUoKUqlPQ=="
+    },
+    "has-tostringtag": {
+      "version": "1.0.2",
+      "resolved": "https://registry.npmjs.org/has-tostringtag/-/has-tostringtag-1.0.2.tgz",
+      "integrity": "sha512-NqADB8VjPFLM2V0VvHUewwwsw0ZWBaIdgo+ieHtK3hasLz4qeCRjYcqfB6AQrBggRKppKF8L52/VqdVsO47Dlw==",
+      "requires": {
+        "has-symbols": "^1.0.3"
+      }
+    },
+    "hasown": {
+      "version": "2.0.2",
+      "resolved": "https://registry.npmjs.org/hasown/-/hasown-2.0.2.tgz",
+      "integrity": "sha512-0hJU9SCPvmMzIBdZFqNPXWa6dqh7WdH0cII9y+CyS8rG3nL48Bclra9HmKhVVUHyPWNH5Y7xDwAB7bfgSjkUMQ==",
+      "requires": {
+        "function-bind": "^1.1.2"
+      }
+    },
+    "hookable": {
+      "version": "5.5.3",
+      "resolved": "https://registry.npmjs.org/hookable/-/hookable-5.5.3.tgz",
+      "integrity": "sha512-Yc+BQe8SvoXH1643Qez1zqLRmbA5rCL+sSmk6TVos0LWVfNIB7PGncdlId77WzLGSIB5KaWgTaNTs2lNVEI6VQ=="
+    },
+    "is-binary-path": {
+      "version": "2.1.0",
+      "resolved": "https://registry.npmjs.org/is-binary-path/-/is-binary-path-2.1.0.tgz",
+      "integrity": "sha512-ZMERYes6pDydyuGidse7OsHxtbI7WVeUEozgR/g7rd0xUimYNlvZRE/K2MgZTjWy725IfelLeVcEM97mmtRGXw==",
+      "dev": true,
+      "requires": {
+        "binary-extensions": "^2.0.0"
+      }
+    },
+    "is-core-module": {
+      "version": "2.16.1",
+      "resolved": "https://registry.npmjs.org/is-core-module/-/is-core-module-2.16.1.tgz",
+      "integrity": "sha512-UfoeMA6fIJ8wTYFEUjelnaGI67v6+N7qXJEvQuIGa99l4xsCruSYOVSQ0uPANn4dAzm8lkYPaKLrrijLq7x23w==",
+      "dev": true,
+      "requires": {
+        "hasown": "^2.0.2"
+      }
+    },
+    "is-extglob": {
+      "version": "2.1.1",
+      "resolved": "https://registry.npmjs.org/is-extglob/-/is-extglob-2.1.1.tgz",
+      "integrity": "sha512-SbKbANkN603Vi4jEZv49LeVJMn4yGwsbzZworEoyEiutsN3nJYdbO36zfhGJ6QEDpOZIFkDtnq5JRxmvl3jsoQ==",
+      "dev": true
+    },
+    "is-glob": {
+      "version": "4.0.3",
+      "resolved": "https://registry.npmjs.org/is-glob/-/is-glob-4.0.3.tgz",
+      "integrity": "sha512-xelSayHH36ZgE7ZWhli7pW34hNbNl8Ojv5KVmkJD4hBdD3th8Tfk9vYasLM+mXWOZhFkgZfxhLSnrwRr4elSSg==",
+      "dev": true,
+      "requires": {
+        "is-extglob": "^2.1.1"
+      }
+    },
+    "is-number": {
+      "version": "7.0.0",
+      "resolved": "https://registry.npmjs.org/is-number/-/is-number-7.0.0.tgz",
+      "integrity": "sha512-41Cifkg6e8TylSpdtTpeLVMqvSBEVzTttHvERD741+pnZ8ANv0004MRL43QKPDlK9cGvNp6NZWZUBlbGXYxxng==",
+      "dev": true
+    },
+    "is-what": {
+      "version": "5.5.0",
+      "resolved": "https://registry.npmjs.org/is-what/-/is-what-5.5.0.tgz",
+      "integrity": "sha512-oG7cgbmg5kLYae2N5IVd3jm2s+vldjxJzK1pcu9LfpGuQ93MQSzo0okvRna+7y5ifrD+20FE8FvjusyGaz14fw=="
+    },
+    "jiti": {
+      "version": "1.21.7",
+      "resolved": "https://registry.npmjs.org/jiti/-/jiti-1.21.7.tgz",
+      "integrity": "sha512-/imKNG4EbWNrVjoNC/1H5/9GFy+tqjGBHCaSsN+P2RnPqjsLmv6UD3Ej+Kj8nBWaRAwyk7kK5ZUc+OEatnTR3A==",
+      "dev": true
+    },
+    "lilconfig": {
+      "version": "3.1.3",
+      "resolved": "https://registry.npmjs.org/lilconfig/-/lilconfig-3.1.3.tgz",
+      "integrity": "sha512-/vlFKAoH5Cgt3Ie+JLhRbwOsCQePABiU3tJ1egGvyQ+33R/vcwM2Zl2QR/LzjsBeItPt3oSVXapn+m4nQDvpzw==",
+      "dev": true
+    },
+    "lines-and-columns": {
+      "version": "1.2.4",
+      "resolved": "https://registry.npmjs.org/lines-and-columns/-/lines-and-columns-1.2.4.tgz",
+      "integrity": "sha512-7ylylesZQ/PV29jhEDl3Ufjo6ZX7gCqJr5F7PKrqc93v7fzSymt1BpwEU8nAUXs8qzzvqhbjhK5QZg6Mt/HkBg==",
+      "dev": true
+    },
+    "magic-string": {
+      "version": "0.30.21",
+      "resolved": "https://registry.npmjs.org/magic-string/-/magic-string-0.30.21.tgz",
+      "integrity": "sha512-vd2F4YUyEXKGcLHoq+TEyCjxueSeHnFxyyjNp80yg0XV4vUhnDer/lvvlqM/arB5bXQN5K2/3oinyCRyx8T2CQ==",
+      "requires": {
+        "@jridgewell/sourcemap-codec": "^1.5.5"
+      }
+    },
+    "math-intrinsics": {
+      "version": "1.1.0",
+      "resolved": "https://registry.npmjs.org/math-intrinsics/-/math-intrinsics-1.1.0.tgz",
+      "integrity": "sha512-/IXtbwEk5HTPyEwyKX6hGkYXxM9nbj64B+ilVJnC/R6B0pH5G4V3b0pVbL7DBj4tkhBAppbQUlf6F6Xl9LHu1g=="
+    },
+    "merge2": {
+      "version": "1.4.1",
+      "resolved": "https://registry.npmjs.org/merge2/-/merge2-1.4.1.tgz",
+      "integrity": "sha512-8q7VEgMJW4J8tcfVPy8g09NcQwZdbwFEqhe/WZkoIzjn/3TGDwtOCYtXGxA3O8tPzpczCCDgv+P2P5y00ZJOOg==",
+      "dev": true
+    },
+    "micromatch": {
+      "version": "4.0.8",
+      "resolved": "https://registry.npmjs.org/micromatch/-/micromatch-4.0.8.tgz",
+      "integrity": "sha512-PXwfBhYu0hBCPw8Dn0E+WDYb7af3dSLVWKi3HGv84IdF4TyFoC0ysxFd0Goxw7nSv4T/PzEJQxsYsEiFCKo2BA==",
+      "dev": true,
+      "requires": {
+        "braces": "^3.0.3",
+        "picomatch": "^2.3.1"
+      }
+    },
+    "mime-db": {
+      "version": "1.52.0",
+      "resolved": "https://registry.npmjs.org/mime-db/-/mime-db-1.52.0.tgz",
+      "integrity": "sha512-sPU4uV7dYlvtWJxwwxHD0PuihVNiE7TyAbQ5SWxDCB9mUYvOgroQOwYQQOKPJ8CIbE+1ETVlOoK1UC2nU3gYvg=="
+    },
+    "mime-types": {
+      "version": "2.1.35",
+      "resolved": "https://registry.npmjs.org/mime-types/-/mime-types-2.1.35.tgz",
+      "integrity": "sha512-ZDY+bPm5zTTF+YpCrAU9nK0UgICYPT0QtT1NZWFv4s++TNkcgVaT0g6+4R2uI4MjQjzysHB1zxuWL50hzaeXiw==",
+      "requires": {
+        "mime-db": "1.52.0"
+      }
+    },
+    "mitt": {
+      "version": "3.0.1",
+      "resolved": "https://registry.npmjs.org/mitt/-/mitt-3.0.1.tgz",
+      "integrity": "sha512-vKivATfr97l2/QBCYAkXYDbrIWPM2IIKEl7YPhjCvKlG3kE2gm+uBo6nEXK3M5/Ffh/FLpKExzOQ3JJoJGFKBw=="
+    },
+    "mz": {
+      "version": "2.7.0",
+      "resolved": "https://registry.npmjs.org/mz/-/mz-2.7.0.tgz",
+      "integrity": "sha512-z81GNO7nnYMEhrGh9LeymoE4+Yr0Wn5McHIZMK5cfQCl+NDX08sCZgUc9/6MHni9IWuFLm1Z3HTCXu2z9fN62Q==",
+      "dev": true,
+      "requires": {
+        "any-promise": "^1.0.0",
+        "object-assign": "^4.0.1",
+        "thenify-all": "^1.0.0"
+      }
+    },
+    "nanoid": {
+      "version": "3.3.11",
+      "resolved": "https://registry.npmjs.org/nanoid/-/nanoid-3.3.11.tgz",
+      "integrity": "sha512-N8SpfPUnUp1bK+PMYW8qSWdl9U+wwNWI4QKxOYDy9JAro3WMX7p2OeVRF9v+347pnakNevPmiHhNmZ2HbFA76w=="
+    },
+    "node-releases": {
+      "version": "2.0.27",
+      "resolved": "https://registry.npmjs.org/node-releases/-/node-releases-2.0.27.tgz",
+      "integrity": "sha512-nmh3lCkYZ3grZvqcCH+fjmQ7X+H0OeZgP40OierEaAptX4XofMh5kwNbWh7lBduUzCcV/8kZ+NDLCwm2iorIlA==",
+      "dev": true
+    },
+    "normalize-path": {
+      "version": "3.0.0",
+      "resolved": "https://registry.npmjs.org/normalize-path/-/normalize-path-3.0.0.tgz",
+      "integrity": "sha512-6eZs5Ls3WtCisHWp9S2GUy8dqkpGi4BVSz3GaqiE6ezub0512ESztXUwUB6C6IKbQkY2Pnb/mD4WYojCRwcwLA==",
+      "dev": true
+    },
+    "object-assign": {
+      "version": "4.1.1",
+      "resolved": "https://registry.npmjs.org/object-assign/-/object-assign-4.1.1.tgz",
+      "integrity": "sha512-rJgTQnkUnH1sFw8yT6VSU3zD3sWmu6sZhIseY8VX+GRu3P6F7Fu+JNDoXfklElbLJSnc3FUQHVe4cU5hj+BcUg==",
+      "dev": true
+    },
+    "object-hash": {
+      "version": "3.0.0",
+      "resolved": "https://registry.npmjs.org/object-hash/-/object-hash-3.0.0.tgz",
+      "integrity": "sha512-RSn9F68PjH9HqtltsSnqYC1XXoWe9Bju5+213R98cNGttag9q9yAOTzdbsqvIa7aNm5WffBZFpWYr2aWrklWAw==",
+      "dev": true
+    },
+    "path-parse": {
+      "version": "1.0.7",
+      "resolved": "https://registry.npmjs.org/path-parse/-/path-parse-1.0.7.tgz",
+      "integrity": "sha512-LDJzPVEEEPR+y48z93A0Ed0yXb8pAByGWo/k5YYdYgpY2/2EsOsksJrq7lOHxryrVOn1ejG6oAp8ahvOIQD8sw==",
+      "dev": true
+    },
+    "perfect-debounce": {
+      "version": "1.0.0",
+      "resolved": "https://registry.npmjs.org/perfect-debounce/-/perfect-debounce-1.0.0.tgz",
+      "integrity": "sha512-xCy9V055GLEqoFaHoC1SoLIaLmWctgCUaBaWxDZ7/Zx4CTyX7cJQLJOok/orfjZAh9kEYpjJa4d0KcJmCbctZA=="
+    },
+    "picocolors": {
+      "version": "1.1.1",
+      "resolved": "https://registry.npmjs.org/picocolors/-/picocolors-1.1.1.tgz",
+      "integrity": "sha512-xceH2snhtb5M9liqDsmEw56le376mTZkEX/jEb/RxNFyegNul7eNslCXP9FDj/Lcu0X8KEyMceP2ntpaHrDEVA=="
+    },
+    "picomatch": {
+      "version": "2.3.1",
+      "resolved": "https://registry.npmjs.org/picomatch/-/picomatch-2.3.1.tgz",
+      "integrity": "sha512-JU3teHTNjmE2VCGFzuY8EXzCDVwEqB2a8fsIvwaStHhAWJEeVd1o1QD80CU6+ZdEXXSLbSsuLwJjkCBWqRQUVA==",
+      "dev": true
+    },
+    "pify": {
+      "version": "2.3.0",
+      "resolved": "https://registry.npmjs.org/pify/-/pify-2.3.0.tgz",
+      "integrity": "sha512-udgsAY+fTnvv7kI7aaxbqwWNb0AHiB0qBO89PZKPkoTmGOgdbrHDKD+0B2X4uTfJ/FT1R09r9gTsjUjNJotuog==",
+      "dev": true
+    },
+    "pinia": {
+      "version": "3.0.4",
+      "resolved": "https://registry.npmjs.org/pinia/-/pinia-3.0.4.tgz",
+      "integrity": "sha512-l7pqLUFTI/+ESXn6k3nu30ZIzW5E2WZF/LaHJEpoq6ElcLD+wduZoB2kBN19du6K/4FDpPMazY2wJr+IndBtQw==",
+      "requires": {
+        "@vue/devtools-api": "^7.7.7"
+      }
+    },
+    "pirates": {
+      "version": "4.0.7",
+      "resolved": "https://registry.npmjs.org/pirates/-/pirates-4.0.7.tgz",
+      "integrity": "sha512-TfySrs/5nm8fQJDcBDuUng3VOUKsd7S+zqvbOTiGXHfxX4wK31ard+hoNuvkicM/2YFzlpDgABOevKSsB4G/FA==",
+      "dev": true
+    },
+    "postcss": {
+      "version": "8.5.6",
+      "resolved": "https://registry.npmjs.org/postcss/-/postcss-8.5.6.tgz",
+      "integrity": "sha512-3Ybi1tAuwAP9s0r1UQ2J4n5Y0G05bJkpUIO0/bI9MhwmD70S5aTWbXGBwxHrelT+XM1k6dM0pk+SwNkpTRN7Pg==",
+      "requires": {
+        "nanoid": "^3.3.11",
+        "picocolors": "^1.1.1",
+        "source-map-js": "^1.2.1"
+      }
+    },
+    "postcss-import": {
+      "version": "15.1.0",
+      "resolved": "https://registry.npmjs.org/postcss-import/-/postcss-import-15.1.0.tgz",
+      "integrity": "sha512-hpr+J05B2FVYUAXHeK1YyI267J/dDDhMU6B6civm8hSY1jYJnBXxzKDKDswzJmtLHryrjhnDjqqp/49t8FALew==",
+      "dev": true,
+      "requires": {
+        "postcss-value-parser": "^4.0.0",
+        "read-cache": "^1.0.0",
+        "resolve": "^1.1.7"
+      }
+    },
+    "postcss-js": {
+      "version": "4.1.0",
+      "resolved": "https://registry.npmjs.org/postcss-js/-/postcss-js-4.1.0.tgz",
+      "integrity": "sha512-oIAOTqgIo7q2EOwbhb8UalYePMvYoIeRY2YKntdpFQXNosSu3vLrniGgmH9OKs/qAkfoj5oB3le/7mINW1LCfw==",
+      "dev": true,
+      "requires": {
+        "camelcase-css": "^2.0.1"
+      }
+    },
+    "postcss-load-config": {
+      "version": "6.0.1",
+      "resolved": "https://registry.npmjs.org/postcss-load-config/-/postcss-load-config-6.0.1.tgz",
+      "integrity": "sha512-oPtTM4oerL+UXmx+93ytZVN82RrlY/wPUV8IeDxFrzIjXOLF1pN+EmKPLbubvKHT2HC20xXsCAH2Z+CKV6Oz/g==",
+      "dev": true,
+      "requires": {
+        "lilconfig": "^3.1.1"
+      }
+    },
+    "postcss-nested": {
+      "version": "6.2.0",
+      "resolved": "https://registry.npmjs.org/postcss-nested/-/postcss-nested-6.2.0.tgz",
+      "integrity": "sha512-HQbt28KulC5AJzG+cZtj9kvKB93CFCdLvog1WFLf1D+xmMvPGlBstkpTEZfK5+AN9hfJocyBFCNiqyS48bpgzQ==",
+      "dev": true,
+      "requires": {
+        "postcss-selector-parser": "^6.1.1"
+      }
+    },
+    "postcss-selector-parser": {
+      "version": "6.1.2",
+      "resolved": "https://registry.npmjs.org/postcss-selector-parser/-/postcss-selector-parser-6.1.2.tgz",
+      "integrity": "sha512-Q8qQfPiZ+THO/3ZrOrO0cJJKfpYCagtMUkXbnEfmgUjwXg6z/WBeOyS9APBBPCTSiDV+s4SwQGu8yFsiMRIudg==",
+      "dev": true,
+      "requires": {
+        "cssesc": "^3.0.0",
+        "util-deprecate": "^1.0.2"
+      }
+    },
+    "postcss-value-parser": {
+      "version": "4.2.0",
+      "resolved": "https://registry.npmjs.org/postcss-value-parser/-/postcss-value-parser-4.2.0.tgz",
+      "integrity": "sha512-1NNCs6uurfkVbeXG4S8JFT9t19m45ICnif8zWLd5oPSZ50QnwMfK+H3jv408d4jw/7Bttv5axS5IiHoLaVNHeQ==",
+      "dev": true
+    },
+    "proxy-from-env": {
+      "version": "1.1.0",
+      "resolved": "https://registry.npmjs.org/proxy-from-env/-/proxy-from-env-1.1.0.tgz",
+      "integrity": "sha512-D+zkORCbA9f1tdWRK0RaCR3GPv50cMxcrz4X8k5LTSUD1Dkw47mKJEZQNunItRTkWwgtaUSo1RVFRIG9ZXiFYg=="
+    },
+    "queue-microtask": {
+      "version": "1.2.3",
+      "resolved": "https://registry.npmjs.org/queue-microtask/-/queue-microtask-1.2.3.tgz",
+      "integrity": "sha512-NuaNSa6flKT5JaSYQzJok04JzTL1CA6aGhv5rfLW3PgqA+M2ChpZQnAC8h8i4ZFkBS8X5RqkDBHA7r4hej3K9A==",
+      "dev": true
+    },
+    "read-cache": {
+      "version": "1.0.0",
+      "resolved": "https://registry.npmjs.org/read-cache/-/read-cache-1.0.0.tgz",
+      "integrity": "sha512-Owdv/Ft7IjOgm/i0xvNDZ1LrRANRfew4b2prF3OWMQLxLfu3bS8FVhCsrSCMK4lR56Y9ya+AThoTpDCTxCmpRA==",
+      "dev": true,
+      "requires": {
+        "pify": "^2.3.0"
+      }
+    },
+    "readdirp": {
+      "version": "3.6.0",
+      "resolved": "https://registry.npmjs.org/readdirp/-/readdirp-3.6.0.tgz",
+      "integrity": "sha512-hOS089on8RduqdbhvQ5Z37A0ESjsqz6qnRcffsMU3495FuTdqSm+7bhJ29JvIOsBDEEnan5DPu9t3To9VRlMzA==",
+      "dev": true,
+      "requires": {
+        "picomatch": "^2.2.1"
+      }
+    },
+    "resolve": {
+      "version": "1.22.11",
+      "resolved": "https://registry.npmjs.org/resolve/-/resolve-1.22.11.tgz",
+      "integrity": "sha512-RfqAvLnMl313r7c9oclB1HhUEAezcpLjz95wFH4LVuhk9JF/r22qmVP9AMmOU4vMX7Q8pN8jwNg/CSpdFnMjTQ==",
+      "dev": true,
+      "requires": {
+        "is-core-module": "^2.16.1",
+        "path-parse": "^1.0.7",
+        "supports-preserve-symlinks-flag": "^1.0.0"
+      }
+    },
+    "reusify": {
+      "version": "1.1.0",
+      "resolved": "https://registry.npmjs.org/reusify/-/reusify-1.1.0.tgz",
+      "integrity": "sha512-g6QUff04oZpHs0eG5p83rFLhHeV00ug/Yf9nZM6fLeUrPguBTkTQOdpAWWspMh55TZfVQDPaN3NQJfbVRAxdIw==",
+      "dev": true
+    },
+    "rfdc": {
+      "version": "1.4.1",
+      "resolved": "https://registry.npmjs.org/rfdc/-/rfdc-1.4.1.tgz",
+      "integrity": "sha512-q1b3N5QkRUWUl7iyylaaj3kOpIT0N2i9MqIEQXP73GVsN9cw3fdx8X63cEmWhJGi2PPCF23Ijp7ktmd39rawIA=="
+    },
+    "rollup": {
+      "version": "4.59.0",
+      "resolved": "https://registry.npmjs.org/rollup/-/rollup-4.59.0.tgz",
+      "integrity": "sha512-2oMpl67a3zCH9H79LeMcbDhXW/UmWG/y2zuqnF2jQq5uq9TbM9TVyXvA4+t+ne2IIkBdrLpAaRQAvo7YI/Yyeg==",
+      "dev": true,
+      "requires": {
+        "@rollup/rollup-android-arm-eabi": "4.59.0",
+        "@rollup/rollup-android-arm64": "4.59.0",
+        "@rollup/rollup-darwin-arm64": "4.59.0",
+        "@rollup/rollup-darwin-x64": "4.59.0",
+        "@rollup/rollup-freebsd-arm64": "4.59.0",
+        "@rollup/rollup-freebsd-x64": "4.59.0",
+        "@rollup/rollup-linux-arm-gnueabihf": "4.59.0",
+        "@rollup/rollup-linux-arm-musleabihf": "4.59.0",
+        "@rollup/rollup-linux-arm64-gnu": "4.59.0",
+        "@rollup/rollup-linux-arm64-musl": "4.59.0",
+        "@rollup/rollup-linux-loong64-gnu": "4.59.0",
+        "@rollup/rollup-linux-loong64-musl": "4.59.0",
+        "@rollup/rollup-linux-ppc64-gnu": "4.59.0",
+        "@rollup/rollup-linux-ppc64-musl": "4.59.0",
+        "@rollup/rollup-linux-riscv64-gnu": "4.59.0",
+        "@rollup/rollup-linux-riscv64-musl": "4.59.0",
+        "@rollup/rollup-linux-s390x-gnu": "4.59.0",
+        "@rollup/rollup-linux-x64-gnu": "4.59.0",
+        "@rollup/rollup-linux-x64-musl": "4.59.0",
+        "@rollup/rollup-openbsd-x64": "4.59.0",
+        "@rollup/rollup-openharmony-arm64": "4.59.0",
+        "@rollup/rollup-win32-arm64-msvc": "4.59.0",
+        "@rollup/rollup-win32-ia32-msvc": "4.59.0",
+        "@rollup/rollup-win32-x64-gnu": "4.59.0",
+        "@rollup/rollup-win32-x64-msvc": "4.59.0",
+        "@types/estree": "1.0.8",
+        "fsevents": "~2.3.2"
+      }
+    },
+    "run-parallel": {
+      "version": "1.2.0",
+      "resolved": "https://registry.npmjs.org/run-parallel/-/run-parallel-1.2.0.tgz",
+      "integrity": "sha512-5l4VyZR86LZ/lDxZTR6jqL8AFE2S0IFLMP26AbjsLVADxHdhB/c0GUsH+y39UfCi3dzz8OlQuPmnaJOMoDHQBA==",
+      "dev": true,
+      "requires": {
+        "queue-microtask": "^1.2.2"
+      }
+    },
+    "source-map-js": {
+      "version": "1.2.1",
+      "resolved": "https://registry.npmjs.org/source-map-js/-/source-map-js-1.2.1.tgz",
+      "integrity": "sha512-UXWMKhLOwVKb728IUtQPXxfYU+usdybtUrK/8uGE8CQMvrhOpwvzDBwj0QhSL7MQc7vIsISBG8VQ8+IDQxpfQA=="
+    },
+    "speakingurl": {
+      "version": "14.0.1",
+      "resolved": "https://registry.npmjs.org/speakingurl/-/speakingurl-14.0.1.tgz",
+      "integrity": "sha512-1POYv7uv2gXoyGFpBCmpDVSNV74IfsWlDW216UPjbWufNf+bSU6GdbDsxdcxtfwb4xlI3yxzOTKClUosxARYrQ=="
+    },
+    "sucrase": {
+      "version": "3.35.1",
+      "resolved": "https://registry.npmjs.org/sucrase/-/sucrase-3.35.1.tgz",
+      "integrity": "sha512-DhuTmvZWux4H1UOnWMB3sk0sbaCVOoQZjv8u1rDoTV0HTdGem9hkAZtl4JZy8P2z4Bg0nT+YMeOFyVr4zcG5Tw==",
+      "dev": true,
+      "requires": {
+        "@jridgewell/gen-mapping": "^0.3.2",
+        "commander": "^4.0.0",
+        "lines-and-columns": "^1.1.6",
+        "mz": "^2.7.0",
+        "pirates": "^4.0.1",
+        "tinyglobby": "^0.2.11",
+        "ts-interface-checker": "^0.1.9"
+      }
+    },
+    "superjson": {
+      "version": "2.2.6",
+      "resolved": "https://registry.npmjs.org/superjson/-/superjson-2.2.6.tgz",
+      "integrity": "sha512-H+ue8Zo4vJmV2nRjpx86P35lzwDT3nItnIsocgumgr0hHMQ+ZGq5vrERg9kJBo5AWGmxZDhzDo+WVIJqkB0cGA==",
+      "requires": {
+        "copy-anything": "^4"
+      }
+    },
+    "supports-preserve-symlinks-flag": {
+      "version": "1.0.0",
+      "resolved": "https://registry.npmjs.org/supports-preserve-symlinks-flag/-/supports-preserve-symlinks-flag-1.0.0.tgz",
+      "integrity": "sha512-ot0WnXS9fgdkgIcePe6RHNk1WA8+muPa6cSjeR3V8K27q9BB1rTE3R1p7Hv0z1ZyAc8s6Vvv8DIyWf681MAt0w==",
+      "dev": true
+    },
+    "tailwind-merge": {
+      "version": "3.5.0",
+      "resolved": "https://registry.npmjs.org/tailwind-merge/-/tailwind-merge-3.5.0.tgz",
+      "integrity": "sha512-I8K9wewnVDkL1NTGoqWmVEIlUcB9gFriAEkXkfCjX5ib8ezGxtR3xD7iZIxrfArjEsH7F1CHD4RFUtxefdqV/A==",
+      "dev": true
+    },
+    "tailwindcss": {
+      "version": "3.4.19",
+      "resolved": "https://registry.npmjs.org/tailwindcss/-/tailwindcss-3.4.19.tgz",
+      "integrity": "sha512-3ofp+LL8E+pK/JuPLPggVAIaEuhvIz4qNcf3nA1Xn2o/7fb7s/TYpHhwGDv1ZU3PkBluUVaF8PyCHcm48cKLWQ==",
+      "dev": true,
+      "requires": {
+        "@alloc/quick-lru": "^5.2.0",
+        "arg": "^5.0.2",
+        "chokidar": "^3.6.0",
+        "didyoumean": "^1.2.2",
+        "dlv": "^1.1.3",
+        "fast-glob": "^3.3.2",
+        "glob-parent": "^6.0.2",
+        "is-glob": "^4.0.3",
+        "jiti": "^1.21.7",
+        "lilconfig": "^3.1.3",
+        "micromatch": "^4.0.8",
+        "normalize-path": "^3.0.0",
+        "object-hash": "^3.0.0",
+        "picocolors": "^1.1.1",
+        "postcss": "^8.4.47",
+        "postcss-import": "^15.1.0",
+        "postcss-js": "^4.0.1",
+        "postcss-load-config": "^4.0.2 || ^5.0 || ^6.0",
+        "postcss-nested": "^6.2.0",
+        "postcss-selector-parser": "^6.1.2",
+        "resolve": "^1.22.8",
+        "sucrase": "^3.35.0"
+      }
+    },
+    "thenify": {
+      "version": "3.3.1",
+      "resolved": "https://registry.npmjs.org/thenify/-/thenify-3.3.1.tgz",
+      "integrity": "sha512-RVZSIV5IG10Hk3enotrhvz0T9em6cyHBLkH/YAZuKqd8hRkKhSfCGIcP2KUY0EPxndzANBmNllzWPwak+bheSw==",
+      "dev": true,
+      "requires": {
+        "any-promise": "^1.0.0"
+      }
+    },
+    "thenify-all": {
+      "version": "1.6.0",
+      "resolved": "https://registry.npmjs.org/thenify-all/-/thenify-all-1.6.0.tgz",
+      "integrity": "sha512-RNxQH/qI8/t3thXJDwcstUO4zeqo64+Uy/+sNVRBx4Xn2OX+OZ9oP+iJnNFqplFra2ZUVeKCSa2oVWi3T4uVmA==",
+      "dev": true,
+      "requires": {
+        "thenify": ">= 3.1.0 < 4"
+      }
+    },
+    "tinyglobby": {
+      "version": "0.2.15",
+      "resolved": "https://registry.npmjs.org/tinyglobby/-/tinyglobby-0.2.15.tgz",
+      "integrity": "sha512-j2Zq4NyQYG5XMST4cbs02Ak8iJUdxRM0XI5QyxXuZOzKOINmWurp3smXu3y5wDcJrptwpSjgXHzIQxR0omXljQ==",
+      "dev": true,
+      "requires": {
+        "fdir": "^6.5.0",
+        "picomatch": "^4.0.3"
+      },
+      "dependencies": {
+        "picomatch": {
+          "version": "4.0.3",
+          "resolved": "https://registry.npmjs.org/picomatch/-/picomatch-4.0.3.tgz",
+          "integrity": "sha512-5gTmgEY/sqK6gFXLIsQNH19lWb4ebPDLA4SdLP7dsWkIXHWlG66oPuVvXSGFPppYZz8ZDZq0dYYrbHfBCVUb1Q==",
+          "dev": true
+        }
+      }
+    },
+    "to-regex-range": {
+      "version": "5.0.1",
+      "resolved": "https://registry.npmjs.org/to-regex-range/-/to-regex-range-5.0.1.tgz",
+      "integrity": "sha512-65P7iz6X5yEr1cwcgvQxbbIw7Uk3gOy5dIdtZ4rDveLqhrdJP+Li/Hx6tyK0NEb+2GCyneCMJiGqrADCSNk8sQ==",
+      "dev": true,
+      "requires": {
+        "is-number": "^7.0.0"
+      }
+    },
+    "ts-interface-checker": {
+      "version": "0.1.13",
+      "resolved": "https://registry.npmjs.org/ts-interface-checker/-/ts-interface-checker-0.1.13.tgz",
+      "integrity": "sha512-Y/arvbn+rrz3JCKl9C4kVNfTfSm2/mEp5FSz5EsZSANGPSlQrpRI5M4PKF+mJnE52jOO90PnPSc3Ur3bTQw0gA==",
+      "dev": true
+    },
+    "typescript": {
+      "version": "5.9.3",
+      "resolved": "https://registry.npmjs.org/typescript/-/typescript-5.9.3.tgz",
+      "integrity": "sha512-jl1vZzPDinLr9eUt3J/t7V6FgNEw9QjvBPdysz9KfQDD41fQrC2Y4vKQdiaUpFT4bXlb1RHhLpp8wtm6M5TgSw==",
+      "dev": true
+    },
+    "update-browserslist-db": {
+      "version": "1.2.3",
+      "resolved": "https://registry.npmjs.org/update-browserslist-db/-/update-browserslist-db-1.2.3.tgz",
+      "integrity": "sha512-Js0m9cx+qOgDxo0eMiFGEueWztz+d4+M3rGlmKPT+T4IS/jP4ylw3Nwpu6cpTTP8R1MAC1kF4VbdLt3ARf209w==",
+      "dev": true,
+      "requires": {
+        "escalade": "^3.2.0",
+        "picocolors": "^1.1.1"
+      }
+    },
+    "util-deprecate": {
+      "version": "1.0.2",
+      "resolved": "https://registry.npmjs.org/util-deprecate/-/util-deprecate-1.0.2.tgz",
+      "integrity": "sha512-EPD5q1uXyFxJpCrLnCc1nHnq3gOa6DZBocAIiI2TaSCA7VCJ1UJDMagCzIkXNsUYfD1daK//LTEQ8xiIbrHtcw==",
+      "dev": true
+    },
+    "vite": {
+      "version": "7.3.1",
+      "resolved": "https://registry.npmjs.org/vite/-/vite-7.3.1.tgz",
+      "integrity": "sha512-w+N7Hifpc3gRjZ63vYBXA56dvvRlNWRczTdmCBBa+CotUzAPf5b7YMdMR/8CQoeYE5LX3W4wj6RYTgonm1b9DA==",
+      "dev": true,
+      "requires": {
+        "esbuild": "^0.27.0",
+        "fdir": "^6.5.0",
+        "fsevents": "~2.3.3",
+        "picomatch": "^4.0.3",
+        "postcss": "^8.5.6",
+        "rollup": "^4.43.0",
+        "tinyglobby": "^0.2.15"
+      },
+      "dependencies": {
+        "picomatch": {
+          "version": "4.0.3",
+          "resolved": "https://registry.npmjs.org/picomatch/-/picomatch-4.0.3.tgz",
+          "integrity": "sha512-5gTmgEY/sqK6gFXLIsQNH19lWb4ebPDLA4SdLP7dsWkIXHWlG66oPuVvXSGFPppYZz8ZDZq0dYYrbHfBCVUb1Q==",
+          "dev": true
+        }
+      }
+    },
+    "vue": {
+      "version": "3.5.29",
+      "resolved": "https://registry.npmjs.org/vue/-/vue-3.5.29.tgz",
+      "integrity": "sha512-BZqN4Ze6mDQVNAni0IHeMJ5mwr8VAJ3MQC9FmprRhcBYENw+wOAAjRj8jfmN6FLl0j96OXbR+CjWhmAmM+QGnA==",
+      "requires": {
+        "@vue/compiler-dom": "3.5.29",
+        "@vue/compiler-sfc": "3.5.29",
+        "@vue/runtime-dom": "3.5.29",
+        "@vue/server-renderer": "3.5.29",
+        "@vue/shared": "3.5.29"
+      }
+    },
+    "vue-observe-visibility": {
+      "version": "2.0.0-alpha.1",
+      "resolved": "https://registry.npmjs.org/vue-observe-visibility/-/vue-observe-visibility-2.0.0-alpha.1.tgz",
+      "integrity": "sha512-flFbp/gs9pZniXR6fans8smv1kDScJ8RS7rEpMjhVabiKeq7Qz3D9+eGsypncjfIyyU84saU88XZ0zjbD6Gq/g=="
+    },
+    "vue-resize": {
+      "version": "2.0.0-alpha.1",
+      "resolved": "https://registry.npmjs.org/vue-resize/-/vue-resize-2.0.0-alpha.1.tgz",
+      "integrity": "sha512-7+iqOueLU7uc9NrMfrzbG8hwMqchfVfSzpVlCMeJQe4pyibqyoifDNbKTZvwxZKDvGkB+PdFeKvnGZMoEb8esg=="
+    },
+    "vue-router": {
+      "version": "4.6.4",
+      "resolved": "https://registry.npmjs.org/vue-router/-/vue-router-4.6.4.tgz",
+      "integrity": "sha512-Hz9q5sa33Yhduglwz6g9skT8OBPii+4bFn88w6J+J4MfEo4KRRpmiNG/hHHkdbRFlLBOqxN8y8gf2Fb0MTUgVg==",
+      "requires": {
+        "@vue/devtools-api": "^6.6.4"
+      },
+      "dependencies": {
+        "@vue/devtools-api": {
+          "version": "6.6.4",
+          "resolved": "https://registry.npmjs.org/@vue/devtools-api/-/devtools-api-6.6.4.tgz",
+          "integrity": "sha512-sGhTPMuXqZ1rVOk32RylztWkfXTRhuS7vgAKv0zjqk8gbsHkJ7xfFf+jbySxt7tWObEJwyKaHMikV/WGDiQm8g=="
+        }
+      }
+    },
+    "vue-virtual-scroller": {
+      "version": "2.0.0-beta.8",
+      "resolved": "https://registry.npmjs.org/vue-virtual-scroller/-/vue-virtual-scroller-2.0.0-beta.8.tgz",
+      "integrity": "sha512-b8/f5NQ5nIEBRTNi6GcPItE4s7kxNHw2AIHLtDp+2QvqdTjVN0FgONwX9cr53jWRgnu+HRLPaWDOR2JPI5MTfQ==",
+      "requires": {
+        "mitt": "^2.1.0",
+        "vue-observe-visibility": "^2.0.0-alpha.1",
+        "vue-resize": "^2.0.0-alpha.1"
+      },
+      "dependencies": {
+        "mitt": {
+          "version": "2.1.0",
+          "resolved": "https://registry.npmjs.org/mitt/-/mitt-2.1.0.tgz",
+          "integrity": "sha512-ILj2TpLiysu2wkBbWjAmww7TkZb65aiQO+DkVdUTBpBXq+MHYiETENkKFMtsJZX1Lf4pe4QOrTSjIfUwN5lRdg=="
+        }
+      }
+    }
+  }
+}

frontend/package.json

@@ -0,0 +1,30 @@
+{
+  "name": "gemini-business2api",
+  "private": true,
+  "version": "0.0.0",
+  "type": "module",
+  "scripts": {
+    "dev": "vite",
+    "build": "tsc && vite build",
+    "preview": "vite preview"
+  },
+  "devDependencies": {
+    "@iconify/vue": "^5.0.0",
+    "autoprefixer": "^10.4.23",
+    "class-variance-authority": "^0.7.1",
+    "clsx": "^2.1.1",
+    "postcss": "^8.5.6",
+    "tailwind-merge": "^3.4.0",
+    "tailwindcss": "^3.4.19",
+    "typescript": "~5.9.3",
+    "vite": "^7.2.4"
+  },
+  "dependencies": {
+    "@vitejs/plugin-vue": "^6.0.3",
+    "axios": "^1.13.2",
+    "pinia": "^3.0.4",
+    "vue": "^3.5.26",
+    "vue-router": "^4.6.4",
+    "vue-virtual-scroller": "^2.0.0-beta.8"
+  }
+}

frontend/postcss.config.js

@@ -0,0 +1,6 @@
+export default {
+  plugins: {
+    tailwindcss: {},
+    autoprefixer: {},
+  },
+}

frontend/src/App.vue

@@ -0,0 +1,9 @@
+<template>
+  <RouterView />
+  <Toast />
+</template>
+
+<script setup lang="ts">
+import { RouterView } from 'vue-router'
+import Toast from '@/components/ui/Toast.vue'
+</script>