更新

Docs/DEPLOY_MANUAL.md

@@ -27,12 +27,18 @@ node --version
 
 # 检查 FFmpeg
 ffmpeg -version
+
+# 检查 pm2 (用于服务管理)
+pm2 --version
 ```
 
-如果缺少 FFmpeg:
+如果缺少依赖:
 ```bash
 sudo apt update
 sudo apt install ffmpeg
+
+# 安装 pm2
+npm install -g pm2
 ```
 
 ---
@@ -48,7 +54,30 @@ cd /home/rongye/ProgramFiles/ViGent2
 
 ---
 
-## 步骤 3: 安装后端依赖
+## 步骤 3: 部署 AI 模型 (LatentSync 1.6)
+
+> ⚠️ **重要**：LatentSync 需要独立的 Conda 环境和 **~18GB VRAM**。请**不要**直接安装在后端环境中。
+
+请参考详细的独立部署指南：
+**[LatentSync 部署指南](../models/LatentSync/DEPLOY.md)**
+
+该指南包含以下关键步骤，请务必严格按照文档操作：
+1. 创建独立的 `latentsync` Conda 环境
+2. 安装 PyTorch 2.5.1 和相关依赖
+3. 下载模型权重 (HuggingFace CLI)
+4. 复制核心推理代码
+5. 验证推理脚本
+
+**验证 LatentSync 部署**:
+```bash
+cd /home/rongye/ProgramFiles/ViGent2/models/LatentSync
+conda activate latentsync
+python -m scripts.server  # 测试能否启动，Ctrl+C 退出
+```
+
+---
+
+## 步骤 4: 安装后端依赖
 
 ```bash
 cd /home/rongye/ProgramFiles/ViGent2/backend
@@ -69,47 +98,16 @@ playwright install chromium
 
 ---
 
-## 步骤 4: 部署 AI 模型 (LatentSync 1.6)
-
-> ⚠️ **重要**：LatentSync 需要独立的 Conda 环境和 **~18GB VRAM**。请**不要**直接安装在后端环境中。
-
-请参考详细的独立部署指南：
-**[LatentSync 部署指南](../models/LatentSync/DEPLOY.md)**
-
-该指南包含以下关键步骤，请务必严格按照文档操作：
-1. 创建独立的 `latentsync` Conda 环境
-2. 安装 PyTorch 2.5.1 和相关依赖
-3. 下载模型权重 (HuggingFace CLI)
-4. 复制核心推理代码
-5. 验证推理脚本
-
-确保 LatentSync 部署成功后，再继续后续步骤。
-
----
-
-## 步骤 5: 启动 LatentSync 常驻加速服务 (可选)
-
-为了消除每次生成视频时的 30-40秒 模型加载时间，建议启动常驻服务：
-
-```bash
-cd /home/rongye/ProgramFiles/ViGent2/models/LatentSync
-
-# 后台启动服务 (自动读取 backend/.env 中的 GPU 配置)
-nohup python -m scripts.server > server.log 2>&1 &
-```
-
----
-
-## 步骤 7: 配置环境变量
+## 步骤 5: 配置环境变量
 
 ```bash
 cd /home/rongye/ProgramFiles/ViGent2/backend
 
-# 复制配置模板 (默认配置已经就绪)
+# 复制配置模板
 cp .env.example .env
 ```
 
-> 💡 **说明**：`.env.example` 已包含正确的 LatentSync 默认配置，直接复制即可使用。  
+> 💡 **说明**：`.env.example` 已包含正确的默认配置，直接复制即可使用。  
 > 如需自定义，可编辑 `.env` 修改以下参数：
 
 | 配置项 | 默认值 | 说明 |
@@ -122,20 +120,25 @@ cp .env.example .env
 
 ---
 
-## 步骤 8: 安装前端依赖
+## 步骤 6: 安装前端依赖
 
 ```bash
 cd /home/rongye/ProgramFiles/ViGent2/frontend
 
 # 安装依赖
 npm install
+
+# 生产环境构建 (可选)
+npm run build
 ```
 
 ---
 
-## 步骤 9: 测试运行
+## 步骤 7: 测试运行
 
-### 启动后端
+> 💡 先手动启动测试，确认一切正常后再配置 pm2 常驻服务。
+
+### 启动后端 (终端 1)
 
 ```bash
 cd /home/rongye/ProgramFiles/ViGent2/backend
@@ -143,16 +146,22 @@ source venv/bin/activate
 uvicorn app.main:app --host 0.0.0.0 --port 8006
 ```
 
-### 启动前端 (新开终端)
+### 启动前端 (终端 2)
 
 ```bash
 cd /home/rongye/ProgramFiles/ViGent2/frontend
 npm run dev -- -H 0.0.0.0 --port 3002
 ```
 
----
+### 启动 LatentSync (终端 3, 可选加速)
 
-## 步骤 10: 验证
+```bash
+cd /home/rongye/ProgramFiles/ViGent2/models/LatentSync
+conda activate latentsync
+python -m scripts.server
+```
+
+### 验证
 
 1. 访问 http://服务器IP:3002 查看前端
 2. 访问 http://服务器IP:8006/docs 查看 API 文档
@@ -160,53 +169,72 @@ npm run dev -- -H 0.0.0.0 --port 3002
 
 ---
 
-## 使用 systemd 管理服务 (可选)
+## 步骤 8: 使用 pm2 管理常驻服务
 
-### 后端服务
+> 推荐使用 pm2 管理所有服务，支持自动重启和日志管理。
 
-创建 `/etc/systemd/system/vigent2-backend.service`:
-```ini
-[Unit]
-Description=ViGent2 Backend API
-After=network.target
+### 创建 pm2 配置文件
 
-[Service]
-Type=simple
-User=rongye
-WorkingDirectory=/home/rongye/ProgramFiles/ViGent2/backend
-Environment="PATH=/home/rongye/ProgramFiles/ViGent2/backend/venv/bin"
-ExecStart=/home/rongye/ProgramFiles/ViGent2/backend/venv/bin/uvicorn app.main:app --host 0.0.0.0 --port 8006
-Restart=always
+创建 `/home/rongye/ProgramFiles/ViGent2/ecosystem.config.js`:
 
-[Install]
-WantedBy=multi-user.target
+```javascript
+module.exports = {
+  apps: [
+    {
+      name: 'vigent2-backend',
+      cwd: '/home/rongye/ProgramFiles/ViGent2/backend',
+      script: 'venv/bin/uvicorn',
+      args: 'app.main:app --host 0.0.0.0 --port 8006',
+      interpreter: 'none',
+      env: {
+        PATH: '/home/rongye/ProgramFiles/ViGent2/backend/venv/bin:' + process.env.PATH
+      }
+    },
+    {
+      name: 'vigent2-frontend',
+      cwd: '/home/rongye/ProgramFiles/ViGent2/frontend',
+      script: 'npm',
+      args: 'run start',
+      env: {
+        PORT: 3002
+      }
+    },
+    {
+      name: 'vigent2-latentsync',
+      cwd: '/home/rongye/ProgramFiles/ViGent2/models/LatentSync',
+      script: 'python',
+      args: '-m scripts.server',
+      interpreter: '/home/rongye/miniconda3/envs/latentsync/bin/python'
+    }
+  ]
+};
 ```
 
-### 前端服务
-
-创建 `/etc/systemd/system/vigent2-frontend.service`:
-```ini
-[Unit]
-Description=ViGent2 Frontend
-After=network.target
-
-[Service]
-Type=simple
-User=rongye
-WorkingDirectory=/home/rongye/ProgramFiles/ViGent2/frontend
-ExecStart=/usr/bin/npm run start
-Restart=always
-
-[Install]
-WantedBy=multi-user.target
-```
-
-### 启用服务
+### 启动服务
 
 ```bash
-sudo systemctl daemon-reload
-sudo systemctl enable vigent2-backend vigent2-frontend
-sudo systemctl start vigent2-backend vigent2-frontend
+cd /home/rongye/ProgramFiles/ViGent2
+
+# 启动所有服务
+pm2 start ecosystem.config.js
+
+# 查看状态
+pm2 status
+
+# 设置开机自启
+pm2 save
+pm2 startup  # 按提示执行生成的命令
+```
+
+### pm2 常用命令
+
+```bash
+pm2 status                    # 查看所有服务状态
+pm2 logs                      # 查看所有日志
+pm2 logs vigent2-backend      # 查看后端日志
+pm2 restart all               # 重启所有服务
+pm2 stop vigent2-latentsync   # 停止 LatentSync 服务
+pm2 delete all                # 删除所有服务
 ```
 
 ---
@@ -227,14 +255,45 @@ python3 -c "import torch; print(torch.cuda.is_available())"
 # 查看端口占用
 sudo lsof -i :8006
 sudo lsof -i :3002
+sudo lsof -i :8007
 ```
 
 ### 查看日志
 
 ```bash
-# 后端日志
-journalctl -u vigent2-backend -f
-
-# 前端日志
-journalctl -u vigent2-frontend -f
+# pm2 日志
+pm2 logs vigent2-backend
+pm2 logs vigent2-frontend
+pm2 logs vigent2-latentsync
 ```
+
+---
+
+## 依赖清单
+
+### 后端关键依赖
+
+| 依赖 | 用途 |
+|------|------|
+| `fastapi` | Web API 框架 |
+| `uvicorn` | ASGI 服务器 |
+| `edge-tts` | 微软 TTS 配音 |
+| `playwright` | 社交媒体自动发布 |
+| `biliup` | B站视频上传 |
+| `loguru` | 日志管理 |
+
+### 前端关键依赖
+
+| 依赖 | 用途 |
+|------|------|
+| `next` | React 框架 |
+| `swr` | 数据请求与缓存 |
+| `tailwindcss` | CSS 样式 |
+
+### LatentSync 关键依赖
+
+| 依赖 | 用途 |
+|------|------|
+| `torch` 2.5.1 | PyTorch GPU 推理 |
+| `diffusers` | Latent Diffusion 模型 |
+| `accelerate` | 模型加速 |

Docs/DevLogs/Day8.md

@@ -0,0 +1,113 @@
+# Day 8: 用户体验优化
+
+**日期**: 2026-01-22  
+**目标**: 文件名保留 + 视频持久化 + 界面优化
+
+---
+
+## 📋 任务概览
+
+| 任务 | 状态 |
+|------|------|
+| 文件名保留 | ✅ 完成 |
+| 视频持久化 | ✅ 完成 |
+| 历史视频列表 | ✅ 完成 |
+| 删除功能 | ✅ 完成 |
+
+---
+
+## 🎉 实施成果
+
+### 后端改动
+
+**修改文件**:
+- `backend/app/api/materials.py`
+  - ✅ `sanitize_filename()` 文件名安全化
+  - ✅ 时间戳前缀避免冲突 (`{timestamp}_{原始文件名}`)
+  - ✅ `list_materials` 显示原始文件名
+  - ✅ `DELETE /api/materials/{id}` 删除素材
+
+- `backend/app/api/videos.py`
+  - ✅ `GET /api/videos/generated` 历史视频列表
+  - ✅ `DELETE /api/videos/generated/{id}` 删除视频
+
+### 前端改动
+
+**修改文件**:
+- `frontend/src/app/page.tsx`
+  - ✅ `GeneratedVideo` 类型定义
+  - ✅ `generatedVideos` 状态管理
+  - ✅ `fetchGeneratedVideos()` 获取历史
+  - ✅ `deleteMaterial()` / `deleteVideo()` 删除功能
+  - ✅ 素材卡片添加删除按钮 (hover 显示)
+  - ✅ 历史视频列表组件 (右侧预览区下方)
+  - ✅ 生成完成后自动刷新历史列表
+
+---
+
+## 🔧 API 变更
+
+### 新增端点
+
+| 方法 | 路径 | 说明 |
+|------|------|------|
+| GET | `/api/videos/generated` | 获取生成视频列表 |
+| DELETE | `/api/videos/generated/{id}` | 删除生成视频 |
+| DELETE | `/api/materials/{id}` | 删除素材 |
+
+### 文件命名规则
+
+```
+原始: 测试视频.mp4
+保存: 1737518400_测试视频.mp4
+显示: 测试视频.mp4 (前端自动去除时间戳前缀)
+```
+
+---
+
+## ✅ 完成总结
+
+1. **文件名保留** - 上传保留原始名称，时间戳前缀避免冲突
+2. **视频持久化** - 从文件系统读取，刷新不丢失
+3. **历史列表** - 右侧显示历史视频，点击切换播放
+4. **删除功能** - 素材和视频均支持删除
+
+---
+
+## 📊 测试清单
+
+- [x] 上传视频后检查素材列表显示原始文件名
+- [x] 刷新页面后检查历史视频列表持久化
+- [x] 测试删除素材功能
+- [x] 测试删除生成视频功能
+- [x] 测试历史视频列表点击切换播放
+
+---
+
+## 🔧 发布功能修复 (Day 8 下半场)
+
+> 以下修复在用户体验优化后进行
+
+### 问题
+
+1. **抖音 QR 登录假成功** - 前端检测到旧 Cookie 文件就显示"登录成功"，实际可能已过期
+2. **抖音上传循环卡死** - 发布后检测逻辑不完善，`while True` 无超时
+3. **前端轮询不规范** - 使用 `setInterval` 手动轮询，不符合 React 最佳实践
+
+### 修复
+
+**后端**:
+- `publish_service.py` - 添加 `logout()` 方法、修复 `get_login_session_status()` 优先检查活跃会话
+- `api/publish.py` - 新增 `POST /api/publish/logout/{platform}` 端点
+- `douyin_uploader.py` - 添加 `import time`，修复发布按钮点击竞态条件
+
+**前端**:
+- `publish/page.tsx` - 使用 `useSWR` 替代 `setInterval` 轮询登录状态
+- `package.json` - 添加 `swr` 依赖
+
+### 新增 API
+
+| 方法 | 路径 | 说明 |
+|------|------|------|
+| POST | `/api/publish/logout/{platform}` | 注销平台登录 |
+

Docs/DevLogs/Day9.md

@@ -0,0 +1,119 @@
+# Day 9: 发布模块代码优化
+
+**日期**: 2026-01-23  
+**目标**: 代码质量优化 + 发布功能验证
+
+---
+
+## 📋 任务概览
+
+| 任务 | 状态 |
+|------|------|
+| B站/抖音发布验证 | ✅ 完成 |
+| 资源清理保障 (try-finally) | ✅ 完成 |
+| 超时保护 (消除无限循环) | ✅ 完成 |
+| 小红书 headless 模式修复 | ✅ 完成 |
+| API 输入验证 | ✅ 完成 |
+| 类型提示完善 | ✅ 完成 |
+| 服务层代码优化 | ✅ 完成 |
+
+---
+
+## 🎉 发布验证结果
+
+### 登录功能
+- ✅ **B站登录成功** - 策略3(Text)匹配，Cookie已保存
+- ✅ **抖音登录成功** - 策略3(Text)匹配，Cookie已保存
+
+### 发布功能
+- ✅ **抖音发布成功** - 自动关闭弹窗、跳转管理页面
+- ✅ **B站发布成功** - API返回 `bvid: BV14izPBQEbd`
+
+---
+
+## 🔧 代码优化
+
+### 1. 资源清理保障
+
+**问题**：Playwright 浏览器在异常路径可能未关闭
+
+**修复**：`try-finally` 模式确保资源释放
+```python
+browser = None
+context = None
+try:
+    browser = await playwright.chromium.launch(headless=True)
+    context = await browser.new_context(...)
+    # ... 业务逻辑 ...
+finally:
+    if context:
+        try: await context.close()
+        except Exception: pass
+    if browser:
+        try: await browser.close()
+        except Exception: pass
+```
+
+### 2. 超时保护
+
+**问题**：`while True` 循环可能导致任务卡死
+
+**修复**：添加类级别超时常量
+```python
+class DouyinUploader(BaseUploader):
+    UPLOAD_TIMEOUT = 300       # 视频上传超时
+    PUBLISH_TIMEOUT = 180      # 发布检测超时
+    PAGE_REDIRECT_TIMEOUT = 60 # 页面跳转超时
+```
+
+### 3. B站 bvid 提取修复
+
+**问题**：API 返回的 bvid 在 `data` 字段内
+
+**修复**：同时检查多个位置
+```python
+bvid = ret.get('data', {}).get('bvid') or ret.get('bvid', '')
+aid = ret.get('data', {}).get('aid') or ret.get('aid', '')
+```
+
+### 4. API 输入验证
+
+**修复**：所有端点添加平台验证
+```python
+SUPPORTED_PLATFORMS = {"bilibili", "douyin", "xiaohongshu"}
+
+if platform not in SUPPORTED_PLATFORMS:
+    raise HTTPException(status_code=400, detail=f"不支持的平台: {platform}")
+```
+
+---
+
+## 📁 修改文件列表
+
+### 后端
+
+| 文件 | 修改内容 |
+|------|----------|
+| `app/api/publish.py` | 输入验证、平台常量、文档改进 |
+| `app/services/publish_service.py` | 类型提示、平台 enabled 标记 |
+| `app/services/qr_login_service.py` | 类型提示、修复裸 except、超时常量 |
+| `app/services/uploader/base_uploader.py` | 类型提示 |
+| `app/services/uploader/bilibili_uploader.py` | bvid提取修复、类型提示 |
+| `app/services/uploader/douyin_uploader.py` | 资源清理、超时保护、类型提示 |
+| `app/services/uploader/xiaohongshu_uploader.py` | headless模式、资源清理、超时保护 |
+
+---
+
+## ✅ 完成总结
+
+1. **发布功能验证通过** - B站/抖音登录和发布均正常
+2. **代码健壮性提升** - 资源清理、超时保护、异常处理
+3. **代码可维护性** - 完整类型提示、常量化配置
+4. **服务器兼容性** - 小红书 headless 模式修复
+
+---
+
+## 🔗 相关文档
+
+- [代码审核报告](file:///C:/Users/danny/.gemini/antigravity/brain/a28bb1a6-2929-4c55-b837-c989943844e1/walkthrough.md)
+- [部署手册](file:///d:/CodingProjects/Antigravity/ViGent2/Docs/DEPLOY_MANUAL.md)

Docs/implementation_plan.md

@@ -22,7 +22,7 @@
 ┌─────────────────────────────────────────────────────────┐
 │                   后端 (FastAPI)                         │
 ├─────────────────────────────────────────────────────────┤
-│  Celery 任务队列 (Redis)                                 │
+│  异步任务队列 (asyncio)                                 │
 │  ├── 视频生成任务                                        │
 │  ├── TTS 配音任务                                        │
 │  └── 自动发布任务                                        │
@@ -30,7 +30,7 @@
         │               │               │
         ▼               ▼               ▼
   ┌──────────┐   ┌──────────┐   ┌──────────┐
-  │ MuseTalk │   │  FFmpeg  │   │Playwright│
+  │LatentSync│   │  FFmpeg  │   │Playwright│
   │ 唇形同步  │   │ 视频合成  │   │ 自动发布  │
   └──────────┘   └──────────┘   └──────────┘
 ```
@@ -45,7 +45,7 @@
 | **UI 组件库** | Tailwind + shadcn/ui | Ant Design |
 | **后端框架** | FastAPI | Flask |
 | **任务队列** | Celery + Redis | RQ / Dramatiq |
-| **唇形同步** | MuseTalk | Wav2Lip / SadTalker |
+| **唇形同步** | **LatentSync 1.6** | MuseTalk / Wav2Lip |
 | **TTS 配音** | EdgeTTS | CosyVoice |
 | **声音克隆** | GPT-SoVITS (可选) | - |
 | **视频处理** | FFmpeg | MoviePy |
@@ -269,6 +269,32 @@ cp -r SuperIPAgent/social-auto-upload backend/social_upload
 - [x] **常驻模型服务** (Persistent Server, 0s 加载)
 - [x] **GPU 并发控制** (串行队列防崩溃)
 
+### 阶段十一：社交媒体发布完善 (Day 7) ✅
+
+> **目标**：实现全自动扫码登录和多平台发布
+
+- [x] QR码自动登录 (Playwright headless + Stealth)
+- [x] 多平台上传器架构 (B站/抖音/小红书)
+- [x] Cookie 自动管理
+- [x] 定时发布功能
+
+### 阶段十二：用户体验优化 (Day 8) ✅
+
+> **目标**：提升文件管理和历史记录功能
+
+- [x] 文件名保留 (时间戳前缀 + 原始名称)
+- [x] 视频持久化 (历史视频列表 API)
+- [x] 素材/视频删除功能
+
+### 阶段十三：发布模块优化 (Day 9) ✅
+
+> **目标**：代码质量优化 + 发布功能验证
+
+- [x] B站/抖音登录+发布验证通过
+- [x] 资源清理保障 (try-finally)
+- [x] 超时保护 (消除无限循环)
+- [x] 完整类型提示
+
 ---
 
 ## 项目目录结构 (最终)

Docs/task_complete.md

@@ -2,8 +2,8 @@
 
 **项目**：ViGent2 数字人口播视频生成系统  
 **服务器**：Dell R730 (2× RTX 3090 24GB)  
-**更新时间**：2026-01-21  
-**整体进度**：100%（Day 7 社交发布完成）
+**更新时间**：2026-01-23  
+**整体进度**：100%（Day 9 发布模块优化完成）
 
 ## 📖 快速导航
 
@@ -16,7 +16,7 @@
 | [时间线](#-时间线) | 开发历程 |
 
 **相关文档**：
-- [Day 日志](file:///d:/CodingProjects/Antigravity/ViGent2/Docs/DevLogs/) (Day1-Day7)
+- [Day 日志](file:///d:/CodingProjects/Antigravity/ViGent2/Docs/DevLogs/) (Day1-Day9)
 - [部署指南](file:///d:/CodingProjects/Antigravity/ViGent2/Docs/DEPLOY_MANUAL.md)
 
 ---
@@ -102,6 +102,23 @@
 - [x] QR登录超时修复 (Stealth模式、多选择器fallback)
 - [x] 文档规则优化 (智能修改标准、工具使用规范)
 
+### 阶段十二：用户体验优化 (Day 8)
+- [x] 文件名保留 (时间戳前缀 + 原始名称)
+- [x] 视频持久化 (从文件系统读取历史)
+- [x] 历史视频列表组件
+- [x] 素材/视频删除功能
+- [x] 登出功能 (Logout API + 前端按钮)
+- [x] 前端 SWR 轮询优化
+- [x] QR 登录状态检测修复
+
+### 阶段十三：发布模块优化 (Day 9)
+- [x] B站/抖音发布验证通过
+- [x] 资源清理保障 (try-finally)
+- [x] 超时保护 (消除无限循环)
+- [x] 小红书 headless 模式修复
+- [x] API 输入验证
+- [x] 完整类型提示
+
 ---
 
 ## 🛤️ 后续规划
@@ -109,10 +126,10 @@
 ### 🔴 优先待办
 - [x] 视频合成最终验证 (MP4生成) ✅ Day 4 完成
 - [x] 端到端流程完整测试 ✅ Day 4 完成
-- [ ] 社交媒体发布测试 (B站/抖音已登录)
+- [x] 社交媒体发布测试 ✅ Day 9 完成 (B站/抖音登录+发布)
 
 ### 🟠 功能完善
-- [ ] 定时发布功能
+- [x] 定时发布功能 ✅ Day 7 完成
 - [ ] 批量视频生成
 - [ ] 字幕样式编辑器
 
@@ -139,7 +156,7 @@
 | TTS 配音 | 100% | ✅ 完成 |
 | 视频合成 | 100% | ✅ 完成 |
 | 唇形同步 | 100% | ✅ LatentSync 1.6 升级完成 |
-| 社交发布 | 100% | ✅ 完成 (待验证) |
+| 社交发布 | 100% | ✅ Day 9 验证通过 |
 | 服务器部署 | 100% | ✅ 完成 |
 
 ---
@@ -224,5 +241,18 @@ Day 7: 社交媒体发布完善     ✅ 完成
        - 多平台发布 (B站/抖音/小红书)
        - UI 一致性优化
        - 文档规则体系优化
+
+Day 8: 用户体验优化          ✅ 完成
+       - 文件名保留 (时间戳前缀)
+       - 视频持久化 (历史视频API)
+       - 历史视频列表组件
+       - 素材/视频删除功能
+
+Day 9: 发布模块优化          ✅ 完成
+       - B站/抖音登录+发布验证通过
+       - 资源清理保障 (try-finally)
+       - 超时保护 (消除无限循环)
+       - 小红书 headless 模式修复
+       - 完整类型提示
 ```
 

backend/app/api/publish.py

@@ -12,6 +12,7 @@ router = APIRouter()
 publish_service = PublishService()
 
 class PublishRequest(BaseModel):
+    """Video publish request model"""
     video_path: str
     platform: str
     title: str
@@ -20,13 +21,25 @@ class PublishRequest(BaseModel):
     publish_time: Optional[datetime] = None
 
 class PublishResponse(BaseModel):
+    """Video publish response model"""
     success: bool
     message: str
     platform: str
     url: Optional[str] = None
 
+# Supported platforms for validation
+SUPPORTED_PLATFORMS = {"bilibili", "douyin", "xiaohongshu"}
+
 @router.post("/", response_model=PublishResponse)
 async def publish_video(request: PublishRequest, background_tasks: BackgroundTasks):
+    """发布视频到指定平台"""
+    # Validate platform
+    if request.platform not in SUPPORTED_PLATFORMS:
+        raise HTTPException(
+            status_code=400, 
+            detail=f"不支持的平台: {request.platform}。支持的平台: {', '.join(SUPPORTED_PLATFORMS)}"
+        )
+    
     try:
         result = await publish_service.publish(
             video_path=request.video_path,
@@ -56,22 +69,32 @@ async def list_accounts():
 
 @router.post("/login/{platform}")
 async def login_platform(platform: str):
+    """触发平台QR码登录"""
+    if platform not in SUPPORTED_PLATFORMS:
+        raise HTTPException(status_code=400, detail=f"不支持的平台: {platform}")
+    
     result = await publish_service.login(platform)
     if result.get("success"):
         return result
     else:
         raise HTTPException(status_code=400, detail=result.get("message"))
 
+@router.post("/logout/{platform}")
+async def logout_platform(platform: str):
+    """注销平台登录"""
+    if platform not in SUPPORTED_PLATFORMS:
+        raise HTTPException(status_code=400, detail=f"不支持的平台: {platform}")
+    
+    result = publish_service.logout(platform)
+    return result
+
 @router.get("/login/status/{platform}")
 async def get_login_status(platform: str):
-    """检查登录状态"""
-    # 这里简化处理，实际应该维护一个登录会话字典
-    cookie_file = publish_service.cookies_dir / f"{platform}_cookies.json"
+    """检查登录状态 (优先检查活跃的扫码会话)"""
+    if platform not in SUPPORTED_PLATFORMS:
+        raise HTTPException(status_code=400, detail=f"不支持的平台: {platform}")
     
-    if cookie_file.exists():
-        return {"success": True, "message": "已登录"}
-    else:
-        return {"success": False, "message": "未登录"}
+    return publish_service.get_login_session_status(platform)
 
 @router.post("/cookies/save/{platform}")
 async def save_platform_cookie(platform: str, cookie_data: dict):
@@ -82,7 +105,13 @@ async def save_platform_cookie(platform: str, cookie_data: dict):
         platform: 平台ID
         cookie_data: {"cookie_string": "document.cookie的内容"}
     """
+    if platform not in SUPPORTED_PLATFORMS:
+        raise HTTPException(status_code=400, detail=f"不支持的平台: {platform}")
+    
     cookie_string = cookie_data.get("cookie_string", "")
+    if not cookie_string:
+        raise HTTPException(status_code=400, detail="cookie_string 不能为空")
+    
     result = await publish_service.save_cookie_string(platform, cookie_string)
     
     if result.get("success"):

backend/app/services/publish_service.py

@@ -1,9 +1,10 @@
 """
 发布服务 (基于 social-auto-upload 架构)
 """
+import json
 from datetime import datetime
 from pathlib import Path
-from typing import Optional, List
+from typing import Optional, List, Dict, Any
 from loguru import logger
 from app.core.config import settings
 
@@ -16,19 +17,22 @@ from .uploader.xiaohongshu_uploader import XiaohongshuUploader
 class PublishService:
     """Social media publishing service"""
     
-    PLATFORMS = {
-        "bilibili": {"name": "B站", "url": "https://member.bilibili.com/platform/upload/video/frame"},
-        "douyin": {"name": "抖音", "url": "https://creator.douyin.com/"},
-        "xiaohongshu": {"name": "小红书", "url": "https://creator.xiaohongshu.com/"},
-        "weixin": {"name": "微信视频号", "url": "https://channels.weixin.qq.com/"},
-        "kuaishou": {"name": "快手", "url": "https://cp.kuaishou.com/"},
+    # 支持的平台配置
+    PLATFORMS: Dict[str, Dict[str, Any]] = {
+        "bilibili": {"name": "B站", "url": "https://member.bilibili.com/platform/upload/video/frame", "enabled": True},
+        "douyin": {"name": "抖音", "url": "https://creator.douyin.com/", "enabled": True},
+        "xiaohongshu": {"name": "小红书", "url": "https://creator.xiaohongshu.com/", "enabled": True},
+        "weixin": {"name": "微信视频号", "url": "https://channels.weixin.qq.com/", "enabled": False},
+        "kuaishou": {"name": "快手", "url": "https://cp.kuaishou.com/", "enabled": False},
     }
     
-    def __init__(self):
+    def __init__(self) -> None:
         self.cookies_dir = settings.BASE_DIR / "cookies"
         self.cookies_dir.mkdir(exist_ok=True)
+        # 存储活跃的登录会话，用于跟踪登录状态
+        self.active_login_sessions: Dict[str, Any] = {}
     
-    def get_accounts(self):
+    def get_accounts(self) -> List[Dict[str, Any]]:
         """Get list of platform accounts with login status"""
         accounts = []
         for pid, pinfo in self.PLATFORMS.items():
@@ -37,7 +41,7 @@ class PublishService:
                 "platform": pid,
                 "name": pinfo["name"],
                 "logged_in": cookie_file.exists(),
-                "enabled": True
+                "enabled": pinfo.get("enabled", True)
             })
         return accounts
     
@@ -49,8 +53,8 @@ class PublishService:
         tags: List[str],
         description: str = "",
         publish_time: Optional[datetime] = None,
-        **kwargs
-    ):
+        **kwargs: Any
+    ) -> Dict[str, Any]:
         """
         Publish video to specified platform
         
@@ -87,7 +91,7 @@ class PublishService:
             if platform == "bilibili":
                 uploader = BilibiliUploader(
                     title=title,
-                    file_path=str(settings.BASE_DIR / video_path),  # Convert to absolute path
+                    file_path=str(settings.BASE_DIR.parent / video_path),  # Convert to absolute path
                     tags=tags,
                     publish_date=publish_time,
                     account_file=str(account_file),
@@ -98,7 +102,7 @@ class PublishService:
             elif platform == "douyin":
                 uploader = DouyinUploader(
                     title=title,
-                    file_path=str(settings.BASE_DIR / video_path),
+                    file_path=str(settings.BASE_DIR.parent / video_path),
                     tags=tags,
                     publish_date=publish_time,
                     account_file=str(account_file),
@@ -107,7 +111,7 @@ class PublishService:
             elif platform == "xiaohongshu":
                 uploader = XiaohongshuUploader(
                     title=title,
-                    file_path=str(settings.BASE_DIR / video_path),
+                    file_path=str(settings.BASE_DIR.parent / video_path),
                     tags=tags,
                     publish_date=publish_time,
                     account_file=str(account_file),
@@ -134,7 +138,7 @@ class PublishService:
                 "platform": platform
             }
     
-    async def login(self, platform: str):
+    async def login(self, platform: str) -> Dict[str, Any]:
         """
         启动QR码登录流程
         
@@ -150,6 +154,9 @@ class PublishService:
             # 创建QR登录服务
             qr_service = QRLoginService(platform, self.cookies_dir)
             
+            # 存储活跃会话
+            self.active_login_sessions[platform] = qr_service
+            
             # 启动登录并获取二维码
             result = await qr_service.start_login()
             
@@ -161,8 +168,55 @@ class PublishService:
                 "success": False,
                 "message": f"登录失败: {str(e)}"
             }
+
+    def get_login_session_status(self, platform: str) -> Dict[str, Any]:
+        """获取活跃登录会话的状态"""
+        # 1. 如果有活跃的扫码会话，优先检查它
+        if platform in self.active_login_sessions:
+            qr_service = self.active_login_sessions[platform]
+            status = qr_service.get_login_status()
+            
+            # 如果登录成功且Cookie已保存，清理会话
+            if status["success"] and status["cookies_saved"]:
+                del self.active_login_sessions[platform]
+                return {"success": True, "message": "登录成功"}
+            
+            return {"success": False, "message": "等待扫码..."}
+            
+        # 2. 如果没有活跃会话，检查本地Cookie文件是否存在 (用于页面初始加载)
+        # 注意：这无法检测Cookie是否过期，只能检测文件在不在
+        # 在扫码流程中，前端应该依赖上面第1步的返回
+        cookie_file = self.cookies_dir / f"{platform}_cookies.json"
+        if cookie_file.exists():
+             return {"success": True, "message": "已登录 (历史状态)"}
+             
+        return {"success": False, "message": "未登录"}
     
-    async def save_cookie_string(self, platform: str, cookie_string: str):
+    def logout(self, platform: str) -> Dict[str, Any]:
+        """
+        Logout from platform (delete cookie file)
+        """
+        if platform not in self.PLATFORMS:
+            return {"success": False, "message": "不支持的平台"}
+            
+        try:
+            # 1. 移除活跃会话
+            if platform in self.active_login_sessions:
+                del self.active_login_sessions[platform]
+                
+            # 2. 删除Cookie文件
+            cookie_file = self.cookies_dir / f"{platform}_cookies.json"
+            if cookie_file.exists():
+                cookie_file.unlink()
+                logger.info(f"[登出] {platform} Cookie已删除")
+                
+            return {"success": True, "message": "已注销"}
+            
+        except Exception as e:
+            logger.exception(f"[登出] 失败: {e}")
+            return {"success": False, "message": f"注销失败: {str(e)}"}
+
+    async def save_cookie_string(self, platform: str, cookie_string: str) -> Dict[str, Any]:
         """
         保存从客户端浏览器提取的Cookie字符串
         
@@ -198,7 +252,6 @@ class PublishService:
                 cookie_dict = bilibili_cookies
             
             # 保存Cookie
-            import json
             with open(account_file, 'w', encoding='utf-8') as f:
                 json.dump(cookie_dict, f, indent=2)
             

backend/app/services/qr_login_service.py

@@ -4,22 +4,30 @@ QR码自动登录服务
 """
 import asyncio
 import base64
-from pathlib import Path
-from playwright.async_api import async_playwright, Page
-from loguru import logger
 import json
-import os
+from pathlib import Path
+from typing import Optional, Dict, Any, List
+from playwright.async_api import async_playwright, Page, BrowserContext, Browser, Playwright as PW
+from loguru import logger
 
 
 class QRLoginService:
     """QR码登录服务"""
     
-    def __init__(self, platform: str, cookies_dir: Path):
+    # 登录监控超时 (秒)
+    LOGIN_TIMEOUT = 120
+    
+    def __init__(self, platform: str, cookies_dir: Path) -> None:
         self.platform = platform
         self.cookies_dir = cookies_dir
-        self.qr_code_image = None
-        self.login_success = False
-        self.cookies_data = None
+        self.qr_code_image: Optional[str] = None
+        self.login_success: bool = False
+        self.cookies_data: Optional[Dict[str, Any]] = None
+        
+        # Playwright 资源 (手动管理生命周期)
+        self.playwright: Optional[PW] = None
+        self.browser: Optional[Browser] = None
+        self.context: Optional[BrowserContext] = None
         
         # 每个平台使用多个选择器 (使用逗号分隔，Playwright会同时等待它们)
         self.platform_configs = {
@@ -56,7 +64,7 @@ class QRLoginService:
             }
         }
     
-    async def start_login(self):
+    async def start_login(self) -> Dict[str, Any]:
         """
         启动登录流程
         
@@ -129,109 +137,94 @@ class QRLoginService:
             await self._cleanup()
             return {"success": False, "message": f"启动失败: {str(e)}"}
     
-    async def _extract_qr_code(self, page: Page, selectors: list) -> str:
+    async def _extract_qr_code(self, page: Page, selectors: List[str]) -> Optional[str]:
         """
-        提取二维码图片（并行执行 CSS策略 和 文本策略）
+        提取二维码图片 (借鉴 SuperIPAgent 的方式)
         """
-        async def strategy_css():
+        qr_element = None
+        
+        # 策略1: 使用 get_by_role (最可靠, SuperIPAgent 使用此方法)
+        if self.platform == "douyin":
             try:
-                combined_selector = ", ".join(selectors)
-                logger.debug(f"[{self.platform}] 策略1(CSS): 开始等待...")
-                el = await page.wait_for_selector(combined_selector, state="visible", timeout=5000)
-                if el:
-                    logger.info(f"[{self.platform}] 策略1(CSS): 匹配成功")
-                    return el
-            except:
-                pass
-            return None
-
-        async def strategy_text():
-            # 扩展支持 Bilibili 和 Douyin
-            if self.platform not in ["bilibili", "douyin"]: return None
+                logger.debug(f"[{self.platform}] 策略1(Role): 尝试 get_by_role('img', name='二维码')...")
+                img = page.get_by_role("img", name="二维码")
+                await img.wait_for(state="visible", timeout=10000)
+                if await img.count() > 0:
+                    # 获取 src 属性，如果是 data:image 则直接用，否则截图
+                    src = await img.get_attribute("src")
+                    if src and src.startswith("data:image"):
+                        logger.info(f"[{self.platform}] 策略1(Role): 获取到 data URI")
+                        # 提取 base64 部分
+                        return src.split(",")[1] if "," in src else src
+                    else:
+                        logger.info(f"[{self.platform}] 策略1(Role): 截图获取")
+                        screenshot = await img.screenshot()
+                        return base64.b64encode(screenshot).decode()
+            except Exception as e:
+                logger.warning(f"[{self.platform}] 策略1(Role) 失败: {e}")
+        
+        # 策略2: CSS 选择器
+        try:
+            combined_selector = ", ".join(selectors)
+            logger.debug(f"[{self.platform}] 策略2(CSS): 开始等待...")
+            el = await page.wait_for_selector(combined_selector, state="visible", timeout=8000)
+            if el:
+                logger.info(f"[{self.platform}] 策略2(CSS): 匹配成功")
+                qr_element = el
+        except Exception as e:
+            logger.warning(f"[{self.platform}] 策略2(CSS) 失败: {e}")
+        
+        # 策略3: 基于文本查找附近图片
+        if not qr_element:
             try:
-                logger.debug(f"[{self.platform}] 策略2(Text): 开始搜索...")
-                # 关键词列表
-                keywords = ["扫码登录", "打开抖音", "抖音APP", "使用手机抖音扫码"]
-                scan_text = None
+                logger.debug(f"[{self.platform}] 策略3(Text): 开始搜索...")
+                keywords = ["扫码登录", "二维码", "打开抖音", "抖音APP"]
                 
-                # 遍历尝试关键词 (带等待)
                 for kw in keywords:
                     try:
-                        t = page.get_by_text(kw, exact=False).first
-                        # 稍微等待一下文字渲染
-                        await t.wait_for(state="visible", timeout=2000)
-                        scan_text = t
-                        logger.debug(f"[{self.platform}] 找到关键词: {kw}")
-                        break
-                    except:
-                        continue
-                
-                if scan_text:
-                    # 尝试定位周边的图片
-                    parent_locator = scan_text
-                    # 向上查找5层（扩大范围）
-                    for _ in range(5):
-                        parent_locator = parent_locator.locator("..")
+                        text_el = page.get_by_text(kw, exact=False).first
+                        await text_el.wait_for(state="visible", timeout=2000)
                         
-                        # 找图片
-                        img = parent_locator.locator("img").first
-                        if await img.is_visible():
-                            # 过滤掉头像等小图标，确保尺寸足够大
-                            bbox = await img.bounding_box()
-                            if bbox and bbox['width'] > 100:
-                                logger.info(f"[{self.platform}] 策略2(Text): 定位成功(Img)")
-                                return img
-                                
-                        # 找Canvas
-                        canvas = parent_locator.locator("canvas").first
-                        if await canvas.is_visible():
-                            logger.info(f"[{self.platform}] 策略2(Text): 定位成功(Canvas)")
-                            return canvas
+                        # 向上查找图片
+                        parent = text_el
+                        for _ in range(5):
+                            parent = parent.locator("..")
+                            imgs = parent.locator("img")
                             
+                            for i in range(await imgs.count()):
+                                img = imgs.nth(i)
+                                if await img.is_visible():
+                                    bbox = await img.bounding_box()
+                                    if bbox and bbox['width'] > 100:
+                                        logger.info(f"[{self.platform}] 策略3(Text): 成功")
+                                        qr_element = img
+                                        break
+                            if qr_element:
+                                break
+                        if qr_element:
+                            break
+                    except Exception:
+                        continue
             except Exception as e:
-                logger.warning(f"[{self.platform}] 策略2异常: {e}")
-            return None
-
-        # 并行执行两个策略，谁先找到算谁的
-        tasks = [
-            asyncio.create_task(strategy_css()),
-            asyncio.create_task(strategy_text())
-        ]
+                logger.warning(f"[{self.platform}] 策略3(Text) 失败: {e}")
         
-        qr_element = None
-        pending = set(tasks)
-        
-        while pending:
-            done, pending = await asyncio.wait(pending, return_when=asyncio.FIRST_COMPLETED)
-            
-            for task in done:
-                result = await task
-                if result:
-                    qr_element = result
-                    break
-            
-            if qr_element:
-                break
-        
-        # 取消剩下的任务 (如果找到了)
-        for task in pending:
-            task.cancel()
-
+        # 如果找到元素，截图返回
         if qr_element:
             try:
                 screenshot = await qr_element.screenshot()
                 return base64.b64encode(screenshot).decode()
             except Exception as e:
                 logger.error(f"[{self.platform}] 截图失败: {e}")
-
-        # 失败处理
-        logger.warning(f"[{self.platform}] 所有策略失败，保存全页截图")
+        
+        # 所有策略失败 - 不使用全页截图，直接返回 None
+        logger.error(f"[{self.platform}] 所有QR码提取策略失败")
+        
+        # 保存调试截图
         debug_dir = Path(__file__).parent.parent.parent / 'debug_screenshots'
         debug_dir.mkdir(exist_ok=True)
         await page.screenshot(path=str(debug_dir / f"{self.platform}_debug.png"))
         
-        screenshot = await page.screenshot()
-        return base64.b64encode(screenshot).decode()
+        return None  # 不再回退到全页截图
     
     async def _monitor_login_status(self, page: Page, success_url: str):
         """监控登录状态"""
@@ -240,7 +233,7 @@ class QRLoginService:
             key_cookies = {"bilibili": "SESSDATA", "douyin": "sessionid", "xiaohongshu": "web_session"}
             target_cookie = key_cookies.get(self.platform, "")
             
-            for i in range(120):
+            for i in range(self.LOGIN_TIMEOUT):
                 await asyncio.sleep(1)
                 
                 try:
@@ -275,37 +268,57 @@ class QRLoginService:
         finally:
             await self._cleanup()
 
-    async def _cleanup(self):
+    async def _cleanup(self) -> None:
         """清理资源"""
-        if hasattr(self, 'context') and self.context:
-            try: await self.context.close()
-            except: pass
-        if hasattr(self, 'browser') and self.browser:
-            try: await self.browser.close()
-            except: pass
-        if hasattr(self, 'playwright') and self.playwright:
-            try: await self.playwright.stop()
-            except: pass
+        if self.context:
+            try:
+                await self.context.close()
+            except Exception:
+                pass
+            self.context = None
+        if self.browser:
+            try:
+                await self.browser.close()
+            except Exception:
+                pass
+            self.browser = None
+        if self.playwright:
+            try:
+                await self.playwright.stop()
+            except Exception:
+                pass
+            self.playwright = None
             
-    async def _save_cookies(self, cookies: list):
+    async def _save_cookies(self, cookies: List[Dict[str, Any]]) -> None:
         """保存Cookie到文件"""
         try:
             cookie_file = self.cookies_dir / f"{self.platform}_cookies.json"
-            cookie_dict = {c['name']: c['value'] for c in cookies}
             
             if self.platform == "bilibili":
+                # Bilibili 使用简单格式 (biliup库需要)
+                cookie_dict = {c['name']: c['value'] for c in cookies}
                 required = ['SESSDATA', 'bili_jct', 'DedeUserID', 'DedeUserID__ckMd5']
                 cookie_dict = {k: v for k, v in cookie_dict.items() if k in required}
+                
+                with open(cookie_file, 'w', encoding='utf-8') as f:
+                    json.dump(cookie_dict, f, indent=2)
+                self.cookies_data = cookie_dict
+            else:
+                # Douyin/Xiaohongshu 使用 Playwright storage_state 完整格式
+                # 这样可以直接用 browser.new_context(storage_state=file)
+                storage_state = {
+                    "cookies": cookies,
+                    "origins": []
+                }
+                with open(cookie_file, 'w', encoding='utf-8') as f:
+                    json.dump(storage_state, f, indent=2)
+                self.cookies_data = storage_state
             
-            with open(cookie_file, 'w', encoding='utf-8') as f:
-                json.dump(cookie_dict, f, indent=2)
-            
-            self.cookies_data = cookie_dict
             logger.success(f"[{self.platform}] Cookie已保存")
         except Exception as e:
             logger.error(f"[{self.platform}] 保存Cookie失败: {e}")
     
-    def get_login_status(self):
+    def get_login_status(self) -> Dict[str, Any]:
         """获取登录状态"""
         return {
             "success": self.login_success,

backend/app/services/uploader/base_uploader.py

@@ -3,7 +3,7 @@ Base uploader class for all social media platforms
 """
 from abc import ABC, abstractmethod
 from pathlib import Path
-from typing import List, Optional
+from typing import List, Optional, Dict, Any, Union
 from datetime import datetime
 
 
@@ -38,7 +38,7 @@ class BaseUploader(ABC):
         self.description = description
     
     @abstractmethod
-    async def main(self):
+    async def main(self) -> Dict[str, Any]:
         """
         Main upload method - must be implemented by subclasses
         
@@ -50,7 +50,7 @@ class BaseUploader(ABC):
         """
         pass
     
-    def _get_timestamp(self, dt):
+    def _get_timestamp(self, dt: Union[datetime, int]) -> int:
         """
         Convert datetime to Unix timestamp
         

backend/app/services/uploader/bilibili_uploader.py

@@ -2,9 +2,11 @@
 Bilibili uploader using biliup library
 """
 import json
+import asyncio
 from pathlib import Path
-from typing import Optional, List
+from typing import Optional, List, Dict, Any
 from datetime import datetime
+from concurrent.futures import ThreadPoolExecutor
 
 try:
     from biliup.plugins.bili_webup import BiliBili, Data
@@ -15,6 +17,9 @@ except ImportError:
 from loguru import logger
 from .base_uploader import BaseUploader
 
+# Thread pool for running sync biliup code
+_executor = ThreadPoolExecutor(max_workers=2)
+
 
 class BilibiliUploader(BaseUploader):
     """Bilibili video uploader using biliup library"""
@@ -46,13 +51,19 @@ class BilibiliUploader(BaseUploader):
                 "biliup library not installed. Please run: pip install biliup"
             )
     
-    async def main(self):
+    async def main(self) -> Dict[str, Any]:
         """
         Upload video to Bilibili
         
         Returns:
             dict: Upload result
         """
+        # Run sync upload in thread pool to avoid asyncio.run() conflict
+        loop = asyncio.get_event_loop()
+        return await loop.run_in_executor(_executor, self._upload_sync)
+    
+    def _upload_sync(self) -> Dict[str, Any]:
+        """Synchronous upload logic (runs in thread pool)"""
         try:
             # 1. Load cookie data
             if not self.account_file or not Path(self.account_file).exists():
@@ -66,6 +77,22 @@ class BilibiliUploader(BaseUploader):
             with open(self.account_file, 'r', encoding='utf-8') as f:
                 cookie_data = json.load(f)
             
+            # Convert simple cookie format to biliup format if needed
+            if 'cookie_info' not in cookie_data and 'SESSDATA' in cookie_data:
+                # Transform to biliup expected format
+                cookie_data = {
+                    'cookie_info': {
+                        'cookies': [
+                            {'name': k, 'value': v} for k, v in cookie_data.items()
+                        ]
+                    },
+                    'token_info': {
+                        'access_token': cookie_data.get('access_token', ''),
+                        'refresh_token': cookie_data.get('refresh_token', '')
+                    }
+                }
+                logger.info("[B站] Cookie格式已转换")
+            
             # 2. Prepare video data
             data = Data()
             data.copyright = self.copyright
@@ -97,17 +124,39 @@ class BilibiliUploader(BaseUploader):
                 # Submit
                 ret = bili.submit()
                 
+                # Debug: log full response
+                logger.debug(f"[B站] API响应: {ret}")
+                
                 if ret.get('code') == 0:
-                    bvid = ret.get('bvid', '')
-                    logger.success(f"[B站] 上传成功: {bvid}")
-                    return {
-                        "success": True,
-                        "message": "上传成功" if data.dtime == 0 else "已设置定时发布",
-                        "url": f"https://www.bilibili.com/video/{bvid}" if bvid else None
-                    }
+                    # Try multiple keys for bvid (API may vary)
+                    bvid = ret.get('data', {}).get('bvid') or ret.get('bvid', '')
+                    aid = ret.get('data', {}).get('aid') or ret.get('aid', '')
+                    
+                    if bvid:
+                        logger.success(f"[B站] 上传成功: {bvid}")
+                        return {
+                            "success": True,
+                            "message": "上传成功" if data.dtime == 0 else "已设置定时发布",
+                            "url": f"https://www.bilibili.com/video/{bvid}"
+                        }
+                    elif aid:
+                        logger.success(f"[B站] 上传成功: av{aid}")
+                        return {
+                            "success": True,
+                            "message": "上传成功" if data.dtime == 0 else "已设置定时发布",
+                            "url": f"https://www.bilibili.com/video/av{aid}"
+                        }
+                    else:
+                        # No bvid/aid but code=0, still consider success
+                        logger.warning(f"[B站] 上传返回code=0但无bvid/aid: {ret}")
+                        return {
+                            "success": True,
+                            "message": "上传成功（无法获取视频链接）",
+                            "url": None
+                        }
                 else:
                     error_msg = ret.get('message', '未知错误')
-                    logger.error(f"[B站] 上传失败: {error_msg}")
+                    logger.error(f"[B站] 上传失败: {error_msg} (完整响应: {ret})")
                     return {
                         "success": False,
                         "message": f"上传失败: {error_msg}",

backend/app/services/uploader/douyin_uploader.py

@@ -1,169 +1,585 @@
-"""
-Douyin (抖音) uploader using Playwright
-Based on social-auto-upload implementation
-"""
-from datetime import datetime
-from pathlib import Path
-from typing import Optional, List
-import asyncio
-
-from playwright.async_api import Playwright, async_playwright
-from loguru import logger
-
-from .base_uploader import BaseUploader
-from .cookie_utils import set_init_script
-
-
-class DouyinUploader(BaseUploader):
-    """Douyin video uploader using Playwright"""
-    
-    def __init__(
-        self,
-        title: str,
-        file_path: str,
-        tags: List[str],
-        publish_date: Optional[datetime] = None,
-        account_file: Optional[str] = None,
-        description: str = ""
-    ):
-        super().__init__(title, file_path, tags, publish_date, account_file, description)
-        self.upload_url = "https://creator.douyin.com/creator-micro/content/upload"
-    
-    async def set_schedule_time(self, page, publish_date):
-        """Set scheduled publish time"""
-        try:
-            # Click "定时发布" radio button
-            label_element = page.locator("[class^='radio']:has-text('定时发布')")
-            await label_element.click()
-            await asyncio.sleep(1)
-            
-            # Format time
-            publish_date_hour = publish_date.strftime("%Y-%m-%d %H:%M")
-            
-            # Fill datetime input
-            await page.locator('.semi-input[placeholder="日期和时间"]').click()
-            await page.keyboard.press("Control+KeyA")
-            await page.keyboard.type(str(publish_date_hour))
-            await page.keyboard.press("Enter")
-            
-            await asyncio.sleep(1)
-            logger.info(f"[抖音] 已设置定时发布: {publish_date_hour}")
-            
-        except Exception as e:
-            logger.error(f"[抖音] 设置定时发布失败: {e}")
-    
-    async def upload(self, playwright: Playwright):
-        """Main upload logic"""
-        try:
-            # Launch browser
-            browser = await playwright.chromium.launch(headless=False)
-            context = await browser.new_context(storage_state=self.account_file)
-            context = await set_init_script(context)
-            
-            page = await context.new_page()
-            
-            # Go to upload page
-            await page.goto(self.upload_url)
-            logger.info(f"[抖音] 正在上传: {self.file_path.name}")
-            
-            # Upload video file
-            await page.set_input_files("input[type='file']", str(self.file_path))
-            
-            # Wait for redirect to publish page
-            while True:
-                try:
-                    await page.wait_for_url(
-                        "https://creator.douyin.com/creator-micro/content/publish?enter_from=publish_page",
-                        timeout=3000
-                    )
-                    logger.info("[抖音] 成功进入发布页面")
-                    break
-                except:
-                    try:
-                        await page.wait_for_url(
-                            "https://creator.douyin.com/creator-micro/content/post/video?enter_from=publish_page",
-                            timeout=3000
-                        )
-                        logger.info("[抖音] 成功进入发布页面 (版本2)")
-                        break
-                    except:
-                        await asyncio.sleep(0.5)
-            
-            # Fill title
-            await asyncio.sleep(1)
-            logger.info("[抖音] 正在填充标题和话题...")
-            
-            title_container = page.get_by_text('作品描述').locator("..").locator("..").locator(
-                "xpath=following-sibling::div[1]").locator("input")
-            
-            if await title_container.count():
-                await title_container.fill(self.title[:30])
-            
-            # Add tags
-            css_selector = ".zone-container"
-            for tag in self.tags:
-                await page.type(css_selector, "#" + tag)
-                await page.press(css_selector, "Space")
-            
-            logger.info(f"[抖音] 总共添加 {len(self.tags)} 个话题")
-            
-            # Wait for upload to complete
-            while True:
-                try:
-                    number = await page.locator('[class^="long-card"] div:has-text("重新上传")').count()
-                    if number > 0:
-                        logger.success("[抖音] 视频上传完毕")
-                        break
-                    else:
-                        logger.info("[抖音] 正在上传视频中...")
-                        await asyncio.sleep(2)
-                except:
-                    await asyncio.sleep(2)
-            
-            # Set scheduled publish time if needed
-            if self.publish_date != 0:
-                await self.set_schedule_time(page, self.publish_date)
-            
-            # Click publish button
-            while True:
-                try:
-                    publish_button = page.get_by_role('button', name="发布", exact=True)
-                    if await publish_button.count():
-                        await publish_button.click()
-                    
-                    await page.wait_for_url(
-                        "https://creator.douyin.com/creator-micro/content/manage**",
-                        timeout=3000
-                    )
-                    logger.success("[抖音] 视频发布成功")
-                    break
-                except:
-                    logger.info("[抖音] 视频正在发布中...")
-                    await asyncio.sleep(0.5)
-            
-            # Save updated cookies
-            await context.storage_state(path=self.account_file)
-            logger.success("[抖音] Cookie 更新完毕")
-            
-            await asyncio.sleep(2)
-            await context.close()
-            await browser.close()
-            
-            return {
-                "success": True,
-                "message": "上传成功" if self.publish_date == 0 else "已设置定时发布",
-                "url": None
-            }
-            
-        except Exception as e:
-            logger.exception(f"[抖音] 上传失败: {e}")
-            return {
-                "success": False,
-                "message": f"上传失败: {str(e)}",
-                "url": None
-            }
-    
-    async def main(self):
-        """Execute upload"""
-        async with async_playwright() as playwright:
-            return await self.upload(playwright)
+"""
+Douyin (抖音) uploader using Playwright
+Based on social-auto-upload implementation
+"""
+from datetime import datetime
+from pathlib import Path
+from typing import Optional, List, Dict, Any
+import asyncio
+import time
+
+from playwright.async_api import Playwright, async_playwright
+from loguru import logger
+
+from .base_uploader import BaseUploader
+from .cookie_utils import set_init_script
+
+
+class DouyinUploader(BaseUploader):
+    """Douyin video uploader using Playwright"""
+    
+    # 超时配置 (秒)
+    UPLOAD_TIMEOUT = 300  # 视频上传超时
+    PUBLISH_TIMEOUT = 180  # 发布检测超时
+    PAGE_REDIRECT_TIMEOUT = 60  # 页面跳转超时
+    POLL_INTERVAL = 2  # 轮询间隔
+    MAX_CLICK_RETRIES = 3  # 按钮点击重试次数
+    
+    def __init__(
+        self,
+        title: str,
+        file_path: str,
+        tags: List[str],
+        publish_date: Optional[datetime] = None,
+        account_file: Optional[str] = None,
+        description: str = ""
+    ):
+        super().__init__(title, file_path, tags, publish_date, account_file, description)
+        self.upload_url = "https://creator.douyin.com/creator-micro/content/upload"
+
+    async def _is_text_visible(self, page, text: str, exact: bool = False) -> bool:
+        try:
+            return await page.get_by_text(text, exact=exact).first.is_visible()
+        except Exception:
+            return False
+
+    async def _first_visible_locator(self, locator, timeout: int = 1000):
+        try:
+            if await locator.count() == 0:
+                return None
+            candidate = locator.first
+            if await candidate.is_visible(timeout=timeout):
+                return candidate
+        except Exception:
+            return None
+        return None
+
+    async def _wait_for_publish_result(self, page, max_wait_time: int = 180):
+        success_texts = ["发布成功", "作品已发布", "再发一条", "查看作品", "审核中", "待审核"]
+        weak_texts = ["发布完成"]
+        failure_texts = ["发布失败", "发布异常", "发布出错", "请完善", "请补充", "请先上传"]
+        start_time = time.time()
+        poll_interval = 2
+        weak_reason = None
+
+        while time.time() - start_time < max_wait_time:
+            if page.is_closed():
+                return False, "页面已关闭", False
+
+            current_url = page.url
+            if "content/manage" in current_url:
+                return True, f"已跳转到管理页面 (URL: {current_url})", False
+
+            for text in success_texts:
+                if await self._is_text_visible(page, text, exact=False):
+                    return True, f"检测到成功提示: {text}", False
+
+            for text in failure_texts:
+                if await self._is_text_visible(page, text, exact=False):
+                    return False, f"检测到失败提示: {text}", False
+
+            for text in weak_texts:
+                if await self._is_text_visible(page, text, exact=False):
+                    weak_reason = text
+
+            logger.info("[抖音] 视频正在发布中...")
+            await asyncio.sleep(poll_interval)
+
+        if weak_reason:
+            return False, f"检测到提示: {weak_reason}", True
+
+        return False, "发布检测超时", True
+
+    async def _fill_title(self, page, title: str) -> bool:
+        title_text = title[:30]
+        locator_candidates = []
+
+        try:
+            label_locator = page.get_by_text("作品描述").locator("..").locator("..").locator(
+                "xpath=following-sibling::div[1]"
+            ).locator("textarea, input, div[contenteditable='true']")
+            locator_candidates.append(label_locator)
+        except Exception:
+            pass
+
+        locator_candidates.extend([
+            page.locator("textarea[placeholder*='作品描述']"),
+            page.locator("textarea[placeholder*='描述']"),
+            page.locator("input[placeholder*='作品描述']"),
+            page.locator("input[placeholder*='描述']"),
+            page.locator("div[contenteditable='true']"),
+        ])
+
+        for locator in locator_candidates:
+            try:
+                if await locator.count() > 0:
+                    target = locator.first
+                    await target.fill(title_text)
+                    return True
+            except Exception:
+                continue
+
+        return False
+
+    async def _select_cover_if_needed(self, page) -> bool:
+        try:
+            cover_button = page.get_by_text("选择封面", exact=False).first
+            if await cover_button.is_visible():
+                await cover_button.click()
+                logger.info("[抖音] 尝试选择封面")
+                await asyncio.sleep(0.5)
+
+                dialog = page.locator(
+                    "div.dy-creator-content-modal-wrap, div[role='dialog'], "
+                    "div[class*='modal'], div[class*='dialog']"
+                ).last
+                scopes = [dialog] if await dialog.count() > 0 else [page]
+
+                switched = False
+                for scope in scopes:
+                    for selector in [
+                        "button:has-text('设置横封面')",
+                        "div:has-text('设置横封面')",
+                        "span:has-text('设置横封面')",
+                    ]:
+                        try:
+                            button = await self._first_visible_locator(scope.locator(selector))
+                            if button:
+                                await button.click()
+                                logger.info("[抖音] 已切换到横封面设置")
+                                await asyncio.sleep(0.5)
+                                switched = True
+                                break
+                        except Exception:
+                            continue
+                    if switched:
+                        break
+
+                selected = False
+                for scope in scopes:
+                    for selector in [
+                        "div[class*='cover'] img",
+                        "div[class*='cover']",
+                        "div[class*='frame'] img",
+                        "div[class*='frame']",
+                        "div[class*='preset']",
+                        "img",
+                    ]:
+                        try:
+                            candidate = await self._first_visible_locator(scope.locator(selector))
+                            if candidate:
+                                await candidate.click()
+                                logger.info("[抖音] 已选择封面帧")
+                                selected = True
+                                break
+                        except Exception:
+                            continue
+                    if selected:
+                        break
+
+                confirm_selectors = [
+                    "button:has-text('完成')",
+                    "button:has-text('确定')",
+                    "button:has-text('保存')",
+                    "button:has-text('确认')",
+                ]
+                for selector in confirm_selectors:
+                    try:
+                        button = await self._first_visible_locator(page.locator(selector))
+                        if button:
+                            if not await button.is_enabled():
+                                for _ in range(8):
+                                    if await button.is_enabled():
+                                        break
+                                    await asyncio.sleep(0.5)
+                            await button.click()
+                            logger.info(f"[抖音] 封面已确认: {selector}")
+                            await asyncio.sleep(0.5)
+                            if await dialog.count() > 0:
+                                try:
+                                    await dialog.wait_for(state="hidden", timeout=5000)
+                                except Exception:
+                                    pass
+                            return True
+                    except Exception:
+                        continue
+
+                return selected
+        except Exception as e:
+            logger.warning(f"[抖音] 选择封面失败: {e}")
+        return False
+
+    async def _click_publish_confirm_modal(self, page):
+        confirm_selectors = [
+            "button:has-text('确认发布')",
+            "button:has-text('继续发布')",
+            "button:has-text('确定发布')",
+            "button:has-text('发布确认')",
+        ]
+        for selector in confirm_selectors:
+            try:
+                button = page.locator(selector).first
+                if await button.is_visible():
+                    await button.click()
+                    logger.info(f"[抖音] 点击了发布确认按钮: {selector}")
+                    await asyncio.sleep(1)
+                    return True
+            except Exception:
+                continue
+        return False
+
+    async def _dismiss_blocking_modal(self, page) -> bool:
+        modal_locator = page.locator(
+            "div.dy-creator-content-modal-wrap, div[role='dialog'], "
+            "div[class*='modal'], div[class*='dialog']"
+        )
+        try:
+            count = await modal_locator.count()
+        except Exception:
+            return False
+
+        if count == 0:
+            return False
+
+        button_texts = [
+            "我知道了",
+            "知道了",
+            "确定",
+            "继续",
+            "继续发布",
+            "确认",
+            "同意并继续",
+            "完成",
+            "好的",
+            "明白了",
+        ]
+        close_selectors = [
+            "button[class*='close']",
+            "span[class*='close']",
+            "i[class*='close']",
+        ]
+
+        for index in range(count):
+            modal = modal_locator.nth(index)
+            try:
+                if not await modal.is_visible():
+                    continue
+
+                for text in button_texts:
+                    try:
+                        button = modal.get_by_role("button", name=text).first
+                        if await button.is_visible():
+                            await button.click()
+                            logger.info(f"[抖音] 关闭弹窗: {text}")
+                            await asyncio.sleep(0.5)
+                            return True
+                    except Exception:
+                        continue
+
+                for selector in close_selectors:
+                    try:
+                        close_button = modal.locator(selector).first
+                        if await close_button.is_visible():
+                            await close_button.click()
+                            logger.info("[抖音] 关闭弹窗: close")
+                            await asyncio.sleep(0.5)
+                            return True
+                    except Exception:
+                        continue
+            except Exception:
+                continue
+
+        return False
+
+    async def _verify_publish_in_manage(self, page):
+        manage_url = "https://creator.douyin.com/creator-micro/content/manage"
+        try:
+            await page.goto(manage_url)
+            await page.wait_for_load_state("domcontentloaded")
+            await asyncio.sleep(2)
+            title_text = self.title[:30]
+            title_locator = page.get_by_text(title_text, exact=False).first
+            if await title_locator.is_visible():
+                return True, "内容管理中检测到新作品"
+            if await self._is_text_visible(page, "审核中", exact=False):
+                return True, "内容管理显示审核中"
+        except Exception as e:
+            return False, f"无法验证内容管理: {e}"
+        return False, "内容管理中未找到视频"
+    
+    async def set_schedule_time(self, page, publish_date):
+        """Set scheduled publish time"""
+        try:
+            # Click "定时发布" radio button
+            label_element = page.locator("[class^='radio']:has-text('定时发布')")
+            await label_element.click()
+            await asyncio.sleep(1)
+            
+            # Format time
+            publish_date_hour = publish_date.strftime("%Y-%m-%d %H:%M")
+            
+            # Fill datetime input
+            await page.locator('.semi-input[placeholder="日期和时间"]').click()
+            await page.keyboard.press("Control+KeyA")
+            await page.keyboard.type(str(publish_date_hour))
+            await page.keyboard.press("Enter")
+            
+            await asyncio.sleep(1)
+            logger.info(f"[抖音] 已设置定时发布: {publish_date_hour}")
+            
+        except Exception as e:
+            logger.error(f"[抖音] 设置定时发布失败: {e}")
+    
+    async def upload(self, playwright: Playwright) -> dict:
+        """Main upload logic with guaranteed resource cleanup"""
+        browser = None
+        context = None
+        try:
+            # Launch browser in headless mode for server deployment
+            browser = await playwright.chromium.launch(headless=True)
+            context = await browser.new_context(storage_state=self.account_file)
+            context = await set_init_script(context)
+            
+            page = await context.new_page()
+            
+            # Go to upload page
+            await page.goto(self.upload_url)
+            await page.wait_for_load_state('domcontentloaded')
+            await asyncio.sleep(2)
+            
+            logger.info(f"[抖音] 正在上传: {self.file_path.name}")
+            
+            # Check if redirected to login page (more reliable than text detection)
+            current_url = page.url
+            if "login" in current_url or "passport" in current_url:
+                logger.error("[抖音] Cookie 已失效，被重定向到登录页")
+                return {
+                    "success": False,
+                    "message": "Cookie 已失效，请重新登录",
+                    "url": None
+                }
+            
+            # Ensure we're on the upload page
+            if "content/upload" not in page.url:
+                logger.info("[抖音] 当前不在上传页面，强制跳转...")
+                await page.goto(self.upload_url)
+                await asyncio.sleep(2)
+            
+            # Try multiple selectors for the file input (page structure varies)
+            file_uploaded = False
+            selectors = [
+                "div[class^='container'] input",  # Primary selector from SuperIPAgent
+                "input[type='file']",  # Fallback selector
+                "div[class^='upload'] input[type='file']",  # Alternative
+            ]
+            
+            for selector in selectors:
+                try:
+                    logger.info(f"[抖音] 尝试选择器: {selector}")
+                    locator = page.locator(selector).first
+                    if await locator.count() > 0:
+                        await locator.set_input_files(str(self.file_path))
+                        file_uploaded = True
+                        logger.info(f"[抖音] 文件上传成功使用选择器: {selector}")
+                        break
+                except Exception as e:
+                    logger.warning(f"[抖音] 选择器 {selector} 失败: {e}")
+                    continue
+            
+            if not file_uploaded:
+                logger.error("[抖音] 所有选择器都失败，无法上传文件")
+                return {
+                    "success": False,
+                    "message": "无法找到上传按钮，页面可能已更新",
+                    "url": None
+                }
+            
+            # Wait for redirect to publish page (with timeout)
+            redirect_start = time.time()
+            while time.time() - redirect_start < self.PAGE_REDIRECT_TIMEOUT:
+                current_url = page.url
+                if "content/publish" in current_url or "content/post/video" in current_url:
+                    logger.info("[抖音] 成功进入发布页面")
+                    break
+                await asyncio.sleep(0.5)
+            else:
+                logger.error("[抖音] 等待发布页面超时")
+                return {
+                    "success": False,
+                    "message": "等待发布页面超时",
+                    "url": None
+                }
+            
+            # Fill title
+            await asyncio.sleep(1)
+            logger.info("[抖音] 正在填充标题和话题...")
+
+            if not await self._fill_title(page, self.title):
+                logger.warning("[抖音] 未找到作品描述输入框")
+            
+            # Add tags
+            css_selector = ".zone-container"
+            for tag in self.tags:
+                await page.type(css_selector, "#" + tag)
+                await page.press(css_selector, "Space")
+            
+            logger.info(f"[抖音] 总共添加 {len(self.tags)} 个话题")
+
+            cover_selected = await self._select_cover_if_needed(page)
+            if not cover_selected:
+                logger.warning("[抖音] 未确认封面选择，可能影响发布")
+            
+            # Wait for upload to complete (with timeout)
+            upload_start = time.time()
+            while time.time() - upload_start < self.UPLOAD_TIMEOUT:
+                try:
+                    number = await page.locator('[class^="long-card"] div:has-text("重新上传")').count()
+                    if number > 0:
+                        logger.success("[抖音] 视频上传完毕")
+                        break
+                    else:
+                        logger.info("[抖音] 正在上传视频中...")
+                        await asyncio.sleep(self.POLL_INTERVAL)
+                except Exception:
+                    await asyncio.sleep(self.POLL_INTERVAL)
+            else:
+                logger.error("[抖音] 视频上传超时")
+                return {
+                    "success": False,
+                    "message": "视频上传超时",
+                    "url": None
+                }
+            
+            # Set scheduled publish time if needed
+            if self.publish_date != 0:
+                await self.set_schedule_time(page, self.publish_date)
+            
+            # Click publish button
+            # 使用更稳健的点击逻辑
+            try:
+                publish_label = "定时发布" if self.publish_date != 0 else "发布"
+                publish_button = page.get_by_role('button', name=publish_label, exact=True)
+                # 等待按钮出现
+                await publish_button.wait_for(state="visible", timeout=10000)
+                if not await publish_button.is_enabled():
+                    logger.error("[抖音] 发布按钮不可点击，可能需要补充封面或确认信息")
+                    return {
+                        "success": False,
+                        "message": "发布按钮不可点击，请检查封面/声明等必填项",
+                        "url": None
+                    }
+                await asyncio.sleep(1) # 额外等待以确保可交互
+
+                clicked = False
+                for attempt in range(self.MAX_CLICK_RETRIES):
+                    await self._dismiss_blocking_modal(page)
+                    try:
+                        await publish_button.click(timeout=5000)
+                        logger.info(f"[抖音] 点击了{publish_label}按钮")
+                        clicked = True
+                        break
+                    except Exception as click_error:
+                        logger.warning(f"[抖音] 点击发布按钮失败，重试 {attempt + 1}/{self.MAX_CLICK_RETRIES}: {click_error}")
+                        try:
+                            await page.keyboard.press("Escape")
+                        except Exception:
+                            pass
+                        await asyncio.sleep(1)
+
+                if not clicked:
+                    raise RuntimeError("点击发布按钮失败")
+            except Exception as e:
+                logger.error(f"[抖音] 点击发布按钮失败: {e}")
+                # 尝试备用选择器
+                try:
+                    fallback_selectors = ["button:has-text('发布')", "button:has-text('定时发布')"]
+                    clicked = False
+                    for selector in fallback_selectors:
+                        try:
+                            await page.click(selector, timeout=5000)
+                            logger.info(f"[抖音] 使用备用选择器点击了按钮: {selector}")
+                            clicked = True
+                            break
+                        except Exception:
+                            continue
+
+                    if not clicked:
+                        return {
+                            "success": False,
+                            "message": "无法点击发布按钮，请检查页面状态",
+                            "url": None
+                        }
+                except Exception:
+                    return {
+                        "success": False,
+                        "message": "无法点击发布按钮，请检查页面状态",
+                        "url": None
+                    }
+
+            await self._click_publish_confirm_modal(page)
+
+            # 4. 检测发布完成
+            publish_success, publish_reason, is_timeout = await self._wait_for_publish_result(page)
+            if not publish_success and is_timeout:
+                verify_success, verify_reason = await self._verify_publish_in_manage(page)
+                if verify_success:
+                    publish_success = True
+                    publish_reason = verify_reason
+                else:
+                    publish_reason = f"{publish_reason}; {verify_reason}"
+            if publish_success:
+                logger.success(f"[抖音] 发布成功: {publish_reason}")
+            else:
+                if is_timeout:
+                    logger.warning("[抖音] 发布检测超时，但这不一定代表失败")
+                else:
+                    logger.warning(f"[抖音] 发布未成功: {publish_reason}")
+            
+            # Save updated cookies
+            await context.storage_state(path=self.account_file)
+            logger.success("[抖音] Cookie 更新完毕")
+            
+            await asyncio.sleep(2)
+            
+            if publish_success:
+                return {
+                    "success": True,
+                    "message": "发布成功",
+                    "url": None
+                }
+            if is_timeout:
+                return {
+                    "success": True,
+                    "message": "发布检测超时，请到抖音后台确认",
+                    "url": None
+                }
+            return {
+                "success": False,
+                "message": f"发布失败: {publish_reason}",
+                "url": None
+            }
+            
+        except Exception as e:
+            logger.exception(f"[抖音] 上传失败: {e}")
+            return {
+                "success": False,
+                "message": f"上传失败: {str(e)}",
+                "url": None
+            }
+        finally:
+            # 确保资源释放
+            if context:
+                try:
+                    await context.close()
+                except Exception:
+                    pass
+            if browser:
+                try:
+                    await browser.close()
+                except Exception:
+                    pass
+    
+    async def main(self) -> Dict[str, Any]:
+        """Execute upload"""
+        async with async_playwright() as playwright:
+            return await self.upload(playwright)

backend/app/services/uploader/xiaohongshu_uploader.py

@@ -4,7 +4,7 @@ Based on social-auto-upload implementation
 """
 from datetime import datetime
 from pathlib import Path
-from typing import Optional, List
+from typing import Optional, List, Dict, Any
 import asyncio
 
 from playwright.async_api import Playwright, async_playwright
@@ -17,6 +17,11 @@ from .cookie_utils import set_init_script
 class XiaohongshuUploader(BaseUploader):
     """Xiaohongshu video uploader using Playwright"""
     
+    # 超时配置 (秒)
+    UPLOAD_TIMEOUT = 300  # 视频上传超时
+    PUBLISH_TIMEOUT = 120  # 发布检测超时
+    POLL_INTERVAL = 1  # 轮询间隔
+    
     def __init__(
         self,
         title: str,
@@ -54,11 +59,13 @@ class XiaohongshuUploader(BaseUploader):
         except Exception as e:
             logger.error(f"[小红书] 设置定时发布失败: {e}")
     
-    async def upload(self, playwright: Playwright):
-        """Main upload logic"""
+    async def upload(self, playwright: Playwright) -> dict:
+        """Main upload logic with guaranteed resource cleanup"""
+        browser = None
+        context = None
         try:
-            # Launch browser
-            browser = await playwright.chromium.launch(headless=False)
+            # Launch browser (headless for server deployment)
+            browser = await playwright.chromium.launch(headless=True)
             context = await browser.new_context(
                 viewport={"width": 1600, "height": 900},
                 storage_state=self.account_file
@@ -74,8 +81,10 @@ class XiaohongshuUploader(BaseUploader):
             # Upload video file
             await page.locator("div[class^='upload-content'] input[class='upload-input']").set_input_files(str(self.file_path))
             
-            # Wait for upload to complete
-            while True:
+            # Wait for upload to complete (with timeout)
+            import time
+            upload_start = time.time()
+            while time.time() - upload_start < self.UPLOAD_TIMEOUT:
                 try:
                     upload_input = await page.wait_for_selector('input.upload-input', timeout=3000)
                     preview_new = await upload_input.query_selector(
@@ -100,11 +109,18 @@ class XiaohongshuUploader(BaseUploader):
                     else:
                         logger.info("[小红书] 未找到预览元素，继续等待...")
                     
-                    await asyncio.sleep(1)
+                    await asyncio.sleep(self.POLL_INTERVAL)
                     
                 except Exception as e:
                     logger.info(f"[小红书] 检测过程: {str(e)}，重新尝试...")
                     await asyncio.sleep(0.5)
+            else:
+                logger.error("[小红书] 视频上传超时")
+                return {
+                    "success": False,
+                    "message": "视频上传超时",
+                    "url": None
+                }
             
             # Fill title and tags
             await asyncio.sleep(1)
@@ -126,8 +142,9 @@ class XiaohongshuUploader(BaseUploader):
             if self.publish_date != 0:
                 await self.set_schedule_time(page, self.publish_date)
             
-            # Click publish button
-            while True:
+            # Click publish button (with timeout)
+            publish_start = time.time()
+            while time.time() - publish_start < self.PUBLISH_TIMEOUT:
                 try:
                     if self.publish_date != 0:
                         await page.locator('button:has-text("定时发布")').click()
@@ -140,17 +157,17 @@ class XiaohongshuUploader(BaseUploader):
                     )
                     logger.success("[小红书] 视频发布成功")
                     break
-                except:
+                except Exception:
                     logger.info("[小红书] 视频正在发布中...")
                     await asyncio.sleep(0.5)
+            else:
+                logger.warning("[小红书] 发布检测超时，请手动确认")
             
             # Save updated cookies
             await context.storage_state(path=self.account_file)
             logger.success("[小红书] Cookie 更新完毕")
             
             await asyncio.sleep(2)
-            await context.close()
-            await browser.close()
             
             return {
                 "success": True,
@@ -165,8 +182,20 @@ class XiaohongshuUploader(BaseUploader):
                 "message": f"上传失败: {str(e)}",
                 "url": None
             }
+        finally:
+            # 确保资源释放
+            if context:
+                try:
+                    await context.close()
+                except Exception:
+                    pass
+            if browser:
+                try:
+                    await browser.close()
+                except Exception:
+                    pass
     
-    async def main(self):
+    async def main(self) -> Dict[str, Any]:
         """Execute upload"""
         async with async_playwright() as playwright:
             return await self.upload(playwright)

frontend/package-lock.json

@@ -10,7 +10,8 @@
       "dependencies": {
         "next": "16.1.1",
         "react": "19.2.3",
-        "react-dom": "19.2.3"
+        "react-dom": "19.2.3",
+        "swr": "^2.3.8"
       },
       "devDependencies": {
         "@tailwindcss/postcss": "^4",
@@ -2759,6 +2760,15 @@
         "url": "https://github.com/sponsors/ljharb"
       }
     },
+    "node_modules/dequal": {
+      "version": "2.0.3",
+      "resolved": "https://registry.npmjs.org/dequal/-/dequal-2.0.3.tgz",
+      "integrity": "sha512-0je+qPKHEMohvfRTCEo3CrPG6cAzAYgmzKyxRiYSSDkS6eGJdyVJm7WaYA5ECaAD9wLB2T4EEeymA5aFVcYXCA==",
+      "license": "MIT",
+      "engines": {
+        "node": ">=6"
+      }
+    },
     "node_modules/detect-libc": {
       "version": "2.1.2",
       "resolved": "https://registry.npmjs.org/detect-libc/-/detect-libc-2.1.2.tgz",
@@ -6027,6 +6037,19 @@
         "url": "https://github.com/sponsors/ljharb"
       }
     },
+    "node_modules/swr": {
+      "version": "2.3.8",
+      "resolved": "https://registry.npmjs.org/swr/-/swr-2.3.8.tgz",
+      "integrity": "sha512-gaCPRVoMq8WGDcWj9p4YWzCMPHzE0WNl6W8ADIx9c3JBEIdMkJGMzW+uzXvxHMltwcYACr9jP+32H8/hgwMR7w==",
+      "license": "MIT",
+      "dependencies": {
+        "dequal": "^2.0.3",
+        "use-sync-external-store": "^1.6.0"
+      },
+      "peerDependencies": {
+        "react": "^16.11.0 || ^17.0.0 || ^18.0.0 || ^19.0.0"
+      }
+    },
     "node_modules/tailwindcss": {
       "version": "4.1.18",
       "resolved": "https://registry.npmjs.org/tailwindcss/-/tailwindcss-4.1.18.tgz",
@@ -6387,6 +6410,15 @@
         "punycode": "^2.1.0"
       }
     },
+    "node_modules/use-sync-external-store": {
+      "version": "1.6.0",
+      "resolved": "https://registry.npmjs.org/use-sync-external-store/-/use-sync-external-store-1.6.0.tgz",
+      "integrity": "sha512-Pp6GSwGP/NrPIrxVFAIkOQeyw8lFenOHijQWkUTrDvrF4ALqylP2C/KCkeS9dpUM3KvYRQhna5vt7IL95+ZQ9w==",
+      "license": "MIT",
+      "peerDependencies": {
+        "react": "^16.8.0 || ^17.0.0 || ^18.0.0 || ^19.0.0"
+      }
+    },
     "node_modules/which": {
       "version": "2.0.2",
       "resolved": "https://registry.npmjs.org/which/-/which-2.0.2.tgz",

frontend/package.json

@@ -11,7 +11,8 @@
   "dependencies": {
     "next": "16.1.1",
     "react": "19.2.3",
-    "react-dom": "19.2.3"
+    "react-dom": "19.2.3",
+    "swr": "^2.3.8"
   },
   "devDependencies": {
     "@tailwindcss/postcss": "^4",
@@ -23,4 +24,4 @@
     "tailwindcss": "^4",
     "typescript": "^5"
   }
-}
+}

frontend/src/app/publish/page.tsx

@@ -1,6 +1,9 @@
 "use client";
 
 import { useState, useEffect } from "react";
+import useSWR from 'swr';
+
+const fetcher = (url: string) => fetch(url).then((res) => res.json());
 import Link from "next/link";
 
 // 动态获取 API 地址：服务端使用 localhost，客户端使用当前域名
@@ -119,6 +122,38 @@ export default function PublishPage() {
         setIsPublishing(false);
     };
 
+    // SWR Polling for Login Status
+    const { data: loginStatus } = useSWR(
+        qrPlatform ? `${API_BASE}/api/publish/login/status/${qrPlatform}` : null,
+        fetcher,
+        {
+            refreshInterval: 2000,
+            onSuccess: (data) => {
+                if (data.success) {
+                    setQrCodeImage(null);
+                    setQrPlatform(null);
+                    alert('✅ 登录成功！');
+                    fetchAccounts();
+                }
+            }
+        }
+    );
+
+    // Timeout logic for QR code (business logic: stop after 2 mins)
+    useEffect(() => {
+        let timer: NodeJS.Timeout;
+        if (qrPlatform) {
+            timer = setTimeout(() => {
+                if (qrPlatform) { // Double check active
+                    setQrPlatform(null);
+                    setQrCodeImage(null);
+                    alert('登录超时，请重试');
+                }
+            }, 120000);
+        }
+        return () => clearTimeout(timer);
+    }, [qrPlatform]);
+
     const handleLogin = async (platform: string) => {
         try {
             const res = await fetch(`${API_BASE}/api/publish/login/${platform}`, {
@@ -127,32 +162,9 @@ export default function PublishPage() {
             const result = await res.json();
 
             if (result.success && result.qr_code) {
-                // 显示二维码
                 setQrCodeImage(result.qr_code);
                 setQrPlatform(platform);
-
-                // 轮询登录状态
-                const checkInterval = setInterval(async () => {
-                    const statusRes = await fetch(`${API_BASE}/api/publish/login/status/${platform}`);
-                    const statusData = await statusRes.json();
-
-                    if (statusData.success) {
-                        clearInterval(checkInterval);
-                        setQrCodeImage(null);
-                        setQrPlatform(null);
-                        alert('✅ 登录成功！');
-                        fetchAccounts(); // 刷新账号状态
-                    }
-                }, 2000); // 每2秒检查一次
-
-                // 2分钟后停止轮询
-                setTimeout(() => {
-                    clearInterval(checkInterval);
-                    if (qrCodeImage) {
-                        setQrCodeImage(null);
-                        alert('登录超时，请重试');
-                    }
-                }, 120000);
+                // SWR hook will automatically start polling since qrPlatform is set
             } else {
                 alert(result.message || '登录失败');
             }
@@ -161,6 +173,24 @@ export default function PublishPage() {
         }
     };
 
+    const handleLogout = async (platform: string) => {
+        if (!confirm('确定要注销登录吗？')) return;
+        try {
+            const res = await fetch(`${API_BASE}/api/publish/logout/${platform}`, {
+                method: 'POST'
+            });
+            const result = await res.json();
+            if (result.success) {
+                alert('已注销');
+                fetchAccounts();
+            } else {
+                alert(result.message || '注销失败');
+            }
+        } catch (error) {
+            alert(`注销失败: ${error}`);
+        }
+    };
+
     const platformIcons: Record<string, string> = {
         douyin: "🎵",
         xiaohongshu: "📕",
@@ -248,12 +278,31 @@ export default function PublishPage() {
                                                 </div>
                                             </div>
                                         </div>
-                                        <button
-                                            onClick={() => handleLogin(account.platform)}
-                                            className="px-3 py-1 bg-purple-600 hover:bg-purple-700 text-white text-sm rounded-lg transition-colors"
-                                        >
-                                            🔐 扫码登录
-                                        </button>
+                                        <div className="flex gap-2">
+                                            {account.logged_in ? (
+                                                <>
+                                                    <button
+                                                        onClick={() => handleLogin(account.platform)}
+                                                        className="px-3 py-1 bg-white/10 hover:bg-white/20 text-white text-sm rounded-lg transition-colors"
+                                                    >
+                                                        ↻ 重新登录
+                                                    </button>
+                                                    <button
+                                                        onClick={() => handleLogout(account.platform)}
+                                                        className="px-3 py-1 bg-red-500/80 hover:bg-red-600 text-white text-sm rounded-lg transition-colors"
+                                                    >
+                                                        注销
+                                                    </button>
+                                                </>
+                                            ) : (
+                                                <button
+                                                    onClick={() => handleLogin(account.platform)}
+                                                    className="px-3 py-1 bg-purple-600 hover:bg-purple-700 text-white text-sm rounded-lg transition-colors"
+                                                >
+                                                    🔐 扫码登录
+                                                </button>
+                                            )}
+                                        </div>
                                     </div>
                                 ))}
                             </div>