Upload 1108 files

.dockerignore

@@ -0,0 +1,77 @@
+# Git
+.git
+.gitignore
+.gitattributes
+
+# Python
+__pycache__/
+*.py[cod]
+*$py.class
+*.so
+.Python
+build/
+develop-eggs/
+dist/
+downloads/
+eggs/
+.eggs/
+lib/
+lib64/
+parts/
+sdist/
+var/
+wheels/
+*.egg-info/
+.installed.cfg
+*.egg
+MANIFEST
+*.manifest
+*.spec
+pip-log.txt
+pip-delete-this-directory.txt
+
+# Virtual Environment
+venv/
+env/
+ENV/
+.venv
+
+# IDE
+.vscode/
+.idea/
+*.swp
+*.swo
+*~
+.DS_Store
+
+# Project specific
+data/*.db
+data/*.db-journal
+tmp/*
+logs/*
+*.log
+
+# Docker
+Dockerfile
+docker-compose*.yml
+.dockerignore
+
+# Documentation
+README.md
+DEPLOYMENT.md
+LICENSE
+*.md
+
+# Test files
+tests/
+test_*.py
+*_test.py
+
+# CI/CD
+.github/
+.gitlab-ci.yml
+.travis.yml
+
+# Environment files
+.env
+.env.*

.gitattributes

@@ -33,3 +33,11 @@ saved_model/**/* filter=lfs diff=lfs merge=lfs -text
 *.zip filter=lfs diff=lfs merge=lfs -text
 *.zst filter=lfs diff=lfs merge=lfs -text
 *tfevents* filter=lfs diff=lfs merge=lfs -text
+venv/Lib/site-packages/pip/_vendor/__pycache__/pyparsing.cpython-310.pyc filter=lfs diff=lfs merge=lfs -text
+venv/Lib/site-packages/pip/_vendor/distlib/t64.exe filter=lfs diff=lfs merge=lfs -text
+venv/Lib/site-packages/pip/_vendor/html5lib/__pycache__/constants.cpython-310.pyc filter=lfs diff=lfs merge=lfs -text
+venv/Lib/site-packages/pip/_vendor/idna/__pycache__/uts46data.cpython-310.pyc filter=lfs diff=lfs merge=lfs -text
+venv/Lib/site-packages/pkg_resources/__pycache__/__init__.cpython-310.pyc filter=lfs diff=lfs merge=lfs -text
+venv/Lib/site-packages/pkg_resources/_vendor/__pycache__/pyparsing.cpython-310.pyc filter=lfs diff=lfs merge=lfs -text
+venv/Lib/site-packages/setuptools/_vendor/__pycache__/pyparsing.cpython-310.pyc filter=lfs diff=lfs merge=lfs -text
+venv/Lib/site-packages/setuptools/_vendor/more_itertools/__pycache__/more.cpython-310.pyc filter=lfs diff=lfs merge=lfs -text

.gitignore

@@ -0,0 +1,56 @@
+# Python
+__pycache__/
+*.py[cod]
+*$py.class
+*.so
+.Python
+env/
+venv/
+ENV/
+build/
+develop-eggs/
+dist/
+downloads/
+eggs/
+.eggs/
+lib/
+lib64/
+parts/
+sdist/
+var/
+wheels/
+*.egg-info/
+.installed.cfg
+*.egg
+
+# Database
+*.db
+*.sqlite
+*.sqlite3
+data/*.db
+
+# Logs
+*.log
+logs.txt
+
+# IDE
+.vscode/
+.idea/
+*.swp
+*.swo
+*~
+.DS_Store
+
+# Environment
+.env
+.env.local
+
+# Config (optional)
+# config/setting.toml
+
+# Temporary files
+*.tmp
+*.bak
+*.cache
+
+browser_data

Dockerfile

@@ -0,0 +1,35 @@
+FROM python:3.11-slim
+
+WORKDIR /app
+
+# 安装 Playwright 所需的系统依赖
+RUN apt-get update && apt-get install -y \
+    libnss3 \
+    libnspr4 \
+    libatk1.0-0 \
+    libatk-bridge2.0-0 \
+    libcups2 \
+    libdrm2 \
+    libxkbcommon0 \
+    libxcomposite1 \
+    libxdamage1 \
+    libxfixes3 \
+    libxrandr2 \
+    libgbm1 \
+    libasound2 \
+    libpango-1.0-0 \
+    libcairo2 \
+    && rm -rf /var/lib/apt/lists/*
+
+# 安装 Python 依赖
+COPY requirements.txt .
+RUN pip install --no-cache-dir -r requirements.txt
+
+# 安装 Playwright 浏览器
+RUN playwright install chromium
+
+COPY . .
+
+EXPOSE 8000
+
+CMD ["python", "main.py"]

LICENSE

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

@@ -1,11 +1,298 @@
+# Flow2API
+
+<div align="center">
+
+[![License](https://img.shields.io/badge/license-MIT-blue.svg)](LICENSE)
+[![Python](https://img.shields.io/badge/python-3.8%2B-blue.svg)](https://www.python.org/)
+[![FastAPI](https://img.shields.io/badge/fastapi-0.119.0-green.svg)](https://fastapi.tiangolo.com/)
+[![Docker](https://img.shields.io/badge/docker-supported-blue.svg)](https://www.docker.com/)
+
+**一个功能完整的 OpenAI 兼容 API 服务，为 Flow 提供统一的接口**
+
+</div>
+
+## ✨ 核心特性
+
+- 🎨 **文生图** / **图生图**
+- 🎬 **文生视频** / **图生视频**
+- 🎞️ **首尾帧视频**
+- 🔄 **AT自动刷新**
+- 📊 **余额显示** - 实时查询和显示 VideoFX Credits
+- 🚀 **负载均衡** - 多 Token 轮询和并发控制
+- 🌐 **代理支持** - 支持 HTTP/SOCKS5 代理
+- 📱 **Web 管理界面** - 直观的 Token 和配置管理
+- 🎨 **图片生成连续对话**
+
+## 🚀 快速开始
+
+### 前置要求
+
+- Docker 和 Docker Compose（推荐）
+- 或 Python 3.8+
+
+- 由于Flow增加了额外的验证码，你可以自行选择使用浏览器打码或第三发打码：
+注册[YesCaptcha](https://yescaptcha.com/i/13Xd8K)并获取api key，将其填入系统配置页面```YesCaptcha API密钥```区域
+
+- 自动更新st浏览器拓展：[Flow2API-Token-Updater](https://github.com/TheSmallHanCat/Flow2API-Token-Updater)
+
+### 方式一：Docker 部署（推荐）
+
+#### 标准模式（不使用代理）
+
+```bash
+# 克隆项目
+git clone https://github.com/TheSmallHanCat/flow2api.git
+cd flow2api
+
+# 启动服务
+docker-compose up -d
+
+# 查看日志
+docker-compose logs -f
+```
+
+#### WARP 模式（使用代理）
+
+```bash
+# 使用 WARP 代理启动
+docker-compose -f docker-compose.warp.yml up -d
+
+# 查看日志
+docker-compose -f docker-compose.warp.yml logs -f
+```
+
+### 方式二：本地部署
+
+```bash
+# 克隆项目
+git clone https://github.com/TheSmallHanCat/flow2api.git
+cd flow2api
+
+# 创建虚拟环境
+python -m venv venv
+
+# 激活虚拟环境
+# Windows
+venv\Scripts\activate
+# Linux/Mac
+source venv/bin/activate
+
+# 安装依赖
+pip install -r requirements.txt
+
+# 启动服务
+python main.py
+```
+
+### 方式三：Hugging Face 部署
+
+1. **准备工作**
+   - 注册并登录 [Hugging Face](https://huggingface.co/)
+   - 创建一个新的 Space
+   - 选择 "Docker" 作为 Space 类型
+
+2. **配置 Space**
+   - **Repository name**: 输入一个名称（例如 `flow2api`）
+   - **Visibility**: 选择 "Public" 或 "Private"
+   - **Hardware**: 选择适当的硬件配置（最低推荐 2GB RAM）
+
+3. **部署步骤**
+   - 在 Space 的 "Files" 标签页中，上传项目的所有文件
+   - 确保 `app.py` 文件存在（Hugging Face 的部署入口）
+   - 确保 `requirements.txt` 文件包含所有必要的依赖
+   - 点击 "Build" 按钮开始部署
+
+4. **访问服务**
+   - 部署完成后，通过 Space 提供的 URL 访问服务
+   - 默认登录地址: `https://<your-space-name>.hf.space/`
+   - 首次登录用户名: `admin`，密码: `admin`
+
+5. **注意事项**
+   - Hugging Face Spaces 使用端口 7860，配置已自动适配
+   - 由于 Hugging Face 的网络环境，可能需要配置代理
+   - 建议在管理界面中修改默认的管理员密码
+   - 对于视频生成等耗时操作，可能会受到 Hugging Face 的资源限制
+
+### 首次访问
+
+服务启动后,访问管理后台: **http://localhost:8000**,首次登录后请立即修改密码!
+
+- **用户名**: `admin`
+- **密码**: `admin`
+
+## 📋 支持的模型
+
+### 图片生成
+
+| 模型名称 | 说明| 尺寸 |
+|---------|--------|--------|
+| `gemini-2.5-flash-image-landscape` | 图/文生图 | 横屏 |
+| `gemini-2.5-flash-image-portrait` | 图/文生图 | 竖屏 |
+| `gemini-3.0-pro-image-landscape` | 图/文生图 | 横屏 |
+| `gemini-3.0-pro-image-portrait` | 图/文生图 | 竖屏 |
+| `imagen-4.0-generate-preview-landscape` | 图/文生图 | 横屏 |
+| `imagen-4.0-generate-preview-portrait` | 图/文生图 | 竖屏 |
+
+### 视频生成
+
+#### 文生视频 (T2V - Text to Video)
+⚠️ **不支持上传图片**
+
+| 模型名称 | 说明| 尺寸 |
+|---------|---------|--------|
+| `veo_3_1_t2v_fast_portrait` | 文生视频 | 竖屏 |
+| `veo_3_1_t2v_fast_landscape` | 文生视频 | 横屏 |
+| `veo_2_1_fast_d_15_t2v_portrait` | 文生视频 | 竖屏 |
+| `veo_2_1_fast_d_15_t2v_landscape` | 文生视频 | 横屏 |
+| `veo_2_0_t2v_portrait` | 文生视频 | 竖屏 |
+| `veo_2_0_t2v_landscape` | 文生视频 | 横屏 |
+
+#### 首尾帧模型 (I2V - Image to Video)
+📸 **支持1-2张图片：首尾帧**
+
+| 模型名称 | 说明| 尺寸 |
+|---------|---------|--------|
+| `veo_3_1_i2v_s_fast_fl_portrait` | 图生视频 | 竖屏 |
+| `veo_3_1_i2v_s_fast_fl_landscape` | 图生视频 | 横屏 |
+| `veo_2_1_fast_d_15_i2v_portrait` | 图生视频 | 竖屏 |
+| `veo_2_1_fast_d_15_i2v_landscape` | 图生视频 | 横屏 |
+| `veo_2_0_i2v_portrait` | 图生视频 | 竖屏 |
+| `veo_2_0_i2v_landscape` | 图生视频 | 横屏 |
+
+#### 多图生成 (R2V - Reference Images to Video)
+🖼️ **支持多张图片**
+
+| 模型名称 | 说明| 尺寸 |
+|---------|---------|--------|
+| `veo_3_0_r2v_fast_portrait` | 图生视频 | 竖屏 |
+| `veo_3_0_r2v_fast_landscape` | 图生视频 | 横屏 |
+
+## 📡 API 使用示例（需要使用流式）
+
+### 文生图
+
+```bash
+curl -X POST "http://localhost:8000/v1/chat/completions" \
+  -H "Authorization: Bearer han1234" \
+  -H "Content-Type: application/json" \
+  -d '{
+    "model": "gemini-2.5-flash-image-landscape",
+    "messages": [
+      {
+        "role": "user",
+        "content": "一只可爱的猫咪在花园里玩耍"
+      }
+    ],
+    "stream": true
+  }'
+```
+
+### 图生图
+
+```bash
+curl -X POST "http://localhost:8000/v1/chat/completions" \
+  -H "Authorization: Bearer han1234" \
+  -H "Content-Type: application/json" \
+  -d '{
+    "model": "imagen-4.0-generate-preview-landscape",
+    "messages": [
+      {
+        "role": "user",
+        "content": [
+          {
+            "type": "text",
+            "text": "将这张图片变成水彩画风格"
+          },
+          {
+            "type": "image_url",
+            "image_url": {
+              "url": "data:image/jpeg;base64,<base64_encoded_image>"
+            }
+          }
+        ]
+      }
+    ],
+    "stream": true
+  }'
+```
+
+### 文生视频
+
+```bash
+curl -X POST "http://localhost:8000/v1/chat/completions" \
+  -H "Authorization: Bearer han1234" \
+  -H "Content-Type: application/json" \
+  -d '{
+    "model": "veo_3_1_t2v_fast_landscape",
+    "messages": [
+      {
+        "role": "user",
+        "content": "一只小猫在草地上追逐蝴蝶"
+      }
+    ],
+    "stream": true
+  }'
+```
+
+### 首尾帧生成视频
+
+```bash
+curl -X POST "http://localhost:8000/v1/chat/completions" \
+  -H "Authorization: Bearer han1234" \
+  -H "Content-Type: application/json" \
+  -d '{
+    "model": "veo_3_1_i2v_s_fast_fl_landscape",
+    "messages": [
+      {
+        "role": "user",
+        "content": [
+          {
+            "type": "text",
+            "text": "从第一张图过渡到第二张图"
+          },
+          {
+            "type": "image_url",
+            "image_url": {
+              "url": "data:image/jpeg;base64,<首帧base64>"
+            }
+          },
+          {
+            "type": "image_url",
+            "image_url": {
+              "url": "data:image/jpeg;base64,<尾帧base64>"
+            }
+          }
+        ]
+      }
+    ],
+    "stream": true
+  }'
+```
+
+---
+
+## 📄 许可证
+
+本项目采用 MIT 许可证。详见 [LICENSE](LICENSE) 文件。
+
+---
+
+## 🙏 致谢
+
+- [PearNoDec](https://github.com/PearNoDec) 提供的YesCaptcha打码方案
+- [raomaiping](https://github.com/raomaiping) 提供的无头打码方案
+感谢所有贡献者和使用者的支持！
+
 ---
-title: FLOW2API
-emoji: 🚀
-colorFrom: gray
-colorTo: green
-sdk: docker
-pinned: false
-short_description: FLOW2API
+
+## 📞 联系方式
+
+- 提交 Issue：[GitHub Issues](https://github.com/TheSmallHanCat/flow2api/issues)
+
 ---
 
-Check out the configuration reference at https://huggingface.co/docs/hub/spaces-config-reference
+**⭐ 如果这个项目对你有帮助，请给个 Star！**
+
+## Star History
+
+[![Star History Chart](https://api.star-history.com/svg?repos=TheSmallHanCat/flow2api&type=date&legend=top-left)](https://www.star-history.com/#TheSmallHanCat/flow2api&type=date&legend=top-left)

app.py

@@ -0,0 +1,18 @@
+"""Flow2API - Hugging Face Deployment Entry Point"""
+from src.main import app
+import os
+
+# Hugging Face 要求使用 7860 端口
+if __name__ == "__main__":
+    import uvicorn
+    from src.core.config import config
+    
+    # 使用环境变量中的端口（Hugging Face 会设置），默认 7860
+    port = int(os.getenv("PORT", "7860"))
+    
+    uvicorn.run(
+        "src.main:app",
+        host="0.0.0.0",
+        port=port,
+        reload=False
+    )

config/setting.toml

@@ -0,0 +1,42 @@
+[global]
+api_key = "han1234"
+admin_username = "admin"
+admin_password = "admin"
+
+[flow]
+labs_base_url = "https://labs.google/fx/api"
+api_base_url = "https://aisandbox-pa.googleapis.com/v1"
+timeout = 120
+poll_interval = 3.0
+max_poll_attempts = 200
+
+[server]
+host = "0.0.0.0"
+port = 7860
+
+[debug]
+enabled = false
+log_requests = true
+log_responses = true
+mask_token = true
+
+[proxy]
+proxy_enabled = false
+proxy_url = ""
+
+[generation]
+image_timeout = 300
+video_timeout = 1500
+
+[admin]
+error_ban_threshold = 3
+
+[cache]
+enabled = false
+timeout = 7200  # 缓存超时时间(秒), 默认2小时
+base_url = ""   # 缓存文件访问的基础URL, 留空则使用服务器地址
+
+[captcha]
+captcha_method = "browser"  # 打码方式: yescaptcha 或 browser
+yescaptcha_api_key = ""  # YesCaptcha API密钥
+yescaptcha_base_url = "https://api.yescaptcha.com"

config/setting_warp.toml

@@ -0,0 +1,42 @@
+[global]
+api_key = "han1234"
+admin_username = "admin"
+admin_password = "admin"
+
+[flow]
+labs_base_url = "https://labs.google/fx/api"
+api_base_url = "https://aisandbox-pa.googleapis.com/v1"
+timeout = 120
+poll_interval = 3.0
+max_poll_attempts = 200
+
+[server]
+host = "0.0.0.0"
+port = 8000
+
+[debug]
+enabled = false
+log_requests = true
+log_responses = true
+mask_token = true
+
+[proxy]
+proxy_enabled = true
+proxy_url = "socks5://warp:1080"
+
+[generation]
+image_timeout = 300
+video_timeout = 1500
+
+[admin]
+error_ban_threshold = 3
+
+[cache]
+enabled = false
+timeout = 7200  # 缓存超时时间(秒), 默认2小时
+base_url = ""   # 缓存文件访问的基础URL, 留空则使用服务器地址
+
+[captcha]
+captcha_method = "browser"  # 打码方式: yescaptcha 或 browser
+yescaptcha_api_key = ""  # YesCaptcha API密钥
+yescaptcha_base_url = "https://api.yescaptcha.com"

docker-compose.proxy.yml

@@ -0,0 +1,36 @@
+version: '3.8'
+
+services:
+  flow2api:
+    image: thesmallhancat/flow2api:latest
+    container_name: flow2api
+    ports:
+      - "8000:8000"
+    volumes:
+      - ./data:/app/data
+      - ./config/setting_warp.toml:/app/config/setting.toml
+    environment:
+      - PYTHONUNBUFFERED=1
+    restart: unless-stopped
+    depends_on:
+      - warp
+
+  warp:
+    image: caomingjun/warp
+    container_name: warp
+    restart: always
+    devices:
+      - /dev/net/tun:/dev/net/tun
+    ports:
+      - "1080:1080"
+    environment:
+      - WARP_SLEEP=2
+    cap_add:
+      - MKNOD
+      - AUDIT_WRITE
+      - NET_ADMIN
+    sysctls:
+      - net.ipv6.conf.all.disable_ipv6=0
+      - net.ipv4.conf.all.src_valid_mark=1
+    volumes:
+      - ./data:/var/lib/cloudflare-warp

docker-compose.yml

@@ -0,0 +1,14 @@
+version: '3.8'
+
+services:
+  flow2api:
+    image: thesmallhancat/flow2api:latest
+    container_name: flow2api
+    ports:
+      - "8000:8000"
+    volumes:
+      - ./data:/app/data
+      - ./config/setting.toml:/app/config/setting.toml
+    environment:
+      - PYTHONUNBUFFERED=1
+    restart: unless-stopped

main.py

@@ -0,0 +1,13 @@
+"""Flow2API - Main Entry Point"""
+from src.main import app
+import uvicorn
+
+if __name__ == "__main__":
+    from src.core.config import config
+
+    uvicorn.run(
+        "src.main:app",
+        host=config.server_host,
+        port=config.server_port,
+        reload=False
+    )

request.py

@@ -0,0 +1,150 @@
+import os
+import json
+import re
+import base64
+import aiohttp # Async test. Need to install
+import asyncio
+
+
+# --- 配置区域 ---
+BASE_URL = os.getenv('GEMINI_FLOW2API_URL', 'http://127.0.0.1:8000')
+BACKEND_URL = BASE_URL + "/v1/chat/completions"
+API_KEY = os.getenv('GEMINI_FLOW2API_APIKEY', 'Bearer han1234')
+if API_KEY is None:
+    raise ValueError('[gemini flow2api] api key not set')
+MODEL_LANDSCAPE = "gemini-3.0-pro-image-landscape"
+MODEL_PORTRAIT = "gemini-3.0-pro-image-portrait"
+
+# 修改: 增加 model 参数，默认为 None
+async def request_backend_generation(
+        prompt: str,
+        images: list[bytes] = None,
+        model: str = None) -> bytes | None:
+    """
+    请求后端生成图片。
+    :param prompt: 提示词
+    :param images: 图片二进制列表
+    :param model: 指定模型名称 (可选)
+    :return: 成功返回图片bytes，失败返回None
+    """
+    # 更新token
+    images = images or []
+    
+    # 逻辑: 如果未指定 model，默认使用 Landscape
+    use_model = model if model else MODEL_LANDSCAPE
+
+    # 1. 构造 Payload
+    if images:
+        content_payload = [{"type": "text", "text": prompt}]
+        print(f"[Backend] 正在处理 {len(images)} 张图片输入...")
+        for img_bytes in images:
+            b64_str = base64.b64encode(img_bytes).decode('utf-8')
+            content_payload.append({
+                "type": "image_url",
+                "image_url": {"url": f"data:image/jpeg;base64,{b64_str}"}
+            })
+    else:
+        content_payload = prompt
+
+    payload = {
+        "model": use_model,  # 使用选定的模型
+        "messages": [{"role": "user", "content": content_payload}],
+        "stream": True
+    }
+    
+    headers = {
+        "Authorization": API_KEY,
+        "Content-Type": "application/json"
+    }
+
+    image_url = None
+    print(f"[Backend] Model: {use_model} | 发起请求: {prompt[:20]}...") 
+    
+    try:
+        async with aiohttp.ClientSession() as session:
+            async with session.post(BACKEND_URL, json=payload, headers=headers, timeout=120) as response:
+                if response.status != 200:
+                    err_text = await response.text()
+                    content = response.content
+                    print(f"[Backend Error] Status {response.status}: {err_text} {content}")
+                    raise Exception(f"API Error: {response.status}: {err_text}")
+
+                async for line in response.content:
+                    line_str = line.decode('utf-8').strip()
+                    if line_str.startswith('{"error'):
+                        chunk = json.loads(data_str)
+                        delta = chunk.get("choices", [{}])[0].get("delta", {})
+                        msg = delta['reasoning_content']
+                        if '401' in msg:
+                            msg += '\nAccess Token 已失效，需重新配置。'
+                        elif '400' in msg:
+                            msg += '\n返回内容被拦截。'
+                        raise Exception(msg)
+
+                    if not line_str or not line_str.startswith('data: '):
+                        continue
+                    
+                    data_str = line_str[6:]
+                    if data_str == '[DONE]':
+                        break
+                    
+                    try:
+                        chunk = json.loads(data_str)
+                        delta = chunk.get("choices", [{}])[0].get("delta", {})
+                        
+                        # 打印思考过程
+                        if "reasoning_content" in delta:
+                            print(delta['reasoning_content'], end="", flush=True)
+
+                        # 提取内容中的图片链接
+                        if "content" in delta:
+                            content_text = delta["content"]
+                            img_match = re.search(r'!\[.*?\]\((.*?)\)', content_text)
+                            if img_match:
+                                image_url = img_match.group(1)
+                                print(f"\n[Backend] 捕获图片链接: {image_url}")
+                    except json.JSONDecodeError:
+                        continue
+            
+            # 3. 下载生成的图片
+            if image_url:
+                async with session.get(image_url) as img_resp:
+                    if img_resp.status == 200:
+                        image_bytes = await img_resp.read()
+                        return image_bytes
+                    else:
+                        print(f"[Backend Error] 图片下载失败: {img_resp.status}")
+    except Exception as e:
+        print(f"[Backend Exception] {e}")
+        raise e 
+        
+    return None
+
+if __name__ == '__main__':
+    async def main():
+        print("=== AI 绘图接口测试 ===")
+        user_prompt = input("请输入提示词 (例如 '一只猫'): ").strip()
+        if not user_prompt:
+            user_prompt = "A cute cat in the garden"
+        
+        print(f"正在请求: {user_prompt}")
+        
+        # 这里的 images 传空列表用于测试文生图
+        # 如果想测试图生图，你需要手动读取本地文件：
+        # with open("output_test.jpg", "rb") as f: img_data = f.read()
+        # result = await request_backend_generation(user_prompt, [img_data])
+        
+        result = await request_backend_generation(user_prompt)
+        
+        if result:
+            filename = "output_test.jpg"
+            with open(filename, "wb") as f:
+                f.write(result)
+            print(f"\n[Success] 图片已保存为 {filename}，大小: {len(result)} bytes")
+        else:
+            print("\n[Failed] 生成失败")
+
+    # 运行测试
+    if os.name == 'nt':  # Windows 兼容性
+        asyncio.set_event_loop_policy(asyncio.WindowsSelectorEventLoopPolicy())
+    asyncio.run(main())

requirements.txt

@@ -0,0 +1,10 @@
+fastapi==0.119.0
+uvicorn[standard]==0.32.1
+aiosqlite==0.20.0
+pydantic==2.10.4
+curl-cffi==0.7.3
+tomli==2.2.1
+bcrypt==4.2.1
+python-multipart==0.0.20
+python-dateutil==2.8.2
+playwright==1.53.0

src/api/__init__.py

@@ -0,0 +1,6 @@
+"""API modules"""
+
+from .routes import router as api_router
+from .admin import router as admin_router
+
+__all__ = ["api_router", "admin_router"]

src/api/admin.py

@@ -0,0 +1,1047 @@
+"""Admin API routes"""
+from fastapi import APIRouter, Depends, HTTPException, Header, Request
+from fastapi.responses import JSONResponse
+from pydantic import BaseModel
+from typing import Optional, List
+import secrets
+from ..core.auth import AuthManager
+from ..core.database import Database
+from ..core.config import config
+from ..services.token_manager import TokenManager
+from ..services.proxy_manager import ProxyManager
+
+router = APIRouter()
+
+# Dependency injection
+token_manager: TokenManager = None
+proxy_manager: ProxyManager = None
+db: Database = None
+
+# Store active admin session tokens (in production, use Redis or database)
+active_admin_tokens = set()
+
+
+def set_dependencies(tm: TokenManager, pm: ProxyManager, database: Database):
+    """Set service instances"""
+    global token_manager, proxy_manager, db
+    token_manager = tm
+    proxy_manager = pm
+    db = database
+
+
+# ========== Request Models ==========
+
+class LoginRequest(BaseModel):
+    username: str
+    password: str
+
+
+class AddTokenRequest(BaseModel):
+    st: str
+    project_id: Optional[str] = None  # 用户可选输入project_id
+    project_name: Optional[str] = None
+    remark: Optional[str] = None
+    image_enabled: bool = True
+    video_enabled: bool = True
+    image_concurrency: int = -1
+    video_concurrency: int = -1
+
+
+class UpdateTokenRequest(BaseModel):
+    st: str  # Session Token (必填，用于刷新AT)
+    project_id: Optional[str] = None  # 用户可选输入project_id
+    project_name: Optional[str] = None
+    remark: Optional[str] = None
+    image_enabled: Optional[bool] = None
+    video_enabled: Optional[bool] = None
+    image_concurrency: Optional[int] = None
+    video_concurrency: Optional[int] = None
+
+
+class ProxyConfigRequest(BaseModel):
+    proxy_enabled: bool
+    proxy_url: Optional[str] = None
+
+
+class GenerationConfigRequest(BaseModel):
+    image_timeout: int
+    video_timeout: int
+
+
+class ChangePasswordRequest(BaseModel):
+    username: Optional[str] = None
+    old_password: str
+    new_password: str
+
+
+class UpdateAPIKeyRequest(BaseModel):
+    new_api_key: str
+
+
+class UpdateDebugConfigRequest(BaseModel):
+    enabled: bool
+
+
+class UpdateAdminConfigRequest(BaseModel):
+    error_ban_threshold: int
+
+
+class ST2ATRequest(BaseModel):
+    """ST转AT请求"""
+    st: str
+
+
+class ImportTokenItem(BaseModel):
+    """导入Token项"""
+    email: Optional[str] = None
+    access_token: Optional[str] = None
+    session_token: Optional[str] = None
+    is_active: bool = True
+    image_enabled: bool = True
+    video_enabled: bool = True
+    image_concurrency: int = -1
+    video_concurrency: int = -1
+
+
+class ImportTokensRequest(BaseModel):
+    """导入Token请求"""
+    tokens: List[ImportTokenItem]
+
+
+# ========== Auth Middleware ==========
+
+async def verify_admin_token(authorization: str = Header(None)):
+    """Verify admin session token (NOT API key)"""
+    if not authorization or not authorization.startswith("Bearer "):
+        raise HTTPException(status_code=401, detail="Missing authorization")
+
+    token = authorization[7:]
+
+    # Check if token is in active session tokens
+    if token not in active_admin_tokens:
+        raise HTTPException(status_code=401, detail="Invalid or expired admin token")
+
+    return token
+
+
+# ========== Auth Endpoints ==========
+
+@router.post("/api/admin/login")
+async def admin_login(request: LoginRequest):
+    """Admin login - returns session token (NOT API key)"""
+    admin_config = await db.get_admin_config()
+
+    if not AuthManager.verify_admin(request.username, request.password):
+        raise HTTPException(status_code=401, detail="Invalid credentials")
+
+    # Generate independent session token
+    session_token = f"admin-{secrets.token_urlsafe(32)}"
+
+    # Store in active tokens
+    active_admin_tokens.add(session_token)
+
+    return {
+        "success": True,
+        "token": session_token,  # Session token (NOT API key)
+        "username": admin_config.username
+    }
+
+
+@router.post("/api/admin/logout")
+async def admin_logout(token: str = Depends(verify_admin_token)):
+    """Admin logout - invalidate session token"""
+    active_admin_tokens.discard(token)
+    return {"success": True, "message": "退出登录成功"}
+
+
+@router.post("/api/admin/change-password")
+async def change_password(
+    request: ChangePasswordRequest,
+    token: str = Depends(verify_admin_token)
+):
+    """Change admin password"""
+    admin_config = await db.get_admin_config()
+
+    # Verify old password
+    if not AuthManager.verify_admin(admin_config.username, request.old_password):
+        raise HTTPException(status_code=400, detail="旧密码错误")
+
+    # Update password and username in database
+    update_params = {"password": request.new_password}
+    if request.username:
+        update_params["username"] = request.username
+
+    await db.update_admin_config(**update_params)
+
+    # 🔥 Hot reload: sync database config to memory
+    await db.reload_config_to_memory()
+
+    # 🔑 Invalidate all admin session tokens (force re-login for security)
+    active_admin_tokens.clear()
+
+    return {"success": True, "message": "密码修改成功,请重新登录"}
+
+
+# ========== Token Management ==========
+
+@router.get("/api/tokens")
+async def get_tokens(token: str = Depends(verify_admin_token)):
+    """Get all tokens with statistics"""
+    tokens = await token_manager.get_all_tokens()
+    result = []
+
+    for t in tokens:
+        stats = await db.get_token_stats(t.id)
+
+        result.append({
+            "id": t.id,
+            "st": t.st,  # Session Token for editing
+            "at": t.at,  # Access Token for editing (从ST转换而来)
+            "at_expires": t.at_expires.isoformat() if t.at_expires else None,  # 🆕 AT过期时间
+            "token": t.at,  # 兼容前端 token.token 的访问方式
+            "email": t.email,
+            "name": t.name,
+            "remark": t.remark,
+            "is_active": t.is_active,
+            "created_at": t.created_at.isoformat() if t.created_at else None,
+            "last_used_at": t.last_used_at.isoformat() if t.last_used_at else None,
+            "use_count": t.use_count,
+            "credits": t.credits,  # 🆕 余额
+            "user_paygate_tier": t.user_paygate_tier,
+            "current_project_id": t.current_project_id,  # 🆕 项目ID
+            "current_project_name": t.current_project_name,  # 🆕 项目名称
+            "image_enabled": t.image_enabled,
+            "video_enabled": t.video_enabled,
+            "image_concurrency": t.image_concurrency,
+            "video_concurrency": t.video_concurrency,
+            "image_count": stats.image_count if stats else 0,
+            "video_count": stats.video_count if stats else 0,
+            "error_count": stats.error_count if stats else 0
+        })
+
+    return result  # 直接返回数组,兼容前端
+
+
+@router.post("/api/tokens")
+async def add_token(
+    request: AddTokenRequest,
+    token: str = Depends(verify_admin_token)
+):
+    """Add a new token"""
+    try:
+        new_token = await token_manager.add_token(
+            st=request.st,
+            project_id=request.project_id,  # 🆕 支持用户指定project_id
+            project_name=request.project_name,
+            remark=request.remark,
+            image_enabled=request.image_enabled,
+            video_enabled=request.video_enabled,
+            image_concurrency=request.image_concurrency,
+            video_concurrency=request.video_concurrency
+        )
+
+        return {
+            "success": True,
+            "message": "Token添加成功",
+            "token": {
+                "id": new_token.id,
+                "email": new_token.email,
+                "credits": new_token.credits,
+                "project_id": new_token.current_project_id,
+                "project_name": new_token.current_project_name
+            }
+        }
+    except ValueError as e:
+        raise HTTPException(status_code=400, detail=str(e))
+    except Exception as e:
+        raise HTTPException(status_code=500, detail=f"添加Token失败: {str(e)}")
+
+
+@router.put("/api/tokens/{token_id}")
+async def update_token(
+    token_id: int,
+    request: UpdateTokenRequest,
+    token: str = Depends(verify_admin_token)
+):
+    """Update token - 使用ST自动刷新AT"""
+    try:
+        # 先ST转AT
+        result = await token_manager.flow_client.st_to_at(request.st)
+        at = result["access_token"]
+        expires = result.get("expires")
+
+        # 解析过期时间
+        from datetime import datetime
+        at_expires = None
+        if expires:
+            try:
+                at_expires = datetime.fromisoformat(expires.replace('Z', '+00:00'))
+            except:
+                pass
+
+        # 更新token (包含AT、ST、AT过期时间、project_id和project_name)
+        await token_manager.update_token(
+            token_id=token_id,
+            st=request.st,
+            at=at,
+            at_expires=at_expires,  # 🆕 更新AT过期时间
+            project_id=request.project_id,
+            project_name=request.project_name,
+            remark=request.remark,
+            image_enabled=request.image_enabled,
+            video_enabled=request.video_enabled,
+            image_concurrency=request.image_concurrency,
+            video_concurrency=request.video_concurrency
+        )
+
+        return {"success": True, "message": "Token更新成功"}
+    except Exception as e:
+        raise HTTPException(status_code=500, detail=str(e))
+
+
+@router.delete("/api/tokens/{token_id}")
+async def delete_token(
+    token_id: int,
+    token: str = Depends(verify_admin_token)
+):
+    """Delete token"""
+    try:
+        await token_manager.delete_token(token_id)
+        return {"success": True, "message": "Token删除成功"}
+    except Exception as e:
+        raise HTTPException(status_code=500, detail=str(e))
+
+
+@router.post("/api/tokens/{token_id}/enable")
+async def enable_token(
+    token_id: int,
+    token: str = Depends(verify_admin_token)
+):
+    """Enable token"""
+    await token_manager.enable_token(token_id)
+    return {"success": True, "message": "Token已启用"}
+
+
+@router.post("/api/tokens/{token_id}/disable")
+async def disable_token(
+    token_id: int,
+    token: str = Depends(verify_admin_token)
+):
+    """Disable token"""
+    await token_manager.disable_token(token_id)
+    return {"success": True, "message": "Token已禁用"}
+
+
+@router.post("/api/tokens/{token_id}/refresh-credits")
+async def refresh_credits(
+    token_id: int,
+    token: str = Depends(verify_admin_token)
+):
+    """刷新Token余额 🆕"""
+    try:
+        credits = await token_manager.refresh_credits(token_id)
+        return {
+            "success": True,
+            "message": "余额刷新成功",
+            "credits": credits
+        }
+    except Exception as e:
+        raise HTTPException(status_code=500, detail=f"刷新余额失败: {str(e)}")
+
+
+@router.post("/api/tokens/{token_id}/refresh-at")
+async def refresh_at(
+    token_id: int,
+    token: str = Depends(verify_admin_token)
+):
+    """手动刷新Token的AT (使用ST转换) 🆕"""
+    try:
+        # 调用token_manager的内部刷新方法
+        success = await token_manager._refresh_at(token_id)
+
+        if success:
+            # 获取更新后的token信息
+            updated_token = await token_manager.get_token(token_id)
+            return {
+                "success": True,
+                "message": "AT刷新成功",
+                "token": {
+                    "id": updated_token.id,
+                    "email": updated_token.email,
+                    "at_expires": updated_token.at_expires.isoformat() if updated_token.at_expires else None
+                }
+            }
+        else:
+            raise HTTPException(status_code=500, detail="AT刷新失败")
+    except Exception as e:
+        raise HTTPException(status_code=500, detail=f"刷新AT失败: {str(e)}")
+
+
+@router.post("/api/tokens/st2at")
+async def st_to_at(
+    request: ST2ATRequest,
+    token: str = Depends(verify_admin_token)
+):
+    """Convert Session Token to Access Token (仅转换,不添加到数据库)"""
+    try:
+        result = await token_manager.flow_client.st_to_at(request.st)
+        return {
+            "success": True,
+            "message": "ST converted to AT successfully",
+            "access_token": result["access_token"],
+            "email": result.get("user", {}).get("email"),
+            "expires": result.get("expires")
+        }
+    except Exception as e:
+        raise HTTPException(status_code=400, detail=str(e))
+
+
+@router.post("/api/tokens/import")
+async def import_tokens(
+    request: ImportTokensRequest,
+    token: str = Depends(verify_admin_token)
+):
+    """批量导入Token"""
+    from datetime import datetime, timezone
+
+    added = 0
+    updated = 0
+    errors = []
+
+    for idx, item in enumerate(request.tokens):
+        try:
+            st = item.session_token
+
+            if not st:
+                errors.append(f"第{idx+1}项: 缺少 session_token")
+                continue
+
+            # 使用 ST 转 AT 获取用户信息
+            try:
+                result = await token_manager.flow_client.st_to_at(st)
+                at = result["access_token"]
+                email = result.get("user", {}).get("email")
+                expires = result.get("expires")
+
+                if not email:
+                    errors.append(f"第{idx+1}项: 无法获取邮箱信息")
+                    continue
+
+                # 解析过期时间
+                at_expires = None
+                is_expired = False
+                if expires:
+                    try:
+                        at_expires = datetime.fromisoformat(expires.replace('Z', '+00:00'))
+                        # 判断是否过期
+                        now = datetime.now(timezone.utc)
+                        is_expired = at_expires <= now
+                    except:
+                        pass
+
+                # 使用邮箱检查是否已存在
+                existing_tokens = await token_manager.get_all_tokens()
+                existing = next((t for t in existing_tokens if t.email == email), None)
+
+                if existing:
+                    # 更新现有Token
+                    await token_manager.update_token(
+                        token_id=existing.id,
+                        st=st,
+                        at=at,
+                        at_expires=at_expires,
+                        image_enabled=item.image_enabled,
+                        video_enabled=item.video_enabled,
+                        image_concurrency=item.image_concurrency,
+                        video_concurrency=item.video_concurrency
+                    )
+                    # 如果过期则禁用
+                    if is_expired:
+                        await token_manager.disable_token(existing.id)
+                    updated += 1
+                else:
+                    # 添加新Token
+                    new_token = await token_manager.add_token(
+                        st=st,
+                        image_enabled=item.image_enabled,
+                        video_enabled=item.video_enabled,
+                        image_concurrency=item.image_concurrency,
+                        video_concurrency=item.video_concurrency
+                    )
+                    # 如果过期则禁用
+                    if is_expired:
+                        await token_manager.disable_token(new_token.id)
+                    added += 1
+
+            except Exception as e:
+                errors.append(f"第{idx+1}项: {str(e)}")
+
+        except Exception as e:
+            errors.append(f"第{idx+1}项: {str(e)}")
+
+    return {
+        "success": True,
+        "added": added,
+        "updated": updated,
+        "errors": errors if errors else None,
+        "message": f"导入完成: 新增 {added} 个, 更新 {updated} 个" + (f", {len(errors)} 个失败" if errors else "")
+    }
+
+
+# ========== Config Management ==========
+
+@router.get("/api/config/proxy")
+async def get_proxy_config(token: str = Depends(verify_admin_token)):
+    """Get proxy configuration"""
+    config = await proxy_manager.get_proxy_config()
+    return {
+        "success": True,
+        "config": {
+            "enabled": config.enabled,
+            "proxy_url": config.proxy_url
+        }
+    }
+
+
+@router.get("/api/proxy/config")
+async def get_proxy_config_alias(token: str = Depends(verify_admin_token)):
+    """Get proxy configuration (alias for frontend compatibility)"""
+    config = await proxy_manager.get_proxy_config()
+    return {
+        "proxy_enabled": config.enabled,  # Frontend expects proxy_enabled
+        "proxy_url": config.proxy_url
+    }
+
+
+@router.post("/api/proxy/config")
+async def update_proxy_config_alias(
+    request: ProxyConfigRequest,
+    token: str = Depends(verify_admin_token)
+):
+    """Update proxy configuration (alias for frontend compatibility)"""
+    await proxy_manager.update_proxy_config(request.proxy_enabled, request.proxy_url)
+    return {"success": True, "message": "代理配置更新成功"}
+
+
+@router.post("/api/config/proxy")
+async def update_proxy_config(
+    request: ProxyConfigRequest,
+    token: str = Depends(verify_admin_token)
+):
+    """Update proxy configuration"""
+    await proxy_manager.update_proxy_config(request.proxy_enabled, request.proxy_url)
+    return {"success": True, "message": "代理配置更新成功"}
+
+
+@router.get("/api/config/generation")
+async def get_generation_config(token: str = Depends(verify_admin_token)):
+    """Get generation timeout configuration"""
+    config = await db.get_generation_config()
+    return {
+        "success": True,
+        "config": {
+            "image_timeout": config.image_timeout,
+            "video_timeout": config.video_timeout
+        }
+    }
+
+
+@router.post("/api/config/generation")
+async def update_generation_config(
+    request: GenerationConfigRequest,
+    token: str = Depends(verify_admin_token)
+):
+    """Update generation timeout configuration"""
+    await db.update_generation_config(request.image_timeout, request.video_timeout)
+
+    # 🔥 Hot reload: sync database config to memory
+    await db.reload_config_to_memory()
+
+    return {"success": True, "message": "生成配置更新成功"}
+
+
+# ========== System Info ==========
+
+@router.get("/api/system/info")
+async def get_system_info(token: str = Depends(verify_admin_token)):
+    """Get system information"""
+    tokens = await token_manager.get_all_tokens()
+    active_tokens = [t for t in tokens if t.is_active]
+
+    total_credits = sum(t.credits for t in active_tokens)
+
+    return {
+        "success": True,
+        "info": {
+            "total_tokens": len(tokens),
+            "active_tokens": len(active_tokens),
+            "total_credits": total_credits,
+            "version": "1.0.0"
+        }
+    }
+
+
+# ========== Additional Routes for Frontend Compatibility ==========
+
+@router.post("/api/login")
+async def login(request: LoginRequest):
+    """Login endpoint (alias for /api/admin/login)"""
+    return await admin_login(request)
+
+
+@router.post("/api/logout")
+async def logout(token: str = Depends(verify_admin_token)):
+    """Logout endpoint (alias for /api/admin/logout)"""
+    return await admin_logout(token)
+
+
+@router.get("/api/stats")
+async def get_stats(token: str = Depends(verify_admin_token)):
+    """Get statistics for dashboard"""
+    tokens = await token_manager.get_all_tokens()
+    active_tokens = [t for t in tokens if t.is_active]
+
+    # Calculate totals
+    total_images = 0
+    total_videos = 0
+    total_errors = 0
+    today_images = 0
+    today_videos = 0
+    today_errors = 0
+
+    for t in tokens:
+        stats = await db.get_token_stats(t.id)
+        if stats:
+            total_images += stats.image_count
+            total_videos += stats.video_count
+            total_errors += stats.error_count  # Historical total errors
+            today_images += stats.today_image_count
+            today_videos += stats.today_video_count
+            today_errors += stats.today_error_count
+
+    return {
+        "total_tokens": len(tokens),
+        "active_tokens": len(active_tokens),
+        "total_images": total_images,
+        "total_videos": total_videos,
+        "total_errors": total_errors,
+        "today_images": today_images,
+        "today_videos": today_videos,
+        "today_errors": today_errors
+    }
+
+
+@router.get("/api/logs")
+async def get_logs(
+    limit: int = 100,
+    token: str = Depends(verify_admin_token)
+):
+    """Get request logs with token email"""
+    logs = await db.get_logs(limit=limit)
+
+    return [{
+        "id": log.get("id"),
+        "token_id": log.get("token_id"),
+        "token_email": log.get("token_email"),
+        "token_username": log.get("token_username"),
+        "operation": log.get("operation"),
+        "status_code": log.get("status_code"),
+        "duration": log.get("duration"),
+        "created_at": log.get("created_at"),
+        "request_body": log.get("request_body"),
+        "response_body": log.get("response_body")
+    } for log in logs]
+
+
+@router.delete("/api/logs")
+async def clear_logs(token: str = Depends(verify_admin_token)):
+    """Clear all logs"""
+    try:
+        await db.clear_all_logs()
+        return {"success": True, "message": "所有日志已清空"}
+    except Exception as e:
+        raise HTTPException(status_code=500, detail=str(e))
+
+
+@router.get("/api/admin/config")
+async def get_admin_config(token: str = Depends(verify_admin_token)):
+    """Get admin configuration"""
+    admin_config = await db.get_admin_config()
+
+    return {
+        "admin_username": admin_config.username,
+        "api_key": admin_config.api_key,
+        "error_ban_threshold": admin_config.error_ban_threshold,
+        "debug_enabled": config.debug_enabled  # Return actual debug status
+    }
+
+
+@router.post("/api/admin/config")
+async def update_admin_config(
+    request: UpdateAdminConfigRequest,
+    token: str = Depends(verify_admin_token)
+):
+    """Update admin configuration (error_ban_threshold)"""
+    # Update error_ban_threshold in database
+    await db.update_admin_config(error_ban_threshold=request.error_ban_threshold)
+
+    return {"success": True, "message": "配置更新成功"}
+
+
+@router.post("/api/admin/password")
+async def update_admin_password(
+    request: ChangePasswordRequest,
+    token: str = Depends(verify_admin_token)
+):
+    """Update admin password"""
+    return await change_password(request, token)
+
+
+@router.post("/api/admin/apikey")
+async def update_api_key(
+    request: UpdateAPIKeyRequest,
+    token: str = Depends(verify_admin_token)
+):
+    """Update API key (for external API calls, NOT for admin login)"""
+    # Update API key in database
+    await db.update_admin_config(api_key=request.new_api_key)
+
+    # 🔥 Hot reload: sync database config to memory
+    await db.reload_config_to_memory()
+
+    return {"success": True, "message": "API Key更新成功"}
+
+
+@router.post("/api/admin/debug")
+async def update_debug_config(
+    request: UpdateDebugConfigRequest,
+    token: str = Depends(verify_admin_token)
+):
+    """Update debug configuration"""
+    try:
+        # Update in-memory config only (not database)
+        # This ensures debug mode is automatically disabled on restart
+        config.set_debug_enabled(request.enabled)
+
+        status = "enabled" if request.enabled else "disabled"
+        return {"success": True, "message": f"Debug mode {status}", "enabled": request.enabled}
+    except Exception as e:
+        raise HTTPException(status_code=500, detail=f"Failed to update debug config: {str(e)}")
+
+
+@router.get("/api/generation/timeout")
+async def get_generation_timeout(token: str = Depends(verify_admin_token)):
+    """Get generation timeout configuration"""
+    return await get_generation_config(token)
+
+
+@router.post("/api/generation/timeout")
+async def update_generation_timeout(
+    request: GenerationConfigRequest,
+    token: str = Depends(verify_admin_token)
+):
+    """Update generation timeout configuration"""
+    await db.update_generation_config(request.image_timeout, request.video_timeout)
+
+    # 🔥 Hot reload: sync database config to memory
+    await db.reload_config_to_memory()
+
+    return {"success": True, "message": "生成配置更新成功"}
+
+
+# ========== AT Auto Refresh Config ==========
+
+@router.get("/api/token-refresh/config")
+async def get_token_refresh_config(token: str = Depends(verify_admin_token)):
+    """Get AT auto refresh configuration (默认启用)"""
+    return {
+        "success": True,
+        "config": {
+            "at_auto_refresh_enabled": True  # Flow2API默认启用AT自动刷新
+        }
+    }
+
+
+@router.post("/api/token-refresh/enabled")
+async def update_token_refresh_enabled(
+    token: str = Depends(verify_admin_token)
+):
+    """Update AT auto refresh enabled (Flow2API固定启用,此接口仅用于前端兼容)"""
+    return {
+        "success": True,
+        "message": "Flow2API的AT自动刷新默认启用且无法关闭"
+    }
+
+
+# ========== Cache Configuration Endpoints ==========
+
+@router.get("/api/cache/config")
+async def get_cache_config(token: str = Depends(verify_admin_token)):
+    """Get cache configuration"""
+    cache_config = await db.get_cache_config()
+
+    # Calculate effective base URL
+    effective_base_url = cache_config.cache_base_url if cache_config.cache_base_url else f"http://127.0.0.1:8000"
+
+    return {
+        "success": True,
+        "config": {
+            "enabled": cache_config.cache_enabled,
+            "timeout": cache_config.cache_timeout,
+            "base_url": cache_config.cache_base_url or "",
+            "effective_base_url": effective_base_url
+        }
+    }
+
+
+@router.post("/api/cache/enabled")
+async def update_cache_enabled(
+    request: dict,
+    token: str = Depends(verify_admin_token)
+):
+    """Update cache enabled status"""
+    enabled = request.get("enabled", False)
+    await db.update_cache_config(enabled=enabled)
+
+    # 🔥 Hot reload: sync database config to memory
+    await db.reload_config_to_memory()
+
+    return {"success": True, "message": f"缓存已{'启用' if enabled else '禁用'}"}
+
+
+@router.post("/api/cache/config")
+async def update_cache_config_full(
+    request: dict,
+    token: str = Depends(verify_admin_token)
+):
+    """Update complete cache configuration"""
+    enabled = request.get("enabled")
+    timeout = request.get("timeout")
+    base_url = request.get("base_url")
+
+    await db.update_cache_config(enabled=enabled, timeout=timeout, base_url=base_url)
+
+    # 🔥 Hot reload: sync database config to memory
+    await db.reload_config_to_memory()
+
+    return {"success": True, "message": "缓存配置更新成功"}
+
+
+@router.post("/api/cache/base-url")
+async def update_cache_base_url(
+    request: dict,
+    token: str = Depends(verify_admin_token)
+):
+    """Update cache base URL"""
+    base_url = request.get("base_url", "")
+    await db.update_cache_config(base_url=base_url)
+
+    # 🔥 Hot reload: sync database config to memory
+    await db.reload_config_to_memory()
+
+    return {"success": True, "message": "缓存Base URL更新成功"}
+
+
+@router.post("/api/captcha/config")
+async def update_captcha_config(
+    request: dict,
+    token: str = Depends(verify_admin_token)
+):
+    """Update captcha configuration"""
+    from ..services.browser_captcha import validate_browser_proxy_url
+
+    captcha_method = request.get("captcha_method")
+    yescaptcha_api_key = request.get("yescaptcha_api_key")
+    yescaptcha_base_url = request.get("yescaptcha_base_url")
+    browser_proxy_enabled = request.get("browser_proxy_enabled", False)
+    browser_proxy_url = request.get("browser_proxy_url", "")
+
+    # 验证浏览器代理URL格式
+    if browser_proxy_enabled and browser_proxy_url:
+        is_valid, error_msg = validate_browser_proxy_url(browser_proxy_url)
+        if not is_valid:
+            return {"success": False, "message": error_msg}
+
+    await db.update_captcha_config(
+        captcha_method=captcha_method,
+        yescaptcha_api_key=yescaptcha_api_key,
+        yescaptcha_base_url=yescaptcha_base_url,
+        browser_proxy_enabled=browser_proxy_enabled,
+        browser_proxy_url=browser_proxy_url if browser_proxy_enabled else None
+    )
+
+    # 🔥 Hot reload: sync database config to memory
+    await db.reload_config_to_memory()
+
+    return {"success": True, "message": "验证码配置更新成功"}
+
+
+@router.get("/api/captcha/config")
+async def get_captcha_config(token: str = Depends(verify_admin_token)):
+    """Get captcha configuration"""
+    captcha_config = await db.get_captcha_config()
+    return {
+        "captcha_method": captcha_config.captcha_method,
+        "yescaptcha_api_key": captcha_config.yescaptcha_api_key,
+        "yescaptcha_base_url": captcha_config.yescaptcha_base_url,
+        "browser_proxy_enabled": captcha_config.browser_proxy_enabled,
+        "browser_proxy_url": captcha_config.browser_proxy_url or ""
+    }
+
+
+# ========== Plugin Configuration Endpoints ==========
+
+@router.get("/api/plugin/config")
+async def get_plugin_config(request: Request, token: str = Depends(verify_admin_token)):
+    """Get plugin configuration"""
+    plugin_config = await db.get_plugin_config()
+
+    # Get the actual domain and port from the request
+    # This allows the connection URL to reflect the user's actual access path
+    host_header = request.headers.get("host", "")
+
+    # Generate connection URL based on actual request
+    if host_header:
+        # Use the actual domain/IP and port from the request
+        connection_url = f"http://{host_header}/api/plugin/update-token"
+    else:
+        # Fallback to config-based URL
+        from ..core.config import config
+        server_host = config.server_host
+        server_port = config.server_port
+
+        if server_host == "0.0.0.0":
+            connection_url = f"http://127.0.0.1:{server_port}/api/plugin/update-token"
+        else:
+            connection_url = f"http://{server_host}:{server_port}/api/plugin/update-token"
+
+    return {
+        "success": True,
+        "config": {
+            "connection_token": plugin_config.connection_token,
+            "connection_url": connection_url,
+            "auto_enable_on_update": plugin_config.auto_enable_on_update
+        }
+    }
+
+
+@router.post("/api/plugin/config")
+async def update_plugin_config(
+    request: dict,
+    token: str = Depends(verify_admin_token)
+):
+    """Update plugin configuration"""
+    connection_token = request.get("connection_token", "")
+    auto_enable_on_update = request.get("auto_enable_on_update", True)  # 默认开启
+
+    # Generate random token if empty
+    if not connection_token:
+        connection_token = secrets.token_urlsafe(32)
+
+    await db.update_plugin_config(
+        connection_token=connection_token,
+        auto_enable_on_update=auto_enable_on_update
+    )
+
+    return {
+        "success": True,
+        "message": "插件配置更新成功",
+        "connection_token": connection_token,
+        "auto_enable_on_update": auto_enable_on_update
+    }
+
+
+@router.post("/api/plugin/update-token")
+async def plugin_update_token(request: dict, authorization: Optional[str] = Header(None)):
+    """Receive token update from Chrome extension (no admin auth required, uses connection_token)"""
+    # Verify connection token
+    plugin_config = await db.get_plugin_config()
+
+    # Extract token from Authorization header
+    provided_token = None
+    if authorization:
+        if authorization.startswith("Bearer "):
+            provided_token = authorization[7:]
+        else:
+            provided_token = authorization
+
+    # Check if token matches
+    if not plugin_config.connection_token or provided_token != plugin_config.connection_token:
+        raise HTTPException(status_code=401, detail="Invalid connection token")
+
+    # Extract session token from request
+    session_token = request.get("session_token")
+
+    if not session_token:
+        raise HTTPException(status_code=400, detail="Missing session_token")
+
+    # Step 1: Convert ST to AT to get user info (including email)
+    try:
+        result = await token_manager.flow_client.st_to_at(session_token)
+        at = result["access_token"]
+        expires = result.get("expires")
+        user_info = result.get("user", {})
+        email = user_info.get("email", "")
+
+        if not email:
+            raise HTTPException(status_code=400, detail="Failed to get email from session token")
+
+        # Parse expiration time
+        from datetime import datetime
+        at_expires = None
+        if expires:
+            try:
+                at_expires = datetime.fromisoformat(expires.replace('Z', '+00:00'))
+            except:
+                pass
+
+    except Exception as e:
+        raise HTTPException(status_code=400, detail=f"Invalid session token: {str(e)}")
+
+    # Step 2: Check if token with this email exists
+    existing_token = await db.get_token_by_email(email)
+
+    if existing_token:
+        # Update existing token
+        try:
+            # Update token
+            await token_manager.update_token(
+                token_id=existing_token.id,
+                st=session_token,
+                at=at,
+                at_expires=at_expires
+            )
+
+            # Check if auto-enable is enabled and token is disabled
+            if plugin_config.auto_enable_on_update and not existing_token.is_active:
+                await token_manager.enable_token(existing_token.id)
+                return {
+                    "success": True,
+                    "message": f"Token updated and auto-enabled for {email}",
+                    "action": "updated",
+                    "auto_enabled": True
+                }
+
+            return {
+                "success": True,
+                "message": f"Token updated for {email}",
+                "action": "updated"
+            }
+        except Exception as e:
+            raise HTTPException(status_code=500, detail=f"Failed to update token: {str(e)}")
+    else:
+        # Add new token
+        try:
+            new_token = await token_manager.add_token(
+                st=session_token,
+                remark="Added by Chrome Extension"
+            )
+
+            return {
+                "success": True,
+                "message": f"Token added for {new_token.email}",
+                "action": "added",
+                "token_id": new_token.id
+            }
+        except Exception as e:
+            raise HTTPException(status_code=500, detail=f"Failed to add token: {str(e)}")

src/api/routes.py

@@ -0,0 +1,213 @@
+"""API routes - OpenAI compatible endpoints"""
+from fastapi import APIRouter, Depends, HTTPException
+from fastapi.responses import StreamingResponse, JSONResponse
+from typing import List, Optional
+import base64
+import re
+import json
+import time
+from urllib.parse import urlparse
+from curl_cffi.requests import AsyncSession
+from ..core.auth import verify_api_key_header
+from ..core.models import ChatCompletionRequest
+from ..services.generation_handler import GenerationHandler, MODEL_CONFIG
+from ..core.logger import debug_logger
+
+router = APIRouter()
+
+# Dependency injection will be set up in main.py
+generation_handler: GenerationHandler = None
+
+
+def set_generation_handler(handler: GenerationHandler):
+    """Set generation handler instance"""
+    global generation_handler
+    generation_handler = handler
+
+
+async def retrieve_image_data(url: str) -> Optional[bytes]:
+    """
+    智能获取图片数据：
+    1. 优先检查是否为本地 /tmp/ 缓存文件，如果是则直接读取磁盘
+    2. 如果本地不存在或是外部链接，则进行网络下载
+    """
+    # 优先尝试本地读取
+    try:
+        if "/tmp/" in url and generation_handler and generation_handler.file_cache:
+            path = urlparse(url).path
+            filename = path.split("/tmp/")[-1]
+            local_file_path = generation_handler.file_cache.cache_dir / filename
+
+            if local_file_path.exists() and local_file_path.is_file():
+                data = local_file_path.read_bytes()
+                if data:
+                    return data
+    except Exception as e:
+        debug_logger.log_warning(f"[CONTEXT] 本地缓存读取失败: {str(e)}")
+
+    # 回退逻辑：网络下载
+    try:
+        async with AsyncSession() as session:
+            response = await session.get(url, timeout=30, impersonate="chrome110", verify=False)
+            if response.status_code == 200:
+                return response.content
+            else:
+                debug_logger.log_warning(f"[CONTEXT] 图片下载失败，状态码: {response.status_code}")
+    except Exception as e:
+        debug_logger.log_error(f"[CONTEXT] 图片下载异常: {str(e)}")
+
+    return None
+
+
+@router.get("/v1/models")
+async def list_models(api_key: str = Depends(verify_api_key_header)):
+    """List available models"""
+    models = []
+
+    for model_id, config in MODEL_CONFIG.items():
+        description = f"{config['type'].capitalize()} generation"
+        if config['type'] == 'image':
+            description += f" - {config['model_name']}"
+        else:
+            description += f" - {config['model_key']}"
+
+        models.append({
+            "id": model_id,
+            "object": "model",
+            "owned_by": "flow2api",
+            "description": description
+        })
+
+    return {
+        "object": "list",
+        "data": models
+    }
+
+
+@router.post("/v1/chat/completions")
+async def create_chat_completion(
+    request: ChatCompletionRequest,
+    api_key: str = Depends(verify_api_key_header)
+):
+    """Create chat completion (unified endpoint for image and video generation)"""
+    try:
+        # Extract prompt from messages
+        if not request.messages:
+            raise HTTPException(status_code=400, detail="Messages cannot be empty")
+
+        last_message = request.messages[-1]
+        content = last_message.content
+
+        # Handle both string and array format (OpenAI multimodal)
+        prompt = ""
+        images: List[bytes] = []
+
+        if isinstance(content, str):
+            # Simple text format
+            prompt = content
+        elif isinstance(content, list):
+            # Multimodal format
+            for item in content:
+                if item.get("type") == "text":
+                    prompt = item.get("text", "")
+                elif item.get("type") == "image_url":
+                    # Extract base64 image
+                    image_url = item.get("image_url", {}).get("url", "")
+                    if image_url.startswith("data:image"):
+                        # Parse base64
+                        match = re.search(r"base64,(.+)", image_url)
+                        if match:
+                            image_base64 = match.group(1)
+                            image_bytes = base64.b64decode(image_base64)
+                            images.append(image_bytes)
+
+        # Fallback to deprecated image parameter
+        if request.image and not images:
+            if request.image.startswith("data:image"):
+                match = re.search(r"base64,(.+)", request.image)
+                if match:
+                    image_base64 = match.group(1)
+                    image_bytes = base64.b64decode(image_base64)
+                    images.append(image_bytes)
+
+        # 自动参考图：仅对图片模型生效
+        model_config = MODEL_CONFIG.get(request.model)
+
+        if model_config and model_config["type"] == "image" and len(request.messages) > 1:
+            debug_logger.log_info(f"[CONTEXT] 开始查找历史参考图，消息数量: {len(request.messages)}")
+
+            # 查找上一次 assistant 回复的图片
+            for msg in reversed(request.messages[:-1]):
+                if msg.role == "assistant" and isinstance(msg.content, str):
+                    # 匹配 Markdown 图片格式: ![...](http...)
+                    matches = re.findall(r"!\[.*?\]\((.*?)\)", msg.content)
+                    if matches:
+                        last_image_url = matches[-1]
+
+                        if last_image_url.startswith("http"):
+                            try:
+                                downloaded_bytes = await retrieve_image_data(last_image_url)
+                                if downloaded_bytes and len(downloaded_bytes) > 0:
+                                    # 将历史图片插入到最前面
+                                    images.insert(0, downloaded_bytes)
+                                    debug_logger.log_info(f"[CONTEXT] ✅ 添加历史参考图: {last_image_url}")
+                                    break
+                                else:
+                                    debug_logger.log_warning(f"[CONTEXT] 图片下载失败或为空，尝试下一个: {last_image_url}")
+                            except Exception as e:
+                                debug_logger.log_error(f"[CONTEXT] 处理参考图时出错: {str(e)}")
+                                # 继续尝试下一个图片
+
+        if not prompt:
+            raise HTTPException(status_code=400, detail="Prompt cannot be empty")
+
+        # Call generation handler
+        if request.stream:
+            # Streaming response
+            async def generate():
+                async for chunk in generation_handler.handle_generation(
+                    model=request.model,
+                    prompt=prompt,
+                    images=images if images else None,
+                    stream=True
+                ):
+                    yield chunk
+
+                # Send [DONE] signal
+                yield "data: [DONE]\n\n"
+
+            return StreamingResponse(
+                generate(),
+                media_type="text/event-stream",
+                headers={
+                    "Cache-Control": "no-cache",
+                    "Connection": "keep-alive",
+                    "X-Accel-Buffering": "no"
+                }
+            )
+        else:
+            # Non-streaming response
+            result = None
+            async for chunk in generation_handler.handle_generation(
+                model=request.model,
+                prompt=prompt,
+                images=images if images else None,
+                stream=False
+            ):
+                result = chunk
+
+            if result:
+                # Parse the result JSON string
+                try:
+                    result_json = json.loads(result)
+                    return JSONResponse(content=result_json)
+                except json.JSONDecodeError:
+                    # If not JSON, return as-is
+                    return JSONResponse(content={"result": result})
+            else:
+                raise HTTPException(status_code=500, detail="Generation failed: No response from handler")
+
+    except HTTPException:
+        raise
+    except Exception as e:
+        raise HTTPException(status_code=500, detail=str(e))

src/core/__init__.py

@@ -0,0 +1,7 @@
+"""Core modules"""
+
+from .config import config
+from .auth import AuthManager, verify_api_key_header
+from .logger import debug_logger
+
+__all__ = ["config", "AuthManager", "verify_api_key_header", "debug_logger"]

src/core/auth.py

@@ -0,0 +1,39 @@
+"""Authentication module"""
+import bcrypt
+from typing import Optional
+from fastapi import HTTPException, Security
+from fastapi.security import HTTPBearer, HTTPAuthorizationCredentials
+from .config import config
+
+security = HTTPBearer()
+
+class AuthManager:
+    """Authentication manager"""
+
+    @staticmethod
+    def verify_api_key(api_key: str) -> bool:
+        """Verify API key"""
+        return api_key == config.api_key
+
+    @staticmethod
+    def verify_admin(username: str, password: str) -> bool:
+        """Verify admin credentials"""
+        # Compare with current config (which may be from database or config file)
+        return username == config.admin_username and password == config.admin_password
+
+    @staticmethod
+    def hash_password(password: str) -> str:
+        """Hash password"""
+        return bcrypt.hashpw(password.encode(), bcrypt.gensalt()).decode()
+
+    @staticmethod
+    def verify_password(password: str, hashed: str) -> bool:
+        """Verify password"""
+        return bcrypt.checkpw(password.encode(), hashed.encode())
+
+async def verify_api_key_header(credentials: HTTPAuthorizationCredentials = Security(security)) -> str:
+    """Verify API key from Authorization header"""
+    api_key = credentials.credentials
+    if not AuthManager.verify_api_key(api_key):
+        raise HTTPException(status_code=401, detail="Invalid API key")
+    return api_key

src/core/config.py

@@ -0,0 +1,218 @@
+"""Configuration management for Flow2API"""
+import tomli
+from pathlib import Path
+from typing import Dict, Any, Optional
+
+class Config:
+    """Application configuration"""
+
+    def __init__(self):
+        self._config = self._load_config()
+        self._admin_username: Optional[str] = None
+        self._admin_password: Optional[str] = None
+
+    def _load_config(self) -> Dict[str, Any]:
+        """Load configuration from setting.toml"""
+        config_path = Path(__file__).parent.parent.parent / "config" / "setting.toml"
+        with open(config_path, "rb") as f:
+            return tomli.load(f)
+
+    def reload_config(self):
+        """Reload configuration from file"""
+        self._config = self._load_config()
+
+    def get_raw_config(self) -> Dict[str, Any]:
+        """Get raw configuration dictionary"""
+        return self._config
+
+    @property
+    def admin_username(self) -> str:
+        # If admin_username is set from database, use it; otherwise fall back to config file
+        if self._admin_username is not None:
+            return self._admin_username
+        return self._config["global"]["admin_username"]
+
+    @admin_username.setter
+    def admin_username(self, value: str):
+        self._admin_username = value
+        self._config["global"]["admin_username"] = value
+
+    def set_admin_username_from_db(self, username: str):
+        """Set admin username from database"""
+        self._admin_username = username
+
+    # Flow2API specific properties
+    @property
+    def flow_labs_base_url(self) -> str:
+        """Google Labs base URL for project management"""
+        return self._config["flow"]["labs_base_url"]
+
+    @property
+    def flow_api_base_url(self) -> str:
+        """Google AI Sandbox API base URL for generation"""
+        return self._config["flow"]["api_base_url"]
+
+    @property
+    def flow_timeout(self) -> int:
+        return self._config["flow"]["timeout"]
+
+    @property
+    def flow_max_retries(self) -> int:
+        return self._config["flow"]["max_retries"]
+
+    @property
+    def poll_interval(self) -> float:
+        return self._config["flow"]["poll_interval"]
+
+    @property
+    def max_poll_attempts(self) -> int:
+        return self._config["flow"]["max_poll_attempts"]
+
+    @property
+    def server_host(self) -> str:
+        return self._config["server"]["host"]
+
+    @property
+    def server_port(self) -> int:
+        return self._config["server"]["port"]
+
+    @property
+    def debug_enabled(self) -> bool:
+        return self._config.get("debug", {}).get("enabled", False)
+
+    @property
+    def debug_log_requests(self) -> bool:
+        return self._config.get("debug", {}).get("log_requests", True)
+
+    @property
+    def debug_log_responses(self) -> bool:
+        return self._config.get("debug", {}).get("log_responses", True)
+
+    @property
+    def debug_mask_token(self) -> bool:
+        return self._config.get("debug", {}).get("mask_token", True)
+
+    # Mutable properties for runtime updates
+    @property
+    def api_key(self) -> str:
+        return self._config["global"]["api_key"]
+
+    @api_key.setter
+    def api_key(self, value: str):
+        self._config["global"]["api_key"] = value
+
+    @property
+    def admin_password(self) -> str:
+        # If admin_password is set from database, use it; otherwise fall back to config file
+        if self._admin_password is not None:
+            return self._admin_password
+        return self._config["global"]["admin_password"]
+
+    @admin_password.setter
+    def admin_password(self, value: str):
+        self._admin_password = value
+        self._config["global"]["admin_password"] = value
+
+    def set_admin_password_from_db(self, password: str):
+        """Set admin password from database"""
+        self._admin_password = password
+
+    def set_debug_enabled(self, enabled: bool):
+        """Set debug mode enabled/disabled"""
+        if "debug" not in self._config:
+            self._config["debug"] = {}
+        self._config["debug"]["enabled"] = enabled
+
+    @property
+    def image_timeout(self) -> int:
+        """Get image generation timeout in seconds"""
+        return self._config.get("generation", {}).get("image_timeout", 300)
+
+    def set_image_timeout(self, timeout: int):
+        """Set image generation timeout in seconds"""
+        if "generation" not in self._config:
+            self._config["generation"] = {}
+        self._config["generation"]["image_timeout"] = timeout
+
+    @property
+    def video_timeout(self) -> int:
+        """Get video generation timeout in seconds"""
+        return self._config.get("generation", {}).get("video_timeout", 1500)
+
+    def set_video_timeout(self, timeout: int):
+        """Set video generation timeout in seconds"""
+        if "generation" not in self._config:
+            self._config["generation"] = {}
+        self._config["generation"]["video_timeout"] = timeout
+
+    # Cache configuration
+    @property
+    def cache_enabled(self) -> bool:
+        """Get cache enabled status"""
+        return self._config.get("cache", {}).get("enabled", False)
+
+    def set_cache_enabled(self, enabled: bool):
+        """Set cache enabled status"""
+        if "cache" not in self._config:
+            self._config["cache"] = {}
+        self._config["cache"]["enabled"] = enabled
+
+    @property
+    def cache_timeout(self) -> int:
+        """Get cache timeout in seconds"""
+        return self._config.get("cache", {}).get("timeout", 7200)
+
+    def set_cache_timeout(self, timeout: int):
+        """Set cache timeout in seconds"""
+        if "cache" not in self._config:
+            self._config["cache"] = {}
+        self._config["cache"]["timeout"] = timeout
+
+    @property
+    def cache_base_url(self) -> str:
+        """Get cache base URL"""
+        return self._config.get("cache", {}).get("base_url", "")
+
+    def set_cache_base_url(self, base_url: str):
+        """Set cache base URL"""
+        if "cache" not in self._config:
+            self._config["cache"] = {}
+        self._config["cache"]["base_url"] = base_url
+
+    # Captcha configuration
+    @property
+    def captcha_method(self) -> str:
+        """Get captcha method"""
+        return self._config.get("captcha", {}).get("captcha_method", "yescaptcha")
+
+    def set_captcha_method(self, method: str):
+        """Set captcha method"""
+        if "captcha" not in self._config:
+            self._config["captcha"] = {}
+        self._config["captcha"]["captcha_method"] = method
+
+    @property
+    def yescaptcha_api_key(self) -> str:
+        """Get YesCaptcha API key"""
+        return self._config.get("captcha", {}).get("yescaptcha_api_key", "")
+
+    def set_yescaptcha_api_key(self, api_key: str):
+        """Set YesCaptcha API key"""
+        if "captcha" not in self._config:
+            self._config["captcha"] = {}
+        self._config["captcha"]["yescaptcha_api_key"] = api_key
+
+    @property
+    def yescaptcha_base_url(self) -> str:
+        """Get YesCaptcha base URL"""
+        return self._config.get("captcha", {}).get("yescaptcha_base_url", "https://api.yescaptcha.com")
+
+    def set_yescaptcha_base_url(self, base_url: str):
+        """Set YesCaptcha base URL"""
+        if "captcha" not in self._config:
+            self._config["captcha"] = {}
+        self._config["captcha"]["yescaptcha_base_url"] = base_url
+
+
+# Global config instance
+config = Config()

src/core/database.py

@@ -0,0 +1,1269 @@
+"""Database storage layer for Flow2API"""
+import aiosqlite
+import json
+from datetime import datetime
+from typing import Optional, List
+from pathlib import Path
+from .models import Token, TokenStats, Task, RequestLog, AdminConfig, ProxyConfig, GenerationConfig, CacheConfig, Project, CaptchaConfig, PluginConfig
+
+
+class Database:
+    """SQLite database manager"""
+
+    def __init__(self, db_path: str = None):
+        if db_path is None:
+            # Store database in data directory
+            data_dir = Path(__file__).parent.parent.parent / "data"
+            data_dir.mkdir(exist_ok=True)
+            db_path = str(data_dir / "flow.db")
+        self.db_path = db_path
+
+    def db_exists(self) -> bool:
+        """Check if database file exists"""
+        return Path(self.db_path).exists()
+
+    async def _table_exists(self, db, table_name: str) -> bool:
+        """Check if a table exists in the database"""
+        cursor = await db.execute(
+            "SELECT name FROM sqlite_master WHERE type='table' AND name=?",
+            (table_name,)
+        )
+        result = await cursor.fetchone()
+        return result is not None
+
+    async def _column_exists(self, db, table_name: str, column_name: str) -> bool:
+        """Check if a column exists in a table"""
+        try:
+            cursor = await db.execute(f"PRAGMA table_info({table_name})")
+            columns = await cursor.fetchall()
+            return any(col[1] == column_name for col in columns)
+        except:
+            return False
+
+    async def _ensure_config_rows(self, db, config_dict: dict = None):
+        """Ensure all config tables have their default rows
+
+        Args:
+            db: Database connection
+            config_dict: Configuration dictionary from setting.toml (optional)
+                        If None, use default values instead of reading from TOML.
+        """
+        # Ensure admin_config has a row
+        cursor = await db.execute("SELECT COUNT(*) FROM admin_config")
+        count = await cursor.fetchone()
+        if count[0] == 0:
+            admin_username = "admin"
+            admin_password = "admin"
+            api_key = "han1234"
+            error_ban_threshold = 3
+
+            if config_dict:
+                global_config = config_dict.get("global", {})
+                admin_username = global_config.get("admin_username", "admin")
+                admin_password = global_config.get("admin_password", "admin")
+                api_key = global_config.get("api_key", "han1234")
+
+                admin_config = config_dict.get("admin", {})
+                error_ban_threshold = admin_config.get("error_ban_threshold", 3)
+
+            await db.execute("""
+                INSERT INTO admin_config (id, username, password, api_key, error_ban_threshold)
+                VALUES (1, ?, ?, ?, ?)
+            """, (admin_username, admin_password, api_key, error_ban_threshold))
+
+        # Ensure proxy_config has a row
+        cursor = await db.execute("SELECT COUNT(*) FROM proxy_config")
+        count = await cursor.fetchone()
+        if count[0] == 0:
+            proxy_enabled = False
+            proxy_url = None
+
+            if config_dict:
+                proxy_config = config_dict.get("proxy", {})
+                proxy_enabled = proxy_config.get("proxy_enabled", False)
+                proxy_url = proxy_config.get("proxy_url", "")
+                proxy_url = proxy_url if proxy_url else None
+
+            await db.execute("""
+                INSERT INTO proxy_config (id, enabled, proxy_url)
+                VALUES (1, ?, ?)
+            """, (proxy_enabled, proxy_url))
+
+        # Ensure generation_config has a row
+        cursor = await db.execute("SELECT COUNT(*) FROM generation_config")
+        count = await cursor.fetchone()
+        if count[0] == 0:
+            image_timeout = 300
+            video_timeout = 1500
+
+            if config_dict:
+                generation_config = config_dict.get("generation", {})
+                image_timeout = generation_config.get("image_timeout", 300)
+                video_timeout = generation_config.get("video_timeout", 1500)
+
+            await db.execute("""
+                INSERT INTO generation_config (id, image_timeout, video_timeout)
+                VALUES (1, ?, ?)
+            """, (image_timeout, video_timeout))
+
+        # Ensure cache_config has a row
+        cursor = await db.execute("SELECT COUNT(*) FROM cache_config")
+        count = await cursor.fetchone()
+        if count[0] == 0:
+            cache_enabled = False
+            cache_timeout = 7200
+            cache_base_url = None
+
+            if config_dict:
+                cache_config = config_dict.get("cache", {})
+                cache_enabled = cache_config.get("enabled", False)
+                cache_timeout = cache_config.get("timeout", 7200)
+                cache_base_url = cache_config.get("base_url", "")
+                # Convert empty string to None
+                cache_base_url = cache_base_url if cache_base_url else None
+
+            await db.execute("""
+                INSERT INTO cache_config (id, cache_enabled, cache_timeout, cache_base_url)
+                VALUES (1, ?, ?, ?)
+            """, (cache_enabled, cache_timeout, cache_base_url))
+
+        # Ensure debug_config has a row
+        cursor = await db.execute("SELECT COUNT(*) FROM debug_config")
+        count = await cursor.fetchone()
+        if count[0] == 0:
+            debug_enabled = False
+            log_requests = True
+            log_responses = True
+            mask_token = True
+
+            if config_dict:
+                debug_config = config_dict.get("debug", {})
+                debug_enabled = debug_config.get("enabled", False)
+                log_requests = debug_config.get("log_requests", True)
+                log_responses = debug_config.get("log_responses", True)
+                mask_token = debug_config.get("mask_token", True)
+
+            await db.execute("""
+                INSERT INTO debug_config (id, enabled, log_requests, log_responses, mask_token)
+                VALUES (1, ?, ?, ?, ?)
+            """, (debug_enabled, log_requests, log_responses, mask_token))
+
+        # Ensure captcha_config has a row
+        cursor = await db.execute("SELECT COUNT(*) FROM captcha_config")
+        count = await cursor.fetchone()
+        if count[0] == 0:
+            captcha_method = "browser"
+            yescaptcha_api_key = ""
+            yescaptcha_base_url = "https://api.yescaptcha.com"
+
+            if config_dict:
+                captcha_config = config_dict.get("captcha", {})
+                captcha_method = captcha_config.get("captcha_method", "browser")
+                yescaptcha_api_key = captcha_config.get("yescaptcha_api_key", "")
+                yescaptcha_base_url = captcha_config.get("yescaptcha_base_url", "https://api.yescaptcha.com")
+
+            await db.execute("""
+                INSERT INTO captcha_config (id, captcha_method, yescaptcha_api_key, yescaptcha_base_url)
+                VALUES (1, ?, ?, ?)
+            """, (captcha_method, yescaptcha_api_key, yescaptcha_base_url))
+
+        # Ensure plugin_config has a row
+        cursor = await db.execute("SELECT COUNT(*) FROM plugin_config")
+        count = await cursor.fetchone()
+        if count[0] == 0:
+            await db.execute("""
+                INSERT INTO plugin_config (id, connection_token)
+                VALUES (1, '')
+            """)
+
+    async def check_and_migrate_db(self, config_dict: dict = None):
+        """Check database integrity and perform migrations if needed
+
+        This method is called during upgrade mode to:
+        1. Create missing tables (if they don't exist)
+        2. Add missing columns to existing tables
+        3. Ensure all config tables have default rows
+
+        Args:
+            config_dict: Configuration dictionary from setting.toml (optional)
+                        Used only to initialize missing config rows with default values.
+                        Existing config rows will NOT be overwritten.
+        """
+        async with aiosqlite.connect(self.db_path) as db:
+            print("Checking database integrity and performing migrations...")
+
+            # ========== Step 1: Create missing tables ==========
+            # Check and create cache_config table if missing
+            if not await self._table_exists(db, "cache_config"):
+                print("  ✓ Creating missing table: cache_config")
+                await db.execute("""
+                    CREATE TABLE cache_config (
+                        id INTEGER PRIMARY KEY DEFAULT 1,
+                        cache_enabled BOOLEAN DEFAULT 0,
+                        cache_timeout INTEGER DEFAULT 7200,
+                        cache_base_url TEXT,
+                        created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP,
+                        updated_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP
+                    )
+                """)
+
+            # Check and create captcha_config table if missing
+            if not await self._table_exists(db, "captcha_config"):
+                print("  ✓ Creating missing table: captcha_config")
+                await db.execute("""
+                    CREATE TABLE captcha_config (
+                        id INTEGER PRIMARY KEY DEFAULT 1,
+                        captcha_method TEXT DEFAULT 'browser',
+                        yescaptcha_api_key TEXT DEFAULT '',
+                        yescaptcha_base_url TEXT DEFAULT 'https://api.yescaptcha.com',
+                        website_key TEXT DEFAULT '6LdsFiUsAAAAAIjVDZcuLhaHiDn5nnHVXVRQGeMV',
+                        page_action TEXT DEFAULT 'FLOW_GENERATION',
+                        browser_proxy_enabled BOOLEAN DEFAULT 0,
+                        browser_proxy_url TEXT,
+                        created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP,
+                        updated_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP
+                    )
+                """)
+
+            # Check and create plugin_config table if missing
+            if not await self._table_exists(db, "plugin_config"):
+                print("  ✓ Creating missing table: plugin_config")
+                await db.execute("""
+                    CREATE TABLE plugin_config (
+                        id INTEGER PRIMARY KEY DEFAULT 1,
+                        connection_token TEXT DEFAULT '',
+                        created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP,
+                        updated_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP
+                    )
+                """)
+
+            # ========== Step 2: Add missing columns to existing tables ==========
+            # Check and add missing columns to tokens table
+            if await self._table_exists(db, "tokens"):
+                columns_to_add = [
+                    ("at", "TEXT"),  # Access Token
+                    ("at_expires", "TIMESTAMP"),  # AT expiration time
+                    ("credits", "INTEGER DEFAULT 0"),  # Balance
+                    ("user_paygate_tier", "TEXT"),  # User tier
+                    ("current_project_id", "TEXT"),  # Current project UUID
+                    ("current_project_name", "TEXT"),  # Project name
+                    ("image_enabled", "BOOLEAN DEFAULT 1"),
+                    ("video_enabled", "BOOLEAN DEFAULT 1"),
+                    ("image_concurrency", "INTEGER DEFAULT -1"),
+                    ("video_concurrency", "INTEGER DEFAULT -1"),
+                    ("ban_reason", "TEXT"),  # 禁用原因
+                    ("banned_at", "TIMESTAMP"),  # 禁用时间
+                ]
+
+                for col_name, col_type in columns_to_add:
+                    if not await self._column_exists(db, "tokens", col_name):
+                        try:
+                            await db.execute(f"ALTER TABLE tokens ADD COLUMN {col_name} {col_type}")
+                            print(f"  ✓ Added column '{col_name}' to tokens table")
+                        except Exception as e:
+                            print(f"  ✗ Failed to add column '{col_name}': {e}")
+
+            # Check and add missing columns to admin_config table
+            if await self._table_exists(db, "admin_config"):
+                if not await self._column_exists(db, "admin_config", "error_ban_threshold"):
+                    try:
+                        await db.execute("ALTER TABLE admin_config ADD COLUMN error_ban_threshold INTEGER DEFAULT 3")
+                        print("  ✓ Added column 'error_ban_threshold' to admin_config table")
+                    except Exception as e:
+                        print(f"  ✗ Failed to add column 'error_ban_threshold': {e}")
+
+            # Check and add missing columns to captcha_config table
+            if await self._table_exists(db, "captcha_config"):
+                captcha_columns_to_add = [
+                    ("browser_proxy_enabled", "BOOLEAN DEFAULT 0"),
+                    ("browser_proxy_url", "TEXT"),
+                ]
+
+                for col_name, col_type in captcha_columns_to_add:
+                    if not await self._column_exists(db, "captcha_config", col_name):
+                        try:
+                            await db.execute(f"ALTER TABLE captcha_config ADD COLUMN {col_name} {col_type}")
+                            print(f"  ✓ Added column '{col_name}' to captcha_config table")
+                        except Exception as e:
+                            print(f"  ✗ Failed to add column '{col_name}': {e}")
+
+            # Check and add missing columns to token_stats table
+            if await self._table_exists(db, "token_stats"):
+                stats_columns_to_add = [
+                    ("today_image_count", "INTEGER DEFAULT 0"),
+                    ("today_video_count", "INTEGER DEFAULT 0"),
+                    ("today_error_count", "INTEGER DEFAULT 0"),
+                    ("today_date", "DATE"),
+                    ("consecutive_error_count", "INTEGER DEFAULT 0"),  # 🆕 连续错误计数
+                ]
+
+                for col_name, col_type in stats_columns_to_add:
+                    if not await self._column_exists(db, "token_stats", col_name):
+                        try:
+                            await db.execute(f"ALTER TABLE token_stats ADD COLUMN {col_name} {col_type}")
+                            print(f"  ✓ Added column '{col_name}' to token_stats table")
+                        except Exception as e:
+                            print(f"  ✗ Failed to add column '{col_name}': {e}")
+
+            # Check and add missing columns to plugin_config table
+            if await self._table_exists(db, "plugin_config"):
+                plugin_columns_to_add = [
+                    ("auto_enable_on_update", "BOOLEAN DEFAULT 1"),  # 默认开启
+                ]
+
+                for col_name, col_type in plugin_columns_to_add:
+                    if not await self._column_exists(db, "plugin_config", col_name):
+                        try:
+                            await db.execute(f"ALTER TABLE plugin_config ADD COLUMN {col_name} {col_type}")
+                            print(f"  ✓ Added column '{col_name}' to plugin_config table")
+                        except Exception as e:
+                            print(f"  ✗ Failed to add column '{col_name}': {e}")
+
+            # ========== Step 3: Ensure all config tables have default rows ==========
+            # Note: This will NOT overwrite existing config rows
+            # It only ensures missing rows are created with default values from setting.toml
+            await self._ensure_config_rows(db, config_dict=config_dict)
+
+            await db.commit()
+            print("Database migration check completed.")
+
+    async def init_db(self):
+        """Initialize database tables"""
+        async with aiosqlite.connect(self.db_path) as db:
+            # Tokens table (Flow2API版本)
+            await db.execute("""
+                CREATE TABLE IF NOT EXISTS tokens (
+                    id INTEGER PRIMARY KEY AUTOINCREMENT,
+                    st TEXT UNIQUE NOT NULL,
+                    at TEXT,
+                    at_expires TIMESTAMP,
+                    email TEXT NOT NULL,
+                    name TEXT,
+                    remark TEXT,
+                    is_active BOOLEAN DEFAULT 1,
+                    created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP,
+                    last_used_at TIMESTAMP,
+                    use_count INTEGER DEFAULT 0,
+                    credits INTEGER DEFAULT 0,
+                    user_paygate_tier TEXT,
+                    current_project_id TEXT,
+                    current_project_name TEXT,
+                    image_enabled BOOLEAN DEFAULT 1,
+                    video_enabled BOOLEAN DEFAULT 1,
+                    image_concurrency INTEGER DEFAULT -1,
+                    video_concurrency INTEGER DEFAULT -1,
+                    ban_reason TEXT,
+                    banned_at TIMESTAMP
+                )
+            """)
+
+            # Projects table (新增)
+            await db.execute("""
+                CREATE TABLE IF NOT EXISTS projects (
+                    id INTEGER PRIMARY KEY AUTOINCREMENT,
+                    project_id TEXT UNIQUE NOT NULL,
+                    token_id INTEGER NOT NULL,
+                    project_name TEXT NOT NULL,
+                    tool_name TEXT DEFAULT 'PINHOLE',
+                    is_active BOOLEAN DEFAULT 1,
+                    created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP,
+                    FOREIGN KEY (token_id) REFERENCES tokens(id)
+                )
+            """)
+
+            # Token stats table
+            await db.execute("""
+                CREATE TABLE IF NOT EXISTS token_stats (
+                    id INTEGER PRIMARY KEY AUTOINCREMENT,
+                    token_id INTEGER NOT NULL,
+                    image_count INTEGER DEFAULT 0,
+                    video_count INTEGER DEFAULT 0,
+                    success_count INTEGER DEFAULT 0,
+                    error_count INTEGER DEFAULT 0,
+                    last_success_at TIMESTAMP,
+                    last_error_at TIMESTAMP,
+                    today_image_count INTEGER DEFAULT 0,
+                    today_video_count INTEGER DEFAULT 0,
+                    today_error_count INTEGER DEFAULT 0,
+                    today_date DATE,
+                    consecutive_error_count INTEGER DEFAULT 0,
+                    FOREIGN KEY (token_id) REFERENCES tokens(id)
+                )
+            """)
+
+            # Tasks table
+            await db.execute("""
+                CREATE TABLE IF NOT EXISTS tasks (
+                    id INTEGER PRIMARY KEY AUTOINCREMENT,
+                    task_id TEXT UNIQUE NOT NULL,
+                    token_id INTEGER NOT NULL,
+                    model TEXT NOT NULL,
+                    prompt TEXT NOT NULL,
+                    status TEXT NOT NULL DEFAULT 'processing',
+                    progress INTEGER DEFAULT 0,
+                    result_urls TEXT,
+                    error_message TEXT,
+                    scene_id TEXT,
+                    created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP,
+                    completed_at TIMESTAMP,
+                    FOREIGN KEY (token_id) REFERENCES tokens(id)
+                )
+            """)
+
+            # Request logs table
+            await db.execute("""
+                CREATE TABLE IF NOT EXISTS request_logs (
+                    id INTEGER PRIMARY KEY AUTOINCREMENT,
+                    token_id INTEGER,
+                    operation TEXT NOT NULL,
+                    request_body TEXT,
+                    response_body TEXT,
+                    status_code INTEGER NOT NULL,
+                    duration FLOAT NOT NULL,
+                    created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP,
+                    FOREIGN KEY (token_id) REFERENCES tokens(id)
+                )
+            """)
+
+            # Admin config table
+            await db.execute("""
+                CREATE TABLE IF NOT EXISTS admin_config (
+                    id INTEGER PRIMARY KEY DEFAULT 1,
+                    username TEXT DEFAULT 'admin',
+                    password TEXT DEFAULT 'admin',
+                    api_key TEXT DEFAULT 'han1234',
+                    error_ban_threshold INTEGER DEFAULT 3,
+                    updated_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP
+                )
+            """)
+
+            # Proxy config table
+            await db.execute("""
+                CREATE TABLE IF NOT EXISTS proxy_config (
+                    id INTEGER PRIMARY KEY DEFAULT 1,
+                    enabled BOOLEAN DEFAULT 0,
+                    proxy_url TEXT,
+                    updated_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP
+                )
+            """)
+
+            # Generation config table
+            await db.execute("""
+                CREATE TABLE IF NOT EXISTS generation_config (
+                    id INTEGER PRIMARY KEY DEFAULT 1,
+                    image_timeout INTEGER DEFAULT 300,
+                    video_timeout INTEGER DEFAULT 1500,
+                    updated_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP
+                )
+            """)
+
+            # Cache config table
+            await db.execute("""
+                CREATE TABLE IF NOT EXISTS cache_config (
+                    id INTEGER PRIMARY KEY DEFAULT 1,
+                    cache_enabled BOOLEAN DEFAULT 0,
+                    cache_timeout INTEGER DEFAULT 7200,
+                    cache_base_url TEXT,
+                    created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP,
+                    updated_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP
+                )
+            """)
+
+            # Debug config table
+            await db.execute("""
+                CREATE TABLE IF NOT EXISTS debug_config (
+                    id INTEGER PRIMARY KEY DEFAULT 1,
+                    enabled BOOLEAN DEFAULT 0,
+                    log_requests BOOLEAN DEFAULT 1,
+                    log_responses BOOLEAN DEFAULT 1,
+                    mask_token BOOLEAN DEFAULT 1,
+                    created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP,
+                    updated_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP
+                )
+            """)
+
+            # Captcha config table
+            await db.execute("""
+                CREATE TABLE IF NOT EXISTS captcha_config (
+                    id INTEGER PRIMARY KEY DEFAULT 1,
+                    captcha_method TEXT DEFAULT 'browser',
+                    yescaptcha_api_key TEXT DEFAULT '',
+                    yescaptcha_base_url TEXT DEFAULT 'https://api.yescaptcha.com',
+                    website_key TEXT DEFAULT '6LdsFiUsAAAAAIjVDZcuLhaHiDn5nnHVXVRQGeMV',
+                    page_action TEXT DEFAULT 'FLOW_GENERATION',
+                    browser_proxy_enabled BOOLEAN DEFAULT 0,
+                    browser_proxy_url TEXT,
+                    created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP,
+                    updated_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP
+                )
+            """)
+
+            # Plugin config table
+            await db.execute("""
+                CREATE TABLE IF NOT EXISTS plugin_config (
+                    id INTEGER PRIMARY KEY DEFAULT 1,
+                    connection_token TEXT DEFAULT '',
+                    created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP,
+                    updated_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP
+                )
+            """)
+
+            # Create indexes
+            await db.execute("CREATE INDEX IF NOT EXISTS idx_task_id ON tasks(task_id)")
+            await db.execute("CREATE INDEX IF NOT EXISTS idx_token_st ON tokens(st)")
+            await db.execute("CREATE INDEX IF NOT EXISTS idx_project_id ON projects(project_id)")
+
+            # Migrate request_logs table if needed
+            await self._migrate_request_logs(db)
+
+            await db.commit()
+
+    async def _migrate_request_logs(self, db):
+        """Migrate request_logs table from old schema to new schema"""
+        try:
+            # Check if old columns exist
+            has_model = await self._column_exists(db, "request_logs", "model")
+            has_operation = await self._column_exists(db, "request_logs", "operation")
+
+            if has_model and not has_operation:
+                # Old schema detected, need migration
+                print("🔄 检测到旧的request_logs表结构,开始迁移...")
+
+                # Rename old table
+                await db.execute("ALTER TABLE request_logs RENAME TO request_logs_old")
+
+                # Create new table with new schema
+                await db.execute("""
+                    CREATE TABLE request_logs (
+                        id INTEGER PRIMARY KEY AUTOINCREMENT,
+                        token_id INTEGER,
+                        operation TEXT NOT NULL,
+                        request_body TEXT,
+                        response_body TEXT,
+                        status_code INTEGER NOT NULL,
+                        duration FLOAT NOT NULL,
+                        created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP,
+                        FOREIGN KEY (token_id) REFERENCES tokens(id)
+                    )
+                """)
+
+                # Migrate data from old table (basic migration)
+                await db.execute("""
+                    INSERT INTO request_logs (token_id, operation, request_body, status_code, duration, created_at)
+                    SELECT
+                        token_id,
+                        model as operation,
+                        json_object('model', model, 'prompt', substr(prompt, 1, 100)) as request_body,
+                        CASE
+                            WHEN status = 'completed' THEN 200
+                            WHEN status = 'failed' THEN 500
+                            ELSE 0
+                        END as status_code,
+                        response_time as duration,
+                        created_at
+                    FROM request_logs_old
+                """)
+
+                # Drop old table
+                await db.execute("DROP TABLE request_logs_old")
+
+                print("✅ request_logs表迁移完成")
+        except Exception as e:
+            print(f"⚠️ request_logs表迁移失败: {e}")
+            # Continue even if migration fails
+
+    # Token operations
+    async def add_token(self, token: Token) -> int:
+        """Add a new token"""
+        async with aiosqlite.connect(self.db_path) as db:
+            cursor = await db.execute("""
+                INSERT INTO tokens (st, at, at_expires, email, name, remark, is_active,
+                                   credits, user_paygate_tier, current_project_id, current_project_name,
+                                   image_enabled, video_enabled, image_concurrency, video_concurrency)
+                VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
+            """, (token.st, token.at, token.at_expires, token.email, token.name, token.remark,
+                  token.is_active, token.credits, token.user_paygate_tier,
+                  token.current_project_id, token.current_project_name,
+                  token.image_enabled, token.video_enabled,
+                  token.image_concurrency, token.video_concurrency))
+            await db.commit()
+            token_id = cursor.lastrowid
+
+            # Create stats entry
+            await db.execute("""
+                INSERT INTO token_stats (token_id) VALUES (?)
+            """, (token_id,))
+            await db.commit()
+
+            return token_id
+
+    async def get_token(self, token_id: int) -> Optional[Token]:
+        """Get token by ID"""
+        async with aiosqlite.connect(self.db_path) as db:
+            db.row_factory = aiosqlite.Row
+            cursor = await db.execute("SELECT * FROM tokens WHERE id = ?", (token_id,))
+            row = await cursor.fetchone()
+            if row:
+                return Token(**dict(row))
+            return None
+
+    async def get_token_by_st(self, st: str) -> Optional[Token]:
+        """Get token by ST"""
+        async with aiosqlite.connect(self.db_path) as db:
+            db.row_factory = aiosqlite.Row
+            cursor = await db.execute("SELECT * FROM tokens WHERE st = ?", (st,))
+            row = await cursor.fetchone()
+            if row:
+                return Token(**dict(row))
+            return None
+
+    async def get_token_by_email(self, email: str) -> Optional[Token]:
+        """Get token by email"""
+        async with aiosqlite.connect(self.db_path) as db:
+            db.row_factory = aiosqlite.Row
+            cursor = await db.execute("SELECT * FROM tokens WHERE email = ?", (email,))
+            row = await cursor.fetchone()
+            if row:
+                return Token(**dict(row))
+            return None
+
+    async def get_all_tokens(self) -> List[Token]:
+        """Get all tokens"""
+        async with aiosqlite.connect(self.db_path) as db:
+            db.row_factory = aiosqlite.Row
+            cursor = await db.execute("SELECT * FROM tokens ORDER BY created_at DESC")
+            rows = await cursor.fetchall()
+            return [Token(**dict(row)) for row in rows]
+
+    async def get_active_tokens(self) -> List[Token]:
+        """Get all active tokens"""
+        async with aiosqlite.connect(self.db_path) as db:
+            db.row_factory = aiosqlite.Row
+            cursor = await db.execute("SELECT * FROM tokens WHERE is_active = 1 ORDER BY last_used_at ASC")
+            rows = await cursor.fetchall()
+            return [Token(**dict(row)) for row in rows]
+
+    async def update_token(self, token_id: int, **kwargs):
+        """Update token fields"""
+        async with aiosqlite.connect(self.db_path) as db:
+            updates = []
+            params = []
+
+            for key, value in kwargs.items():
+                if value is not None:
+                    updates.append(f"{key} = ?")
+                    params.append(value)
+
+            if updates:
+                params.append(token_id)
+                query = f"UPDATE tokens SET {', '.join(updates)} WHERE id = ?"
+                await db.execute(query, params)
+                await db.commit()
+
+    async def delete_token(self, token_id: int):
+        """Delete token and related data"""
+        async with aiosqlite.connect(self.db_path) as db:
+            await db.execute("DELETE FROM token_stats WHERE token_id = ?", (token_id,))
+            await db.execute("DELETE FROM projects WHERE token_id = ?", (token_id,))
+            await db.execute("DELETE FROM tokens WHERE id = ?", (token_id,))
+            await db.commit()
+
+    # Project operations
+    async def add_project(self, project: Project) -> int:
+        """Add a new project"""
+        async with aiosqlite.connect(self.db_path) as db:
+            cursor = await db.execute("""
+                INSERT INTO projects (project_id, token_id, project_name, tool_name, is_active)
+                VALUES (?, ?, ?, ?, ?)
+            """, (project.project_id, project.token_id, project.project_name,
+                  project.tool_name, project.is_active))
+            await db.commit()
+            return cursor.lastrowid
+
+    async def get_project_by_id(self, project_id: str) -> Optional[Project]:
+        """Get project by UUID"""
+        async with aiosqlite.connect(self.db_path) as db:
+            db.row_factory = aiosqlite.Row
+            cursor = await db.execute("SELECT * FROM projects WHERE project_id = ?", (project_id,))
+            row = await cursor.fetchone()
+            if row:
+                return Project(**dict(row))
+            return None
+
+    async def get_projects_by_token(self, token_id: int) -> List[Project]:
+        """Get all projects for a token"""
+        async with aiosqlite.connect(self.db_path) as db:
+            db.row_factory = aiosqlite.Row
+            cursor = await db.execute(
+                "SELECT * FROM projects WHERE token_id = ? ORDER BY created_at DESC",
+                (token_id,)
+            )
+            rows = await cursor.fetchall()
+            return [Project(**dict(row)) for row in rows]
+
+    async def delete_project(self, project_id: str):
+        """Delete project"""
+        async with aiosqlite.connect(self.db_path) as db:
+            await db.execute("DELETE FROM projects WHERE project_id = ?", (project_id,))
+            await db.commit()
+
+    # Task operations
+    async def create_task(self, task: Task) -> int:
+        """Create a new task"""
+        async with aiosqlite.connect(self.db_path) as db:
+            cursor = await db.execute("""
+                INSERT INTO tasks (task_id, token_id, model, prompt, status, progress, scene_id)
+                VALUES (?, ?, ?, ?, ?, ?, ?)
+            """, (task.task_id, task.token_id, task.model, task.prompt,
+                  task.status, task.progress, task.scene_id))
+            await db.commit()
+            return cursor.lastrowid
+
+    async def get_task(self, task_id: str) -> Optional[Task]:
+        """Get task by ID"""
+        async with aiosqlite.connect(self.db_path) as db:
+            db.row_factory = aiosqlite.Row
+            cursor = await db.execute("SELECT * FROM tasks WHERE task_id = ?", (task_id,))
+            row = await cursor.fetchone()
+            if row:
+                task_dict = dict(row)
+                # Parse result_urls from JSON
+                if task_dict.get("result_urls"):
+                    task_dict["result_urls"] = json.loads(task_dict["result_urls"])
+                return Task(**task_dict)
+            return None
+
+    async def update_task(self, task_id: str, **kwargs):
+        """Update task"""
+        async with aiosqlite.connect(self.db_path) as db:
+            updates = []
+            params = []
+
+            for key, value in kwargs.items():
+                if value is not None:
+                    # Convert list to JSON string for result_urls
+                    if key == "result_urls" and isinstance(value, list):
+                        value = json.dumps(value)
+                    updates.append(f"{key} = ?")
+                    params.append(value)
+
+            if updates:
+                params.append(task_id)
+                query = f"UPDATE tasks SET {', '.join(updates)} WHERE task_id = ?"
+                await db.execute(query, params)
+                await db.commit()
+
+    # Token stats operations (kept for compatibility, now delegates to specific methods)
+    async def increment_token_stats(self, token_id: int, stat_type: str):
+        """Increment token statistics (delegates to specific methods)"""
+        if stat_type == "image":
+            await self.increment_image_count(token_id)
+        elif stat_type == "video":
+            await self.increment_video_count(token_id)
+        elif stat_type == "error":
+            await self.increment_error_count(token_id)
+
+    async def get_token_stats(self, token_id: int) -> Optional[TokenStats]:
+        """Get token statistics"""
+        async with aiosqlite.connect(self.db_path) as db:
+            db.row_factory = aiosqlite.Row
+            cursor = await db.execute("SELECT * FROM token_stats WHERE token_id = ?", (token_id,))
+            row = await cursor.fetchone()
+            if row:
+                return TokenStats(**dict(row))
+            return None
+
+    async def increment_image_count(self, token_id: int):
+        """Increment image generation count with daily reset"""
+        from datetime import date
+        async with aiosqlite.connect(self.db_path) as db:
+            today = str(date.today())
+            # Get current stats
+            cursor = await db.execute("SELECT today_date FROM token_stats WHERE token_id = ?", (token_id,))
+            row = await cursor.fetchone()
+
+            # If date changed, reset today's count
+            if row and row[0] != today:
+                await db.execute("""
+                    UPDATE token_stats
+                    SET image_count = image_count + 1,
+                        today_image_count = 1,
+                        today_date = ?
+                    WHERE token_id = ?
+                """, (today, token_id))
+            else:
+                # Same day, just increment both
+                await db.execute("""
+                    UPDATE token_stats
+                    SET image_count = image_count + 1,
+                        today_image_count = today_image_count + 1,
+                        today_date = ?
+                    WHERE token_id = ?
+                """, (today, token_id))
+            await db.commit()
+
+    async def increment_video_count(self, token_id: int):
+        """Increment video generation count with daily reset"""
+        from datetime import date
+        async with aiosqlite.connect(self.db_path) as db:
+            today = str(date.today())
+            # Get current stats
+            cursor = await db.execute("SELECT today_date FROM token_stats WHERE token_id = ?", (token_id,))
+            row = await cursor.fetchone()
+
+            # If date changed, reset today's count
+            if row and row[0] != today:
+                await db.execute("""
+                    UPDATE token_stats
+                    SET video_count = video_count + 1,
+                        today_video_count = 1,
+                        today_date = ?
+                    WHERE token_id = ?
+                """, (today, token_id))
+            else:
+                # Same day, just increment both
+                await db.execute("""
+                    UPDATE token_stats
+                    SET video_count = video_count + 1,
+                        today_video_count = today_video_count + 1,
+                        today_date = ?
+                    WHERE token_id = ?
+                """, (today, token_id))
+            await db.commit()
+
+    async def increment_error_count(self, token_id: int):
+        """Increment error count with daily reset
+
+        Updates two counters:
+        - error_count: Historical total errors (never reset)
+        - consecutive_error_count: Consecutive errors (reset on success/enable)
+        - today_error_count: Today's errors (reset on date change)
+        """
+        from datetime import date
+        async with aiosqlite.connect(self.db_path) as db:
+            today = str(date.today())
+            # Get current stats
+            cursor = await db.execute("SELECT today_date FROM token_stats WHERE token_id = ?", (token_id,))
+            row = await cursor.fetchone()
+
+            # If date changed, reset today's error count
+            if row and row[0] != today:
+                await db.execute("""
+                    UPDATE token_stats
+                    SET error_count = error_count + 1,
+                        consecutive_error_count = consecutive_error_count + 1,
+                        today_error_count = 1,
+                        today_date = ?,
+                        last_error_at = CURRENT_TIMESTAMP
+                    WHERE token_id = ?
+                """, (today, token_id))
+            else:
+                # Same day, just increment all counters
+                await db.execute("""
+                    UPDATE token_stats
+                    SET error_count = error_count + 1,
+                        consecutive_error_count = consecutive_error_count + 1,
+                        today_error_count = today_error_count + 1,
+                        today_date = ?,
+                        last_error_at = CURRENT_TIMESTAMP
+                    WHERE token_id = ?
+                """, (today, token_id))
+            await db.commit()
+
+    async def reset_error_count(self, token_id: int):
+        """Reset consecutive error count (only reset consecutive_error_count, keep error_count and today_error_count)
+
+        This is called when:
+        - Token is manually enabled by admin
+        - Request succeeds (resets consecutive error counter)
+
+        Note: error_count (total historical errors) is NEVER reset
+        """
+        async with aiosqlite.connect(self.db_path) as db:
+            await db.execute("""
+                UPDATE token_stats SET consecutive_error_count = 0 WHERE token_id = ?
+            """, (token_id,))
+            await db.commit()
+
+    # Config operations
+    async def get_admin_config(self) -> Optional[AdminConfig]:
+        """Get admin configuration"""
+        async with aiosqlite.connect(self.db_path) as db:
+            db.row_factory = aiosqlite.Row
+            cursor = await db.execute("SELECT * FROM admin_config WHERE id = 1")
+            row = await cursor.fetchone()
+            if row:
+                return AdminConfig(**dict(row))
+            return None
+
+    async def update_admin_config(self, **kwargs):
+        """Update admin configuration"""
+        async with aiosqlite.connect(self.db_path) as db:
+            updates = []
+            params = []
+
+            for key, value in kwargs.items():
+                if value is not None:
+                    updates.append(f"{key} = ?")
+                    params.append(value)
+
+            if updates:
+                updates.append("updated_at = CURRENT_TIMESTAMP")
+                query = f"UPDATE admin_config SET {', '.join(updates)} WHERE id = 1"
+                await db.execute(query, params)
+                await db.commit()
+
+    async def get_proxy_config(self) -> Optional[ProxyConfig]:
+        """Get proxy configuration"""
+        async with aiosqlite.connect(self.db_path) as db:
+            db.row_factory = aiosqlite.Row
+            cursor = await db.execute("SELECT * FROM proxy_config WHERE id = 1")
+            row = await cursor.fetchone()
+            if row:
+                return ProxyConfig(**dict(row))
+            return None
+
+    async def update_proxy_config(self, enabled: bool, proxy_url: Optional[str] = None):
+        """Update proxy configuration"""
+        async with aiosqlite.connect(self.db_path) as db:
+            await db.execute("""
+                UPDATE proxy_config
+                SET enabled = ?, proxy_url = ?, updated_at = CURRENT_TIMESTAMP
+                WHERE id = 1
+            """, (enabled, proxy_url))
+            await db.commit()
+
+    async def get_generation_config(self) -> Optional[GenerationConfig]:
+        """Get generation configuration"""
+        async with aiosqlite.connect(self.db_path) as db:
+            db.row_factory = aiosqlite.Row
+            cursor = await db.execute("SELECT * FROM generation_config WHERE id = 1")
+            row = await cursor.fetchone()
+            if row:
+                return GenerationConfig(**dict(row))
+            return None
+
+    async def update_generation_config(self, image_timeout: int, video_timeout: int):
+        """Update generation configuration"""
+        async with aiosqlite.connect(self.db_path) as db:
+            await db.execute("""
+                UPDATE generation_config
+                SET image_timeout = ?, video_timeout = ?, updated_at = CURRENT_TIMESTAMP
+                WHERE id = 1
+            """, (image_timeout, video_timeout))
+            await db.commit()
+
+    # Request log operations
+    async def add_request_log(self, log: RequestLog):
+        """Add request log"""
+        async with aiosqlite.connect(self.db_path) as db:
+            await db.execute("""
+                INSERT INTO request_logs (token_id, operation, request_body, response_body, status_code, duration)
+                VALUES (?, ?, ?, ?, ?, ?)
+            """, (log.token_id, log.operation, log.request_body, log.response_body,
+                  log.status_code, log.duration))
+            await db.commit()
+
+    async def get_logs(self, limit: int = 100, token_id: Optional[int] = None):
+        """Get request logs with token email"""
+        async with aiosqlite.connect(self.db_path) as db:
+            db.row_factory = aiosqlite.Row
+
+            if token_id:
+                cursor = await db.execute("""
+                    SELECT
+                        rl.id,
+                        rl.token_id,
+                        rl.operation,
+                        rl.request_body,
+                        rl.response_body,
+                        rl.status_code,
+                        rl.duration,
+                        rl.created_at,
+                        t.email as token_email,
+                        t.name as token_username
+                    FROM request_logs rl
+                    LEFT JOIN tokens t ON rl.token_id = t.id
+                    WHERE rl.token_id = ?
+                    ORDER BY rl.created_at DESC
+                    LIMIT ?
+                """, (token_id, limit))
+            else:
+                cursor = await db.execute("""
+                    SELECT
+                        rl.id,
+                        rl.token_id,
+                        rl.operation,
+                        rl.request_body,
+                        rl.response_body,
+                        rl.status_code,
+                        rl.duration,
+                        rl.created_at,
+                        t.email as token_email,
+                        t.name as token_username
+                    FROM request_logs rl
+                    LEFT JOIN tokens t ON rl.token_id = t.id
+                    ORDER BY rl.created_at DESC
+                    LIMIT ?
+                """, (limit,))
+
+            rows = await cursor.fetchall()
+            return [dict(row) for row in rows]
+
+    async def clear_all_logs(self):
+        """Clear all request logs"""
+        async with aiosqlite.connect(self.db_path) as db:
+            await db.execute("DELETE FROM request_logs")
+            await db.commit()
+
+    async def init_config_from_toml(self, config_dict: dict, is_first_startup: bool = True):
+        """
+        Initialize database configuration from setting.toml
+
+        Args:
+            config_dict: Configuration dictionary from setting.toml
+            is_first_startup: If True, initialize all config rows from setting.toml.
+                            If False (upgrade mode), only ensure missing config rows exist with default values.
+        """
+        async with aiosqlite.connect(self.db_path) as db:
+            if is_first_startup:
+                # First startup: Initialize all config tables with values from setting.toml
+                await self._ensure_config_rows(db, config_dict)
+            else:
+                # Upgrade mode: Only ensure missing config rows exist (with default values, not from TOML)
+                await self._ensure_config_rows(db, config_dict=None)
+
+            await db.commit()
+
+    async def reload_config_to_memory(self):
+        """
+        Reload all configuration from database to in-memory Config instance.
+        This should be called after any configuration update to ensure hot-reload.
+
+        Includes:
+        - Admin config (username, password, api_key)
+        - Cache config (enabled, timeout, base_url)
+        - Generation config (image_timeout, video_timeout)
+        - Proxy config will be handled by ProxyManager
+        """
+        from .config import config
+
+        # Reload admin config
+        admin_config = await self.get_admin_config()
+        if admin_config:
+            config.set_admin_username_from_db(admin_config.username)
+            config.set_admin_password_from_db(admin_config.password)
+            config.api_key = admin_config.api_key
+
+        # Reload cache config
+        cache_config = await self.get_cache_config()
+        if cache_config:
+            config.set_cache_enabled(cache_config.cache_enabled)
+            config.set_cache_timeout(cache_config.cache_timeout)
+            config.set_cache_base_url(cache_config.cache_base_url or "")
+
+        # Reload generation config
+        generation_config = await self.get_generation_config()
+        if generation_config:
+            config.set_image_timeout(generation_config.image_timeout)
+            config.set_video_timeout(generation_config.video_timeout)
+
+        # Reload debug config
+        debug_config = await self.get_debug_config()
+        if debug_config:
+            config.set_debug_enabled(debug_config.enabled)
+
+        # Reload captcha config
+        captcha_config = await self.get_captcha_config()
+        if captcha_config:
+            config.set_captcha_method(captcha_config.captcha_method)
+            config.set_yescaptcha_api_key(captcha_config.yescaptcha_api_key)
+            config.set_yescaptcha_base_url(captcha_config.yescaptcha_base_url)
+
+    # Cache config operations
+    async def get_cache_config(self) -> CacheConfig:
+        """Get cache configuration"""
+        async with aiosqlite.connect(self.db_path) as db:
+            db.row_factory = aiosqlite.Row
+            cursor = await db.execute("SELECT * FROM cache_config WHERE id = 1")
+            row = await cursor.fetchone()
+            if row:
+                return CacheConfig(**dict(row))
+            # Return default if not found
+            return CacheConfig(cache_enabled=False, cache_timeout=7200)
+
+    async def update_cache_config(self, enabled: bool = None, timeout: int = None, base_url: Optional[str] = None):
+        """Update cache configuration"""
+        async with aiosqlite.connect(self.db_path) as db:
+            db.row_factory = aiosqlite.Row
+            # Get current values
+            cursor = await db.execute("SELECT * FROM cache_config WHERE id = 1")
+            row = await cursor.fetchone()
+
+            if row:
+                current = dict(row)
+                # Use new values if provided, otherwise keep existing
+                new_enabled = enabled if enabled is not None else current.get("cache_enabled", False)
+                new_timeout = timeout if timeout is not None else current.get("cache_timeout", 7200)
+                new_base_url = base_url if base_url is not None else current.get("cache_base_url")
+
+                # If base_url is explicitly set to empty string, treat as None
+                if base_url == "":
+                    new_base_url = None
+
+                await db.execute("""
+                    UPDATE cache_config
+                    SET cache_enabled = ?, cache_timeout = ?, cache_base_url = ?, updated_at = CURRENT_TIMESTAMP
+                    WHERE id = 1
+                """, (new_enabled, new_timeout, new_base_url))
+            else:
+                # Insert default row if not exists
+                new_enabled = enabled if enabled is not None else False
+                new_timeout = timeout if timeout is not None else 7200
+                new_base_url = base_url if base_url is not None else None
+
+                await db.execute("""
+                    INSERT INTO cache_config (id, cache_enabled, cache_timeout, cache_base_url)
+                    VALUES (1, ?, ?, ?)
+                """, (new_enabled, new_timeout, new_base_url))
+
+            await db.commit()
+
+    # Debug config operations
+    async def get_debug_config(self) -> 'DebugConfig':
+        """Get debug configuration"""
+        from .models import DebugConfig
+        async with aiosqlite.connect(self.db_path) as db:
+            db.row_factory = aiosqlite.Row
+            cursor = await db.execute("SELECT * FROM debug_config WHERE id = 1")
+            row = await cursor.fetchone()
+            if row:
+                return DebugConfig(**dict(row))
+            # Return default if not found
+            return DebugConfig(enabled=False, log_requests=True, log_responses=True, mask_token=True)
+
+    async def update_debug_config(
+        self,
+        enabled: bool = None,
+        log_requests: bool = None,
+        log_responses: bool = None,
+        mask_token: bool = None
+    ):
+        """Update debug configuration"""
+        async with aiosqlite.connect(self.db_path) as db:
+            db.row_factory = aiosqlite.Row
+            # Get current values
+            cursor = await db.execute("SELECT * FROM debug_config WHERE id = 1")
+            row = await cursor.fetchone()
+
+            if row:
+                current = dict(row)
+                # Use new values if provided, otherwise keep existing
+                new_enabled = enabled if enabled is not None else current.get("enabled", False)
+                new_log_requests = log_requests if log_requests is not None else current.get("log_requests", True)
+                new_log_responses = log_responses if log_responses is not None else current.get("log_responses", True)
+                new_mask_token = mask_token if mask_token is not None else current.get("mask_token", True)
+
+                await db.execute("""
+                    UPDATE debug_config
+                    SET enabled = ?, log_requests = ?, log_responses = ?, mask_token = ?, updated_at = CURRENT_TIMESTAMP
+                    WHERE id = 1
+                """, (new_enabled, new_log_requests, new_log_responses, new_mask_token))
+            else:
+                # Insert default row if not exists
+                new_enabled = enabled if enabled is not None else False
+                new_log_requests = log_requests if log_requests is not None else True
+                new_log_responses = log_responses if log_responses is not None else True
+                new_mask_token = mask_token if mask_token is not None else True
+
+                await db.execute("""
+                    INSERT INTO debug_config (id, enabled, log_requests, log_responses, mask_token)
+                    VALUES (1, ?, ?, ?, ?)
+                """, (new_enabled, new_log_requests, new_log_responses, new_mask_token))
+
+            await db.commit()
+
+    # Captcha config operations
+    async def get_captcha_config(self) -> CaptchaConfig:
+        """Get captcha configuration"""
+        async with aiosqlite.connect(self.db_path) as db:
+            db.row_factory = aiosqlite.Row
+            cursor = await db.execute("SELECT * FROM captcha_config WHERE id = 1")
+            row = await cursor.fetchone()
+            if row:
+                return CaptchaConfig(**dict(row))
+            return CaptchaConfig()
+
+    async def update_captcha_config(
+        self,
+        captcha_method: str = None,
+        yescaptcha_api_key: str = None,
+        yescaptcha_base_url: str = None,
+        browser_proxy_enabled: bool = None,
+        browser_proxy_url: str = None
+    ):
+        """Update captcha configuration"""
+        async with aiosqlite.connect(self.db_path) as db:
+            db.row_factory = aiosqlite.Row
+            cursor = await db.execute("SELECT * FROM captcha_config WHERE id = 1")
+            row = await cursor.fetchone()
+
+            if row:
+                current = dict(row)
+                new_method = captcha_method if captcha_method is not None else current.get("captcha_method", "yescaptcha")
+                new_api_key = yescaptcha_api_key if yescaptcha_api_key is not None else current.get("yescaptcha_api_key", "")
+                new_base_url = yescaptcha_base_url if yescaptcha_base_url is not None else current.get("yescaptcha_base_url", "https://api.yescaptcha.com")
+                new_proxy_enabled = browser_proxy_enabled if browser_proxy_enabled is not None else current.get("browser_proxy_enabled", False)
+                new_proxy_url = browser_proxy_url if browser_proxy_url is not None else current.get("browser_proxy_url")
+
+                await db.execute("""
+                    UPDATE captcha_config
+                    SET captcha_method = ?, yescaptcha_api_key = ?, yescaptcha_base_url = ?,
+                        browser_proxy_enabled = ?, browser_proxy_url = ?, updated_at = CURRENT_TIMESTAMP
+                    WHERE id = 1
+                """, (new_method, new_api_key, new_base_url, new_proxy_enabled, new_proxy_url))
+            else:
+                new_method = captcha_method if captcha_method is not None else "yescaptcha"
+                new_api_key = yescaptcha_api_key if yescaptcha_api_key is not None else ""
+                new_base_url = yescaptcha_base_url if yescaptcha_base_url is not None else "https://api.yescaptcha.com"
+                new_proxy_enabled = browser_proxy_enabled if browser_proxy_enabled is not None else False
+                new_proxy_url = browser_proxy_url
+
+                await db.execute("""
+                    INSERT INTO captcha_config (id, captcha_method, yescaptcha_api_key, yescaptcha_base_url, browser_proxy_enabled, browser_proxy_url)
+                    VALUES (1, ?, ?, ?, ?, ?)
+                """, (new_method, new_api_key, new_base_url, new_proxy_enabled, new_proxy_url))
+
+            await db.commit()
+
+    # Plugin config operations
+    async def get_plugin_config(self) -> PluginConfig:
+        """Get plugin configuration"""
+        async with aiosqlite.connect(self.db_path) as db:
+            db.row_factory = aiosqlite.Row
+            cursor = await db.execute("SELECT * FROM plugin_config WHERE id = 1")
+            row = await cursor.fetchone()
+            if row:
+                return PluginConfig(**dict(row))
+            return PluginConfig()
+
+    async def update_plugin_config(self, connection_token: str, auto_enable_on_update: bool = True):
+        """Update plugin configuration"""
+        async with aiosqlite.connect(self.db_path) as db:
+            db.row_factory = aiosqlite.Row
+            cursor = await db.execute("SELECT * FROM plugin_config WHERE id = 1")
+            row = await cursor.fetchone()
+
+            if row:
+                await db.execute("""
+                    UPDATE plugin_config
+                    SET connection_token = ?, auto_enable_on_update = ?, updated_at = CURRENT_TIMESTAMP
+                    WHERE id = 1
+                """, (connection_token, auto_enable_on_update))
+            else:
+                await db.execute("""
+                    INSERT INTO plugin_config (id, connection_token, auto_enable_on_update)
+                    VALUES (1, ?, ?)
+                """, (connection_token, auto_enable_on_update))
+
+            await db.commit()

src/core/logger.py

@@ -0,0 +1,252 @@
+"""Debug logger module for detailed API request/response logging"""
+import json
+import logging
+from datetime import datetime
+from pathlib import Path
+from typing import Dict, Any, Optional
+from .config import config
+
+class DebugLogger:
+    """Debug logger for API requests and responses"""
+
+    def __init__(self):
+        self.log_file = Path("logs.txt")
+        self._setup_logger()
+
+    def _setup_logger(self):
+        """Setup file logger"""
+        # Create logger
+        self.logger = logging.getLogger("debug_logger")
+        self.logger.setLevel(logging.DEBUG)
+
+        # Remove existing handlers
+        self.logger.handlers.clear()
+
+        # Create file handler
+        file_handler = logging.FileHandler(
+            self.log_file,
+            mode='a',
+            encoding='utf-8'
+        )
+        file_handler.setLevel(logging.DEBUG)
+
+        # Create formatter
+        formatter = logging.Formatter(
+            '%(message)s',
+            datefmt='%Y-%m-%d %H:%M:%S'
+        )
+        file_handler.setFormatter(formatter)
+
+        # Add handler
+        self.logger.addHandler(file_handler)
+
+        # Prevent propagation to root logger
+        self.logger.propagate = False
+
+    def _mask_token(self, token: str) -> str:
+        """Mask token for logging (show first 6 and last 6 characters)"""
+        if not config.debug_mask_token or len(token) <= 12:
+            return token
+        return f"{token[:6]}...{token[-6:]}"
+
+    def _format_timestamp(self) -> str:
+        """Format current timestamp"""
+        return datetime.now().strftime('%Y-%m-%d %H:%M:%S.%f')[:-3]
+
+    def _write_separator(self, char: str = "=", length: int = 100):
+        """Write separator line"""
+        self.logger.info(char * length)
+
+    def log_request(
+        self,
+        method: str,
+        url: str,
+        headers: Dict[str, str],
+        body: Optional[Any] = None,
+        files: Optional[Dict] = None,
+        proxy: Optional[str] = None
+    ):
+        """Log API request details to log.txt"""
+
+        if not config.debug_enabled or not config.debug_log_requests:
+            return
+
+        try:
+            self._write_separator()
+            self.logger.info(f"🔵 [REQUEST] {self._format_timestamp()}")
+            self._write_separator("-")
+
+            # Basic info
+            self.logger.info(f"Method: {method}")
+            self.logger.info(f"URL: {url}")
+
+            # Headers
+            self.logger.info("\n📋 Headers:")
+            masked_headers = dict(headers)
+            if "Authorization" in masked_headers or "authorization" in masked_headers:
+                auth_key = "Authorization" if "Authorization" in masked_headers else "authorization"
+                auth_value = masked_headers[auth_key]
+                if auth_value.startswith("Bearer "):
+                    token = auth_value[7:]
+                    masked_headers[auth_key] = f"Bearer {self._mask_token(token)}"
+
+            # Mask Cookie header (ST token)
+            if "Cookie" in masked_headers:
+                cookie_value = masked_headers["Cookie"]
+                if "__Secure-next-auth.session-token=" in cookie_value:
+                    parts = cookie_value.split("=", 1)
+                    if len(parts) == 2:
+                        st_token = parts[1].split(";")[0]
+                        masked_headers["Cookie"] = f"__Secure-next-auth.session-token={self._mask_token(st_token)}"
+
+            for key, value in masked_headers.items():
+                self.logger.info(f"  {key}: {value}")
+
+            # Body
+            if body is not None:
+                self.logger.info("\n📦 Request Body:")
+                if isinstance(body, (dict, list)):
+                    body_str = json.dumps(body, indent=2, ensure_ascii=False)
+                    self.logger.info(body_str)
+                else:
+                    self.logger.info(str(body))
+
+            # Files
+            if files:
+                self.logger.info("\n📎 Files:")
+                try:
+                    if hasattr(files, 'keys') and callable(getattr(files, 'keys', None)):
+                        for key in files.keys():
+                            self.logger.info(f"  {key}: <file data>")
+                    else:
+                        self.logger.info("  <multipart form data>")
+                except (AttributeError, TypeError):
+                    self.logger.info("  <binary file data>")
+
+            # Proxy
+            if proxy:
+                self.logger.info(f"\n🌐 Proxy: {proxy}")
+
+            self._write_separator()
+            self.logger.info("")  # Empty line
+
+        except Exception as e:
+            self.logger.error(f"Error logging request: {e}")
+
+    def log_response(
+        self,
+        status_code: int,
+        headers: Dict[str, str],
+        body: Any,
+        duration_ms: Optional[float] = None
+    ):
+        """Log API response details to log.txt"""
+
+        if not config.debug_enabled or not config.debug_log_responses:
+            return
+
+        try:
+            self._write_separator()
+            self.logger.info(f"🟢 [RESPONSE] {self._format_timestamp()}")
+            self._write_separator("-")
+
+            # Status
+            status_emoji = "✅" if 200 <= status_code < 300 else "❌"
+            self.logger.info(f"Status: {status_code} {status_emoji}")
+
+            # Duration
+            if duration_ms is not None:
+                self.logger.info(f"Duration: {duration_ms:.2f}ms")
+
+            # Headers
+            self.logger.info("\n📋 Response Headers:")
+            for key, value in headers.items():
+                self.logger.info(f"  {key}: {value}")
+
+            # Body
+            self.logger.info("\n📦 Response Body:")
+            if isinstance(body, (dict, list)):
+                body_str = json.dumps(body, indent=2, ensure_ascii=False)
+                self.logger.info(body_str)
+            elif isinstance(body, str):
+                # Try to parse as JSON
+                try:
+                    parsed = json.loads(body)
+                    body_str = json.dumps(parsed, indent=2, ensure_ascii=False)
+                    self.logger.info(body_str)
+                except:
+                    # Not JSON, log as text (limit length)
+                    if len(body) > 2000:
+                        self.logger.info(f"{body[:2000]}... (truncated)")
+                    else:
+                        self.logger.info(body)
+            else:
+                self.logger.info(str(body))
+
+            self._write_separator()
+            self.logger.info("")  # Empty line
+
+        except Exception as e:
+            self.logger.error(f"Error logging response: {e}")
+
+    def log_error(
+        self,
+        error_message: str,
+        status_code: Optional[int] = None,
+        response_text: Optional[str] = None
+    ):
+        """Log API error details to log.txt"""
+
+        if not config.debug_enabled:
+            return
+
+        try:
+            self._write_separator()
+            self.logger.info(f"🔴 [ERROR] {self._format_timestamp()}")
+            self._write_separator("-")
+
+            if status_code:
+                self.logger.info(f"Status Code: {status_code}")
+
+            self.logger.info(f"Error Message: {error_message}")
+
+            if response_text:
+                self.logger.info("\n📦 Error Response:")
+                # Try to parse as JSON
+                try:
+                    parsed = json.loads(response_text)
+                    body_str = json.dumps(parsed, indent=2, ensure_ascii=False)
+                    self.logger.info(body_str)
+                except:
+                    # Not JSON, log as text
+                    if len(response_text) > 2000:
+                        self.logger.info(f"{response_text[:2000]}... (truncated)")
+                    else:
+                        self.logger.info(response_text)
+
+            self._write_separator()
+            self.logger.info("")  # Empty line
+
+        except Exception as e:
+            self.logger.error(f"Error logging error: {e}")
+
+    def log_info(self, message: str):
+        """Log general info message to log.txt"""
+        if not config.debug_enabled:
+            return
+        try:
+            self.logger.info(f"ℹ️  [{self._format_timestamp()}] {message}")
+        except Exception as e:
+            self.logger.error(f"Error logging info: {e}")
+
+    def log_warning(self, message: str):
+        """Log warning message to log.txt"""
+        if not config.debug_enabled:
+            return
+        try:
+            self.logger.warning(f"⚠️  [{self._format_timestamp()}] {message}")
+        except Exception as e:
+            self.logger.error(f"Error logging warning: {e}")
+
+# Global debug logger instance
+debug_logger = DebugLogger()

src/core/models.py

@@ -0,0 +1,186 @@
+"""Data models for Flow2API"""
+from pydantic import BaseModel
+from typing import Optional, List, Union, Any
+from datetime import datetime
+
+
+class Token(BaseModel):
+    """Token model for Flow2API"""
+    id: Optional[int] = None
+
+    # 认证信息 (核心)
+    st: str  # Session Token (__Secure-next-auth.session-token)
+    at: Optional[str] = None  # Access Token (从ST转换而来)
+    at_expires: Optional[datetime] = None  # AT过期时间
+
+    # 基础信息
+    email: str
+    name: Optional[str] = ""
+    remark: Optional[str] = None
+    is_active: bool = True
+    created_at: Optional[datetime] = None
+    last_used_at: Optional[datetime] = None
+    use_count: int = 0
+
+    # VideoFX特有字段
+    credits: int = 0  # 剩余credits
+    user_paygate_tier: Optional[str] = None  # PAYGATE_TIER_ONE
+
+    # 项目管理
+    current_project_id: Optional[str] = None  # 当前使用的项目UUID
+    current_project_name: Optional[str] = None  # 项目名称
+
+    # 功能开关
+    image_enabled: bool = True
+    video_enabled: bool = True
+
+    # 并发限制
+    image_concurrency: int = -1  # -1表示无限制
+    video_concurrency: int = -1  # -1表示无限制
+
+    # 429禁用相关
+    ban_reason: Optional[str] = None  # 禁用原因: "429_rate_limit" 或 None
+    banned_at: Optional[datetime] = None  # 禁用时间
+
+
+class Project(BaseModel):
+    """Project model for VideoFX"""
+    id: Optional[int] = None
+    project_id: str  # VideoFX项目UUID
+    token_id: int  # 关联的Token ID
+    project_name: str  # 项目名称
+    tool_name: str = "PINHOLE"  # 工具名称,固定为PINHOLE
+    is_active: bool = True
+    created_at: Optional[datetime] = None
+
+
+class TokenStats(BaseModel):
+    """Token statistics"""
+    token_id: int
+    image_count: int = 0
+    video_count: int = 0
+    success_count: int = 0
+    error_count: int = 0  # Historical total errors (never reset)
+    last_success_at: Optional[datetime] = None
+    last_error_at: Optional[datetime] = None
+    # 今日统计
+    today_image_count: int = 0
+    today_video_count: int = 0
+    today_error_count: int = 0
+    today_date: Optional[str] = None
+    # 连续错误计数 (用于自动禁用判断)
+    consecutive_error_count: int = 0
+
+
+class Task(BaseModel):
+    """Generation task"""
+    id: Optional[int] = None
+    task_id: str  # Flow API返回的operation name
+    token_id: int
+    model: str
+    prompt: str
+    status: str  # processing, completed, failed
+    progress: int = 0  # 0-100
+    result_urls: Optional[List[str]] = None
+    error_message: Optional[str] = None
+    scene_id: Optional[str] = None  # Flow API的sceneId
+    created_at: Optional[datetime] = None
+    completed_at: Optional[datetime] = None
+
+
+class RequestLog(BaseModel):
+    """API request log"""
+    id: Optional[int] = None
+    token_id: Optional[int] = None
+    operation: str
+    request_body: Optional[str] = None
+    response_body: Optional[str] = None
+    status_code: int
+    duration: float
+    created_at: Optional[datetime] = None
+
+
+class AdminConfig(BaseModel):
+    """Admin configuration"""
+    id: int = 1
+    username: str
+    password: str
+    api_key: str
+    error_ban_threshold: int = 3  # Auto-disable token after N consecutive errors
+
+
+class ProxyConfig(BaseModel):
+    """Proxy configuration"""
+    id: int = 1
+    enabled: bool = False
+    proxy_url: Optional[str] = None
+
+
+class GenerationConfig(BaseModel):
+    """Generation timeout configuration"""
+    id: int = 1
+    image_timeout: int = 300  # seconds
+    video_timeout: int = 1500  # seconds
+
+
+class CacheConfig(BaseModel):
+    """Cache configuration"""
+    id: int = 1
+    cache_enabled: bool = False
+    cache_timeout: int = 7200  # seconds (2 hours)
+    cache_base_url: Optional[str] = None
+    created_at: Optional[datetime] = None
+    updated_at: Optional[datetime] = None
+
+
+class DebugConfig(BaseModel):
+    """Debug configuration"""
+    id: int = 1
+    enabled: bool = False
+    log_requests: bool = True
+    log_responses: bool = True
+    mask_token: bool = True
+    created_at: Optional[datetime] = None
+    updated_at: Optional[datetime] = None
+
+
+class CaptchaConfig(BaseModel):
+    """Captcha configuration"""
+    id: int = 1
+    captcha_method: str = "browser"  # yescaptcha 或 browser
+    yescaptcha_api_key: str = ""
+    yescaptcha_base_url: str = "https://api.yescaptcha.com"
+    website_key: str = "6LdsFiUsAAAAAIjVDZcuLhaHiDn5nnHVXVRQGeMV"
+    page_action: str = "FLOW_GENERATION"
+    browser_proxy_enabled: bool = False  # 浏览器打码是否启用代理
+    browser_proxy_url: Optional[str] = None  # 浏览器打码代理URL
+    created_at: Optional[datetime] = None
+    updated_at: Optional[datetime] = None
+
+
+class PluginConfig(BaseModel):
+    """Plugin connection configuration"""
+    id: int = 1
+    connection_token: str = ""  # 插件连接token
+    auto_enable_on_update: bool = True  # 更新token时自动启用（默认开启）
+    created_at: Optional[datetime] = None
+    updated_at: Optional[datetime] = None
+
+
+# OpenAI Compatible Request Models
+class ChatMessage(BaseModel):
+    """Chat message"""
+    role: str
+    content: Union[str, List[dict]]  # string or multimodal array
+
+
+class ChatCompletionRequest(BaseModel):
+    """Chat completion request (OpenAI compatible)"""
+    model: str
+    messages: List[ChatMessage]
+    stream: bool = False
+    temperature: Optional[float] = None
+    max_tokens: Optional[int] = None
+    # Flow2API specific parameters
+    image: Optional[str] = None  # Base64 encoded image (deprecated, use messages)
+    video: Optional[str] = None  # Base64 encoded video (deprecated)

src/main.py

@@ -0,0 +1,209 @@
+"""FastAPI application initialization"""
+from fastapi import FastAPI
+from fastapi.responses import HTMLResponse, FileResponse
+from fastapi.staticfiles import StaticFiles
+from fastapi.middleware.cors import CORSMiddleware
+from contextlib import asynccontextmanager
+from pathlib import Path
+
+from .core.config import config
+from .core.database import Database
+from .services.flow_client import FlowClient
+from .services.proxy_manager import ProxyManager
+from .services.token_manager import TokenManager
+from .services.load_balancer import LoadBalancer
+from .services.concurrency_manager import ConcurrencyManager
+from .services.generation_handler import GenerationHandler
+from .api import routes, admin
+
+
+@asynccontextmanager
+async def lifespan(app: FastAPI):
+    """Application lifespan manager"""
+    # Startup
+    print("=" * 60)
+    print("Flow2API Starting...")
+    print("=" * 60)
+
+    # Get config from setting.toml
+    config_dict = config.get_raw_config()
+
+    # Check if database exists (determine if first startup)
+    is_first_startup = not db.db_exists()
+
+    # Initialize database tables structure
+    await db.init_db()
+
+    # Handle database initialization based on startup type
+    if is_first_startup:
+        print("🎉 First startup detected. Initializing database and configuration from setting.toml...")
+        await db.init_config_from_toml(config_dict, is_first_startup=True)
+        print("✓ Database and configuration initialized successfully.")
+    else:
+        print("🔄 Existing database detected. Checking for missing tables and columns...")
+        await db.check_and_migrate_db(config_dict)
+        print("✓ Database migration check completed.")
+
+    # Load admin config from database
+    admin_config = await db.get_admin_config()
+    if admin_config:
+        config.set_admin_username_from_db(admin_config.username)
+        config.set_admin_password_from_db(admin_config.password)
+        config.api_key = admin_config.api_key
+
+    # Load cache configuration from database
+    cache_config = await db.get_cache_config()
+    config.set_cache_enabled(cache_config.cache_enabled)
+    config.set_cache_timeout(cache_config.cache_timeout)
+    config.set_cache_base_url(cache_config.cache_base_url or "")
+
+    # Load generation configuration from database
+    generation_config = await db.get_generation_config()
+    config.set_image_timeout(generation_config.image_timeout)
+    config.set_video_timeout(generation_config.video_timeout)
+
+    # Load debug configuration from database
+    debug_config = await db.get_debug_config()
+    config.set_debug_enabled(debug_config.enabled)
+
+    # Load captcha configuration from database
+    captcha_config = await db.get_captcha_config()
+    config.set_captcha_method(captcha_config.captcha_method)
+    config.set_yescaptcha_api_key(captcha_config.yescaptcha_api_key)
+    config.set_yescaptcha_base_url(captcha_config.yescaptcha_base_url)
+
+    # Initialize browser captcha service if needed
+    browser_service = None
+    if captcha_config.captcha_method == "personal":
+        from .services.browser_captcha_personal import BrowserCaptchaService
+        browser_service = await BrowserCaptchaService.get_instance(db)
+        await browser_service.open_login_window()
+        print("✓ Browser captcha service initialized (webui mode)")
+    elif captcha_config.captcha_method == "browser":
+        from .services.browser_captcha import BrowserCaptchaService
+        browser_service = await BrowserCaptchaService.get_instance(db)
+        print("✓ Browser captcha service initialized (headless mode)")
+
+    # Initialize concurrency manager
+    tokens = await token_manager.get_all_tokens()
+    await concurrency_manager.initialize(tokens)
+
+    # Start file cache cleanup task
+    await generation_handler.file_cache.start_cleanup_task()
+
+    # Start 429 auto-unban task
+    import asyncio
+    async def auto_unban_task():
+        """定时任务：每小时检查并解禁429被禁用的token"""
+        while True:
+            try:
+                await asyncio.sleep(3600)  # 每小时执行一次
+                await token_manager.auto_unban_429_tokens()
+            except Exception as e:
+                print(f"❌ Auto-unban task error: {e}")
+
+    auto_unban_task_handle = asyncio.create_task(auto_unban_task())
+
+    print(f"✓ Database initialized")
+    print(f"✓ Total tokens: {len(tokens)}")
+    print(f"✓ Cache: {'Enabled' if config.cache_enabled else 'Disabled'} (timeout: {config.cache_timeout}s)")
+    print(f"✓ File cache cleanup task started")
+    print(f"✓ 429 auto-unban task started (runs every hour)")
+    print(f"✓ Server running on http://{config.server_host}:{config.server_port}")
+    print("=" * 60)
+
+    yield
+
+    # Shutdown
+    print("Flow2API Shutting down...")
+    # Stop file cache cleanup task
+    await generation_handler.file_cache.stop_cleanup_task()
+    # Stop auto-unban task
+    auto_unban_task_handle.cancel()
+    try:
+        await auto_unban_task_handle
+    except asyncio.CancelledError:
+        pass
+    # Close browser if initialized
+    if browser_service:
+        await browser_service.close()
+        print("✓ Browser captcha service closed")
+    print("✓ File cache cleanup task stopped")
+    print("✓ 429 auto-unban task stopped")
+
+
+# Initialize components
+db = Database()
+proxy_manager = ProxyManager(db)
+flow_client = FlowClient(proxy_manager)
+token_manager = TokenManager(db, flow_client)
+concurrency_manager = ConcurrencyManager()
+load_balancer = LoadBalancer(token_manager, concurrency_manager)
+generation_handler = GenerationHandler(
+    flow_client,
+    token_manager,
+    load_balancer,
+    db,
+    concurrency_manager,
+    proxy_manager  # 添加 proxy_manager 参数
+)
+
+# Set dependencies
+routes.set_generation_handler(generation_handler)
+admin.set_dependencies(token_manager, proxy_manager, db)
+
+# Create FastAPI app
+app = FastAPI(
+    title="Flow2API",
+    description="OpenAI-compatible API for Google VideoFX (Veo)",
+    version="1.0.0",
+    lifespan=lifespan
+)
+
+# CORS middleware
+app.add_middleware(
+    CORSMiddleware,
+    allow_origins=["*"],
+    allow_credentials=True,
+    allow_methods=["*"],
+    allow_headers=["*"],
+)
+
+# Include routers
+app.include_router(routes.router)
+app.include_router(admin.router)
+
+# Static files - serve tmp directory for cached files
+tmp_dir = Path(__file__).parent.parent / "tmp"
+tmp_dir.mkdir(exist_ok=True)
+app.mount("/tmp", StaticFiles(directory=str(tmp_dir)), name="tmp")
+
+# HTML routes for frontend
+static_path = Path(__file__).parent.parent / "static"
+
+
+@app.get("/", response_class=HTMLResponse)
+async def index():
+    """Redirect to login page"""
+    login_file = static_path / "login.html"
+    if login_file.exists():
+        return FileResponse(str(login_file))
+    return HTMLResponse(content="<h1>Flow2API</h1><p>Frontend not found</p>", status_code=404)
+
+
+@app.get("/login", response_class=HTMLResponse)
+async def login_page():
+    """Login page"""
+    login_file = static_path / "login.html"
+    if login_file.exists():
+        return FileResponse(str(login_file))
+    return HTMLResponse(content="<h1>Login Page Not Found</h1>", status_code=404)
+
+
+@app.get("/manage", response_class=HTMLResponse)
+async def manage_page():
+    """Management console page"""
+    manage_file = static_path / "manage.html"
+    if manage_file.exists():
+        return FileResponse(str(manage_file))
+    return HTMLResponse(content="<h1>Management Page Not Found</h1>", status_code=404)

src/services/__init__.py

@@ -0,0 +1,17 @@
+"""Services modules"""
+
+from .flow_client import FlowClient
+from .proxy_manager import ProxyManager
+from .load_balancer import LoadBalancer
+from .concurrency_manager import ConcurrencyManager
+from .token_manager import TokenManager
+from .generation_handler import GenerationHandler
+
+__all__ = [
+    "FlowClient",
+    "ProxyManager",
+    "LoadBalancer",
+    "ConcurrencyManager",
+    "TokenManager",
+    "GenerationHandler"
+]

src/services/browser_captcha.py

@@ -0,0 +1,317 @@
+"""
+浏览器自动化获取 reCAPTCHA token
+使用 Playwright 访问页面并执行 reCAPTCHA 验证
+"""
+import asyncio
+import time
+import re
+from typing import Optional, Dict
+from playwright.async_api import async_playwright, Browser, BrowserContext
+
+from ..core.logger import debug_logger
+
+
+def parse_proxy_url(proxy_url: str) -> Optional[Dict[str, str]]:
+    """解析代理URL，分离协议、主机、端口、认证信息
+
+    Args:
+        proxy_url: 代理URL，格式：protocol://[username:password@]host:port
+
+    Returns:
+        代理配置字典，包含server、username、password（如果有认证）
+    """
+    proxy_pattern = r'^(socks5|http|https)://(?:([^:]+):([^@]+)@)?([^:]+):(\d+)$'
+    match = re.match(proxy_pattern, proxy_url)
+
+    if match:
+        protocol, username, password, host, port = match.groups()
+        proxy_config = {'server': f'{protocol}://{host}:{port}'}
+
+        if username and password:
+            proxy_config['username'] = username
+            proxy_config['password'] = password
+
+        return proxy_config
+    return None
+
+
+def validate_browser_proxy_url(proxy_url: str) -> tuple[bool, str]:
+    """验证浏览器代理URL格式（仅支持HTTP和无认证SOCKS5）
+
+    Args:
+        proxy_url: 代理URL
+
+    Returns:
+        (是否有效, 错误信息)
+    """
+    if not proxy_url or not proxy_url.strip():
+        return True, ""  # 空URL视为有效（不使用代理）
+
+    proxy_url = proxy_url.strip()
+    parsed = parse_proxy_url(proxy_url)
+
+    if not parsed:
+        return False, "代理URL格式错误，正确格式：http://host:port 或 socks5://host:port"
+
+    # 检查是否有认证信息
+    has_auth = 'username' in parsed
+
+    # 获取协议
+    protocol = parsed['server'].split('://')[0]
+
+    # SOCKS5不支持认证
+    if protocol == 'socks5' and has_auth:
+        return False, "浏览器不支持带认证的SOCKS5代理，请使用HTTP代理或移除SOCKS5认证"
+
+    # HTTP/HTTPS支持认证
+    if protocol in ['http', 'https']:
+        return True, ""
+
+    # SOCKS5无认证支持
+    if protocol == 'socks5' and not has_auth:
+        return True, ""
+
+    return False, f"不支持的代理协议：{protocol}"
+
+
+class BrowserCaptchaService:
+    """浏览器自动化获取 reCAPTCHA token（单例模式）"""
+
+    _instance: Optional['BrowserCaptchaService'] = None
+    _lock = asyncio.Lock()
+
+    def __init__(self, db=None):
+        """初始化服务（始终使用无头模式）"""
+        self.headless = True  # 始终无头
+        self.playwright = None
+        self.browser: Optional[Browser] = None
+        self._initialized = False
+        self.website_key = "6LdsFiUsAAAAAIjVDZcuLhaHiDn5nnHVXVRQGeMV"
+        self.db = db
+
+    @classmethod
+    async def get_instance(cls, db=None) -> 'BrowserCaptchaService':
+        """获取单例实例"""
+        if cls._instance is None:
+            async with cls._lock:
+                if cls._instance is None:
+                    cls._instance = cls(db)
+                    await cls._instance.initialize()
+        return cls._instance
+
+    async def initialize(self):
+        """初始化浏览器（启动一次）"""
+        if self._initialized:
+            return
+
+        try:
+            # 获取浏览器专用代理配置
+            proxy_url = None
+            if self.db:
+                captcha_config = await self.db.get_captcha_config()
+                if captcha_config.browser_proxy_enabled and captcha_config.browser_proxy_url:
+                    proxy_url = captcha_config.browser_proxy_url
+
+            debug_logger.log_info(f"[BrowserCaptcha] 正在启动浏览器... (proxy={proxy_url or 'None'})")
+            self.playwright = await async_playwright().start()
+
+            # 配置浏览器启动参数
+            launch_options = {
+                'headless': self.headless,
+                'args': [
+                    '--disable-blink-features=AutomationControlled',
+                    '--disable-dev-shm-usage',
+                    '--no-sandbox',
+                    '--disable-setuid-sandbox'
+                ]
+            }
+
+            # 如果有代理，解析并添加代理配置
+            if proxy_url:
+                proxy_config = parse_proxy_url(proxy_url)
+                if proxy_config:
+                    launch_options['proxy'] = proxy_config
+                    auth_info = "auth=yes" if 'username' in proxy_config else "auth=no"
+                    debug_logger.log_info(f"[BrowserCaptcha] 代理配置: {proxy_config['server']} ({auth_info})")
+                else:
+                    debug_logger.log_warning(f"[BrowserCaptcha] 代理URL格式错误: {proxy_url}")
+
+            self.browser = await self.playwright.chromium.launch(**launch_options)
+            self._initialized = True
+            debug_logger.log_info(f"[BrowserCaptcha] ✅ 浏览器已启动 (headless={self.headless}, proxy={proxy_url or 'None'})")
+        except Exception as e:
+            debug_logger.log_error(f"[BrowserCaptcha] ❌ 浏览器启动失败: {str(e)}")
+            raise
+
+    async def get_token(self, project_id: str) -> Optional[str]:
+        """获取 reCAPTCHA token
+
+        Args:
+            project_id: Flow项目ID
+
+        Returns:
+            reCAPTCHA token字符串，如果获取失败返回None
+        """
+        if not self._initialized:
+            await self.initialize()
+
+        start_time = time.time()
+        context = None
+
+        try:
+            # 创建新的上下文
+            context = await self.browser.new_context(
+                viewport={'width': 1920, 'height': 1080},
+                user_agent='Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/120.0.0.0 Safari/537.36',
+                locale='en-US',
+                timezone_id='America/New_York'
+            )
+            page = await context.new_page()
+
+            website_url = f"https://labs.google/fx/tools/flow/project/{project_id}"
+
+            debug_logger.log_info(f"[BrowserCaptcha] 访问页面: {website_url}")
+
+            # 访问页面
+            try:
+                await page.goto(website_url, wait_until="domcontentloaded", timeout=30000)
+            except Exception as e:
+                debug_logger.log_warning(f"[BrowserCaptcha] 页面加载超时或失败: {str(e)}")
+
+            # 检查并注入 reCAPTCHA v3 脚本
+            debug_logger.log_info("[BrowserCaptcha] 检查并加载 reCAPTCHA v3 脚本...")
+            script_loaded = await page.evaluate("""
+                () => {
+                    if (window.grecaptcha && typeof window.grecaptcha.execute === 'function') {
+                        return true;
+                    }
+                    return false;
+                }
+            """)
+
+            if not script_loaded:
+                # 注入脚本
+                debug_logger.log_info("[BrowserCaptcha] 注入 reCAPTCHA v3 脚本...")
+                await page.evaluate(f"""
+                    () => {{
+                        return new Promise((resolve) => {{
+                            const script = document.createElement('script');
+                            script.src = 'https://www.google.com/recaptcha/api.js?render={self.website_key}';
+                            script.async = true;
+                            script.defer = true;
+                            script.onload = () => resolve(true);
+                            script.onerror = () => resolve(false);
+                            document.head.appendChild(script);
+                        }});
+                    }}
+                """)
+
+            # 等待reCAPTCHA加载和初始化
+            debug_logger.log_info("[BrowserCaptcha] 等待reCAPTCHA初始化...")
+            for i in range(20):
+                grecaptcha_ready = await page.evaluate("""
+                    () => {
+                        return window.grecaptcha &&
+                               typeof window.grecaptcha.execute === 'function';
+                    }
+                """)
+                if grecaptcha_ready:
+                    debug_logger.log_info(f"[BrowserCaptcha] reCAPTCHA 已准备好（等待了 {i*0.5} 秒）")
+                    break
+                await asyncio.sleep(0.5)
+            else:
+                debug_logger.log_warning("[BrowserCaptcha] reCAPTCHA 初始化超时，继续尝试执行...")
+
+            # 额外等待确保完全初始化
+            await page.wait_for_timeout(1000)
+
+            # 执行reCAPTCHA并获取token
+            debug_logger.log_info("[BrowserCaptcha] 执行reCAPTCHA验证...")
+            token = await page.evaluate("""
+                async (websiteKey) => {
+                    try {
+                        if (!window.grecaptcha) {
+                            console.error('[BrowserCaptcha] window.grecaptcha 不存在');
+                            return null;
+                        }
+
+                        if (typeof window.grecaptcha.execute !== 'function') {
+                            console.error('[BrowserCaptcha] window.grecaptcha.execute 不是函数');
+                            return null;
+                        }
+
+                        // 确保grecaptcha已准备好
+                        await new Promise((resolve, reject) => {
+                            const timeout = setTimeout(() => {
+                                reject(new Error('reCAPTCHA加载超时'));
+                            }, 15000);
+
+                            if (window.grecaptcha && window.grecaptcha.ready) {
+                                window.grecaptcha.ready(() => {
+                                    clearTimeout(timeout);
+                                    resolve();
+                                });
+                            } else {
+                                clearTimeout(timeout);
+                                resolve();
+                            }
+                        });
+
+                        // 执行reCAPTCHA v3
+                        const token = await window.grecaptcha.execute(websiteKey, {
+                            action: 'FLOW_GENERATION'
+                        });
+
+                        return token;
+                    } catch (error) {
+                        console.error('[BrowserCaptcha] reCAPTCHA执行错误:', error);
+                        return null;
+                    }
+                }
+            """, self.website_key)
+
+            duration_ms = (time.time() - start_time) * 1000
+
+            if token:
+                debug_logger.log_info(f"[BrowserCaptcha] ✅ Token获取成功（耗时 {duration_ms:.0f}ms）")
+                return token
+            else:
+                debug_logger.log_error("[BrowserCaptcha] Token获取失败（返回null）")
+                return None
+
+        except Exception as e:
+            debug_logger.log_error(f"[BrowserCaptcha] 获取token异常: {str(e)}")
+            return None
+        finally:
+            # 关闭上下文
+            if context:
+                try:
+                    await context.close()
+                except:
+                    pass
+
+    async def close(self):
+        """关闭浏览器"""
+        try:
+            if self.browser:
+                try:
+                    await self.browser.close()
+                except Exception as e:
+                    # 忽略连接关闭错误（正常关闭场景）
+                    if "Connection closed" not in str(e):
+                        debug_logger.log_warning(f"[BrowserCaptcha] 关闭浏览器时出现异常: {str(e)}")
+                finally:
+                    self.browser = None
+
+            if self.playwright:
+                try:
+                    await self.playwright.stop()
+                except Exception:
+                    pass  # 静默处理 playwright 停止异常
+                finally:
+                    self.playwright = None
+
+            self._initialized = False
+            debug_logger.log_info("[BrowserCaptcha] 浏览器已关闭")
+        except Exception as e:
+            debug_logger.log_error(f"[BrowserCaptcha] 关闭浏览器异常: {str(e)}")

src/services/browser_captcha_personal.py

@@ -0,0 +1,197 @@
+import asyncio
+import time
+import re
+import os
+from typing import Optional, Dict
+from playwright.async_api import async_playwright, BrowserContext, Page
+
+from ..core.logger import debug_logger
+
+# ... (保持原来的 parse_proxy_url 和 validate_browser_proxy_url 函数不变) ...
+def parse_proxy_url(proxy_url: str) -> Optional[Dict[str, str]]:
+    """解析代理URL，分离协议、主机、端口、认证信息"""
+    proxy_pattern = r'^(socks5|http|https)://(?:([^:]+):([^@]+)@)?([^:]+):(\d+)$'
+    match = re.match(proxy_pattern, proxy_url)
+    if match:
+        protocol, username, password, host, port = match.groups()
+        proxy_config = {'server': f'{protocol}://{host}:{port}'}
+        if username and password:
+            proxy_config['username'] = username
+            proxy_config['password'] = password
+        return proxy_config
+    return None
+
+class BrowserCaptchaService:
+    """浏览器自动化获取 reCAPTCHA token（持久化有头模式）"""
+
+    _instance: Optional['BrowserCaptchaService'] = None
+    _lock = asyncio.Lock()
+
+    def __init__(self, db=None):
+        """初始化服务"""
+        # === 修改点 1: 设置为有头模式 ===
+        self.headless = False 
+        self.playwright = None
+        # 注意: 持久化模式下，我们操作的是 context 而不是 browser
+        self.context: Optional[BrowserContext] = None 
+        self._initialized = False
+        self.website_key = "6LdsFiUsAAAAAIjVDZcuLhaHiDn5nnHVXVRQGeMV"
+        self.db = db
+        
+        # === 修改点 2: 指定本地数据存储目录 ===
+        # 这会在脚本运行目录下生成 browser_data 文件夹，用于保存你的登录状态
+        self.user_data_dir = os.path.join(os.getcwd(), "browser_data")
+
+    @classmethod
+    async def get_instance(cls, db=None) -> 'BrowserCaptchaService':
+        if cls._instance is None:
+            async with cls._lock:
+                if cls._instance is None:
+                    cls._instance = cls(db)
+                    # 首次调用不强制初始化，等待 get_token 时懒加载，或者可以在这里await
+        return cls._instance
+
+    async def initialize(self):
+        """初始化持久化浏览器上下文"""
+        if self._initialized and self.context:
+            return
+
+        try:
+            proxy_url = None
+            if self.db:
+                captcha_config = await self.db.get_captcha_config()
+                if captcha_config.browser_proxy_enabled and captcha_config.browser_proxy_url:
+                    proxy_url = captcha_config.browser_proxy_url
+
+            debug_logger.log_info(f"[BrowserCaptcha] 正在启动浏览器 (用户数据目录: {self.user_data_dir})...")
+            self.playwright = await async_playwright().start()
+
+            # 配置启动参数
+            launch_options = {
+                'headless': self.headless,
+                'user_data_dir': self.user_data_dir, # 指定数据目录
+                'viewport': {'width': 1280, 'height': 720}, # 设置默认窗口大小
+                'args': [
+                    '--disable-blink-features=AutomationControlled',
+                    '--disable-infobars',
+                    '--no-sandbox',
+                    '--disable-setuid-sandbox',
+                ]
+            }
+
+            # 代理配置
+            if proxy_url:
+                proxy_config = parse_proxy_url(proxy_url)
+                if proxy_config:
+                    launch_options['proxy'] = proxy_config
+                    debug_logger.log_info(f"[BrowserCaptcha] 使用代理: {proxy_config['server']}")
+
+            # === 修改点 3: 使用 launch_persistent_context ===
+            # 这会启动一个带有状态的浏览器窗口
+            self.context = await self.playwright.chromium.launch_persistent_context(**launch_options)
+            
+            # 设置默认超时
+            self.context.set_default_timeout(30000)
+
+            self._initialized = True
+            debug_logger.log_info(f"[BrowserCaptcha] ✅ 浏览器已启动 (Profile: {self.user_data_dir})")
+            
+        except Exception as e:
+            debug_logger.log_error(f"[BrowserCaptcha] ❌ 浏览器启动失败: {str(e)}")
+            raise
+
+    async def get_token(self, project_id: str) -> Optional[str]:
+        """获取 reCAPTCHA token"""
+        # 确保浏览器已启动
+        if not self._initialized or not self.context:
+            await self.initialize()
+
+        start_time = time.time()
+        page: Optional[Page] = None
+
+        try:
+            # === 修改点 4: 在现有上下文中新建标签页，而不是新建上下文 ===
+            # 这样可以复用该上下文中已保存的 Cookie (你的登录状态)
+            page = await self.context.new_page()
+
+            website_url = f"https://labs.google/fx/tools/flow/project/{project_id}"
+            debug_logger.log_info(f"[BrowserCaptcha] 访问页面: {website_url}")
+
+            # 访问页面
+            try:
+                await page.goto(website_url, wait_until="domcontentloaded")
+            except Exception as e:
+                debug_logger.log_warning(f"[BrowserCaptcha] 页面加载警告: {str(e)}")
+
+            # --- 关键点：如果需要人工介入 ---
+            # 你可以在这里加入一段逻辑，如果是第一次运行，或者检测到未登录，
+            # 可以暂停脚本，等你手动操作完再继续。
+            # 例如: await asyncio.sleep(30) 
+            
+            # ... (中间注入脚本和执行 reCAPTCHA 的代码逻辑与原版完全一致，此处省略以节省篇幅) ...
+            # ... 请将原代码中从 "检查并注入 reCAPTCHA v3 脚本" 到 token 获取部分的代码复制到这里 ...
+            
+            # 这里为了演示，简写注入逻辑（请保留你原有的完整注入逻辑）:
+            script_loaded = await page.evaluate("() => { return !!(window.grecaptcha && window.grecaptcha.execute); }")
+            if not script_loaded:
+                await page.evaluate(f"""
+                    () => {{
+                        const script = document.createElement('script');
+                        script.src = 'https://www.google.com/recaptcha/api.js?render={self.website_key}';
+                        script.async = true; script.defer = true;
+                        document.head.appendChild(script);
+                    }}
+                """)
+                # 等待加载... (保留你原有的等待循环)
+                await page.wait_for_timeout(2000) 
+
+            # 执行获取 Token (保留你原有的 execute 逻辑)
+            token = await page.evaluate(f"""
+                async () => {{
+                    try {{
+                        return await window.grecaptcha.execute('{self.website_key}', {{ action: 'FLOW_GENERATION' }});
+                    }} catch (e) {{ return null; }}
+                }}
+            """)
+            
+            if token:
+                debug_logger.log_info(f"[BrowserCaptcha] ✅ Token获取成功")
+                return token
+            else:
+                debug_logger.log_error("[BrowserCaptcha] Token获取失败")
+                return None
+
+        except Exception as e:
+            debug_logger.log_error(f"[BrowserCaptcha] 异常: {str(e)}")
+            return None
+        finally:
+            # === 修改点 5: 只关闭 Page (标签页)，不关闭 Context (浏览器窗口) ===
+            if page:
+                try:
+                    await page.close()
+                except:
+                    pass
+
+    async def close(self):
+        """完全关闭浏览器（清理资源时调用）"""
+        try:
+            if self.context:
+                await self.context.close() # 这会关闭整个浏览器窗口
+                self.context = None
+            
+            if self.playwright:
+                await self.playwright.stop()
+                self.playwright = None
+                
+            self._initialized = False
+            debug_logger.log_info("[BrowserCaptcha] 浏览器服务已关闭")
+        except Exception as e:
+            debug_logger.log_error(f"[BrowserCaptcha] 关闭异常: {str(e)}")
+
+    # 增加一个辅助方法，用于手动登录
+    async def open_login_window(self):
+        """调用此方法打开一个永久窗口供你登录Google"""
+        await self.initialize()
+        page = await self.context.new_page()
+        await page.goto("https://accounts.google.com/")
+        print("请在打开的浏览器中登录账号。登录完成后，无需关闭浏览器，脚本下次运行时会自动使用此状态。")

src/services/concurrency_manager.py

@@ -0,0 +1,190 @@
+"""Concurrency manager for token-based rate limiting"""
+import asyncio
+from typing import Dict, Optional
+from ..core.logger import debug_logger
+
+
+class ConcurrencyManager:
+    """Manages concurrent request limits for each token"""
+
+    def __init__(self):
+        """Initialize concurrency manager"""
+        self._image_concurrency: Dict[int, int] = {}  # token_id -> remaining image concurrency
+        self._video_concurrency: Dict[int, int] = {}  # token_id -> remaining video concurrency
+        self._lock = asyncio.Lock()  # Protect concurrent access
+
+    async def initialize(self, tokens: list):
+        """
+        Initialize concurrency counters from token list
+
+        Args:
+            tokens: List of Token objects with image_concurrency and video_concurrency fields
+        """
+        async with self._lock:
+            for token in tokens:
+                if token.image_concurrency and token.image_concurrency > 0:
+                    self._image_concurrency[token.id] = token.image_concurrency
+                if token.video_concurrency and token.video_concurrency > 0:
+                    self._video_concurrency[token.id] = token.video_concurrency
+
+            debug_logger.log_info(f"Concurrency manager initialized with {len(tokens)} tokens")
+
+    async def can_use_image(self, token_id: int) -> bool:
+        """
+        Check if token can be used for image generation
+
+        Args:
+            token_id: Token ID
+
+        Returns:
+            True if token has available image concurrency, False if concurrency is 0
+        """
+        async with self._lock:
+            # If not in dict, it means no limit (-1)
+            if token_id not in self._image_concurrency:
+                return True
+
+            remaining = self._image_concurrency[token_id]
+            if remaining <= 0:
+                debug_logger.log_info(f"Token {token_id} image concurrency exhausted (remaining: {remaining})")
+                return False
+
+            return True
+
+    async def can_use_video(self, token_id: int) -> bool:
+        """
+        Check if token can be used for video generation
+
+        Args:
+            token_id: Token ID
+
+        Returns:
+            True if token has available video concurrency, False if concurrency is 0
+        """
+        async with self._lock:
+            # If not in dict, it means no limit (-1)
+            if token_id not in self._video_concurrency:
+                return True
+
+            remaining = self._video_concurrency[token_id]
+            if remaining <= 0:
+                debug_logger.log_info(f"Token {token_id} video concurrency exhausted (remaining: {remaining})")
+                return False
+
+            return True
+
+    async def acquire_image(self, token_id: int) -> bool:
+        """
+        Acquire image concurrency slot
+
+        Args:
+            token_id: Token ID
+
+        Returns:
+            True if acquired, False if not available
+        """
+        async with self._lock:
+            if token_id not in self._image_concurrency:
+                # No limit
+                return True
+
+            if self._image_concurrency[token_id] <= 0:
+                return False
+
+            self._image_concurrency[token_id] -= 1
+            debug_logger.log_info(f"Token {token_id} acquired image slot (remaining: {self._image_concurrency[token_id]})")
+            return True
+
+    async def acquire_video(self, token_id: int) -> bool:
+        """
+        Acquire video concurrency slot
+
+        Args:
+            token_id: Token ID
+
+        Returns:
+            True if acquired, False if not available
+        """
+        async with self._lock:
+            if token_id not in self._video_concurrency:
+                # No limit
+                return True
+
+            if self._video_concurrency[token_id] <= 0:
+                return False
+
+            self._video_concurrency[token_id] -= 1
+            debug_logger.log_info(f"Token {token_id} acquired video slot (remaining: {self._video_concurrency[token_id]})")
+            return True
+
+    async def release_image(self, token_id: int):
+        """
+        Release image concurrency slot
+
+        Args:
+            token_id: Token ID
+        """
+        async with self._lock:
+            if token_id in self._image_concurrency:
+                self._image_concurrency[token_id] += 1
+                debug_logger.log_info(f"Token {token_id} released image slot (remaining: {self._image_concurrency[token_id]})")
+
+    async def release_video(self, token_id: int):
+        """
+        Release video concurrency slot
+
+        Args:
+            token_id: Token ID
+        """
+        async with self._lock:
+            if token_id in self._video_concurrency:
+                self._video_concurrency[token_id] += 1
+                debug_logger.log_info(f"Token {token_id} released video slot (remaining: {self._video_concurrency[token_id]})")
+
+    async def get_image_remaining(self, token_id: int) -> Optional[int]:
+        """
+        Get remaining image concurrency for token
+
+        Args:
+            token_id: Token ID
+
+        Returns:
+            Remaining count or None if no limit
+        """
+        async with self._lock:
+            return self._image_concurrency.get(token_id)
+
+    async def get_video_remaining(self, token_id: int) -> Optional[int]:
+        """
+        Get remaining video concurrency for token
+
+        Args:
+            token_id: Token ID
+
+        Returns:
+            Remaining count or None if no limit
+        """
+        async with self._lock:
+            return self._video_concurrency.get(token_id)
+
+    async def reset_token(self, token_id: int, image_concurrency: int = -1, video_concurrency: int = -1):
+        """
+        Reset concurrency counters for a token
+
+        Args:
+            token_id: Token ID
+            image_concurrency: New image concurrency limit (-1 for no limit)
+            video_concurrency: New video concurrency limit (-1 for no limit)
+        """
+        async with self._lock:
+            if image_concurrency > 0:
+                self._image_concurrency[token_id] = image_concurrency
+            elif token_id in self._image_concurrency:
+                del self._image_concurrency[token_id]
+
+            if video_concurrency > 0:
+                self._video_concurrency[token_id] = video_concurrency
+            elif token_id in self._video_concurrency:
+                del self._video_concurrency[token_id]
+
+            debug_logger.log_info(f"Token {token_id} concurrency reset (image: {image_concurrency}, video: {video_concurrency})")

src/services/file_cache.py

@@ -0,0 +1,301 @@
+"""File caching service"""
+import os
+import asyncio
+import hashlib
+import time
+from pathlib import Path
+from typing import Optional
+from datetime import datetime, timedelta
+from curl_cffi.requests import AsyncSession
+from ..core.config import config
+from ..core.logger import debug_logger
+
+
+class FileCache:
+    """File caching service for videos"""
+
+    def __init__(self, cache_dir: str = "tmp", default_timeout: int = 7200, proxy_manager=None):
+        """
+        Initialize file cache
+
+        Args:
+            cache_dir: Cache directory path
+            default_timeout: Default cache timeout in seconds (default: 2 hours)
+            proxy_manager: ProxyManager instance for downloading files
+        """
+        self.cache_dir = Path(cache_dir)
+        self.cache_dir.mkdir(exist_ok=True)
+        self.default_timeout = default_timeout
+        self.proxy_manager = proxy_manager
+        self._cleanup_task = None
+
+    async def start_cleanup_task(self):
+        """Start background cleanup task"""
+        if self._cleanup_task is None:
+            self._cleanup_task = asyncio.create_task(self._cleanup_loop())
+
+    async def stop_cleanup_task(self):
+        """Stop background cleanup task"""
+        if self._cleanup_task:
+            self._cleanup_task.cancel()
+            try:
+                await self._cleanup_task
+            except asyncio.CancelledError:
+                pass
+            self._cleanup_task = None
+
+    async def _cleanup_loop(self):
+        """Background task to clean up expired files"""
+        while True:
+            try:
+                await asyncio.sleep(300)  # Check every 5 minutes
+                await self._cleanup_expired_files()
+            except asyncio.CancelledError:
+                break
+            except Exception as e:
+                debug_logger.log_error(
+                    error_message=f"Cleanup task error: {str(e)}",
+                    status_code=0,
+                    response_text=""
+                )
+
+    async def _cleanup_expired_files(self):
+        """Remove expired cache files"""
+        try:
+            current_time = time.time()
+            removed_count = 0
+
+            for file_path in self.cache_dir.iterdir():
+                if file_path.is_file():
+                    # Check file age
+                    file_age = current_time - file_path.stat().st_mtime
+                    if file_age > self.default_timeout:
+                        try:
+                            file_path.unlink()
+                            removed_count += 1
+                        except Exception:
+                            pass
+
+            if removed_count > 0:
+                debug_logger.log_info(f"Cleanup: removed {removed_count} expired cache files")
+
+        except Exception as e:
+            debug_logger.log_error(
+                error_message=f"Failed to cleanup expired files: {str(e)}",
+                status_code=0,
+                response_text=""
+            )
+
+    def _generate_cache_filename(self, url: str, media_type: str) -> str:
+        """Generate unique filename for cached file"""
+        # Use URL hash as filename
+        url_hash = hashlib.md5(url.encode()).hexdigest()
+
+        # Determine file extension
+        if media_type == "video":
+            ext = ".mp4"
+        elif media_type == "image":
+            ext = ".jpg"
+        else:
+            ext = ""
+
+        return f"{url_hash}{ext}"
+
+    async def download_and_cache(self, url: str, media_type: str) -> str:
+        """
+        Download file from URL and cache it locally
+
+        Args:
+            url: File URL to download
+            media_type: 'image' or 'video'
+
+        Returns:
+            Local cache filename
+        """
+        filename = self._generate_cache_filename(url, media_type)
+        file_path = self.cache_dir / filename
+
+        # Check if already cached and not expired
+        if file_path.exists():
+            file_age = time.time() - file_path.stat().st_mtime
+            if file_age < self.default_timeout:
+                debug_logger.log_info(f"Cache hit: {filename}")
+                return filename
+            else:
+                # Remove expired file
+                try:
+                    file_path.unlink()
+                except Exception:
+                    pass
+
+        # Download file
+        debug_logger.log_info(f"Downloading file from: {url}")
+
+        # Get proxy if available
+        proxy_url = None
+        if self.proxy_manager:
+            proxy_config = await self.proxy_manager.get_proxy_config()
+            if proxy_config and proxy_config.enabled and proxy_config.proxy_url:
+                proxy_url = proxy_config.proxy_url
+
+        # Try method 1: curl_cffi with browser impersonation
+        try:
+            async with AsyncSession() as session:
+                proxies = {"http": proxy_url, "https": proxy_url} if proxy_url else None
+                headers = {
+                    "Accept": "*/*",
+                    "Accept-Language": "zh-CN,zh;q=0.9,en;q=0.8",
+                    "Accept-Encoding": "gzip, deflate, br",
+                    "Connection": "keep-alive",
+                    "Sec-Fetch-Dest": "document",
+                    "Sec-Fetch-Mode": "navigate",
+                    "Sec-Fetch-Site": "none",
+                    "Upgrade-Insecure-Requests": "1"
+                }
+                response = await session.get(
+                    url,
+                    timeout=60,
+                    proxies=proxies,
+                    headers=headers,
+                    impersonate="chrome120",
+                    verify=False
+                )
+
+                if response.status_code == 200:
+                    with open(file_path, 'wb') as f:
+                        f.write(response.content)
+                    debug_logger.log_info(f"File cached (curl_cffi): {filename} ({len(response.content)} bytes)")
+                    return filename
+                else:
+                    debug_logger.log_warning(f"curl_cffi failed with HTTP {response.status_code}, trying wget...")
+
+        except Exception as e:
+            debug_logger.log_warning(f"curl_cffi failed: {str(e)}, trying wget...")
+
+        # Try method 2: wget command
+        try:
+            import subprocess
+
+            wget_cmd = [
+                "wget",
+                "-q",  # Quiet mode
+                "-O", str(file_path),  # Output file
+                "--timeout=60",
+                "--tries=3",
+                "--user-agent=Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/120.0.0.0 Safari/537.36",
+                "--header=Accept: */*",
+                "--header=Accept-Language: zh-CN,zh;q=0.9,en;q=0.8",
+                "--header=Connection: keep-alive"
+            ]
+
+            # Add proxy if configured
+            if proxy_url:
+                # wget uses environment variables for proxy
+                env = os.environ.copy()
+                env['http_proxy'] = proxy_url
+                env['https_proxy'] = proxy_url
+            else:
+                env = None
+
+            # Add URL
+            wget_cmd.append(url)
+
+            # Execute wget
+            result = subprocess.run(wget_cmd, capture_output=True, timeout=90, env=env)
+
+            if result.returncode == 0 and file_path.exists():
+                file_size = file_path.stat().st_size
+                if file_size > 0:
+                    debug_logger.log_info(f"File cached (wget): {filename} ({file_size} bytes)")
+                    return filename
+                else:
+                    raise Exception("Downloaded file is empty")
+            else:
+                error_msg = result.stderr.decode('utf-8', errors='ignore') if result.stderr else "Unknown error"
+                debug_logger.log_warning(f"wget failed: {error_msg}, trying curl...")
+
+        except FileNotFoundError:
+            debug_logger.log_warning("wget not found, trying curl...")
+        except Exception as e:
+            debug_logger.log_warning(f"wget failed: {str(e)}, trying curl...")
+
+        # Try method 3: system curl command
+        try:
+            import subprocess
+
+            curl_cmd = [
+                "curl",
+                "-L",  # Follow redirects
+                "-s",  # Silent mode
+                "-o", str(file_path),  # Output file
+                "--max-time", "60",
+                "-H", "Accept: */*",
+                "-H", "Accept-Language: zh-CN,zh;q=0.9,en;q=0.8",
+                "-H", "Connection: keep-alive",
+                "-A", "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/120.0.0.0 Safari/537.36"
+            ]
+
+            # Add proxy if configured
+            if proxy_url:
+                curl_cmd.extend(["-x", proxy_url])
+
+            # Add URL
+            curl_cmd.append(url)
+
+            # Execute curl
+            result = subprocess.run(curl_cmd, capture_output=True, timeout=90)
+
+            if result.returncode == 0 and file_path.exists():
+                file_size = file_path.stat().st_size
+                if file_size > 0:
+                    debug_logger.log_info(f"File cached (curl): {filename} ({file_size} bytes)")
+                    return filename
+                else:
+                    raise Exception("Downloaded file is empty")
+            else:
+                error_msg = result.stderr.decode('utf-8', errors='ignore') if result.stderr else "Unknown error"
+                raise Exception(f"curl command failed: {error_msg}")
+
+        except Exception as e:
+            debug_logger.log_error(
+                error_message=f"Failed to download file: {str(e)}",
+                status_code=0,
+                response_text=str(e)
+            )
+            raise Exception(f"Failed to cache file: {str(e)}")
+
+    def get_cache_path(self, filename: str) -> Path:
+        """Get full path to cached file"""
+        return self.cache_dir / filename
+
+    def set_timeout(self, timeout: int):
+        """Set cache timeout in seconds"""
+        self.default_timeout = timeout
+        debug_logger.log_info(f"Cache timeout updated to {timeout} seconds")
+
+    def get_timeout(self) -> int:
+        """Get current cache timeout"""
+        return self.default_timeout
+
+    async def clear_all(self):
+        """Clear all cached files"""
+        try:
+            removed_count = 0
+            for file_path in self.cache_dir.iterdir():
+                if file_path.is_file():
+                    try:
+                        file_path.unlink()
+                        removed_count += 1
+                    except Exception:
+                        pass
+
+            debug_logger.log_info(f"Cache cleared: removed {removed_count} files")
+            return removed_count
+
+        except Exception as e:
+            debug_logger.log_error(
+                error_message=f"Failed to clear cache: {str(e)}",
+                status_code=0,
+                response_text=""
+            )
+            raise

src/services/flow_client.py

@@ -0,0 +1,765 @@
+"""Flow API Client for VideoFX (Veo)"""
+import time
+import uuid
+import random
+import base64
+from typing import Dict, Any, Optional, List
+from curl_cffi.requests import AsyncSession
+from ..core.logger import debug_logger
+from ..core.config import config
+
+
+class FlowClient:
+    """VideoFX API客户端"""
+
+    def __init__(self, proxy_manager):
+        self.proxy_manager = proxy_manager
+        self.labs_base_url = config.flow_labs_base_url  # https://labs.google/fx/api
+        self.api_base_url = config.flow_api_base_url    # https://aisandbox-pa.googleapis.com/v1
+        self.timeout = config.flow_timeout
+
+    async def _make_request(
+        self,
+        method: str,
+        url: str,
+        headers: Optional[Dict] = None,
+        json_data: Optional[Dict] = None,
+        use_st: bool = False,
+        st_token: Optional[str] = None,
+        use_at: bool = False,
+        at_token: Optional[str] = None
+    ) -> Dict[str, Any]:
+        """统一HTTP请求处理
+
+        Args:
+            method: HTTP方法 (GET/POST)
+            url: 完整URL
+            headers: 请求头
+            json_data: JSON请求体
+            use_st: 是否使用ST认证 (Cookie方式)
+            st_token: Session Token
+            use_at: 是否使用AT认证 (Bearer方式)
+            at_token: Access Token
+        """
+        proxy_url = await self.proxy_manager.get_proxy_url()
+
+        if headers is None:
+            headers = {}
+
+        # ST认证 - 使用Cookie
+        if use_st and st_token:
+            headers["Cookie"] = f"__Secure-next-auth.session-token={st_token}"
+
+        # AT认证 - 使用Bearer
+        if use_at and at_token:
+            headers["authorization"] = f"Bearer {at_token}"
+
+        # 通用请求头
+        headers.update({
+            "Content-Type": "application/json",
+            "User-Agent": "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36"
+        })
+
+        # Log request
+        if config.debug_enabled:
+            debug_logger.log_request(
+                method=method,
+                url=url,
+                headers=headers,
+                body=json_data,
+                proxy=proxy_url
+            )
+
+        start_time = time.time()
+
+        try:
+            async with AsyncSession() as session:
+                if method.upper() == "GET":
+                    response = await session.get(
+                        url,
+                        headers=headers,
+                        proxy=proxy_url,
+                        timeout=self.timeout,
+                        impersonate="chrome110"
+                    )
+                else:  # POST
+                    response = await session.post(
+                        url,
+                        headers=headers,
+                        json=json_data,
+                        proxy=proxy_url,
+                        timeout=self.timeout,
+                        impersonate="chrome110"
+                    )
+
+                duration_ms = (time.time() - start_time) * 1000
+
+                # Log response
+                if config.debug_enabled:
+                    debug_logger.log_response(
+                        status_code=response.status_code,
+                        headers=dict(response.headers),
+                        body=response.text,
+                        duration_ms=duration_ms
+                    )
+
+                response.raise_for_status()
+                return response.json()
+
+        except Exception as e:
+            duration_ms = (time.time() - start_time) * 1000
+            error_msg = str(e)
+
+            if config.debug_enabled:
+                debug_logger.log_error(
+                    error_message=error_msg,
+                    status_code=getattr(e, 'status_code', None),
+                    response_text=getattr(e, 'response_text', None)
+                )
+
+            raise Exception(f"Flow API request failed: {error_msg}")
+
+    # ========== 认证相关 (使用ST) ==========
+
+    async def st_to_at(self, st: str) -> dict:
+        """ST转AT
+
+        Args:
+            st: Session Token
+
+        Returns:
+            {
+                "access_token": "AT",
+                "expires": "2025-11-15T04:46:04.000Z",
+                "user": {...}
+            }
+        """
+        url = f"{self.labs_base_url}/auth/session"
+        result = await self._make_request(
+            method="GET",
+            url=url,
+            use_st=True,
+            st_token=st
+        )
+        return result
+
+    # ========== 项目管理 (使用ST) ==========
+
+    async def create_project(self, st: str, title: str) -> str:
+        """创建项目,返回project_id
+
+        Args:
+            st: Session Token
+            title: 项目标题
+
+        Returns:
+            project_id (UUID)
+        """
+        url = f"{self.labs_base_url}/trpc/project.createProject"
+        json_data = {
+            "json": {
+                "projectTitle": title,
+                "toolName": "PINHOLE"
+            }
+        }
+
+        result = await self._make_request(
+            method="POST",
+            url=url,
+            json_data=json_data,
+            use_st=True,
+            st_token=st
+        )
+
+        # 解析返回的project_id
+        project_id = result["result"]["data"]["json"]["result"]["projectId"]
+        return project_id
+
+    async def delete_project(self, st: str, project_id: str):
+        """删除项目
+
+        Args:
+            st: Session Token
+            project_id: 项目ID
+        """
+        url = f"{self.labs_base_url}/trpc/project.deleteProject"
+        json_data = {
+            "json": {
+                "projectToDeleteId": project_id
+            }
+        }
+
+        await self._make_request(
+            method="POST",
+            url=url,
+            json_data=json_data,
+            use_st=True,
+            st_token=st
+        )
+
+    # ========== 余额查询 (使用AT) ==========
+
+    async def get_credits(self, at: str) -> dict:
+        """查询余额
+
+        Args:
+            at: Access Token
+
+        Returns:
+            {
+                "credits": 920,
+                "userPaygateTier": "PAYGATE_TIER_ONE"
+            }
+        """
+        url = f"{self.api_base_url}/credits"
+        result = await self._make_request(
+            method="GET",
+            url=url,
+            use_at=True,
+            at_token=at
+        )
+        return result
+
+    # ========== 图片上传 (使用AT) ==========
+
+    async def upload_image(
+        self,
+        at: str,
+        image_bytes: bytes,
+        aspect_ratio: str = "IMAGE_ASPECT_RATIO_LANDSCAPE"
+    ) -> str:
+        """上传图片,返回mediaGenerationId
+
+        Args:
+            at: Access Token
+            image_bytes: 图片字节数据
+            aspect_ratio: 图片或视频宽高比（会自动转换为图片格式）
+
+        Returns:
+            mediaGenerationId (CAM...)
+        """
+        # 转换视频aspect_ratio为图片aspect_ratio
+        # VIDEO_ASPECT_RATIO_LANDSCAPE -> IMAGE_ASPECT_RATIO_LANDSCAPE
+        # VIDEO_ASPECT_RATIO_PORTRAIT -> IMAGE_ASPECT_RATIO_PORTRAIT
+        if aspect_ratio.startswith("VIDEO_"):
+            aspect_ratio = aspect_ratio.replace("VIDEO_", "IMAGE_")
+
+        # 编码为base64 (去掉前缀)
+        image_base64 = base64.b64encode(image_bytes).decode('utf-8')
+
+        url = f"{self.api_base_url}:uploadUserImage"
+        json_data = {
+            "imageInput": {
+                "rawImageBytes": image_base64,
+                "mimeType": "image/jpeg",
+                "isUserUploaded": True,
+                "aspectRatio": aspect_ratio
+            },
+            "clientContext": {
+                "sessionId": self._generate_session_id(),
+                "tool": "ASSET_MANAGER"
+            }
+        }
+
+        result = await self._make_request(
+            method="POST",
+            url=url,
+            json_data=json_data,
+            use_at=True,
+            at_token=at
+        )
+
+        # 返回mediaGenerationId
+        media_id = result["mediaGenerationId"]["mediaGenerationId"]
+        return media_id
+
+    # ========== 图片生成 (使用AT) - 同步返回 ==========
+
+    async def generate_image(
+        self,
+        at: str,
+        project_id: str,
+        prompt: str,
+        model_name: str,
+        aspect_ratio: str,
+        image_inputs: Optional[List[Dict]] = None
+    ) -> dict:
+        """生成图片(同步返回)
+
+        Args:
+            at: Access Token
+            project_id: 项目ID
+            prompt: 提示词
+            model_name: GEM_PIX, GEM_PIX_2 或 IMAGEN_3_5
+            aspect_ratio: 图片宽高比
+            image_inputs: 参考图片列表(图生图时使用)
+
+        Returns:
+            {
+                "media": [{
+                    "image": {
+                        "generatedImage": {
+                            "fifeUrl": "图片URL",
+                            ...
+                        }
+                    }
+                }]
+            }
+        """
+        url = f"{self.api_base_url}/projects/{project_id}/flowMedia:batchGenerateImages"
+
+        # 获取 reCAPTCHA token
+        recaptcha_token = await self._get_recaptcha_token(project_id) or ""
+        session_id = self._generate_session_id()
+
+        # 构建请求
+        request_data = {
+            "clientContext": {
+                "recaptchaToken": recaptcha_token,
+                "projectId": project_id,
+                "sessionId": session_id,
+                "tool": "PINHOLE"
+            },
+            "seed": random.randint(1, 99999),
+            "imageModelName": model_name,
+            "imageAspectRatio": aspect_ratio,
+            "prompt": prompt,
+            "imageInputs": image_inputs or []
+        }
+
+        json_data = {
+            "clientContext": {
+                "recaptchaToken": recaptcha_token,
+                "sessionId": session_id
+            },
+            "requests": [request_data]
+        }
+
+        result = await self._make_request(
+            method="POST",
+            url=url,
+            json_data=json_data,
+            use_at=True,
+            at_token=at
+        )
+
+        return result
+
+    # ========== 视频生成 (使用AT) - 异步返回 ==========
+
+    async def generate_video_text(
+        self,
+        at: str,
+        project_id: str,
+        prompt: str,
+        model_key: str,
+        aspect_ratio: str,
+        user_paygate_tier: str = "PAYGATE_TIER_ONE"
+    ) -> dict:
+        """文生视频,返回task_id
+
+        Args:
+            at: Access Token
+            project_id: 项目ID
+            prompt: 提示词
+            model_key: veo_3_1_t2v_fast 等
+            aspect_ratio: 视频宽高比
+            user_paygate_tier: 用户等级
+
+        Returns:
+            {
+                "operations": [{
+                    "operation": {"name": "task_id"},
+                    "sceneId": "uuid",
+                    "status": "MEDIA_GENERATION_STATUS_PENDING"
+                }],
+                "remainingCredits": 900
+            }
+        """
+        url = f"{self.api_base_url}/video:batchAsyncGenerateVideoText"
+
+        # 获取 reCAPTCHA token
+        recaptcha_token = await self._get_recaptcha_token(project_id) or ""
+        session_id = self._generate_session_id()
+        scene_id = str(uuid.uuid4())
+
+        json_data = {
+            "clientContext": {
+                "recaptchaToken": recaptcha_token,
+                "sessionId": session_id,
+                "projectId": project_id,
+                "tool": "PINHOLE",
+                "userPaygateTier": user_paygate_tier
+            },
+            "requests": [{
+                "aspectRatio": aspect_ratio,
+                "seed": random.randint(1, 99999),
+                "textInput": {
+                    "prompt": prompt
+                },
+                "videoModelKey": model_key,
+                "metadata": {
+                    "sceneId": scene_id
+                }
+            }]
+        }
+
+        result = await self._make_request(
+            method="POST",
+            url=url,
+            json_data=json_data,
+            use_at=True,
+            at_token=at
+        )
+
+        return result
+
+    async def generate_video_reference_images(
+        self,
+        at: str,
+        project_id: str,
+        prompt: str,
+        model_key: str,
+        aspect_ratio: str,
+        reference_images: List[Dict],
+        user_paygate_tier: str = "PAYGATE_TIER_ONE"
+    ) -> dict:
+        """图生视频,返回task_id
+
+        Args:
+            at: Access Token
+            project_id: 项目ID
+            prompt: 提示词
+            model_key: veo_3_0_r2v_fast
+            aspect_ratio: 视频宽高比
+            reference_images: 参考图片列表 [{"imageUsageType": "IMAGE_USAGE_TYPE_ASSET", "mediaId": "..."}]
+            user_paygate_tier: 用户等级
+
+        Returns:
+            同 generate_video_text
+        """
+        url = f"{self.api_base_url}/video:batchAsyncGenerateVideoReferenceImages"
+
+        # 获取 reCAPTCHA token
+        recaptcha_token = await self._get_recaptcha_token(project_id) or ""
+        session_id = self._generate_session_id()
+        scene_id = str(uuid.uuid4())
+
+        json_data = {
+            "clientContext": {
+                "recaptchaToken": recaptcha_token,
+                "sessionId": session_id,
+                "projectId": project_id,
+                "tool": "PINHOLE",
+                "userPaygateTier": user_paygate_tier
+            },
+            "requests": [{
+                "aspectRatio": aspect_ratio,
+                "seed": random.randint(1, 99999),
+                "textInput": {
+                    "prompt": prompt
+                },
+                "videoModelKey": model_key,
+                "referenceImages": reference_images,
+                "metadata": {
+                    "sceneId": scene_id
+                }
+            }]
+        }
+
+        result = await self._make_request(
+            method="POST",
+            url=url,
+            json_data=json_data,
+            use_at=True,
+            at_token=at
+        )
+
+        return result
+
+    async def generate_video_start_end(
+        self,
+        at: str,
+        project_id: str,
+        prompt: str,
+        model_key: str,
+        aspect_ratio: str,
+        start_media_id: str,
+        end_media_id: str,
+        user_paygate_tier: str = "PAYGATE_TIER_ONE"
+    ) -> dict:
+        """收尾帧生成视频,返回task_id
+
+        Args:
+            at: Access Token
+            project_id: 项目ID
+            prompt: 提示词
+            model_key: veo_3_1_i2v_s_fast_fl
+            aspect_ratio: 视频宽高比
+            start_media_id: 起始帧mediaId
+            end_media_id: 结束帧mediaId
+            user_paygate_tier: 用户等级
+
+        Returns:
+            同 generate_video_text
+        """
+        url = f"{self.api_base_url}/video:batchAsyncGenerateVideoStartAndEndImage"
+
+        # 获取 reCAPTCHA token
+        recaptcha_token = await self._get_recaptcha_token(project_id) or ""
+        session_id = self._generate_session_id()
+        scene_id = str(uuid.uuid4())
+
+        json_data = {
+            "clientContext": {
+                "recaptchaToken": recaptcha_token,
+                "sessionId": session_id,
+                "projectId": project_id,
+                "tool": "PINHOLE",
+                "userPaygateTier": user_paygate_tier
+            },
+            "requests": [{
+                "aspectRatio": aspect_ratio,
+                "seed": random.randint(1, 99999),
+                "textInput": {
+                    "prompt": prompt
+                },
+                "videoModelKey": model_key,
+                "startImage": {
+                    "mediaId": start_media_id
+                },
+                "endImage": {
+                    "mediaId": end_media_id
+                },
+                "metadata": {
+                    "sceneId": scene_id
+                }
+            }]
+        }
+
+        result = await self._make_request(
+            method="POST",
+            url=url,
+            json_data=json_data,
+            use_at=True,
+            at_token=at
+        )
+
+        return result
+
+    async def generate_video_start_image(
+        self,
+        at: str,
+        project_id: str,
+        prompt: str,
+        model_key: str,
+        aspect_ratio: str,
+        start_media_id: str,
+        user_paygate_tier: str = "PAYGATE_TIER_ONE"
+    ) -> dict:
+        """仅首帧生成视频,返回task_id
+
+        Args:
+            at: Access Token
+            project_id: 项目ID
+            prompt: 提示词
+            model_key: veo_3_1_i2v_s_fast_fl等
+            aspect_ratio: 视频宽高比
+            start_media_id: 起始帧mediaId
+            user_paygate_tier: 用户等级
+
+        Returns:
+            同 generate_video_text
+        """
+        url = f"{self.api_base_url}/video:batchAsyncGenerateVideoStartAndEndImage"
+
+        # 获取 reCAPTCHA token
+        recaptcha_token = await self._get_recaptcha_token(project_id) or ""
+        session_id = self._generate_session_id()
+        scene_id = str(uuid.uuid4())
+
+        json_data = {
+            "clientContext": {
+                "recaptchaToken": recaptcha_token,
+                "sessionId": session_id,
+                "projectId": project_id,
+                "tool": "PINHOLE",
+                "userPaygateTier": user_paygate_tier
+            },
+            "requests": [{
+                "aspectRatio": aspect_ratio,
+                "seed": random.randint(1, 99999),
+                "textInput": {
+                    "prompt": prompt
+                },
+                "videoModelKey": model_key,
+                "startImage": {
+                    "mediaId": start_media_id
+                },
+                # 注意: 没有endImage字段,只用首帧
+                "metadata": {
+                    "sceneId": scene_id
+                }
+            }]
+        }
+
+        result = await self._make_request(
+            method="POST",
+            url=url,
+            json_data=json_data,
+            use_at=True,
+            at_token=at
+        )
+
+        return result
+
+    # ========== 任务轮询 (使用AT) ==========
+
+    async def check_video_status(self, at: str, operations: List[Dict]) -> dict:
+        """查询视频生成状态
+
+        Args:
+            at: Access Token
+            operations: 操作列表 [{"operation": {"name": "task_id"}, "sceneId": "...", "status": "..."}]
+
+        Returns:
+            {
+                "operations": [{
+                    "operation": {
+                        "name": "task_id",
+                        "metadata": {...}  # 完成时包含视频信息
+                    },
+                    "status": "MEDIA_GENERATION_STATUS_SUCCESSFUL"
+                }]
+            }
+        """
+        url = f"{self.api_base_url}/video:batchCheckAsyncVideoGenerationStatus"
+
+        json_data = {
+            "operations": operations
+        }
+
+        result = await self._make_request(
+            method="POST",
+            url=url,
+            json_data=json_data,
+            use_at=True,
+            at_token=at
+        )
+
+        return result
+
+    # ========== 媒体删除 (使用ST) ==========
+
+    async def delete_media(self, st: str, media_names: List[str]):
+        """删除媒体
+
+        Args:
+            st: Session Token
+            media_names: 媒体ID列表
+        """
+        url = f"{self.labs_base_url}/trpc/media.deleteMedia"
+        json_data = {
+            "json": {
+                "names": media_names
+            }
+        }
+
+        await self._make_request(
+            method="POST",
+            url=url,
+            json_data=json_data,
+            use_st=True,
+            st_token=st
+        )
+
+    # ========== 辅助方法 ==========
+
+    def _generate_session_id(self) -> str:
+        """生成sessionId: ;timestamp"""
+        return f";{int(time.time() * 1000)}"
+
+    def _generate_scene_id(self) -> str:
+        """生成sceneId: UUID"""
+        return str(uuid.uuid4())
+
+    async def _get_recaptcha_token(self, project_id: str) -> Optional[str]:
+        """获取reCAPTCHA token - 支持两种方式"""
+        captcha_method = config.captcha_method
+
+        # 恒定浏览器打码
+        if captcha_method == "personal":
+            try:
+                from .browser_captcha_personal import BrowserCaptchaService
+                service = await BrowserCaptchaService.get_instance(self.proxy_manager)
+                return await service.get_token(project_id)
+            except Exception as e:
+                debug_logger.log_error(f"[reCAPTCHA Browser] error: {str(e)}")
+                return None
+        # 无头浏览器打码
+        elif captcha_method == "browser":
+            try:
+                from .browser_captcha import BrowserCaptchaService
+                service = await BrowserCaptchaService.get_instance(self.proxy_manager)
+                return await service.get_token(project_id)
+            except Exception as e:
+                debug_logger.log_error(f"[reCAPTCHA Browser] error: {str(e)}")
+                return None
+        else:
+            # YesCaptcha打码
+            client_key = config.yescaptcha_api_key
+            if not client_key:
+                debug_logger.log_info("[reCAPTCHA] API key not configured, skipping")
+                return None
+
+            website_key = "6LdsFiUsAAAAAIjVDZcuLhaHiDn5nnHVXVRQGeMV"
+            website_url = f"https://labs.google/fx/tools/flow/project/{project_id}"
+            base_url = config.yescaptcha_base_url
+            page_action = "FLOW_GENERATION"
+
+            try:
+                async with AsyncSession() as session:
+                    create_url = f"{base_url}/createTask"
+                    create_data = {
+                        "clientKey": client_key,
+                        "task": {
+                            "websiteURL": website_url,
+                            "websiteKey": website_key,
+                            "type": "RecaptchaV3TaskProxylessM1",
+                            "pageAction": page_action
+                        }
+                    }
+
+                    result = await session.post(create_url, json=create_data, impersonate="chrome110")
+                    result_json = result.json()
+                    task_id = result_json.get('taskId')
+
+                    debug_logger.log_info(f"[reCAPTCHA] created task_id: {task_id}")
+
+                    if not task_id:
+                        return None
+
+                    get_url = f"{base_url}/getTaskResult"
+                    for i in range(40):
+                        get_data = {
+                            "clientKey": client_key,
+                            "taskId": task_id
+                        }
+                        result = await session.post(get_url, json=get_data, impersonate="chrome110")
+                        result_json = result.json()
+
+                        debug_logger.log_info(f"[reCAPTCHA] polling #{i+1}: {result_json}")
+
+                        solution = result_json.get('solution', {})
+                        response = solution.get('gRecaptchaResponse')
+
+                        if response:
+                            return response
+
+                        time.sleep(3)
+
+                    return None
+
+            except Exception as e:
+                debug_logger.log_error(f"[reCAPTCHA] error: {str(e)}")
+                return None

src/services/generation_handler.py

@@ -0,0 +1,1018 @@
+"""Generation handler for Flow2API"""
+import asyncio
+import base64
+import json
+import time
+from typing import Optional, AsyncGenerator, List, Dict, Any
+from ..core.logger import debug_logger
+from ..core.config import config
+from ..core.models import Task, RequestLog
+from .file_cache import FileCache
+
+
+# Model configuration
+MODEL_CONFIG = {
+    # 图片生成 - GEM_PIX (Gemini 2.5 Flash)
+    "gemini-2.5-flash-image-landscape": {
+        "type": "image",
+        "model_name": "GEM_PIX",
+        "aspect_ratio": "IMAGE_ASPECT_RATIO_LANDSCAPE"
+    },
+    "gemini-2.5-flash-image-portrait": {
+        "type": "image",
+        "model_name": "GEM_PIX",
+        "aspect_ratio": "IMAGE_ASPECT_RATIO_PORTRAIT"
+    },
+
+    # 图片生成 - GEM_PIX_2 (Gemini 3.0 Pro)
+    "gemini-3.0-pro-image-landscape": {
+        "type": "image",
+        "model_name": "GEM_PIX_2",
+        "aspect_ratio": "IMAGE_ASPECT_RATIO_LANDSCAPE"
+    },
+    "gemini-3.0-pro-image-portrait": {
+        "type": "image",
+        "model_name": "GEM_PIX_2",
+        "aspect_ratio": "IMAGE_ASPECT_RATIO_PORTRAIT"
+    },
+
+    # 图片生成 - IMAGEN_3_5 (Imagen 4.0)
+    "imagen-4.0-generate-preview-landscape": {
+        "type": "image",
+        "model_name": "IMAGEN_3_5",
+        "aspect_ratio": "IMAGE_ASPECT_RATIO_LANDSCAPE"
+    },
+    "imagen-4.0-generate-preview-portrait": {
+        "type": "image",
+        "model_name": "IMAGEN_3_5",
+        "aspect_ratio": "IMAGE_ASPECT_RATIO_PORTRAIT"
+    },
+
+    # ========== 文生视频 (T2V - Text to Video) ==========
+    # 不支持上传图片，只使用文本提示词生成
+
+    # veo_3_1_t2v_fast_portrait (竖屏)
+    # 上游模型名: veo_3_1_t2v_fast_portrait
+    "veo_3_1_t2v_fast_portrait": {
+        "type": "video",
+        "video_type": "t2v",
+        "model_key": "veo_3_1_t2v_fast_portrait",
+        "aspect_ratio": "VIDEO_ASPECT_RATIO_PORTRAIT",
+        "supports_images": False
+    },
+    # veo_3_1_t2v_fast_landscape (横屏)
+    # 上游模型名: veo_3_1_t2v_fast
+    "veo_3_1_t2v_fast_landscape": {
+        "type": "video",
+        "video_type": "t2v",
+        "model_key": "veo_3_1_t2v_fast",
+        "aspect_ratio": "VIDEO_ASPECT_RATIO_LANDSCAPE",
+        "supports_images": False
+    },
+
+    # veo_2_1_fast_d_15_t2v (需要新增横竖屏)
+    "veo_2_1_fast_d_15_t2v_portrait": {
+        "type": "video",
+        "video_type": "t2v",
+        "model_key": "veo_2_1_fast_d_15_t2v",
+        "aspect_ratio": "VIDEO_ASPECT_RATIO_PORTRAIT",
+        "supports_images": False
+    },
+    "veo_2_1_fast_d_15_t2v_landscape": {
+        "type": "video",
+        "video_type": "t2v",
+        "model_key": "veo_2_1_fast_d_15_t2v",
+        "aspect_ratio": "VIDEO_ASPECT_RATIO_LANDSCAPE",
+        "supports_images": False
+    },
+
+    # veo_2_0_t2v (需要新增横竖屏)
+    "veo_2_0_t2v_portrait": {
+        "type": "video",
+        "video_type": "t2v",
+        "model_key": "veo_2_0_t2v",
+        "aspect_ratio": "VIDEO_ASPECT_RATIO_PORTRAIT",
+        "supports_images": False
+    },
+    "veo_2_0_t2v_landscape": {
+        "type": "video",
+        "video_type": "t2v",
+        "model_key": "veo_2_0_t2v",
+        "aspect_ratio": "VIDEO_ASPECT_RATIO_LANDSCAPE",
+        "supports_images": False
+    },
+
+    # veo_3_1_t2v_fast_portrait_ultra (竖屏)
+    "veo_3_1_t2v_fast_portrait_ultra": {
+        "type": "video",
+        "video_type": "t2v",
+        "model_key": "veo_3_1_t2v_fast_portrait_ultra",
+        "aspect_ratio": "VIDEO_ASPECT_RATIO_PORTRAIT",
+        "supports_images": False
+    },
+
+    # veo_3_1_t2v_fast_portrait_ultra_relaxed (竖屏)
+    "veo_3_1_t2v_fast_portrait_ultra_relaxed": {
+        "type": "video",
+        "video_type": "t2v",
+        "model_key": "veo_3_1_t2v_fast_portrait_ultra_relaxed",
+        "aspect_ratio": "VIDEO_ASPECT_RATIO_PORTRAIT",
+        "supports_images": False
+    },
+
+    # veo_3_1_t2v_portrait (竖屏)
+    "veo_3_1_t2v_portrait": {
+        "type": "video",
+        "video_type": "t2v",
+        "model_key": "veo_3_1_t2v_portrait",
+        "aspect_ratio": "VIDEO_ASPECT_RATIO_PORTRAIT",
+        "supports_images": False
+    },
+
+    # ========== 首尾帧模型 (I2V - Image to Video) ==========
+    # 支持1-2张图片：1张作为首帧，2张作为首尾帧
+
+    # veo_3_1_i2v_s_fast_fl (需要新增横竖屏)
+    "veo_3_1_i2v_s_fast_fl_portrait": {
+        "type": "video",
+        "video_type": "i2v",
+        "model_key": "veo_3_1_i2v_s_fast_fl",
+        "aspect_ratio": "VIDEO_ASPECT_RATIO_PORTRAIT",
+        "supports_images": True,
+        "min_images": 1,
+        "max_images": 2
+    },
+    "veo_3_1_i2v_s_fast_fl_landscape": {
+        "type": "video",
+        "video_type": "i2v",
+        "model_key": "veo_3_1_i2v_s_fast_fl",
+        "aspect_ratio": "VIDEO_ASPECT_RATIO_LANDSCAPE",
+        "supports_images": True,
+        "min_images": 1,
+        "max_images": 2
+    },
+
+    # veo_2_1_fast_d_15_i2v (需要新增横竖屏)
+    "veo_2_1_fast_d_15_i2v_portrait": {
+        "type": "video",
+        "video_type": "i2v",
+        "model_key": "veo_2_1_fast_d_15_i2v",
+        "aspect_ratio": "VIDEO_ASPECT_RATIO_PORTRAIT",
+        "supports_images": True,
+        "min_images": 1,
+        "max_images": 2
+    },
+    "veo_2_1_fast_d_15_i2v_landscape": {
+        "type": "video",
+        "video_type": "i2v",
+        "model_key": "veo_2_1_fast_d_15_i2v",
+        "aspect_ratio": "VIDEO_ASPECT_RATIO_LANDSCAPE",
+        "supports_images": True,
+        "min_images": 1,
+        "max_images": 2
+    },
+
+    # veo_2_0_i2v (需要新增横竖屏)
+    "veo_2_0_i2v_portrait": {
+        "type": "video",
+        "video_type": "i2v",
+        "model_key": "veo_2_0_i2v",
+        "aspect_ratio": "VIDEO_ASPECT_RATIO_PORTRAIT",
+        "supports_images": True,
+        "min_images": 1,
+        "max_images": 2
+    },
+    "veo_2_0_i2v_landscape": {
+        "type": "video",
+        "video_type": "i2v",
+        "model_key": "veo_2_0_i2v",
+        "aspect_ratio": "VIDEO_ASPECT_RATIO_LANDSCAPE",
+        "supports_images": True,
+        "min_images": 1,
+        "max_images": 2
+    },
+
+    # veo_3_1_i2v_s_fast_ultra (需要新增横竖屏)
+    "veo_3_1_i2v_s_fast_ultra_portrait": {
+        "type": "video",
+        "video_type": "i2v",
+        "model_key": "veo_3_1_i2v_s_fast_ultra",
+        "aspect_ratio": "VIDEO_ASPECT_RATIO_PORTRAIT",
+        "supports_images": True,
+        "min_images": 1,
+        "max_images": 2
+    },
+    "veo_3_1_i2v_s_fast_ultra_landscape": {
+        "type": "video",
+        "video_type": "i2v",
+        "model_key": "veo_3_1_i2v_s_fast_ultra",
+        "aspect_ratio": "VIDEO_ASPECT_RATIO_LANDSCAPE",
+        "supports_images": True,
+        "min_images": 1,
+        "max_images": 2
+    },
+
+    # veo_3_1_i2v_s_fast_ultra_relaxed (需要新增横竖屏)
+    "veo_3_1_i2v_s_fast_ultra_relaxed_portrait": {
+        "type": "video",
+        "video_type": "i2v",
+        "model_key": "veo_3_1_i2v_s_fast_ultra_relaxed",
+        "aspect_ratio": "VIDEO_ASPECT_RATIO_PORTRAIT",
+        "supports_images": True,
+        "min_images": 1,
+        "max_images": 2
+    },
+    "veo_3_1_i2v_s_fast_ultra_relaxed_landscape": {
+        "type": "video",
+        "video_type": "i2v",
+        "model_key": "veo_3_1_i2v_s_fast_ultra_relaxed",
+        "aspect_ratio": "VIDEO_ASPECT_RATIO_LANDSCAPE",
+        "supports_images": True,
+        "min_images": 1,
+        "max_images": 2
+    },
+
+    # veo_3_1_i2v_s (需要新增横竖屏)
+    "veo_3_1_i2v_s_portrait": {
+        "type": "video",
+        "video_type": "i2v",
+        "model_key": "veo_3_1_i2v_s",
+        "aspect_ratio": "VIDEO_ASPECT_RATIO_PORTRAIT",
+        "supports_images": True,
+        "min_images": 1,
+        "max_images": 2
+    },
+    "veo_3_1_i2v_s_landscape": {
+        "type": "video",
+        "video_type": "i2v",
+        "model_key": "veo_3_1_i2v_s",
+        "aspect_ratio": "VIDEO_ASPECT_RATIO_LANDSCAPE",
+        "supports_images": True,
+        "min_images": 1,
+        "max_images": 2
+    },
+
+    # ========== 多图生成 (R2V - Reference Images to Video) ==========
+    # 支持多张图片,不限制数量
+
+    # veo_3_0_r2v_fast (需要新增横竖屏)
+    "veo_3_0_r2v_fast_portrait": {
+        "type": "video",
+        "video_type": "r2v",
+        "model_key": "veo_3_0_r2v_fast",
+        "aspect_ratio": "VIDEO_ASPECT_RATIO_PORTRAIT",
+        "supports_images": True,
+        "min_images": 0,
+        "max_images": None  # 不限制
+    },
+    "veo_3_0_r2v_fast_landscape": {
+        "type": "video",
+        "video_type": "r2v",
+        "model_key": "veo_3_0_r2v_fast",
+        "aspect_ratio": "VIDEO_ASPECT_RATIO_LANDSCAPE",
+        "supports_images": True,
+        "min_images": 0,
+        "max_images": None  # 不限制
+    },
+
+    # veo_3_0_r2v_fast_ultra (需要新增横竖屏)
+    "veo_3_0_r2v_fast_ultra_portrait": {
+        "type": "video",
+        "video_type": "r2v",
+        "model_key": "veo_3_0_r2v_fast_ultra",
+        "aspect_ratio": "VIDEO_ASPECT_RATIO_PORTRAIT",
+        "supports_images": True,
+        "min_images": 0,
+        "max_images": None  # 不限制
+    },
+    "veo_3_0_r2v_fast_ultra_landscape": {
+        "type": "video",
+        "video_type": "r2v",
+        "model_key": "veo_3_0_r2v_fast_ultra",
+        "aspect_ratio": "VIDEO_ASPECT_RATIO_LANDSCAPE",
+        "supports_images": True,
+        "min_images": 0,
+        "max_images": None  # 不限制
+    },
+
+    # veo_3_0_r2v_fast_ultra_relaxed (需要新增横竖屏)
+    "veo_3_0_r2v_fast_ultra_relaxed_portrait": {
+        "type": "video",
+        "video_type": "r2v",
+        "model_key": "veo_3_0_r2v_fast_ultra_relaxed",
+        "aspect_ratio": "VIDEO_ASPECT_RATIO_PORTRAIT",
+        "supports_images": True,
+        "min_images": 0,
+        "max_images": None  # 不限制
+    },
+    "veo_3_0_r2v_fast_ultra_relaxed_landscape": {
+        "type": "video",
+        "video_type": "r2v",
+        "model_key": "veo_3_0_r2v_fast_ultra_relaxed",
+        "aspect_ratio": "VIDEO_ASPECT_RATIO_LANDSCAPE",
+        "supports_images": True,
+        "min_images": 0,
+        "max_images": None  # 不限制
+    }
+}
+
+
+class GenerationHandler:
+    """统一生成处理器"""
+
+    def __init__(self, flow_client, token_manager, load_balancer, db, concurrency_manager, proxy_manager):
+        self.flow_client = flow_client
+        self.token_manager = token_manager
+        self.load_balancer = load_balancer
+        self.db = db
+        self.concurrency_manager = concurrency_manager
+        self.file_cache = FileCache(
+            cache_dir="tmp",
+            default_timeout=config.cache_timeout,
+            proxy_manager=proxy_manager
+        )
+
+    async def check_token_availability(self, is_image: bool, is_video: bool) -> bool:
+        """检查Token可用性
+
+        Args:
+            is_image: 是否检查图片生成Token
+            is_video: 是否检查视频生成Token
+
+        Returns:
+            True表示有可用Token, False表示无可用Token
+        """
+        token_obj = await self.load_balancer.select_token(
+            for_image_generation=is_image,
+            for_video_generation=is_video
+        )
+        return token_obj is not None
+
+    async def handle_generation(
+        self,
+        model: str,
+        prompt: str,
+        images: Optional[List[bytes]] = None,
+        stream: bool = False
+    ) -> AsyncGenerator:
+        """统一生成入口
+
+        Args:
+            model: 模型名称
+            prompt: 提示词
+            images: 图片列表 (bytes格式)
+            stream: 是否流式输出
+        """
+        start_time = time.time()
+        token = None
+
+        # 1. 验证模型
+        if model not in MODEL_CONFIG:
+            error_msg = f"不支持的模型: {model}"
+            debug_logger.log_error(error_msg)
+            yield self._create_error_response(error_msg)
+            return
+
+        model_config = MODEL_CONFIG[model]
+        generation_type = model_config["type"]
+        debug_logger.log_info(f"[GENERATION] 开始生成 - 模型: {model}, 类型: {generation_type}, Prompt: {prompt[:50]}...")
+
+        # 非流式模式: 只检查可用性
+        if not stream:
+            is_image = (generation_type == "image")
+            is_video = (generation_type == "video")
+            available = await self.check_token_availability(is_image, is_video)
+
+            if available:
+                if is_image:
+                    message = "所有Token可用于图片生成。请启用流式模式使用生成功能。"
+                else:
+                    message = "所有Token可用于视频生成。请启用流式模式使用生成功能。"
+            else:
+                if is_image:
+                    message = "没有可用的Token进行图片生成"
+                else:
+                    message = "没有可用的Token进行视频生成"
+
+            yield self._create_completion_response(message, is_availability_check=True)
+            return
+
+        # 向用户展示开始信息
+        if stream:
+            yield self._create_stream_chunk(
+                f"✨ {'视频' if generation_type == 'video' else '图片'}生成任务已启动\n",
+                role="assistant"
+            )
+
+        # 2. 选择Token
+        debug_logger.log_info(f"[GENERATION] 正在选择可用Token...")
+
+        if generation_type == "image":
+            token = await self.load_balancer.select_token(for_image_generation=True, model=model)
+        else:
+            token = await self.load_balancer.select_token(for_video_generation=True, model=model)
+
+        if not token:
+            error_msg = self._get_no_token_error_message(generation_type)
+            debug_logger.log_error(f"[GENERATION] {error_msg}")
+            if stream:
+                yield self._create_stream_chunk(f"❌ {error_msg}\n")
+            yield self._create_error_response(error_msg)
+            return
+
+        debug_logger.log_info(f"[GENERATION] 已选择Token: {token.id} ({token.email})")
+
+        try:
+            # 3. 确保AT有效
+            debug_logger.log_info(f"[GENERATION] 检查Token AT有效性...")
+            if stream:
+                yield self._create_stream_chunk("初始化生成环境...\n")
+
+            if not await self.token_manager.is_at_valid(token.id):
+                error_msg = "Token AT无效或刷新失败"
+                debug_logger.log_error(f"[GENERATION] {error_msg}")
+                if stream:
+                    yield self._create_stream_chunk(f"❌ {error_msg}\n")
+                yield self._create_error_response(error_msg)
+                return
+
+            # 重新获取token (AT可能已刷新)
+            token = await self.token_manager.get_token(token.id)
+
+            # 4. 确保Project存在
+            debug_logger.log_info(f"[GENERATION] 检查/创建Project...")
+
+            project_id = await self.token_manager.ensure_project_exists(token.id)
+            debug_logger.log_info(f"[GENERATION] Project ID: {project_id}")
+
+            # 5. 根据类型处理
+            if generation_type == "image":
+                debug_logger.log_info(f"[GENERATION] 开始图片生成流程...")
+                async for chunk in self._handle_image_generation(
+                    token, project_id, model_config, prompt, images, stream
+                ):
+                    yield chunk
+            else:  # video
+                debug_logger.log_info(f"[GENERATION] 开始视频生成流程...")
+                async for chunk in self._handle_video_generation(
+                    token, project_id, model_config, prompt, images, stream
+                ):
+                    yield chunk
+
+            # 6. 记录使用
+            is_video = (generation_type == "video")
+            await self.token_manager.record_usage(token.id, is_video=is_video)
+
+            # 重置错误计数 (请求成功时清空连续错误计数)
+            await self.token_manager.record_success(token.id)
+
+            debug_logger.log_info(f"[GENERATION] ✅ 生成成功完成")
+
+            # 7. 记录成功日志
+            duration = time.time() - start_time
+
+            # 构建响应数据，包含生成的URL
+            response_data = {
+                "status": "success",
+                "model": model,
+                "prompt": prompt[:100]
+            }
+
+            # 添加生成的URL（如果有）
+            if hasattr(self, '_last_generated_url') and self._last_generated_url:
+                response_data["url"] = self._last_generated_url
+                # 清除临时存储
+                self._last_generated_url = None
+
+            await self._log_request(
+                token.id,
+                f"generate_{generation_type}",
+                {"model": model, "prompt": prompt[:100], "has_images": images is not None and len(images) > 0},
+                response_data,
+                200,
+                duration
+            )
+
+        except Exception as e:
+            error_msg = f"生成失败: {str(e)}"
+            debug_logger.log_error(f"[GENERATION] ❌ {error_msg}")
+            if stream:
+                yield self._create_stream_chunk(f"❌ {error_msg}\n")
+            if token:
+                # 记录错误（所有错误统一处理，不再特殊处理429）
+                await self.token_manager.record_error(token.id)
+            yield self._create_error_response(error_msg)
+
+            # 记录失败日志
+            duration = time.time() - start_time
+            await self._log_request(
+                token.id if token else None,
+                f"generate_{generation_type if model_config else 'unknown'}",
+                {"model": model, "prompt": prompt[:100], "has_images": images is not None and len(images) > 0},
+                {"error": error_msg},
+                500,
+                duration
+            )
+
+    def _get_no_token_error_message(self, generation_type: str) -> str:
+        """获取无可用Token时的详细错误信息"""
+        if generation_type == "image":
+            return "没有可用的Token进行图片生成。所有Token都处于禁用、冷却、锁定或已过期状态。"
+        else:
+            return "没有可用的Token进行视频生成。所有Token都处于禁用、冷却、配额耗尽或已过期状态。"
+
+    async def _handle_image_generation(
+        self,
+        token,
+        project_id: str,
+        model_config: dict,
+        prompt: str,
+        images: Optional[List[bytes]],
+        stream: bool
+    ) -> AsyncGenerator:
+        """处理图片生成 (同步返回)"""
+
+        # 获取并发槽位
+        if self.concurrency_manager:
+            if not await self.concurrency_manager.acquire_image(token.id):
+                yield self._create_error_response("图片并发限制已达上限")
+                return
+
+        try:
+            # 上传图片 (如果有)
+            image_inputs = []
+            if images and len(images) > 0:
+                if stream:
+                    yield self._create_stream_chunk(f"上传 {len(images)} 张参考图片...\n")
+
+                # 支持多图输入
+                for idx, image_bytes in enumerate(images):
+                    media_id = await self.flow_client.upload_image(
+                        token.at,
+                        image_bytes,
+                        model_config["aspect_ratio"]
+                    )
+                    image_inputs.append({
+                        "name": media_id,
+                        "imageInputType": "IMAGE_INPUT_TYPE_REFERENCE"
+                    })
+                    if stream:
+                        yield self._create_stream_chunk(f"已上传第 {idx + 1}/{len(images)} 张图片\n")
+
+            # 调用生成API
+            if stream:
+                yield self._create_stream_chunk("正在生成图片...\n")
+
+            result = await self.flow_client.generate_image(
+                at=token.at,
+                project_id=project_id,
+                prompt=prompt,
+                model_name=model_config["model_name"],
+                aspect_ratio=model_config["aspect_ratio"],
+                image_inputs=image_inputs
+            )
+
+            # 提取URL
+            media = result.get("media", [])
+            if not media:
+                yield self._create_error_response("生成结果为空")
+                return
+
+            image_url = media[0]["image"]["generatedImage"]["fifeUrl"]
+
+            # 缓存图片 (如果启用)
+            local_url = image_url
+            if config.cache_enabled:
+                try:
+                    if stream:
+                        yield self._create_stream_chunk("缓存图片中...\n")
+                    cached_filename = await self.file_cache.download_and_cache(image_url, "image")
+                    local_url = f"{self._get_base_url()}/tmp/{cached_filename}"
+                    if stream:
+                        yield self._create_stream_chunk("✅ 图片缓存成功,准备返回缓存地址...\n")
+                except Exception as e:
+                    debug_logger.log_error(f"Failed to cache image: {str(e)}")
+                    # 缓存失败不影响结果返回,使用原始URL
+                    local_url = image_url
+                    if stream:
+                        yield self._create_stream_chunk(f"⚠️ 缓存失败: {str(e)}\n正在返回源链接...\n")
+            else:
+                if stream:
+                    yield self._create_stream_chunk("缓存已关闭,正在返回源链接...\n")
+
+            # 返回结果
+            # 存储URL用于日志记录
+            self._last_generated_url = local_url
+
+            if stream:
+                yield self._create_stream_chunk(
+                    f"![Generated Image]({local_url})",
+                    finish_reason="stop"
+                )
+            else:
+                yield self._create_completion_response(
+                    local_url,  # 直接传URL,让方法内部格式化
+                    media_type="image"
+                )
+
+        finally:
+            # 释放并发槽位
+            if self.concurrency_manager:
+                await self.concurrency_manager.release_image(token.id)
+
+    async def _handle_video_generation(
+        self,
+        token,
+        project_id: str,
+        model_config: dict,
+        prompt: str,
+        images: Optional[List[bytes]],
+        stream: bool
+    ) -> AsyncGenerator:
+        """处理视频生成 (异步轮询)"""
+
+        # 获取并发槽位
+        if self.concurrency_manager:
+            if not await self.concurrency_manager.acquire_video(token.id):
+                yield self._create_error_response("视频并发限制已达上限")
+                return
+
+        try:
+            # 获取模型类型和配置
+            video_type = model_config.get("video_type")
+            supports_images = model_config.get("supports_images", False)
+            min_images = model_config.get("min_images", 0)
+            max_images = model_config.get("max_images", 0)
+
+            # 图片数量
+            image_count = len(images) if images else 0
+
+            # ========== 验证和处理图片 ==========
+
+            # T2V: 文生视频 - 不支持图片
+            if video_type == "t2v":
+                if image_count > 0:
+                    if stream:
+                        yield self._create_stream_chunk("⚠️ 文生视频模型不支持上传图片,将忽略图片仅使用文本提示词生成\n")
+                    debug_logger.log_warning(f"[T2V] 模型 {model_config['model_key']} 不支持图片,已忽略 {image_count} 张图片")
+                images = None  # 清空图片
+                image_count = 0
+
+            # I2V: 首尾帧模型 - 需要1-2张图片
+            elif video_type == "i2v":
+                if image_count < min_images or image_count > max_images:
+                    error_msg = f"❌ 首尾帧模型需要 {min_images}-{max_images} 张图片,当前提供了 {image_count} 张"
+                    if stream:
+                        yield self._create_stream_chunk(f"{error_msg}\n")
+                    yield self._create_error_response(error_msg)
+                    return
+
+            # R2V: 多图生成 - 支持多张图片,不限制数量
+            elif video_type == "r2v":
+                # 不再限制最大图片数量
+                pass
+
+            # ========== 上传图片 ==========
+            start_media_id = None
+            end_media_id = None
+            reference_images = []
+
+            # I2V: 首尾帧处理
+            if video_type == "i2v" and images:
+                if image_count == 1:
+                    # 只有1张图: 仅作为首帧
+                    if stream:
+                        yield self._create_stream_chunk("上传首帧图片...\n")
+                    start_media_id = await self.flow_client.upload_image(
+                        token.at, images[0], model_config["aspect_ratio"]
+                    )
+                    debug_logger.log_info(f"[I2V] 仅上传首帧: {start_media_id}")
+
+                elif image_count == 2:
+                    # 2张图: 首帧+尾帧
+                    if stream:
+                        yield self._create_stream_chunk("上传首帧和尾帧图片...\n")
+                    start_media_id = await self.flow_client.upload_image(
+                        token.at, images[0], model_config["aspect_ratio"]
+                    )
+                    end_media_id = await self.flow_client.upload_image(
+                        token.at, images[1], model_config["aspect_ratio"]
+                    )
+                    debug_logger.log_info(f"[I2V] 上传首尾帧: {start_media_id}, {end_media_id}")
+
+            # R2V: 多图处理
+            elif video_type == "r2v" and images:
+                if stream:
+                    yield self._create_stream_chunk(f"上传 {image_count} 张参考图片...\n")
+
+                for idx, img in enumerate(images):  # 上传所有图片,不限制数量
+                    media_id = await self.flow_client.upload_image(
+                        token.at, img, model_config["aspect_ratio"]
+                    )
+                    reference_images.append({
+                        "imageUsageType": "IMAGE_USAGE_TYPE_ASSET",
+                        "mediaId": media_id
+                    })
+                debug_logger.log_info(f"[R2V] 上传了 {len(reference_images)} 张参考图片")
+
+            # ========== 调用生成API ==========
+            if stream:
+                yield self._create_stream_chunk("提交视频生成任务...\n")
+
+            # I2V: 首尾帧生成
+            if video_type == "i2v" and start_media_id:
+                if end_media_id:
+                    # 有首尾帧
+                    result = await self.flow_client.generate_video_start_end(
+                        at=token.at,
+                        project_id=project_id,
+                        prompt=prompt,
+                        model_key=model_config["model_key"],
+                        aspect_ratio=model_config["aspect_ratio"],
+                        start_media_id=start_media_id,
+                        end_media_id=end_media_id,
+                        user_paygate_tier=token.user_paygate_tier or "PAYGATE_TIER_ONE"
+                    )
+                else:
+                    # 只有首帧
+                    result = await self.flow_client.generate_video_start_image(
+                        at=token.at,
+                        project_id=project_id,
+                        prompt=prompt,
+                        model_key=model_config["model_key"],
+                        aspect_ratio=model_config["aspect_ratio"],
+                        start_media_id=start_media_id,
+                        user_paygate_tier=token.user_paygate_tier or "PAYGATE_TIER_ONE"
+                    )
+
+            # R2V: 多图生成
+            elif video_type == "r2v" and reference_images:
+                result = await self.flow_client.generate_video_reference_images(
+                    at=token.at,
+                    project_id=project_id,
+                    prompt=prompt,
+                    model_key=model_config["model_key"],
+                    aspect_ratio=model_config["aspect_ratio"],
+                    reference_images=reference_images,
+                    user_paygate_tier=token.user_paygate_tier or "PAYGATE_TIER_ONE"
+                )
+
+            # T2V 或 R2V无图: 纯文本生成
+            else:
+                result = await self.flow_client.generate_video_text(
+                    at=token.at,
+                    project_id=project_id,
+                    prompt=prompt,
+                    model_key=model_config["model_key"],
+                    aspect_ratio=model_config["aspect_ratio"],
+                    user_paygate_tier=token.user_paygate_tier or "PAYGATE_TIER_ONE"
+                )
+
+            # 获取task_id和operations
+            operations = result.get("operations", [])
+            if not operations:
+                yield self._create_error_response("生成任务创建失败")
+                return
+
+            operation = operations[0]
+            task_id = operation["operation"]["name"]
+            scene_id = operation.get("sceneId")
+
+            # 保存Task到数据库
+            task = Task(
+                task_id=task_id,
+                token_id=token.id,
+                model=model_config["model_key"],
+                prompt=prompt,
+                status="processing",
+                scene_id=scene_id
+            )
+            await self.db.create_task(task)
+
+            # 轮询结果
+            if stream:
+                yield self._create_stream_chunk(f"视频生成中...\n")
+
+            async for chunk in self._poll_video_result(token, operations, stream):
+                yield chunk
+
+        finally:
+            # 释放并发槽位
+            if self.concurrency_manager:
+                await self.concurrency_manager.release_video(token.id)
+
+    async def _poll_video_result(
+        self,
+        token,
+        operations: List[Dict],
+        stream: bool
+    ) -> AsyncGenerator:
+        """轮询视频生成结果"""
+
+        max_attempts = config.max_poll_attempts
+        poll_interval = config.poll_interval
+
+        for attempt in range(max_attempts):
+            await asyncio.sleep(poll_interval)
+
+            try:
+                result = await self.flow_client.check_video_status(token.at, operations)
+                checked_operations = result.get("operations", [])
+
+                if not checked_operations:
+                    continue
+
+                operation = checked_operations[0]
+                status = operation.get("status")
+
+                # 状态更新 - 每20秒报告一次 (poll_interval=3秒, 20秒约7次轮询)
+                progress_update_interval = 7  # 每7次轮询 = 21秒
+                if stream and attempt % progress_update_interval == 0:  # 每20秒报告一次
+                    progress = min(int((attempt / max_attempts) * 100), 95)
+                    yield self._create_stream_chunk(f"生成进度: {progress}%\n")
+
+                # 检查状态
+                if status == "MEDIA_GENERATION_STATUS_SUCCESSFUL":
+                    # 成功
+                    metadata = operation["operation"].get("metadata", {})
+                    video_info = metadata.get("video", {})
+                    video_url = video_info.get("fifeUrl")
+
+                    if not video_url:
+                        yield self._create_error_response("视频URL为空")
+                        return
+
+                    # 缓存视频 (如果启用)
+                    local_url = video_url
+                    if config.cache_enabled:
+                        try:
+                            if stream:
+                                yield self._create_stream_chunk("正在缓存视频文件...\n")
+                            cached_filename = await self.file_cache.download_and_cache(video_url, "video")
+                            local_url = f"{self._get_base_url()}/tmp/{cached_filename}"
+                            if stream:
+                                yield self._create_stream_chunk("✅ 视频缓存成功,准备返回缓存地址...\n")
+                        except Exception as e:
+                            debug_logger.log_error(f"Failed to cache video: {str(e)}")
+                            # 缓存失败不影响结果返回,使用原始URL
+                            local_url = video_url
+                            if stream:
+                                yield self._create_stream_chunk(f"⚠️ 缓存失败: {str(e)}\n正在返回源链接...\n")
+                    else:
+                        if stream:
+                            yield self._create_stream_chunk("缓存已关闭,正在返回源链接...\n")
+
+                    # 更新数据库
+                    task_id = operation["operation"]["name"]
+                    await self.db.update_task(
+                        task_id,
+                        status="completed",
+                        progress=100,
+                        result_urls=[local_url],
+                        completed_at=time.time()
+                    )
+
+                    # 存储URL用于日志记录
+                    self._last_generated_url = local_url
+
+                    # 返回结果
+                    if stream:
+                        yield self._create_stream_chunk(
+                            f"<video src='{local_url}' controls style='max-width:100%'></video>",
+                            finish_reason="stop"
+                        )
+                    else:
+                        yield self._create_completion_response(
+                            local_url,  # 直接传URL,让方法内部格式化
+                            media_type="video"
+                        )
+                    return
+
+                elif status.startswith("MEDIA_GENERATION_STATUS_ERROR"):
+                    # 失败
+                    yield self._create_error_response(f"视频生成失败: {status}")
+                    return
+
+            except Exception as e:
+                debug_logger.log_error(f"Poll error: {str(e)}")
+                continue
+
+        # 超时
+        yield self._create_error_response(f"视频生成超时 (已轮询{max_attempts}次)")
+
+    # ========== 响应格式化 ==========
+
+    def _create_stream_chunk(self, content: str, role: str = None, finish_reason: str = None) -> str:
+        """创建流式响应chunk"""
+        import json
+        import time
+
+        chunk = {
+            "id": f"chatcmpl-{int(time.time())}",
+            "object": "chat.completion.chunk",
+            "created": int(time.time()),
+            "model": "flow2api",
+            "choices": [{
+                "index": 0,
+                "delta": {},
+                "finish_reason": finish_reason
+            }]
+        }
+
+        if role:
+            chunk["choices"][0]["delta"]["role"] = role
+
+        if finish_reason:
+            chunk["choices"][0]["delta"]["content"] = content
+        else:
+            chunk["choices"][0]["delta"]["reasoning_content"] = content
+
+        return f"data: {json.dumps(chunk, ensure_ascii=False)}\n\n"
+
+    def _create_completion_response(self, content: str, media_type: str = "image", is_availability_check: bool = False) -> str:
+        """创建非流式响应
+
+        Args:
+            content: 媒体URL或纯文本消息
+            media_type: 媒体类型 ("image" 或 "video")
+            is_availability_check: 是否为可用性检查响应 (纯文本消息)
+
+        Returns:
+            JSON格式的响应
+        """
+        import json
+        import time
+
+        # 可用性检查: 返回纯文本消息
+        if is_availability_check:
+            formatted_content = content
+        else:
+            # 媒体生成: 根据媒体类型格式化内容为Markdown
+            if media_type == "video":
+                formatted_content = f"```html\n<video src='{content}' controls></video>\n```"
+            else:  # image
+                formatted_content = f"![Generated Image]({content})"
+
+        response = {
+            "id": f"chatcmpl-{int(time.time())}",
+            "object": "chat.completion",
+            "created": int(time.time()),
+            "model": "flow2api",
+            "choices": [{
+                "index": 0,
+                "message": {
+                    "role": "assistant",
+                    "content": formatted_content
+                },
+                "finish_reason": "stop"
+            }]
+        }
+
+        return json.dumps(response, ensure_ascii=False)
+
+    def _create_error_response(self, error_message: str) -> str:
+        """创建错误响应"""
+        import json
+
+        error = {
+            "error": {
+                "message": error_message,
+                "type": "invalid_request_error",
+                "code": "generation_failed"
+            }
+        }
+
+        return json.dumps(error, ensure_ascii=False)
+
+    def _get_base_url(self) -> str:
+        """获取基础URL用于缓存文件访问"""
+        # 优先使用配置的cache_base_url
+        if config.cache_base_url:
+            return config.cache_base_url
+        # 否则使用服务器地址
+        return f"http://{config.server_host}:{config.server_port}"
+
+    async def _log_request(
+        self,
+        token_id: Optional[int],
+        operation: str,
+        request_data: Dict[str, Any],
+        response_data: Dict[str, Any],
+        status_code: int,
+        duration: float
+    ):
+        """记录请求到数据库"""
+        try:
+            log = RequestLog(
+                token_id=token_id,
+                operation=operation,
+                request_body=json.dumps(request_data, ensure_ascii=False),
+                response_body=json.dumps(response_data, ensure_ascii=False),
+                status_code=status_code,
+                duration=duration
+            )
+            await self.db.add_request_log(log)
+        except Exception as e:
+            # 日志记录失败不影响主流程
+            debug_logger.log_error(f"Failed to log request: {e}")
+

src/services/load_balancer.py

@@ -0,0 +1,89 @@
+"""Load balancing module for Flow2API"""
+import random
+from typing import Optional
+from ..core.models import Token
+from .concurrency_manager import ConcurrencyManager
+from ..core.logger import debug_logger
+
+
+class LoadBalancer:
+    """Token load balancer with random selection"""
+
+    def __init__(self, token_manager, concurrency_manager: Optional[ConcurrencyManager] = None):
+        self.token_manager = token_manager
+        self.concurrency_manager = concurrency_manager
+
+    async def select_token(
+        self,
+        for_image_generation: bool = False,
+        for_video_generation: bool = False,
+        model: Optional[str] = None
+    ) -> Optional[Token]:
+        """
+        Select a token using random load balancing
+
+        Args:
+            for_image_generation: If True, only select tokens with image_enabled=True
+            for_video_generation: If True, only select tokens with video_enabled=True
+            model: Model name (used to filter tokens for specific models)
+
+        Returns:
+            Selected token or None if no available tokens
+        """
+        debug_logger.log_info(f"[LOAD_BALANCER] 开始选择Token (图片生成={for_image_generation}, 视频生成={for_video_generation}, 模型={model})")
+
+        active_tokens = await self.token_manager.get_active_tokens()
+        debug_logger.log_info(f"[LOAD_BALANCER] 获取到 {len(active_tokens)} 个活跃Token")
+
+        if not active_tokens:
+            debug_logger.log_info(f"[LOAD_BALANCER] ❌ 没有活跃的Token")
+            return None
+
+        # Filter tokens based on generation type
+        available_tokens = []
+        filtered_reasons = {}  # 记录过滤原因
+
+        for token in active_tokens:
+            # Check if token has valid AT (not expired)
+            if not await self.token_manager.is_at_valid(token.id):
+                filtered_reasons[token.id] = "AT无效或已过期"
+                continue
+
+            # Filter for image generation
+            if for_image_generation:
+                if not token.image_enabled:
+                    filtered_reasons[token.id] = "图片生成已禁用"
+                    continue
+
+                # Check concurrency limit
+                if self.concurrency_manager and not await self.concurrency_manager.can_use_image(token.id):
+                    filtered_reasons[token.id] = "图片并发已满"
+                    continue
+
+            # Filter for video generation
+            if for_video_generation:
+                if not token.video_enabled:
+                    filtered_reasons[token.id] = "视频生成已禁用"
+                    continue
+
+                # Check concurrency limit
+                if self.concurrency_manager and not await self.concurrency_manager.can_use_video(token.id):
+                    filtered_reasons[token.id] = "视频并发已满"
+                    continue
+
+            available_tokens.append(token)
+
+        # 输出过滤信息
+        if filtered_reasons:
+            debug_logger.log_info(f"[LOAD_BALANCER] 已过滤Token:")
+            for token_id, reason in filtered_reasons.items():
+                debug_logger.log_info(f"[LOAD_BALANCER]   - Token {token_id}: {reason}")
+
+        if not available_tokens:
+            debug_logger.log_info(f"[LOAD_BALANCER] ❌ 没有可用的Token (图片生成={for_image_generation}, 视频生成={for_video_generation})")
+            return None
+
+        # Random selection
+        selected = random.choice(available_tokens)
+        debug_logger.log_info(f"[LOAD_BALANCER] ✅ 已选择Token {selected.id} ({selected.email}) - 余额: {selected.credits}")
+        return selected

src/services/proxy_manager.py

@@ -0,0 +1,25 @@
+"""Proxy management module"""
+from typing import Optional
+from ..core.database import Database
+from ..core.models import ProxyConfig
+
+class ProxyManager:
+    """Proxy configuration manager"""
+
+    def __init__(self, db: Database):
+        self.db = db
+
+    async def get_proxy_url(self) -> Optional[str]:
+        """Get proxy URL if enabled, otherwise return None"""
+        config = await self.db.get_proxy_config()
+        if config and config.enabled and config.proxy_url:
+            return config.proxy_url
+        return None
+
+    async def update_proxy_config(self, enabled: bool, proxy_url: Optional[str]):
+        """Update proxy configuration"""
+        await self.db.update_proxy_config(enabled, proxy_url)
+
+    async def get_proxy_config(self) -> ProxyConfig:
+        """Get proxy configuration"""
+        return await self.db.get_proxy_config()

src/services/token_manager.py

@@ -0,0 +1,504 @@
+"""Token manager for Flow2API with AT auto-refresh"""
+import asyncio
+from datetime import datetime, timedelta, timezone
+from typing import Optional, List
+from ..core.database import Database
+from ..core.models import Token, Project
+from ..core.logger import debug_logger
+from .flow_client import FlowClient
+from .proxy_manager import ProxyManager
+
+
+class TokenManager:
+    """Token lifecycle manager with AT auto-refresh"""
+
+    def __init__(self, db: Database, flow_client: FlowClient):
+        self.db = db
+        self.flow_client = flow_client
+        self._lock = asyncio.Lock()
+
+    # ========== Token CRUD ==========
+
+    async def get_all_tokens(self) -> List[Token]:
+        """Get all tokens"""
+        return await self.db.get_all_tokens()
+
+    async def get_active_tokens(self) -> List[Token]:
+        """Get all active tokens"""
+        return await self.db.get_active_tokens()
+
+    async def get_token(self, token_id: int) -> Optional[Token]:
+        """Get token by ID"""
+        return await self.db.get_token(token_id)
+
+    async def delete_token(self, token_id: int):
+        """Delete token"""
+        await self.db.delete_token(token_id)
+
+    async def enable_token(self, token_id: int):
+        """Enable a token and reset error count"""
+        # Enable the token
+        await self.db.update_token(token_id, is_active=True)
+        # Reset error count when enabling (only reset total error_count, keep today_error_count)
+        await self.db.reset_error_count(token_id)
+
+    async def disable_token(self, token_id: int):
+        """Disable a token"""
+        await self.db.update_token(token_id, is_active=False)
+
+    # ========== Token添加 (支持Project创建) ==========
+
+    async def add_token(
+        self,
+        st: str,
+        project_id: Optional[str] = None,
+        project_name: Optional[str] = None,
+        remark: Optional[str] = None,
+        image_enabled: bool = True,
+        video_enabled: bool = True,
+        image_concurrency: int = -1,
+        video_concurrency: int = -1
+    ) -> Token:
+        """Add a new token
+
+        Args:
+            st: Session Token (必需)
+            project_id: 项目ID (可选,如果提供则直接使用,不创建新项目)
+            project_name: 项目名称 (可选,如果不提供则自动生成)
+            remark: 备注
+            image_enabled: 是否启用图片生成
+            video_enabled: 是否启用视频生成
+            image_concurrency: 图片并发限制
+            video_concurrency: 视频并发限制
+
+        Returns:
+            Token object
+        """
+        # Step 1: 检查ST是否已存在
+        existing_token = await self.db.get_token_by_st(st)
+        if existing_token:
+            raise ValueError(f"Token 已存在（邮箱: {existing_token.email}）")
+
+        # Step 2: 使用ST转换AT
+        debug_logger.log_info(f"[ADD_TOKEN] Converting ST to AT...")
+        try:
+            result = await self.flow_client.st_to_at(st)
+            at = result["access_token"]
+            expires = result.get("expires")
+            user_info = result.get("user", {})
+            email = user_info.get("email", "")
+            name = user_info.get("name", email.split("@")[0] if email else "")
+
+            # 解析过期时间
+            at_expires = None
+            if expires:
+                try:
+                    at_expires = datetime.fromisoformat(expires.replace('Z', '+00:00'))
+                except:
+                    pass
+
+        except Exception as e:
+            raise ValueError(f"ST转AT失败: {str(e)}")
+
+        # Step 3: 查询余额
+        try:
+            credits_result = await self.flow_client.get_credits(at)
+            credits = credits_result.get("credits", 0)
+            user_paygate_tier = credits_result.get("userPaygateTier")
+        except:
+            credits = 0
+            user_paygate_tier = None
+
+        # Step 4: 处理Project ID和名称
+        if project_id:
+            # 用户提供了project_id,直接使用
+            debug_logger.log_info(f"[ADD_TOKEN] Using provided project_id: {project_id}")
+            if not project_name:
+                # 如果没有提供project_name,生成一个
+                now = datetime.now()
+                project_name = now.strftime("%b %d - %H:%M")
+        else:
+            # 用户没有提供project_id,需要创建新项目
+            if not project_name:
+                # 自动生成项目名称
+                now = datetime.now()
+                project_name = now.strftime("%b %d - %H:%M")
+
+            try:
+                project_id = await self.flow_client.create_project(st, project_name)
+                debug_logger.log_info(f"[ADD_TOKEN] Created new project: {project_name} (ID: {project_id})")
+            except Exception as e:
+                raise ValueError(f"创建项目失败: {str(e)}")
+
+        # Step 5: 创建Token对象
+        token = Token(
+            st=st,
+            at=at,
+            at_expires=at_expires,
+            email=email,
+            name=name,
+            remark=remark,
+            is_active=True,
+            credits=credits,
+            user_paygate_tier=user_paygate_tier,
+            current_project_id=project_id,
+            current_project_name=project_name,
+            image_enabled=image_enabled,
+            video_enabled=video_enabled,
+            image_concurrency=image_concurrency,
+            video_concurrency=video_concurrency
+        )
+
+        # Step 6: 保存到数据库
+        token_id = await self.db.add_token(token)
+        token.id = token_id
+
+        # Step 7: 保存Project到数据库
+        project = Project(
+            project_id=project_id,
+            token_id=token_id,
+            project_name=project_name,
+            tool_name="PINHOLE"
+        )
+        await self.db.add_project(project)
+
+        debug_logger.log_info(f"[ADD_TOKEN] Token added successfully (ID: {token_id}, Email: {email})")
+        return token
+
+    async def update_token(
+        self,
+        token_id: int,
+        st: Optional[str] = None,
+        at: Optional[str] = None,
+        at_expires: Optional[datetime] = None,
+        project_id: Optional[str] = None,
+        project_name: Optional[str] = None,
+        remark: Optional[str] = None,
+        image_enabled: Optional[bool] = None,
+        video_enabled: Optional[bool] = None,
+        image_concurrency: Optional[int] = None,
+        video_concurrency: Optional[int] = None
+    ):
+        """Update token (支持修改project_id和project_name)
+
+        当用户编辑保存token时，如果token未过期，自动清空429禁用状态
+        """
+        update_fields = {}
+
+        if st is not None:
+            update_fields["st"] = st
+        if at is not None:
+            update_fields["at"] = at
+        if at_expires is not None:
+            update_fields["at_expires"] = at_expires
+        if project_id is not None:
+            update_fields["current_project_id"] = project_id
+        if project_name is not None:
+            update_fields["current_project_name"] = project_name
+        if remark is not None:
+            update_fields["remark"] = remark
+        if image_enabled is not None:
+            update_fields["image_enabled"] = image_enabled
+        if video_enabled is not None:
+            update_fields["video_enabled"] = video_enabled
+        if image_concurrency is not None:
+            update_fields["image_concurrency"] = image_concurrency
+        if video_concurrency is not None:
+            update_fields["video_concurrency"] = video_concurrency
+
+        # 检查token是否因429被禁用，如果是且未过期，则清空429状态
+        token = await self.db.get_token(token_id)
+        if token and token.ban_reason == "429_rate_limit":
+            # 检查token是否过期
+            is_expired = False
+            if token.at_expires:
+                now = datetime.now(timezone.utc)
+                if token.at_expires.tzinfo is None:
+                    at_expires_aware = token.at_expires.replace(tzinfo=timezone.utc)
+                else:
+                    at_expires_aware = token.at_expires
+                is_expired = at_expires_aware <= now
+
+            # 如果未过期，清空429禁用状态
+            if not is_expired:
+                debug_logger.log_info(f"[UPDATE_TOKEN] Token {token_id} 编辑保存，清空429禁用状态")
+                update_fields["ban_reason"] = None
+                update_fields["banned_at"] = None
+
+        if update_fields:
+            await self.db.update_token(token_id, **update_fields)
+
+    # ========== AT自动刷新逻辑 (核心) ==========
+
+    async def is_at_valid(self, token_id: int) -> bool:
+        """检查AT是否有效,如果无效或即将过期则自动刷新
+
+        Returns:
+            True if AT is valid or refreshed successfully
+            False if AT cannot be refreshed
+        """
+        token = await self.db.get_token(token_id)
+        if not token:
+            return False
+
+        # 如果AT不存在,需要刷新
+        if not token.at:
+            debug_logger.log_info(f"[AT_CHECK] Token {token_id}: AT不存在,需要刷新")
+            return await self._refresh_at(token_id)
+
+        # 如果没有过期时间,假设需要刷新
+        if not token.at_expires:
+            debug_logger.log_info(f"[AT_CHECK] Token {token_id}: AT过期时间未知,尝试刷新")
+            return await self._refresh_at(token_id)
+
+        # 检查是否即将过期 (提前1小时刷新)
+        now = datetime.now(timezone.utc)
+        # 确保at_expires也是timezone-aware
+        if token.at_expires.tzinfo is None:
+            at_expires_aware = token.at_expires.replace(tzinfo=timezone.utc)
+        else:
+            at_expires_aware = token.at_expires
+
+        time_until_expiry = at_expires_aware - now
+
+        if time_until_expiry.total_seconds() < 3600:  # 1 hour (3600 seconds)
+            debug_logger.log_info(f"[AT_CHECK] Token {token_id}: AT即将过期 (剩余 {time_until_expiry.total_seconds():.0f} 秒),需要刷新")
+            return await self._refresh_at(token_id)
+
+        # AT有效
+        return True
+
+    async def _refresh_at(self, token_id: int) -> bool:
+        """内部方法: 刷新AT
+
+        Returns:
+            True if refresh successful, False otherwise
+        """
+        async with self._lock:
+            token = await self.db.get_token(token_id)
+            if not token:
+                return False
+
+            try:
+                debug_logger.log_info(f"[AT_REFRESH] Token {token_id}: 开始刷新AT...")
+
+                # 使用ST转AT
+                result = await self.flow_client.st_to_at(token.st)
+                new_at = result["access_token"]
+                expires = result.get("expires")
+
+                # 解析过期时间
+                new_at_expires = None
+                if expires:
+                    try:
+                        new_at_expires = datetime.fromisoformat(expires.replace('Z', '+00:00'))
+                    except:
+                        pass
+
+                # 更新数据库
+                await self.db.update_token(
+                    token_id,
+                    at=new_at,
+                    at_expires=new_at_expires
+                )
+
+                debug_logger.log_info(f"[AT_REFRESH] Token {token_id}: AT刷新成功")
+                debug_logger.log_info(f"  - 新过期时间: {new_at_expires}")
+
+                # 同时刷新credits
+                try:
+                    credits_result = await self.flow_client.get_credits(new_at)
+                    await self.db.update_token(
+                        token_id,
+                        credits=credits_result.get("credits", 0)
+                    )
+                except:
+                    pass
+
+                return True
+
+            except Exception as e:
+                debug_logger.log_error(f"[AT_REFRESH] Token {token_id}: AT刷新失败 - {str(e)}")
+                # 刷新失败,禁用Token
+                await self.disable_token(token_id)
+                return False
+
+    async def ensure_project_exists(self, token_id: int) -> str:
+        """确保Token有可用的Project
+
+        Returns:
+            project_id
+        """
+        token = await self.db.get_token(token_id)
+        if not token:
+            raise ValueError("Token not found")
+
+        # 如果已有project_id,直接返回
+        if token.current_project_id:
+            return token.current_project_id
+
+        # 创建新Project
+        now = datetime.now()
+        project_name = now.strftime("%b %d - %H:%M")
+
+        try:
+            project_id = await self.flow_client.create_project(token.st, project_name)
+            debug_logger.log_info(f"[PROJECT] Created project for token {token_id}: {project_name}")
+
+            # 更新Token
+            await self.db.update_token(
+                token_id,
+                current_project_id=project_id,
+                current_project_name=project_name
+            )
+
+            # 保存Project到数据库
+            project = Project(
+                project_id=project_id,
+                token_id=token_id,
+                project_name=project_name
+            )
+            await self.db.add_project(project)
+
+            return project_id
+
+        except Exception as e:
+            raise ValueError(f"Failed to create project: {str(e)}")
+
+    # ========== Token使用统计 ==========
+
+    async def record_usage(self, token_id: int, is_video: bool = False):
+        """Record token usage"""
+        await self.db.update_token(token_id, use_count=1, last_used_at=datetime.now())
+
+        if is_video:
+            await self.db.increment_token_stats(token_id, "video")
+        else:
+            await self.db.increment_token_stats(token_id, "image")
+
+    async def record_error(self, token_id: int):
+        """Record token error and auto-disable if threshold reached"""
+        await self.db.increment_token_stats(token_id, "error")
+
+        # Check if should auto-disable token (based on consecutive errors)
+        stats = await self.db.get_token_stats(token_id)
+        admin_config = await self.db.get_admin_config()
+
+        if stats and stats.consecutive_error_count >= admin_config.error_ban_threshold:
+            debug_logger.log_warning(
+                f"[TOKEN_BAN] Token {token_id} consecutive error count ({stats.consecutive_error_count}) "
+                f"reached threshold ({admin_config.error_ban_threshold}), auto-disabling"
+            )
+            await self.disable_token(token_id)
+
+    async def record_success(self, token_id: int):
+        """Record successful request (reset consecutive error count)
+
+        This method resets error_count to 0, which is used for auto-disable threshold checking.
+        Note: today_error_count and historical statistics are NOT reset.
+        """
+        await self.db.reset_error_count(token_id)
+
+    async def ban_token_for_429(self, token_id: int):
+        """因429错误立即禁用token
+
+        Args:
+            token_id: Token ID
+        """
+        debug_logger.log_warning(f"[429_BAN] 禁用Token {token_id} (原因: 429 Rate Limit)")
+        await self.db.update_token(
+            token_id,
+            is_active=False,
+            ban_reason="429_rate_limit",
+            banned_at=datetime.now(timezone.utc)
+        )
+
+    async def auto_unban_429_tokens(self):
+        """自动解禁因429被禁用的token
+
+        规则:
+        - 距离禁用时间12小时后自动解禁
+        - 仅解禁未过期的token
+        - 仅解禁因429被禁用的token
+        """
+        all_tokens = await self.db.get_all_tokens()
+        now = datetime.now(timezone.utc)
+
+        for token in all_tokens:
+            # 跳过非429禁用的token
+            if token.ban_reason != "429_rate_limit":
+                continue
+
+            # 跳过未禁用的token
+            if token.is_active:
+                continue
+
+            # 跳过没有禁用时间的token
+            if not token.banned_at:
+                continue
+
+            # 检查token是否已过期
+            if token.at_expires:
+                # 确保时区一致
+                if token.at_expires.tzinfo is None:
+                    at_expires_aware = token.at_expires.replace(tzinfo=timezone.utc)
+                else:
+                    at_expires_aware = token.at_expires
+
+                # 如果已过期，跳过
+                if at_expires_aware <= now:
+                    debug_logger.log_info(f"[AUTO_UNBAN] Token {token.id} 已过期，跳过解禁")
+                    continue
+
+            # 确保banned_at时区一致
+            if token.banned_at.tzinfo is None:
+                banned_at_aware = token.banned_at.replace(tzinfo=timezone.utc)
+            else:
+                banned_at_aware = token.banned_at
+
+            # 检查是否已过12小时
+            time_since_ban = now - banned_at_aware
+            if time_since_ban.total_seconds() >= 12 * 3600:  # 12小时
+                debug_logger.log_info(
+                    f"[AUTO_UNBAN] 解禁Token {token.id} (禁用时间: {banned_at_aware}, "
+                    f"已过 {time_since_ban.total_seconds() / 3600:.1f} 小时)"
+                )
+                await self.db.update_token(
+                    token.id,
+                    is_active=True,
+                    ban_reason=None,
+                    banned_at=None
+                )
+                # 重置错误计数
+                await self.db.reset_error_count(token.id)
+
+    # ========== 余额刷新 ==========
+
+    async def refresh_credits(self, token_id: int) -> int:
+        """刷新Token余额
+
+        Returns:
+            credits
+        """
+        token = await self.db.get_token(token_id)
+        if not token:
+            return 0
+
+        # 确保AT有效
+        if not await self.is_at_valid(token_id):
+            return 0
+
+        # 重新获取token (AT可能已刷新)
+        token = await self.db.get_token(token_id)
+
+        try:
+            result = await self.flow_client.get_credits(token.at)
+            credits = result.get("credits", 0)
+
+            # 更新数据库
+            await self.db.update_token(token_id, credits=credits)
+
+            return credits
+        except Exception as e:
+            debug_logger.log_error(f"Failed to refresh credits for token {token_id}: {str(e)}")
+            return 0

static/login.html

@@ -0,0 +1,53 @@
+<!DOCTYPE html>
+<html lang="zh-CN" class="h-full">
+<head>
+    <meta charset="UTF-8">
+    <meta name="viewport" content="width=device-width, initial-scale=1.0">
+    <title>登录 - Flow2API</title>
+    <script src="https://cdn.tailwindcss.com"></script>
+    <style>
+        @keyframes slide-up{from{transform:translateY(100%);opacity:0}to{transform:translateY(0);opacity:1}}
+        .animate-slide-up{animation:slide-up .3s ease-out}
+    </style>
+    <script>
+        tailwind.config={theme:{extend:{colors:{border:"hsl(0 0% 89%)",input:"hsl(0 0% 89%)",ring:"hsl(0 0% 3.9%)",background:"hsl(0 0% 100%)",foreground:"hsl(0 0% 3.9%)",primary:{DEFAULT:"hsl(0 0% 9%)",foreground:"hsl(0 0% 98%)"},secondary:{DEFAULT:"hsl(0 0% 96.1%)",foreground:"hsl(0 0% 9%)"},muted:{DEFAULT:"hsl(0 0% 96.1%)",foreground:"hsl(0 0% 45.1%)"},destructive:{DEFAULT:"hsl(0 84.2% 60.2%)",foreground:"hsl(0 0% 98%)"}}}}}
+    </script>
+</head>
+<body class="h-full bg-background text-foreground antialiased">
+    <div class="flex min-h-full flex-col justify-center py-12 px-4 sm:px-6 lg:px-8">
+        <div class="sm:mx-auto sm:w-full sm:max-w-md">
+            <div class="text-center">
+                <h1 class="text-4xl font-bold">Flow2API</h1>
+                <p class="mt-2 text-sm text-muted-foreground">管理员控制台</p>
+            </div>
+        </div>
+
+        <div class="sm:mx-auto sm:w-full sm:max-w-md">
+            <div class="bg-background py-8 px-4 sm:px-10 rounded-lg">
+                <form id="loginForm" class="space-y-6">
+                    <div class="space-y-2">
+                        <label for="username" class="text-sm font-medium">账户</label>
+                        <input type="text" id="username" name="username" required class="flex h-10 w-full rounded-md border border-input bg-background px-3 py-2 text-sm placeholder:text-muted-foreground focus-visible:outline-none focus-visible:ring-2 focus-visible:ring-ring disabled:opacity-50" placeholder="请输入账户">
+                    </div>
+                    <div class="space-y-2">
+                        <label for="password" class="text-sm font-medium">密码</label>
+                        <input type="password" id="password" name="password" required class="flex h-10 w-full rounded-md border border-input bg-background px-3 py-2 text-sm placeholder:text-muted-foreground focus-visible:outline-none focus-visible:ring-2 focus-visible:ring-ring disabled:opacity-50" placeholder="请输入密码">
+                    </div>
+                    <button type="submit" id="loginButton" class="inline-flex items-center justify-center rounded-md font-medium transition-colors bg-primary text-primary-foreground hover:bg-primary/90 h-10 w-full disabled:opacity-50">登录</button>
+                </form>
+
+                <div class="mt-6 text-center text-xs text-muted-foreground">
+                    <p>Flow2API © 2025</p>
+                </div>
+            </div>
+        </div>
+    </div>
+
+    <script>
+        const form=document.getElementById('loginForm'),btn=document.getElementById('loginButton');
+        form.addEventListener('submit',async(e)=>{e.preventDefault();btn.disabled=true;btn.textContent='登录中...';try{const fd=new FormData(form),r=await fetch('/api/login',{method:'POST',headers:{'Content-Type':'application/json'},body:JSON.stringify({username:fd.get('username'),password:fd.get('password')})});const d=await r.json();d.success?(localStorage.setItem('adminToken',d.token),location.href='/manage'):showToast(d.message||'登录失败','error')}catch(e){showToast('网络错误,请稍后重试','error')}finally{btn.disabled=false;btn.textContent='登录'}});
+        function showToast(m,t='error'){const d=document.createElement('div'),bc={success:'bg-green-600',error:'bg-destructive',info:'bg-primary'};d.className=`fixed bottom-4 right-4 ${bc[t]||bc.error} text-white px-4 py-2.5 rounded-lg shadow-lg text-sm font-medium z-50 animate-slide-up`;d.textContent=m;document.body.appendChild(d);setTimeout(()=>{d.style.opacity='0';d.style.transition='opacity .3s';setTimeout(()=>d.parentNode&&document.body.removeChild(d),300)},2000)}
+        window.addEventListener('DOMContentLoaded',()=>{const t=localStorage.getItem('adminToken');t&&fetch('/api/stats',{headers:{Authorization:`Bearer ${t}`}}).then(r=>{if(r.ok)location.href='/manage'})});
+    </script>
+</body>
+</html>

static/manage.html

@@ -0,0 +1,722 @@
+<!DOCTYPE html>
+<html lang="zh-CN" class="h-full">
+<head>
+    <meta charset="UTF-8">
+    <meta name="viewport" content="width=device-width, initial-scale=1.0">
+    <title>管理控制台 - Flow2API</title>
+    <script src="https://cdn.tailwindcss.com"></script>
+    <style>
+        @keyframes slide-up{from{transform:translateY(100%);opacity:0}to{transform:translateY(0);opacity:1}}
+        .animate-slide-up{animation:slide-up .3s ease-out}
+        .tab-btn{transition:all .2s ease}
+    </style>
+    <script>
+        tailwind.config={theme:{extend:{colors:{border:"hsl(0 0% 89%)",input:"hsl(0 0% 89%)",ring:"hsl(0 0% 3.9%)",background:"hsl(0 0% 100%)",foreground:"hsl(0 0% 3.9%)",primary:{DEFAULT:"hsl(0 0% 9%)",foreground:"hsl(0 0% 98%)"},secondary:{DEFAULT:"hsl(0 0% 96.1%)",foreground:"hsl(0 0% 9%)"},muted:{DEFAULT:"hsl(0 0% 96.1%)",foreground:"hsl(0 0% 45.1%)"},destructive:{DEFAULT:"hsl(0 84.2% 60.2%)",foreground:"hsl(0 0% 98%)"}}}}}
+    </script>
+</head>
+<body class="h-full bg-background text-foreground antialiased">
+    <!-- 导航栏 -->
+    <header class="sticky top-0 z-50 w-full border-b border-border/40 bg-background/95 backdrop-blur">
+        <div class="mx-auto flex h-14 max-w-7xl items-center px-6">
+            <div class="mr-4 flex items-baseline gap-3">
+                <span class="font-bold text-xl">Flow2API</span>
+            </div>
+            <div class="flex flex-1 items-center justify-end gap-3">
+                <a href="https://github.com/TheSmallHanCat/flow2api" target="_blank" class="inline-flex items-center justify-center text-xs transition-colors hover:bg-accent hover:text-accent-foreground h-7 px-2.5" title="GitHub 仓库">
+                    <svg class="h-4 w-4" xmlns="http://www.w3.org/2000/svg" viewBox="0 0 24 24" fill="currentColor">
+                        <path d="M12 0c-6.626 0-12 5.373-12 12 0 5.302 3.438 9.8 8.207 11.387.599.111.793-.261.793-.577v-2.234c-3.338.726-4.033-1.416-4.033-1.416-.546-1.387-1.333-1.756-1.333-1.756-1.089-.745.083-.729.083-.729 1.205.084 1.839 1.237 1.839 1.237 1.07 1.834 2.807 1.304 3.492.997.107-.775.418-1.305.762-1.604-2.665-.305-5.467-1.334-5.467-5.931 0-1.311.469-2.381 1.236-3.221-.124-.303-.535-1.524.117-3.176 0 0 1.008-.322 3.301 1.23.957-.266 1.983-.399 3.003-.404 1.02.005 2.047.138 3.006.404 2.291-1.552 3.297-1.23 3.297-1.23.653 1.653.242 2.874.118 3.176.77.84 1.235 1.911 1.235 3.221 0 4.609-2.807 5.624-5.479 5.921.43.372.823 1.102.823 2.222v 3.293c0 .319.192.694.801.576 4.765-1.589 8.199-6.086 8.199-11.386 0-6.627-5.373-12-12-12z"/>
+                    </svg>
+                </a>
+                <button onclick="logout()" class="inline-flex items-center justify-center text-xs transition-colors hover:bg-accent hover:text-accent-foreground h-7 px-2.5 gap-1">
+                    <svg class="h-3.5 w-3.5" xmlns="http://www.w3.org/2000/svg" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2">
+                        <path d="M9 21H5a2 2 0 0 1-2-2V5a2 2 0 0 1 2-2h4"/>
+                        <polyline points="16 17 21 12 16 7"/>
+                        <line x1="21" y1="12" x2="9" y2="12"/>
+                    </svg>
+                    退出
+                </button>
+            </div>
+        </div>
+    </header>
+
+    <main class="mx-auto max-w-7xl px-6 py-6">
+        <!-- Tab 导航 -->
+        <div class="border-b border-border mb-6">
+            <nav class="flex space-x-8">
+                <button onclick="switchTab('tokens')" id="tabTokens" class="tab-btn border-b-2 border-primary text-sm font-medium py-3 px-1">Token 管理</button>
+                <button onclick="switchTab('settings')" id="tabSettings" class="tab-btn border-b-2 border-transparent text-sm font-medium py-3 px-1">系统配置</button>
+                <button onclick="switchTab('logs')" id="tabLogs" class="tab-btn border-b-2 border-transparent text-sm font-medium py-3 px-1">请求日志</button>
+            </nav>
+        </div>
+
+        <!-- Token 管理面板 -->
+        <div id="panelTokens">
+            <!-- 统计卡片 -->
+            <div class="grid gap-4 grid-cols-2 md:grid-cols-5 mb-6">
+                <div class="rounded-lg border border-border bg-background p-4">
+                    <p class="text-sm font-medium text-muted-foreground mb-2">Token 总数</p>
+                    <h3 class="text-xl font-bold" id="statTotal">-</h3>
+                </div>
+                <div class="rounded-lg border border-border bg-background p-4">
+                    <p class="text-sm font-medium text-muted-foreground mb-2">活跃 Token</p>
+                    <h3 class="text-xl font-bold text-green-600" id="statActive">-</h3>
+                </div>
+                <div class="rounded-lg border border-border bg-background p-4">
+                    <p class="text-sm font-medium text-muted-foreground mb-2">今日图片/总图片</p>
+                    <h3 class="text-xl font-bold text-blue-600" id="statImages">-</h3>
+                </div>
+                <div class="rounded-lg border border-border bg-background p-4">
+                    <p class="text-sm font-medium text-muted-foreground mb-2">今日视频/总视频</p>
+                    <h3 class="text-xl font-bold text-purple-600" id="statVideos">-</h3>
+                </div>
+                <div class="rounded-lg border border-border bg-background p-4">
+                    <p class="text-sm font-medium text-muted-foreground mb-2">今日错误/总错误</p>
+                    <h3 class="text-xl font-bold text-destructive" id="statErrors">-</h3>
+                </div>
+            </div>
+
+            <!-- Token 列表 -->
+            <div class="rounded-lg border border-border bg-background">
+                <div class="flex items-center justify-between gap-4 p-4 border-b border-border">
+                    <h3 class="text-lg font-semibold">Token 列表</h3>
+                    <div class="flex items-center gap-3">
+                        <!-- 自动刷新AT标签和开关 -->
+                        <div class="flex items-center gap-2">
+                            <span class="text-xs text-muted-foreground">自动刷新AT</span>
+                            <div class="relative inline-flex items-center group">
+                                <label class="inline-flex items-center cursor-pointer">
+                                    <input type="checkbox" id="atAutoRefreshToggle" onchange="toggleATAutoRefresh()" class="sr-only peer">
+                                    <div class="relative w-11 h-6 bg-gray-200 peer-focus:outline-none peer-focus:ring-2 peer-focus:ring-primary rounded-full peer peer-checked:after:translate-x-full peer-checked:after:border-white after:content-[''] after:absolute after:top-[2px] after:left-[2px] after:bg-white after:border-gray-300 after:border after:rounded-full after:h-5 after:w-5 after:transition-all peer-checked:bg-primary"></div>
+                                </label>
+                                <!-- 悬浮提示 -->
+                                <div class="absolute bottom-full mb-2 left-1/2 transform -translate-x-1/2 bg-gray-900 text-white text-xs rounded px-2 py-1 whitespace-nowrap opacity-0 group-hover:opacity-100 transition-opacity pointer-events-none z-10">
+                                    Token距离过期<1h时自动使用ST刷新AT
+                                    <div class="absolute top-full left-1/2 transform -translate-x-1/2 border-4 border-transparent border-t-gray-900"></div>
+                                </div>
+                            </div>
+                        </div>
+                        <button onclick="refreshTokens()" class="inline-flex items-center justify-center rounded-md transition-colors hover:bg-accent h-8 w-8" title="刷新">
+                            <svg class="h-4 w-4" xmlns="http://www.w3.org/2000/svg" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2">
+                                <polyline points="23 4 23 10 17 10"/><polyline points="1 20 1 14 7 14"/><path d="M3.51 9a9 9 0 0 1 14.85-3.36L23 10M1 14l4.64 4.36A9 9 0 0 0 20.49 15"/>
+                            </svg>
+                        </button>
+                        <button onclick="exportTokens()" class="inline-flex items-center justify-center rounded-md bg-blue-600 text-white hover:bg-blue-700 h-8 px-3" title="导出所有Token">
+                            <svg class="h-4 w-4 mr-2" xmlns="http://www.w3.org/2000/svg" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2">
+                                <path d="M21 15v4a2 2 0 0 1-2 2H5a2 2 0 0 1-2-2v-4"/>
+                                <polyline points="7 10 12 15 17 10"/>
+                                <line x1="12" y1="15" x2="12" y2="3"/>
+                            </svg>
+                            <span class="text-sm font-medium">导出</span>
+                        </button>
+                        <button onclick="openImportModal()" class="inline-flex items-center justify-center rounded-md bg-green-600 text-white hover:bg-green-700 h-8 px-3" title="导入Token">
+                            <svg class="h-4 w-4 mr-2" xmlns="http://www.w3.org/2000/svg" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2">
+                                <path d="M21 15v4a2 2 0 0 1-2 2H5a2 2 0 0 1-2-2v-4"/>
+                                <polyline points="17 8 12 3 7 8"/>
+                                <line x1="12" y1="3" x2="12" y2="15"/>
+                            </svg>
+                            <span class="text-sm font-medium">导入</span>
+                        </button>
+                        <button onclick="openAddModal()" class="inline-flex items-center justify-center rounded-md bg-primary text-primary-foreground hover:bg-primary/90 h-8 px-3">
+                            <svg class="h-4 w-4 mr-2" xmlns="http://www.w3.org/2000/svg" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2">
+                                <line x1="12" y1="5" x2="12" y2="19"/>
+                                <line x1="5" y1="12" x2="19" y2="12"/>
+                            </svg>
+                            <span class="text-sm font-medium">新增</span>
+                        </button>
+                    </div>
+                </div>
+                
+                <div class="relative w-full overflow-auto">
+                    <table class="w-full text-sm">
+                        <thead>
+                            <tr class="border-b border-border">
+                                <th class="h-10 px-3 text-left align-middle font-medium text-muted-foreground">邮箱</th>
+                                <th class="h-10 px-3 text-left align-middle font-medium text-muted-foreground">状态</th>
+                                <th class="h-10 px-3 text-left align-middle font-medium text-muted-foreground">过期时间</th>
+                                <th class="h-10 px-3 text-left align-middle font-medium text-muted-foreground">余额</th>
+                                <th class="h-10 px-3 text-left align-middle font-medium text-muted-foreground">类型</th>
+                                <th class="h-10 px-3 text-left align-middle font-medium text-muted-foreground">项目名称</th>
+                                <th class="h-10 px-3 text-left align-middle font-medium text-muted-foreground">项目ID</th>
+                                <th class="h-10 px-3 text-left align-middle font-medium text-muted-foreground">图片</th>
+                                <th class="h-10 px-3 text-left align-middle font-medium text-muted-foreground">视频</th>
+                                <th class="h-10 px-3 text-left align-middle font-medium text-muted-foreground">错误</th>
+                                <th class="h-10 px-3 text-left align-middle font-medium text-muted-foreground">备注</th>
+                                <th class="h-10 px-3 text-right align-middle font-medium text-muted-foreground">操作</th>
+                            </tr>
+                        </thead>
+                        <tbody id="tokenTableBody" class="divide-y divide-border">
+                            <!-- 动态填充 -->
+                        </tbody>
+                    </table>
+                </div>
+            </div>
+        </div>
+
+        <!-- 系统配置面板 -->
+        <div id="panelSettings" class="hidden">
+            <div class="grid gap-6 lg:grid-cols-2">
+                <!-- 安全配置 -->
+                <div class="rounded-lg border border-border bg-background p-6">
+                    <h3 class="text-lg font-semibold mb-4">安全配置</h3>
+                    <div class="space-y-4">
+                        <div>
+                            <label class="text-sm font-medium mb-2 block">管理员用户名</label>
+                            <input id="cfgAdminUsername" type="text" class="flex h-9 w-full rounded-md border border-input bg-background px-3 py-2 text-sm">
+                            <p class="text-xs text-muted-foreground mt-1">管理员用户名</p>
+                        </div>
+                        <div>
+                            <label class="text-sm font-medium mb-2 block">旧密码</label>
+                            <input id="cfgOldPassword" type="password" class="flex h-9 w-full rounded-md border border-input bg-background px-3 py-2 text-sm" placeholder="输入旧密码">
+                        </div>
+                        <div>
+                            <label class="text-sm font-medium mb-2 block">新密码</label>
+                            <input id="cfgNewPassword" type="password" class="flex h-9 w-full rounded-md border border-input bg-background px-3 py-2 text-sm" placeholder="输入新密码">
+                        </div>
+                        <button onclick="updateAdminPassword()" class="inline-flex items-center justify-center rounded-md bg-primary text-primary-foreground hover:bg-primary/90 h-9 px-4 w-full">修改密码</button>
+                    </div>
+                </div>
+
+                <!-- API 密钥配置 -->
+                <div class="rounded-lg border border-border bg-background p-6">
+                    <h3 class="text-lg font-semibold mb-4">API 密钥配置</h3>
+                    <div class="space-y-4">
+                        <div>
+                            <label class="text-sm font-medium mb-2 block">当前 API Key</label>
+                            <input id="cfgCurrentAPIKey" type="text" class="flex h-9 w-full rounded-md border border-input bg-background px-3 py-2 text-sm" readonly disabled>
+                            <p class="text-xs text-muted-foreground mt-1">当前使用的 API Key（只读）</p>
+                        </div>
+                        <div>
+                            <label class="text-sm font-medium mb-2 block">新 API Key</label>
+                            <input id="cfgNewAPIKey" type="text" class="flex h-9 w-full rounded-md border border-input bg-background px-3 py-2 text-sm" placeholder="输入新的 API Key">
+                            <p class="text-xs text-muted-foreground mt-1">用于客���端调用 API 的密钥</p>
+                        </div>
+                        <button onclick="updateAPIKey()" class="inline-flex items-center justify-center rounded-md bg-primary text-primary-foreground hover:bg-primary/90 h-9 px-4 w-full">更新 API Key</button>
+                    </div>
+                </div>
+
+                <!-- 代理配置 -->
+                <div class="rounded-lg border border-border bg-background p-6">
+                    <h3 class="text-lg font-semibold mb-4">代理配置</h3>
+                    <div class="space-y-4">
+                        <div>
+                            <label class="inline-flex items-center gap-2 cursor-pointer">
+                                <input type="checkbox" id="cfgProxyEnabled" class="h-4 w-4 rounded border-input">
+                                <span class="text-sm font-medium">启用代理</span>
+                            </label>
+                        </div>
+                        <div>
+                            <label class="text-sm font-medium mb-2 block">代理地址</label>
+                            <input id="cfgProxyUrl" class="flex h-9 w-full rounded-md border border-input bg-background px-3 py-2 text-sm" placeholder="http://127.0.0.1:7890 或 socks5://127.0.0.1:1080">
+                            <p class="text-xs text-muted-foreground mt-1">支持 HTTP 和 SOCKS5 代理</p>
+                        </div>
+                        <button onclick="saveProxyConfig()" class="inline-flex items-center justify-center rounded-md bg-primary text-primary-foreground hover:bg-primary/90 h-9 px-4 w-full">保存配置</button>
+                    </div>
+                </div>
+
+                <!-- 错误处理配置 -->
+                <div class="rounded-lg border border-border bg-background p-6">
+                    <h3 class="text-lg font-semibold mb-4">错误处理配置</h3>
+                    <div class="space-y-4">
+                        <div>
+                            <label class="text-sm font-medium mb-2 block">错误封禁阈值</label>
+                            <input id="cfgErrorBan" type="number" class="flex h-9 w-full rounded-md border border-input bg-background px-3 py-2 text-sm" placeholder="3">
+                            <p class="text-xs text-muted-foreground mt-1">Token 连续错误达到此次数后自动禁用</p>
+                        </div>
+                        <button onclick="saveAdminConfig()" class="inline-flex items-center justify-center rounded-md bg-primary text-primary-foreground hover:bg-primary/90 h-9 px-4 w-full">保存配置</button>
+                    </div>
+                </div>
+
+                <!-- 缓存配置 -->
+                <div class="rounded-lg border border-border bg-background p-6">
+                    <h3 class="text-lg font-semibold mb-4">缓存配置</h3>
+                    <div class="space-y-4">
+                        <div>
+                            <label class="inline-flex items-center gap-2 cursor-pointer">
+                                <input type="checkbox" id="cfgCacheEnabled" class="h-4 w-4 rounded border-input" onchange="toggleCacheOptions()">
+                                <span class="text-sm font-medium">启用缓存</span>
+                            </label>
+                            <p class="text-xs text-muted-foreground mt-1">关闭后，生成的图片和视频将直接输出原始链接，不会缓存到本地</p>
+                        </div>
+
+                        <!-- 缓存配置选项 -->
+                        <div id="cacheOptions" style="display: none;" class="space-y-4 pt-4 border-t border-border">
+                            <div>
+                                <label class="text-sm font-medium mb-2 block">缓存超时时间（秒）</label>
+                                <input id="cfgCacheTimeout" type="number" class="flex h-9 w-full rounded-md border border-input bg-background px-3 py-2 text-sm" placeholder="7200" min="60" max="86400">
+                                <p class="text-xs text-muted-foreground mt-1">文件缓存超时时间，范围：60-86400 秒（1分钟-24小时）</p>
+                            </div>
+                            <div>
+                                <label class="text-sm font-medium mb-2 block">缓存文件访问域名</label>
+                                <input id="cfgCacheBaseUrl" type="text" class="flex h-9 w-full rounded-md border border-input bg-background px-3 py-2 text-sm" placeholder="https://yourdomain.com">
+                                <p class="text-xs text-muted-foreground mt-1">留空则使用服务器地址，例如：https://yourdomain.com</p>
+                            </div>
+                            <div id="cacheEffectiveUrl" class="rounded-md bg-muted p-3 hidden">
+                                <p class="text-xs text-muted-foreground">
+                                    <strong>🌐 当前生效的访问地址：</strong><code id="cacheEffectiveUrlValue" class="bg-background px-1 py-0.5 rounded"></code>
+                                </p>
+                            </div>
+                        </div>
+
+                        <button onclick="saveCacheConfig()" class="inline-flex items-center justify-center rounded-md bg-primary text-primary-foreground hover:bg-primary/90 h-9 px-4 w-full">保存配置</button>
+                    </div>
+                </div>
+
+                <!-- 验证码配置 -->
+                <div class="rounded-lg border border-border bg-background p-6">
+                    <h3 class="text-lg font-semibold mb-4">验证码配置</h3>
+                    <div class="space-y-4">
+                        <div>
+                            <label class="text-sm font-medium mb-2 block">打码方式</label>
+                            <select id="cfgCaptchaMethod" class="flex h-9 w-full rounded-md border border-input bg-background px-3 py-2 text-sm" onchange="toggleCaptchaOptions()">
+                                <option value="yescaptcha">YesCaptcha打码</option>
+                                <option value="browser">无头浏览器打码</option>
+                                <option value="personal">内置浏览器打码</option>
+                            </select>
+                            <p class="text-xs text-muted-foreground mt-1">选择验证码获取方式</p>
+                        </div>
+
+                        <!-- YesCaptcha配置选项 -->
+                        <div id="yescaptchaOptions" class="space-y-4">
+                            <div>
+                                <label class="text-sm font-medium mb-2 block">YesCaptcha API密钥</label>
+                                <input id="cfgYescaptchaApiKey" type="text" class="flex h-9 w-full rounded-md border border-input bg-background px-3 py-2 text-sm" placeholder="请输入YesCaptcha API密钥">
+                                <p class="text-xs text-muted-foreground mt-1">用于自动获取reCAPTCHA验证码，留空则不使用验证码</p>
+                            </div>
+                            <div>
+                                <label class="text-sm font-medium mb-2 block">YesCaptcha API地址</label>
+                                <input id="cfgYescaptchaBaseUrl" type="text" class="flex h-9 w-full rounded-md border border-input bg-background px-3 py-2 text-sm" placeholder="https://api.yescaptcha.com">
+                                <p class="text-xs text-muted-foreground mt-1">YesCaptcha服务地址，默认：https://api.yescaptcha.com</p>
+                            </div>
+                        </div>
+
+                        <!-- 浏览器打码配置选项 -->
+                        <div id="browserCaptchaOptions" class="hidden space-y-4">
+                            <div class="rounded-md bg-blue-50 dark:bg-blue-900/20 p-3 border border-blue-200 dark:border-blue-800">
+                                <p class="text-xs text-blue-800 dark:text-blue-200">
+                                    ℹ️ <strong>浏览器打码：</strong>使用Playwright自动化浏览器获取验证码，无需额外配置，但会占用更多系统资源
+                                </p>
+                            </div>
+
+                            <div>
+                                <label class="inline-flex items-center gap-2 cursor-pointer">
+                                    <input type="checkbox" id="cfgBrowserProxyEnabled" class="h-4 w-4 rounded border-input" onchange="toggleBrowserProxyInput()">
+                                    <span class="text-sm font-medium">启用代理</span>
+                                </label>
+                                <p class="text-xs text-muted-foreground mt-2">为无头浏览器配置独立代理</p>
+                            </div>
+
+                            <div id="browserProxyUrlInput" class="hidden">
+                                <label class="text-sm font-medium mb-2 block">代理地址</label>
+                                <input id="cfgBrowserProxyUrl" type="text" class="flex h-9 w-full rounded-md border border-input bg-background px-3 py-2 text-sm" placeholder="http://host:port 或 socks5://host:port">
+                                <p class="text-xs text-muted-foreground mt-1">
+                                    ⚠️ <strong>仅支持：</strong>HTTP代理（可带认证）或 SOCKS5代理（不可带认证）<br>
+                                    示例：<code class="bg-muted px-1 py-0.5 rounded">http://user:pass@proxy.com:8080</code> 或 <code class="bg-muted px-1 py-0.5 rounded">socks5://proxy.com:1080</code>
+                                </p>
+                            </div>
+                        </div>
+
+                        <button onclick="saveCaptchaConfig()" class="inline-flex items-center justify-center rounded-md bg-primary text-primary-foreground hover:bg-primary/90 h-9 px-4 w-full">保存配置</button>
+                    </div>
+                </div>
+
+                <!-- 插件连接配置 -->
+                <div class="rounded-lg border border-border bg-background p-6">
+                    <h3 class="text-lg font-semibold mb-4">插件连接配置</h3>
+                    <div class="space-y-4">
+                        <div>
+                            <label class="text-sm font-semibold mb-2 block">连接接口</label>
+                            <div class="flex gap-2">
+                                <input id="cfgPluginConnectionUrl" type="text" readonly class="flex h-9 flex-1 rounded-md border border-input bg-muted px-3 py-2 text-sm" placeholder="加载中...">
+                                <button onclick="copyConnectionUrl()" class="inline-flex items-center justify-center rounded-md bg-secondary text-secondary-foreground hover:bg-secondary/80 h-9 px-4">复制</button>
+                            </div>
+                            <p class="text-xs text-muted-foreground mt-1">Chrome扩展插件需要配置此接口地址</p>
+                        </div>
+                        <div>
+                            <label class="text-sm font-semibold mb-2 block">连接Token</label>
+                            <div class="flex gap-2">
+                                <input id="cfgPluginConnectionToken" type="text" class="flex h-9 flex-1 rounded-md border border-input bg-background px-3 py-2 text-sm" placeholder="留空自动生成">
+                                <button onclick="copyConnectionToken()" class="inline-flex items-center justify-center rounded-md bg-secondary text-secondary-foreground hover:bg-secondary/80 h-9 px-4">复制</button>
+                            </div>
+                            <p class="text-xs text-muted-foreground mt-1">用于验证Chrome扩展插件的身份，留空将自动生成随机token</p>
+                        </div>
+                        <div>
+                            <label class="inline-flex items-center gap-2 cursor-pointer">
+                                <input type="checkbox" id="cfgAutoEnableOnUpdate" class="h-4 w-4 rounded border-input">
+                                <span class="text-sm font-medium">更新token时自动启用</span>
+                            </label>
+                            <p class="text-xs text-muted-foreground mt-2">当插件更新token时，如果该token被禁用，则自动启用它</p>
+                        </div>
+                        <div class="rounded-md bg-blue-50 dark:bg-blue-900/20 p-3 border border-blue-200 dark:border-blue-800">
+                            <p class="text-xs text-blue-800 dark:text-blue-200">
+                                ℹ️ <strong>使用说明：</strong>安装Chrome扩展后，将连接接口和Token配置到插件中，插件会自动提取Google Labs的cookie并更新到系统
+                            </p>
+                        </div>
+                        <button onclick="savePluginConfig()" class="inline-flex items-center justify-center rounded-md bg-primary text-primary-foreground hover:bg-primary/90 h-9 px-4 w-full">保存配置</button>
+                    </div>
+                </div>
+
+                <!-- 生成超时配置 -->
+                <div class="rounded-lg border border-border bg-background p-6">
+                    <h3 class="text-lg font-semibold mb-4">生成超时配置</h3>
+                    <div class="space-y-4">
+                        <div>
+                            <label class="text-sm font-medium mb-2 block">图片生成超时时间（秒）</label>
+                            <input id="cfgImageTimeout" type="number" class="flex h-9 w-full rounded-md border border-input bg-background px-3 py-2 text-sm" placeholder="300" min="60" max="3600">
+                            <p class="text-xs text-muted-foreground mt-1">图片生成超时时间，范围：60-3600 秒（1分钟-1小时），超时后自动释放Token锁</p>
+                        </div>
+                        <div>
+                            <label class="text-sm font-medium mb-2 block">视频生成超时时间（秒）</label>
+                            <input id="cfgVideoTimeout" type="number" class="flex h-9 w-full rounded-md border border-input bg-background px-3 py-2 text-sm" placeholder="1500" min="60" max="7200">
+                            <p class="text-xs text-muted-foreground mt-1">视频生成超时时间，范围：60-7200 秒（1分钟-2小时），超时后返回上游API超时错误</p>
+                        </div>
+                        <button onclick="saveGenerationTimeout()" class="inline-flex items-center justify-center rounded-md bg-primary text-primary-foreground hover:bg-primary/90 h-9 px-4 w-full">保存配置</button>
+                    </div>
+                </div>
+
+                <!-- 调试配置 -->
+                <div class="rounded-lg border border-border bg-background p-6">
+                    <h3 class="text-lg font-semibold mb-4">调试配置</h3>
+                    <div class="space-y-4">
+                        <div>
+                            <label class="inline-flex items-center gap-2 cursor-pointer">
+                                <input type="checkbox" id="cfgDebugEnabled" class="h-4 w-4 rounded border-input" onchange="toggleDebugMode()">
+                                <span class="text-sm font-medium">启用调试模式</span>
+                            </label>
+                            <p class="text-xs text-muted-foreground mt-2">开启后，详细的上游API请求和响应日志将写入 <code class="bg-muted px-1 py-0.5 rounded">logs.txt</code> 文件</p>
+                        </div>
+                        <div class="rounded-md bg-yellow-50 dark:bg-yellow-900/20 p-3 border border-yellow-200 dark:border-yellow-800">
+                            <p class="text-xs text-yellow-800 dark:text-yellow-200">
+                                ⚠️ <strong>注意：</strong>调试模式会产生非常非常大量的日志，仅限Debug时候开启，否则磁盘boom
+                            </p>
+                        </div>
+                    </div>
+                </div>
+            </div>
+        </div>
+
+        <!-- 请求日志面板 -->
+        <div id="panelLogs" class="hidden">
+            <div class="rounded-lg border border-border bg-background">
+                <div class="flex items-center justify-between gap-4 p-4 border-b border-border">
+                    <h3 class="text-lg font-semibold">请求日志</h3>
+                    <div class="flex gap-2">
+                        <button onclick="clearAllLogs()" class="inline-flex items-center justify-center rounded-md transition-colors hover:bg-red-50 hover:text-red-700 h-8 px-3 text-sm" title="清空日志">
+                            <svg class="h-4 w-4 mr-1" xmlns="http://www.w3.org/2000/svg" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2">
+                                <polyline points="3 6 5 6 21 6"/><path d="M19 6v14a2 2 0 0 1-2 2H7a2 2 0 0 1-2-2V6m3 0V4a2 2 0 0 1 2-2h4a2 2 0 0 1 2 2v2"/>
+                            </svg>
+                            清空
+                        </button>
+                        <button onclick="refreshLogs()" class="inline-flex items-center justify-center rounded-md transition-colors hover:bg-accent h-8 w-8" title="刷新">
+                            <svg class="h-4 w-4" xmlns="http://www.w3.org/2000/svg" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2">
+                                <polyline points="23 4 23 10 17 10"/><polyline points="1 20 1 14 7 14"/><path d="M3.51 9a9 9 0 0 1 14.85-3.36L23 10M1 14l4.64 4.36A9 9 0 0 0 20.49 15"/>
+                            </svg>
+                        </button>
+                    </div>
+                </div>
+                <div class="relative w-full overflow-auto max-h-[600px]">
+                    <table class="w-full text-sm">
+                        <thead class="sticky top-0 bg-background">
+                            <tr class="border-b border-border">
+                                <th class="h-10 px-3 text-left align-middle font-medium text-muted-foreground">操作</th>
+                                <th class="h-10 px-3 text-left align-middle font-medium text-muted-foreground">Token邮箱</th>
+                                <th class="h-10 px-3 text-left align-middle font-medium text-muted-foreground">状态码</th>
+                                <th class="h-10 px-3 text-left align-middle font-medium text-muted-foreground">耗时(秒)</th>
+                                <th class="h-10 px-3 text-left align-middle font-medium text-muted-foreground">时间</th>
+                                <th class="h-10 px-3 text-left align-middle font-medium text-muted-foreground">详情</th>
+                            </tr>
+                        </thead>
+                        <tbody id="logsTableBody" class="divide-y divide-border">
+                            <!-- 动态填充 -->
+                        </tbody>
+                    </table>
+                </div>
+            </div>
+        </div>
+
+        <!-- 日志详情模态框 -->
+        <div id="logDetailModal" class="hidden fixed inset-0 z-50 bg-black/80 flex items-center justify-center p-4">
+            <div class="bg-background rounded-lg border border-border w-full max-w-3xl shadow-xl max-h-[80vh] flex flex-col">
+                <div class="flex items-center justify-between p-5 border-b border-border">
+                    <h3 class="text-lg font-semibold">日志详情</h3>
+                    <button onclick="closeLogDetailModal()" class="text-muted-foreground hover:text-foreground">
+                        <svg class="h-3.5 w-3.5" xmlns="http://www.w3.org/2000/svg" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2">
+                            <line x1="18" y1="6" x2="6" y2="18"/>
+                            <line x1="6" y1="6" x2="18" y2="18"/>
+                        </svg>
+                    </button>
+                </div>
+                <div class="p-5 overflow-y-auto">
+                    <div id="logDetailContent" class="space-y-4">
+                        <!-- 动态填充 -->
+                    </div>
+                </div>
+            </div>
+        </div>
+
+        <!-- 页脚 -->
+        <footer class="mt-12 pt-6 border-t border-border text-center text-xs text-muted-foreground">
+            <p>© 2025 <a href="https://linux.do/u/thesmallhancat/summary" target="_blank" class="no-underline hover:underline" style="color: inherit;">TheSmallHanCat</a> && <a href="https://linux.do/u/tibbar/summary" target="_blank" class="no-underline hover:underline" style="color: inherit;">Tibbar</a>. All rights reserved.</p>
+        </footer>
+    </main>
+
+    <!-- 添加 Token 模态框 -->
+    <div id="addModal" class="hidden fixed inset-0 z-50 bg-black/80 flex items-center justify-center p-4 overflow-y-auto">
+        <div class="bg-background rounded-lg border border-border w-full max-w-2xl shadow-xl my-auto">
+            <div class="flex items-center justify-between p-5 border-b border-border sticky top-0 bg-background">
+                <h3 class="text-lg font-semibold">添加 Token</h3>
+                <button onclick="closeAddModal()" class="text-muted-foreground hover:text-foreground">
+                    <svg class="h-3.5 w-3.5" xmlns="http://www.w3.org/2000/svg" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2">
+                        <line x1="18" y1="6" x2="6" y2="18"/>
+                        <line x1="6" y1="6" x2="18" y2="18"/>
+                    </svg>
+                </button>
+            </div>
+            <div class="p-5 space-y-4 max-h-[calc(100vh-200px)] overflow-y-auto">
+                <!-- Session Token -->
+                <div class="space-y-2">
+                    <label class="text-sm font-medium">Session Token (ST) <span class="text-red-500">*</span></label>
+                    <textarea id="addTokenST" rows="3" class="flex w-full rounded-md border border-input bg-background px-3 py-2 text-sm font-mono resize-none" placeholder="请输入 Session Token" required></textarea>
+                    <p class="text-xs text-muted-foreground">从浏览器 Cookie 中获取 __Secure-next-auth.session-token，保存时将自动转换为 Access Token</p>
+                </div>
+
+                <!-- Remark -->
+                <div class="space-y-2">
+                    <label class="text-sm font-medium">备注 <span class="text-muted-foreground text-xs">- 可选</span></label>
+                    <input id="addTokenRemark" class="flex h-9 w-full rounded-md border border-input bg-background px-3 py-2 text-sm" placeholder="添加备注信息">
+                </div>
+
+                <!-- Project ID -->
+                <div class="space-y-2">
+                    <label class="text-sm font-medium">Project ID <span class="text-muted-foreground text-xs">- 可选</span></label>
+                    <input id="addTokenProjectId" class="flex h-9 w-full rounded-md border border-input bg-background px-3 py-2 text-sm font-mono" placeholder="若不填写则系统自动生成">
+                    <p class="text-xs text-muted-foreground">如果已有Project ID可直接输入,留空则创建新项目</p>
+                </div>
+
+                <!-- Project Name -->
+                <div class="space-y-2">
+                    <label class="text-sm font-medium">Project Name <span class="text-muted-foreground text-xs">- 可选</span></label>
+                    <input id="addTokenProjectName" class="flex h-9 w-full rounded-md border border-input bg-background px-3 py-2 text-sm" placeholder="若不填写则自动生成 (如: Jan 01 - 12:00)">
+                </div>
+
+                <!-- 功能开关 -->
+                <div class="space-y-3 pt-2 border-t border-border">
+                    <label class="text-sm font-medium">功能开关</label>
+                    <div class="space-y-2">
+                        <div class="flex items-center gap-3">
+                            <label class="inline-flex items-center gap-2 cursor-pointer">
+                                <input type="checkbox" id="addTokenImageEnabled" checked class="h-4 w-4 rounded border-input">
+                                <span class="text-sm font-medium">启用图片生成</span>
+                            </label>
+                            <input type="number" id="addTokenImageConcurrency" value="-1" class="flex h-8 w-20 rounded-md border border-input bg-background px-2 py-1 text-sm" placeholder="并发数" title="并发数量限制：设置同时处理的最大请求数。-1表示不限制">
+                        </div>
+                    </div>
+                    <div class="space-y-2">
+                        <div class="flex items-center gap-3">
+                            <label class="inline-flex items-center gap-2 cursor-pointer">
+                                <input type="checkbox" id="addTokenVideoEnabled" checked class="h-4 w-4 rounded border-input">
+                                <span class="text-sm font-medium">启用视频生成</span>
+                            </label>
+                            <input type="number" id="addTokenVideoConcurrency" value="-1" class="flex h-8 w-20 rounded-md border border-input bg-background px-2 py-1 text-sm" placeholder="并发数" title="并发数量限制：设置同时处理的最大请求数。-1表示不限制">
+                        </div>
+                    </div>
+                </div>
+            </div>
+            <div class="flex items-center justify-end gap-3 p-5 border-t border-border sticky bottom-0 bg-background">
+                <button onclick="closeAddModal()" class="inline-flex items-center justify-center rounded-md border border-input bg-background hover:bg-accent h-9 px-5">取消</button>
+                <button id="addTokenBtn" onclick="submitAddToken()" class="inline-flex items-center justify-center rounded-md bg-primary text-primary-foreground hover:bg-primary/90 h-9 px-5">
+                    <span id="addTokenBtnText">添加</span>
+                    <svg id="addTokenBtnSpinner" class="hidden animate-spin h-4 w-4 ml-2" xmlns="http://www.w3.org/2000/svg" fill="none" viewBox="0 0 24 24">
+                        <circle class="opacity-25" cx="12" cy="12" r="10" stroke="currentColor" stroke-width="4"></circle>
+                        <path class="opacity-75" fill="currentColor" d="M4 12a8 8 0 018-8V0C5.373 0 0 5.373 0 12h4zm2 5.291A7.962 7.962 0 014 12H0c0 3.042 1.135 5.824 3 7.938l3-2.647z"></path>
+                    </svg>
+                </button>
+            </div>
+        </div>
+    </div>
+
+    <!-- 编辑 Token 模态框 -->
+    <div id="editModal" class="hidden fixed inset-0 z-50 bg-black/80 flex items-center justify-center p-4 overflow-y-auto">
+        <div class="bg-background rounded-lg border border-border w-full max-w-2xl shadow-xl my-auto">
+            <div class="flex items-center justify-between p-5 border-b border-border sticky top-0 bg-background">
+                <h3 class="text-lg font-semibold">编辑 Token</h3>
+                <button onclick="closeEditModal()" class="text-muted-foreground hover:text-foreground">
+                    <svg class="h-3.5 w-3.5" xmlns="http://www.w3.org/2000/svg" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2">
+                        <line x1="18" y1="6" x2="6" y2="18"/>
+                        <line x1="6" y1="6" x2="18" y2="18"/>
+                    </svg>
+                </button>
+            </div>
+            <div class="p-5 space-y-4 max-h-[calc(100vh-200px)] overflow-y-auto">
+                <input type="hidden" id="editTokenId">
+
+                <!-- Session Token -->
+                <div class="space-y-2">
+                    <label class="text-sm font-medium">Session Token (ST) <span class="text-red-500">*</span></label>
+                    <textarea id="editTokenST" rows="3" class="flex w-full rounded-md border border-input bg-background px-3 py-2 text-sm font-mono resize-none" placeholder="请输入 Session Token" required></textarea>
+                    <p class="text-xs text-muted-foreground">从浏览器 Cookie 中获取 __Secure-next-auth.session-token，保存时将自动转换为 Access Token</p>
+                </div>
+
+                <!-- Remark -->
+                <div class="space-y-2">
+                    <label class="text-sm font-medium">备注 <span class="text-muted-foreground text-xs">- 可选</span></label>
+                    <input id="editTokenRemark" class="flex h-9 w-full rounded-md border border-input bg-background px-3 py-2 text-sm" placeholder="添加备注信息">
+                </div>
+
+                <!-- Project ID -->
+                <div class="space-y-2">
+                    <label class="text-sm font-medium">Project ID <span class="text-muted-foreground text-xs">- 可选</span></label>
+                    <input id="editTokenProjectId" class="flex h-9 w-full rounded-md border border-input bg-background px-3 py-2 text-sm font-mono" placeholder="若不填写则保持原有值">
+                    <p class="text-xs text-muted-foreground">修改Project ID会更新Token使用的项目</p>
+                </div>
+
+                <!-- Project Name -->
+                <div class="space-y-2">
+                    <label class="text-sm font-medium">Project Name <span class="text-muted-foreground text-xs">- 可选</span></label>
+                    <input id="editTokenProjectName" class="flex h-9 w-full rounded-md border border-input bg-background px-3 py-2 text-sm" placeholder="若不填写则保持原有值">
+                </div>
+
+                <!-- 功能开关 -->
+                <div class="space-y-3 pt-2 border-t border-border">
+                    <label class="text-sm font-medium">功能开关</label>
+                    <div class="space-y-2">
+                        <div class="flex items-center gap-3">
+                            <label class="inline-flex items-center gap-2 cursor-pointer">
+                                <input type="checkbox" id="editTokenImageEnabled" class="h-4 w-4 rounded border-input">
+                                <span class="text-sm font-medium">启用图片生成</span>
+                            </label>
+                            <input type="number" id="editTokenImageConcurrency" class="flex h-8 w-20 rounded-md border border-input bg-background px-2 py-1 text-sm" placeholder="并发数" title="并发数量限制：设置同时处理的最大请求数。-1表示不限制">
+                        </div>
+                    </div>
+                    <div class="space-y-2">
+                        <div class="flex items-center gap-3">
+                            <label class="inline-flex items-center gap-2 cursor-pointer">
+                                <input type="checkbox" id="editTokenVideoEnabled" class="h-4 w-4 rounded border-input">
+                                <span class="text-sm font-medium">启用视频生成</span>
+                            </label>
+                            <input type="number" id="editTokenVideoConcurrency" class="flex h-8 w-20 rounded-md border border-input bg-background px-2 py-1 text-sm" placeholder="并发数" title="并发数量限制：设置同时处理的最大请求数。-1表示不限制">
+                        </div>
+                    </div>
+                </div>
+            </div>
+            <div class="flex items-center justify-end gap-3 p-5 border-t border-border sticky bottom-0 bg-background">
+                <button onclick="closeEditModal()" class="inline-flex items-center justify-center rounded-md border border-input bg-background hover:bg-accent h-9 px-5">取消</button>
+                <button id="editTokenBtn" onclick="submitEditToken()" class="inline-flex items-center justify-center rounded-md bg-primary text-primary-foreground hover:bg-primary/90 h-9 px-5">
+                    <span id="editTokenBtnText">保存</span>
+                    <svg id="editTokenBtnSpinner" class="hidden animate-spin h-4 w-4 ml-2" xmlns="http://www.w3.org/2000/svg" fill="none" viewBox="0 0 24 24">
+                        <circle class="opacity-25" cx="12" cy="12" r="10" stroke="currentColor" stroke-width="4"></circle>
+                        <path class="opacity-75" fill="currentColor" d="M4 12a8 8 0 018-8V0C5.373 0 0 5.373 0 12h4zm2 5.291A7.962 7.962 0 014 12H0c0 3.042 1.135 5.824 3 7.938l3-2.647z"></path>
+                    </svg>
+                </button>
+            </div>
+        </div>
+    </div>
+
+    <!-- Token 导入模态框 -->
+    <div id="importModal" class="hidden fixed inset-0 z-50 bg-black/80 flex items-center justify-center p-4">
+        <div class="bg-background rounded-lg border border-border w-full max-w-md shadow-xl">
+            <div class="flex items-center justify-between p-5 border-b border-border">
+                <h3 class="text-lg font-semibold">导入 Token</h3>
+                <button onclick="closeImportModal()" class="text-muted-foreground hover:text-foreground">
+                    <svg class="h-3.5 w-3.5" xmlns="http://www.w3.org/2000/svg" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2">
+                        <line x1="18" y1="6" x2="6" y2="18"/>
+                        <line x1="6" y1="6" x2="18" y2="18"/>
+                    </svg>
+                </button>
+            </div>
+            <div class="p-5 space-y-4">
+                <div>
+                    <label class="text-sm font-medium mb-2 block">选择 JSON 文件</label>
+                    <input type="file" id="importFile" accept=".json" class="flex h-9 w-full rounded-md border border-input bg-background px-3 py-2 text-sm">
+                    <p class="text-xs text-muted-foreground mt-1">选择导出的 Token JSON 文件进行导入</p>
+                </div>
+                <div class="rounded-md bg-blue-50 dark:bg-blue-900/20 p-3 border border-blue-200 dark:border-blue-800">
+                    <p class="text-xs text-blue-800 dark:text-blue-200">
+                        <strong>说明：</strong>如果邮箱存在则会覆盖更新，不存在则会新增
+                    </p>
+                </div>
+            </div>
+            <div class="flex items-center justify-end gap-3 p-5 border-t border-border">
+                <button onclick="closeImportModal()" class="inline-flex items-center justify-center rounded-md border border-input bg-background hover:bg-accent h-9 px-5">取消</button>
+                <button id="importBtn" onclick="submitImportTokens()" class="inline-flex items-center justify-center rounded-md bg-primary text-primary-foreground hover:bg-primary/90 h-9 px-5">
+                    <span id="importBtnText">导入</span>
+                    <svg id="importBtnSpinner" class="hidden animate-spin h-4 w-4 ml-2" xmlns="http://www.w3.org/2000/svg" fill="none" viewBox="0 0 24 24">
+                        <circle class="opacity-25" cx="12" cy="12" r="10" stroke="currentColor" stroke-width="4"></circle>
+                        <path class="opacity-75" fill="currentColor" d="M4 12a8 8 0 018-8V0C5.373 0 0 5.373 0 12h4zm2 5.291A7.962 7.962 0 014 12H0c0 3.042 1.135 5.824 3 7.938l3-2.647z"></path>
+                    </svg>
+                </button>
+            </div>
+        </div>
+    </div>
+
+    <script>
+        let allTokens=[];
+        const $=(id)=>document.getElementById(id),
+        checkAuth=()=>{const t=localStorage.getItem('adminToken');return t||(location.href='/login',null),t},
+        apiRequest=async(url,opts={})=>{const t=checkAuth();if(!t)return null;const r=await fetch(url,{...opts,headers:{...opts.headers,Authorization:`Bearer ${t}`,'Content-Type':'application/json'}});return r.status===401?(localStorage.removeItem('adminToken'),location.href='/login',null):r},
+        loadStats=async()=>{try{const r=await apiRequest('/api/stats');if(!r)return;const d=await r.json();$('statTotal').textContent=d.total_tokens||0;$('statActive').textContent=d.active_tokens||0;$('statImages').textContent=(d.today_images||0)+'/'+(d.total_images||0);$('statVideos').textContent=(d.today_videos||0)+'/'+(d.total_videos||0);$('statErrors').textContent=(d.today_errors||0)+'/'+(d.total_errors||0)}catch(e){console.error('加载统计失败:',e)}},
+        loadTokens=async()=>{try{const r=await apiRequest('/api/tokens');if(!r)return;allTokens=await r.json();renderTokens()}catch(e){console.error('加载Token失败:',e)}},
+        formatExpiry=exp=>{if(!exp)return'<span class="text-muted-foreground">-</span>';const d=new Date(exp),now=new Date(),diff=d-now;const dateStr=d.toLocaleDateString('zh-CN',{year:'numeric',month:'2-digit',day:'2-digit'}).replace(/\//g,'-');const timeStr=d.toLocaleTimeString('zh-CN',{hour:'2-digit',minute:'2-digit',hour12:false});const hours=Math.floor(diff/36e5);if(diff<0)return`<span class="text-red-600 font-medium" title="已过期">已过期</span>`;if(hours<1)return`<span class="text-red-600 font-medium" title="${dateStr} ${timeStr}">${Math.floor(diff/6e4)}分钟</span>`;if(hours<24)return`<span class="text-orange-600 font-medium" title="${dateStr} ${timeStr}">${hours}小时</span>`;const days=Math.floor(diff/864e5);if(days<7)return`<span class="text-orange-600" title="${dateStr} ${timeStr}">${days}天</span>`;return`<span class="text-muted-foreground" title="${dateStr} ${timeStr}">${days}天</span>`},
+        formatPlanType=type=>{if(!type)return'-';const typeMap={'chatgpt_team':'Team','chatgpt_plus':'Plus','chatgpt_pro':'Pro','chatgpt_free':'Free'};return typeMap[type]||type},
+        formatSora2=(t)=>{if(t.sora2_supported===true){const remaining=t.sora2_total_count-t.sora2_redeemed_count;const tooltipText=`邀请码: ${t.sora2_invite_code||'无'}\n可用次数: ${remaining}/${t.sora2_total_count}\n已用次数: ${t.sora2_redeemed_count}`;return`<div class="inline-flex items-center gap-1"><span class="inline-flex items-center rounded px-2 py-0.5 text-xs bg-green-50 text-green-700 cursor-pointer" title="${tooltipText}" onclick="copySora2Code('${t.sora2_invite_code||''}')">支持</span><span class="text-xs text-muted-foreground" title="${tooltipText}">${remaining}/${t.sora2_total_count}</span></div>`}else if(t.sora2_supported===false){return`<span class="inline-flex items-center rounded px-2 py-0.5 text-xs bg-gray-100 text-gray-700 cursor-pointer" title="点击使用邀请码激活" onclick="openSora2Modal(${t.id})">不支持</span>`}else{return'-'}},
+        formatPlanTypeWithTooltip=(t)=>{const tooltipText=t.subscription_end?`套餐到期: ${new Date(t.subscription_end).toLocaleDateString('zh-CN',{year:'numeric',month:'2-digit',day:'2-digit'}).replace(/\//g,'-')} ${new Date(t.subscription_end).toLocaleTimeString('zh-CN',{hour:'2-digit',minute:'2-digit',hour12:false})}`:'';return`<span class="inline-flex items-center rounded px-2 py-0.5 text-xs bg-blue-50 text-blue-700 cursor-pointer" title="${tooltipText||t.plan_title||'-'}">${formatPlanType(t.plan_type)}</span>`},
+        formatSora2Remaining=(t)=>{if(t.sora2_supported===true){const remaining=t.sora2_remaining_count||0;return`<span class="text-xs">${remaining}</span>`}else{return'-'}},
+        formatAccountType=(tier)=>{if(tier==='PAYGATE_TIER_NOT_PAID'){return`<span class="inline-flex items-center rounded px-2 py-0.5 text-xs bg-gray-100 text-gray-700">普通</span>`}else{return`<span class="inline-flex items-center rounded px-2 py-0.5 text-xs bg-purple-50 text-purple-700">会员</span>`}},
+        renderTokens=()=>{const tb=$('tokenTableBody');tb.innerHTML=allTokens.map(t=>{const imageDisplay=t.image_enabled?`${t.image_count||0}`:'-';const videoDisplay=t.video_enabled?`${t.video_count||0}`:'-';const creditsDisplay=t.credits!==undefined?`${t.credits}`:'-';const accountTypeDisplay=formatAccountType(t.user_paygate_tier);const projectDisplay=t.current_project_name||'-';const projectIdDisplay=t.current_project_id?(t.current_project_id.length>5?`<span class="cursor-pointer text-blue-600 hover:text-blue-700" onclick="copyProjectId('${t.current_project_id}')" title="${t.current_project_id}">${t.current_project_id.substring(0,5)}...</span>`:`<span class="cursor-pointer text-blue-600 hover:text-blue-700" onclick="copyProjectId('${t.current_project_id}')" title="${t.current_project_id}">${t.current_project_id}</span>`):'-';const expiryDisplay=formatExpiry(t.at_expires);return`<tr><td class="py-2.5 px-3">${t.email}</td><td class="py-2.5 px-3"><span class="inline-flex items-center rounded px-2 py-0.5 text-xs ${t.is_active?'bg-green-50 text-green-700':'bg-gray-100 text-gray-700'}">${t.is_active?'活跃':'禁用'}</span></td><td class="py-2.5 px-3 text-xs">${expiryDisplay}</td><td class="py-2.5 px-3"><button onclick="refreshTokenCredits(${t.id})" class="inline-flex items-center gap-1 text-blue-600 hover:text-blue-700 text-sm" title="点击刷新余额"><span>${creditsDisplay}</span><svg class="h-3 w-3" xmlns="http://www.w3.org/2000/svg" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2"><path d="M21 12a9 9 0 11-6.219-8.56"/><path d="M15 4.5l3.5 3.5L22 4.5"/></svg></button></td><td class="py-2.5 px-3">${accountTypeDisplay}</td><td class="py-2.5 px-3 text-xs">${projectDisplay}</td><td class="py-2.5 px-3 text-xs">${projectIdDisplay}</td><td class="py-2.5 px-3">${imageDisplay}</td><td class="py-2.5 px-3">${videoDisplay}</td><td class="py-2.5 px-3">${t.error_count||0}</td><td class="py-2.5 px-3 text-xs text-muted-foreground">${t.remark||'-'}</td><td class="py-2.5 px-3 text-right"><button onclick="refreshTokenAT(${t.id})" class="inline-flex items-center justify-center rounded-md hover:bg-blue-50 hover:text-blue-700 h-7 px-2 text-xs mr-1" title="刷新AT">更新</button><button onclick="openEditModal(${t.id})" class="inline-flex items-center justify-center rounded-md hover:bg-green-50 hover:text-green-700 h-7 px-2 text-xs mr-1">编辑</button><button onclick="toggleToken(${t.id},${t.is_active})" class="inline-flex items-center justify-center rounded-md hover:bg-accent h-7 px-2 text-xs mr-1">${t.is_active?'禁用':'启用'}</button><button onclick="deleteToken(${t.id})" class="inline-flex items-center justify-center rounded-md hover:bg-destructive/10 hover:text-destructive h-7 px-2 text-xs">删除</button></td></tr>`}).join('')},
+        refreshTokenCredits=async(id)=>{try{showToast('正在刷新余额...','info');const r=await apiRequest(`/api/tokens/${id}/refresh-credits`,{method:'POST'});if(!r)return;const d=await r.json();if(d.success){showToast(`余额刷新成功: ${d.credits}`,'success');await refreshTokens()}else{showToast('刷新失败: '+(d.detail||'未知错误'),'error')}}catch(e){showToast('刷新失败: '+e.message,'error')}},
+        refreshTokenAT=async(id)=>{try{showToast('正在更新AT...','info');const r=await apiRequest(`/api/tokens/${id}/refresh-at`,{method:'POST'});if(!r)return;const d=await r.json();if(d.success){const expiresDate=d.token.at_expires?new Date(d.token.at_expires):null;const expiresStr=expiresDate?expiresDate.toLocaleString('zh-CN',{year:'numeric',month:'2-digit',day:'2-digit',hour:'2-digit',minute:'2-digit',hour12:false}).replace(/\//g,'-'):'未知';showToast(`AT更新成功! 新过期时间: ${expiresStr}`,'success');await refreshTokens()}else{showToast('更新失败: '+(d.detail||'未知错误'),'error')}}catch(e){showToast('更新失败: '+e.message,'error')}},
+        refreshTokens=async()=>{await loadTokens();await loadStats()},
+        openAddModal=()=>$('addModal').classList.remove('hidden'),
+        closeAddModal=()=>{$('addModal').classList.add('hidden');$('addTokenST').value='';$('addTokenRemark').value='';$('addTokenProjectId').value='';$('addTokenProjectName').value='';$('addTokenImageEnabled').checked=true;$('addTokenVideoEnabled').checked=true;$('addTokenImageConcurrency').value='-1';$('addTokenVideoConcurrency').value='-1'},
+        openEditModal=(id)=>{const token=allTokens.find(t=>t.id===id);if(!token)return showToast('Token不存在','error');$('editTokenId').value=token.id;$('editTokenST').value=token.st||'';$('editTokenRemark').value=token.remark||'';$('editTokenProjectId').value=token.current_project_id||'';$('editTokenProjectName').value=token.current_project_name||'';$('editTokenImageEnabled').checked=token.image_enabled!==false;$('editTokenVideoEnabled').checked=token.video_enabled!==false;$('editTokenImageConcurrency').value=token.image_concurrency||'-1';$('editTokenVideoConcurrency').value=token.video_concurrency||'-1';$('editModal').classList.remove('hidden')},
+        closeEditModal=()=>{$('editModal').classList.add('hidden');$('editTokenId').value='';$('editTokenST').value='';$('editTokenRemark').value='';$('editTokenProjectId').value='';$('editTokenProjectName').value='';$('editTokenImageEnabled').checked=true;$('editTokenVideoEnabled').checked=true;$('editTokenImageConcurrency').value='';$('editTokenVideoConcurrency').value=''},
+        submitEditToken=async()=>{const id=parseInt($('editTokenId').value),st=$('editTokenST').value.trim(),remark=$('editTokenRemark').value.trim(),projectId=$('editTokenProjectId').value.trim(),projectName=$('editTokenProjectName').value.trim(),imageEnabled=$('editTokenImageEnabled').checked,videoEnabled=$('editTokenVideoEnabled').checked,imageConcurrency=$('editTokenImageConcurrency').value?parseInt($('editTokenImageConcurrency').value):null,videoConcurrency=$('editTokenVideoConcurrency').value?parseInt($('editTokenVideoConcurrency').value):null;if(!id)return showToast('Token ID无效','error');if(!st)return showToast('��输入 Session Token','error');const btn=$('editTokenBtn'),btnText=$('editTokenBtnText'),btnSpinner=$('editTokenBtnSpinner');btn.disabled=true;btnText.textContent='保存中...';btnSpinner.classList.remove('hidden');try{const r=await apiRequest(`/api/tokens/${id}`,{method:'PUT',body:JSON.stringify({st:st,remark:remark||null,project_id:projectId||null,project_name:projectName||null,image_enabled:imageEnabled,video_enabled:videoEnabled,image_concurrency:imageConcurrency,video_concurrency:videoConcurrency})});if(!r){btn.disabled=false;btnText.textContent='保存';btnSpinner.classList.add('hidden');return}const d=await r.json();if(d.success){closeEditModal();await refreshTokens();showToast('Token更新成功','success')}else{showToast('更新失败: '+(d.detail||d.message||'未知错误'),'error')}}catch(e){showToast('更新失败: '+e.message,'error')}finally{btn.disabled=false;btnText.textContent='保存';btnSpinner.classList.add('hidden')}},
+        convertST2AT=async()=>{const st=$('addTokenST').value.trim();if(!st)return showToast('请先输入 Session Token','error');try{showToast('正在转换 ST→AT...','info');const r=await apiRequest('/api/tokens/st2at',{method:'POST',body:JSON.stringify({st:st})});if(!r)return;const d=await r.json();if(d.success&&d.access_token){$('addTokenAT').value=d.access_token;showToast('转换成功！AT已自动填入','success')}else{showToast('转换失败: '+(d.message||d.detail||'未知错误'),'error')}}catch(e){showToast('转换失败: '+e.message,'error')}},
+        convertEditST2AT=async()=>{const st=$('editTokenST').value.trim();if(!st)return showToast('请先输入 Session Token','error');try{showToast('正在转换 ST→AT...','info');const r=await apiRequest('/api/tokens/st2at',{method:'POST',body:JSON.stringify({st:st})});if(!r)return;const d=await r.json();if(d.success&&d.access_token){$('editTokenAT').value=d.access_token;showToast('转换成功！AT已自动填入','success')}else{showToast('转换失败: '+(d.message||d.detail||'未知错误'),'error')}}catch(e){showToast('转换失败: '+e.message,'error')}},
+        submitAddToken=async()=>{const st=$('addTokenST').value.trim(),remark=$('addTokenRemark').value.trim(),projectId=$('addTokenProjectId').value.trim(),projectName=$('addTokenProjectName').value.trim(),imageEnabled=$('addTokenImageEnabled').checked,videoEnabled=$('addTokenVideoEnabled').checked,imageConcurrency=parseInt($('addTokenImageConcurrency').value)||(-1),videoConcurrency=parseInt($('addTokenVideoConcurrency').value)||(-1);if(!st)return showToast('请输入 Session Token','error');const btn=$('addTokenBtn'),btnText=$('addTokenBtnText'),btnSpinner=$('addTokenBtnSpinner');btn.disabled=true;btnText.textContent='添加中...';btnSpinner.classList.remove('hidden');try{const r=await apiRequest('/api/tokens',{method:'POST',body:JSON.stringify({st:st,remark:remark||null,project_id:projectId||null,project_name:projectName||null,image_enabled:imageEnabled,video_enabled:videoEnabled,image_concurrency:imageConcurrency,video_concurrency:videoConcurrency})});if(!r){btn.disabled=false;btnText.textContent='添加';btnSpinner.classList.add('hidden');return}const d=await r.json();if(d.success){closeAddModal();await refreshTokens();showToast('Token添加成功','success')}else{showToast('添加失败: '+(d.detail||d.message||'未知错误'),'error')}}catch(e){showToast('添加失败: '+e.message,'error')}finally{btn.disabled=false;btnText.textContent='添加';btnSpinner.classList.add('hidden')}},
+        testToken=async(id)=>{try{showToast('正在测试Token...','info');const r=await apiRequest(`/api/tokens/${id}/test`,{method:'POST'});if(!r)return;const d=await r.json();if(d.success&&d.status==='success'){let msg=`Token有效！用户: ${d.email||'未知'}`;if(d.sora2_supported){const remaining=d.sora2_total_count-d.sora2_redeemed_count;msg+=`\nSora2: 支持 (${remaining}/${d.sora2_total_count})`;if(d.sora2_remaining_count!==undefined){msg+=`\n可用次数: ${d.sora2_remaining_count}`}}showToast(msg,'success');await refreshTokens()}else{showToast(`Token无效: ${d.message||'未知错误'}`,'error')}}catch(e){showToast('测试失败: '+e.message,'error')}},
+        toggleToken=async(id,isActive)=>{const action=isActive?'disable':'enable';try{const r=await apiRequest(`/api/tokens/${id}/${action}`,{method:'POST'});if(!r)return;const d=await r.json();d.success?(await refreshTokens(),showToast(isActive?'Token已禁用':'Token已启用','success')):showToast('操作失败','error')}catch(e){showToast('操作失败: '+e.message,'error')}},
+        toggleTokenStatus=async(id,active)=>{try{const r=await apiRequest(`/api/tokens/${id}/status`,{method:'PUT',body:JSON.stringify({is_active:active})});if(!r)return;const d=await r.json();d.success?(await refreshTokens(),showToast('状态更新成功','success')):showToast('更新失败','error')}catch(e){showToast('更新失败: '+e.message,'error')}},
+        deleteToken=async(id,skipConfirm=false)=>{if(!skipConfirm&&!confirm('确定要删除这个Token吗?'))return;try{const r=await apiRequest(`/api/tokens/${id}`,{method:'DELETE'});if(!r)return;const d=await r.json();if(d.success){await refreshTokens();if(!skipConfirm)showToast('删除成功','success');return true}else{if(!skipConfirm)showToast('删除失败','error');return false}}catch(e){if(!skipConfirm)showToast('删除失败: '+e.message,'error');return false}},
+        copySora2Code=async(code)=>{if(!code){showToast('没有可复制的邀请码','error');return}try{if(navigator.clipboard&&navigator.clipboard.writeText){await navigator.clipboard.writeText(code);showToast(`邀请码已复制: ${code}`,'success')}else{const textarea=document.createElement('textarea');textarea.value=code;textarea.style.position='fixed';textarea.style.opacity='0';document.body.appendChild(textarea);textarea.select();const success=document.execCommand('copy');document.body.removeChild(textarea);if(success){showToast(`邀请码已复制: ${code}`,'success')}else{showToast('复制失败: 浏览器不支持','error')}}}catch(e){showToast('复制失败: '+e.message,'error')}},
+        copyProjectId=async(projectId)=>{if(!projectId){showToast('没有可复制的Project ID','error');return}try{if(navigator.clipboard&&navigator.clipboard.writeText){await navigator.clipboard.writeText(projectId);showToast(`Project ID已复制: ${projectId}`,'success')}else{const textarea=document.createElement('textarea');textarea.value=projectId;textarea.style.position='fixed';textarea.style.opacity='0';document.body.appendChild(textarea);textarea.select();const success=document.execCommand('copy');document.body.removeChild(textarea);if(success){showToast(`Project ID已复制: ${projectId}`,'success')}else{showToast('复制失败: 浏览器不支持','error')}}}catch(e){showToast('复制失败: '+e.message,'error')}},
+        openSora2Modal=(id)=>{$('sora2TokenId').value=id;$('sora2InviteCode').value='';$('sora2Modal').classList.remove('hidden')},
+        closeSora2Modal=()=>{$('sora2Modal').classList.add('hidden');$('sora2TokenId').value='';$('sora2InviteCode').value=''},
+        openImportModal=()=>{$('importModal').classList.remove('hidden');$('importFile').value=''},
+        closeImportModal=()=>{$('importModal').classList.add('hidden');$('importFile').value=''},
+        exportTokens=()=>{if(allTokens.length===0){showToast('没有Token可导出','error');return}const exportData=allTokens.map(t=>({email:t.email,access_token:t.token,session_token:t.st||null,is_active:t.is_active,image_enabled:t.image_enabled!==false,video_enabled:t.video_enabled!==false,image_concurrency:t.image_concurrency||(-1),video_concurrency:t.video_concurrency||(-1)}));const dataStr=JSON.stringify(exportData,null,2);const dataBlob=new Blob([dataStr],{type:'application/json'});const url=URL.createObjectURL(dataBlob);const link=document.createElement('a');link.href=url;link.download=`tokens_${new Date().toISOString().split('T')[0]}.json`;document.body.appendChild(link);link.click();document.body.removeChild(link);URL.revokeObjectURL(url);showToast(`已导出 ${allTokens.length} 个Token`,'success')},
+        submitImportTokens=async()=>{const fileInput=$('importFile');if(!fileInput.files||fileInput.files.length===0){showToast('请选择文件','error');return}const file=fileInput.files[0];if(!file.name.endsWith('.json')){showToast('请选择JSON文件','error');return}try{const fileContent=await file.text();const importData=JSON.parse(fileContent);if(!Array.isArray(importData)){showToast('JSON格式错误：应为数组','error');return}if(importData.length===0){showToast('JSON文件为空','error');return}const btn=$('importBtn'),btnText=$('importBtnText'),btnSpinner=$('importBtnSpinner');btn.disabled=true;btnText.textContent='导入中...';btnSpinner.classList.remove('hidden');try{const r=await apiRequest('/api/tokens/import',{method:'POST',body:JSON.stringify({tokens:importData})});if(!r){btn.disabled=false;btnText.textContent='导入';btnSpinner.classList.add('hidden');return}const d=await r.json();if(d.success){closeImportModal();await refreshTokens();const msg=`导入成功！新增: ${d.added||0}, 更新: ${d.updated||0}`;showToast(msg,'success')}else{showToast('导入失败: '+(d.detail||d.message||'未知错误'),'error')}}catch(e){showToast('导入失败: '+e.message,'error')}finally{btn.disabled=false;btnText.textContent='导入';btnSpinner.classList.add('hidden')}}catch(e){showToast('文件解析失败: '+e.message,'error')}},
+        submitSora2Activate=async()=>{const tokenId=parseInt($('sora2TokenId').value),inviteCode=$('sora2InviteCode').value.trim();if(!tokenId)return showToast('Token ID无效','error');if(!inviteCode)return showToast('请输入邀请码','error');if(inviteCode.length!==6)return showToast('邀请码必须是6位','error');const btn=$('sora2ActivateBtn'),btnText=$('sora2ActivateBtnText'),btnSpinner=$('sora2ActivateBtnSpinner');btn.disabled=true;btnText.textContent='激活中...';btnSpinner.classList.remove('hidden');try{showToast('正在激活Sora2...','info');const r=await apiRequest(`/api/tokens/${tokenId}/sora2/activate?invite_code=${inviteCode}`,{method:'POST'});if(!r){btn.disabled=false;btnText.textContent='激活';btnSpinner.classList.add('hidden');return}const d=await r.json();if(d.success){closeSora2Modal();await refreshTokens();if(d.already_accepted){showToast('Sora2已激活（之前已接受）','success')}else{showToast(`Sora2激活成功！邀请码: ${d.invite_code||'无'}`,'success')}}else{showToast('激活失败: '+(d.message||'未知错误'),'error')}}catch(e){showToast('激活失败: '+e.message,'error')}finally{btn.disabled=false;btnText.textContent='激活';btnSpinner.classList.add('hidden')}},
+        loadAdminConfig=async()=>{try{const r=await apiRequest('/api/admin/config');if(!r)return;const d=await r.json();$('cfgErrorBan').value=d.error_ban_threshold||3;$('cfgAdminUsername').value=d.admin_username||'admin';$('cfgCurrentAPIKey').value=d.api_key||'';$('cfgDebugEnabled').checked=d.debug_enabled||false}catch(e){console.error('加载配置失败:',e)}},
+        saveAdminConfig=async()=>{try{const r=await apiRequest('/api/admin/config',{method:'POST',body:JSON.stringify({error_ban_threshold:parseInt($('cfgErrorBan').value)||3})});if(!r)return;const d=await r.json();d.success?showToast('配置保存成功','success'):showToast('保存失败','error')}catch(e){showToast('保存失败: '+e.message,'error')}},
+        updateAdminPassword=async()=>{const username=$('cfgAdminUsername').value.trim(),oldPwd=$('cfgOldPassword').value.trim(),newPwd=$('cfgNewPassword').value.trim();if(!oldPwd||!newPwd)return showToast('请输入旧密码和新密码','error');if(newPwd.length<4)return showToast('新密码至少4个字符','error');try{const r=await apiRequest('/api/admin/password',{method:'POST',body:JSON.stringify({username:username||undefined,old_password:oldPwd,new_password:newPwd})});if(!r)return;const d=await r.json();if(d.success){showToast('密码修改成功，请重新登录','success');setTimeout(()=>{localStorage.removeItem('adminToken');location.href='/login'},2000)}else{showToast('修改失败: '+(d.detail||'未知错误'),'error')}}catch(e){showToast('修改失败: '+e.message,'error')}},
+        updateAPIKey=async()=>{const newKey=$('cfgNewAPIKey').value.trim();if(!newKey)return showToast('请输入新的 API Key','error');if(newKey.length<6)return showToast('API Key 至少6个字符','error');if(!confirm('确定要更新 API Key 吗？更新后需要通知所有客户端使用新密钥。'))return;try{const r=await apiRequest('/api/admin/apikey',{method:'POST',body:JSON.stringify({new_api_key:newKey})});if(!r)return;const d=await r.json();if(d.success){showToast('API Key 更新成功','success');$('cfgCurrentAPIKey').value=newKey;$('cfgNewAPIKey').value=''}else{showToast('更新失败: '+(d.detail||'未知错误'),'error')}}catch(e){showToast('更新失败: '+e.message,'error')}},
+        toggleDebugMode=async()=>{const enabled=$('cfgDebugEnabled').checked;try{const r=await apiRequest('/api/admin/debug',{method:'POST',body:JSON.stringify({enabled:enabled})});if(!r)return;const d=await r.json();if(d.success){showToast(enabled?'调试模式已开启':'调试模式已关闭','success')}else{showToast('操作失败: '+(d.detail||'未知错误'),'error');$('cfgDebugEnabled').checked=!enabled}}catch(e){showToast('操作失败: '+e.message,'error');$('cfgDebugEnabled').checked=!enabled}},
+        loadProxyConfig=async()=>{try{const r=await apiRequest('/api/proxy/config');if(!r)return;const d=await r.json();$('cfgProxyEnabled').checked=d.proxy_enabled||false;$('cfgProxyUrl').value=d.proxy_url||''}catch(e){console.error('加载代理配置失败:',e)}},
+        saveProxyConfig=async()=>{try{const r=await apiRequest('/api/proxy/config',{method:'POST',body:JSON.stringify({proxy_enabled:$('cfgProxyEnabled').checked,proxy_url:$('cfgProxyUrl').value.trim()})});if(!r)return;const d=await r.json();d.success?showToast('代理配置保存成功','success'):showToast('保存失败','error')}catch(e){showToast('保存失败: '+e.message,'error')}},
+        toggleCacheOptions=()=>{const enabled=$('cfgCacheEnabled').checked;$('cacheOptions').style.display=enabled?'block':'none'},
+        loadCacheConfig=async()=>{try{console.log('开始加载缓存配置...');const r=await apiRequest('/api/cache/config');if(!r){console.error('API请求失败');return}const d=await r.json();console.log('缓存配置数据:',d);if(d.success&&d.config){const enabled=d.config.enabled!==false;const timeout=d.config.timeout||7200;const baseUrl=d.config.base_url||'';const effectiveUrl=d.config.effective_base_url||'';console.log('设置缓存启用:',enabled);console.log('设置超时时间:',timeout);console.log('设置域名:',baseUrl);console.log('生效URL:',effectiveUrl);$('cfgCacheEnabled').checked=enabled;$('cfgCacheTimeout').value=timeout;$('cfgCacheBaseUrl').value=baseUrl;if(effectiveUrl){$('cacheEffectiveUrlValue').textContent=effectiveUrl;$('cacheEffectiveUrl').classList.remove('hidden')}else{$('cacheEffectiveUrl').classList.add('hidden')}toggleCacheOptions();console.log('缓存配置加载成功')}else{console.error('缓存配置数据格式错误:',d)}}catch(e){console.error('加载缓存配置失败:',e);showToast('加载缓存配置失败: '+e.message,'error')}},
+        loadGenerationTimeout=async()=>{try{console.log('开始加载生成超时配置...');const r=await apiRequest('/api/generation/timeout');if(!r){console.error('API请求失败');return}const d=await r.json();console.log('生成超时配置数据:',d);if(d.success&&d.config){const imageTimeout=d.config.image_timeout||300;const videoTimeout=d.config.video_timeout||1500;console.log('设置图片超时:',imageTimeout);console.log('设置视频超时:',videoTimeout);$('cfgImageTimeout').value=imageTimeout;$('cfgVideoTimeout').value=videoTimeout;console.log('生成超时配置加载成功')}else{console.error('生成超时配置数据格式错误:',d)}}catch(e){console.error('加载生成超时配置失败:',e);showToast('加载生成超时配置失败: '+e.message,'error')}},
+        saveCacheConfig=async()=>{const enabled=$('cfgCacheEnabled').checked,timeout=parseInt($('cfgCacheTimeout').value)||7200,baseUrl=$('cfgCacheBaseUrl').value.trim();console.log('保存缓存配置:',{enabled,timeout,baseUrl});if(timeout<60||timeout>86400)return showToast('缓存超时时间必须在 60-86400 秒之间','error');if(baseUrl&&!baseUrl.startsWith('http://')&&!baseUrl.startsWith('https://'))return showToast('域名必须以 http:// 或 https:// 开头','error');try{console.log('保存缓存启用状态...');const r0=await apiRequest('/api/cache/enabled',{method:'POST',body:JSON.stringify({enabled:enabled})});if(!r0){console.error('保存缓存启用状态请求失败');return}const d0=await r0.json();console.log('缓存启用状态保存结果:',d0);if(!d0.success){console.error('保存缓存启用状态失败:',d0);return showToast('保存缓存启用状态失败','error')}console.log('保存超时时间...');const r1=await apiRequest('/api/cache/config',{method:'POST',body:JSON.stringify({timeout:timeout})});if(!r1){console.error('保存超时时间请求失败');return}const d1=await r1.json();console.log('超时时间保存结果:',d1);if(!d1.success){console.error('保存超时时间失败:',d1);return showToast('保存超时时间失败','error')}console.log('保存域名...');const r2=await apiRequest('/api/cache/base-url',{method:'POST',body:JSON.stringify({base_url:baseUrl})});if(!r2){console.error('保存域名请求失败');return}const d2=await r2.json();console.log('域名保存结果:',d2);if(d2.success){showToast('缓存配置保存成功','success');console.log('等待配置文件写入完成...');await new Promise(r=>setTimeout(r,200));console.log('重新加载配置...');await loadCacheConfig()}else{console.error('保存域名失败:',d2);showToast('保存域名失败','error')}}catch(e){console.error('保存失败:',e);showToast('保存失败: '+e.message,'error')}},
+        saveGenerationTimeout=async()=>{const imageTimeout=parseInt($('cfgImageTimeout').value)||300,videoTimeout=parseInt($('cfgVideoTimeout').value)||1500;console.log('保存生成超时配置:',{imageTimeout,videoTimeout});if(imageTimeout<60||imageTimeout>3600)return showToast('图片超时时间必须在 60-3600 秒之间','error');if(videoTimeout<60||videoTimeout>7200)return showToast('视频超时时间必须在 60-7200 秒之间','error');try{const r=await apiRequest('/api/generation/timeout',{method:'POST',body:JSON.stringify({image_timeout:imageTimeout,video_timeout:videoTimeout})});if(!r){console.error('保存请求失败');return}const d=await r.json();console.log('保存结果:',d);if(d.success){showToast('生成超时配置保存成功','success');await new Promise(r=>setTimeout(r,200));await loadGenerationTimeout()}else{console.error('保存失败:',d);showToast('保存失败','error')}}catch(e){console.error('保存失败:',e);showToast('保存失败: '+e.message,'error')}},
+        toggleCaptchaOptions=()=>{const method=$('cfgCaptchaMethod').value;$('yescaptchaOptions').style.display=method==='yescaptcha'?'block':'none';$('browserCaptchaOptions').classList.toggle('hidden',method!=='browser')},
+        toggleBrowserProxyInput=()=>{const enabled=$('cfgBrowserProxyEnabled').checked;$('browserProxyUrlInput').classList.toggle('hidden',!enabled)},
+        loadCaptchaConfig=async()=>{try{console.log('开始加载验证码配置...');const r=await apiRequest('/api/captcha/config');if(!r){console.error('API请求失败');return}const d=await r.json();console.log('验证码配置数据:',d);$('cfgCaptchaMethod').value=d.captcha_method||'yescaptcha';$('cfgYescaptchaApiKey').value=d.yescaptcha_api_key||'';$('cfgYescaptchaBaseUrl').value=d.yescaptcha_base_url||'https://api.yescaptcha.com';$('cfgBrowserProxyEnabled').checked=d.browser_proxy_enabled||false;$('cfgBrowserProxyUrl').value=d.browser_proxy_url||'';toggleCaptchaOptions();toggleBrowserProxyInput();console.log('验证码配置加载成功')}catch(e){console.error('加载验证码配置失败:',e);showToast('加载验证码配置失败: '+e.message,'error')}},
+        saveCaptchaConfig=async()=>{const method=$('cfgCaptchaMethod').value,apiKey=$('cfgYescaptchaApiKey').value.trim(),baseUrl=$('cfgYescaptchaBaseUrl').value.trim(),browserProxyEnabled=$('cfgBrowserProxyEnabled').checked,browserProxyUrl=$('cfgBrowserProxyUrl').value.trim();console.log('保存验证码配置:',{method,apiKey,baseUrl,browserProxyEnabled,browserProxyUrl});try{const r=await apiRequest('/api/captcha/config',{method:'POST',body:JSON.stringify({captcha_method:method,yescaptcha_api_key:apiKey,yescaptcha_base_url:baseUrl,browser_proxy_enabled:browserProxyEnabled,browser_proxy_url:browserProxyUrl})});if(!r){console.error('保存请求失败');return}const d=await r.json();console.log('保存结果:',d);if(d.success){showToast('验证码配置保存成功','success');await new Promise(r=>setTimeout(r,200));await loadCaptchaConfig()}else{console.error('保存失败:',d);showToast(d.message||'保存失败','error')}}catch(e){console.error('保存失败:',e);showToast('保存失败: '+e.message,'error')}},
+        loadPluginConfig=async()=>{try{const r=await apiRequest('/api/plugin/config');if(!r)return;const d=await r.json();if(d.success&&d.config){$('cfgPluginConnectionUrl').value=d.config.connection_url||'';$('cfgPluginConnectionToken').value=d.config.connection_token||'';$('cfgAutoEnableOnUpdate').checked=d.config.auto_enable_on_update||false}}catch(e){console.error('加载插件配置失败:',e);showToast('加载插件配置失败: '+e.message,'error')}},
+        savePluginConfig=async()=>{const token=$('cfgPluginConnectionToken').value.trim();const autoEnable=$('cfgAutoEnableOnUpdate').checked;try{const r=await apiRequest('/api/plugin/config',{method:'POST',body:JSON.stringify({connection_token:token,auto_enable_on_update:autoEnable})});if(!r)return;const d=await r.json();if(d.success){showToast('插件配置保存成功','success');await loadPluginConfig()}else{showToast(d.message||'保存失败','error')}}catch(e){showToast('保存失败: '+e.message,'error')}},
+        copyConnectionUrl=()=>{const url=$('cfgPluginConnectionUrl').value;if(!url){showToast('连接接口为空','error');return}navigator.clipboard.writeText(url).then(()=>showToast('连接接口已复制','success')).catch(()=>showToast('复制失败','error'))},
+        copyConnectionToken=()=>{const token=$('cfgPluginConnectionToken').value;if(!token){showToast('连接Token为空','error');return}navigator.clipboard.writeText(token).then(()=>showToast('连接Token已复制','success')).catch(()=>showToast('复制失败','error'))},
+        toggleATAutoRefresh=async()=>{try{const enabled=$('atAutoRefreshToggle').checked;const r=await apiRequest('/api/token-refresh/enabled',{method:'POST',body:JSON.stringify({enabled:enabled})});if(!r){$('atAutoRefreshToggle').checked=!enabled;return}const d=await r.json();if(d.success){showToast(enabled?'AT自动刷新已启用':'AT自动刷新已禁用','success')}else{showToast('操作失败: '+(d.detail||'未知错误'),'error');$('atAutoRefreshToggle').checked=!enabled}}catch(e){showToast('操作失败: '+e.message,'error');$('atAutoRefreshToggle').checked=!enabled}},
+        loadATAutoRefreshConfig=async()=>{try{const r=await apiRequest('/api/token-refresh/config');if(!r)return;const d=await r.json();if(d.success&&d.config){$('atAutoRefreshToggle').checked=d.config.at_auto_refresh_enabled||false}else{console.error('AT自动刷新配置数据格式错误:',d)}}catch(e){console.error('加载AT自动刷新配置失败:',e)}},
+        loadLogs=async()=>{try{const r=await apiRequest('/api/logs?limit=100');if(!r)return;const logs=await r.json();window.allLogs=logs;const tb=$('logsTableBody');tb.innerHTML=logs.map(l=>`<tr><td class="py-2.5 px-3">${l.operation}</td><td class="py-2.5 px-3"><span class="text-xs ${l.token_email?'text-blue-600':'text-muted-foreground'}">${l.token_email||'未知'}</span></td><td class="py-2.5 px-3"><span class="inline-flex items-center rounded px-2 py-0.5 text-xs ${l.status_code===200?'bg-green-50 text-green-700':'bg-red-50 text-red-700'}">${l.status_code}</span></td><td class="py-2.5 px-3">${l.duration.toFixed(2)}</td><td class="py-2.5 px-3 text-xs text-muted-foreground">${l.created_at?new Date(l.created_at).toLocaleString('zh-CN'):'-'}</td><td class="py-2.5 px-3"><button onclick="showLogDetail(${l.id})" class="inline-flex items-center justify-center rounded-md hover:bg-blue-50 hover:text-blue-700 h-7 px-2 text-xs">查看</button></td></tr>`).join('')}catch(e){console.error('加载日志失败:',e)}},
+        refreshLogs=async()=>{await loadLogs()},
+        clearAllLogs=async()=>{if(!confirm('确定要清空所有日志吗？此操作不可恢复！'))return;try{const r=await apiRequest('/api/logs',{method:'DELETE'});if(!r)return;const d=await r.json();if(d.success){showToast('日志已清空','success');await loadLogs()}else{showToast('清空失败: '+(d.message||'未知错误'),'error')}}catch(e){showToast('清空失败: '+e.message,'error')}},
+        showLogDetail=(logId)=>{const log=window.allLogs.find(l=>l.id===logId);if(!log){showToast('日志不存在','error');return}const content=$('logDetailContent');let detailHtml='';if(log.status_code===200){try{const responseBody=log.response_body?JSON.parse(log.response_body):null;if(responseBody){if(responseBody.url){detailHtml+=`<div class="space-y-2"><h4 class="font-medium text-sm">生成结果</h4><div class="rounded-md border border-border p-3 bg-muted/30"><p class="text-sm mb-2"><span class="font-medium">文件URL:</span></p><a href="${responseBody.url}" target="_blank" class="text-blue-600 hover:underline text-xs break-all">${responseBody.url}</a></div></div>`}else if(responseBody.data&&responseBody.data.length>0){const item=responseBody.data[0];if(item.url){detailHtml+=`<div class="space-y-2"><h4 class="font-medium text-sm">生成结果</h4><div class="rounded-md border border-border p-3 bg-muted/30"><p class="text-sm mb-2"><span class="font-medium">文件URL:</span></p><a href="${item.url}" target="_blank" class="text-blue-600 hover:underline text-xs break-all">${item.url}</a></div></div>`}else{detailHtml+=`<div class="space-y-2"><h4 class="font-medium text-sm">响应数据</h4><pre class="rounded-md border border-border p-3 bg-muted/30 text-xs overflow-x-auto">${JSON.stringify(responseBody,null,2)}</pre></div>`}}else{detailHtml+=`<div class="space-y-2"><h4 class="font-medium text-sm">响应数据</h4><pre class="rounded-md border border-border p-3 bg-muted/30 text-xs overflow-x-auto">${JSON.stringify(responseBody,null,2)}</pre></div>`}}else{detailHtml+=`<div class="space-y-2"><h4 class="font-medium text-sm">响应信息</h4><p class="text-sm text-muted-foreground">无响应数据</p></div>`}}catch(e){detailHtml+=`<div class="space-y-2"><h4 class="font-medium text-sm">响应数据</h4><pre class="rounded-md border border-border p-3 bg-muted/30 text-xs overflow-x-auto">${log.response_body||'无'}</pre></div>`}}else{try{const responseBody=log.response_body?JSON.parse(log.response_body):null;if(responseBody&&responseBody.error){detailHtml+=`<div class="space-y-2"><h4 class="font-medium text-sm text-red-600">错误原因</h4><div class="rounded-md border border-red-200 p-3 bg-red-50"><p class="text-sm text-red-700">${responseBody.error.message||responseBody.error||'未知错误'}</p></div></div>`}else if(log.response_body&&log.response_body!=='{}'){detailHtml+=`<div class="space-y-2"><h4 class="font-medium text-sm text-red-600">错误信息</h4><pre class="rounded-md border border-red-200 p-3 bg-red-50 text-xs overflow-x-auto">${log.response_body}</pre></div>`}}catch(e){if(log.response_body&&log.response_body!=='{}'){detailHtml+=`<div class="space-y-2"><h4 class="font-medium text-sm text-red-600">错误信息</h4><pre class="rounded-md border border-red-200 p-3 bg-red-50 text-xs overflow-x-auto">${log.response_body}</pre></div>`}}}detailHtml+=`<div class="space-y-2 pt-4 border-t border-border"><h4 class="font-medium text-sm">基本信息</h4><div class="grid grid-cols-2 gap-2 text-sm"><div><span class="text-muted-foreground">操作:</span> ${log.operation}</div><div><span class="text-muted-foreground">状态码:</span> <span class="inline-flex items-center rounded px-2 py-0.5 text-xs ${log.status_code===200?'bg-green-50 text-green-700':'bg-red-50 text-red-700'}">${log.status_code}</span></div><div><span class="text-muted-foreground">耗时:</span> ${log.duration.toFixed(2)}秒</div><div><span class="text-muted-foreground">时间:</span> ${log.created_at?new Date(log.created_at).toLocaleString('zh-CN'):'-'}</div></div></div>`;content.innerHTML=detailHtml;$('logDetailModal').classList.remove('hidden')},
+        closeLogDetailModal=()=>{$('logDetailModal').classList.add('hidden')},
+        showToast=(m,t='info')=>{const d=document.createElement('div'),bc={success:'bg-green-600',error:'bg-destructive',info:'bg-primary'};d.className=`fixed bottom-4 right-4 ${bc[t]||bc.info} text-white px-4 py-2.5 rounded-lg shadow-lg text-sm font-medium z-50 animate-slide-up`;d.textContent=m;document.body.appendChild(d);setTimeout(()=>{d.style.opacity='0';d.style.transition='opacity .3s';setTimeout(()=>d.parentNode&&document.body.removeChild(d),300)},2000)},
+        logout=()=>{if(!confirm('确定要退出登录吗?'))return;localStorage.removeItem('adminToken');location.href='/login'},
+        switchTab=t=>{const cap=n=>n.charAt(0).toUpperCase()+n.slice(1);['tokens','settings','logs'].forEach(n=>{const active=n===t;$(`panel${cap(n)}`).classList.toggle('hidden',!active);$(`tab${cap(n)}`).classList.toggle('border-primary',active);$(`tab${cap(n)}`).classList.toggle('text-primary',active);$(`tab${cap(n)}`).classList.toggle('border-transparent',!active);$(`tab${cap(n)}`).classList.toggle('text-muted-foreground',!active)});if(t==='settings'){loadAdminConfig();loadProxyConfig();loadCacheConfig();loadGenerationTimeout();loadCaptchaConfig();loadPluginConfig();loadATAutoRefreshConfig()}else if(t==='logs'){loadLogs()}};
+        window.addEventListener('DOMContentLoaded',()=>{checkAuth();refreshTokens();loadATAutoRefreshConfig()});
+    </script>
+</body>
+</html>

venv/Lib/site-packages/_distutils_hack/__init__.py

@@ -0,0 +1,128 @@
+import sys
+import os
+import re
+import importlib
+import warnings
+
+
+is_pypy = '__pypy__' in sys.builtin_module_names
+
+
+warnings.filterwarnings('ignore',
+                        r'.+ distutils\b.+ deprecated',
+                        DeprecationWarning)
+
+
+def warn_distutils_present():
+    if 'distutils' not in sys.modules:
+        return
+    if is_pypy and sys.version_info < (3, 7):
+        # PyPy for 3.6 unconditionally imports distutils, so bypass the warning
+        # https://foss.heptapod.net/pypy/pypy/-/blob/be829135bc0d758997b3566062999ee8b23872b4/lib-python/3/site.py#L250
+        return
+    warnings.warn(
+        "Distutils was imported before Setuptools, but importing Setuptools "
+        "also replaces the `distutils` module in `sys.modules`. This may lead "
+        "to undesirable behaviors or errors. To avoid these issues, avoid "
+        "using distutils directly, ensure that setuptools is installed in the "
+        "traditional way (e.g. not an editable install), and/or make sure "
+        "that setuptools is always imported before distutils.")
+
+
+def clear_distutils():
+    if 'distutils' not in sys.modules:
+        return
+    warnings.warn("Setuptools is replacing distutils.")
+    mods = [name for name in sys.modules if re.match(r'distutils\b', name)]
+    for name in mods:
+        del sys.modules[name]
+
+
+def enabled():
+    """
+    Allow selection of distutils by environment variable.
+    """
+    which = os.environ.get('SETUPTOOLS_USE_DISTUTILS', 'stdlib')
+    return which == 'local'
+
+
+def ensure_local_distutils():
+    clear_distutils()
+    distutils = importlib.import_module('setuptools._distutils')
+    distutils.__name__ = 'distutils'
+    sys.modules['distutils'] = distutils
+
+    # sanity check that submodules load as expected
+    core = importlib.import_module('distutils.core')
+    assert '_distutils' in core.__file__, core.__file__
+
+
+def do_override():
+    """
+    Ensure that the local copy of distutils is preferred over stdlib.
+
+    See https://github.com/pypa/setuptools/issues/417#issuecomment-392298401
+    for more motivation.
+    """
+    if enabled():
+        warn_distutils_present()
+        ensure_local_distutils()
+
+
+class DistutilsMetaFinder:
+    def find_spec(self, fullname, path, target=None):
+        if path is not None:
+            return
+
+        method_name = 'spec_for_{fullname}'.format(**locals())
+        method = getattr(self, method_name, lambda: None)
+        return method()
+
+    def spec_for_distutils(self):
+        import importlib.abc
+        import importlib.util
+
+        class DistutilsLoader(importlib.abc.Loader):
+
+            def create_module(self, spec):
+                return importlib.import_module('setuptools._distutils')
+
+            def exec_module(self, module):
+                pass
+
+        return importlib.util.spec_from_loader('distutils', DistutilsLoader())
+
+    def spec_for_pip(self):
+        """
+        Ensure stdlib distutils when running under pip.
+        See pypa/pip#8761 for rationale.
+        """
+        if self.pip_imported_during_build():
+            return
+        clear_distutils()
+        self.spec_for_distutils = lambda: None
+
+    @staticmethod
+    def pip_imported_during_build():
+        """
+        Detect if pip is being imported in a build script. Ref #2355.
+        """
+        import traceback
+        return any(
+            frame.f_globals['__file__'].endswith('setup.py')
+            for frame, line in traceback.walk_stack(None)
+        )
+
+
+DISTUTILS_FINDER = DistutilsMetaFinder()
+
+
+def add_shim():
+    sys.meta_path.insert(0, DISTUTILS_FINDER)
+
+
+def remove_shim():
+    try:
+        sys.meta_path.remove(DISTUTILS_FINDER)
+    except ValueError:
+        pass

venv/Lib/site-packages/_distutils_hack/override.py

@@ -0,0 +1 @@
+__import__('_distutils_hack').do_override()

venv/Lib/site-packages/distutils-precedence.pth

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:7ea7ffef3fe2a117ee12c68ed6553617f0d7fd2f0590257c25c484959a3b7373
+size 152

venv/Lib/site-packages/pip-21.2.3.dist-info/INSTALLER

@@ -0,0 +1 @@
+pip

venv/Lib/site-packages/pip-21.2.3.dist-info/LICENSE.txt

@@ -0,0 +1,20 @@
+Copyright (c) 2008-2021 The pip developers (see AUTHORS.txt file)
+
+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.

venv/Lib/site-packages/pip-21.2.3.dist-info/METADATA

@@ -0,0 +1,92 @@
+Metadata-Version: 2.1
+Name: pip
+Version: 21.2.3
+Summary: The PyPA recommended tool for installing Python packages.
+Home-page: https://pip.pypa.io/
+Author: The pip developers
+Author-email: distutils-sig@python.org
+License: MIT
+Project-URL: Documentation, https://pip.pypa.io
+Project-URL: Source, https://github.com/pypa/pip
+Project-URL: Changelog, https://pip.pypa.io/en/stable/news/
+Platform: UNKNOWN
+Classifier: Development Status :: 5 - Production/Stable
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Topic :: Software Development :: Build Tools
+Classifier: Programming Language :: Python
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3 :: Only
+Classifier: Programming Language :: Python :: 3.6
+Classifier: Programming Language :: Python :: 3.7
+Classifier: Programming Language :: Python :: 3.8
+Classifier: Programming Language :: Python :: 3.9
+Classifier: Programming Language :: Python :: Implementation :: CPython
+Classifier: Programming Language :: Python :: Implementation :: PyPy
+Requires-Python: >=3.6
+License-File: LICENSE.txt
+
+pip - The Python Package Installer
+==================================
+
+.. image:: https://img.shields.io/pypi/v/pip.svg
+   :target: https://pypi.org/project/pip/
+
+.. image:: https://readthedocs.org/projects/pip/badge/?version=latest
+   :target: https://pip.pypa.io/en/latest
+
+pip is the `package installer`_ for Python. You can use pip to install packages from the `Python Package Index`_ and other indexes.
+
+Please take a look at our documentation for how to install and use pip:
+
+* `Installation`_
+* `Usage`_
+
+We release updates regularly, with a new version every 3 months. Find more details in our documentation:
+
+* `Release notes`_
+* `Release process`_
+
+In pip 20.3, we've `made a big improvement to the heart of pip`_; `learn more`_. We want your input, so `sign up for our user experience research studies`_ to help us do it right.
+
+**Note**: pip 21.0, in January 2021, removed Python 2 support, per pip's `Python 2 support policy`_. Please migrate to Python 3.
+
+If you find bugs, need help, or want to talk to the developers, please use our mailing lists or chat rooms:
+
+* `Issue tracking`_
+* `Discourse channel`_
+* `User IRC`_
+
+If you want to get involved head over to GitHub to get the source code, look at our development documentation and feel free to jump on the developer mailing lists and chat rooms:
+
+* `GitHub page`_
+* `Development documentation`_
+* `Development mailing list`_
+* `Development IRC`_
+
+Code of Conduct
+---------------
+
+Everyone interacting in the pip project's codebases, issue trackers, chat
+rooms, and mailing lists is expected to follow the `PSF Code of Conduct`_.
+
+.. _package installer: https://packaging.python.org/guides/tool-recommendations/
+.. _Python Package Index: https://pypi.org
+.. _Installation: https://pip.pypa.io/en/stable/installation/
+.. _Usage: https://pip.pypa.io/en/stable/
+.. _Release notes: https://pip.pypa.io/en/stable/news.html
+.. _Release process: https://pip.pypa.io/en/latest/development/release-process/
+.. _GitHub page: https://github.com/pypa/pip
+.. _Development documentation: https://pip.pypa.io/en/latest/development
+.. _made a big improvement to the heart of pip: https://pyfound.blogspot.com/2020/11/pip-20-3-new-resolver.html
+.. _learn more: https://pip.pypa.io/en/latest/user_guide/#changes-to-the-pip-dependency-resolver-in-20-3-2020
+.. _sign up for our user experience research studies: https://pyfound.blogspot.com/2020/03/new-pip-resolver-to-roll-out-this-year.html
+.. _Python 2 support policy: https://pip.pypa.io/en/latest/development/release-process/#python-2-support
+.. _Issue tracking: https://github.com/pypa/pip/issues
+.. _Discourse channel: https://discuss.python.org/c/packaging
+.. _Development mailing list: https://mail.python.org/mailman3/lists/distutils-sig.python.org/
+.. _User IRC: https://kiwiirc.com/nextclient/#ircs://irc.libera.chat:+6697/pypa
+.. _Development IRC: https://kiwiirc.com/nextclient/#ircs://irc.libera.chat:+6697/pypa-dev
+.. _PSF Code of Conduct: https://github.com/pypa/.github/blob/main/CODE_OF_CONDUCT.md
+
+

venv/Lib/site-packages/pip-21.2.3.dist-info/RECORD

@@ -0,0 +1,795 @@
+../../Scripts/pip.exe,sha256=U22BM6itznlzrP8HMUlQoiy_IuZMJJqDXU2Wgja2WNs,106390
+../../Scripts/pip3.10.exe,sha256=U22BM6itznlzrP8HMUlQoiy_IuZMJJqDXU2Wgja2WNs,106390
+../../Scripts/pip3.exe,sha256=U22BM6itznlzrP8HMUlQoiy_IuZMJJqDXU2Wgja2WNs,106390
+pip-21.2.3.dist-info/INSTALLER,sha256=zuuue4knoyJ-UwPPXg8fezS7VCrXJQrAP7zeNuwvFQg,4
+pip-21.2.3.dist-info/LICENSE.txt,sha256=gJDJthjxG8mDPXZg96yUjnIt4bce2hULfec5mrfNnmI,1110
+pip-21.2.3.dist-info/METADATA,sha256=BA4M-MqDkwwNoSPm1cVEoleu3sEr_iN4HbpM3cjr6rI,4165
+pip-21.2.3.dist-info/RECORD,,
+pip-21.2.3.dist-info/REQUESTED,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+pip-21.2.3.dist-info/WHEEL,sha256=OqRkF0eY5GHssMorFjlbTIq072vpHpF60fIQA6lS9xA,92
+pip-21.2.3.dist-info/entry_points.txt,sha256=HtfDOwpUlr9s73jqLQ6wF9V0_0qvUXJwCBz7Vwx0Ue0,125
+pip-21.2.3.dist-info/top_level.txt,sha256=zuuue4knoyJ-UwPPXg8fezS7VCrXJQrAP7zeNuwvFQg,4
+pip/__init__.py,sha256=qXU49Q5cd1uydhWo2AnReaOxEtM0o8t5EP9EvhtRCN8,370
+pip/__main__.py,sha256=8mTMucDffyV05KR_fXWM2p1JQEnHPu1-CWjbthYHYis,1229
+pip/__pycache__/__init__.cpython-310.pyc,,
+pip/__pycache__/__main__.cpython-310.pyc,,
+pip/_internal/__init__.py,sha256=OLxitHt9NAlSaObDjAlRSYUkAftIjV9sUpv1yIZDO4E,592
+pip/_internal/__pycache__/__init__.cpython-310.pyc,,
+pip/_internal/__pycache__/build_env.cpython-310.pyc,,
+pip/_internal/__pycache__/cache.cpython-310.pyc,,
+pip/_internal/__pycache__/configuration.cpython-310.pyc,,
+pip/_internal/__pycache__/exceptions.cpython-310.pyc,,
+pip/_internal/__pycache__/main.cpython-310.pyc,,
+pip/_internal/__pycache__/pyproject.cpython-310.pyc,,
+pip/_internal/__pycache__/self_outdated_check.cpython-310.pyc,,
+pip/_internal/__pycache__/wheel_builder.cpython-310.pyc,,
+pip/_internal/build_env.py,sha256=YMIinJTDdKm_x5JC8IjJZp-_Zw42kBm6fkiWprBi-Hk,10415
+pip/_internal/cache.py,sha256=bjyh33eOAq6kX1kPk84Oxb_JXazpP6izVZipJLq0eJI,10245
+pip/_internal/cli/__init__.py,sha256=9gMw_A_StJXzDh2Rhxil6bd8tFP-ZR719Q1pINHAw5I,136
+pip/_internal/cli/__pycache__/__init__.cpython-310.pyc,,
+pip/_internal/cli/__pycache__/autocompletion.cpython-310.pyc,,
+pip/_internal/cli/__pycache__/base_command.cpython-310.pyc,,
+pip/_internal/cli/__pycache__/cmdoptions.cpython-310.pyc,,
+pip/_internal/cli/__pycache__/command_context.cpython-310.pyc,,
+pip/_internal/cli/__pycache__/main.cpython-310.pyc,,
+pip/_internal/cli/__pycache__/main_parser.cpython-310.pyc,,
+pip/_internal/cli/__pycache__/parser.cpython-310.pyc,,
+pip/_internal/cli/__pycache__/progress_bars.cpython-310.pyc,,
+pip/_internal/cli/__pycache__/req_command.cpython-310.pyc,,
+pip/_internal/cli/__pycache__/spinners.cpython-310.pyc,,
+pip/_internal/cli/__pycache__/status_codes.cpython-310.pyc,,
+pip/_internal/cli/autocompletion.py,sha256=_d6Ugrj-KQOCoDgDscSr_238-RcwedXzpLmW8F_L_uc,6562
+pip/_internal/cli/base_command.py,sha256=mZH7AMA9tBoiYEysFx9l3Pe_h23mnNZy8K8M_ZhsRSs,7810
+pip/_internal/cli/cmdoptions.py,sha256=Kalu7Z2ZAvySgOOIo4e_Ah3Vv8HDmGhLQlkDysI-ihw,29292
+pip/_internal/cli/command_context.py,sha256=ocjEqsuP6pFF98N_ljRyLToYLm5fBgMaZicVjMy_f0Y,787
+pip/_internal/cli/main.py,sha256=D6DAuHgfr4na5SuEbtLyx1FlZhcGHIB9BltXsjrrKsA,2542
+pip/_internal/cli/main_parser.py,sha256=rusU-JYOLpcJ8cFXWiPvuDoNpTptRlndY3WyBh2UXq4,2701
+pip/_internal/cli/parser.py,sha256=0eTD4_7ucvjv_VnZajerOhzHUAIOju5KDlQM0rv5VP4,11080
+pip/_internal/cli/progress_bars.py,sha256=-bhkKHcjsZ0tWdf-DH9eGHsJuGedVPih8E0vV2_rJXg,8550
+pip/_internal/cli/req_command.py,sha256=_9w-fMnI0j8bey7mryr-iLxjCoUT_jIU3lkNp2PQJVU,17001
+pip/_internal/cli/spinners.py,sha256=rQJtl8c9JiMpOCsOk-YRFYtWdhiFoFectJuryMM-jn4,5233
+pip/_internal/cli/status_codes.py,sha256=1xaB32lG8Nf1nMl_6e0yy5z2Iyvv81OTUpuHwXgGsfU,122
+pip/_internal/commands/__init__.py,sha256=LoscneenHTO4OCqGIah4KtHyPNURU6F7bUeGRjbcr_k,3888
+pip/_internal/commands/__pycache__/__init__.cpython-310.pyc,,
+pip/_internal/commands/__pycache__/cache.cpython-310.pyc,,
+pip/_internal/commands/__pycache__/check.cpython-310.pyc,,
+pip/_internal/commands/__pycache__/completion.cpython-310.pyc,,
+pip/_internal/commands/__pycache__/configuration.cpython-310.pyc,,
+pip/_internal/commands/__pycache__/debug.cpython-310.pyc,,
+pip/_internal/commands/__pycache__/download.cpython-310.pyc,,
+pip/_internal/commands/__pycache__/freeze.cpython-310.pyc,,
+pip/_internal/commands/__pycache__/hash.cpython-310.pyc,,
+pip/_internal/commands/__pycache__/help.cpython-310.pyc,,
+pip/_internal/commands/__pycache__/index.cpython-310.pyc,,
+pip/_internal/commands/__pycache__/install.cpython-310.pyc,,
+pip/_internal/commands/__pycache__/list.cpython-310.pyc,,
+pip/_internal/commands/__pycache__/search.cpython-310.pyc,,
+pip/_internal/commands/__pycache__/show.cpython-310.pyc,,
+pip/_internal/commands/__pycache__/uninstall.cpython-310.pyc,,
+pip/_internal/commands/__pycache__/wheel.cpython-310.pyc,,
+pip/_internal/commands/cache.py,sha256=XqHqGkiyZ6A0Vf0oIGJhWiNY4k9JIC0nlNmooiaCtuo,7453
+pip/_internal/commands/check.py,sha256=FZ7IHeRkwnWkwgdaMI1AjFPcI4xrPK4_4jODp8aDyiA,1617
+pip/_internal/commands/completion.py,sha256=RXEru4uYaBfUUtZJ2bLE7s6FJUe9t1BAVSUQ8wPzW0o,3005
+pip/_internal/commands/configuration.py,sha256=1Fr4QLwdu1OcBL_FZQh6uY3i7i38qI70OJGG-JhoUuI,9228
+pip/_internal/commands/debug.py,sha256=Bb2Lxzn7XEQRYgBYOZbuK3EYeLphKHo8Gubg_EZ6JnU,6851
+pip/_internal/commands/download.py,sha256=sT3gInhPvMyhuZ-rVBf1OlpLzh52J0hStM57_CPdvCA,5088
+pip/_internal/commands/freeze.py,sha256=xzVjiTJT5DBJceJPNnAYyCF4oGITyuSpfsfkSKR70Fg,2869
+pip/_internal/commands/hash.py,sha256=XoLZ3Hx_b72asRLGOe1WXSvJ6ClwSFhn-aFPgbcB9Zk,1719
+pip/_internal/commands/help.py,sha256=zV8LmdIbJOnVOIZTz1TwlNWQZQLEWZnJGwXSSh9SSEw,1173
+pip/_internal/commands/index.py,sha256=qTchSIS-zCEiJCrZ9X-o5_93kMYCSVZDRTmeY_fhOOE,4920
+pip/_internal/commands/install.py,sha256=oj_4a73RMGXgmFQV1jUZEZTnvnZw5kkT6pA3naYj3PA,28243
+pip/_internal/commands/list.py,sha256=1K-dhUMEs8akjPE16n5Eq9GsalONKkS7bvWwSCNzQe8,12090
+pip/_internal/commands/search.py,sha256=Dtebo30wNJJ0Blr5MkmiET1wIuNioxzoH8vR82ma7Tc,5707
+pip/_internal/commands/show.py,sha256=G-ak6SZS-H2MJqQI89D2x4TLd8l9amVYhtaa5dhCFeE,8208
+pip/_internal/commands/uninstall.py,sha256=sTUTiJSTp0NKeFHUBJHD3f-fSVPGFjBY6go_DhpvC0Q,3580
+pip/_internal/commands/wheel.py,sha256=dIRE7v6g9HTpTw0nsOG2HHoG0uvwrWV5-xyp0kuJdhU,6365
+pip/_internal/configuration.py,sha256=g_C1ByxxCGrYfY26B-X8v-3mbUwzlXdj9EKwDs-0kH0,14128
+pip/_internal/distributions/__init__.py,sha256=99Rzk077wS5wGire_mchcAjtJG9vbwTLPXZKLWrh_D4,879
+pip/_internal/distributions/__pycache__/__init__.cpython-310.pyc,,
+pip/_internal/distributions/__pycache__/base.cpython-310.pyc,,
+pip/_internal/distributions/__pycache__/installed.cpython-310.pyc,,
+pip/_internal/distributions/__pycache__/sdist.cpython-310.pyc,,
+pip/_internal/distributions/__pycache__/wheel.cpython-310.pyc,,
+pip/_internal/distributions/base.py,sha256=VCEqCFm36o5SSpu3esHmM055Wv5TOxGFLXtxpY8m-L8,1244
+pip/_internal/distributions/installed.py,sha256=UZU2Q4-jcAaPexNZzqk5YXhols1jTjyh4xAA0ZQ_A8g,667
+pip/_internal/distributions/sdist.py,sha256=5OpYaS51ll8tqsZC-h86ij62RQkid3YZEOqUXCRq8TA,3957
+pip/_internal/distributions/wheel.py,sha256=8lzZqqpA5oUUHANOZlf0qcKLIunsJ3K821VP29hLYdg,1217
+pip/_internal/exceptions.py,sha256=yiMEmKFvLIPNGaLCQxxtnacfNhUisQayQ4XiqPuRLZU,13567
+pip/_internal/index/__init__.py,sha256=x0ifDyFChwwQC4V_eHBFF1fvzLwbXRYG3nq15-Axy24,32
+pip/_internal/index/__pycache__/__init__.cpython-310.pyc,,
+pip/_internal/index/__pycache__/collector.cpython-310.pyc,,
+pip/_internal/index/__pycache__/package_finder.cpython-310.pyc,,
+pip/_internal/index/__pycache__/sources.cpython-310.pyc,,
+pip/_internal/index/collector.py,sha256=pB-NFZkI-KjQnhTBo7JzArphtu6OVJ52WVQlFQrSbFU,18179
+pip/_internal/index/package_finder.py,sha256=k7qar-7Lw778ODq0iB-ETXjof-MUhRh4YHXsVNjl6eo,37120
+pip/_internal/index/sources.py,sha256=SW2LlD5eAF2Rj74TbpEUNjADU9UH-K76oqgJFNtDlWc,6781
+pip/_internal/locations/__init__.py,sha256=bReITFXFSX786ngLRJhXhsb1npYOw8YbpOuOngrQUik,11584
+pip/_internal/locations/__pycache__/__init__.cpython-310.pyc,,
+pip/_internal/locations/__pycache__/_distutils.cpython-310.pyc,,
+pip/_internal/locations/__pycache__/_sysconfig.cpython-310.pyc,,
+pip/_internal/locations/__pycache__/base.cpython-310.pyc,,
+pip/_internal/locations/_distutils.py,sha256=OUPuNiGJP2vmiYgwdAR-ZQryj_2yANs9DebSm4afDZU,6040
+pip/_internal/locations/_sysconfig.py,sha256=sJJD4PQujUcLAaKiOeXYsILmQb0-hjznP79PzKPiA4Q,8137
+pip/_internal/locations/base.py,sha256=KMpxtATY6iOshQ3AimpymGTy81zK-pM1CWPemJQ0mj4,1631
+pip/_internal/main.py,sha256=yXF5_lVS3QQTxrbbvNk31juR2E1_16H1iu-xuXAod9o,364
+pip/_internal/metadata/__init__.py,sha256=p3NvOGG_3quhV9bOlDPvWSAEByPsdn63cO4FrsFubM0,1624
+pip/_internal/metadata/__pycache__/__init__.cpython-310.pyc,,
+pip/_internal/metadata/__pycache__/base.cpython-310.pyc,,
+pip/_internal/metadata/__pycache__/pkg_resources.cpython-310.pyc,,
+pip/_internal/metadata/base.py,sha256=dCfs9XIcicyYSoFtVtzq6rFvduUYNdV6U_EDDlG4yJ0,8170
+pip/_internal/metadata/pkg_resources.py,sha256=azUoAkvyF-h80pORd0czY4-fWUIRe_z3i2qNHuKiSjE,5353
+pip/_internal/models/__init__.py,sha256=j2kiRfNTH6h5JVP5yO_N2Yn0DqiNzJUtaPjHe2xMcgg,65
+pip/_internal/models/__pycache__/__init__.cpython-310.pyc,,
+pip/_internal/models/__pycache__/candidate.cpython-310.pyc,,
+pip/_internal/models/__pycache__/direct_url.cpython-310.pyc,,
+pip/_internal/models/__pycache__/format_control.cpython-310.pyc,,
+pip/_internal/models/__pycache__/index.cpython-310.pyc,,
+pip/_internal/models/__pycache__/link.cpython-310.pyc,,
+pip/_internal/models/__pycache__/scheme.cpython-310.pyc,,
+pip/_internal/models/__pycache__/search_scope.cpython-310.pyc,,
+pip/_internal/models/__pycache__/selection_prefs.cpython-310.pyc,,
+pip/_internal/models/__pycache__/target_python.cpython-310.pyc,,
+pip/_internal/models/__pycache__/wheel.cpython-310.pyc,,
+pip/_internal/models/candidate.py,sha256=L4nKS2HIgdOfbylU-2MIO2APVWEWueJpHu_gcwO0iH4,977
+pip/_internal/models/direct_url.py,sha256=36n2ed5kddmPLhNLh4b1GzGr36dUdSgl23Xrbcxd_ck,6482
+pip/_internal/models/format_control.py,sha256=PZ5PExPrxArZWzzPFATSj6W07UqvxjtrMBgFNAUxae4,2641
+pip/_internal/models/index.py,sha256=vqgOrXoZqQW4AA928wBmEGjKbxjeb-_NALLGZH0kMXY,1090
+pip/_internal/models/link.py,sha256=SrRPbWmpzWh1LfQd-eurbYAuMvOvpD5fzMvNDlRFpQ8,10227
+pip/_internal/models/scheme.py,sha256=moDcYk85amZUkf6Je5TDvXh4xMHxsSgf8rkD1ykpQhU,769
+pip/_internal/models/search_scope.py,sha256=D_Q6xSo1dTjSRljshHz_xVe4vXXivl2H7_rtj0dSHpU,4600
+pip/_internal/models/selection_prefs.py,sha256=0DZIWNPT8q2EiuqZCAQxczCoVnbs9_C4zugNfhNnvaw,1923
+pip/_internal/models/target_python.py,sha256=NUm2Ua7qbJHFK0UzKAlfHixudx4-FgmAFKPKf3B2RyU,3981
+pip/_internal/models/wheel.py,sha256=NLmn_y8dVc5vfTcAYw3EfS692hAF9MPPMDr5wTBu_4E,3633
+pip/_internal/network/__init__.py,sha256=IEtuAPVGqBTS0C7M0KJ95xqGcA76coOc2AsDcgIBP-8,52
+pip/_internal/network/__pycache__/__init__.cpython-310.pyc,,
+pip/_internal/network/__pycache__/auth.cpython-310.pyc,,
+pip/_internal/network/__pycache__/cache.cpython-310.pyc,,
+pip/_internal/network/__pycache__/download.cpython-310.pyc,,
+pip/_internal/network/__pycache__/lazy_wheel.cpython-310.pyc,,
+pip/_internal/network/__pycache__/session.cpython-310.pyc,,
+pip/_internal/network/__pycache__/utils.cpython-310.pyc,,
+pip/_internal/network/__pycache__/xmlrpc.cpython-310.pyc,,
+pip/_internal/network/auth.py,sha256=820jI8SAsVfNnfoOfxfH7HaGVFtYX_M8vsHEtiHCS14,11961
+pip/_internal/network/cache.py,sha256=KfaWDbALIGsUnP4qi1MfvKSpCJ0vlC5lviELSTNKLtQ,2169
+pip/_internal/network/download.py,sha256=-EnS83XhpNVRsfB107nYU-OPZsHd29QQdG6lNokemAk,6200
+pip/_internal/network/lazy_wheel.py,sha256=LFVwrv2nHpwr0pl17i-3sbEAedJjraaLdRTFRfS23vo,7825
+pip/_internal/network/session.py,sha256=9KBZpMGrtEmek4iPgpZiLEBgyxQ6bPH3yUUxNbEEQ54,17036
+pip/_internal/network/utils.py,sha256=K4d2srYGzR_tz5vVBbKFC7rBWA-G_DqqX9io2flIrI0,4155
+pip/_internal/network/xmlrpc.py,sha256=oFCngChTOtIVcc55ExwdX1HJcPvL-6PKMNl5ok6nMQk,1851
+pip/_internal/operations/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+pip/_internal/operations/__pycache__/__init__.cpython-310.pyc,,
+pip/_internal/operations/__pycache__/check.cpython-310.pyc,,
+pip/_internal/operations/__pycache__/freeze.cpython-310.pyc,,
+pip/_internal/operations/__pycache__/prepare.cpython-310.pyc,,
+pip/_internal/operations/build/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+pip/_internal/operations/build/__pycache__/__init__.cpython-310.pyc,,
+pip/_internal/operations/build/__pycache__/metadata.cpython-310.pyc,,
+pip/_internal/operations/build/__pycache__/metadata_legacy.cpython-310.pyc,,
+pip/_internal/operations/build/__pycache__/wheel.cpython-310.pyc,,
+pip/_internal/operations/build/__pycache__/wheel_legacy.cpython-310.pyc,,
+pip/_internal/operations/build/metadata.py,sha256=-06VLFRgwxsIuqHL_56NxXdn7TQuZHeaL4RYXDnjB18,1200
+pip/_internal/operations/build/metadata_legacy.py,sha256=1V8i8VVGUF7GauyS_KPEhcl7dIwrocD6lyT5kWvXkBA,1991
+pip/_internal/operations/build/wheel.py,sha256=r2IKZgek1REUjP4xA0RLEG5O1-HsPZtzfy7q7W3_nhQ,1144
+pip/_internal/operations/build/wheel_legacy.py,sha256=4ddx179dnTTHJertW50M6869gchuyrNEdYcyWe4w5Yg,3337
+pip/_internal/operations/check.py,sha256=eCLrRScb_ZJDxTK9rMjU5kbLuu1xRngdoLxATNPuPQE,5448
+pip/_internal/operations/freeze.py,sha256=WEglEwdf9rD9M6jGzMyRVhiN-WF8p-hhiHGnwsWlDDc,10833
+pip/_internal/operations/install/__init__.py,sha256=Zug2xxRJjeI2LdVd45iwmeavUBYXA4ltbhFFwc4BEOg,53
+pip/_internal/operations/install/__pycache__/__init__.cpython-310.pyc,,
+pip/_internal/operations/install/__pycache__/editable_legacy.cpython-310.pyc,,
+pip/_internal/operations/install/__pycache__/legacy.cpython-310.pyc,,
+pip/_internal/operations/install/__pycache__/wheel.cpython-310.pyc,,
+pip/_internal/operations/install/editable_legacy.py,sha256=FhvBds_MF_Flabnylh6EVwCD3mFDxa-RmdKq3jl5JGM,1443
+pip/_internal/operations/install/legacy.py,sha256=xyGakzR-Xnfa9H37-OzT6cKH-AQMsctBkFxfUr3jlvw,4537
+pip/_internal/operations/install/wheel.py,sha256=oV6IB77355YCaI_ta4mqWXyHlkQF8OqBRZAdq8jpQYs,30269
+pip/_internal/operations/prepare.py,sha256=QB3-cmVD1agyO6_B9oiRs9HCQyyDMHF9pLTboLtufxo,25503
+pip/_internal/pyproject.py,sha256=DQoqc7F3HyFBO7fG82HOPsdP-GfEzfuqTUGOG0v2E1c,7246
+pip/_internal/req/__init__.py,sha256=5eiQnk8IiwtrWHU4r1ttcLy545MCrUdg5eRRq7_ZNz0,2925
+pip/_internal/req/__pycache__/__init__.cpython-310.pyc,,
+pip/_internal/req/__pycache__/constructors.cpython-310.pyc,,
+pip/_internal/req/__pycache__/req_file.cpython-310.pyc,,
+pip/_internal/req/__pycache__/req_install.cpython-310.pyc,,
+pip/_internal/req/__pycache__/req_set.cpython-310.pyc,,
+pip/_internal/req/__pycache__/req_tracker.cpython-310.pyc,,
+pip/_internal/req/__pycache__/req_uninstall.cpython-310.pyc,,
+pip/_internal/req/constructors.py,sha256=Izde_5pbxkMzDWN-khLufzKKpC0uaGNTPRO9ShWrud8,16300
+pip/_internal/req/req_file.py,sha256=RN04-oHRNn5xECciUcs0Gh3LxA1RdlVw1X6wbVs0r7k,17936
+pip/_internal/req/req_install.py,sha256=gIGZ3t9QzqCBoeL04my4DIuqM86j0i5nId6iwZIGYzQ,32517
+pip/_internal/req/req_set.py,sha256=yeKmy9-oH5tW2Oe7SHobrp9btcDBZ3DxdFJ3HqAKQ44,7762
+pip/_internal/req/req_tracker.py,sha256=tFN50kuTTWwpY0WJkPK6QCPUZePmUhaBbuKVSgkWl1A,4312
+pip/_internal/req/req_uninstall.py,sha256=T6n_Pgpljq30LLQ81Qs4kpPoxSuJUkUvbvG9b697rGs,24450
+pip/_internal/resolution/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+pip/_internal/resolution/__pycache__/__init__.cpython-310.pyc,,
+pip/_internal/resolution/__pycache__/base.cpython-310.pyc,,
+pip/_internal/resolution/base.py,sha256=qMuP4GV1NJU-81E3gUKzczQxzS-f_SWF0Dk59YVrH9A,575
+pip/_internal/resolution/legacy/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+pip/_internal/resolution/legacy/__pycache__/__init__.cpython-310.pyc,,
+pip/_internal/resolution/legacy/__pycache__/resolver.cpython-310.pyc,,
+pip/_internal/resolution/legacy/resolver.py,sha256=6nUm1wcBGRT58gUOu0-B0TE354XrCx_dexslaFtlDis,18005
+pip/_internal/resolution/resolvelib/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+pip/_internal/resolution/resolvelib/__pycache__/__init__.cpython-310.pyc,,
+pip/_internal/resolution/resolvelib/__pycache__/base.cpython-310.pyc,,
+pip/_internal/resolution/resolvelib/__pycache__/candidates.cpython-310.pyc,,
+pip/_internal/resolution/resolvelib/__pycache__/factory.cpython-310.pyc,,
+pip/_internal/resolution/resolvelib/__pycache__/found_candidates.cpython-310.pyc,,
+pip/_internal/resolution/resolvelib/__pycache__/provider.cpython-310.pyc,,
+pip/_internal/resolution/resolvelib/__pycache__/reporter.cpython-310.pyc,,
+pip/_internal/resolution/resolvelib/__pycache__/requirements.cpython-310.pyc,,
+pip/_internal/resolution/resolvelib/__pycache__/resolver.cpython-310.pyc,,
+pip/_internal/resolution/resolvelib/base.py,sha256=IWvd3KNMJtIqDLcqeUuGV4MbimM83JOofBKwggVYxzI,5434
+pip/_internal/resolution/resolvelib/candidates.py,sha256=a8-csKtuj_Bz8UeYgk2cz8mP1EOObTyXsZrCO8wq2Tc,19397
+pip/_internal/resolution/resolvelib/factory.py,sha256=clwGzM3_u3SReBwOOG9sAvcdd2pNqk03T5qrCyryeB4,27559
+pip/_internal/resolution/resolvelib/found_candidates.py,sha256=9kFfU_ZFugtCMaCIez6UYrG4hyfqwDaQYxP9db9XQvE,5427
+pip/_internal/resolution/resolvelib/provider.py,sha256=qXB9l3kjEca0orqTS2e6TGaWHJIn537kEqJYClBIShQ,8617
+pip/_internal/resolution/resolvelib/reporter.py,sha256=AwjzTX3LytVk9wuVS1LdJAk1V2kPhEdn1dE7MfrPwLM,2669
+pip/_internal/resolution/resolvelib/requirements.py,sha256=FKE-HcZmsljRrcLpr545XprOOqDd09149GjjF8AfTiw,5621
+pip/_internal/resolution/resolvelib/resolver.py,sha256=Bmwfy5pO8cLzI-13YMgWEAWwFlpjLKdKeCBHMrdWyWM,10795
+pip/_internal/self_outdated_check.py,sha256=cNOjZkFVtwJmftBZt34cH2j9SJ5Gd4vSbJY8FBYM6tg,6671
+pip/_internal/utils/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+pip/_internal/utils/__pycache__/__init__.cpython-310.pyc,,
+pip/_internal/utils/__pycache__/_log.cpython-310.pyc,,
+pip/_internal/utils/__pycache__/appdirs.cpython-310.pyc,,
+pip/_internal/utils/__pycache__/compat.cpython-310.pyc,,
+pip/_internal/utils/__pycache__/compatibility_tags.cpython-310.pyc,,
+pip/_internal/utils/__pycache__/datetime.cpython-310.pyc,,
+pip/_internal/utils/__pycache__/deprecation.cpython-310.pyc,,
+pip/_internal/utils/__pycache__/direct_url_helpers.cpython-310.pyc,,
+pip/_internal/utils/__pycache__/distutils_args.cpython-310.pyc,,
+pip/_internal/utils/__pycache__/encoding.cpython-310.pyc,,
+pip/_internal/utils/__pycache__/entrypoints.cpython-310.pyc,,
+pip/_internal/utils/__pycache__/filesystem.cpython-310.pyc,,
+pip/_internal/utils/__pycache__/filetypes.cpython-310.pyc,,
+pip/_internal/utils/__pycache__/glibc.cpython-310.pyc,,
+pip/_internal/utils/__pycache__/hashes.cpython-310.pyc,,
+pip/_internal/utils/__pycache__/inject_securetransport.cpython-310.pyc,,
+pip/_internal/utils/__pycache__/logging.cpython-310.pyc,,
+pip/_internal/utils/__pycache__/misc.cpython-310.pyc,,
+pip/_internal/utils/__pycache__/models.cpython-310.pyc,,
+pip/_internal/utils/__pycache__/packaging.cpython-310.pyc,,
+pip/_internal/utils/__pycache__/parallel.cpython-310.pyc,,
+pip/_internal/utils/__pycache__/pkg_resources.cpython-310.pyc,,
+pip/_internal/utils/__pycache__/setuptools_build.cpython-310.pyc,,
+pip/_internal/utils/__pycache__/subprocess.cpython-310.pyc,,
+pip/_internal/utils/__pycache__/temp_dir.cpython-310.pyc,,
+pip/_internal/utils/__pycache__/unpacking.cpython-310.pyc,,
+pip/_internal/utils/__pycache__/urls.cpython-310.pyc,,
+pip/_internal/utils/__pycache__/virtualenv.cpython-310.pyc,,
+pip/_internal/utils/__pycache__/wheel.cpython-310.pyc,,
+pip/_internal/utils/_log.py,sha256=t0zjUNjMLPYna4ZbL0MJB8wrxGdFvC8JsPs7f3UUdz0,1053
+pip/_internal/utils/appdirs.py,sha256=JKsp6Dlfk0BjBfni2Geq_uzpSycc8pV0Ap5A5qAwhag,1220
+pip/_internal/utils/compat.py,sha256=U1ofuQpRkcmWNtCsZccTK_24YsauhWl0KPDMnC69adM,1947
+pip/_internal/utils/compatibility_tags.py,sha256=f0RJ5Wb3Jj2T5z57i0RPLyoWNtqYvymealy3aUucrVU,5622
+pip/_internal/utils/datetime.py,sha256=NhzGBwpDdc5W1hX7-ynGHSFH5T8srUUPpFw6zOORiMM,253
+pip/_internal/utils/deprecation.py,sha256=onEDau8zZyztsQf5HjhHTckTChbXIIdOWRh_Ugz1PSQ,3304
+pip/_internal/utils/direct_url_helpers.py,sha256=7xVyieLJtD1SmB1xsNhIPsYBGIDK7AZGQUtfZyRi0tQ,3073
+pip/_internal/utils/distutils_args.py,sha256=fw5ZrUBHRy2IWgLciAKUl7RA4Ryu6jWL-M9LNv90V2k,1291
+pip/_internal/utils/encoding.py,sha256=3Hr_T_shHHq5EJmQg7sUCeNY37pvmxEmQay6aPsK_4o,1205
+pip/_internal/utils/entrypoints.py,sha256=Iq8laJFPEcErDlGcPIshG_-VrUmfwLB3_nLWlT1EIKI,1082
+pip/_internal/utils/filesystem.py,sha256=8UhURyTKl2R1l9TAnYXuULsGNNMkH9IBPHAoRy4QEaU,6075
+pip/_internal/utils/filetypes.py,sha256=0VA-FQmevfgw7_9OAe7YXjxB3DcYUxpUypVKERWlU_I,789
+pip/_internal/utils/glibc.py,sha256=6i1vPIDuLfV3vKQeFe2oUa9QjSHGVlOkvysujEldOEE,3262
+pip/_internal/utils/hashes.py,sha256=dV10-3U4kcopR-XrArkX6vFSiLS9uNOhPbrv8olu8Qw,5332
+pip/_internal/utils/inject_securetransport.py,sha256=Wa89Vhq5SdlBGreg8wdE40iDJGTouYEyFuugMrOVUI0,846
+pip/_internal/utils/logging.py,sha256=cRHg2gUYXEUknl_WzZ2Zdxxah485Gr69wl8TpymaAHc,12735
+pip/_internal/utils/misc.py,sha256=Zt509grPCYtfQEI16CHULTX9nW8eRXbBucPQQasuOYk,24472
+pip/_internal/utils/models.py,sha256=89bZ42cL0YJUmV9GCaFLfs4ZiG_cDW1udAHc6UTCI2c,1376
+pip/_internal/utils/packaging.py,sha256=xTyBldqCDRn0_v9CQizadbHd3ZUTgjXeElTxrJW_JKo,2989
+pip/_internal/utils/parallel.py,sha256=7IFve8sBfphARNXprnhhuSyzlxfdDWaMP3LTFwCUL9c,3325
+pip/_internal/utils/pkg_resources.py,sha256=bkYDe05U5fph4t8TO-q06fpHQwuzookJqP0MokucHWg,1146
+pip/_internal/utils/setuptools_build.py,sha256=tO48Mgcb28GJf3zmkQlzBvsRR-2hdrpm1dipXFBkyaE,5220
+pip/_internal/utils/subprocess.py,sha256=0GB0g9r2muHAnljX2s_sX-x805eWWoDtdN_9JcCwKu8,10324
+pip/_internal/utils/temp_dir.py,sha256=gFwfsfEtM-y5Lb9ZqpbP1wy_K3o-vUPsMouAFQCy7mg,8210
+pip/_internal/utils/unpacking.py,sha256=klIaodkk3_rIg-VjN2s-PQFPfGXaVhOWpOwd46T7bHo,9317
+pip/_internal/utils/urls.py,sha256=pJQSXBv1vKtBFr9KPbSMYA5lY7-G9rjLHq0A8plI7yo,1863
+pip/_internal/utils/virtualenv.py,sha256=3JeTdc_O-2uZbfn7EmQKLyXurWKD3nKSEi856ZZWSC4,3675
+pip/_internal/utils/wheel.py,sha256=xeIImmT3FJfVBPv3J4jxsHJy2wLinnJXAsZOcrrMSAM,6479
+pip/_internal/vcs/__init__.py,sha256=6ZAbu6NoqDWJjYPWCtn8PaZjulAEgs-R0Xngq2Z174Q,611
+pip/_internal/vcs/__pycache__/__init__.cpython-310.pyc,,
+pip/_internal/vcs/__pycache__/bazaar.cpython-310.pyc,,
+pip/_internal/vcs/__pycache__/git.cpython-310.pyc,,
+pip/_internal/vcs/__pycache__/mercurial.cpython-310.pyc,,
+pip/_internal/vcs/__pycache__/subversion.cpython-310.pyc,,
+pip/_internal/vcs/__pycache__/versioncontrol.cpython-310.pyc,,
+pip/_internal/vcs/bazaar.py,sha256=6_3dygJ3x0TrnlsMx2-sokvNKpk-6EfH2zsMgAmLj4o,3058
+pip/_internal/vcs/git.py,sha256=vYxXxg4M6YIUxNQCswMJJ2ZiBkb4capqTziRrATcp0E,17853
+pip/_internal/vcs/mercurial.py,sha256=jrfkmZF7SLOwxrJroz-NjvTTMCvaWl8BnZATPdu1CsE,5234
+pip/_internal/vcs/subversion.py,sha256=Oy4kcrNGmimnatKWHGKtED-0Da6bjfuc2DtsnitUam0,12195
+pip/_internal/vcs/versioncontrol.py,sha256=7w9WNAlFXQj5pRlWA-3jA8XUwn1VSxbNfmWvI-aY2p0,23998
+pip/_internal/wheel_builder.py,sha256=3bibo47mjXw7rRChRqudDQObp5JynLQ5uZ8x81PtBq8,12100
+pip/_vendor/__init__.py,sha256=3sjRJDFysoLez0JAFlt8jJA0FUzWVPkt9AlJlcuNsC0,4814
+pip/_vendor/__pycache__/__init__.cpython-310.pyc,,
+pip/_vendor/__pycache__/appdirs.cpython-310.pyc,,
+pip/_vendor/__pycache__/distro.cpython-310.pyc,,
+pip/_vendor/__pycache__/pyparsing.cpython-310.pyc,,
+pip/_vendor/__pycache__/six.cpython-310.pyc,,
+pip/_vendor/appdirs.py,sha256=Od1rs7d0yMmHLUc0FQn2DleIUbC--EEmM-UtXvFqAjM,26540
+pip/_vendor/cachecontrol/__init__.py,sha256=SR74BEsga7Z2I6-CH8doh2Oq_vH0GG7RCwjJg7TntdI,313
+pip/_vendor/cachecontrol/__pycache__/__init__.cpython-310.pyc,,
+pip/_vendor/cachecontrol/__pycache__/_cmd.cpython-310.pyc,,
+pip/_vendor/cachecontrol/__pycache__/adapter.cpython-310.pyc,,
+pip/_vendor/cachecontrol/__pycache__/cache.cpython-310.pyc,,
+pip/_vendor/cachecontrol/__pycache__/compat.cpython-310.pyc,,
+pip/_vendor/cachecontrol/__pycache__/controller.cpython-310.pyc,,
+pip/_vendor/cachecontrol/__pycache__/filewrapper.cpython-310.pyc,,
+pip/_vendor/cachecontrol/__pycache__/heuristics.cpython-310.pyc,,
+pip/_vendor/cachecontrol/__pycache__/serialize.cpython-310.pyc,,
+pip/_vendor/cachecontrol/__pycache__/wrapper.cpython-310.pyc,,
+pip/_vendor/cachecontrol/_cmd.py,sha256=KIO6PIJoXmNr5RGS2pZjDum1-40oR4fw5kE0LguxrY4,1352
+pip/_vendor/cachecontrol/adapter.py,sha256=FBRrYfpkXaH8hKogEgw6wYCScnL2SJFDZlHBNF0EvLE,5015
+pip/_vendor/cachecontrol/cache.py,sha256=gCo5R0D__iptJ49dUfxwWfu2Lc2OjpDs-MERy2hTpK8,844
+pip/_vendor/cachecontrol/caches/__init__.py,sha256=rN8Ox5dd2ucPtgkybgz77XfTTUL4HFTO2-n2ACK2q3E,88
+pip/_vendor/cachecontrol/caches/__pycache__/__init__.cpython-310.pyc,,
+pip/_vendor/cachecontrol/caches/__pycache__/file_cache.cpython-310.pyc,,
+pip/_vendor/cachecontrol/caches/__pycache__/redis_cache.cpython-310.pyc,,
+pip/_vendor/cachecontrol/caches/file_cache.py,sha256=tw35e4ZnOsxqrlZ2fQ2VYz2FlUlCbFMerNu2tPwtRHY,4299
+pip/_vendor/cachecontrol/caches/redis_cache.py,sha256=hFJ_J9MCUTjblJCBT_cV_glP--2toqHDCKLRGUIHSOQ,889
+pip/_vendor/cachecontrol/compat.py,sha256=3BisP29GBHAo0QxUrbpBsMeXSp8YzKQcGHwEW7VYU2U,724
+pip/_vendor/cachecontrol/controller.py,sha256=fTDK1V7NjpnU1hwfMboX4Vyh73-uWgL6QkghtvvyTrY,14525
+pip/_vendor/cachecontrol/filewrapper.py,sha256=YsK9ISeZg26n-rS0z7MdEcMTyQ9gW_fLb6zIRJvE2rg,2613
+pip/_vendor/cachecontrol/heuristics.py,sha256=yndlfXHJZ5u_TC1ECrV4fVl68OuWiXnDS0HPyscK1MM,4205
+pip/_vendor/cachecontrol/serialize.py,sha256=7Jq5PcVBH6RVI-qkKkQsV5yAiZCFQa7yFhvITw_DYsc,7279
+pip/_vendor/cachecontrol/wrapper.py,sha256=tKJnzRvbl7uJRxOChwlNLdJf9NR0QlnknQxgNzQW2kM,719
+pip/_vendor/certifi/__init__.py,sha256=mRf2Fl2WmJxc7O-Zob068lpqa3nlsU4215CXzbkoBBU,65
+pip/_vendor/certifi/__main__.py,sha256=4JJNpOgznsXzgISGReUBrJGB6Q4zJOlIV99WFE185fM,267
+pip/_vendor/certifi/__pycache__/__init__.cpython-310.pyc,,
+pip/_vendor/certifi/__pycache__/__main__.cpython-310.pyc,,
+pip/_vendor/certifi/__pycache__/core.cpython-310.pyc,,
+pip/_vendor/certifi/cacert.pem,sha256=3i-hfE2K5o3CBKG2tYt6ehJWk2fP64o6Th83fHPoPp4,259465
+pip/_vendor/certifi/core.py,sha256=u1ccq2BcSYX_ZtX61r6UFpwbKCKxNavjrzse_QVQ_PI,2916
+pip/_vendor/chardet/__init__.py,sha256=yxky3TQpsr5YTFEf5XYv0O4wq2e1WSilELYZ9e2AEes,3354
+pip/_vendor/chardet/__pycache__/__init__.cpython-310.pyc,,
+pip/_vendor/chardet/__pycache__/big5freq.cpython-310.pyc,,
+pip/_vendor/chardet/__pycache__/big5prober.cpython-310.pyc,,
+pip/_vendor/chardet/__pycache__/chardistribution.cpython-310.pyc,,
+pip/_vendor/chardet/__pycache__/charsetgroupprober.cpython-310.pyc,,
+pip/_vendor/chardet/__pycache__/charsetprober.cpython-310.pyc,,
+pip/_vendor/chardet/__pycache__/codingstatemachine.cpython-310.pyc,,
+pip/_vendor/chardet/__pycache__/compat.cpython-310.pyc,,
+pip/_vendor/chardet/__pycache__/cp949prober.cpython-310.pyc,,
+pip/_vendor/chardet/__pycache__/enums.cpython-310.pyc,,
+pip/_vendor/chardet/__pycache__/escprober.cpython-310.pyc,,
+pip/_vendor/chardet/__pycache__/escsm.cpython-310.pyc,,
+pip/_vendor/chardet/__pycache__/eucjpprober.cpython-310.pyc,,
+pip/_vendor/chardet/__pycache__/euckrfreq.cpython-310.pyc,,
+pip/_vendor/chardet/__pycache__/euckrprober.cpython-310.pyc,,
+pip/_vendor/chardet/__pycache__/euctwfreq.cpython-310.pyc,,
+pip/_vendor/chardet/__pycache__/euctwprober.cpython-310.pyc,,
+pip/_vendor/chardet/__pycache__/gb2312freq.cpython-310.pyc,,
+pip/_vendor/chardet/__pycache__/gb2312prober.cpython-310.pyc,,
+pip/_vendor/chardet/__pycache__/hebrewprober.cpython-310.pyc,,
+pip/_vendor/chardet/__pycache__/jisfreq.cpython-310.pyc,,
+pip/_vendor/chardet/__pycache__/jpcntx.cpython-310.pyc,,
+pip/_vendor/chardet/__pycache__/langbulgarianmodel.cpython-310.pyc,,
+pip/_vendor/chardet/__pycache__/langgreekmodel.cpython-310.pyc,,
+pip/_vendor/chardet/__pycache__/langhebrewmodel.cpython-310.pyc,,
+pip/_vendor/chardet/__pycache__/langhungarianmodel.cpython-310.pyc,,
+pip/_vendor/chardet/__pycache__/langrussianmodel.cpython-310.pyc,,
+pip/_vendor/chardet/__pycache__/langthaimodel.cpython-310.pyc,,
+pip/_vendor/chardet/__pycache__/langturkishmodel.cpython-310.pyc,,
+pip/_vendor/chardet/__pycache__/latin1prober.cpython-310.pyc,,
+pip/_vendor/chardet/__pycache__/mbcharsetprober.cpython-310.pyc,,
+pip/_vendor/chardet/__pycache__/mbcsgroupprober.cpython-310.pyc,,
+pip/_vendor/chardet/__pycache__/mbcssm.cpython-310.pyc,,
+pip/_vendor/chardet/__pycache__/sbcharsetprober.cpython-310.pyc,,
+pip/_vendor/chardet/__pycache__/sbcsgroupprober.cpython-310.pyc,,
+pip/_vendor/chardet/__pycache__/sjisprober.cpython-310.pyc,,
+pip/_vendor/chardet/__pycache__/universaldetector.cpython-310.pyc,,
+pip/_vendor/chardet/__pycache__/utf8prober.cpython-310.pyc,,
+pip/_vendor/chardet/__pycache__/version.cpython-310.pyc,,
+pip/_vendor/chardet/big5freq.py,sha256=dwRzRlsGp3Zgr1JQSSSwnxvyaZ7_q-5kuPfCVMuy4to,31640
+pip/_vendor/chardet/big5prober.py,sha256=TpmdoNfRtnQ7x9Q_p-a1CHaG-ok2mbisN5e9UHAtOiY,1804
+pip/_vendor/chardet/chardistribution.py,sha256=NzboAhfS6GODy_Tp6BkmUOL4NuxwTVfdVFcKA9bdUAo,9644
+pip/_vendor/chardet/charsetgroupprober.py,sha256=NPYh0Agp8UnrfqIls_qdbwszQ1mv9imGawGUCErFT6M,3946
+pip/_vendor/chardet/charsetprober.py,sha256=kk5-m0VdjqzbEhPRkBZ386R3fBQo3DxsBrdL-WFyk1o,5255
+pip/_vendor/chardet/cli/__init__.py,sha256=frcCV1k9oG9oKj3dpUqdJg1PxRT2RSN_XKdLCPjaYaY,2
+pip/_vendor/chardet/cli/__pycache__/__init__.cpython-310.pyc,,
+pip/_vendor/chardet/cli/__pycache__/chardetect.cpython-310.pyc,,
+pip/_vendor/chardet/cli/chardetect.py,sha256=535zsG4tA_x-_xPtEeDvn46QLib2nvF-5NT_nJdGgVs,2831
+pip/_vendor/chardet/codingstatemachine.py,sha256=qz9ZwK1q4mZ4s4zDRbyXu5KaGunYbk7g1Z7fqfb4mA4,3678
+pip/_vendor/chardet/compat.py,sha256=3j2eGvEAakISaIanHZ4wZutzfttNdRSdlo6RSjpyxsM,1236
+pip/_vendor/chardet/cp949prober.py,sha256=5NnMVUcel3jDY3w8ljD0cXyj2lcrvdagxOVE1jxl7xc,1904
+pip/_vendor/chardet/enums.py,sha256=3H_EIVP-VUYOdKqe2xmYdyooEDSLqS8sACMbn_3oejU,1737
+pip/_vendor/chardet/escprober.py,sha256=5MrTnVtZGEt3ssnY-lOXmOo3JY-CIqz9ruG3KjDpkbY,4051
+pip/_vendor/chardet/escsm.py,sha256=xQbwmM3Ieuskg-Aohyc6-bSfg3vsY0tx2TEKLDoVZGg,10756
+pip/_vendor/chardet/eucjpprober.py,sha256=PHumemJS19xMhDR4xPrsvxMfyBfsb297kVWmYz6zgy8,3841
+pip/_vendor/chardet/euckrfreq.py,sha256=MrLrIWMtlaDI0LYt-MM3MougBbLtSWHs6kvZx0VasIM,13741
+pip/_vendor/chardet/euckrprober.py,sha256=VbiOn7_id7mL9Q5GdeV0Ze3w5fG0nRCpUkEzeR-bnnY,1795
+pip/_vendor/chardet/euctwfreq.py,sha256=ZPBIHZDwNknGf7m6r4xGH8bX0W38qBpnTwVVv1QHw_M,32008
+pip/_vendor/chardet/euctwprober.py,sha256=hlUyGKUxzOPfBxCcyUcvRZSxgkLuvRoDU9wejp6YMiM,1793
+pip/_vendor/chardet/gb2312freq.py,sha256=aLHs-2GS8vmSM2ljyoWWgeVq_xRRcS_gN7ykpIiV43A,20998
+pip/_vendor/chardet/gb2312prober.py,sha256=msVbrDFcrJRE_XvsyETiqbTGfvdFhVIEZ2zBd-OENaE,1800
+pip/_vendor/chardet/hebrewprober.py,sha256=r81LqgKb24ZbvOmfi95MzItUxx7bkrjJR1ppkj5rvZw,14130
+pip/_vendor/chardet/jisfreq.py,sha256=vrqCR4CmwownBVXJ3Hh_gsfiDnIHOELbcNmTyC6Jx3w,26102
+pip/_vendor/chardet/jpcntx.py,sha256=Cn4cypo2y8CpqCan-zsdfYdEgXkRCnsqQoYaCu6FRjI,19876
+pip/_vendor/chardet/langbulgarianmodel.py,sha256=IuDOQ4uAe5spaYXt1F-2_496DFYd3J5lyLKKbVg-Nkw,110347
+pip/_vendor/chardet/langgreekmodel.py,sha256=cZRowhYjEUNYCevhuD5ZMHMiOIf3Pk1IpRixjTpRPB0,103969
+pip/_vendor/chardet/langhebrewmodel.py,sha256=p-xw_b2XvGVSIQFgQL91cVpS7u3vPpGJZ0udYxD07Do,103159
+pip/_vendor/chardet/langhungarianmodel.py,sha256=EKIZs5Z8Y-l6ORDcBzE9htOMMnAnr2j6Wb1PFRBMVxM,107148
+pip/_vendor/chardet/langrussianmodel.py,sha256=TFH-3rTFzbCBF15oasmoqf92FKBnwWY_HaN2ptl5WVo,136898
+pip/_vendor/chardet/langthaimodel.py,sha256=rTzLQ2x_RjQEzZfIksCR--SCFQyuP5eCtQpqxyl5-x8,107695
+pip/_vendor/chardet/langturkishmodel.py,sha256=fWI_tafe_UQ24gdOGqOWy1tnEY2jxKHoi4ueoT3rrrc,100329
+pip/_vendor/chardet/latin1prober.py,sha256=s1SFkEFY2NGe2_9bgX2MhOmyM_U_qSd_jVSdkdSgZxs,5515
+pip/_vendor/chardet/mbcharsetprober.py,sha256=hzFVD-brxTAVLnTAkDqa1ztd6RwGGwb5oAdvhj1-lE8,3504
+pip/_vendor/chardet/mbcsgroupprober.py,sha256=DlT-X7KRUl5y3SWJNqF1NXqvkjVc47jPKjJ2j4KVs3A,2066
+pip/_vendor/chardet/mbcssm.py,sha256=LGUDh1VB61rWsZB4QlJBzaCjI2PUEUgbBc91gPlX4DQ,26053
+pip/_vendor/chardet/metadata/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+pip/_vendor/chardet/metadata/__pycache__/__init__.cpython-310.pyc,,
+pip/_vendor/chardet/metadata/__pycache__/languages.cpython-310.pyc,,
+pip/_vendor/chardet/metadata/languages.py,sha256=pGf_EnapgynSUCViRjUcwEi7AWw_bYPJFHCqerAFSbQ,19784
+pip/_vendor/chardet/sbcharsetprober.py,sha256=VPAZ5z-o8ixIIfEGTScLVXeQxkd3Zqi1eceerr0rb78,6281
+pip/_vendor/chardet/sbcsgroupprober.py,sha256=p8XICsXYXOF78Anypfvdne8K_0p8qFC-SUF5nwD1fo4,4392
+pip/_vendor/chardet/sjisprober.py,sha256=1WGev_SSHpa7AVXmM0DIONl1OvyKc8mdydUNaKtGGNI,3866
+pip/_vendor/chardet/universaldetector.py,sha256=C3ryFrDZ9JuroNMdYwgDa2_zAYJlWuPHyHLX5WtCY-g,12789
+pip/_vendor/chardet/utf8prober.py,sha256=rGwn69WfIvmibp0sWvYuH_TPoXs7zzwKHTX79Ojbr9o,2848
+pip/_vendor/chardet/version.py,sha256=LCY3oiBIflXJGeBYm7ly2aw6P9n272rhp3t7qz3oOHo,251
+pip/_vendor/colorama/__init__.py,sha256=besK61Glmusp-wZ1wjjSlsPKEY_6zndaeulh1FkVStw,245
+pip/_vendor/colorama/__pycache__/__init__.cpython-310.pyc,,
+pip/_vendor/colorama/__pycache__/ansi.cpython-310.pyc,,
+pip/_vendor/colorama/__pycache__/ansitowin32.cpython-310.pyc,,
+pip/_vendor/colorama/__pycache__/initialise.cpython-310.pyc,,
+pip/_vendor/colorama/__pycache__/win32.cpython-310.pyc,,
+pip/_vendor/colorama/__pycache__/winterm.cpython-310.pyc,,
+pip/_vendor/colorama/ansi.py,sha256=121ZIWJSdXR76TcqKXusVZQRgyb0AIlRnf5EW6oSGlQ,2624
+pip/_vendor/colorama/ansitowin32.py,sha256=bZByVMjpiUp-LSAK21KNvCh63UN9CPkXdHFPUsq20kA,10775
+pip/_vendor/colorama/initialise.py,sha256=J92wwYPAAEgdlAyw-ady4JJxl1j9UmXPodi0HicWDwg,1995
+pip/_vendor/colorama/win32.py,sha256=fI0Ani_DO_cYDAbHz_a0BsMbDKHCA1-P3PGcj0eDCmA,5556
+pip/_vendor/colorama/winterm.py,sha256=Zurpa5AEwarU62JTuERX53gGelEWH5SBUiAXN4CxMtA,6607
+pip/_vendor/distlib/__init__.py,sha256=iP0jP2IxDeV5bLyzuna9JsdxOw2AO-VqAMXslthb-oQ,604
+pip/_vendor/distlib/__pycache__/__init__.cpython-310.pyc,,
+pip/_vendor/distlib/__pycache__/compat.cpython-310.pyc,,
+pip/_vendor/distlib/__pycache__/database.cpython-310.pyc,,
+pip/_vendor/distlib/__pycache__/index.cpython-310.pyc,,
+pip/_vendor/distlib/__pycache__/locators.cpython-310.pyc,,
+pip/_vendor/distlib/__pycache__/manifest.cpython-310.pyc,,
+pip/_vendor/distlib/__pycache__/markers.cpython-310.pyc,,
+pip/_vendor/distlib/__pycache__/metadata.cpython-310.pyc,,
+pip/_vendor/distlib/__pycache__/resources.cpython-310.pyc,,
+pip/_vendor/distlib/__pycache__/scripts.cpython-310.pyc,,
+pip/_vendor/distlib/__pycache__/util.cpython-310.pyc,,
+pip/_vendor/distlib/__pycache__/version.cpython-310.pyc,,
+pip/_vendor/distlib/__pycache__/wheel.cpython-310.pyc,,
+pip/_vendor/distlib/_backport/__init__.py,sha256=XkACqtjaFfFn1QQBFDNxSqhMva0LqXeeh6H3fVwwLQ4,280
+pip/_vendor/distlib/_backport/__pycache__/__init__.cpython-310.pyc,,
+pip/_vendor/distlib/_backport/__pycache__/misc.cpython-310.pyc,,
+pip/_vendor/distlib/_backport/__pycache__/shutil.cpython-310.pyc,,
+pip/_vendor/distlib/_backport/__pycache__/sysconfig.cpython-310.pyc,,
+pip/_vendor/distlib/_backport/__pycache__/tarfile.cpython-310.pyc,,
+pip/_vendor/distlib/_backport/misc.py,sha256=focjmI7975W3LgEtiNC99lvxohfZdsNSLTakOcPNShs,1012
+pip/_vendor/distlib/_backport/shutil.py,sha256=h-yIttFtLq-_LKn5lLn4beHXzRwcmo2wEg4UKU7hX6E,26471
+pip/_vendor/distlib/_backport/sysconfig.cfg,sha256=LoipPkR2PfCKC7JUQBGxp6OFVlWIiWBXT-rNuzv8acU,2701
+pip/_vendor/distlib/_backport/sysconfig.py,sha256=qV5ZK6YVkHS-gUFacIT2TpFBw7bZJFH3DYa8PbT6O54,27640
+pip/_vendor/distlib/_backport/tarfile.py,sha256=fzwGLsCdTmO8uzoHjyjSgu4-srrDQEAcw4jNKUfvQH0,95235
+pip/_vendor/distlib/compat.py,sha256=Z8PBQ-ZPCJuRvzs5rtHuzceFOB8iYV8HHjAGrW3SQ8s,42528
+pip/_vendor/distlib/database.py,sha256=m_LtL3siDUdcSvftoTnXcjhUJA-WZhDwTvHO7rg72SA,52398
+pip/_vendor/distlib/index.py,sha256=LMZK2uX_oH2SNgPQ_lnnoJFFx6X5ByY-LBP8qgUTuC0,21248
+pip/_vendor/distlib/locators.py,sha256=mefGpRbPPG1Bl-UhNUquwBQR50J8uL0x2CSG-c5mbJs,53265
+pip/_vendor/distlib/manifest.py,sha256=0TlGw5ZyFp8wxr_GJz7tAAXGYwUJvceMIOsh9ydAXpM,15204
+pip/_vendor/distlib/markers.py,sha256=lTFISO7AcGHoYk2AQx_VFrjDltOFAg5YnPTvBGnOZtE,4474
+pip/_vendor/distlib/metadata.py,sha256=tCLNLfWfC-lQacX4bY-mBTKPgJZTiowKnLX2HWUcQeE,40167
+pip/_vendor/distlib/resources.py,sha256=DMriFf8j-5IXduPHW0YPnx50jQIbaOlvTQkPcdN5r88,11178
+pip/_vendor/distlib/scripts.py,sha256=-jtzATPNKOj8VpnxJUh1aXdUUkNpXiop-bOwsojbwWA,17671
+pip/_vendor/distlib/t32.exe,sha256=NS3xBCVAld35JVFNmb-1QRyVtThukMrwZVeXn4LhaEQ,96768
+pip/_vendor/distlib/t64.exe,sha256=oAqHes78rUWVM0OtVqIhUvequl_PKhAhXYQWnUf7zR0,105984
+pip/_vendor/distlib/util.py,sha256=w5nS2W71eWhilj69cZbERp6NR5rV1p_yIUbkwpvtqu4,69523
+pip/_vendor/distlib/version.py,sha256=cI1oZGIqY11EQn5P-jI_OqQml7jIxLFS52syBFIpXNU,24247
+pip/_vendor/distlib/w32.exe,sha256=lJtnZdeUxTZWya_EW5DZos_K5rswRECGspIl8ZJCIXs,90112
+pip/_vendor/distlib/w64.exe,sha256=0aRzoN2BO9NWW4ENy4_4vHkHR4qZTFZNVSAJJYlODTI,99840
+pip/_vendor/distlib/wheel.py,sha256=NNoICc3pe4uSF-gHpmqgGwQs3Q-0dnn5418JHS1ZI6c,44118
+pip/_vendor/distro.py,sha256=ni3ahks9qSr3P1FMur9zTPEF_xcAdaHW8iWZWqwB5mU,44858
+pip/_vendor/html5lib/__init__.py,sha256=Bmlpvs5dN2GoaWRAvN2UZ1yF_p7xb2zROelA0QxBKis,1195
+pip/_vendor/html5lib/__pycache__/__init__.cpython-310.pyc,,
+pip/_vendor/html5lib/__pycache__/_ihatexml.cpython-310.pyc,,
+pip/_vendor/html5lib/__pycache__/_inputstream.cpython-310.pyc,,
+pip/_vendor/html5lib/__pycache__/_tokenizer.cpython-310.pyc,,
+pip/_vendor/html5lib/__pycache__/_utils.cpython-310.pyc,,
+pip/_vendor/html5lib/__pycache__/constants.cpython-310.pyc,,
+pip/_vendor/html5lib/__pycache__/html5parser.cpython-310.pyc,,
+pip/_vendor/html5lib/__pycache__/serializer.cpython-310.pyc,,
+pip/_vendor/html5lib/_ihatexml.py,sha256=IyMKE35pNPCYYGs290_oSUhWXF1BQZsbVcXBzGuFvl4,17017
+pip/_vendor/html5lib/_inputstream.py,sha256=EA6Wj46jxuK6544Vnk9YOjIpFwGbfJW0Ar2cMH1H0VU,33271
+pip/_vendor/html5lib/_tokenizer.py,sha256=BUDNWZENVB0oFBiKR49sZsqQU4rzLLa13-byISlYRfA,78775
+pip/_vendor/html5lib/_trie/__init__.py,sha256=kfSo27BaU64El8U7bg4ugLmI3Ksywu54xE6BlhVgggA,114
+pip/_vendor/html5lib/_trie/__pycache__/__init__.cpython-310.pyc,,
+pip/_vendor/html5lib/_trie/__pycache__/_base.cpython-310.pyc,,
+pip/_vendor/html5lib/_trie/__pycache__/py.cpython-310.pyc,,
+pip/_vendor/html5lib/_trie/_base.py,sha256=LTpLNz1pn7LAcfn2TFvRp4moVPbFTkkbhzjPKUrvGes,1053
+pip/_vendor/html5lib/_trie/py.py,sha256=LmuYcbypKw-aMLcT0-IY6WewATGzg1QRkmyd8hTBQeY,1842
+pip/_vendor/html5lib/_utils.py,sha256=dLFxoZDTv5r38HOIHy45uxWwUY7VhLgbEFWNQw6Wppo,5090
+pip/_vendor/html5lib/constants.py,sha256=P9n6_ScDgAFkst0YfKaB-yaAlxVtUS9uMn5Lh8ywbQo,86410
+pip/_vendor/html5lib/filters/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+pip/_vendor/html5lib/filters/__pycache__/__init__.cpython-310.pyc,,
+pip/_vendor/html5lib/filters/__pycache__/alphabeticalattributes.cpython-310.pyc,,
+pip/_vendor/html5lib/filters/__pycache__/base.cpython-310.pyc,,
+pip/_vendor/html5lib/filters/__pycache__/inject_meta_charset.cpython-310.pyc,,
+pip/_vendor/html5lib/filters/__pycache__/lint.cpython-310.pyc,,
+pip/_vendor/html5lib/filters/__pycache__/optionaltags.cpython-310.pyc,,
+pip/_vendor/html5lib/filters/__pycache__/sanitizer.cpython-310.pyc,,
+pip/_vendor/html5lib/filters/__pycache__/whitespace.cpython-310.pyc,,
+pip/_vendor/html5lib/filters/alphabeticalattributes.py,sha256=0TV6VWJzhNkcLFiR7BNZUJsTJgAEEyZ02in6-PuL2gU,948
+pip/_vendor/html5lib/filters/base.py,sha256=6D2t423hbOLtjnvAAOrs1mWX1vsabMLBrWQF67ITPho,298
+pip/_vendor/html5lib/filters/inject_meta_charset.py,sha256=J-W5X3LyosH1sUipiHU1x-2ocd7g9JSudpIek_QlCUU,3018
+pip/_vendor/html5lib/filters/lint.py,sha256=O6sK29HXXW02Nv-EIEOfGvdQMuXxWvBePu2sQ2ecbJc,3736
+pip/_vendor/html5lib/filters/optionaltags.py,sha256=IVHcJ35kr6_MYBqahFMIK-Gel-ALLUk6Wk9X-or_yXk,10795
+pip/_vendor/html5lib/filters/sanitizer.py,sha256=uwT0HNJHjnw3Omf2LpmvfoVdIgAWb9_3VrMcWD1es_M,27813
+pip/_vendor/html5lib/filters/whitespace.py,sha256=bCC0mMQZicbq8HCg67pip_oScN5Fz_KkkvldfE137Kw,1252
+pip/_vendor/html5lib/html5parser.py,sha256=2xGZMaUvdkuuswAmpkazK1CXHT_y3-XTy4lS71PYUuU,119981
+pip/_vendor/html5lib/serializer.py,sha256=vMivcnRcQxjCSTrbMFdevLMhJ2HbF0cfv_CkroTODZM,16168
+pip/_vendor/html5lib/treeadapters/__init__.py,sha256=76InX2oJAx-C4rGAJziZsoE_CHI8_3thl6TeMgP-ypk,709
+pip/_vendor/html5lib/treeadapters/__pycache__/__init__.cpython-310.pyc,,
+pip/_vendor/html5lib/treeadapters/__pycache__/genshi.cpython-310.pyc,,
+pip/_vendor/html5lib/treeadapters/__pycache__/sax.cpython-310.pyc,,
+pip/_vendor/html5lib/treeadapters/genshi.py,sha256=nQHNa4Hu0IMpu4bqHbJJS3_Cd1pKXgDO1pgMZ6gADDg,1769
+pip/_vendor/html5lib/treeadapters/sax.py,sha256=PAmV6NG9BSpfMHUY72bDbXwAe6Q2tPn1BC2yAD-K1G0,1826
+pip/_vendor/html5lib/treebuilders/__init__.py,sha256=zfrXDjeqDo2M7cJFax6hRJs70Az4pfHFiZbuLOZ9YE4,3680
+pip/_vendor/html5lib/treebuilders/__pycache__/__init__.cpython-310.pyc,,
+pip/_vendor/html5lib/treebuilders/__pycache__/base.cpython-310.pyc,,
+pip/_vendor/html5lib/treebuilders/__pycache__/dom.cpython-310.pyc,,
+pip/_vendor/html5lib/treebuilders/__pycache__/etree.cpython-310.pyc,,
+pip/_vendor/html5lib/treebuilders/__pycache__/etree_lxml.cpython-310.pyc,,
+pip/_vendor/html5lib/treebuilders/base.py,sha256=Yao9LOJd-4KaLEx-3ysqRkAkhv1YaDqhTksvX6nuQyY,14982
+pip/_vendor/html5lib/treebuilders/dom.py,sha256=QWkBtUprtDosTiTFlIY6QpgKwk2-pD0AV84qVTNgiLo,9164
+pip/_vendor/html5lib/treebuilders/etree.py,sha256=k-LHrme562Hd5GmIi87r1_vfF25MtURGPurT3mAp8sY,13179
+pip/_vendor/html5lib/treebuilders/etree_lxml.py,sha256=CviyyGjvv2TwN-m47DC8DFWdx0Gt-atRw9jMTv4v8-Q,15158
+pip/_vendor/html5lib/treewalkers/__init__.py,sha256=buyxCJb9LFfJ_1ZIMdc-Do1zV93Uw-7L942o2H-Swy0,5873
+pip/_vendor/html5lib/treewalkers/__pycache__/__init__.cpython-310.pyc,,
+pip/_vendor/html5lib/treewalkers/__pycache__/base.cpython-310.pyc,,
+pip/_vendor/html5lib/treewalkers/__pycache__/dom.cpython-310.pyc,,
+pip/_vendor/html5lib/treewalkers/__pycache__/etree.cpython-310.pyc,,
+pip/_vendor/html5lib/treewalkers/__pycache__/etree_lxml.cpython-310.pyc,,
+pip/_vendor/html5lib/treewalkers/__pycache__/genshi.cpython-310.pyc,,
+pip/_vendor/html5lib/treewalkers/base.py,sha256=g-cLq7VStBtpZZZ1v_Tbwp3GhJjQ2oG5njgeHVhAaXE,7728
+pip/_vendor/html5lib/treewalkers/dom.py,sha256=fBJht3gn5a6y1WN2KE9gsUru158yTQ0KikT3vOM7Xc4,1456
+pip/_vendor/html5lib/treewalkers/etree.py,sha256=VtcKOS13qy9nv2PAaYoB1j9V1Z8n9o0AEA9KoGAgYOg,4682
+pip/_vendor/html5lib/treewalkers/etree_lxml.py,sha256=u9X06RqSrHanDb0qGI-v8I99-PqzOzmnpZOspHHz_Io,6572
+pip/_vendor/html5lib/treewalkers/genshi.py,sha256=P_2Tnc2GkbWJfuodXN9oYIg6kN9E26aWXXe9iL0_eX4,2378
+pip/_vendor/idna/__init__.py,sha256=aHTBHXXun6n0ecdus8ToBvhs-4Ziin24HuNbJ9ZXE3o,893
+pip/_vendor/idna/__pycache__/__init__.cpython-310.pyc,,
+pip/_vendor/idna/__pycache__/codec.cpython-310.pyc,,
+pip/_vendor/idna/__pycache__/compat.cpython-310.pyc,,
+pip/_vendor/idna/__pycache__/core.cpython-310.pyc,,
+pip/_vendor/idna/__pycache__/idnadata.cpython-310.pyc,,
+pip/_vendor/idna/__pycache__/intranges.cpython-310.pyc,,
+pip/_vendor/idna/__pycache__/package_data.cpython-310.pyc,,
+pip/_vendor/idna/__pycache__/uts46data.cpython-310.pyc,,
+pip/_vendor/idna/codec.py,sha256=LtpT6KflQ-NkZZXgLc0_ADLiShhKuC__nz_JmYyLnXs,3570
+pip/_vendor/idna/compat.py,sha256=Y-t409G3-dxunv_cSx0zrDjJkOKtC60ALLuqSknryXc,376
+pip/_vendor/idna/core.py,sha256=PWa20xVmQMBN8zgaBNXGNKCbQHOdnqKEpdcWCxXTidw,13235
+pip/_vendor/idna/idnadata.py,sha256=z3JZKnxitScqic6U-cO3rM_SmC2P0-UjUHEDnGv1xsQ,44400
+pip/_vendor/idna/intranges.py,sha256=Ipf6IPZDhD56FppDz_tjl_1YWzzh_viPiEBBp_nSQ8k,1991
+pip/_vendor/idna/package_data.py,sha256=MMuW8HkL_d3g6tkyzl7kIEN-fg9uyv6YDmk_v_jjL3U,23
+pip/_vendor/idna/uts46data.py,sha256=l_0BwSDthDPKq_AX35avb7jnXUgPEKgjf816traOf8s,210287
+pip/_vendor/msgpack/__init__.py,sha256=OhoFouHD7wOYMP2PN-Hlyk9RAZw39V-iPTDRsmkoIns,1172
+pip/_vendor/msgpack/__pycache__/__init__.cpython-310.pyc,,
+pip/_vendor/msgpack/__pycache__/_version.cpython-310.pyc,,
+pip/_vendor/msgpack/__pycache__/exceptions.cpython-310.pyc,,
+pip/_vendor/msgpack/__pycache__/ext.cpython-310.pyc,,
+pip/_vendor/msgpack/__pycache__/fallback.cpython-310.pyc,,
+pip/_vendor/msgpack/_version.py,sha256=qcv5IclQy1PSvtCYDvZyjaUSFWdHPIRzdGjv3YwkKCs,21
+pip/_vendor/msgpack/exceptions.py,sha256=2fCtczricqQgdT3NtW6cTqmZn3WA7GQtmlPuT-NhLyM,1129
+pip/_vendor/msgpack/ext.py,sha256=3Xznjz11nxxfQJe50uLzKDznWOvxOBxWSZ833DL_DDs,6281
+pip/_vendor/msgpack/fallback.py,sha256=ZaNwBMO2hh9WrqHnYqdHJaCv8zzPMnva9YhD5yInTpM,39113
+pip/_vendor/packaging/__about__.py,sha256=eoW72tGZd0YfLOf_tDScx_kjG1SFtdXMg79yNoJrxg4,687
+pip/_vendor/packaging/__init__.py,sha256=Rtl7XZgdQyDFurOf4u9TWH8UM8-Y6pNC9mfN1QP5NZY,522
+pip/_vendor/packaging/__pycache__/__about__.cpython-310.pyc,,
+pip/_vendor/packaging/__pycache__/__init__.cpython-310.pyc,,
+pip/_vendor/packaging/__pycache__/_manylinux.cpython-310.pyc,,
+pip/_vendor/packaging/__pycache__/_musllinux.cpython-310.pyc,,
+pip/_vendor/packaging/__pycache__/_structures.cpython-310.pyc,,
+pip/_vendor/packaging/__pycache__/markers.cpython-310.pyc,,
+pip/_vendor/packaging/__pycache__/requirements.cpython-310.pyc,,
+pip/_vendor/packaging/__pycache__/specifiers.cpython-310.pyc,,
+pip/_vendor/packaging/__pycache__/tags.cpython-310.pyc,,
+pip/_vendor/packaging/__pycache__/utils.cpython-310.pyc,,
+pip/_vendor/packaging/__pycache__/version.cpython-310.pyc,,
+pip/_vendor/packaging/_manylinux.py,sha256=qLGjZQVH7CwWE2jjOIyE2f4hektTsbtFc7UxfRCQzMI,11789
+pip/_vendor/packaging/_musllinux.py,sha256=Eq-8bd_ZnxcxPEZ-N4TTl7_HATTosVSmxMhZidXvg5g,4514
+pip/_vendor/packaging/_structures.py,sha256=9-rULC3_oZTgVRl9Furm3bFZe7xVsZeGiway_piR3c0,1696
+pip/_vendor/packaging/markers.py,sha256=nTk-tDQYPWjSMZSUIwGVaIvY3NbYmtQQLSXvAgBBxL8,8791
+pip/_vendor/packaging/requirements.py,sha256=PKbV9AWRNnqd0jGBMi83GPyS3hAUmx8IMxjQSJEBXsY,4822
+pip/_vendor/packaging/specifiers.py,sha256=HeDND7swHCqUzD9mKLuvXwBp8Rl-sBdWoA9okxul8cA,31792
+pip/_vendor/packaging/tags.py,sha256=aUZfcmH14rf5DAwYCHHjx5Z9zWnPAYqm9QKJf0yEkRk,16198
+pip/_vendor/packaging/utils.py,sha256=wl4SX90PE-_rF8s24QsN30N9afxY8BX42yKBmwI3wtU,4336
+pip/_vendor/packaging/version.py,sha256=CfhEcnRcBUAgA2viaZV9i5f84V0goapf5vSGgg3Yxl0,15169
+pip/_vendor/pep517/__init__.py,sha256=_xFPzQ0RNMbFs0cvD091C2aMOneiq-cTNfGj9uSTc3k,136
+pip/_vendor/pep517/__pycache__/__init__.cpython-310.pyc,,
+pip/_vendor/pep517/__pycache__/build.cpython-310.pyc,,
+pip/_vendor/pep517/__pycache__/check.cpython-310.pyc,,
+pip/_vendor/pep517/__pycache__/colorlog.cpython-310.pyc,,
+pip/_vendor/pep517/__pycache__/compat.cpython-310.pyc,,
+pip/_vendor/pep517/__pycache__/dirtools.cpython-310.pyc,,
+pip/_vendor/pep517/__pycache__/envbuild.cpython-310.pyc,,
+pip/_vendor/pep517/__pycache__/meta.cpython-310.pyc,,
+pip/_vendor/pep517/__pycache__/wrappers.cpython-310.pyc,,
+pip/_vendor/pep517/build.py,sha256=MDBFdwDA7ygdOFkHRZDA2vmbLuM5vIg3PYnHAszhMz8,3596
+pip/_vendor/pep517/check.py,sha256=FwTS6MXy67e7MCC3QPsN4g7sou0Pg1FkXxMBLimFJQ4,6303
+pip/_vendor/pep517/colorlog.py,sha256=uOdcoDYZ0ocKGRPPs5JgvpLYVDIfoEVvoMpc43ICQFU,4213
+pip/_vendor/pep517/compat.py,sha256=BmdEmQQW3XQqBjgDov0EWT-q1V-ECANNzDp692gUTdg,1113
+pip/_vendor/pep517/dirtools.py,sha256=hrSzAJOGDo3tXdtCbgJ6LqoLhPVJn6JGmekz1ofLi6o,1173
+pip/_vendor/pep517/envbuild.py,sha256=D8XnGq1CZKAuIAMZQxpJQrvDwkjKRzKotHAOpr_AF1M,6283
+pip/_vendor/pep517/in_process/__init__.py,sha256=IZ3Qr3CBsGM77dePRWUxnF9FADyAi0imlDLX5MWGPz8,580
+pip/_vendor/pep517/in_process/__pycache__/__init__.cpython-310.pyc,,
+pip/_vendor/pep517/in_process/__pycache__/_in_process.cpython-310.pyc,,
+pip/_vendor/pep517/in_process/_in_process.py,sha256=MW1-Z-5WuMGVy0cdY3-kgSr2rEO7bIYDlhgMuMHciEw,11182
+pip/_vendor/pep517/meta.py,sha256=ZkHYB0YHt4FDuSE5NdFuVsat3xfZ6LgW6VS6d4D6vIQ,2555
+pip/_vendor/pep517/wrappers.py,sha256=mgBTFXDKJtKluWpQ7VMZda49ZUzFGSNu5d_PYJLoor0,13629
+pip/_vendor/pkg_resources/__init__.py,sha256=zeMvnKzGEcWISjTwy6YtFKWamTFJdwBwYjBAFUoyf7A,111573
+pip/_vendor/pkg_resources/__pycache__/__init__.cpython-310.pyc,,
+pip/_vendor/pkg_resources/__pycache__/py31compat.cpython-310.pyc,,
+pip/_vendor/pkg_resources/py31compat.py,sha256=tzQGe-w8g7GEXb6Ozw2-v8ZHaIygADmw0LAgriYzPAc,585
+pip/_vendor/progress/__init__.py,sha256=YTntFxK5CZDfVAa1b77EbNkWljGqvyM72YKRTHaHap8,5034
+pip/_vendor/progress/__pycache__/__init__.cpython-310.pyc,,
+pip/_vendor/progress/__pycache__/bar.cpython-310.pyc,,
+pip/_vendor/progress/__pycache__/counter.cpython-310.pyc,,
+pip/_vendor/progress/__pycache__/spinner.cpython-310.pyc,,
+pip/_vendor/progress/bar.py,sha256=evFQod41y2bMU60teK16uV-A5F4yVUehab8dtCiXj1E,2945
+pip/_vendor/progress/counter.py,sha256=c8AdstUGrFQvIQbvtHjjXxZx6LCflrY-a7DVM6IYTBs,1413
+pip/_vendor/progress/spinner.py,sha256=zLcx2RFinPfM6UwveJJrcJ8YABE3aLCAKqQFVD3pHow,1423
+pip/_vendor/pyparsing.py,sha256=lD3A8iEK1JYvnNDP00Cgve4vZjwEFonCvrpo7mEl3Q8,280501
+pip/_vendor/requests/__init__.py,sha256=IPdrlLH8zOpx45fFKwMSH9HT_d9wfwdjjoka0HEY9ps,5267
+pip/_vendor/requests/__pycache__/__init__.cpython-310.pyc,,
+pip/_vendor/requests/__pycache__/__version__.cpython-310.pyc,,
+pip/_vendor/requests/__pycache__/_internal_utils.cpython-310.pyc,,
+pip/_vendor/requests/__pycache__/adapters.cpython-310.pyc,,
+pip/_vendor/requests/__pycache__/api.cpython-310.pyc,,
+pip/_vendor/requests/__pycache__/auth.cpython-310.pyc,,
+pip/_vendor/requests/__pycache__/certs.cpython-310.pyc,,
+pip/_vendor/requests/__pycache__/compat.cpython-310.pyc,,
+pip/_vendor/requests/__pycache__/cookies.cpython-310.pyc,,
+pip/_vendor/requests/__pycache__/exceptions.cpython-310.pyc,,
+pip/_vendor/requests/__pycache__/help.cpython-310.pyc,,
+pip/_vendor/requests/__pycache__/hooks.cpython-310.pyc,,
+pip/_vendor/requests/__pycache__/models.cpython-310.pyc,,
+pip/_vendor/requests/__pycache__/packages.cpython-310.pyc,,
+pip/_vendor/requests/__pycache__/sessions.cpython-310.pyc,,
+pip/_vendor/requests/__pycache__/status_codes.cpython-310.pyc,,
+pip/_vendor/requests/__pycache__/structures.cpython-310.pyc,,
+pip/_vendor/requests/__pycache__/utils.cpython-310.pyc,,
+pip/_vendor/requests/__version__.py,sha256=SKjnGRNIWoxDQR1pAkRW3fen6mAXw7MruEBPlqvEjuE,455
+pip/_vendor/requests/_internal_utils.py,sha256=zDALdxFfs4pAp4CME_TTw2rGyYR2EGBpSehYHgfn8o0,1138
+pip/_vendor/requests/adapters.py,sha256=v-nXh1zlxNzGQWQicaDrnsMmus75p2c99GPOtPl-6uw,22081
+pip/_vendor/requests/api.py,sha256=IPHU2zrGr6hURdheImh9lqurXPhQlv4PFOkjik6dmSQ,6561
+pip/_vendor/requests/auth.py,sha256=xe7s91xl3ENjQgRlZP3-2KsACnXYHAiLOuHLDw6nyyQ,10512
+pip/_vendor/requests/certs.py,sha256=fFBPJjnP90gWELetFYPbzrsfZgSZopej7XhlkrnVVec,483
+pip/_vendor/requests/compat.py,sha256=xfkhI1O0M1RPT9n92GEeoalPuBOYMsdApi7TONmwWD8,2121
+pip/_vendor/requests/cookies.py,sha256=PIxSKntoUn6l2irwR-CBMgm0scK8s-6yUZzwoCVIAdo,18979
+pip/_vendor/requests/exceptions.py,sha256=-_Uvqm89mT79nPWoxlf_NF7JawnsfHcJdAeIipOiAQg,3377
+pip/_vendor/requests/help.py,sha256=HQ9KRPaFWwmEYS46TnLTyaGYXGNv-G3RQyO9yUfa7Gg,4104
+pip/_vendor/requests/hooks.py,sha256=LAWGUHI8SB52PkhFYbwyPcT6mWsjuVJeeZpM0RUTADc,791
+pip/_vendor/requests/models.py,sha256=eBTofFVVYXXqpuqkMrPzRNYKJfuICHhw5bPn6bi-lEI,35890
+pip/_vendor/requests/packages.py,sha256=ry2VlKGoCDdr8ZJyNCXxDcAF1HfENfmoylCK-_VzXh0,711
+pip/_vendor/requests/sessions.py,sha256=xn0NHgjfsCdvZoi11vUDP8zS0LPM0sVuZP_6qYNC7kw,30949
+pip/_vendor/requests/status_codes.py,sha256=ef_TQlJHa44J6_nrl_hTw6h7I-oZS8qg2MHCu9YyzYY,4311
+pip/_vendor/requests/structures.py,sha256=ssrNLrH8XELX89hk4yRQYEVeHnbopq1HAJBfgu38bi8,3110
+pip/_vendor/requests/utils.py,sha256=dZh-kGRO-A8sLHdHp_hcS_5u4syIDRRE2T-un0s4HwM,32407
+pip/_vendor/resolvelib/__init__.py,sha256=g_NlynQjt3xlCb_JRtRIrV6Y-zBYSkQMxH4NtoC4Axc,563
+pip/_vendor/resolvelib/__pycache__/__init__.cpython-310.pyc,,
+pip/_vendor/resolvelib/__pycache__/providers.cpython-310.pyc,,
+pip/_vendor/resolvelib/__pycache__/reporters.cpython-310.pyc,,
+pip/_vendor/resolvelib/__pycache__/resolvers.cpython-310.pyc,,
+pip/_vendor/resolvelib/__pycache__/structs.cpython-310.pyc,,
+pip/_vendor/resolvelib/compat/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+pip/_vendor/resolvelib/compat/__pycache__/__init__.cpython-310.pyc,,
+pip/_vendor/resolvelib/compat/__pycache__/collections_abc.cpython-310.pyc,,
+pip/_vendor/resolvelib/compat/collections_abc.py,sha256=RCp_gXYFZUg2DF2iUPTTD-XSpBTia4xEuJhjbXNzQyM,162
+pip/_vendor/resolvelib/providers.py,sha256=4rEMGvu_xM5qx42oiIeMwgfwsrd1vCUZusmbfvMknWg,5762
+pip/_vendor/resolvelib/reporters.py,sha256=Yi7l5VMEKyhL20KIEglPukQHWJHkweV4e4amcJs-4yk,1401
+pip/_vendor/resolvelib/resolvers.py,sha256=nlrz0Zql6opJgYgnBoFg3FwG_Z9lGp8rAi7hooQ33E8,17698
+pip/_vendor/resolvelib/structs.py,sha256=8HTLTjfJCdDs2FBt3EqaNiFbn0oelLG9OQK9htCvBpE,4959
+pip/_vendor/six.py,sha256=MB08ff_RApHF8XMk2vSx581-xTyX6sf_pQOtz6j1BZU,35547
+pip/_vendor/tenacity/__init__.py,sha256=YfrArVagvtYH5gcjBOlOQ2u6dx2C2N4X1x0DOUBXv5Y,18774
+pip/_vendor/tenacity/__pycache__/__init__.cpython-310.pyc,,
+pip/_vendor/tenacity/__pycache__/_asyncio.cpython-310.pyc,,
+pip/_vendor/tenacity/__pycache__/_utils.cpython-310.pyc,,
+pip/_vendor/tenacity/__pycache__/after.cpython-310.pyc,,
+pip/_vendor/tenacity/__pycache__/before.cpython-310.pyc,,
+pip/_vendor/tenacity/__pycache__/before_sleep.cpython-310.pyc,,
+pip/_vendor/tenacity/__pycache__/nap.cpython-310.pyc,,
+pip/_vendor/tenacity/__pycache__/retry.cpython-310.pyc,,
+pip/_vendor/tenacity/__pycache__/stop.cpython-310.pyc,,
+pip/_vendor/tenacity/__pycache__/tornadoweb.cpython-310.pyc,,
+pip/_vendor/tenacity/__pycache__/wait.cpython-310.pyc,,
+pip/_vendor/tenacity/_asyncio.py,sha256=jZcrONVfckAiLERCKTxI9DJ_Aeq4fquZj9G7Vr1_I7s,3406
+pip/_vendor/tenacity/_utils.py,sha256=J2-zhV7bDTTuye-U8jtimO7lN1x70_a23qAdKniuzSE,2012
+pip/_vendor/tenacity/after.py,sha256=mJq5ygM_NzL69Bx63RbI24IU5KgGHqmwl3AbQXiTCTc,1542
+pip/_vendor/tenacity/before.py,sha256=RmWTv09-aU_3kFVRJw6PX3dp74ZZqnRD1UZUoCWw5XY,1417
+pip/_vendor/tenacity/before_sleep.py,sha256=gSQPoPHevxpluUv0ASzd2Z4AOfq8Q8Y7XOns32cL4n8,1966
+pip/_vendor/tenacity/nap.py,sha256=5DH1ui6-d3X4ZsQCRKJhY5jaQ0NdYZ2AEqt7Svt5VFM,1426
+pip/_vendor/tenacity/retry.py,sha256=VsJQ9DcYTMr0ZeV43yhQfBDDJD1y5av52TJ0OSwvqLw,6858
+pip/_vendor/tenacity/stop.py,sha256=lVnfBu2fzvqVtsL-HH8o1m_HborN7zLnlXBWa2UzM-A,2886
+pip/_vendor/tenacity/tornadoweb.py,sha256=2wGpfDdTztK9Sk74ARv8prohTReTQzst9a1m1qo5bBs,2204
+pip/_vendor/tenacity/wait.py,sha256=t16nLHioncGDdKA6ETwTNzABC-RrZiR-7HS1pXikVsg,6882
+pip/_vendor/tomli/__init__.py,sha256=fUFJngh-LwLWqbgw4Vc7wvxnfTdrIK8Nc7wvydyxOjw,236
+pip/_vendor/tomli/__pycache__/__init__.cpython-310.pyc,,
+pip/_vendor/tomli/__pycache__/_parser.cpython-310.pyc,,
+pip/_vendor/tomli/__pycache__/_re.cpython-310.pyc,,
+pip/_vendor/tomli/_parser.py,sha256=946C00VAWqHjKSueGK44YSAU_Ufwg4LQmvd8yqta2dg,23118
+pip/_vendor/tomli/_re.py,sha256=tGGogP0HJnQDBSITAPldXRB5TLQeaC069FBzxVOOy5k,2764
+pip/_vendor/urllib3/__init__.py,sha256=FzLqycdKhCzSxjYOPTX50D3qf0lTCe6UgfZdwT-Li7o,2848
+pip/_vendor/urllib3/__pycache__/__init__.cpython-310.pyc,,
+pip/_vendor/urllib3/__pycache__/_collections.cpython-310.pyc,,
+pip/_vendor/urllib3/__pycache__/_version.cpython-310.pyc,,
+pip/_vendor/urllib3/__pycache__/connection.cpython-310.pyc,,
+pip/_vendor/urllib3/__pycache__/connectionpool.cpython-310.pyc,,
+pip/_vendor/urllib3/__pycache__/exceptions.cpython-310.pyc,,
+pip/_vendor/urllib3/__pycache__/fields.cpython-310.pyc,,
+pip/_vendor/urllib3/__pycache__/filepost.cpython-310.pyc,,
+pip/_vendor/urllib3/__pycache__/poolmanager.cpython-310.pyc,,
+pip/_vendor/urllib3/__pycache__/request.cpython-310.pyc,,
+pip/_vendor/urllib3/__pycache__/response.cpython-310.pyc,,
+pip/_vendor/urllib3/_collections.py,sha256=RQtWWhudTDETvb2BCVqih1QTpXS2Q5HSf77UJY5ditA,11148
+pip/_vendor/urllib3/_version.py,sha256=Cs83ZyfrMWqd18tvuyiZ-SW91-r7-fsCZ-S3EnE-7Vk,65
+pip/_vendor/urllib3/connection.py,sha256=ml6ucQ9HfP5eR3t_x7Qpgkke62PF92i-b_XYrIUdZeI,19293
+pip/_vendor/urllib3/connectionpool.py,sha256=itteZaSObupTC6p-6YYcI3KTQdLwgQxlS01w_hOoQqA,38198
+pip/_vendor/urllib3/contrib/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+pip/_vendor/urllib3/contrib/__pycache__/__init__.cpython-310.pyc,,
+pip/_vendor/urllib3/contrib/__pycache__/_appengine_environ.cpython-310.pyc,,
+pip/_vendor/urllib3/contrib/__pycache__/appengine.cpython-310.pyc,,
+pip/_vendor/urllib3/contrib/__pycache__/ntlmpool.cpython-310.pyc,,
+pip/_vendor/urllib3/contrib/__pycache__/pyopenssl.cpython-310.pyc,,
+pip/_vendor/urllib3/contrib/__pycache__/securetransport.cpython-310.pyc,,
+pip/_vendor/urllib3/contrib/__pycache__/socks.cpython-310.pyc,,
+pip/_vendor/urllib3/contrib/_appengine_environ.py,sha256=POYJSeNWacJYwXQdv0If3v56lcoiHuL6MQE8pwG1Yoc,993
+pip/_vendor/urllib3/contrib/_securetransport/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+pip/_vendor/urllib3/contrib/_securetransport/__pycache__/__init__.cpython-310.pyc,,
+pip/_vendor/urllib3/contrib/_securetransport/__pycache__/bindings.cpython-310.pyc,,
+pip/_vendor/urllib3/contrib/_securetransport/__pycache__/low_level.cpython-310.pyc,,
+pip/_vendor/urllib3/contrib/_securetransport/bindings.py,sha256=jreOmmwBW-Cio0m7I_OjmP028nqgrGuo_oB2f7Gir3s,18168
+pip/_vendor/urllib3/contrib/_securetransport/low_level.py,sha256=0KKeznz3h0z-SBDbCtGorDfgCgiZ30VQOqkX5ZgaPBY,14304
+pip/_vendor/urllib3/contrib/appengine.py,sha256=nlIR6iWZ0A1cV9X4dYwdx7H1F1tqGE7ai9QCfJ7ntFo,11348
+pip/_vendor/urllib3/contrib/ntlmpool.py,sha256=JCCrvNQpXdL3eb_D4AoviNnl71nYhSX2r-hG9N-dPf4,4668
+pip/_vendor/urllib3/contrib/pyopenssl.py,sha256=093d4DdfHcz0h8KcEg-D9fQEUtXaVLENmOkzOqNQ5eU,17402
+pip/_vendor/urllib3/contrib/securetransport.py,sha256=ozB5tLGYiVgN2NLx9vvzVxjdtY9nNj9mBxGsCYTwEGI,35356
+pip/_vendor/urllib3/contrib/socks.py,sha256=RqYih4HGeICnKzmYnG3MMo2xMlCdwb1bAdEuo6zCA_Y,7313
+pip/_vendor/urllib3/exceptions.py,sha256=QDT9xy1fNxui5aS7dMabeb1gokQOQ-zOT7XiDp-O5Qo,8540
+pip/_vendor/urllib3/fields.py,sha256=0KSfpuXxzXUMLkI2npM9siWOqCJO1H4wCiJN6neVmlA,8853
+pip/_vendor/urllib3/filepost.py,sha256=BVkEES0YAO9tFwXGBj1mD9yO92pRwk4pX5Q6cO5IRb8,2538
+pip/_vendor/urllib3/packages/__init__.py,sha256=FsOIVHqBFBlT3XxZnaD5y2yq0mvtVwmY4kut3GEfcBI,113
+pip/_vendor/urllib3/packages/__pycache__/__init__.cpython-310.pyc,,
+pip/_vendor/urllib3/packages/__pycache__/six.cpython-310.pyc,,
+pip/_vendor/urllib3/packages/backports/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+pip/_vendor/urllib3/packages/backports/__pycache__/__init__.cpython-310.pyc,,
+pip/_vendor/urllib3/packages/backports/__pycache__/makefile.cpython-310.pyc,,
+pip/_vendor/urllib3/packages/backports/makefile.py,sha256=DREmQjGcs2LoVH_Q3hrggClhTNdcI5Y3GJglsuihjAM,1468
+pip/_vendor/urllib3/packages/six.py,sha256=dUImuFN7dZON9oeQQqHjXdwH3n2Oxr9148Ns4K4Y2xg,35743
+pip/_vendor/urllib3/packages/ssl_match_hostname/__init__.py,sha256=d-Tyw37qbvVdcjcVF4WLYiM7AXaOpIg386C2P2uB5Ks,951
+pip/_vendor/urllib3/packages/ssl_match_hostname/__pycache__/__init__.cpython-310.pyc,,
+pip/_vendor/urllib3/packages/ssl_match_hostname/__pycache__/_implementation.cpython-310.pyc,,
+pip/_vendor/urllib3/packages/ssl_match_hostname/_implementation.py,sha256=WXs1yNtk9PsYVmeTJQAcqeAm81zbzeabEWWf-xRJSAo,5839
+pip/_vendor/urllib3/poolmanager.py,sha256=blNTYqVqFg9zUGncVtyXk1HQsTxKO1Cy9hfGVLAGvhM,20299
+pip/_vendor/urllib3/request.py,sha256=Fe4bQCUhum8qh3t1dihpSsQwdyfd5nB44cNX8566DmM,6155
+pip/_vendor/urllib3/response.py,sha256=LjfUJBUhwPrJTrGgNI3WoySUizNEPd1Xiv71YxE2J7Y,29024
+pip/_vendor/urllib3/util/__init__.py,sha256=UV_J7p9b29cJXXQ6wTvBZppJDLUeKQ6mcv0v1ptl13c,1204
+pip/_vendor/urllib3/util/__pycache__/__init__.cpython-310.pyc,,
+pip/_vendor/urllib3/util/__pycache__/connection.cpython-310.pyc,,
+pip/_vendor/urllib3/util/__pycache__/proxy.cpython-310.pyc,,
+pip/_vendor/urllib3/util/__pycache__/queue.cpython-310.pyc,,
+pip/_vendor/urllib3/util/__pycache__/request.cpython-310.pyc,,
+pip/_vendor/urllib3/util/__pycache__/response.cpython-310.pyc,,
+pip/_vendor/urllib3/util/__pycache__/retry.cpython-310.pyc,,
+pip/_vendor/urllib3/util/__pycache__/ssl_.cpython-310.pyc,,
+pip/_vendor/urllib3/util/__pycache__/ssltransport.cpython-310.pyc,,
+pip/_vendor/urllib3/util/__pycache__/timeout.cpython-310.pyc,,
+pip/_vendor/urllib3/util/__pycache__/url.cpython-310.pyc,,
+pip/_vendor/urllib3/util/__pycache__/wait.cpython-310.pyc,,
+pip/_vendor/urllib3/util/connection.py,sha256=hoiT3Z-vROOSOB-4JrFyRKzF67xYt-ZTFMTiYj1yd6Q,5070
+pip/_vendor/urllib3/util/proxy.py,sha256=xMGYpCWlY1Obf1nod_fhOG3rk3NTUM2q_BJmj6B_NmU,1660
+pip/_vendor/urllib3/util/queue.py,sha256=mY2d0cfoJG51UEKZwk_sJMwYraofNfQWq7Larj9xh_o,520
+pip/_vendor/urllib3/util/request.py,sha256=O-NJTFysuN_wgY33pne8xA1P35qv3R7uh67ER9zwqYM,4266
+pip/_vendor/urllib3/util/response.py,sha256=685vBStgxTo8u3KoOilR6Kuh7IGPZr7TmzrP9awEtqU,3617
+pip/_vendor/urllib3/util/retry.py,sha256=6xS4OYGWN2gz8kX34RH6ly7Uc6YcfCb2Z3V0QMdHpys,21993
+pip/_vendor/urllib3/util/ssl_.py,sha256=WILvlnNl3FxrO1-AuSJzGBuFTLCNIfkzRbhNvIuxseU,17672
+pip/_vendor/urllib3/util/ssltransport.py,sha256=r8zXGD19jRdpYPlAt9wR-mBg9aVRIB3UkV1GiT5uENQ,7152
+pip/_vendor/urllib3/util/timeout.py,sha256=Ym2WjTspeYp4fzcCYGTQ5aSU1neVSMHXBAgDp1rcETw,10271
+pip/_vendor/urllib3/util/url.py,sha256=3MdcqSYaGz4A2FIwYwe4KclwnrTn6ZdEG1-sUoCniUo,14479
+pip/_vendor/urllib3/util/wait.py,sha256=qk2qJQNb3FjhOm9lKJtpByhnsLWRVapWdhW_NLr7Eog,5557
+pip/_vendor/vendor.txt,sha256=gryMWlplkGEQkjoFzG1xYAfARSAghGWVWX-fGObCxOw,386
+pip/_vendor/webencodings/__init__.py,sha256=kG5cBDbIrAtrrdU-h1iSPVYq10ayTFldU1CTRcb1ym4,10921
+pip/_vendor/webencodings/__pycache__/__init__.cpython-310.pyc,,
+pip/_vendor/webencodings/__pycache__/labels.cpython-310.pyc,,
+pip/_vendor/webencodings/__pycache__/mklabels.cpython-310.pyc,,
+pip/_vendor/webencodings/__pycache__/tests.cpython-310.pyc,,
+pip/_vendor/webencodings/__pycache__/x_user_defined.cpython-310.pyc,,
+pip/_vendor/webencodings/labels.py,sha256=e9gPVTA1XNYalJMVVX7lXvb52Kurc4UdnXFJDPcBXFE,9210
+pip/_vendor/webencodings/mklabels.py,sha256=tyhoDDc-TC6kjJY25Qn5TlsyMs2_IyPf_rfh4L6nSrg,1364
+pip/_vendor/webencodings/tests.py,sha256=7J6TdufKEml8sQSWcYEsl-e73QXtPmsIHF6pPT0sq08,6716
+pip/_vendor/webencodings/x_user_defined.py,sha256=CMn5bx2ccJ4y3Bsqf3xC24bYO4ONC3ZY_lv5vrqhKAY,4632
+pip/py.typed,sha256=9_aEgAx4lyfhJKT_8nv7mk-FpX3Mdtn8cV5Fw11xicg,290

venv/Lib/site-packages/pip-21.2.3.dist-info/WHEEL

@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: bdist_wheel (0.36.2)
+Root-Is-Purelib: true
+Tag: py3-none-any
+

venv/Lib/site-packages/pip-21.2.3.dist-info/entry_points.txt

@@ -0,0 +1,5 @@
+[console_scripts]
+pip = pip._internal.cli.main:main
+pip3 = pip._internal.cli.main:main
+pip3.8 = pip._internal.cli.main:main
+

venv/Lib/site-packages/pip-21.2.3.dist-info/top_level.txt

@@ -0,0 +1 @@
+pip