commit 73b274cce8dc218af6190a9ecfdb726ed4fd1b17
Author: zhinianboke <115088296+zhinianboke@users.noreply.github.com>
Date:   Thu Jul 24 12:05:21 2025 +0800

    首次提交

diff --git a/.dockerignore b/.dockerignore
new file mode 100644
index 0000000..3d2a2f0
--- /dev/null
+++ b/.dockerignore
@@ -0,0 +1,91 @@
+# 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
+
+# 虚拟环境
+venv/
+env/
+ENV/
+env.bak/
+venv.bak/
+
+# IDE相关
+.vscode/
+.idea/
+*.swp
+*.swo
+*~
+
+# 操作系统相关
+.DS_Store
+.DS_Store?
+._*
+.Spotlight-V100
+.Trashes
+ehthumbs.db
+Thumbs.db
+
+# 日志文件
+logs/*.log
+*.log
+
+# 数据库文件（构建时不包含，运行时挂载）
+*.db
+*.sqlite
+*.sqlite3
+
+# 临时文件
+*.tmp
+*.temp
+temp/
+tmp/
+
+# 测试文件
+test_*.py
+*_test.py
+tests/
+
+# 文档
+*.md
+docs/
+
+# Docker相关
+Dockerfile*
+docker-compose*.yml
+.dockerignore
+
+# 配置文件（运行时挂载）
+# global_config.yml
+
+# 其他
+.env
+.env.local
+.env.*.local
+node_modules/
+npm-debug.log*
+yarn-debug.log*
+yarn-error.log*
diff --git a/.env b/.env
new file mode 100644
index 0000000..de78e8a
--- /dev/null
+++ b/.env
@@ -0,0 +1,103 @@
+# 闲鱼自动回复系统 Docker 环境变量配置文件
+# 这是默认配置，您可以根据需要修改
+
+# ================================
+# 基础配置
+# ================================
+
+# 时区设置
+TZ=Asia/Shanghai
+
+# Python配置
+PYTHONUNBUFFERED=1
+PYTHONDONTWRITEBYTECODE=1
+
+# 日志级别 (DEBUG, INFO, WARNING, ERROR)
+LOG_LEVEL=INFO
+
+# ================================
+# 数据库配置
+# ================================
+
+# 数据库文件路径
+DB_PATH=/app/data/xianyu_data.db
+
+# ================================
+# 服务配置
+# ================================
+
+# API服务配置
+API_HOST=0.0.0.0  # 绑定所有网络接口，支持IP访问
+API_PORT=8080     # Web服务端口
+
+# Web服务端口 (Docker端口映射)
+WEB_PORT=8080
+
+# ================================
+# 安全配置
+# ================================
+
+# 管理员账号密码 (建议修改)
+ADMIN_USERNAME=admin
+ADMIN_PASSWORD=admin123
+
+# JWT密钥 (建议修改为随机字符串)
+JWT_SECRET_KEY=xianyu-auto-reply-secret-key-2024
+
+# Session超时时间 (秒)
+SESSION_TIMEOUT=3600
+
+# ================================
+# 闲鱼API配置
+# ================================
+
+# WebSocket连接URL
+WEBSOCKET_URL=wss://wss-goofish.dingtalk.com/
+
+# 心跳间隔 (秒)
+HEARTBEAT_INTERVAL=15
+
+# 心跳超时 (秒)
+HEARTBEAT_TIMEOUT=5
+
+# Token刷新间隔 (秒)
+TOKEN_REFRESH_INTERVAL=3600
+
+# Token重试间隔 (秒)
+TOKEN_RETRY_INTERVAL=300
+
+# 消息过期时间 (毫秒)
+MESSAGE_EXPIRE_TIME=300000
+
+# ================================
+# 自动回复配置
+# ================================
+
+# 是否启用自动回复
+AUTO_REPLY_ENABLED=true
+
+# ================================
+# 资源限制
+# ================================
+
+# 内存限制 (MB)
+MEMORY_LIMIT=512
+
+# CPU限制 (核心数)
+CPU_LIMIT=0.5
+
+# 内存预留 (MB)
+MEMORY_RESERVATION=256
+
+# CPU预留 (核心数)
+CPU_RESERVATION=0.25
+
+# ================================
+# 开发配置
+# ================================
+
+# 开发模式 (true/false)
+DEBUG=false
+
+# 热重载 (true/false)
+RELOAD=false
diff --git a/.env.example b/.env.example
new file mode 100644
index 0000000..cbf2af2
--- /dev/null
+++ b/.env.example
@@ -0,0 +1,192 @@
+# 闲鱼自动回复系统 Docker 环境变量配置文件
+# 复制此文件为 .env 并根据需要修改配置
+# 或者直接重命名为 .env 使用默认配置
+
+# ================================
+# 基础配置
+# ================================
+
+# 时区设置
+TZ=Asia/Shanghai
+
+# Python配置
+PYTHONUNBUFFERED=1
+PYTHONDONTWRITEBYTECODE=1
+
+# 日志级别 (DEBUG, INFO, WARNING, ERROR)
+LOG_LEVEL=INFO
+
+# ================================
+# 数据库配置
+# ================================
+
+# 数据库文件路径
+DB_PATH=/app/data/xianyu_data.db
+
+# ================================
+# 服务配置
+# ================================
+
+# Web服务端口
+WEB_PORT=8080
+
+# API服务配置
+API_HOST=0.0.0.0
+API_PORT=8080
+
+# ================================
+# 安全配置
+# ================================
+
+# 管理员账号密码 (建议修改)
+ADMIN_USERNAME=admin
+ADMIN_PASSWORD=admin123
+
+# JWT密钥 (建议修改为随机字符串)
+JWT_SECRET_KEY=your-secret-key-here
+
+# Session超时时间 (秒)
+SESSION_TIMEOUT=3600
+
+# ================================
+# 闲鱼API配置
+# ================================
+
+# WebSocket连接URL
+WEBSOCKET_URL=wss://wss-goofish.dingtalk.com/
+
+# 心跳间隔 (秒)
+HEARTBEAT_INTERVAL=15
+
+# 心跳超时 (秒)
+HEARTBEAT_TIMEOUT=5
+
+# Token刷新间隔 (秒)
+TOKEN_REFRESH_INTERVAL=3600
+
+# Token重试间隔 (秒)
+TOKEN_RETRY_INTERVAL=300
+
+# 消息过期时间 (毫秒)
+MESSAGE_EXPIRE_TIME=300000
+
+# ================================
+# 自动回复配置
+# ================================
+
+# 是否启用自动回复
+AUTO_REPLY_ENABLED=true
+
+# 默认回复消息
+AUTO_REPLY_DEFAULT_MESSAGE=亲爱的"{send_user_name}" 老板你好！所有宝贝都可以拍，秒发货的哈~不满意的话可以直接申请退款哈~
+
+# 最大重试次数
+AUTO_REPLY_MAX_RETRY=3
+
+# 重试间隔 (秒)
+AUTO_REPLY_RETRY_INTERVAL=5
+
+# ================================
+# 自动发货配置
+# ================================
+
+# 是否启用自动发货
+AUTO_DELIVERY_ENABLED=true
+
+# 自动发货超时时间 (秒)
+AUTO_DELIVERY_TIMEOUT=30
+
+# API卡券请求超时时间 (秒)
+API_CARD_TIMEOUT=10
+
+# 批量数据并发保护
+BATCH_DATA_LOCK_TIMEOUT=5
+
+# ================================
+# 代理配置 (可选)
+# ================================
+
+# HTTP代理
+# HTTP_PROXY=http://proxy.example.com:8080
+
+# HTTPS代理
+# HTTPS_PROXY=https://proxy.example.com:8080
+
+# 不使用代理的地址
+# NO_PROXY=localhost,127.0.0.1
+
+# ================================
+# 监控配置
+# ================================
+
+# 健康检查间隔 (秒)
+HEALTH_CHECK_INTERVAL=30
+
+# 健康检查超时 (秒)
+HEALTH_CHECK_TIMEOUT=10
+
+# ================================
+# 资源限制
+# ================================
+
+# 内存限制 (MB)
+MEMORY_LIMIT=512
+
+# CPU限制 (核心数)
+CPU_LIMIT=0.5
+
+# ================================
+# 备份配置
+# ================================
+
+# 自动备份间隔 (小时)
+BACKUP_INTERVAL=24
+
+# 备份保留天数
+BACKUP_RETENTION_DAYS=7
+
+# 备份目录
+BACKUP_DIR=/app/backups
+
+# ================================
+# 开发配置
+# ================================
+
+# 开发模式 (true/false)
+DEBUG=false
+
+# 热重载 (true/false)
+RELOAD=false
+
+# API文档 (true/false)
+ENABLE_DOCS=true
+
+# ================================
+# 第三方服务配置
+# ================================
+
+# 邮件通知配置 (可选)
+# SMTP_HOST=smtp.example.com
+# SMTP_PORT=587
+# SMTP_USERNAME=your-email@example.com
+# SMTP_PASSWORD=your-password
+# SMTP_FROM=noreply@example.com
+
+# 钉钉机器人通知 (可选)
+# DINGTALK_WEBHOOK=https://oapi.dingtalk.com/robot/send?access_token=your-token
+
+# 企业微信机器人通知 (可选)
+# WECHAT_WEBHOOK=https://qyapi.weixin.qq.com/cgi-bin/webhook/send?key=your-key
+
+# ================================
+# 自定义配置
+# ================================
+
+# 自定义配置文件路径
+# CUSTOM_CONFIG_PATH=/app/custom_config.yml
+
+# 插件目录
+# PLUGINS_DIR=/app/plugins
+
+# 模板目录
+# TEMPLATES_DIR=/app/templates
diff --git a/.gitignore b/.gitignore
new file mode 100644
index 0000000..e70e766
--- /dev/null
+++ b/.gitignore
@@ -0,0 +1,30 @@
+__pycache__
+*node_modules/*
+*.so
+.Python
+build/
+develop-eggs/
+dist/
+downloads/
+eggs/
+.eggs/
+lib/
+lib64/
+parts/
+sdist/
+var/
+wheels/
+MANIFEST
+*.manifest
+*.spec
+.cache
+*.log
+local_settings.py
+db.sqlite3
+__pypackages__/
+.venv
+
+venv/
+ENV/
+env.bak/
+venv.bak/
\ No newline at end of file
diff --git a/Dockerfile b/Dockerfile
new file mode 100644
index 0000000..3c630fc
--- /dev/null
+++ b/Dockerfile
@@ -0,0 +1,67 @@
+# 使用Python 3.11作为基础镜像
+FROM python:3.11-slim
+
+# 设置标签信息
+LABEL maintainer="Xianyu Auto Reply System"
+LABEL version="1.0.0"
+LABEL description="闲鱼自动回复系统 - Docker版本"
+
+# 设置工作目录
+WORKDIR /app
+
+# 设置环境变量
+ENV PYTHONUNBUFFERED=1
+ENV PYTHONDONTWRITEBYTECODE=1
+ENV TZ=Asia/Shanghai
+
+# 安装系统依赖
+RUN apt-get update && \
+    apt-get install -y --no-install-recommends \
+        nodejs \
+        npm \
+        tzdata \
+        curl \
+        && apt-get clean \
+        && rm -rf /var/lib/apt/lists/*
+
+# 设置时区
+RUN ln -snf /usr/share/zoneinfo/$TZ /etc/localtime && echo $TZ > /etc/timezone
+
+# 复制requirements.txt并安装Python依赖
+COPY requirements.txt .
+RUN pip install --no-cache-dir --upgrade pip && \
+    pip install --no-cache-dir -r requirements.txt
+
+# 复制项目文件
+COPY . .
+
+# 创建必要的目录并设置权限
+RUN mkdir -p /app/logs /app/data /app/backups && \
+    chmod 777 /app/logs /app/data /app/backups
+
+# 注意: 为了简化权限问题，使用root用户运行
+# 在生产环境中，建议配置适当的用户映射
+
+# 暴露端口
+EXPOSE 8080
+
+# 健康检查
+HEALTHCHECK --interval=30s --timeout=10s --start-period=5s --retries=3 \
+    CMD curl -f http://localhost:8080/health || exit 1
+
+# 创建启动脚本
+RUN echo '#!/bin/bash' > /app/entrypoint.sh && \
+    echo 'set -e' >> /app/entrypoint.sh && \
+    echo '' >> /app/entrypoint.sh && \
+    echo 'echo "🚀 启动闲鱼自动回复系统..."' >> /app/entrypoint.sh && \
+    echo '' >> /app/entrypoint.sh && \
+    echo '# 数据库将在应用启动时自动初始化' >> /app/entrypoint.sh && \
+    echo 'echo "📊 数据库将在应用启动时自动初始化..."' >> /app/entrypoint.sh && \
+    echo '' >> /app/entrypoint.sh && \
+    echo '# 启动主应用' >> /app/entrypoint.sh && \
+    echo 'echo "🎯 启动主应用..."' >> /app/entrypoint.sh && \
+    echo 'exec python Start.py' >> /app/entrypoint.sh && \
+    chmod +x /app/entrypoint.sh
+
+# 启动命令
+CMD ["/app/entrypoint.sh"]
\ No newline at end of file
diff --git a/Docker部署说明.md b/Docker部署说明.md
new file mode 100644
index 0000000..a5754db
--- /dev/null
+++ b/Docker部署说明.md
@@ -0,0 +1,344 @@
+# 🐳 Docker 部署说明
+
+## 📋 部署概述
+
+本项目支持完整的Docker容器化部署，包含所有必要的依赖和配置。支持单容器部署和多容器编排部署。
+
+## 🚀 快速开始
+
+### 方式一：使用 Docker Compose（推荐）
+
+1. **克隆项目**
+   ```bash
+   git clone <repository-url>
+   cd xianyuapis
+   ```
+
+2. **配置环境变量**
+   ```bash
+   # 复制环境变量模板
+   cp .env.example .env
+   
+   # 编辑配置文件（可选）
+   nano .env
+   ```
+
+3. **启动服务**
+   ```bash
+   # 启动基础服务
+   docker-compose up -d
+   
+   # 或者启动包含Nginx的完整服务
+   docker-compose --profile with-nginx up -d
+   ```
+
+4. **访问系统**
+   - 基础部署：http://localhost:8080
+   - 带Nginx：http://localhost
+
+### 方式二：使用 Docker 命令
+
+1. **构建镜像**
+   ```bash
+   docker build -t xianyu-auto-reply:latest .
+   ```
+
+2. **运行容器**
+   ```bash
+   docker run -d \
+     --name xianyu-auto-reply \
+     -p 8080:8080 \
+     -v $(pwd)/data:/app/data \
+     -v $(pwd)/logs:/app/logs \
+     -v $(pwd)/global_config.yml:/app/global_config.yml:ro \
+     -e ADMIN_USERNAME=admin \
+     -e ADMIN_PASSWORD=admin123 \
+     xianyu-auto-reply:latest
+   ```
+
+## 📦 依赖说明
+
+### 新增依赖
+- `python-multipart>=0.0.6` - 文件上传支持（商品管理功能需要）
+
+### 完整依赖列表
+```
+# Web框架和API相关
+fastapi>=0.111
+uvicorn[standard]>=0.29
+pydantic>=2.7
+python-multipart>=0.0.6
+
+# 日志记录
+loguru>=0.7
+
+# 网络通信
+websockets>=10.0,<13.0
+aiohttp>=3.9
+
+# 配置文件处理
+PyYAML>=6.0
+
+# JavaScript执行引擎
+PyExecJS>=1.5.1
+
+# 协议缓冲区解析
+blackboxprotobuf>=1.0.1
+
+# 系统监控
+psutil>=5.9.0
+
+# HTTP客户端（用于测试）
+requests>=2.31.0
+```
+
+## 🔧 配置说明
+
+### 环境变量配置
+
+#### 基础配置
+```bash
+# 时区设置
+TZ=Asia/Shanghai
+
+# 服务端口
+WEB_PORT=8080
+
+# 管理员账号（建议修改）
+ADMIN_USERNAME=admin
+ADMIN_PASSWORD=admin123
+
+# JWT密钥（建议修改）
+JWT_SECRET_KEY=your-secret-key-here
+```
+
+#### 功能配置
+```bash
+# 自动回复
+AUTO_REPLY_ENABLED=true
+
+# 自动发货
+AUTO_DELIVERY_ENABLED=true
+AUTO_DELIVERY_TIMEOUT=30
+
+# 商品管理（新功能）
+ENABLE_ITEM_MANAGEMENT=true
+```
+
+### 数据持久化
+
+#### 重要目录
+- `/app/data` - 数据库文件
+- `/app/logs` - 日志文件
+- `/app/backups` - 备份文件
+
+#### 挂载配置
+```yaml
+volumes:
+  - ./data:/app/data:rw          # 数据库持久化
+  - ./logs:/app/logs:rw          # 日志持久化
+  - ./backups:/app/backups:rw    # 备份持久化
+  - ./global_config.yml:/app/global_config.yml:ro  # 配置文件
+```
+
+## 🏗️ 架构说明
+
+### 容器架构
+```
+┌─────────────────────────────────────┐
+│           Nginx (可选)              │
+│         反向代理 + SSL              │
+└─────────────┬───────────────────────┘
+              │
+┌─────────────▼───────────────────────┐
+│        Xianyu App Container         │
+│  ┌─────────────────────────────────┐ │
+│  │        FastAPI Server          │ │
+│  │         (Port 8080)            │ │
+│  └─────────────────────────────────┘ │
+│  ┌─────────────────────────────────┐ │
+│  │      XianyuAutoAsync           │ │
+│  │     (WebSocket Client)         │ │
+│  └─────────────────────────────────┘ │
+│  ┌─────────────────────────────────┐ │
+│  │       SQLite Database          │ │
+│  │      (商品信息 + 配置)          │ │
+│  └─────────────────────────────────┘ │
+└─────────────────────────────────────┘
+```
+
+### 新功能支持
+- ✅ 商品信息管理
+- ✅ 商品详情编辑
+- ✅ 文件上传功能
+- ✅ 消息通知格式化
+
+## 🔍 健康检查
+
+### 内置健康检查
+```bash
+# 检查容器状态
+docker ps
+
+# 查看健康状态
+docker inspect xianyu-auto-reply | grep Health -A 10
+
+# 手动健康检查
+curl -f http://localhost:8080/health
+```
+
+### 健康检查端点
+- `GET /health` - 基础健康检查
+- `GET /api/status` - 详细状态信息
+
+## 📊 监控和日志
+
+### 日志查看
+```bash
+# 查看容器日志
+docker logs xianyu-auto-reply
+
+# 实时查看日志
+docker logs -f xianyu-auto-reply
+
+# 查看应用日志文件
+docker exec xianyu-auto-reply tail -f /app/logs/xianyu_$(date +%Y%m%d).log
+```
+
+### 性能监控
+```bash
+# 查看资源使用
+docker stats xianyu-auto-reply
+
+# 进入容器
+docker exec -it xianyu-auto-reply bash
+
+# 查看进程状态
+docker exec xianyu-auto-reply ps aux
+```
+
+## 🔒 安全配置
+
+### 生产环境建议
+1. **修改默认密码**
+   ```bash
+   ADMIN_USERNAME=your-admin
+   ADMIN_PASSWORD=your-strong-password
+   ```
+
+2. **使用强JWT密钥**
+   ```bash
+   JWT_SECRET_KEY=$(openssl rand -base64 32)
+   ```
+
+3. **启用HTTPS**
+   ```yaml
+   # 使用Nginx配置SSL
+   docker-compose --profile with-nginx up -d
+   ```
+
+4. **限制网络访问**
+   ```yaml
+   # 仅允许本地访问
+   ports:
+     - "127.0.0.1:8080:8080"
+   ```
+
+## 🚨 故障排除
+
+### 常见问题
+
+1. **容器启动失败**
+   ```bash
+   # 查看详细错误
+   docker logs xianyu-auto-reply
+   
+   # 检查端口占用
+   netstat -tlnp | grep 8080
+   ```
+
+2. **数据库初始化失败**
+   ```bash
+   # 数据库会在应用启动时自动初始化
+   # 如果需要重新初始化，可以删除数据库文件后重启容器
+   docker exec xianyu-auto-reply rm -f /app/data/xianyu_data.db
+   docker restart xianyu-auto-reply
+   ```
+
+3. **权限问题**
+   ```bash
+   # 修复目录权限
+   sudo chown -R 1000:1000 ./data ./logs ./backups
+   ```
+
+4. **依赖安装失败**
+   ```bash
+   # 重新构建镜像
+   docker-compose build --no-cache
+   ```
+
+### 调试模式
+```bash
+# 启用调试模式
+docker-compose -f docker-compose.yml -f docker-compose.debug.yml up -d
+
+# 或设置环境变量
+docker run -e DEBUG=true -e LOG_LEVEL=DEBUG ...
+```
+
+## 🔄 更新部署
+
+### 更新步骤
+1. **停止服务**
+   ```bash
+   docker-compose down
+   ```
+
+2. **拉取最新代码**
+   ```bash
+   git pull origin main
+   ```
+
+3. **重新构建**
+   ```bash
+   docker-compose build --no-cache
+   ```
+
+4. **启动服务**
+   ```bash
+   docker-compose up -d
+   ```
+
+### 数据备份
+```bash
+# 备份数据库
+docker exec xianyu-auto-reply cp /app/data/xianyu_data.db /app/backups/
+
+# 备份配置
+cp .env .env.backup
+cp global_config.yml global_config.yml.backup
+```
+
+## 📈 性能优化
+
+### 资源限制
+```yaml
+deploy:
+  resources:
+    limits:
+      memory: 512M      # 内存限制
+      cpus: '0.5'       # CPU限制
+    reservations:
+      memory: 256M      # 内存预留
+      cpus: '0.25'      # CPU预留
+```
+
+### 优化建议
+1. **调整内存限制**：根据实际使用情况调整
+2. **使用SSD存储**：提高数据库性能
+3. **配置日志轮转**：避免日志文件过大
+4. **定期清理**：清理旧的备份文件
+
+---
+
+🎉 **Docker部署配置完善，支持所有新功能！**
diff --git a/LICENSE b/LICENSE
new file mode 100644
index 0000000..4501f64
--- /dev/null
+++ b/LICENSE
@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025 肥极喵
+
+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.
diff --git a/README.md b/README.md
new file mode 100644
index 0000000..ce4260f
--- /dev/null
+++ b/README.md
@@ -0,0 +1,173 @@
+# 🐟 XianYuAutoDeliveryX - 闲鱼虚拟商品商自动发货&聊天对接大模型
+
+[![Python Version](https://img.shields.io/badge/python-3.7%2B-blue)](https://www.python.org/)
+[![License](https://img.shields.io/badge/license-MIT-green)](LICENSE)
+
+**✨ 基于闲鱼API的自动发货系统，支持虚拟商品商品聊天窗口自动发货、消息自动回复等功能。**
+**⚠️ 注意：本项目仅供学习交流使用，请勿用于商业用途。**
+
+## 🌟 核心特性
+
+- 🔐 **用户认证系统** - 安全的登录认证，保护管理界面
+- 👥 **多账号管理** - 支持同时管理多个闲鱼账号
+- 🎯 **智能关键词回复** - 每个账号独立的关键词回复设置
+- 💾 **数据持久化** - SQLite数据库存储账号和关键词数据
+- 🌐 **美观Web界面** - 响应式设计，操作简单直观
+- 📡 **API接口** - 完整的RESTful API支持
+- 🔄 **实时消息处理** - 基于WebSocket的实时消息监控
+- 📊 **订单状态监控** - 实时跟踪订单状态变化
+- 📝 **完善的日志系统** - 详细的操作日志记录
+
+## 🛠️ 快速开始
+
+### ⛳ 运行环境
+- Python 3.7+
+
+### 🎯 安装依赖
+```bash
+pip install -r requirements.txt
+```
+
+### 🎨 配置说明
+1. 在 `global_config.yml` 中配置基本参数
+2. 系统支持多账号管理，可通过Web界面添加多个闲鱼账号Cookie
+
+### 🚀 运行项目
+```bash
+python Start.py
+```
+
+### 🔐 登录系统
+1. 启动后访问 `http://localhost:8080`
+2. 默认登录账号：
+   - 用户名：`admin`
+   - 密码：`admin123`
+3. 登录后可进入管理界面进行操作
+
+## 📁 项目结构
+```
+├── Start.py              # 项目启动入口
+├── XianyuAutoAsync.py    # 核心业务逻辑
+├── config.py             # 配置管理
+├── cookie_manager.py     # Cookie管理器
+├── db_manager.py         # 数据库管理
+├── reply_server.py       # FastAPI服务器
+├── utils/                # 工具函数目录
+│   ├── xianyu_utils.py   # 闲鱼相关工具
+│   ├── message_utils.py  # 消息处理工具
+│   └── ws_utils.py       # WebSocket工具
+├── static/               # 静态资源
+│   ├── index.html        # 管理界面
+│   └── login.html        # 登录页面
+├── logs/                 # 日志文件
+├── global_config.yml     # 全局配置文件
+├── xianyu_data.db        # SQLite数据库
+└── requirements.txt      # Python依赖
+```
+
+## 🎯 主要功能
+
+### 1. 用户认证系统
+- 安全的登录认证机制
+- Session token管理
+- 自动登录状态检查
+- 登出功能
+
+### 2. 多账号管理
+- 支持添加多个闲鱼账号
+- 每个账号独立管理
+- Cookie安全存储
+- 账号状态监控
+
+### 3. 智能关键词回复
+- 每个账号独立的关键词设置
+- 支持变量替换：`{send_user_name}`, `{send_user_id}`, `{send_message}`
+- 实时关键词匹配
+- 默认回复机制
+
+### 4. Web管理界面
+- 响应式设计，支持移动端
+- 直观的操作界面
+- 实时数据更新
+- 操作反馈提示
+
+## 🔌 API 接口说明
+
+### 智能回复接口
+`POST http://localhost:8080/xianyu/reply`
+
+#### 接口说明
+你需要实现这个接口，本项目会调用这个接口获取自动回复的内容并发送给客户
+不实现这个接口也没关系，系统会默认回复，你也可以配置默认回复的内容
+用于处理闲鱼消息的自动回复，支持对接大语言模型进行智能回复。
+
+**通过这个接口可以检测到用户是否已付款，然后回复虚拟资料内容即可**
+#### 请求参数
+```json
+{
+    "msg_time": "消息时间",
+    "user_url": "用户主页URL",
+    "send_user_id": "发送者ID",
+    "send_user_name": "发送者昵称",
+    "item_id": "商品ID",
+    "send_message": "发送的消息内容",
+    "chat_id": "会话ID"
+}
+```
+
+#### 响应格式
+```json
+{
+    "code": 200,
+    "data": {
+        "send_msg": "回复的消息内容"
+    }
+}
+```
+
+#### 配置示例
+```yaml
+AUTO_REPLY:
+  api:
+    enabled: true  # 是否启用API回复
+    timeout: 10    # 超时时间（秒）
+    url: http://localhost:8080/xianyu/reply
+```
+
+#### 使用场景
+- 当收到买家消息时，系统会自动调用此接口
+- 支持接入 ChatGPT、文心一言等大语言模型
+- 支持自定义回复规则和模板
+- 支持消息变量替换（如 `{send_user_name}`）
+
+#### 注意事项
+- 接口需要返回正确的状态码（200）和消息内容
+- 建议实现错误重试机制
+- 注意处理超时情况（默认10秒）
+- 可以根据需要扩展更多的参数和功能
+
+## 🗝️ 注意事项
+- 请确保闲鱼账号已登录并获取有效的 Cookie
+- 建议在正式环境使用前先在测试环境验证
+- 定期检查日志文件，及时处理异常情况
+- 使用大模型时注意 API 调用频率和成本控制
+
+## 📝 效果
+
+
+![image-20250611004531745](https://typeropic.oss-cn-beijing.aliyuncs.com/cp/image-20250611004531745.png)
+
+![image-20250611004549662](https://typeropic.oss-cn-beijing.aliyuncs.com/cp/image-20250611004549662.png)
+
+## 🧸特别鸣谢
+
+本项目参考了以下开源项目： https://github.com/cv-cat/XianYuApis
+
+感谢[@CVcat](https://github.com/cv-cat)的技术支持
+
+## 📞 联系方式
+如有问题或建议，欢迎提交 Issue 或 Pull Request。
+
+## 技术交流
+
+![image-20250611004141387](https://typeropic.oss-cn-beijing.aliyuncs.com/cp/image-20250611004141387.png)
diff --git a/Start.py b/Start.py
new file mode 100644
index 0000000..228cd42
--- /dev/null
+++ b/Start.py
@@ -0,0 +1,125 @@
+"""项目启动入口：
+
+1. 创建 CookieManager，按配置文件 / 环境变量初始化账号任务
+2. 在后台线程启动 FastAPI (reply_server) 提供管理与自动回复接口
+3. 主协程保持运行
+"""
+
+import os
+import asyncio
+import threading
+import uvicorn
+from urllib.parse import urlparse
+from pathlib import Path
+from loguru import logger
+
+from config import AUTO_REPLY, COOKIES_LIST
+import cookie_manager as cm
+from db_manager import db_manager
+from file_log_collector import setup_file_logging
+
+
+def _start_api_server():
+    """后台线程启动 FastAPI 服务"""
+    api_conf = AUTO_REPLY.get('api', {})
+
+    # 优先使用环境变量配置
+    host = os.getenv('API_HOST', '0.0.0.0')  # 默认绑定所有接口
+    port = int(os.getenv('API_PORT', '8080'))  # 默认端口8080
+
+    # 如果配置文件中有特定配置，则使用配置文件
+    if 'host' in api_conf:
+        host = api_conf['host']
+    if 'port' in api_conf:
+        port = api_conf['port']
+
+    # 兼容旧的URL配置方式
+    if 'url' in api_conf and 'host' not in api_conf and 'port' not in api_conf:
+        url = api_conf.get('url', 'http://0.0.0.0:8080/xianyu/reply')
+        parsed = urlparse(url)
+        if parsed.hostname and parsed.hostname != 'localhost':
+            host = parsed.hostname
+        port = parsed.port or 8080
+
+    logger.info(f"启动Web服务器: http://{host}:{port}")
+    uvicorn.run("reply_server:app", host=host, port=port, log_level="info")
+
+
+def load_keywords_file(path: str):
+    """从文件读取关键字 -> [(keyword, reply)]"""
+    kw_list = []
+    p = Path(path)
+    if not p.exists():
+        return kw_list
+    with p.open('r', encoding='utf-8') as f:
+        for line in f:
+            line = line.strip()
+            if not line or line.startswith('#'):
+                continue
+            if '\t' in line:
+                k, r = line.split('\t', 1)
+            elif ' ' in line:
+                k, r = line.split(' ', 1)
+            elif ':' in line:
+                k, r = line.split(':', 1)
+            else:
+                continue
+            kw_list.append((k.strip(), r.strip()))
+    return kw_list
+
+
+async def main():
+    print("开始启动主程序...")
+
+    # 初始化文件日志收集器
+    print("初始化文件日志收集器...")
+    setup_file_logging()
+    logger.info("文件日志收集器已启动，开始收集实时日志")
+
+    loop = asyncio.get_running_loop()
+
+    # 创建 CookieManager 并在全局暴露
+    print("创建 CookieManager...")
+    cm.manager = cm.CookieManager(loop)
+    manager = cm.manager
+    print("CookieManager 创建完成")
+
+    # 1) 从数据库加载的 Cookie 已经在 CookieManager 初始化时完成
+    # 为每个 Cookie 启动任务
+    for cid, val in manager.cookies.items():
+        try:
+            await manager._add_cookie_async(cid, val)
+            logger.info(f"启动数据库中的 Cookie 任务: {cid}")
+        except Exception as e:
+            logger.error(f"启动 Cookie 任务失败: {cid}, {e}")
+    
+    # 2) 如果配置文件中有新的 Cookie，也加载它们
+    for entry in COOKIES_LIST:
+        cid = entry.get('id')
+        val = entry.get('value')
+        if not cid or not val or cid in manager.cookies:
+            continue
+        
+        kw_file = entry.get('keywords_file')
+        kw_list = load_keywords_file(kw_file) if kw_file else None
+        manager.add_cookie(cid, val, kw_list)
+        logger.info(f"从配置文件加载 Cookie: {cid}")
+
+    # 3) 若老环境变量仍提供单账号 Cookie，则作为 default 账号
+    env_cookie = os.getenv('COOKIES_STR')
+    if env_cookie and 'default' not in manager.list_cookies():
+        manager.add_cookie('default', env_cookie)
+        logger.info("从环境变量加载 default Cookie")
+
+    # 启动 API 服务线程
+    print("启动 API 服务线程...")
+    threading.Thread(target=_start_api_server, daemon=True).start()
+    print("API 服务线程已启动")
+
+    # 阻塞保持运行
+    print("主程序启动完成，保持运行...")
+    await asyncio.Event().wait()
+
+
+if __name__ == '__main__':
+    asyncio.run(main()) 
\ No newline at end of file
diff --git a/UI_IMPROVEMENTS.md b/UI_IMPROVEMENTS.md
new file mode 100644
index 0000000..1ac59fc
--- /dev/null
+++ b/UI_IMPROVEMENTS.md
@@ -0,0 +1,92 @@
+# 🎨 界面优化总结
+
+## ✨ 主要改进
+
+### 1. 🎯 Cookie显示优化
+- **❌ 修改前**: Cookie值被隐藏为星号 (`****`)
+- **✅ 修改后**: 显示完整的Cookie内容，便于查看和调试
+
+### 2. 🎨 视觉设计升级
+- **现代化配色方案**: 使用更现代的紫色主题 (`#4f46e5`)
+- **渐变背景**: 美丽的渐变背景和卡片效果
+- **毛玻璃效果**: 卡片使用 `backdrop-filter: blur()` 实现毛玻璃效果
+- **阴影和动画**: 悬停时的阴影和位移动画效果
+
+### 3. 🔧 功能增强
+- **一键复制Cookie**: 点击Cookie值或复制按钮即可复制到剪贴板
+- **改进的按钮组**: 更紧凑的按钮布局，包含复制功能
+- **更好的空状态**: 当没有账号时显示更友好的提示
+
+### 4. 📱 响应式设计
+- **移动端优化**: 在小屏幕上按钮垂直排列
+- **自适应布局**: 表格和卡片在不同屏幕尺寸下的自适应
+
+## 🛠️ 技术改进
+
+### 新增API接口
+```javascript
+GET /cookies/details
+```
+返回包含Cookie ID和完整值的详细信息，而不仅仅是ID列表。
+
+### CSS样式优化
+- **CSS变量**: 统一的颜色管理
+- **现代字体**: 使用 Inter 字体提升可读性
+- **代码字体**: Cookie值使用等宽字体 (JetBrains Mono)
+- **流畅动画**: 所有交互都有平滑的过渡效果
+
+### JavaScript功能增强
+- **复制功能**: 支持现代浏览器的 Clipboard API
+- **降级方案**: 对于不支持的浏览器提供传统复制方法
+- **用户反馈**: 复制成功/失败的Toast提示
+
+## 🎯 用户体验提升
+
+### 1. Cookie管理
+- **完整显示**: 不再隐藏Cookie内容，便于调试
+- **一键复制**: 快速复制Cookie值到剪贴板
+- **格式化显示**: 使用等宽字体和适当的行高
+
+### 2. 视觉反馈
+- **悬停效果**: 所有可交互元素都有悬停反馈
+- **状态指示**: 清晰的按钮状态和颜色区分
+- **加载动画**: 优雅的加载状态显示
+
+### 3. 操作便利性
+- **按钮分组**: 相关操作按钮紧凑排列
+- **图标提示**: 每个按钮都有清晰的图标和提示
+- **确认对话框**: 危险操作有确认提示
+
+## 📊 界面对比
+
+| 功能 | 修改前 | 修改后 |
+|------|--------|--------|
+| Cookie显示 | 隐藏为星号 | 完整显示 |
+| 复制功能 | 无 | 一键复制 |
+| 视觉效果 | 基础Bootstrap | 现代化渐变设计 |
+| 响应式 | 基本支持 | 完全优化 |
+| 用户反馈 | 基础提示 | 丰富的Toast反馈 |
+
+## 🚀 使用说明
+
+### 访问界面
+1. 启动系统: `python Start.py`
+2. 打开浏览器: `http://localhost:8080`
+3. 登录: `admin` / `admin123`
+
+### 主要功能
+- **添加账号**: 在顶部表单中输入账号ID和Cookie值
+- **查看Cookie**: 完整的Cookie值显示在表格中
+- **复制Cookie**: 点击Cookie值或复制按钮
+- **管理关键词**: 点击关键词按钮设置自动回复
+- **删除账号**: 点击删除按钮（有确认提示）
+
+## 🎉 总结
+
+这次界面优化大幅提升了用户体验：
+- ✅ **Cookie不再隐藏**，便于查看和调试
+- ✅ **现代化设计**，视觉效果更佳
+- ✅ **功能增强**，操作更便利
+- ✅ **响应式优化**，支持各种设备
+
+界面现在更加美观、实用和用户友好！🎨✨
diff --git a/XianyuAutoAsync.py b/XianyuAutoAsync.py
new file mode 100644
index 0000000..56fcc48
--- /dev/null
+++ b/XianyuAutoAsync.py
@@ -0,0 +1,1955 @@
+import asyncio
+import json
+import time
+import base64
+import os
+from loguru import logger
+import websockets
+from utils.xianyu_utils import (
+    decrypt, generate_mid, generate_uuid, trans_cookies,
+    generate_device_id, generate_sign
+)
+from config import (
+    WEBSOCKET_URL, HEARTBEAT_INTERVAL, HEARTBEAT_TIMEOUT,
+    TOKEN_REFRESH_INTERVAL, TOKEN_RETRY_INTERVAL, config, COOKIES_STR,
+    LOG_CONFIG, AUTO_REPLY, DEFAULT_HEADERS, WEBSOCKET_HEADERS,
+    APP_CONFIG, API_ENDPOINTS
+)
+from utils.message_utils import format_message, format_system_message
+from utils.ws_utils import WebSocketClient
+import sys
+import aiohttp
+
+# 日志配置
+log_dir = 'logs'
+os.makedirs(log_dir, exist_ok=True)
+log_path = os.path.join(log_dir, f"xianyu_{time.strftime('%Y-%m-%d')}.log")
+logger.remove()
+logger.add(
+    log_path,
+    rotation=LOG_CONFIG.get('rotation', '1 day'),
+    retention=LOG_CONFIG.get('retention', '7 days'),
+    compression=LOG_CONFIG.get('compression', 'zip'),
+    level=LOG_CONFIG.get('level', 'INFO'),
+    format=LOG_CONFIG.get('format', '<green>{time:YYYY-MM-DD HH:mm:ss.SSS}</green> | <level>{level: <8}</level> | <cyan>{name}</cyan>:<cyan>{function}</cyan>:<cyan>{line}</cyan> - <level>{message}</level>'),
+    encoding='utf-8',
+    enqueue=True
+)
+logger.add(
+    sys.stdout,
+    level=LOG_CONFIG.get('level', 'INFO'),
+    format=LOG_CONFIG.get('format', '<green>{time:YYYY-MM-DD HH:mm:ss.SSS}</green> | <level>{level: <8}</level> | <cyan>{name}</cyan>:<cyan>{function}</cyan>:<cyan>{line}</cyan> - <level>{message}</level>'),
+    enqueue=True
+)
+
+class XianyuLive:
+    def _safe_str(self, e):
+        """安全地将异常转换为字符串"""
+        try:
+            return str(e)
+        except:
+            try:
+                return repr(e)
+            except:
+                return "未知错误"
+
+    def __init__(self, cookies_str=None, cookie_id: str = "default"):
+        """初始化闲鱼直播类"""
+        if not cookies_str:
+            cookies_str = COOKIES_STR
+        if not cookies_str:
+            raise ValueError("未提供cookies，请在global_config.yml中配置COOKIES_STR或通过参数传入")
+            
+        self.cookies = trans_cookies(cookies_str)
+        self.cookie_id = cookie_id  # 唯一账号标识
+        self.cookies_str = cookies_str  # 保存原始cookie字符串
+        self.base_url = WEBSOCKET_URL
+        self.myid = self.cookies['unb']
+        self.device_id = generate_device_id(self.myid)
+        
+        # 心跳相关配置
+        self.heartbeat_interval = HEARTBEAT_INTERVAL
+        self.heartbeat_timeout = HEARTBEAT_TIMEOUT
+        self.last_heartbeat_time = 0
+        self.last_heartbeat_response = 0
+        self.heartbeat_task = None
+        self.ws = None
+        
+        # Token刷新相关配置
+        self.token_refresh_interval = TOKEN_REFRESH_INTERVAL
+        self.token_retry_interval = TOKEN_RETRY_INTERVAL
+        self.last_token_refresh_time = 0
+        self.current_token = None
+        self.token_refresh_task = None
+        self.connection_restart_flag = False  # 连接重启标志
+        
+        # 人工接管功能已禁用，永远走自动模式
+        # self.manual_mode_conversations = set()  # 存储处于人工接管模式的会话ID
+        # self.manual_mode_timeout = MANUAL_MODE.get('timeout', 3600)  # 人工接管超时时间，默认1小时
+        # self.manual_mode_timestamps = {}  # 记录进入人工模式的时间
+        # self.toggle_keywords = MANUAL_MODE.get('toggle_keywords', ['。'])  # 切换关键词
+        self.session = None  # 用于API调用的aiohttp session
+
+    # 人工接管功能已禁用，以下方法不再使用
+    # def check_toggle_keywords(self, message):
+    #     """检查消息是否包含切换关键词"""
+    #     return any(keyword in message for keyword in self.toggle_keywords)
+
+    # def is_manual_mode(self, chat_id):
+    #     """检查是否处于人工接管模式"""
+    #     if chat_id in self.manual_mode_conversations:
+    #         # 检查是否超时
+    #         if time.time() - self.manual_mode_timestamps.get(chat_id, 0) > self.manual_mode_timeout:
+    #             self.exit_manual_mode(chat_id)
+    #             return False
+    #         return True
+    #     return False
+
+    # def enter_manual_mode(self, chat_id):
+    #     """进入人工接管模式"""
+    #     self.manual_mode_conversations.add(chat_id)
+    #     self.manual_mode_timestamps[chat_id] = time.time()
+
+    # def exit_manual_mode(self, chat_id):
+    #     """退出人工接管模式"""
+    #     self.manual_mode_conversations.discard(chat_id)
+    #     self.manual_mode_timestamps.pop(chat_id, None)
+
+    # def toggle_manual_mode(self, chat_id):
+    #     """切换人工接管模式"""
+    #     if self.is_manual_mode(chat_id):
+    #         self.exit_manual_mode(chat_id)
+    #         return False
+    #     else:
+    #         self.enter_manual_mode(chat_id)
+    #         return True
+
+    async def refresh_token(self):
+        """刷新token"""
+        try:
+            logger.info("开始刷新token...")
+            params = {
+                'jsv': '2.7.2',
+                'appKey': '34839810',
+                't': str(int(time.time()) * 1000),
+                'sign': '',
+                'v': '1.0',
+                'type': 'originaljson',
+                'accountSite': 'xianyu',
+                'dataType': 'json',
+                'timeout': '20000',
+                'api': 'mtop.taobao.idlemessage.pc.login.token',
+                'sessionOption': 'AutoLoginOnly',
+                'spm_cnt': 'a21ybx.im.0.0',
+            }
+            data_val = '{"appKey":"444e9908a51d1cb236a27862abc769c9","deviceId":"' + self.device_id + '"}'
+            data = {
+                'data': data_val,
+            }
+            
+            # 获取token
+            token = None
+            if '_m_h5_tk' in self.cookies:
+                token = self.cookies['_m_h5_tk'].split('_')[0]
+            
+            sign = generate_sign(params['t'], token, data_val)
+            params['sign'] = sign
+            
+            # 发送请求
+            headers = DEFAULT_HEADERS.copy()
+            headers['cookie'] = self.cookies_str
+            
+            async with aiohttp.ClientSession() as session:
+                async with session.post(
+                    API_ENDPOINTS.get('token'),
+                    params=params,
+                    data=data,
+                    headers=headers
+                ) as response:
+                    res_json = await response.json()
+                    
+                    # 检查并更新Cookie
+                    if 'set-cookie' in response.headers:
+                        new_cookies = {}
+                        for cookie in response.headers.getall('set-cookie', []):
+                            if '=' in cookie:
+                                name, value = cookie.split(';')[0].split('=', 1)
+                                new_cookies[name.strip()] = value.strip()
+                        
+                        # 更新cookies
+                        if new_cookies:
+                            self.cookies.update(new_cookies)
+                            # 生成新的cookie字符串
+                            self.cookies_str = '; '.join([f"{k}={v}" for k, v in self.cookies.items()])
+                            # 更新数据库中的Cookie
+                            await self.update_config_cookies()
+                            logger.debug("已更新Cookie到数据库")
+                    
+                    if isinstance(res_json, dict):
+                        ret_value = res_json.get('ret', [])
+                        # 检查ret是否包含成功信息
+                        if any('SUCCESS::调用成功' in ret for ret in ret_value):
+                            if 'data' in res_json and 'accessToken' in res_json['data']:
+                                new_token = res_json['data']['accessToken']
+                                self.current_token = new_token
+                                self.last_token_refresh_time = time.time()
+                                logger.info("Token刷新成功")
+                                return new_token
+                            
+                    logger.error(f"Token刷新失败: {res_json}")
+                    return None
+                    
+        except Exception as e:
+            logger.error(f"Token刷新异常: {self._safe_str(e)}")
+            return None
+
+    async def update_config_cookies(self):
+        """更新数据库中的cookies"""
+        try:
+            from db_manager import db_manager
+
+            # 更新数据库中的Cookie
+            if hasattr(self, 'cookie_id') and self.cookie_id:
+                try:
+                    db_manager.save_cookie(self.cookie_id, self.cookies_str)
+                    logger.debug(f"已更新Cookie到数据库: {self.cookie_id}")
+                except Exception as e:
+                    logger.error(f"更新数据库Cookie失败: {self._safe_str(e)}")
+            else:
+                logger.warning("Cookie ID不存在，无法更新数据库")
+
+        except Exception as e:
+            logger.error(f"更新Cookie失败: {self._safe_str(e)}")
+
+    async def save_item_info_to_db(self, item_id: str, item_detail: str = None):
+        """保存商品信息到数据库
+
+        Args:
+            item_id: 商品ID
+            item_detail: 商品详情内容（可以是任意格式的文本）
+        """
+        try:
+            # 跳过以 auto_ 开头的商品ID
+            if item_id and item_id.startswith('auto_'):
+                logger.debug(f"跳过保存自动生成的商品ID: {item_id}")
+                return
+
+            from db_manager import db_manager
+
+            # 直接使用传入的详情内容
+            item_data = item_detail
+
+            # 保存到数据库
+            success = db_manager.save_item_info(self.cookie_id, item_id, item_data)
+            if success:
+                logger.info(f"商品信息已保存到数据库: {item_id}")
+            else:
+                logger.warning(f"保存商品信息到数据库失败: {item_id}")
+
+        except Exception as e:
+            logger.error(f"保存商品信息到数据库异常: {self._safe_str(e)}")
+
+    async def save_item_detail_only(self, item_id, item_detail):
+        """仅保存商品详情（不影响标题等基本信息）"""
+        try:
+            from db_manager import db_manager
+
+            # 使用专门的详情更新方法
+            success = db_manager.update_item_detail(self.cookie_id, item_id, item_detail)
+
+            if success:
+                logger.info(f"商品详情已更新: {item_id}")
+            else:
+                logger.warning(f"更新商品详情失败: {item_id}")
+
+            return success
+
+        except Exception as e:
+            logger.error(f"更新商品详情异常: {self._safe_str(e)}")
+            return False
+
+    async def fetch_item_detail_from_api(self, item_id: str) -> str:
+        """从外部API获取商品详情
+
+        Args:
+            item_id: 商品ID
+
+        Returns:
+            str: 商品详情文本，获取失败返回空字符串
+        """
+        try:
+            # 检查是否启用自动获取功能
+            from config import config
+            auto_fetch_config = config.get('ITEM_DETAIL', {}).get('auto_fetch', {})
+
+            if not auto_fetch_config.get('enabled', True):
+                logger.debug(f"自动获取商品详情功能已禁用: {item_id}")
+                return ""
+
+            # 从配置获取API地址和超时时间
+            api_base_url = auto_fetch_config.get('api_url', 'https://selfapi.zhinianboke.com/api/getItemDetail')
+            timeout_seconds = auto_fetch_config.get('timeout', 10)
+
+            api_url = f"{api_base_url}/{item_id}"
+
+            logger.info(f"正在从外部API获取商品详情: {item_id}")
+
+            # 使用aiohttp发送异步请求
+            import aiohttp
+            import asyncio
+
+            timeout = aiohttp.ClientTimeout(total=timeout_seconds)
+
+            async with aiohttp.ClientSession(timeout=timeout) as session:
+                async with session.get(api_url) as response:
+                    if response.status == 200:
+                        result = await response.json()
+
+                        # 检查返回状态
+                        if result.get('status') == '200' and result.get('data'):
+                            item_detail = result['data']
+                            logger.info(f"成功获取商品详情: {item_id}, 长度: {len(item_detail)}")
+                            logger.debug(f"商品详情内容: {item_detail[:200]}...")
+                            return item_detail
+                        else:
+                            logger.warning(f"API返回状态异常: {result.get('status')}, message: {result.get('message')}")
+                            return ""
+                    else:
+                        logger.warning(f"API请求失败: HTTP {response.status}")
+                        return ""
+
+        except asyncio.TimeoutError:
+            logger.warning(f"获取商品详情超时: {item_id}")
+            return ""
+        except Exception as e:
+            logger.error(f"获取商品详情异常: {item_id}, 错误: {self._safe_str(e)}")
+            return ""
+
+    async def save_items_list_to_db(self, items_list):
+        """批量保存商品列表信息到数据库（并发安全）
+
+        Args:
+            items_list: 从get_item_list_info获取的商品列表
+        """
+        try:
+            from db_manager import db_manager
+
+            # 准备批量数据
+            batch_data = []
+            items_need_detail = []  # 需要获取详情的商品列表
+
+            for item in items_list:
+                item_id = item.get('id')
+                if not item_id or item_id.startswith('auto_'):
+                    continue
+
+                # 构造商品详情数据
+                item_detail = {
+                    'title': item.get('title', ''),
+                    'price': item.get('price', ''),
+                    'price_text': item.get('price_text', ''),
+                    'category_id': item.get('category_id', ''),
+                    'auction_type': item.get('auction_type', ''),
+                    'item_status': item.get('item_status', 0),
+                    'detail_url': item.get('detail_url', ''),
+                    'pic_info': item.get('pic_info', {}),
+                    'detail_params': item.get('detail_params', {}),
+                    'track_params': item.get('track_params', {}),
+                    'item_label_data': item.get('item_label_data', {}),
+                    'card_type': item.get('card_type', 0)
+                }
+
+                # 检查数据库中是否已有详情
+                existing_item = db_manager.get_item_info(self.cookie_id, item_id)
+                has_detail = existing_item and existing_item.get('item_detail') and existing_item['item_detail'].strip()
+
+                batch_data.append({
+                    'cookie_id': self.cookie_id,
+                    'item_id': item_id,
+                    'item_title': item.get('title', ''),
+                    'item_description': '',  # 暂时为空
+                    'item_category': str(item.get('category_id', '')),
+                    'item_price': item.get('price_text', ''),
+                    'item_detail': json.dumps(item_detail, ensure_ascii=False)
+                })
+
+                # 如果没有详情，添加到需要获取详情的列表
+                if not has_detail:
+                    items_need_detail.append({
+                        'item_id': item_id,
+                        'item_title': item.get('title', '')
+                    })
+
+            if not batch_data:
+                logger.info("没有有效的商品数据需要保存")
+                return 0
+
+            # 使用批量保存方法（并发安全）
+            saved_count = db_manager.batch_save_item_basic_info(batch_data)
+            logger.info(f"批量保存商品信息完成: {saved_count}/{len(batch_data)} 个商品")
+
+            # 异步获取缺失的商品详情
+            if items_need_detail:
+                from config import config
+                auto_fetch_config = config.get('ITEM_DETAIL', {}).get('auto_fetch', {})
+
+                if auto_fetch_config.get('enabled', True):
+                    logger.info(f"发现 {len(items_need_detail)} 个商品缺少详情，开始获取...")
+                    detail_success_count = await self._fetch_missing_item_details(items_need_detail)
+                    logger.info(f"成功获取 {detail_success_count}/{len(items_need_detail)} 个商品的详情")
+                else:
+                    logger.info(f"发现 {len(items_need_detail)} 个商品缺少详情，但自动获取功能已禁用")
+
+            return saved_count
+
+        except Exception as e:
+            logger.error(f"批量保存商品信息异常: {self._safe_str(e)}")
+            return 0
+
+    async def _fetch_missing_item_details(self, items_need_detail):
+        """批量获取缺失的商品详情
+
+        Args:
+            items_need_detail: 需要获取详情的商品列表
+
+        Returns:
+            int: 成功获取详情的商品数量
+        """
+        success_count = 0
+
+        try:
+            from db_manager import db_manager
+            from config import config
+
+            # 从配置获取并发数量和延迟时间
+            auto_fetch_config = config.get('ITEM_DETAIL', {}).get('auto_fetch', {})
+            max_concurrent = auto_fetch_config.get('max_concurrent', 3)
+            retry_delay = auto_fetch_config.get('retry_delay', 0.5)
+
+            # 限制并发数量，避免对API服务器造成压力
+            semaphore = asyncio.Semaphore(max_concurrent)
+
+            async def fetch_single_item_detail(item_info):
+                async with semaphore:
+                    try:
+                        item_id = item_info['item_id']
+                        item_title = item_info['item_title']
+
+                        # 获取商品详情
+                        item_detail_text = await self.fetch_item_detail_from_api(item_id)
+
+                        if item_detail_text:
+                            # 保存详情到数据库
+                            success = await self.save_item_detail_only(item_id, item_detail_text)
+                            if success:
+                                logger.info(f"✅ 成功获取并保存商品详情: {item_id} - {item_title}")
+                                return 1
+                            else:
+                                logger.warning(f"❌ 获取详情成功但保存失败: {item_id}")
+                        else:
+                            logger.warning(f"❌ 未能获取商品详情: {item_id} - {item_title}")
+
+                        # 添加延迟，避免请求过于频繁
+                        await asyncio.sleep(retry_delay)
+                        return 0
+
+                    except Exception as e:
+                        logger.error(f"获取单个商品详情异常: {item_info.get('item_id', 'unknown')}, 错误: {self._safe_str(e)}")
+                        return 0
+
+            # 并发获取所有商品详情
+            tasks = [fetch_single_item_detail(item_info) for item_info in items_need_detail]
+            results = await asyncio.gather(*tasks, return_exceptions=True)
+
+            # 统计成功数量
+            for result in results:
+                if isinstance(result, int):
+                    success_count += result
+                elif isinstance(result, Exception):
+                    logger.error(f"获取商品详情任务异常: {result}")
+
+            return success_count
+
+        except Exception as e:
+            logger.error(f"批量获取商品详情异常: {self._safe_str(e)}")
+            return success_count
+
+    async def get_item_info(self, item_id, retry_count=0):
+        """获取商品信息，自动处理token失效的情况"""
+        if retry_count >= 3:  # 最多重试3次
+            logger.error("获取商品信息失败，重试次数过多")
+            return {"error": "获取商品信息失败，重试次数过多"}
+
+        # 如果是重试（retry_count > 0），强制刷新token
+        if retry_count > 0:
+            old_token = self.cookies.get('_m_h5_tk', '').split('_')[0] if self.cookies.get('_m_h5_tk') else ''
+            logger.info(f"重试第{retry_count}次，强制刷新token... 当前_m_h5_tk: {old_token}")
+            await self.refresh_token()
+            new_token = self.cookies.get('_m_h5_tk', '').split('_')[0] if self.cookies.get('_m_h5_tk') else ''
+            logger.info(f"重试刷新token完成，新的_m_h5_tk: {new_token}")
+        else:
+            # 确保使用最新的token（首次调用时的正常逻辑）
+            if not self.current_token or (time.time() - self.last_token_refresh_time) >= self.token_refresh_interval:
+                old_token = self.cookies.get('_m_h5_tk', '').split('_')[0] if self.cookies.get('_m_h5_tk') else ''
+                logger.info(f"Token过期或不存在，刷新token... 当前_m_h5_tk: {old_token}")
+                await self.refresh_token()
+                new_token = self.cookies.get('_m_h5_tk', '').split('_')[0] if self.cookies.get('_m_h5_tk') else ''
+                logger.info(f"Token刷新完成，新的_m_h5_tk: {new_token}")
+
+        # 确保session已创建
+        if not self.session:
+            await self.create_session()
+
+        params = {
+            'jsv': '2.7.2',
+            'appKey': '34839810',
+            't': str(int(time.time()) * 1000),
+            'sign': '',
+            'v': '1.0',
+            'type': 'originaljson',
+            'accountSite': 'xianyu',
+            'dataType': 'json',
+            'timeout': '20000',
+            'api': 'mtop.taobao.idle.pc.detail',
+            'sessionOption': 'AutoLoginOnly',
+            'spm_cnt': 'a21ybx.im.0.0',
+        }
+
+        data_val = '{"itemId":"' + item_id + '"}'
+        data = {
+            'data': data_val,
+        }
+
+        # 始终从最新的cookies中获取_m_h5_tk token（刷新后cookies会被更新）
+        token = trans_cookies(self.cookies_str).get('_m_h5_tk', '').split('_')[0] if trans_cookies(self.cookies_str).get('_m_h5_tk') else ''
+
+        logger.warning(111)
+        logger.warning(token)
+        if token:
+            logger.debug(f"使用cookies中的_m_h5_tk token: {token}")
+        else:
+            logger.warning("cookies中没有找到_m_h5_tk token")
+
+        from utils.xianyu_utils import generate_sign
+        sign = generate_sign(params['t'], token, data_val)
+        params['sign'] = sign
+
+        try:
+            async with self.session.post(
+                'https://h5api.m.goofish.com/h5/mtop.taobao.idle.pc.detail/1.0/',
+                params=params,
+                data=data
+            ) as response:
+                res_json = await response.json()
+
+                logger.debug(f"商品信息获取成功: {res_json}")
+                # 检查返回状态
+                if isinstance(res_json, dict):
+                    ret_value = res_json.get('ret', [])
+                    # 检查ret是否包含成功信息
+                    if not any('SUCCESS::调用成功' in ret for ret in ret_value):
+                        logger.warning(f"商品信息API调用失败，错误信息: {ret_value}")
+                        # 处理响应中的Set-Cookie
+                        if 'Set-Cookie' in response.headers:
+                            logger.debug("检测到Set-Cookie，需要更新cookie")
+                            # TODO: 实现cookie更新逻辑
+                        await asyncio.sleep(0.5)
+                        return await self.get_item_info(item_id, retry_count + 1)
+                    else:
+                        logger.debug(f"商品信息获取成功: {item_id}")
+                        return res_json
+                else:
+                    logger.error(f"商品信息API返回格式异常: {res_json}")
+                    return await self.get_item_info(item_id, retry_count + 1)
+
+        except Exception as e:
+            logger.error(f"商品信息API请求异常: {self._safe_str(e)}")
+            await asyncio.sleep(0.5)
+            return await self.get_item_info(item_id, retry_count + 1)
+
+    def extract_item_id_from_message(self, message):
+        """从消息中提取商品ID的辅助方法"""
+        try:
+            # 方法1: 从message["1"]中提取（如果是字符串格式）
+            message_1 = message.get('1')
+            if isinstance(message_1, str):
+                # 尝试从字符串中提取数字ID
+                import re
+                id_match = re.search(r'(\d{10,})', message_1)
+                if id_match:
+                    logger.info(f"从message[1]字符串中提取商品ID: {id_match.group(1)}")
+                    return id_match.group(1)
+
+            # 方法2: 从message["3"]中提取
+            message_3 = message.get('3', {})
+            if isinstance(message_3, dict):
+
+                # 从extension中提取
+                if 'extension' in message_3:
+                    extension = message_3['extension']
+                    if isinstance(extension, dict):
+                        item_id = extension.get('itemId') or extension.get('item_id')
+                        if item_id:
+                            logger.info(f"从extension中提取商品ID: {item_id}")
+                            return item_id
+
+                # 从bizData中提取
+                if 'bizData' in message_3:
+                    biz_data = message_3['bizData']
+                    if isinstance(biz_data, dict):
+                        item_id = biz_data.get('itemId') or biz_data.get('item_id')
+                        if item_id:
+                            logger.info(f"从bizData中提取商品ID: {item_id}")
+                            return item_id
+
+                # 从其他可能的字段中提取
+                for key, value in message_3.items():
+                    if isinstance(value, dict):
+                        item_id = value.get('itemId') or value.get('item_id')
+                        if item_id:
+                            logger.info(f"从{key}字段中提取商品ID: {item_id}")
+                            return item_id
+
+                # 从消息内容中提取数字ID
+                content = message_3.get('content', '')
+                if isinstance(content, str) and content:
+                    import re
+                    id_match = re.search(r'(\d{10,})', content)
+                    if id_match:
+                        logger.info(f"从消息内容中提取商品ID: {id_match.group(1)}")
+                        return id_match.group(1)
+
+            # 方法3: 遍历整个消息结构查找可能的商品ID
+            def find_item_id_recursive(obj, path=""):
+                if isinstance(obj, dict):
+                    # 直接查找itemId字段
+                    for key in ['itemId', 'item_id', 'id']:
+                        if key in obj and isinstance(obj[key], (str, int)):
+                            value = str(obj[key])
+                            if len(value) >= 10 and value.isdigit():
+                                logger.info(f"从{path}.{key}中提取商品ID: {value}")
+                                return value
+
+                    # 递归查找
+                    for key, value in obj.items():
+                        result = find_item_id_recursive(value, f"{path}.{key}" if path else key)
+                        if result:
+                            return result
+
+                elif isinstance(obj, str):
+                    # 从字符串中提取可能的商品ID
+                    import re
+                    id_match = re.search(r'(\d{10,})', obj)
+                    if id_match:
+                        logger.info(f"从{path}字符串中提取商品ID: {id_match.group(1)}")
+                        return id_match.group(1)
+
+                return None
+
+            result = find_item_id_recursive(message)
+            if result:
+                return result
+
+            logger.warning("所有方法都未能提取到商品ID")
+            return None
+
+        except Exception as e:
+            logger.error(f"提取商品ID失败: {self._safe_str(e)}")
+            return None
+
+    def debug_message_structure(self, message, context=""):
+        """调试消息结构的辅助方法"""
+        try:
+            logger.debug(f"[{context}] 消息结构调试:")
+            logger.debug(f"  消息类型: {type(message)}")
+
+            if isinstance(message, dict):
+                for key, value in message.items():
+                    logger.debug(f"  键 '{key}': {type(value)} - {str(value)[:100]}...")
+
+                    # 特别关注可能包含商品ID的字段
+                    if key in ["1", "3"] and isinstance(value, dict):
+                        logger.debug(f"    详细结构 '{key}':")
+                        for sub_key, sub_value in value.items():
+                            logger.debug(f"      '{sub_key}': {type(sub_value)} - {str(sub_value)[:50]}...")
+            else:
+                logger.debug(f"  消息内容: {str(message)[:200]}...")
+
+        except Exception as e:
+            logger.error(f"调试消息结构时发生错误: {self._safe_str(e)}")
+
+    async def get_default_reply(self, send_user_name: str, send_user_id: str, send_message: str) -> str:
+        """获取默认回复内容，支持变量替换"""
+        try:
+            from db_manager import db_manager
+
+            # 获取当前账号的默认回复设置
+            default_reply_settings = db_manager.get_default_reply(self.cookie_id)
+
+            if not default_reply_settings or not default_reply_settings.get('enabled', False):
+                logger.debug(f"账号 {self.cookie_id} 未启用默认回复")
+                return None
+
+            reply_content = default_reply_settings.get('reply_content', '')
+            if not reply_content:
+                logger.warning(f"账号 {self.cookie_id} 默认回复内容为空")
+                return None
+
+            # 进行变量替换
+            try:
+                formatted_reply = reply_content.format(
+                    send_user_name=send_user_name,
+                    send_user_id=send_user_id,
+                    send_message=send_message
+                )
+                logger.info(f"使用默认回复: {formatted_reply}")
+                return f"[默认回复] {formatted_reply}"
+            except Exception as format_error:
+                logger.error(f"默认回复变量替换失败: {self._safe_str(format_error)}")
+                # 如果变量替换失败，返回原始内容
+                return f"[默认回复] {reply_content}"
+
+        except Exception as e:
+            logger.error(f"获取默认回复失败: {self._safe_str(e)}")
+            return None
+
+    async def send_notification(self, send_user_name: str, send_user_id: str, send_message: str, item_id: str = None):
+        """发送消息通知"""
+        try:
+            from db_manager import db_manager
+            import aiohttp
+            import json
+
+
+            # 获取当前账号的通知配置
+            notifications = db_manager.get_account_notifications(self.cookie_id)
+
+            if not notifications:
+                logger.debug(f"账号 {self.cookie_id} 未配置消息通知")
+                return
+
+            # 构建通知消息
+            notification_msg = f"🚨 接收消息通知\n\n" \
+                             f"账号: {self.cookie_id}\n" \
+                             f"买家: {send_user_name} (ID: {send_user_id})\n" \
+                             f"商品ID: {item_id or '未知'}\n" \
+                             f"消息内容: {send_message}\n" \
+                             f"时间: {time.strftime('%Y-%m-%d %H:%M:%S')}\n\n"
+
+            # 发送通知到各个渠道
+            for notification in notifications:
+                if not notification.get('enabled', True):
+                    continue
+
+                channel_type = notification.get('channel_type')
+                channel_config = notification.get('channel_config')
+
+                try:
+                    if channel_type == 'qq':
+                        await self._send_qq_notification(channel_config, notification_msg)
+                    else:
+                        logger.warning(f"不支持的通知渠道类型: {channel_type}")
+
+                except Exception as notify_error:
+                    logger.error(f"发送通知失败 ({notification.get('channel_name', 'Unknown')}): {self._safe_str(notify_error)}")
+
+        except Exception as e:
+            logger.error(f"处理消息通知失败: {self._safe_str(e)}")
+
+    async def _send_qq_notification(self, config: str, message: str):
+        """发送QQ通知"""
+        try:
+            import aiohttp
+            import json
+
+            # 解析配置（QQ号码）
+            qq_number = config.strip()
+            if not qq_number:
+                logger.warning("QQ通知配置为空")
+                return
+
+            # 构建请求URL
+            api_url = "http://notice.zhinianblog.cn/sendPrivateMsg"
+            params = {
+                'qq': qq_number,
+                'msg': message
+            }
+
+            # 发送GET请求
+            async with aiohttp.ClientSession() as session:
+                async with session.get(api_url, params=params, timeout=10) as response:
+                    if response.status == 200:
+                        logger.info(f"QQ通知发送成功: {qq_number}")
+                    else:
+                        logger.warning(f"QQ通知发送失败: {response.status}")
+
+        except Exception as e:
+            logger.error(f"发送QQ通知异常: {self._safe_str(e)}")
+
+    async def send_delivery_failure_notification(self, send_user_name: str, send_user_id: str, item_id: str, error_message: str):
+        """发送自动发货失败通知"""
+        try:
+            from db_manager import db_manager
+
+            # 获取当前账号的通知配置
+            notifications = db_manager.get_account_notifications(self.cookie_id)
+
+            if not notifications:
+                logger.debug("未配置消息通知，跳过自动发货通知")
+                return
+
+            # 构造通知消息
+            notification_message = f"🚨 自动发货通知\n\n" \
+                                 f"账号: {self.cookie_id}\n" \
+                                 f"买家: {send_user_name} (ID: {send_user_id})\n" \
+                                 f"商品ID: {item_id}\n" \
+                                 f"结果: {error_message}\n" \
+                                 f"时间: {time.strftime('%Y-%m-%d %H:%M:%S')}\n\n" \
+                                 f"请及时处理！"
+
+            # 发送通知到所有已启用的通知渠道
+            for notification in notifications:
+                if notification.get('enabled', False):
+                    channel_type = notification.get('channel_type', 'qq')
+                    channel_config = notification.get('channel_config', '')
+
+                    if channel_type == 'qq':
+                        await self._send_qq_notification(channel_config, notification_message)
+                        logger.info(f"已发送自动发货通知到QQ: {channel_config}")
+
+        except Exception as e:
+            logger.error(f"发送自动发货通知异常: {self._safe_str(e)}")
+
+    async def _auto_delivery(self, item_id: str, item_title: str = None):
+        """自动发货功能"""
+        try:
+            from db_manager import db_manager
+
+            logger.info(f"开始自动发货检查: 商品ID={item_id}")
+
+            # 获取商品详细信息
+            item_info = None
+            search_text = item_title  # 默认使用传入的标题
+
+            if item_id and item_id != "未知商品":
+                # 优先尝试通过API获取商品信息
+                try:
+                    logger.info(f"通过API获取商品详细信息: {item_id}")
+                    item_info = await self.get_item_info(item_id)
+                    if item_info and 'data' in item_info:
+                        data = item_info['data']
+                        item_data = data['itemDO']
+                        shareData = item_data['shareData']
+                        shareInfoJsonString = shareData['shareInfoJsonString']
+
+                        # 解析 shareInfoJsonString 并提取 content 内容
+                        try:
+                            import json
+                            share_info = json.loads(shareInfoJsonString)
+                            content = share_info.get('contentParams', {}).get('mainParams', {}).get('content', '')
+                            if content:
+                                search_text = content
+                                logger.info(f"API成功提取商品内容作为搜索文本: {content[:100]}...")
+                            else:
+                                search_text = shareInfoJsonString
+                                logger.warning("未能从API商品信息中提取到content字段，使用完整JSON字符串")
+                        except json.JSONDecodeError as json_e:
+                            logger.warning(f"解析API商品信息JSON失败: {self._safe_str(json_e)}，使用原始字符串")
+                            search_text = shareInfoJsonString
+                        except Exception as parse_e:
+                            logger.warning(f"提取API商品内容失败: {self._safe_str(parse_e)}，使用原始字符串")
+                            search_text = shareInfoJsonString
+
+                        logger.info(f"API获取到的商品信息为: {search_text[:200]}...")
+                    else:
+                        raise Exception("API返回数据格式异常")
+
+                except Exception as e:
+                    logger.warning(f"API获取商品信息失败: {self._safe_str(e)}，尝试从数据库获取")
+
+                    # API失败时，从数据库获取商品信息
+                    try:
+                        db_item_info = db_manager.get_item_info(self.cookie_id, item_id)
+                        if db_item_info:
+                            # 拼接商品标题和详情作为搜索文本
+                            item_title_db = db_item_info.get('item_title', '') or ''
+                            item_detail_db = db_item_info.get('item_detail', '') or ''
+
+                            # 如果数据库中没有详情，尝试从外部API获取
+                            if not item_detail_db.strip():
+                                from config import config
+                                auto_fetch_config = config.get('ITEM_DETAIL', {}).get('auto_fetch', {})
+
+                                if auto_fetch_config.get('enabled', True):
+                                    logger.info(f"数据库中商品详情为空，尝试从外部API获取: {item_id}")
+                                    try:
+                                        fetched_detail = await self.fetch_item_detail_from_api(item_id)
+                                        if fetched_detail:
+                                            # 保存获取到的详情
+                                            await self.save_item_detail_only(item_id, fetched_detail)
+                                            item_detail_db = fetched_detail
+                                            logger.info(f"成功从外部API获取并保存商品详情: {item_id}")
+                                        else:
+                                            logger.warning(f"外部API未能获取到商品详情: {item_id}")
+                                    except Exception as api_e:
+                                        logger.warning(f"从外部API获取商品详情失败: {item_id}, 错误: {self._safe_str(api_e)}")
+                                else:
+                                    logger.debug(f"自动获取商品详情功能已禁用，跳过: {item_id}")
+
+                            # 组合搜索文本：商品标题 + 商品详情
+                            search_parts = []
+                            if item_title_db.strip():
+                                search_parts.append(item_title_db.strip())
+                            if item_detail_db.strip():
+                                search_parts.append(item_detail_db.strip())
+
+                            if search_parts:
+                                search_text = ' '.join(search_parts)
+                                logger.info(f"使用数据库商品标题+详情作为搜索文本: 标题='{item_title_db}', 详情长度={len(item_detail_db)}")
+                                logger.debug(f"完整搜索文本: {search_text[:200]}...")
+                            else:
+                                logger.warning(f"数据库中商品标题和详情都为空，且无法从API获取: {item_id}")
+                                search_text = item_title or item_id
+                        else:
+                            logger.warning(f"数据库中未找到商品信息: {item_id}")
+                            search_text = item_title or item_id
+
+                    except Exception as db_e:
+                        logger.warning(f"从数据库获取商品信息失败: {self._safe_str(db_e)}")
+                        search_text = item_title or item_id
+
+            if not search_text:
+                search_text = item_id or "未知商品"
+
+            logger.info(f"使用搜索文本匹配发货规则: {search_text[:100]}...")
+
+            # 根据商品信息查找匹配的发货规则
+            delivery_rules = db_manager.get_delivery_rules_by_keyword(search_text)
+
+            if not delivery_rules:
+                logger.info(f"未找到匹配的发货规则: {search_text[:50]}...")
+                return None
+
+            # 使用第一个匹配的规则（按关键字长度降序排列，优先匹配更精确的规则）
+            
+            # 保存商品信息到数据库
+            await self.save_item_info_to_db(item_id, search_text)
+            rule = delivery_rules[0]
+            logger.info(f"找到匹配的发货规则: {rule['keyword']} -> {rule['card_name']} ({rule['card_type']})")
+
+            delivery_content = None
+
+            # 根据卡券类型处理发货内容
+            if rule['card_type'] == 'api':
+                # API类型：调用API获取内容
+                delivery_content = await self._get_api_card_content(rule)
+
+            elif rule['card_type'] == 'text':
+                # 固定文字类型：直接使用文字内容
+                delivery_content = rule['card_text_content']
+
+            elif rule['card_type'] == 'data':
+                # 批量数据类型：获取并消费第一条数据
+                delivery_content = db_manager.consume_batch_data(rule['card_id'])
+
+            if delivery_content:
+                # 增加发货次数统计
+                db_manager.increment_delivery_times(rule['id'])
+                logger.info(f"自动发货成功: 规则ID={rule['id']}, 内容长度={len(delivery_content)}")
+                return delivery_content
+            else:
+                logger.warning(f"获取发货内容失败: 规则ID={rule['id']}")
+                return None
+
+        except Exception as e:
+            logger.error(f"自动发货失败: {self._safe_str(e)}")
+            return None
+
+    async def _get_api_card_content(self, rule, retry_count=0):
+        """调用API获取卡券内容，支持重试机制"""
+        max_retries = 3
+
+        if retry_count >= max_retries:
+            logger.error(f"API调用失败，已达到最大重试次数({max_retries})")
+            return None
+
+        try:
+            import aiohttp
+            import json
+            import asyncio
+
+            api_config = rule.get('card_api_config')
+            if not api_config:
+                logger.error("API配置为空")
+                return None
+
+            # 解析API配置
+            if isinstance(api_config, str):
+                api_config = json.loads(api_config)
+
+            url = api_config.get('url')
+            method = api_config.get('method', 'GET').upper()
+            timeout = api_config.get('timeout', 10)
+            headers = api_config.get('headers', '{}')
+            params = api_config.get('params', '{}')
+
+            # 解析headers和params
+            if isinstance(headers, str):
+                headers = json.loads(headers)
+            if isinstance(params, str):
+                params = json.loads(params)
+
+            retry_info = f" (重试 {retry_count + 1}/{max_retries})" if retry_count > 0 else ""
+            logger.info(f"调用API获取卡券: {method} {url}{retry_info}")
+
+            # 确保session存在
+            if not self.session:
+                await self.create_session()
+
+            # 发起HTTP请求
+            timeout_obj = aiohttp.ClientTimeout(total=timeout)
+
+            if method == 'GET':
+                async with self.session.get(url, headers=headers, params=params, timeout=timeout_obj) as response:
+                    status_code = response.status
+                    response_text = await response.text()
+            elif method == 'POST':
+                async with self.session.post(url, headers=headers, json=params, timeout=timeout_obj) as response:
+                    status_code = response.status
+                    response_text = await response.text()
+            else:
+                logger.error(f"不支持的HTTP方法: {method}")
+                return None
+
+            if status_code == 200:
+                # 尝试解析JSON响应，如果失败则使用原始文本
+                try:
+                    result = json.loads(response_text)
+                    # 如果返回的是对象，尝试提取常见的内容字段
+                    if isinstance(result, dict):
+                        content = result.get('data') or result.get('content') or result.get('card') or str(result)
+                    else:
+                        content = str(result)
+                except:
+                    content = response_text
+
+                logger.info(f"API调用成功，返回内容长度: {len(content)}")
+                return content
+            else:
+                logger.warning(f"API调用失败: {status_code} - {response_text[:200]}...")
+
+                # 如果是服务器错误(5xx)或请求超时，进行重试
+                if status_code >= 500 or status_code == 408:
+                    if retry_count < max_retries - 1:
+                        wait_time = (retry_count + 1) * 2  # 递增等待时间: 2s, 4s, 6s
+                        logger.info(f"等待 {wait_time} 秒后重试...")
+                        await asyncio.sleep(wait_time)
+                        return await self._get_api_card_content(rule, retry_count + 1)
+
+                return None
+
+        except (aiohttp.ClientTimeout, aiohttp.ClientError) as e:
+            logger.warning(f"API调用网络异常: {self._safe_str(e)}")
+
+            # 网络异常也进行重试
+            if retry_count < max_retries - 1:
+                wait_time = (retry_count + 1) * 2  # 递增等待时间
+                logger.info(f"等待 {wait_time} 秒后重试...")
+                await asyncio.sleep(wait_time)
+                return await self._get_api_card_content(rule, retry_count + 1)
+            else:
+                logger.error(f"API调用网络异常，已达到最大重试次数: {self._safe_str(e)}")
+                return None
+
+        except Exception as e:
+            logger.error(f"API调用异常: {self._safe_str(e)}")
+            return None
+
+    async def token_refresh_loop(self):
+        """Token刷新循环"""
+        while True:
+            try:
+                current_time = time.time()
+                if current_time - self.last_token_refresh_time >= self.token_refresh_interval:
+                    logger.info("Token即将过期，准备刷新...")
+                    new_token = await self.refresh_token()
+                    if new_token:
+                        logger.info("Token刷新成功，准备重新建立连接...")
+                        self.connection_restart_flag = True
+                        if self.ws:
+                            await self.ws.close()
+                        break
+                    else:
+                        logger.error("Token刷新失败，将在{}分钟后重试".format(self.token_retry_interval // 60))
+                        await asyncio.sleep(self.token_retry_interval)
+                        continue
+                await asyncio.sleep(60)
+            except Exception as e:
+                logger.error(f"Token刷新循环出错: {self._safe_str(e)}")
+                await asyncio.sleep(60)
+
+    async def create_chat(self, ws, toid, item_id='891198795482'):
+        msg = {
+            "lwp": "/r/SingleChatConversation/create",
+            "headers": {
+                "mid": generate_mid()
+            },
+            "body": [
+                {
+                    "pairFirst": f"{toid}@goofish",
+                    "pairSecond": f"{self.myid}@goofish",
+                    "bizType": "1",
+                    "extension": {
+                        "itemId": item_id
+                    },
+                    "ctx": {
+                        "appVersion": "1.0",
+                        "platform": "web"
+                    }
+                }
+            ]
+        }
+        await ws.send(json.dumps(msg))
+
+    async def send_msg(self, ws, cid, toid, text):
+        text = {
+            "contentType": 1,
+            "text": {
+                "text": text
+            }
+        }
+        text_base64 = str(base64.b64encode(json.dumps(text).encode('utf-8')), 'utf-8')
+        msg = {
+            "lwp": "/r/MessageSend/sendByReceiverScope",
+            "headers": {
+                "mid": generate_mid()
+            },
+            "body": [
+                {
+                    "uuid": generate_uuid(),
+                    "cid": f"{cid}@goofish",
+                    "conversationType": 1,
+                    "content": {
+                        "contentType": 101,
+                        "custom": {
+                            "type": 1,
+                            "data": text_base64
+                        }
+                    },
+                    "redPointPolicy": 0,
+                    "extension": {
+                        "extJson": "{}"
+                    },
+                    "ctx": {
+                        "appVersion": "1.0",
+                        "platform": "web"
+                    },
+                    "mtags": {},
+                    "msgReadStatusSetting": 1
+                },
+                {
+                    "actualReceivers": [
+                        f"{toid}@goofish",
+                        f"{self.myid}@goofish"
+                    ]
+                }
+            ]
+        }
+        await ws.send(json.dumps(msg))
+
+    async def init(self, ws):
+        # 如果没有token或者token过期，获取新token
+        if not self.current_token or (time.time() - self.last_token_refresh_time) >= self.token_refresh_interval:
+            logger.info("获取初始token...")
+            await self.refresh_token()
+        
+        if not self.current_token:
+            logger.error("无法获取有效token，初始化失败")
+            raise Exception("Token获取失败")
+            
+        msg = {
+            "lwp": "/reg",
+            "headers": {
+                "cache-header": "app-key token ua wv",
+                "app-key": APP_CONFIG.get('app_key'),
+                "token": self.current_token,
+                "ua": "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/133.0.0.0 Safari/537.36 DingTalk(2.1.5) OS(Windows/10) Browser(Chrome/133.0.0.0) DingWeb/2.1.5 IMPaaS DingWeb/2.1.5",
+                "dt": "j",
+                "wv": "im:3,au:3,sy:6",
+                "sync": "0,0;0;0;",
+                "did": self.device_id,
+                "mid": generate_mid()
+            }
+        }
+        await ws.send(json.dumps(msg))
+        await asyncio.sleep(1)
+        current_time = int(time.time() * 1000)
+        msg = {
+            "lwp": "/r/SyncStatus/ackDiff",
+            "headers": {"mid": generate_mid()},
+            "body": [
+                {
+                    "pipeline": "sync",
+                    "tooLong2Tag": "PNM,1",
+                    "channel": "sync",
+                    "topic": "sync",
+                    "highPts": 0,
+                    "pts": current_time * 1000,
+                    "seq": 0,
+                    "timestamp": current_time
+                }
+            ]
+        }
+        await ws.send(json.dumps(msg))
+        logger.info('连接注册完成')
+
+    async def send_heartbeat(self, ws):
+        """发送心跳包"""
+        msg = {
+            "lwp": "/!",
+            "headers": {
+                "mid": generate_mid()
+            }
+        }
+        await ws.send(json.dumps(msg))
+        self.last_heartbeat_time = time.time()
+
+    async def heartbeat_loop(self, ws):
+        """心跳循环"""
+        while True:
+            try:
+                await self.send_heartbeat(ws)
+                await asyncio.sleep(self.heartbeat_interval)
+            except Exception as e:
+                logger.error(f"心跳发送失败: {self._safe_str(e)}")
+                break
+
+    async def handle_heartbeat_response(self, message_data):
+        """处理心跳响应"""
+        try:
+            if message_data.get("code") == 200:
+                self.last_heartbeat_response = time.time()
+                logger.debug("心跳响应正常")
+                return True
+        except Exception as e:
+            logger.error(f"处理心跳响应出错: {self._safe_str(e)}")
+        return False
+
+    async def send_msg_once(self, toid, item_id, text):
+        headers = {
+            "Cookie": self.cookies_str,
+            "Host": "wss-goofish.dingtalk.com",
+            "Connection": "Upgrade",
+            "Pragma": "no-cache",
+            "Cache-Control": "no-cache",
+            "User-Agent": "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/133.0.0.0 Safari/537.36",
+            "Origin": "https://www.goofish.com",
+            "Accept-Encoding": "gzip, deflate, br, zstd",
+            "Accept-Language": "zh-CN,zh;q=0.9",
+        }
+        # 兼容不同版本的websockets库
+        try:
+            async with websockets.connect(
+                self.base_url,
+                extra_headers=headers
+            ) as websocket:
+                await self._handle_websocket_connection(websocket, toid, item_id, text)
+        except TypeError as e:
+            # 安全地检查异常信息
+            error_msg = self._safe_str(e)
+
+            if "extra_headers" in error_msg:
+                logger.warning("websockets库不支持extra_headers参数，使用兼容模式")
+                # 使用兼容模式，通过subprotocols传递部分头信息
+                async with websockets.connect(
+                    self.base_url,
+                    additional_headers=headers
+                ) as websocket:
+                    await self._handle_websocket_connection(websocket, toid, item_id, text)
+            else:
+                raise
+
+    async def _create_websocket_connection(self, headers):
+        """创建WebSocket连接，兼容不同版本的websockets库"""
+        try:
+            # 尝试使用extra_headers参数
+            return websockets.connect(
+                self.base_url,
+                extra_headers=headers
+            )
+        except TypeError as e:
+            # 安全地检查异常信息
+            error_msg = self._safe_str(e)
+
+            if "extra_headers" in error_msg:
+                logger.warning("websockets库不支持extra_headers参数，使用兼容模式")
+                # 使用additional_headers参数（较新版本）
+                try:
+                    return websockets.connect(
+                        self.base_url,
+                        additional_headers=headers
+                    )
+                except TypeError:
+                    # 如果都不支持，则不传递headers
+                    logger.warning("websockets库不支持headers参数，使用基础连接模式")
+                    return websockets.connect(self.base_url)
+            else:
+                raise
+
+    async def _handle_websocket_connection(self, websocket, toid, item_id, text):
+        """处理WebSocket连接的具体逻辑"""
+        await self.init(websocket)
+        await self.create_chat(websocket, toid, item_id)
+        async for message in websocket:
+            try:
+                logger.info(f"message: {message}")
+                message = json.loads(message)
+                cid = message["body"]["singleChatConversation"]["cid"]
+                cid = cid.split('@')[0]
+                await self.send_msg(websocket, cid, toid, text)
+                logger.info('send message')
+                return
+            except Exception as e:
+                pass
+
+    def is_chat_message(self, message):
+        """判断是否为用户聊天消息"""
+        try:
+            return (
+                isinstance(message, dict) 
+                and "1" in message 
+                and isinstance(message["1"], dict)
+                and "10" in message["1"]
+                and isinstance(message["1"]["10"], dict)
+                and "reminderContent" in message["1"]["10"]
+            )
+        except Exception:
+            return False
+
+    def is_sync_package(self, message_data):
+        """判断是否为同步包消息"""
+        try:
+            return (
+                isinstance(message_data, dict)
+                and "body" in message_data
+                and "syncPushPackage" in message_data["body"]
+                and "data" in message_data["body"]["syncPushPackage"]
+                and len(message_data["body"]["syncPushPackage"]["data"]) > 0
+            )
+        except Exception:
+            return False
+
+    async def create_session(self):
+        """创建aiohttp session"""
+        if not self.session:
+            # 创建带有cookies和headers的session
+            headers = DEFAULT_HEADERS.copy()
+            headers['cookie'] = self.cookies_str
+
+            self.session = aiohttp.ClientSession(
+                headers=headers,
+                timeout=aiohttp.ClientTimeout(total=30)
+            )
+
+    async def close_session(self):
+        """关闭aiohttp session"""
+        if self.session:
+            await self.session.close()
+            self.session = None
+
+    async def get_api_reply(self, msg_time, user_url, send_user_id, send_user_name, item_id, send_message, chat_id):
+        """调用API获取回复消息"""
+        try:
+            if not self.session:
+                await self.create_session()
+
+            api_config = AUTO_REPLY.get('api', {})
+            timeout = aiohttp.ClientTimeout(total=api_config.get('timeout', 10))
+            
+            payload = {
+                "cookie_id": self.cookie_id,
+                "msg_time": msg_time,
+                "user_url": user_url,
+                "send_user_id": send_user_id,
+                "send_user_name": send_user_name,
+                "item_id": item_id,
+                "send_message": send_message,
+                "chat_id": chat_id
+            }
+            
+            async with self.session.post(
+                api_config.get('url', 'http://localhost:8080/xianyu/reply'),
+                json=payload,
+                timeout=timeout
+            ) as response:
+                result = await response.json()
+                
+                # 将code转换为字符串进行比较，或者直接用数字比较
+                if str(result.get('code')) == '200' or result.get('code') == 200:
+                    send_msg = result.get('data', {}).get('send_msg')
+                    if send_msg:
+                        # 格式化消息中的占位符
+                        return send_msg.format(
+                            send_user_id=payload['send_user_id'],
+                            send_user_name=payload['send_user_name'],
+                            send_message=payload['send_message']
+                        )
+                    else:
+                        logger.warning("API返回成功但无回复消息")
+                        return None
+                else:
+                    logger.warning(f"API返回错误: {result.get('msg', '未知错误')}")
+                    return None
+                    
+        except asyncio.TimeoutError:
+            logger.error("API调用超时")
+            return None
+        except Exception as e:
+            logger.error(f"调用API出错: {self._safe_str(e)}")
+            return None
+
+    async def handle_message(self, message_data, websocket):
+        """处理所有类型的消息"""
+        try:
+            # 发送确认消息
+            try:
+                message = message_data
+                ack = {
+                    "code": 200,
+                    "headers": {
+                        "mid": message["headers"]["mid"] if "mid" in message["headers"] else generate_mid(),
+                        "sid": message["headers"]["sid"] if "sid" in message["headers"] else '',
+                    }
+                }
+                if 'app-key' in message["headers"]:
+                    ack["headers"]["app-key"] = message["headers"]["app-key"]
+                if 'ua' in message["headers"]:
+                    ack["headers"]["ua"] = message["headers"]["ua"]
+                if 'dt' in message["headers"]:
+                    ack["headers"]["dt"] = message["headers"]["dt"]
+                await websocket.send(json.dumps(ack))
+            except Exception as e:
+                pass
+
+            # 如果不是同步包消息，直接返回
+            if not self.is_sync_package(message_data):
+                return
+
+            # 获取并解密数据
+            sync_data = message_data["body"]["syncPushPackage"]["data"][0]
+            
+            # 检查是否有必要的字段
+            if "data" not in sync_data:
+                logger.debug("同步包中无data字段")
+                return
+
+            # 解密数据
+            message = None
+            try:
+                data = sync_data["data"]
+                try:
+                    data = base64.b64decode(data).decode("utf-8")
+                    parsed_data = json.loads(data)
+                    # 处理未加密的消息（如系统提示等）
+                    msg_time = time.strftime("%Y-%m-%d %H:%M:%S", time.localtime())
+                    if isinstance(parsed_data, dict) and 'chatType' in parsed_data:
+                        if 'operation' in parsed_data and 'content' in parsed_data['operation']:
+                            content = parsed_data['operation']['content']
+                            if 'sessionArouse' in content:
+                                # 处理系统引导消息
+                                logger.info(f"[{msg_time}] 【系统】小闲鱼智能提示:")
+                                if 'arouseChatScriptInfo' in content['sessionArouse']:
+                                    for qa in content['sessionArouse']['arouseChatScriptInfo']:
+                                        logger.info(f"  - {qa['chatScrip']}")
+                            elif 'contentType' in content:
+                                # 其他类型的未加密消息
+                                logger.debug(f"[{msg_time}] 【系统】其他类型消息: {content}")
+                        return
+                    else:
+                        # 如果不是系统消息，将解析的数据作为message
+                        message = parsed_data
+                except Exception as e:
+                    # 如果JSON解析失败，尝试解密
+                    decrypted_data = decrypt(data)
+                    message = json.loads(decrypted_data)
+            except Exception as e:
+                logger.error(f"消息解密失败: {self._safe_str(e)}")
+                return
+
+            # 确保message不为空
+            if message is None:
+                logger.error("消息解析后为空")
+                return
+
+            # 确保message是字典类型
+            if not isinstance(message, dict):
+                logger.error(f"消息格式错误，期望字典但得到: {type(message)}")
+                logger.debug(f"消息内容: {message}")
+                return
+
+            # 安全地获取用户ID
+            user_id = None
+            try:
+                message_1 = message.get("1")
+                if isinstance(message_1, str) and '@' in message_1:
+                    user_id = message_1.split('@')[0]
+                elif isinstance(message_1, dict):
+                    # 如果message['1']是字典，尝试其他方式提取user_id
+                    user_id = "unknown_user"
+                else:
+                    user_id = "unknown_user"
+            except Exception as e:
+                logger.warning(f"提取用户ID失败: {self._safe_str(e)}")
+                user_id = "unknown_user"
+
+            # 安全地获取商品ID
+            # item_id = None
+            # try:
+            #     # 尝试从reminderUrl中提取商品ID
+            #     message_1 = message.get("1")
+            #     if isinstance(message_1, dict):
+            #         reminder_data = message_1.get("10")
+            #         if isinstance(reminder_data, dict):
+            #             url_info = reminder_data.get("reminderUrl")
+            #             if isinstance(url_info, str) and "itemId=" in url_info:
+            #                 item_id = url_info.split("itemId=")[1].split("&")[0]
+            #                 logger.info(f"从reminderUrl提取商品ID: {item_id}")
+
+            #     # 如果没有提取到，使用辅助方法
+            #     if not item_id:
+            #         item_id = self.extract_item_id_from_message(message)
+
+            #     # 最后的fallback
+            #     if not item_id:
+            #         item_id = f"auto_{user_id}_{int(time.time())}"
+            #         logger.warning(f"无法提取商品ID，使用默认值: {item_id}")
+
+            # except Exception as e:
+            #     logger.error(f"提取商品ID时发生错误: {self._safe_str(e)}")
+            #     item_id = f"auto_{user_id}_{int(time.time())}"
+
+            # 安全地提取商品ID
+            item_id = None
+            try:
+                if "1" in message and isinstance(message["1"], dict) and "10" in message["1"] and isinstance(message["1"]["10"], dict):
+                    url_info = message["1"]["10"].get("reminderUrl", "")
+                    if isinstance(url_info, str) and "itemId=" in url_info:
+                        item_id = url_info.split("itemId=")[1].split("&")[0]
+
+                # 如果没有提取到，使用辅助方法
+                if not item_id:
+                    item_id = self.extract_item_id_from_message(message)
+
+                if not item_id:
+                    item_id = f"auto_{user_id}_{int(time.time())}"
+                    logger.warning(f"无法提取商品ID，使用默认值: {item_id}")
+
+            except Exception as e:
+                logger.error(f"提取商品ID时发生错误: {self._safe_str(e)}")
+                item_id = f"auto_{user_id}_{int(time.time())}"
+            # 处理订单状态消息
+            try:
+                logger.info(message)
+                msg_time = time.strftime("%Y-%m-%d %H:%M:%S", time.localtime())
+
+                # 安全地检查订单状态
+                red_reminder = None
+                if isinstance(message, dict) and "3" in message and isinstance(message["3"], dict):
+                    red_reminder = message["3"].get("redReminder")
+
+                if red_reminder == '等待买家付款':
+                    user_url = f'https://www.goofish.com/personal?userId={user_id}'
+                    logger.info(f'[{msg_time}] 【系统】等待买家 {user_url} 付款')
+                    return
+                elif red_reminder == '交易关闭':
+                    user_url = f'https://www.goofish.com/personal?userId={user_id}'
+                    logger.info(f'[{msg_time}] 【系统】买家 {user_url} 交易关闭')
+                    return
+                elif red_reminder == '等待卖家发货':
+                    user_url = f'https://www.goofish.com/personal?userId={user_id}'
+                    logger.info(f'[{msg_time}] 【系统】交易成功 {user_url} 等待卖家发货')
+                    # return
+            except:
+                pass
+
+            # 判断是否为聊天消息
+            if not self.is_chat_message(message):
+                logger.debug("非聊天消息")
+                return
+
+            # 处理聊天消息
+            try:
+                # 安全地提取聊天消息信息
+                if not (isinstance(message, dict) and "1" in message and isinstance(message["1"], dict)):
+                    logger.error("消息格式错误：缺少必要的字段结构")
+                    return
+
+                message_1 = message["1"]
+                if not isinstance(message_1.get("10"), dict):
+                    logger.error("消息格式错误：缺少消息详情字段")
+                    return
+
+                create_time = int(message_1.get("5", 0))
+                message_10 = message_1["10"]
+                send_user_name = message_10.get("senderNick", message_10.get("reminderTitle", "未知用户"))
+                send_user_id = message_10.get("senderUserId", "unknown")
+                send_message = message_10.get("reminderContent", "")
+
+                chat_id_raw = message_1.get("2", "")
+                chat_id = chat_id_raw.split('@')[0] if '@' in str(chat_id_raw) else str(chat_id_raw)
+
+            except Exception as e:
+                logger.error(f"提取聊天消息信息失败: {self._safe_str(e)}")
+                return
+
+            # 格式化消息时间
+            msg_time = time.strftime("%Y-%m-%d %H:%M:%S", time.localtime(create_time/1000))
+
+            # 人工接管模式已禁用，永远走自动模式
+            # if self.check_toggle_keywords(send_message):
+            #     is_manual = self.toggle_manual_mode(chat_id)
+            #     mode_str = "进入" if is_manual else "退出"
+            #     logger.info(f"[{msg_time}] 【系统】用户: {send_user_name} 的会话 {chat_id} [商品id: {item_id}] {mode_str}人工接管模式")
+            #     return
+
+            # 判断消息方向
+            if send_user_id == self.myid:
+                logger.info(f"[{msg_time}] 【手动发出】 商品({item_id}): {send_message}")
+
+
+                return
+            else:
+                logger.info(f"[{msg_time}] 【收到】用户: {send_user_name} (ID: {send_user_id}), 商品({item_id}): {send_message}")
+
+
+
+            # 人工接管模式已禁用，永远走自动模式
+            # if self.is_manual_mode(chat_id):
+            #     logger.info(f"[{msg_time}] 【系统】会话 {chat_id} 处于人工接管模式，不自动回复")
+            #     return
+
+            # 自动回复消息
+            if not AUTO_REPLY.get('enabled', True):
+                logger.info(f"[{msg_time}] 【系统】自动回复已禁用")
+                return
+
+            # 构造用户URL
+            user_url = f'https://www.goofish.com/personal?userId={send_user_id}'
+                
+            reply = None
+            # 判断是否启用API回复
+            if AUTO_REPLY.get('api', {}).get('enabled', False):
+                reply = await self.get_api_reply(
+                    msg_time, user_url, send_user_id, send_user_name,
+                    item_id, send_message, chat_id
+                )
+                if not reply:
+                    logger.error(f"[{msg_time}] 【API调用失败】用户: {send_user_name} (ID: {send_user_id}), 商品({item_id}): {send_message}")
+            
+            if send_message == '[我已拍下，待付款]':
+                logger.info(f'[{msg_time}] 系统消息不处理')
+                return
+            elif send_message == '[你关闭了订单，钱款已原路退返]':
+                logger.info(f'[{msg_time}] 系统消息不处理')
+                return
+            elif send_message == '[我已付款，等待你发货]':
+                logger.info(f'[{msg_time}] 【系统】买家已付款，准备自动发货')
+
+                # 构造用户URL
+                user_url = f'https://www.goofish.com/personal?userId={send_user_id}'
+
+                # 自动发货逻辑
+                try:
+                    # 设置默认标题（将通过API获取真实商品信息）
+                    item_title = "待获取商品信息"
+
+                    logger.info(f"准备自动发货: item_id={item_id}, item_title={item_title}")
+
+                    # 调用自动发货方法
+                    delivery_content = await self._auto_delivery(item_id, item_title)
+
+                    if delivery_content:
+                        # 发送发货内容给买家
+                        await self.send_msg(websocket, chat_id, send_user_id, delivery_content)
+                        logger.info(f'[{msg_time}] 【自动发货】已向 {user_url} 发送发货内容')
+                        await self.send_delivery_failure_notification(send_user_name, send_user_id, item_id, "发货成功")
+                    else:
+                        logger.warning(f'[{msg_time}] 【自动发货】未找到匹配的发货规则或获取发货内容失败')
+                        # 发送自动发货失败通知
+                        await self.send_delivery_failure_notification(send_user_name, send_user_id, item_id, "未找到匹配的发货规则或获取发货内容失败")
+
+                except Exception as e:
+                    logger.error(f"自动发货处理异常: {self._safe_str(e)}")
+                    # 发送自动发货异常通知
+                    await self.send_delivery_failure_notification(send_user_name, send_user_id, item_id, f"自动发货处理异常: {str(e)}")
+
+                return
+            elif send_message == '[已付款，待发货]':
+                logger.info(f'[{msg_time}] 【系统】买家已付款，准备自动发货')
+
+                # 构造用户URL
+                user_url = f'https://www.goofish.com/personal?userId={send_user_id}'
+
+                # 自动发货逻辑
+                try:
+                    # 设置默认标题（将通过API获取真实商品信息）
+                    item_title = "待获取商品信息"
+
+                    logger.info(f"准备自动发货: item_id={item_id}, item_title={item_title}")
+
+                    # 调用自动发货方法
+                    delivery_content = await self._auto_delivery(item_id, item_title)
+
+                    if delivery_content:
+                        # 发送发货内容给买家
+                        await self.send_msg(websocket, chat_id, send_user_id, delivery_content)
+                        logger.info(f'[{msg_time}] 【自动发货】已向 {user_url} 发送发货内容')
+                        await self.send_delivery_failure_notification(send_user_name, send_user_id, item_id, "发货成功")
+                    else:
+                        logger.warning(f'[{msg_time}] 【自动发货】未找到匹配的发货规则或获取发货内容失败')
+                        # 发送自动发货失败通知
+                        await self.send_delivery_failure_notification(send_user_name, send_user_id, item_id, "未找到匹配的发货规则或获取发货内容失败")
+
+                except Exception as e:
+                    logger.error(f"自动发货处理异常: {self._safe_str(e)}")
+                    # 发送自动发货异常通知
+                    await self.send_delivery_failure_notification(send_user_name, send_user_id, item_id, f"自动发货处理异常: {str(e)}")
+
+                return
+            # 记录回复来源
+            reply_source = 'API'  # 默认假设是API回复
+
+            # 如果API回复失败或未启用API，尝试使用默认回复
+            if not reply:
+                reply = await self.get_default_reply(send_user_name, send_user_id, send_message)
+                reply_source = '默认'  # 标记为默认回复
+
+            # 保存商品信息到数据库（记录通知时传递的item_id）
+            if item_id:
+                await self.save_item_info_to_db(item_id, None)
+            # 发送通知
+            await self.send_notification(send_user_name, send_user_id, send_message, item_id)
+
+            # 如果有回复内容，发送消息
+            if reply:
+                await self.send_msg(websocket, chat_id, send_user_id, reply)
+                # 记录发出的消息
+                msg_time = time.strftime("%Y-%m-%d %H:%M:%S", time.localtime())
+                logger.info(f"[{msg_time}] 【{reply_source}发出】用户: {send_user_name} (ID: {send_user_id}), 商品({item_id}): {reply}")
+            else:
+                msg_time = time.strftime("%Y-%m-%d %H:%M:%S", time.localtime())
+                logger.info(f"[{msg_time}] 【系统】未找到匹配的回复规则，不回复")
+            
+        except Exception as e:
+            logger.error(f"处理消息时发生错误: {self._safe_str(e)}")
+            logger.debug(f"原始消息: {message_data}")
+
+    async def main(self):
+        """主程序入口"""
+        try:
+            await self.create_session()  # 创建session
+            while True:
+                try:
+                    headers = WEBSOCKET_HEADERS.copy()
+                    headers['Cookie'] = self.cookies_str
+                    
+                    # 兼容不同版本的websockets库
+                    async with await self._create_websocket_connection(headers) as websocket:
+                        self.ws = websocket
+                        await self.init(websocket)
+
+                        # 启动心跳任务
+                        self.heartbeat_task = asyncio.create_task(self.heartbeat_loop(websocket))
+
+                        # 启动token刷新任务
+                        self.token_refresh_task = asyncio.create_task(self.token_refresh_loop())
+
+                        async for message in websocket:
+                            try:
+                                message_data = json.loads(message)
+                                
+                                # 处理心跳响应
+                                if await self.handle_heartbeat_response(message_data):
+                                    continue
+                                    
+                                # 处理其他消息
+                                await self.handle_message(message_data, websocket)
+                                
+                            except Exception as e:
+                                logger.error(f"处理消息出错: {self._safe_str(e)}")
+                                continue
+
+                except Exception as e:
+                    logger.error(f"WebSocket连接异常: {self._safe_str(e)}")
+                    if self.heartbeat_task:
+                        self.heartbeat_task.cancel()
+                    if self.token_refresh_task:
+                        self.token_refresh_task.cancel()
+                    await asyncio.sleep(5)  # 等待5秒后重试
+                    continue
+        finally:
+            await self.close_session()  # 确保关闭session
+
+    async def get_item_list_info(self, retry_count=0):
+        """获取商品信息，自动处理token失效的情况"""
+        if retry_count >= 3:  # 最多重试3次
+            logger.error("获取商品信息失败，重试次数过多")
+            return {"error": "获取商品信息失败，重试次数过多"}
+
+        # 如果是重试（retry_count > 0），强制刷新token
+        if retry_count > 0:
+            old_token = trans_cookies(self.cookies_str).get('_m_h5_tk', '').split('_')[0] if trans_cookies(self.cookies_str).get('_m_h5_tk') else ''
+            logger.info(f"重试第{retry_count}次，强制刷新token... 当前_m_h5_tk: {old_token}")
+            await self.refresh_token()
+            new_token = trans_cookies(self.cookies_str).get('_m_h5_tk', '').split('_')[0] if trans_cookies(self.cookies_str).get('_m_h5_tk') else ''
+            logger.info(f"重试刷新token完成，新的_m_h5_tk: {new_token}")
+        else:
+            # 确保使用最新的token（首次调用时的正常逻辑）
+            if not self.current_token or (time.time() - self.last_token_refresh_time) >= self.token_refresh_interval:
+                old_token = trans_cookies(self.cookies_str).get('_m_h5_tk', '').split('_')[0] if trans_cookies(self.cookies_str).get('_m_h5_tk') else ''
+                logger.info(f"Token过期或不存在，刷新token... 当前_m_h5_tk: {old_token}")
+                await self.refresh_token()
+                new_token = trans_cookies(self.cookies_str).get('_m_h5_tk', '').split('_')[0] if trans_cookies(self.cookies_str).get('_m_h5_tk') else ''
+                logger.info(f"Token刷新完成，新的_m_h5_tk: {new_token}")
+
+        # 确保session已创建
+        if not self.session:
+            await self.create_session()
+
+        params = {
+            'jsv': '2.7.2',
+            'appKey': '34839810',
+            't': str(int(time.time()) * 1000),
+            'sign': '',
+            'v': '1.0',
+            'type': 'originaljson',
+            'accountSite': 'xianyu',
+            'dataType': 'json',
+            'timeout': '20000',
+            'api': 'mtop.idle.web.xyh.item.list',
+            'sessionOption': 'AutoLoginOnly',
+            'spm_cnt': 'a21ybx.im.0.0',
+            'spm_pre': 'a21ybx.collection.menu.1.272b5141NafCNK'
+        }
+
+        data = {
+            'needGroupInfo': False,
+            'pageNumber': 1,
+            'pageSize': 20,
+            'groupName': '在售',
+            'groupId': '58877261',
+            'defaultGroup': True,
+            "userId": self.myid
+        }
+
+        # 始终从最新的cookies中获取_m_h5_tk token（刷新后cookies会被更新）
+        token = trans_cookies(self.cookies_str).get('_m_h5_tk', '').split('_')[0] if trans_cookies(self.cookies_str).get('_m_h5_tk') else ''
+
+        logger.warning(f"准备获取商品列表，token: {token}")
+        if token:
+            logger.debug(f"使用cookies中的_m_h5_tk token: {token}")
+        else:
+            logger.warning("cookies中没有找到_m_h5_tk token")
+
+        # 生成签名
+        data_val = json.dumps(data, separators=(',', ':'))
+        sign = generate_sign(params['t'], token, data_val)
+        params['sign'] = sign
+
+        try:
+            async with self.session.post(
+                'https://h5api.m.goofish.com/h5/mtop.idle.web.xyh.item.list/1.0/',
+                params=params,
+                data={'data': data_val}
+            ) as response:
+                res_json = await response.json()
+
+                logger.info(f"商品信息获取响应: {res_json}")
+
+                # 检查响应是否成功
+                if res_json.get('ret') and res_json['ret'][0] == 'SUCCESS::调用成功':
+                    items_data = res_json.get('data', {})
+                    # 从cardList中提取商品信息
+                    card_list = items_data.get('cardList', [])
+
+                    # 解析cardList中的商品信息
+                    items_list = []
+                    for card in card_list:
+                        card_data = card.get('cardData', {})
+                        if card_data:
+                            # 提取商品基本信息
+                            item_info = {
+                                'id': card_data.get('id', ''),
+                                'title': card_data.get('title', ''),
+                                'price': card_data.get('priceInfo', {}).get('price', ''),
+                                'price_text': card_data.get('priceInfo', {}).get('preText', '') + card_data.get('priceInfo', {}).get('price', ''),
+                                'category_id': card_data.get('categoryId', ''),
+                                'auction_type': card_data.get('auctionType', ''),
+                                'item_status': card_data.get('itemStatus', 0),
+                                'detail_url': card_data.get('detailUrl', ''),
+                                'pic_info': card_data.get('picInfo', {}),
+                                'detail_params': card_data.get('detailParams', {}),
+                                'track_params': card_data.get('trackParams', {}),
+                                'item_label_data': card_data.get('itemLabelDataVO', {}),
+                                'card_type': card.get('cardType', 0)
+                            }
+                            items_list.append(item_info)
+
+                    logger.info(f"成功获取到 {len(items_list)} 个商品")
+
+                    # 打印商品详细信息到控制台
+                    print("\n" + "="*80)
+                    print(f"📦 账号 {self.myid} 的商品列表 ({len(items_list)} 个商品)")
+                    print("="*80)
+
+                    for i, item in enumerate(items_list, 1):
+                        print(f"\n🔸 商品 {i}:")
+                        print(f"   商品ID: {item.get('id', 'N/A')}")
+                        print(f"   商品标题: {item.get('title', 'N/A')}")
+                        print(f"   价格: {item.get('price_text', 'N/A')}")
+                        print(f"   分类ID: {item.get('category_id', 'N/A')}")
+                        print(f"   商品状态: {item.get('item_status', 'N/A')}")
+                        print(f"   拍卖类型: {item.get('auction_type', 'N/A')}")
+                        print(f"   详情链接: {item.get('detail_url', 'N/A')}")
+                        if item.get('pic_info'):
+                            pic_info = item['pic_info']
+                            print(f"   图片信息: {pic_info.get('width', 'N/A')}x{pic_info.get('height', 'N/A')}")
+                            print(f"   图片链接: {pic_info.get('picUrl', 'N/A')}")
+                        print(f"   完整信息: {json.dumps(item, ensure_ascii=False, indent=2)}")
+
+                    print("\n" + "="*80)
+                    print("✅ 商品列表获取完成")
+                    print("="*80)
+
+                    # 自动保存商品信息到数据库
+                    if items_list:
+                        saved_count = await self.save_items_list_to_db(items_list)
+                        logger.info(f"已将 {saved_count} 个商品信息保存到数据库")
+
+                    return {
+                        "success": True,
+                        "total_count": len(items_list),
+                        "items": items_list,
+                        "saved_count": saved_count if items_list else 0,
+                        "raw_data": items_data  # 保留原始数据以备调试
+                    }
+                else:
+                    # 检查是否是token失效
+                    error_msg = res_json.get('ret', [''])[0] if res_json.get('ret') else ''
+                    if 'FAIL_SYS_TOKEN_EXOIRED' in error_msg or 'token' in error_msg.lower():
+                        logger.warning(f"Token失效，准备重试: {error_msg}")
+                        await asyncio.sleep(0.5)
+                        return await self.get_item_list_info(retry_count + 1)
+                    else:
+                        logger.error(f"获取商品信息失败: {res_json}")
+                        return {"error": f"获取商品信息失败: {error_msg}"}
+
+        except Exception as e:
+            logger.error(f"商品信息API请求异常: {self._safe_str(e)}")
+            await asyncio.sleep(0.5)
+            return await self.get_item_list_info(retry_count + 1)
+
+if __name__ == '__main__':
+    cookies_str = os.getenv('COOKIES_STR')
+    xianyuLive = XianyuLive(cookies_str)
+    asyncio.run(xianyuLive.main())
diff --git a/config.py b/config.py
new file mode 100644
index 0000000..2488bee
--- /dev/null
+++ b/config.py
@@ -0,0 +1,121 @@
+import os
+import yaml
+from typing import Dict, Any
+
+class Config:
+    """配置管理类
+    
+    用于加载和管理全局配置文件(global_config.yml)。
+    支持配置的读取、修改和保存。
+    """
+    
+    _instance = None
+    _config = {}
+
+    def __new__(cls):
+        if cls._instance is None:
+            cls._instance = super(Config, cls).__new__(cls)
+            cls._instance._load_config()
+        return cls._instance
+
+    def _load_config(self):
+        """加载配置文件
+        
+        从global_config.yml文件中加载配置信息。
+        如果文件不存在则抛出FileNotFoundError异常。
+        """
+        config_path = os.path.join(os.path.dirname(__file__), 'global_config.yml')
+        if not os.path.exists(config_path):
+            raise FileNotFoundError(f"配置文件不存在: {config_path}")
+
+        with open(config_path, 'r', encoding='utf-8') as f:
+            self._config = yaml.safe_load(f)
+
+    def get(self, key: str, default: Any = None) -> Any:
+        """获取配置项
+        
+        Args:
+            key: 配置项的键，支持点号分隔的多级键
+            default: 当配置项不存在时返回的默认值
+            
+        Returns:
+            配置项的值或默认值
+        """
+        keys = key.split('.')
+        value = self._config
+        for k in keys:
+            if isinstance(value, dict):
+                value = value.get(k)
+            else:
+                return default
+            if value is None:
+                return default
+        return value
+
+    def set(self, key: str, value: Any) -> None:
+        """设置配置项
+        
+        Args:
+            key: 配置项的键，支持点号分隔的多级键
+            value: 要设置的值
+        """
+        keys = key.split('.')
+        config = self._config
+        for k in keys[:-1]:
+            if k not in config:
+                config[k] = {}
+            config = config[k]
+        config[keys[-1]] = value
+
+    def save(self) -> None:
+        """保存配置到文件
+        
+        将当前配置保存回global_config.yml文件
+        """
+        config_path = os.path.join(os.path.dirname(__file__), 'global_config.yml')
+        with open(config_path, 'w', encoding='utf-8') as f:
+            yaml.safe_dump(self._config, f, allow_unicode=True, default_flow_style=False)
+
+    @property
+    def config(self) -> Dict[str, Any]:
+        """获取完整配置
+        
+        Returns:
+            包含所有配置项的字典
+        """
+        return self._config
+
+# 创建全局配置实例
+config = Config()
+
+# 导出常用配置项
+COOKIES_STR = config.get('COOKIES.value', '')
+COOKIES_LAST_UPDATE = config.get('COOKIES.last_update_time', '')
+WEBSOCKET_URL = config.get('WEBSOCKET_URL', 'wss://wss-goofish.dingtalk.com/')
+HEARTBEAT_INTERVAL = config.get('HEARTBEAT_INTERVAL', 15)
+HEARTBEAT_TIMEOUT = config.get('HEARTBEAT_TIMEOUT', 5)
+TOKEN_REFRESH_INTERVAL = config.get('TOKEN_REFRESH_INTERVAL', 3600)
+TOKEN_RETRY_INTERVAL = config.get('TOKEN_RETRY_INTERVAL', 300)
+MESSAGE_EXPIRE_TIME = config.get('MESSAGE_EXPIRE_TIME', 300000)
+API_ENDPOINTS = config.get('API_ENDPOINTS', {})
+DEFAULT_HEADERS = config.get('DEFAULT_HEADERS', {})
+WEBSOCKET_HEADERS = config.get('WEBSOCKET_HEADERS', {})
+APP_CONFIG = config.get('APP_CONFIG', {})
+AUTO_REPLY = config.get('AUTO_REPLY', {
+    'enabled': True,
+    'default_message': '亲爱的"{send_user_name}" 老板你好！所有宝贝都可以拍，秒发货的哈~不满意的话可以直接申请退款哈~',
+    'api': {
+        'enabled': False,
+        'url': 'http://localhost:8080/xianyu/reply',
+        'timeout': 10
+    }
+})
+MANUAL_MODE = config.get('MANUAL_MODE', {})
+LOG_CONFIG = config.get('LOG_CONFIG', {}) 
+_cookies_raw = config.get('COOKIES', [])
+if isinstance(_cookies_raw, list):
+    COOKIES_LIST = _cookies_raw
+else:
+    # 兼容旧格式，仅有 value 字段
+    val = _cookies_raw.get('value') if isinstance(_cookies_raw, dict) else None
+    COOKIES_LIST = [{'id': 'default', 'value': val}] if val else [] 
\ No newline at end of file
diff --git a/cookie_manager.py b/cookie_manager.py
new file mode 100644
index 0000000..f58c011
--- /dev/null
+++ b/cookie_manager.py
@@ -0,0 +1,157 @@
+from __future__ import annotations
+import asyncio
+from typing import Dict, List, Tuple, Optional
+from loguru import logger
+from db_manager import db_manager
+
+__all__ = ["CookieManager", "manager"]
+
+
+class CookieManager:
+    """管理多账号 Cookie 及其对应的 XianyuLive 任务和关键字"""
+
+    def __init__(self, loop: asyncio.AbstractEventLoop):
+        self.loop = loop
+        self.cookies: Dict[str, str] = {}
+        self.tasks: Dict[str, asyncio.Task] = {}
+        self.keywords: Dict[str, List[Tuple[str, str]]] = {}
+        self.cookie_status: Dict[str, bool] = {}  # 账号启用状态
+        self._load_from_db()
+
+    def _load_from_db(self):
+        """从数据库加载所有Cookie、关键字和状态"""
+        try:
+            # 加载所有Cookie
+            self.cookies = db_manager.get_all_cookies()
+            # 加载所有关键字
+            self.keywords = db_manager.get_all_keywords()
+            # 加载所有Cookie状态（默认启用）
+            self.cookie_status = db_manager.get_all_cookie_status()
+            # 为没有状态记录的Cookie设置默认启用状态
+            for cookie_id in self.cookies.keys():
+                if cookie_id not in self.cookie_status:
+                    self.cookie_status[cookie_id] = True
+            logger.info(f"从数据库加载了 {len(self.cookies)} 个Cookie、{len(self.keywords)} 组关键字和 {len(self.cookie_status)} 个状态记录")
+        except Exception as e:
+            logger.error(f"从数据库加载数据失败: {e}")
+
+    # ------------------------ 内部协程 ------------------------
+    async def _run_xianyu(self, cookie_id: str, cookie_value: str):
+        """在事件循环中启动 XianyuLive.main"""
+        from XianyuAutoAsync import XianyuLive  # 延迟导入，避免循环
+        try:
+            live = XianyuLive(cookie_value, cookie_id=cookie_id)
+            await live.main()
+        except asyncio.CancelledError:
+            logger.info(f"XianyuLive 任务已取消: {cookie_id}")
+        except Exception as e:
+            logger.error(f"XianyuLive 任务异常({cookie_id}): {e}")
+
+    async def _add_cookie_async(self, cookie_id: str, cookie_value: str):
+        if cookie_id in self.tasks:
+            raise ValueError("Cookie ID already exists")
+        self.cookies[cookie_id] = cookie_value
+        # 保存到数据库
+        db_manager.save_cookie(cookie_id, cookie_value)
+        task = self.loop.create_task(self._run_xianyu(cookie_id, cookie_value))
+        self.tasks[cookie_id] = task
+        logger.info(f"已启动账号任务: {cookie_id}")
+
+    async def _remove_cookie_async(self, cookie_id: str):
+        task = self.tasks.pop(cookie_id, None)
+        if task:
+            task.cancel()
+        self.cookies.pop(cookie_id, None)
+        self.keywords.pop(cookie_id, None)
+        # 从数据库删除
+        db_manager.delete_cookie(cookie_id)
+        logger.info(f"已移除账号: {cookie_id}")
+
+    # ------------------------ 对外线程安全接口 ------------------------
+    def add_cookie(self, cookie_id: str, cookie_value: str, kw_list: Optional[List[Tuple[str, str]]] = None):
+        """线程安全新增 Cookie 并启动任务"""
+        if kw_list is not None:
+            self.keywords[cookie_id] = kw_list
+        else:
+            self.keywords.setdefault(cookie_id, [])
+        try:
+            current_loop = asyncio.get_running_loop()
+        except RuntimeError:
+            current_loop = None
+
+        if current_loop and current_loop == self.loop:
+            # 同一事件循环中，直接调度
+            return self.loop.create_task(self._add_cookie_async(cookie_id, cookie_value))
+        else:
+            fut = asyncio.run_coroutine_threadsafe(self._add_cookie_async(cookie_id, cookie_value), self.loop)
+            return fut.result()
+
+    def remove_cookie(self, cookie_id: str):
+        try:
+            current_loop = asyncio.get_running_loop()
+        except RuntimeError:
+            current_loop = None
+
+        if current_loop and current_loop == self.loop:
+            return self.loop.create_task(self._remove_cookie_async(cookie_id))
+        else:
+            fut = asyncio.run_coroutine_threadsafe(self._remove_cookie_async(cookie_id), self.loop)
+            return fut.result()
+
+    # 更新 Cookie 值
+    def update_cookie(self, cookie_id: str, new_value: str):
+        """替换指定账号的 Cookie 并重启任务"""
+        async def _update():
+            # 先移除
+            if cookie_id in self.tasks:
+                await self._remove_cookie_async(cookie_id)
+            # 再添加
+            await self._add_cookie_async(cookie_id, new_value)
+
+        try:
+            current_loop = asyncio.get_running_loop()
+        except RuntimeError:
+            current_loop = None
+
+        if current_loop and current_loop == self.loop:
+            return self.loop.create_task(_update())
+        else:
+            fut = asyncio.run_coroutine_threadsafe(_update(), self.loop)
+            return fut.result()
+
+    def update_keywords(self, cookie_id: str, kw_list: List[Tuple[str, str]]):
+        """线程安全更新关键字"""
+        self.keywords[cookie_id] = kw_list
+        # 保存到数据库
+        db_manager.save_keywords(cookie_id, kw_list)
+        logger.info(f"更新关键字: {cookie_id} -> {len(kw_list)} 条")
+
+    # 查询接口
+    def list_cookies(self):
+        return list(self.cookies.keys())
+
+    def get_keywords(self, cookie_id: str) -> List[Tuple[str, str]]:
+        return self.keywords.get(cookie_id, [])
+
+    def update_cookie_status(self, cookie_id: str, enabled: bool):
+        """更新Cookie的启用/禁用状态"""
+        if cookie_id not in self.cookies:
+            raise ValueError(f"Cookie ID {cookie_id} 不存在")
+
+        self.cookie_status[cookie_id] = enabled
+        # 保存到数据库
+        db_manager.save_cookie_status(cookie_id, enabled)
+        logger.info(f"更新Cookie状态: {cookie_id} -> {'启用' if enabled else '禁用'}")
+
+    def get_cookie_status(self, cookie_id: str) -> bool:
+        """获取Cookie的启用状态"""
+        return self.cookie_status.get(cookie_id, True)  # 默认启用
+
+    def get_enabled_cookies(self) -> Dict[str, str]:
+        """获取所有启用的Cookie"""
+        return {cid: value for cid, value in self.cookies.items()
+                if self.cookie_status.get(cid, True)}
+
+
+# 在 Start.py 中会把此变量赋值为具体实例
+manager: Optional[CookieManager] = None 
\ No newline at end of file
diff --git a/data/xianyu_data.db b/data/xianyu_data.db
new file mode 100644
index 0000000..ac15ada
Binary files /dev/null and b/data/xianyu_data.db differ
diff --git a/db_manager.py b/db_manager.py
new file mode 100644
index 0000000..24a05bc
--- /dev/null
+++ b/db_manager.py
@@ -0,0 +1,1823 @@
+import sqlite3
+import os
+import threading
+import hashlib
+import time
+import json
+from typing import List, Tuple, Dict, Optional
+from loguru import logger
+
+class DBManager:
+    """SQLite数据库管理，持久化存储Cookie和关键字"""
+    
+    def __init__(self, db_path: str = None):
+        """初始化数据库连接和表结构"""
+        # 支持环境变量配置数据库路径
+        if db_path is None:
+            db_path = os.getenv('DB_PATH', 'xianyu_data.db')
+
+        # 确保数据目录存在并有正确权限
+        db_dir = os.path.dirname(db_path)
+        if db_dir and not os.path.exists(db_dir):
+            try:
+                os.makedirs(db_dir, mode=0o755, exist_ok=True)
+                logger.info(f"创建数据目录: {db_dir}")
+            except PermissionError as e:
+                logger.error(f"创建数据目录失败，权限不足: {e}")
+                # 尝试使用当前目录
+                db_path = os.path.basename(db_path)
+                logger.warning(f"使用当前目录作为数据库路径: {db_path}")
+            except Exception as e:
+                logger.error(f"创建数据目录失败: {e}")
+                raise
+
+        # 检查目录权限
+        if db_dir and os.path.exists(db_dir):
+            if not os.access(db_dir, os.W_OK):
+                logger.error(f"数据目录没有写权限: {db_dir}")
+                # 尝试使用当前目录
+                db_path = os.path.basename(db_path)
+                logger.warning(f"使用当前目录作为数据库路径: {db_path}")
+
+        self.db_path = db_path
+        logger.info(f"数据库路径: {self.db_path}")
+        self.conn = None
+        self.lock = threading.RLock()  # 使用可重入锁保护数据库操作
+        self.init_db()
+    
+    def init_db(self):
+        """初始化数据库表结构"""
+        try:
+            self.conn = sqlite3.connect(self.db_path, check_same_thread=False)
+            cursor = self.conn.cursor()
+            
+            # 创建cookies表
+            cursor.execute('''
+            CREATE TABLE IF NOT EXISTS cookies (
+                id TEXT PRIMARY KEY,
+                value TEXT NOT NULL,
+                created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP
+            )
+            ''')
+            
+            # 创建keywords表
+            cursor.execute('''
+            CREATE TABLE IF NOT EXISTS keywords (
+                cookie_id TEXT,
+                keyword TEXT,
+                reply TEXT,
+                PRIMARY KEY (cookie_id, keyword),
+                FOREIGN KEY (cookie_id) REFERENCES cookies(id) ON DELETE CASCADE
+            )
+            ''')
+
+            # 创建cookie_status表
+            cursor.execute('''
+            CREATE TABLE IF NOT EXISTS cookie_status (
+                cookie_id TEXT PRIMARY KEY,
+                enabled BOOLEAN DEFAULT TRUE,
+                updated_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP,
+                FOREIGN KEY (cookie_id) REFERENCES cookies(id) ON DELETE CASCADE
+            )
+            ''')
+
+            # 创建卡券表
+            cursor.execute('''
+            CREATE TABLE IF NOT EXISTS cards (
+                id INTEGER PRIMARY KEY AUTOINCREMENT,
+                name TEXT NOT NULL,
+                type TEXT NOT NULL CHECK (type IN ('api', 'text', 'data')),
+                api_config TEXT,
+                text_content TEXT,
+                data_content TEXT,
+                description TEXT,
+                enabled BOOLEAN DEFAULT TRUE,
+                created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP,
+                updated_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP
+            )
+            ''')
+
+            # 创建商品信息表
+            cursor.execute('''
+            CREATE TABLE IF NOT EXISTS item_info (
+                id INTEGER PRIMARY KEY AUTOINCREMENT,
+                cookie_id TEXT NOT NULL,
+                item_id TEXT NOT NULL,
+                item_title TEXT,
+                item_description TEXT,
+                item_category TEXT,
+                item_price TEXT,
+                item_detail TEXT,
+                created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP,
+                updated_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP,
+                FOREIGN KEY (cookie_id) REFERENCES cookies(id) ON DELETE CASCADE,
+                UNIQUE(cookie_id, item_id)
+            )
+            ''')
+
+            # 创建自动发货规则表
+            cursor.execute('''
+            CREATE TABLE IF NOT EXISTS delivery_rules (
+                id INTEGER PRIMARY KEY AUTOINCREMENT,
+                keyword TEXT NOT NULL,
+                card_id INTEGER NOT NULL,
+                delivery_count INTEGER DEFAULT 1,
+                enabled BOOLEAN DEFAULT TRUE,
+                description TEXT,
+                delivery_times INTEGER DEFAULT 0,
+                created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP,
+                updated_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP,
+                FOREIGN KEY (card_id) REFERENCES cards(id) ON DELETE CASCADE
+            )
+            ''')
+
+            # 创建默认回复表
+            cursor.execute('''
+            CREATE TABLE IF NOT EXISTS default_replies (
+                cookie_id TEXT PRIMARY KEY,
+                enabled BOOLEAN DEFAULT FALSE,
+                reply_content TEXT,
+                created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP,
+                updated_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP,
+                FOREIGN KEY (cookie_id) REFERENCES cookies(id) ON DELETE CASCADE
+            )
+            ''')
+
+            # 创建通知渠道表
+            cursor.execute('''
+            CREATE TABLE IF NOT EXISTS notification_channels (
+                id INTEGER PRIMARY KEY AUTOINCREMENT,
+                name TEXT NOT NULL,
+                type TEXT NOT NULL CHECK (type IN ('qq')),
+                config TEXT NOT NULL,
+                enabled BOOLEAN DEFAULT TRUE,
+                created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP,
+                updated_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP
+            )
+            ''')
+
+            # 创建消息通知配置表
+            cursor.execute('''
+            CREATE TABLE IF NOT EXISTS message_notifications (
+                id INTEGER PRIMARY KEY AUTOINCREMENT,
+                cookie_id TEXT NOT NULL,
+                channel_id INTEGER NOT NULL,
+                enabled BOOLEAN DEFAULT TRUE,
+                created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP,
+                updated_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP,
+                FOREIGN KEY (cookie_id) REFERENCES cookies(id) ON DELETE CASCADE,
+                FOREIGN KEY (channel_id) REFERENCES notification_channels(id) ON DELETE CASCADE,
+                UNIQUE(cookie_id, channel_id)
+            )
+            ''')
+
+            # 创建系统设置表
+            cursor.execute('''
+            CREATE TABLE IF NOT EXISTS system_settings (
+                key TEXT PRIMARY KEY,
+                value TEXT NOT NULL,
+                description TEXT,
+                updated_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP
+            )
+            ''')
+
+            # 插入默认系统设置
+            cursor.execute('''
+            INSERT OR IGNORE INTO system_settings (key, value, description) VALUES
+            ('admin_password_hash', ?, '管理员密码哈希'),
+            ('theme_color', 'blue', '主题颜色')
+            ''', (hashlib.sha256("admin123".encode()).hexdigest(),))
+
+            self.conn.commit()
+            logger.info(f"数据库初始化成功: {self.db_path}")
+        except Exception as e:
+            logger.error(f"数据库初始化失败: {e}")
+            if self.conn:
+                self.conn.close()
+            raise
+    
+    def close(self):
+        """关闭数据库连接"""
+        if self.conn:
+            self.conn.close()
+            self.conn = None
+    
+    def get_connection(self):
+        """获取数据库连接，如果已关闭则重新连接"""
+        if self.conn is None:
+            self.conn = sqlite3.connect(self.db_path, check_same_thread=False)
+        return self.conn
+    
+    # -------------------- Cookie操作 --------------------
+    def save_cookie(self, cookie_id: str, cookie_value: str) -> bool:
+        """保存Cookie到数据库，如存在则更新"""
+        with self.lock:
+            try:
+                cursor = self.conn.cursor()
+                cursor.execute(
+                    "INSERT OR REPLACE INTO cookies (id, value) VALUES (?, ?)",
+                    (cookie_id, cookie_value)
+                )
+                self.conn.commit()
+                logger.debug(f"Cookie保存成功: {cookie_id}")
+                return True
+            except Exception as e:
+                logger.error(f"Cookie保存失败: {e}")
+                self.conn.rollback()
+                return False
+    
+    def delete_cookie(self, cookie_id: str) -> bool:
+        """从数据库删除Cookie及其关键字"""
+        with self.lock:
+            try:
+                cursor = self.conn.cursor()
+                # 删除关联的关键字
+                cursor.execute("DELETE FROM keywords WHERE cookie_id = ?", (cookie_id,))
+                # 删除Cookie
+                cursor.execute("DELETE FROM cookies WHERE id = ?", (cookie_id,))
+                self.conn.commit()
+                logger.debug(f"Cookie删除成功: {cookie_id}")
+                return True
+            except Exception as e:
+                logger.error(f"Cookie删除失败: {e}")
+                self.conn.rollback()
+                return False
+    
+    def get_cookie(self, cookie_id: str) -> Optional[str]:
+        """获取指定Cookie值"""
+        with self.lock:
+            try:
+                cursor = self.conn.cursor()
+                cursor.execute("SELECT value FROM cookies WHERE id = ?", (cookie_id,))
+                result = cursor.fetchone()
+                return result[0] if result else None
+            except Exception as e:
+                logger.error(f"获取Cookie失败: {e}")
+                return None
+    
+    def get_all_cookies(self) -> Dict[str, str]:
+        """获取所有Cookie"""
+        with self.lock:
+            try:
+                cursor = self.conn.cursor()
+                cursor.execute("SELECT id, value FROM cookies")
+                return {row[0]: row[1] for row in cursor.fetchall()}
+            except Exception as e:
+                logger.error(f"获取所有Cookie失败: {e}")
+                return {}
+
+    def get_cookie_by_id(self, cookie_id: str) -> Optional[Dict[str, str]]:
+        """根据ID获取Cookie信息
+
+        Args:
+            cookie_id: Cookie ID
+
+        Returns:
+            Dict包含cookie信息，包括cookies_str字段，如果不存在返回None
+        """
+        with self.lock:
+            try:
+                cursor = self.conn.cursor()
+                cursor.execute("SELECT id, value, created_at FROM cookies WHERE id = ?", (cookie_id,))
+                result = cursor.fetchone()
+                if result:
+                    return {
+                        'id': result[0],
+                        'cookies_str': result[1],  # 使用cookies_str字段名以匹配调用方期望
+                        'value': result[1],        # 保持向后兼容
+                        'created_at': result[2]
+                    }
+                return None
+            except Exception as e:
+                logger.error(f"根据ID获取Cookie失败: {e}")
+                return None
+    
+    # -------------------- 关键字操作 --------------------
+    def save_keywords(self, cookie_id: str, keywords: List[Tuple[str, str]]) -> bool:
+        """保存关键字列表，先删除旧数据再插入新数据"""
+        with self.lock:
+            try:
+                cursor = self.conn.cursor()
+
+                # 先删除该cookie_id的所有关键字
+                cursor.execute("DELETE FROM keywords WHERE cookie_id = ?", (cookie_id,))
+
+                # 插入新关键字
+                for keyword, reply in keywords:
+                    cursor.execute(
+                        "INSERT INTO keywords (cookie_id, keyword, reply) VALUES (?, ?, ?)",
+                        (cookie_id, keyword, reply)
+                    )
+
+                self.conn.commit()
+                logger.info(f"关键字保存成功: {cookie_id}, {len(keywords)}条")
+                return True
+            except Exception as e:
+                logger.error(f"关键字保存失败: {e}")
+                self.conn.rollback()
+                return False
+    
+    def get_keywords(self, cookie_id: str) -> List[Tuple[str, str]]:
+        """获取指定Cookie的关键字列表"""
+        with self.lock:
+            try:
+                cursor = self.conn.cursor()
+                cursor.execute(
+                    "SELECT keyword, reply FROM keywords WHERE cookie_id = ?",
+                    (cookie_id,)
+                )
+                return [(row[0], row[1]) for row in cursor.fetchall()]
+            except Exception as e:
+                logger.error(f"获取关键字失败: {e}")
+                return []
+    
+    def get_all_keywords(self) -> Dict[str, List[Tuple[str, str]]]:
+        """获取所有Cookie的关键字"""
+        with self.lock:
+            try:
+                cursor = self.conn.cursor()
+                cursor.execute("SELECT cookie_id, keyword, reply FROM keywords")
+
+                result = {}
+                for row in cursor.fetchall():
+                    cookie_id, keyword, reply = row
+                    if cookie_id not in result:
+                        result[cookie_id] = []
+                    result[cookie_id].append((keyword, reply))
+
+                return result
+            except Exception as e:
+                logger.error(f"获取所有关键字失败: {e}")
+                return {}
+
+    def save_cookie_status(self, cookie_id: str, enabled: bool):
+        """保存Cookie的启用状态"""
+        with self.lock:
+            try:
+                cursor = self.conn.cursor()
+                cursor.execute('''
+                INSERT OR REPLACE INTO cookie_status (cookie_id, enabled, updated_at)
+                VALUES (?, ?, CURRENT_TIMESTAMP)
+                ''', (cookie_id, enabled))
+                self.conn.commit()
+                logger.debug(f"保存Cookie状态: {cookie_id} -> {'启用' if enabled else '禁用'}")
+            except Exception as e:
+                logger.error(f"保存Cookie状态失败: {e}")
+                raise
+
+    def get_cookie_status(self, cookie_id: str) -> bool:
+        """获取Cookie的启用状态"""
+        with self.lock:
+            try:
+                cursor = self.conn.cursor()
+                cursor.execute('SELECT enabled FROM cookie_status WHERE cookie_id = ?', (cookie_id,))
+                result = cursor.fetchone()
+                return bool(result[0]) if result else True  # 默认启用
+            except Exception as e:
+                logger.error(f"获取Cookie状态失败: {e}")
+                return True  # 出错时默认启用
+
+    def get_all_cookie_status(self) -> Dict[str, bool]:
+        """获取所有Cookie的启用状态"""
+        with self.lock:
+            try:
+                cursor = self.conn.cursor()
+                cursor.execute('SELECT cookie_id, enabled FROM cookie_status')
+
+                result = {}
+                for row in cursor.fetchall():
+                    cookie_id, enabled = row
+                    result[cookie_id] = bool(enabled)
+
+                return result
+            except Exception as e:
+                logger.error(f"获取所有Cookie状态失败: {e}")
+                return {}
+
+    # -------------------- 默认回复操作 --------------------
+    def save_default_reply(self, cookie_id: str, enabled: bool, reply_content: str = None):
+        """保存默认回复设置"""
+        with self.lock:
+            try:
+                cursor = self.conn.cursor()
+                cursor.execute('''
+                INSERT OR REPLACE INTO default_replies (cookie_id, enabled, reply_content, updated_at)
+                VALUES (?, ?, ?, CURRENT_TIMESTAMP)
+                ''', (cookie_id, enabled, reply_content))
+                self.conn.commit()
+                logger.debug(f"保存默认回复设置: {cookie_id} -> {'启用' if enabled else '禁用'}")
+            except Exception as e:
+                logger.error(f"保存默认回复设置失败: {e}")
+                raise
+
+    def get_default_reply(self, cookie_id: str) -> Optional[Dict[str, any]]:
+        """获取指定账号的默认回复设置"""
+        with self.lock:
+            try:
+                cursor = self.conn.cursor()
+                cursor.execute('''
+                SELECT enabled, reply_content FROM default_replies WHERE cookie_id = ?
+                ''', (cookie_id,))
+                result = cursor.fetchone()
+                if result:
+                    enabled, reply_content = result
+                    return {
+                        'enabled': bool(enabled),
+                        'reply_content': reply_content or ''
+                    }
+                return None
+            except Exception as e:
+                logger.error(f"获取默认回复设置失败: {e}")
+                return None
+
+    def get_all_default_replies(self) -> Dict[str, Dict[str, any]]:
+        """获取所有账号的默认回复设置"""
+        with self.lock:
+            try:
+                cursor = self.conn.cursor()
+                cursor.execute('SELECT cookie_id, enabled, reply_content FROM default_replies')
+
+                result = {}
+                for row in cursor.fetchall():
+                    cookie_id, enabled, reply_content = row
+                    result[cookie_id] = {
+                        'enabled': bool(enabled),
+                        'reply_content': reply_content or ''
+                    }
+
+                return result
+            except Exception as e:
+                logger.error(f"获取所有默认回复设置失败: {e}")
+                return {}
+
+    def delete_default_reply(self, cookie_id: str) -> bool:
+        """删除指定账号的默认回复设置"""
+        with self.lock:
+            try:
+                cursor = self.conn.cursor()
+                cursor.execute("DELETE FROM default_replies WHERE cookie_id = ?", (cookie_id,))
+                self.conn.commit()
+                logger.debug(f"删除默认回复设置: {cookie_id}")
+                return True
+            except Exception as e:
+                logger.error(f"删除默认回复设置失败: {e}")
+                self.conn.rollback()
+                return False
+
+    # -------------------- 通知渠道操作 --------------------
+    def create_notification_channel(self, name: str, channel_type: str, config: str) -> int:
+        """创建通知渠道"""
+        with self.lock:
+            try:
+                cursor = self.conn.cursor()
+                cursor.execute('''
+                INSERT INTO notification_channels (name, type, config)
+                VALUES (?, ?, ?)
+                ''', (name, channel_type, config))
+                self.conn.commit()
+                channel_id = cursor.lastrowid
+                logger.debug(f"创建通知渠道: {name} (ID: {channel_id})")
+                return channel_id
+            except Exception as e:
+                logger.error(f"创建通知渠道失败: {e}")
+                self.conn.rollback()
+                raise
+
+    def get_notification_channels(self) -> List[Dict[str, any]]:
+        """获取所有通知渠道"""
+        with self.lock:
+            try:
+                cursor = self.conn.cursor()
+                cursor.execute('''
+                SELECT id, name, type, config, enabled, created_at, updated_at
+                FROM notification_channels
+                ORDER BY created_at DESC
+                ''')
+
+                channels = []
+                for row in cursor.fetchall():
+                    channels.append({
+                        'id': row[0],
+                        'name': row[1],
+                        'type': row[2],
+                        'config': row[3],
+                        'enabled': bool(row[4]),
+                        'created_at': row[5],
+                        'updated_at': row[6]
+                    })
+
+                return channels
+            except Exception as e:
+                logger.error(f"获取通知渠道失败: {e}")
+                return []
+
+    def get_notification_channel(self, channel_id: int) -> Optional[Dict[str, any]]:
+        """获取指定通知渠道"""
+        with self.lock:
+            try:
+                cursor = self.conn.cursor()
+                cursor.execute('''
+                SELECT id, name, type, config, enabled, created_at, updated_at
+                FROM notification_channels WHERE id = ?
+                ''', (channel_id,))
+
+                row = cursor.fetchone()
+                if row:
+                    return {
+                        'id': row[0],
+                        'name': row[1],
+                        'type': row[2],
+                        'config': row[3],
+                        'enabled': bool(row[4]),
+                        'created_at': row[5],
+                        'updated_at': row[6]
+                    }
+                return None
+            except Exception as e:
+                logger.error(f"获取通知渠道失败: {e}")
+                return None
+
+    def update_notification_channel(self, channel_id: int, name: str, config: str, enabled: bool = True) -> bool:
+        """更新通知渠道"""
+        with self.lock:
+            try:
+                cursor = self.conn.cursor()
+                cursor.execute('''
+                UPDATE notification_channels
+                SET name = ?, config = ?, enabled = ?, updated_at = CURRENT_TIMESTAMP
+                WHERE id = ?
+                ''', (name, config, enabled, channel_id))
+                self.conn.commit()
+                logger.debug(f"更新通知渠道: {channel_id}")
+                return cursor.rowcount > 0
+            except Exception as e:
+                logger.error(f"更新通知渠道失败: {e}")
+                self.conn.rollback()
+                return False
+
+    def delete_notification_channel(self, channel_id: int) -> bool:
+        """删除通知渠道"""
+        with self.lock:
+            try:
+                cursor = self.conn.cursor()
+                cursor.execute("DELETE FROM notification_channels WHERE id = ?", (channel_id,))
+                self.conn.commit()
+                logger.debug(f"删除通知渠道: {channel_id}")
+                return cursor.rowcount > 0
+            except Exception as e:
+                logger.error(f"删除通知渠道失败: {e}")
+                self.conn.rollback()
+                return False
+
+    # -------------------- 消息通知配置操作 --------------------
+    def set_message_notification(self, cookie_id: str, channel_id: int, enabled: bool = True) -> bool:
+        """设置账号的消息通知"""
+        with self.lock:
+            try:
+                cursor = self.conn.cursor()
+                cursor.execute('''
+                INSERT OR REPLACE INTO message_notifications (cookie_id, channel_id, enabled)
+                VALUES (?, ?, ?)
+                ''', (cookie_id, channel_id, enabled))
+                self.conn.commit()
+                logger.debug(f"设置消息通知: {cookie_id} -> {channel_id}")
+                return True
+            except Exception as e:
+                logger.error(f"设置消息通知失败: {e}")
+                self.conn.rollback()
+                return False
+
+    def get_account_notifications(self, cookie_id: str) -> List[Dict[str, any]]:
+        """获取账号的通知配置"""
+        with self.lock:
+            try:
+                cursor = self.conn.cursor()
+                cursor.execute('''
+                SELECT mn.id, mn.channel_id, mn.enabled, nc.name, nc.type, nc.config
+                FROM message_notifications mn
+                JOIN notification_channels nc ON mn.channel_id = nc.id
+                WHERE mn.cookie_id = ? AND nc.enabled = 1
+                ORDER BY mn.id
+                ''', (cookie_id,))
+
+                notifications = []
+                for row in cursor.fetchall():
+                    notifications.append({
+                        'id': row[0],
+                        'channel_id': row[1],
+                        'enabled': bool(row[2]),
+                        'channel_name': row[3],
+                        'channel_type': row[4],
+                        'channel_config': row[5]
+                    })
+
+                return notifications
+            except Exception as e:
+                logger.error(f"获取账号通知配置失败: {e}")
+                return []
+
+    def get_all_message_notifications(self) -> Dict[str, List[Dict[str, any]]]:
+        """获取所有账号的通知配置"""
+        with self.lock:
+            try:
+                cursor = self.conn.cursor()
+                cursor.execute('''
+                SELECT mn.cookie_id, mn.id, mn.channel_id, mn.enabled, nc.name, nc.type, nc.config
+                FROM message_notifications mn
+                JOIN notification_channels nc ON mn.channel_id = nc.id
+                WHERE nc.enabled = 1
+                ORDER BY mn.cookie_id, mn.id
+                ''')
+
+                result = {}
+                for row in cursor.fetchall():
+                    cookie_id = row[0]
+                    if cookie_id not in result:
+                        result[cookie_id] = []
+
+                    result[cookie_id].append({
+                        'id': row[1],
+                        'channel_id': row[2],
+                        'enabled': bool(row[3]),
+                        'channel_name': row[4],
+                        'channel_type': row[5],
+                        'channel_config': row[6]
+                    })
+
+                return result
+            except Exception as e:
+                logger.error(f"获取所有消息通知配置失败: {e}")
+                return {}
+
+    def delete_message_notification(self, notification_id: int) -> bool:
+        """删除消息通知配置"""
+        with self.lock:
+            try:
+                cursor = self.conn.cursor()
+                cursor.execute("DELETE FROM message_notifications WHERE id = ?", (notification_id,))
+                self.conn.commit()
+                logger.debug(f"删除消息通知配置: {notification_id}")
+                return cursor.rowcount > 0
+            except Exception as e:
+                logger.error(f"删除消息通知配置失败: {e}")
+                self.conn.rollback()
+                return False
+
+    def delete_account_notifications(self, cookie_id: str) -> bool:
+        """删除账号的所有消息通知配置"""
+        with self.lock:
+            try:
+                cursor = self.conn.cursor()
+                cursor.execute("DELETE FROM message_notifications WHERE cookie_id = ?", (cookie_id,))
+                self.conn.commit()
+                logger.debug(f"删除账号通知配置: {cookie_id}")
+                return cursor.rowcount > 0
+            except Exception as e:
+                logger.error(f"删除账号通知配置失败: {e}")
+                self.conn.rollback()
+                return False
+
+    # -------------------- 备份和恢复操作 --------------------
+    def export_backup(self) -> Dict[str, any]:
+        """导出系统备份数据"""
+        with self.lock:
+            try:
+                cursor = self.conn.cursor()
+                backup_data = {
+                    'version': '1.0',
+                    'timestamp': time.time(),
+                    'data': {}
+                }
+
+                # 备份所有表的数据
+                tables = [
+                    'cookies', 'keywords', 'cookie_status', 'cards',
+                    'delivery_rules', 'default_replies', 'notification_channels',
+                    'message_notifications', 'system_settings', 'item_info'
+                ]
+
+                for table in tables:
+                    cursor.execute(f"SELECT * FROM {table}")
+                    columns = [description[0] for description in cursor.description]
+                    rows = cursor.fetchall()
+
+                    backup_data['data'][table] = {
+                        'columns': columns,
+                        'rows': [list(row) for row in rows]
+                    }
+
+                logger.info(f"导出备份成功，包含 {len(tables)} 个表")
+                return backup_data
+
+            except Exception as e:
+                logger.error(f"导出备份失败: {e}")
+                raise
+
+    def import_backup(self, backup_data: Dict[str, any]) -> bool:
+        """导入系统备份数据"""
+        with self.lock:
+            try:
+                # 验证备份数据格式
+                if not isinstance(backup_data, dict) or 'data' not in backup_data:
+                    raise ValueError("备份数据格式无效")
+
+                # 开始事务
+                cursor = self.conn.cursor()
+                cursor.execute("BEGIN TRANSACTION")
+
+                # 清空现有数据（除了管理员密码）
+                # 注意：按照外键依赖关系的逆序删除
+                tables = [
+                    'message_notifications', 'notification_channels', 'default_replies',
+                    'delivery_rules', 'cards', 'item_info', 'cookie_status', 'keywords', 'cookies'
+                ]
+
+                for table in tables:
+                    cursor.execute(f"DELETE FROM {table}")
+
+                # 清空系统设置（保留管理员密码）
+                cursor.execute("DELETE FROM system_settings WHERE key != 'admin_password_hash'")
+
+                # 导入数据
+                data = backup_data['data']
+                for table_name, table_data in data.items():
+                    if table_name not in ['cookies', 'keywords', 'cookie_status', 'cards',
+                                        'delivery_rules', 'default_replies', 'notification_channels',
+                                        'message_notifications', 'system_settings', 'item_info']:
+                        continue
+
+                    columns = table_data['columns']
+                    rows = table_data['rows']
+
+                    if not rows:
+                        continue
+
+                    # 构建插入语句
+                    placeholders = ','.join(['?' for _ in columns])
+
+                    if table_name == 'system_settings':
+                        # 系统设置需要特殊处理，避免覆盖管理员密码
+                        for row in rows:
+                            if len(row) >= 1 and row[0] != 'admin_password_hash':
+                                cursor.execute(f"INSERT INTO {table_name} ({','.join(columns)}) VALUES ({placeholders})", row)
+                    else:
+                        cursor.executemany(f"INSERT INTO {table_name} ({','.join(columns)}) VALUES ({placeholders})", rows)
+
+                # 提交事务
+                self.conn.commit()
+                logger.info("导入备份成功")
+                return True
+
+            except Exception as e:
+                logger.error(f"导入备份失败: {e}")
+                self.conn.rollback()
+                return False
+
+    # -------------------- 系统设置操作 --------------------
+    def get_system_setting(self, key: str) -> Optional[str]:
+        """获取系统设置"""
+        with self.lock:
+            try:
+                cursor = self.conn.cursor()
+                cursor.execute("SELECT value FROM system_settings WHERE key = ?", (key,))
+                result = cursor.fetchone()
+                return result[0] if result else None
+            except Exception as e:
+                logger.error(f"获取系统设置失败: {e}")
+                return None
+
+    def set_system_setting(self, key: str, value: str, description: str = None) -> bool:
+        """设置系统设置"""
+        with self.lock:
+            try:
+                cursor = self.conn.cursor()
+                cursor.execute('''
+                INSERT OR REPLACE INTO system_settings (key, value, description, updated_at)
+                VALUES (?, ?, ?, CURRENT_TIMESTAMP)
+                ''', (key, value, description))
+                self.conn.commit()
+                logger.debug(f"设置系统设置: {key}")
+                return True
+            except Exception as e:
+                logger.error(f"设置系统设置失败: {e}")
+                self.conn.rollback()
+                return False
+
+    def get_all_system_settings(self) -> Dict[str, str]:
+        """获取所有系统设置"""
+        with self.lock:
+            try:
+                cursor = self.conn.cursor()
+                cursor.execute("SELECT key, value FROM system_settings")
+
+                settings = {}
+                for row in cursor.fetchall():
+                    settings[row[0]] = row[1]
+
+                return settings
+            except Exception as e:
+                logger.error(f"获取所有系统设置失败: {e}")
+                return {}
+
+    def verify_admin_password(self, password: str) -> bool:
+        """验证管理员密码"""
+        stored_hash = self.get_system_setting('admin_password_hash')
+        if not stored_hash:
+            return False
+
+        password_hash = hashlib.sha256(password.encode()).hexdigest()
+        return password_hash == stored_hash
+
+    def update_admin_password(self, new_password: str) -> bool:
+        """更新管理员密码"""
+        password_hash = hashlib.sha256(new_password.encode()).hexdigest()
+        return self.set_system_setting('admin_password_hash', password_hash, '管理员密码哈希')
+
+    # ==================== 卡券管理方法 ====================
+
+    def create_card(self, name: str, card_type: str, api_config=None,
+                   text_content: str = None, data_content: str = None,
+                   description: str = None, enabled: bool = True):
+        """创建新卡券"""
+        with self.lock:
+            try:
+                # 处理api_config参数 - 如果是字典则转换为JSON字符串
+                api_config_str = None
+                if api_config is not None:
+                    if isinstance(api_config, dict):
+                        import json
+                        api_config_str = json.dumps(api_config)
+                    else:
+                        api_config_str = str(api_config)
+
+                cursor = self.conn.cursor()
+                cursor.execute('''
+                INSERT INTO cards (name, type, api_config, text_content, data_content,
+                                 description, enabled)
+                VALUES (?, ?, ?, ?, ?, ?, ?)
+                ''', (name, card_type, api_config_str, text_content, data_content,
+                      description, enabled))
+                self.conn.commit()
+                card_id = cursor.lastrowid
+                logger.info(f"创建卡券成功: {name} (ID: {card_id})")
+                return card_id
+            except Exception as e:
+                logger.error(f"创建卡券失败: {e}")
+                raise
+
+    def get_all_cards(self):
+        """获取所有卡券"""
+        with self.lock:
+            try:
+                cursor = self.conn.cursor()
+                cursor.execute('''
+                SELECT id, name, type, api_config, text_content, data_content,
+                       description, enabled, created_at, updated_at
+                FROM cards
+                ORDER BY created_at DESC
+                ''')
+
+                cards = []
+                for row in cursor.fetchall():
+                    # 解析api_config JSON字符串
+                    api_config = row[3]
+                    if api_config:
+                        try:
+                            import json
+                            api_config = json.loads(api_config)
+                        except (json.JSONDecodeError, TypeError):
+                            # 如果解析失败，保持原始字符串
+                            pass
+
+                    cards.append({
+                        'id': row[0],
+                        'name': row[1],
+                        'type': row[2],
+                        'api_config': api_config,
+                        'text_content': row[4],
+                        'data_content': row[5],
+                        'description': row[6],
+                        'enabled': bool(row[7]),
+                        'created_at': row[8],
+                        'updated_at': row[9]
+                    })
+
+                return cards
+            except Exception as e:
+                logger.error(f"获取卡券列表失败: {e}")
+                return []
+
+    def get_card_by_id(self, card_id: int):
+        """根据ID获取卡券"""
+        with self.lock:
+            try:
+                cursor = self.conn.cursor()
+                cursor.execute('''
+                SELECT id, name, type, api_config, text_content, data_content,
+                       description, enabled, created_at, updated_at
+                FROM cards WHERE id = ?
+                ''', (card_id,))
+
+                row = cursor.fetchone()
+                if row:
+                    # 解析api_config JSON字符串
+                    api_config = row[3]
+                    if api_config:
+                        try:
+                            import json
+                            api_config = json.loads(api_config)
+                        except (json.JSONDecodeError, TypeError):
+                            # 如果解析失败，保持原始字符串
+                            pass
+
+                    return {
+                        'id': row[0],
+                        'name': row[1],
+                        'type': row[2],
+                        'api_config': api_config,
+                        'text_content': row[4],
+                        'data_content': row[5],
+                        'description': row[6],
+                        'enabled': bool(row[7]),
+                        'created_at': row[8],
+                        'updated_at': row[9]
+                    }
+                return None
+            except Exception as e:
+                logger.error(f"获取卡券失败: {e}")
+                return None
+
+    def update_card(self, card_id: int, name: str = None, card_type: str = None,
+                   api_config=None, text_content: str = None, data_content: str = None,
+                   description: str = None, enabled: bool = None):
+        """更新卡券"""
+        with self.lock:
+            try:
+                # 处理api_config参数
+                api_config_str = None
+                if api_config is not None:
+                    if isinstance(api_config, dict):
+                        import json
+                        api_config_str = json.dumps(api_config)
+                    else:
+                        api_config_str = str(api_config)
+
+                cursor = self.conn.cursor()
+
+                # 构建更新语句
+                update_fields = []
+                params = []
+
+                if name is not None:
+                    update_fields.append("name = ?")
+                    params.append(name)
+                if card_type is not None:
+                    update_fields.append("type = ?")
+                    params.append(card_type)
+                if api_config_str is not None:
+                    update_fields.append("api_config = ?")
+                    params.append(api_config_str)
+                if text_content is not None:
+                    update_fields.append("text_content = ?")
+                    params.append(text_content)
+                if data_content is not None:
+                    update_fields.append("data_content = ?")
+                    params.append(data_content)
+                if description is not None:
+                    update_fields.append("description = ?")
+                    params.append(description)
+                if enabled is not None:
+                    update_fields.append("enabled = ?")
+                    params.append(enabled)
+
+                if not update_fields:
+                    return True  # 没有需要更新的字段
+
+                update_fields.append("updated_at = CURRENT_TIMESTAMP")
+                params.append(card_id)
+
+                sql = f"UPDATE cards SET {', '.join(update_fields)} WHERE id = ?"
+                cursor.execute(sql, params)
+
+                if cursor.rowcount > 0:
+                    self.conn.commit()
+                    logger.info(f"更新卡券成功: ID {card_id}")
+                    return True
+                else:
+                    return False  # 没有找到对应的记录
+
+            except Exception as e:
+                logger.error(f"更新卡券失败: {e}")
+                self.conn.rollback()
+                raise
+
+    # ==================== 自动发货规则方法 ====================
+
+    def create_delivery_rule(self, keyword: str, card_id: int, delivery_count: int = 1,
+                           enabled: bool = True, description: str = None):
+        """创建发货规则"""
+        with self.lock:
+            try:
+                cursor = self.conn.cursor()
+                cursor.execute('''
+                INSERT INTO delivery_rules (keyword, card_id, delivery_count, enabled, description)
+                VALUES (?, ?, ?, ?, ?)
+                ''', (keyword, card_id, delivery_count, enabled, description))
+                self.conn.commit()
+                rule_id = cursor.lastrowid
+                logger.info(f"创建发货规则成功: {keyword} -> 卡券ID {card_id} (规则ID: {rule_id})")
+                return rule_id
+            except Exception as e:
+                logger.error(f"创建发货规则失败: {e}")
+                raise
+
+    def get_all_delivery_rules(self):
+        """获取所有发货规则"""
+        with self.lock:
+            try:
+                cursor = self.conn.cursor()
+                cursor.execute('''
+                SELECT dr.id, dr.keyword, dr.card_id, dr.delivery_count, dr.enabled,
+                       dr.description, dr.delivery_times, dr.created_at, dr.updated_at,
+                       c.name as card_name, c.type as card_type
+                FROM delivery_rules dr
+                LEFT JOIN cards c ON dr.card_id = c.id
+                ORDER BY dr.created_at DESC
+                ''')
+
+                rules = []
+                for row in cursor.fetchall():
+                    rules.append({
+                        'id': row[0],
+                        'keyword': row[1],
+                        'card_id': row[2],
+                        'delivery_count': row[3],
+                        'enabled': bool(row[4]),
+                        'description': row[5],
+                        'delivery_times': row[6],
+                        'created_at': row[7],
+                        'updated_at': row[8],
+                        'card_name': row[9],
+                        'card_type': row[10]
+                    })
+
+                return rules
+            except Exception as e:
+                logger.error(f"获取发货规则列表失败: {e}")
+                return []
+
+    def get_delivery_rules_by_keyword(self, keyword: str):
+        """根据关键字获取匹配的发货规则"""
+        with self.lock:
+            try:
+                cursor = self.conn.cursor()
+                # 使用更灵活的匹配方式：既支持商品内容包含关键字，也支持关键字包含在商品内容中
+                cursor.execute('''
+                SELECT dr.id, dr.keyword, dr.card_id, dr.delivery_count, dr.enabled,
+                       dr.description, dr.delivery_times,
+                       c.name as card_name, c.type as card_type, c.api_config,
+                       c.text_content, c.data_content, c.enabled as card_enabled
+                FROM delivery_rules dr
+                LEFT JOIN cards c ON dr.card_id = c.id
+                WHERE dr.enabled = 1 AND c.enabled = 1
+                AND (? LIKE '%' || dr.keyword || '%' OR dr.keyword LIKE '%' || ? || '%')
+                ORDER BY
+                    CASE
+                        WHEN ? LIKE '%' || dr.keyword || '%' THEN LENGTH(dr.keyword)
+                        ELSE LENGTH(dr.keyword) / 2
+                    END DESC,
+                    dr.id ASC
+                ''', (keyword, keyword, keyword))
+
+                rules = []
+                for row in cursor.fetchall():
+                    # 解析api_config JSON字符串
+                    api_config = row[9]
+                    if api_config:
+                        try:
+                            import json
+                            api_config = json.loads(api_config)
+                        except (json.JSONDecodeError, TypeError):
+                            # 如果解析失败，保持原始字符串
+                            pass
+
+                    rules.append({
+                        'id': row[0],
+                        'keyword': row[1],
+                        'card_id': row[2],
+                        'delivery_count': row[3],
+                        'enabled': bool(row[4]),
+                        'description': row[5],
+                        'delivery_times': row[6],
+                        'card_name': row[7],
+                        'card_type': row[8],
+                        'card_api_config': api_config,
+                        'card_text_content': row[10],
+                        'card_data_content': row[11],
+                        'card_enabled': bool(row[12])
+                    })
+
+                return rules
+            except Exception as e:
+                logger.error(f"根据关键字获取发货规则失败: {e}")
+                return []
+
+    def get_delivery_rule_by_id(self, rule_id: int):
+        """根据ID获取发货规则"""
+        with self.lock:
+            try:
+                cursor = self.conn.cursor()
+                cursor.execute('''
+                SELECT dr.id, dr.keyword, dr.card_id, dr.delivery_count, dr.enabled,
+                       dr.description, dr.delivery_times, dr.created_at, dr.updated_at,
+                       c.name as card_name, c.type as card_type
+                FROM delivery_rules dr
+                LEFT JOIN cards c ON dr.card_id = c.id
+                WHERE dr.id = ?
+                ''', (rule_id,))
+
+                row = cursor.fetchone()
+                if row:
+                    return {
+                        'id': row[0],
+                        'keyword': row[1],
+                        'card_id': row[2],
+                        'delivery_count': row[3],
+                        'enabled': bool(row[4]),
+                        'description': row[5],
+                        'delivery_times': row[6],
+                        'created_at': row[7],
+                        'updated_at': row[8],
+                        'card_name': row[9],
+                        'card_type': row[10]
+                    }
+                return None
+            except Exception as e:
+                logger.error(f"获取发货规则失败: {e}")
+                return None
+
+    def update_delivery_rule(self, rule_id: int, keyword: str = None, card_id: int = None,
+                           delivery_count: int = None, enabled: bool = None,
+                           description: str = None):
+        """更新发货规则"""
+        with self.lock:
+            try:
+                cursor = self.conn.cursor()
+
+                # 构建更新语句
+                update_fields = []
+                params = []
+
+                if keyword is not None:
+                    update_fields.append("keyword = ?")
+                    params.append(keyword)
+                if card_id is not None:
+                    update_fields.append("card_id = ?")
+                    params.append(card_id)
+                if delivery_count is not None:
+                    update_fields.append("delivery_count = ?")
+                    params.append(delivery_count)
+                if enabled is not None:
+                    update_fields.append("enabled = ?")
+                    params.append(enabled)
+                if description is not None:
+                    update_fields.append("description = ?")
+                    params.append(description)
+
+                if not update_fields:
+                    return True  # 没有需要更新的字段
+
+                update_fields.append("updated_at = CURRENT_TIMESTAMP")
+                params.append(rule_id)
+
+                sql = f"UPDATE delivery_rules SET {', '.join(update_fields)} WHERE id = ?"
+                cursor.execute(sql, params)
+
+                if cursor.rowcount > 0:
+                    self.conn.commit()
+                    logger.info(f"更新发货规则成功: ID {rule_id}")
+                    return True
+                else:
+                    return False  # 没有找到对应的记录
+
+            except Exception as e:
+                logger.error(f"更新发货规则失败: {e}")
+                self.conn.rollback()
+                raise
+
+    def increment_delivery_times(self, rule_id: int):
+        """增加发货次数"""
+        with self.lock:
+            try:
+                cursor = self.conn.cursor()
+                cursor.execute('''
+                UPDATE delivery_rules
+                SET delivery_times = delivery_times + 1, updated_at = CURRENT_TIMESTAMP
+                WHERE id = ?
+                ''', (rule_id,))
+                self.conn.commit()
+                logger.debug(f"发货规则 {rule_id} 发货次数已增加")
+            except Exception as e:
+                logger.error(f"更新发货次数失败: {e}")
+
+    def delete_card(self, card_id: int):
+        """删除卡券"""
+        with self.lock:
+            try:
+                cursor = self.conn.cursor()
+                cursor.execute("DELETE FROM cards WHERE id = ?", (card_id,))
+
+                if cursor.rowcount > 0:
+                    self.conn.commit()
+                    logger.info(f"删除卡券成功: ID {card_id}")
+                    return True
+                else:
+                    return False  # 没有找到对应的记录
+
+            except Exception as e:
+                logger.error(f"删除卡券失败: {e}")
+                self.conn.rollback()
+                raise
+
+    def delete_delivery_rule(self, rule_id: int):
+        """删除发货规则"""
+        with self.lock:
+            try:
+                cursor = self.conn.cursor()
+                cursor.execute("DELETE FROM delivery_rules WHERE id = ?", (rule_id,))
+
+                if cursor.rowcount > 0:
+                    self.conn.commit()
+                    logger.info(f"删除发货规则成功: ID {rule_id}")
+                    return True
+                else:
+                    return False  # 没有找到对应的记录
+
+            except Exception as e:
+                logger.error(f"删除发货规则失败: {e}")
+                self.conn.rollback()
+                raise
+
+    def consume_batch_data(self, card_id: int):
+        """消费批量数据的第一条记录（线程安全）"""
+        with self.lock:
+            try:
+                cursor = self.conn.cursor()
+
+                # 获取卡券的批量数据
+                cursor.execute("SELECT data_content FROM cards WHERE id = ? AND type = 'data'", (card_id,))
+                result = cursor.fetchone()
+
+                if not result or not result[0]:
+                    logger.warning(f"卡券 {card_id} 没有批量数据")
+                    return None
+
+                data_content = result[0]
+                lines = [line.strip() for line in data_content.split('\n') if line.strip()]
+
+                if not lines:
+                    logger.warning(f"卡券 {card_id} 批量数据为空")
+                    return None
+
+                # 获取第一条数据
+                first_line = lines[0]
+
+                # 移除第一条数据，更新数据库
+                remaining_lines = lines[1:]
+                new_data_content = '\n'.join(remaining_lines)
+
+                cursor.execute('''
+                UPDATE cards
+                SET data_content = ?, updated_at = CURRENT_TIMESTAMP
+                WHERE id = ?
+                ''', (new_data_content, card_id))
+
+                self.conn.commit()
+
+                logger.info(f"消费批量数据成功: 卡券ID={card_id}, 剩余={len(remaining_lines)}条")
+                return first_line
+
+            except Exception as e:
+                logger.error(f"消费批量数据失败: {e}")
+                self.conn.rollback()
+                return None
+
+    # ==================== 商品信息管理 ====================
+
+    def save_item_basic_info(self, cookie_id: str, item_id: str, item_title: str = None,
+                            item_description: str = None, item_category: str = None,
+                            item_price: str = None, item_detail: str = None) -> bool:
+        """保存或更新商品基本信息，使用原子操作避免并发问题
+
+        Args:
+            cookie_id: Cookie ID
+            item_id: 商品ID
+            item_title: 商品标题
+            item_description: 商品描述
+            item_category: 商品分类
+            item_price: 商品价格
+            item_detail: 商品详情JSON
+
+        Returns:
+            bool: 操作是否成功
+        """
+        try:
+            with self.lock:
+                cursor = self.conn.cursor()
+
+                # 使用 INSERT OR IGNORE + UPDATE 的原子操作模式
+                # 首先尝试插入，如果已存在则忽略
+                cursor.execute('''
+                INSERT OR IGNORE INTO item_info (cookie_id, item_id, item_title, item_description,
+                                               item_category, item_price, item_detail, created_at, updated_at)
+                VALUES (?, ?, ?, ?, ?, ?, ?, CURRENT_TIMESTAMP, CURRENT_TIMESTAMP)
+                ''', (cookie_id, item_id, item_title or '', item_description or '',
+                      item_category or '', item_price or '', item_detail or ''))
+
+                # 如果是新插入的记录，直接返回成功
+                if cursor.rowcount > 0:
+                    self.conn.commit()
+                    logger.info(f"新增商品基本信息: {item_id} - {item_title}")
+                    return True
+
+                # 记录已存在，使用原子UPDATE操作，只更新非空字段且不覆盖现有非空值
+                update_parts = []
+                params = []
+
+                # 使用 CASE WHEN 语句进行条件更新，避免覆盖现有数据
+                if item_title:
+                    update_parts.append("item_title = CASE WHEN (item_title IS NULL OR item_title = '') THEN ? ELSE item_title END")
+                    params.append(item_title)
+
+                if item_description:
+                    update_parts.append("item_description = CASE WHEN (item_description IS NULL OR item_description = '') THEN ? ELSE item_description END")
+                    params.append(item_description)
+
+                if item_category:
+                    update_parts.append("item_category = CASE WHEN (item_category IS NULL OR item_category = '') THEN ? ELSE item_category END")
+                    params.append(item_category)
+
+                if item_price:
+                    update_parts.append("item_price = CASE WHEN (item_price IS NULL OR item_price = '') THEN ? ELSE item_price END")
+                    params.append(item_price)
+
+                # 对于item_detail，只有在现有值为空时才更新
+                if item_detail:
+                    update_parts.append("item_detail = CASE WHEN (item_detail IS NULL OR item_detail = '' OR TRIM(item_detail) = '') THEN ? ELSE item_detail END")
+                    params.append(item_detail)
+
+                if update_parts:
+                    update_parts.append("updated_at = CURRENT_TIMESTAMP")
+                    params.extend([cookie_id, item_id])
+
+                    sql = f"UPDATE item_info SET {', '.join(update_parts)} WHERE cookie_id = ? AND item_id = ?"
+                    cursor.execute(sql, params)
+
+                    if cursor.rowcount > 0:
+                        logger.info(f"更新商品基本信息: {item_id} - {item_title}")
+                    else:
+                        logger.debug(f"商品信息无需更新: {item_id}")
+
+                self.conn.commit()
+                return True
+
+        except Exception as e:
+            logger.error(f"保存商品基本信息失败: {e}")
+            self.conn.rollback()
+            return False
+
+    def save_item_info(self, cookie_id: str, item_id: str, item_data = None) -> bool:
+        """保存或更新商品信息
+
+        Args:
+            cookie_id: Cookie ID
+            item_id: 商品ID
+            item_data: 商品详情数据，可以是字符串或字典，也可以为None
+
+        Returns:
+            bool: 操作是否成功
+        """
+        try:
+            with self.lock:
+                cursor = self.conn.cursor()
+
+                # 检查商品是否已存在
+                cursor.execute('''
+                SELECT id, item_detail FROM item_info
+                WHERE cookie_id = ? AND item_id = ?
+                ''', (cookie_id, item_id))
+
+                existing = cursor.fetchone()
+
+                if existing:
+                    # 如果传入的商品详情有值，则用最新数据覆盖
+                    if item_data is not None and item_data:
+                        # 处理字符串类型的详情数据
+                        if isinstance(item_data, str):
+                            cursor.execute('''
+                            UPDATE item_info SET
+                                item_detail = ?, updated_at = CURRENT_TIMESTAMP
+                            WHERE cookie_id = ? AND item_id = ?
+                            ''', (item_data, cookie_id, item_id))
+                        else:
+                            # 处理字典类型的详情数据（向后兼容）
+                            cursor.execute('''
+                            UPDATE item_info SET
+                                item_title = ?, item_description = ?, item_category = ?,
+                                item_price = ?, item_detail = ?, updated_at = CURRENT_TIMESTAMP
+                            WHERE cookie_id = ? AND item_id = ?
+                            ''', (
+                                item_data.get('title', ''),
+                                item_data.get('description', ''),
+                                item_data.get('category', ''),
+                                item_data.get('price', ''),
+                                json.dumps(item_data, ensure_ascii=False),
+                                cookie_id, item_id
+                            ))
+                        logger.info(f"更新商品信息（覆盖）: {item_id}")
+                    else:
+                        # 如果商品详情没有数据，则不更新，只记录存在
+                        logger.debug(f"商品信息已存在，无新数据，跳过更新: {item_id}")
+                        return True
+                else:
+                    # 新增商品信息
+                    if isinstance(item_data, str):
+                        # 直接保存字符串详情
+                        cursor.execute('''
+                        INSERT INTO item_info (cookie_id, item_id, item_detail)
+                        VALUES (?, ?, ?)
+                        ''', (cookie_id, item_id, item_data))
+                    else:
+                        # 处理字典类型的详情数据（向后兼容）
+                        cursor.execute('''
+                        INSERT INTO item_info (cookie_id, item_id, item_title, item_description,
+                                             item_category, item_price, item_detail)
+                        VALUES (?, ?, ?, ?, ?, ?, ?)
+                        ''', (
+                            cookie_id, item_id,
+                            item_data.get('title', '') if item_data else '',
+                            item_data.get('description', '') if item_data else '',
+                            item_data.get('category', '') if item_data else '',
+                            item_data.get('price', '') if item_data else '',
+                            json.dumps(item_data, ensure_ascii=False) if item_data else ''
+                        ))
+                    logger.info(f"新增商品信息: {item_id}")
+
+                self.conn.commit()
+                return True
+
+        except Exception as e:
+            logger.error(f"保存商品信息失败: {e}")
+            return False
+
+    def get_item_info(self, cookie_id: str, item_id: str) -> Optional[Dict]:
+        """获取商品信息
+
+        Args:
+            cookie_id: Cookie ID
+            item_id: 商品ID
+
+        Returns:
+            Dict: 商品信息，如果不存在返回None
+        """
+        try:
+            with self.lock:
+                cursor = self.conn.cursor()
+                cursor.execute('''
+                SELECT * FROM item_info
+                WHERE cookie_id = ? AND item_id = ?
+                ''', (cookie_id, item_id))
+
+                row = cursor.fetchone()
+                if row:
+                    columns = [description[0] for description in cursor.description]
+                    item_info = dict(zip(columns, row))
+
+                    # 解析item_detail JSON
+                    if item_info.get('item_detail'):
+                        try:
+                            item_info['item_detail_parsed'] = json.loads(item_info['item_detail'])
+                        except:
+                            item_info['item_detail_parsed'] = {}
+
+                    return item_info
+                return None
+
+        except Exception as e:
+            logger.error(f"获取商品信息失败: {e}")
+            return None
+
+    def get_items_by_cookie(self, cookie_id: str) -> List[Dict]:
+        """获取指定Cookie的所有商品信息
+
+        Args:
+            cookie_id: Cookie ID
+
+        Returns:
+            List[Dict]: 商品信息列表
+        """
+        try:
+            with self.lock:
+                cursor = self.conn.cursor()
+                cursor.execute('''
+                SELECT * FROM item_info
+                WHERE cookie_id = ?
+                ORDER BY updated_at DESC
+                ''', (cookie_id,))
+
+                columns = [description[0] for description in cursor.description]
+                items = []
+
+                for row in cursor.fetchall():
+                    item_info = dict(zip(columns, row))
+
+                    # 解析item_detail JSON
+                    if item_info.get('item_detail'):
+                        try:
+                            item_info['item_detail_parsed'] = json.loads(item_info['item_detail'])
+                        except:
+                            item_info['item_detail_parsed'] = {}
+
+                    items.append(item_info)
+
+                return items
+
+        except Exception as e:
+            logger.error(f"获取Cookie商品信息失败: {e}")
+            return []
+
+    def get_all_items(self) -> List[Dict]:
+        """获取所有商品信息
+
+        Returns:
+            List[Dict]: 所有商品信息列表
+        """
+        try:
+            with self.lock:
+                cursor = self.conn.cursor()
+                cursor.execute('''
+                SELECT * FROM item_info
+                ORDER BY updated_at DESC
+                ''')
+
+                columns = [description[0] for description in cursor.description]
+                items = []
+
+                for row in cursor.fetchall():
+                    item_info = dict(zip(columns, row))
+
+                    # 解析item_detail JSON
+                    if item_info.get('item_detail'):
+                        try:
+                            item_info['item_detail_parsed'] = json.loads(item_info['item_detail'])
+                        except:
+                            item_info['item_detail_parsed'] = {}
+
+                    items.append(item_info)
+
+                return items
+
+        except Exception as e:
+            logger.error(f"获取所有商品信息失败: {e}")
+            return []
+
+    def update_item_detail(self, cookie_id: str, item_id: str, item_detail: str) -> bool:
+        """更新商品详情（不覆盖商品标题等基本信息）
+
+        Args:
+            cookie_id: Cookie ID
+            item_id: 商品ID
+            item_detail: 商品详情JSON字符串
+
+        Returns:
+            bool: 操作是否成功
+        """
+        try:
+            with self.lock:
+                cursor = self.conn.cursor()
+                # 只更新item_detail字段，不影响其他字段
+                cursor.execute('''
+                UPDATE item_info SET
+                    item_detail = ?, updated_at = CURRENT_TIMESTAMP
+                WHERE cookie_id = ? AND item_id = ?
+                ''', (item_detail, cookie_id, item_id))
+
+                if cursor.rowcount > 0:
+                    self.conn.commit()
+                    logger.info(f"更新商品详情成功: {item_id}")
+                    return True
+                else:
+                    logger.warning(f"未找到要更新的商品: {item_id}")
+                    return False
+
+        except Exception as e:
+            logger.error(f"更新商品详情失败: {e}")
+            self.conn.rollback()
+            return False
+
+    def update_item_title_only(self, cookie_id: str, item_id: str, item_title: str) -> bool:
+        """仅更新商品标题（并发安全）
+
+        Args:
+            cookie_id: Cookie ID
+            item_id: 商品ID
+            item_title: 商品标题
+
+        Returns:
+            bool: 操作是否成功
+        """
+        try:
+            with self.lock:
+                cursor = self.conn.cursor()
+                # 使用 INSERT OR REPLACE 确保记录存在，但只更新标题字段
+                cursor.execute('''
+                INSERT INTO item_info (cookie_id, item_id, item_title, item_description,
+                                     item_category, item_price, item_detail, created_at, updated_at)
+                VALUES (?, ?, ?,
+                       COALESCE((SELECT item_description FROM item_info WHERE cookie_id = ? AND item_id = ?), ''),
+                       COALESCE((SELECT item_category FROM item_info WHERE cookie_id = ? AND item_id = ?), ''),
+                       COALESCE((SELECT item_price FROM item_info WHERE cookie_id = ? AND item_id = ?), ''),
+                       COALESCE((SELECT item_detail FROM item_info WHERE cookie_id = ? AND item_id = ?), ''),
+                       COALESCE((SELECT created_at FROM item_info WHERE cookie_id = ? AND item_id = ?), CURRENT_TIMESTAMP),
+                       CURRENT_TIMESTAMP)
+                ON CONFLICT(cookie_id, item_id) DO UPDATE SET
+                    item_title = excluded.item_title,
+                    updated_at = CURRENT_TIMESTAMP
+                ''', (cookie_id, item_id, item_title,
+                      cookie_id, item_id, cookie_id, item_id, cookie_id, item_id,
+                      cookie_id, item_id, cookie_id, item_id))
+
+                self.conn.commit()
+                logger.info(f"更新商品标题成功: {item_id} - {item_title}")
+                return True
+
+        except Exception as e:
+            logger.error(f"更新商品标题失败: {e}")
+            self.conn.rollback()
+            return False
+
+    def batch_save_item_basic_info(self, items_data: list) -> int:
+        """批量保存商品基本信息（并发安全）
+
+        Args:
+            items_data: 商品数据列表，每个元素包含 cookie_id, item_id, item_title 等字段
+
+        Returns:
+            int: 成功保存的商品数量
+        """
+        if not items_data:
+            return 0
+
+        success_count = 0
+        try:
+            with self.lock:
+                cursor = self.conn.cursor()
+
+                # 使用事务批量处理
+                cursor.execute('BEGIN TRANSACTION')
+
+                for item_data in items_data:
+                    try:
+                        cookie_id = item_data.get('cookie_id')
+                        item_id = item_data.get('item_id')
+                        item_title = item_data.get('item_title', '')
+                        item_description = item_data.get('item_description', '')
+                        item_category = item_data.get('item_category', '')
+                        item_price = item_data.get('item_price', '')
+                        item_detail = item_data.get('item_detail', '')
+
+                        if not cookie_id or not item_id:
+                            continue
+
+                        # 使用 INSERT OR IGNORE + UPDATE 模式
+                        cursor.execute('''
+                        INSERT OR IGNORE INTO item_info (cookie_id, item_id, item_title, item_description,
+                                                       item_category, item_price, item_detail, created_at, updated_at)
+                        VALUES (?, ?, ?, ?, ?, ?, ?, CURRENT_TIMESTAMP, CURRENT_TIMESTAMP)
+                        ''', (cookie_id, item_id, item_title, item_description,
+                              item_category, item_price, item_detail))
+
+                        if cursor.rowcount == 0:
+                            # 记录已存在，进行条件更新
+                            update_sql = '''
+                            UPDATE item_info SET
+                                item_title = CASE WHEN (item_title IS NULL OR item_title = '') AND ? != '' THEN ? ELSE item_title END,
+                                item_description = CASE WHEN (item_description IS NULL OR item_description = '') AND ? != '' THEN ? ELSE item_description END,
+                                item_category = CASE WHEN (item_category IS NULL OR item_category = '') AND ? != '' THEN ? ELSE item_category END,
+                                item_price = CASE WHEN (item_price IS NULL OR item_price = '') AND ? != '' THEN ? ELSE item_price END,
+                                item_detail = CASE WHEN (item_detail IS NULL OR item_detail = '' OR TRIM(item_detail) = '') AND ? != '' THEN ? ELSE item_detail END,
+                                updated_at = CURRENT_TIMESTAMP
+                            WHERE cookie_id = ? AND item_id = ?
+                            '''
+                            cursor.execute(update_sql, (
+                                item_title, item_title,
+                                item_description, item_description,
+                                item_category, item_category,
+                                item_price, item_price,
+                                item_detail, item_detail,
+                                cookie_id, item_id
+                            ))
+
+                        success_count += 1
+
+                    except Exception as item_e:
+                        logger.warning(f"批量保存单个商品失败 {item_data.get('item_id', 'unknown')}: {item_e}")
+                        continue
+
+                cursor.execute('COMMIT')
+                logger.info(f"批量保存商品信息完成: {success_count}/{len(items_data)} 个商品")
+                return success_count
+
+        except Exception as e:
+            logger.error(f"批量保存商品信息失败: {e}")
+            try:
+                cursor.execute('ROLLBACK')
+            except:
+                pass
+            return success_count
+
+    def delete_item_info(self, cookie_id: str, item_id: str) -> bool:
+        """删除商品信息
+
+        Args:
+            cookie_id: Cookie ID
+            item_id: 商品ID
+
+        Returns:
+            bool: 操作是否成功
+        """
+        try:
+            with self.lock:
+                cursor = self.conn.cursor()
+                cursor.execute('DELETE FROM item_info WHERE cookie_id = ? AND item_id = ?',
+                             (cookie_id, item_id))
+
+                if cursor.rowcount > 0:
+                    self.conn.commit()
+                    logger.info(f"删除商品信息成功: {cookie_id} - {item_id}")
+                    return True
+                else:
+                    logger.warning(f"未找到要删除的商品信息: {cookie_id} - {item_id}")
+                    return False
+
+        except Exception as e:
+            logger.error(f"删除商品信息失败: {e}")
+            self.conn.rollback()
+            return False
+
+    def batch_delete_item_info(self, items_to_delete: list) -> int:
+        """批量删除商品信息
+
+        Args:
+            items_to_delete: 要删除的商品列表，每个元素包含 cookie_id 和 item_id
+
+        Returns:
+            int: 成功删除的商品数量
+        """
+        if not items_to_delete:
+            return 0
+
+        success_count = 0
+        try:
+            with self.lock:
+                cursor = self.conn.cursor()
+                cursor.execute('BEGIN TRANSACTION')
+
+                for item_data in items_to_delete:
+                    try:
+                        cookie_id = item_data.get('cookie_id')
+                        item_id = item_data.get('item_id')
+
+                        if not cookie_id or not item_id:
+                            continue
+
+                        cursor.execute('DELETE FROM item_info WHERE cookie_id = ? AND item_id = ?',
+                                     (cookie_id, item_id))
+
+                        if cursor.rowcount > 0:
+                            success_count += 1
+                            logger.debug(f"删除商品信息: {cookie_id} - {item_id}")
+
+                    except Exception as item_e:
+                        logger.warning(f"删除单个商品失败 {item_data.get('item_id', 'unknown')}: {item_e}")
+                        continue
+
+                cursor.execute('COMMIT')
+                logger.info(f"批量删除商品信息完成: {success_count}/{len(items_to_delete)} 个商品")
+                return success_count
+
+        except Exception as e:
+            logger.error(f"批量删除商品信息失败: {e}")
+            try:
+                cursor.execute('ROLLBACK')
+            except:
+                pass
+            return success_count
+
+
+# 全局单例
+db_manager = DBManager()
+
+# 确保进程结束时关闭数据库连接
+import atexit
+atexit.register(db_manager.close)
\ No newline at end of file
diff --git a/deploy.bat b/deploy.bat
new file mode 100644
index 0000000..c10fd9d
--- /dev/null
+++ b/deploy.bat
@@ -0,0 +1,298 @@
+@echo off
+chcp 65001 >nul
+setlocal enabledelayedexpansion
+
+:: 闲鱼自动回复系统 Docker 部署脚本 (Windows版本)
+:: 作者: Xianyu Auto Reply System
+:: 版本: 1.0.0
+
+title 闲鱼自动回复系统 Docker 部署
+
+:: 颜色定义
+set "RED=[91m"
+set "GREEN=[92m"
+set "YELLOW=[93m"
+set "BLUE=[94m"
+set "NC=[0m"
+
+:: 打印带颜色的消息
+:print_info
+echo %BLUE%[INFO]%NC% %~1
+goto :eof
+
+:print_success
+echo %GREEN%[SUCCESS]%NC% %~1
+goto :eof
+
+:print_warning
+echo %YELLOW%[WARNING]%NC% %~1
+goto :eof
+
+:print_error
+echo %RED%[ERROR]%NC% %~1
+goto :eof
+
+:: 检查Docker是否安装
+:check_docker
+call :print_info "检查 Docker 环境..."
+
+docker --version >nul 2>&1
+if errorlevel 1 (
+    call :print_error "Docker 未安装，请先安装 Docker Desktop"
+    echo.
+    echo 下载地址: https://www.docker.com/products/docker-desktop
+    pause
+    exit /b 1
+)
+
+docker-compose --version >nul 2>&1
+if errorlevel 1 (
+    call :print_error "Docker Compose 未安装，请先安装 Docker Compose"
+    pause
+    exit /b 1
+)
+
+call :print_success "Docker 环境检查通过"
+goto :eof
+
+:: 创建必要的目录
+:create_directories
+call :print_info "创建必要的目录..."
+
+if not exist "data" mkdir data
+if not exist "logs" mkdir logs
+if not exist "backups" mkdir backups
+if not exist "nginx" mkdir nginx
+if not exist "nginx\ssl" mkdir nginx\ssl
+
+REM 检查目录是否创建成功
+if not exist "data" (
+    call :print_error "data目录创建失败"
+    pause
+    exit /b 1
+)
+
+if not exist "logs" (
+    call :print_error "logs目录创建失败"
+    pause
+    exit /b 1
+)
+
+call :print_success "目录创建完成"
+goto :eof
+
+:: 生成默认配置文件
+:generate_config
+REM 生成.env文件
+if not exist ".env" (
+    if exist ".env.example" (
+        call :print_info "从模板生成 .env 文件..."
+        copy ".env.example" ".env" >nul
+        call :print_success ".env 文件已生成"
+    ) else (
+        call :print_warning ".env.example 文件不存在，跳过 .env 文件生成"
+    )
+) else (
+    call :print_info ".env 文件已存在，跳过生成"
+)
+
+REM 生成global_config.yml文件
+if exist "global_config.yml" (
+    call :print_info "配置文件已存在，跳过生成"
+    goto :eof
+)
+
+call :print_info "生成默认配置文件..."
+
+(
+echo # 闲鱼自动回复系统配置文件
+echo API_ENDPOINTS:
+echo   login_check: https://passport.goofish.com/newlogin/hasLogin.do
+echo   message_headinfo: https://h5api.m.goofish.com/h5/mtop.idle.trade.pc.message.headinfo/1.0/
+echo   token: https://h5api.m.goofish.com/h5/mtop.taobao.idlemessage.pc.login.token/1.0/
+echo.
+echo APP_CONFIG:
+echo   api_version: '1.0'
+echo   app_key: 444e9908a51d1cb236a27862abc769c9
+echo   app_version: '1.0'
+echo   platform: web
+echo.
+echo AUTO_REPLY:
+echo   enabled: true
+echo   default_message: '亲爱的"{send_user_name}" 老板你好！所有宝贝都可以拍，秒发货的哈~不满意的话可以直接申请退款哈~'
+echo   max_retry: 3
+echo   retry_interval: 5
+echo   api:
+echo     enabled: false
+echo     host: 0.0.0.0  # 绑定所有网络接口，支持IP访问
+echo     port: 8080     # Web服务端口
+echo     url: http://0.0.0.0:8080/xianyu/reply
+echo     timeout: 10
+echo.
+echo COOKIES:
+echo   last_update_time: ''
+echo   value: ''
+echo.
+echo DEFAULT_HEADERS:
+echo   accept: application/json
+echo   accept-language: zh-CN,zh;q=0.9
+echo   cache-control: no-cache
+echo   origin: https://www.goofish.com
+echo   pragma: no-cache
+echo   referer: https://www.goofish.com/
+echo   user-agent: Mozilla/5.0 ^(Windows NT 10.0; Win64; x64^) AppleWebKit/537.36 ^(KHTML, like Gecko^) Chrome/119.0.0.0 Safari/537.36
+echo.
+echo WEBSOCKET_URL: wss://wss-goofish.dingtalk.com/
+echo HEARTBEAT_INTERVAL: 15
+echo HEARTBEAT_TIMEOUT: 5
+echo TOKEN_REFRESH_INTERVAL: 3600
+echo TOKEN_RETRY_INTERVAL: 300
+echo MESSAGE_EXPIRE_TIME: 300000
+echo.
+echo LOG_CONFIG:
+echo   level: INFO
+echo   format: '{time:YYYY-MM-DD HH:mm:ss.SSS} | {level} | {name}:{function}:{line} - {message}'
+echo   rotation: '1 day'
+echo   retention: '7 days'
+) > global_config.yml
+
+call :print_success "默认配置文件已生成"
+goto :eof
+
+:: 构建Docker镜像
+:build_image
+call :print_info "构建 Docker 镜像..."
+
+docker build -t xianyu-auto-reply:latest .
+if errorlevel 1 (
+    call :print_error "Docker 镜像构建失败"
+    pause
+    exit /b 1
+)
+
+call :print_success "Docker 镜像构建完成"
+goto :eof
+
+:: 启动服务
+:start_services
+call :print_info "启动服务..."
+
+if "%~1"=="--with-nginx" (
+    call :print_info "启动服务（包含 Nginx）..."
+    docker-compose --profile with-nginx up -d
+) else (
+    call :print_info "启动服务（不包含 Nginx）..."
+    docker-compose up -d
+)
+
+if errorlevel 1 (
+    call :print_error "服务启动失败"
+    pause
+    exit /b 1
+)
+
+call :print_success "服务启动完成"
+goto :eof
+
+:: 显示服务状态
+:show_status
+call :print_info "服务状态："
+docker-compose ps
+
+echo.
+call :print_info "服务日志（最近10行）："
+docker-compose logs --tail=10
+goto :eof
+
+:: 显示访问信息
+:show_access_info
+call :print_success "部署完成！"
+echo.
+call :print_info "访问信息："
+echo   Web界面: http://localhost:8080
+echo   默认账号: admin
+echo   默认密码: admin123
+echo.
+call :print_info "常用命令："
+echo   查看日志: docker-compose logs -f
+echo   重启服务: docker-compose restart
+echo   停止服务: docker-compose down
+echo   更新服务: deploy.bat update
+echo.
+call :print_info "数据目录："
+echo   数据库: .\data\xianyu_data.db
+echo   日志: .\logs\
+echo   配置: .\global_config.yml
+echo.
+goto :eof
+
+:: 更新服务
+:update_services
+call :print_info "更新服务..."
+
+docker-compose down
+call :build_image
+call :start_services %~1
+
+call :print_success "服务更新完成"
+goto :eof
+
+:: 清理资源
+:cleanup
+call :print_warning "清理 Docker 资源..."
+
+docker-compose down --volumes --remove-orphans
+docker rmi xianyu-auto-reply:latest 2>nul
+
+call :print_success "清理完成"
+goto :eof
+
+:: 显示帮助
+:show_help
+echo 使用方法:
+echo   %~nx0                    # 首次部署
+echo   %~nx0 with-nginx         # 部署并启动 Nginx
+echo   %~nx0 update             # 更新服务
+echo   %~nx0 update with-nginx  # 更新服务并启动 Nginx
+echo   %~nx0 status             # 查看服务状态
+echo   %~nx0 cleanup            # 清理所有资源
+echo   %~nx0 help               # 显示帮助
+goto :eof
+
+:: 主函数
+:main
+echo ========================================
+echo   闲鱼自动回复系统 Docker 部署脚本
+echo ========================================
+echo.
+
+if "%~1"=="update" (
+    call :print_info "更新模式"
+    call :check_docker
+    call :update_services %~2
+    call :show_status
+    call :show_access_info
+) else if "%~1"=="cleanup" (
+    call :print_warning "清理模式"
+    call :cleanup
+) else if "%~1"=="status" (
+    call :show_status
+) else if "%~1"=="help" (
+    call :show_help
+) else (
+    call :print_info "首次部署模式"
+    call :check_docker
+    call :create_directories
+    call :generate_config
+    call :build_image
+    call :start_services %~1
+    call :show_status
+    call :show_access_info
+)
+
+echo.
+pause
+goto :eof
+
+:: 执行主函数
+call :main %*
diff --git a/deploy.sh b/deploy.sh
new file mode 100644
index 0000000..75f3d0b
--- /dev/null
+++ b/deploy.sh
@@ -0,0 +1,288 @@
+#!/bin/bash
+
+# 闲鱼自动回复系统 Docker 部署脚本
+# 作者: Xianyu Auto Reply System
+# 版本: 1.0.0
+
+set -e
+
+# 颜色定义
+RED='\033[0;31m'
+GREEN='\033[0;32m'
+YELLOW='\033[1;33m'
+BLUE='\033[0;34m'
+NC='\033[0m' # No Color
+
+# 打印带颜色的消息
+print_info() {
+    echo -e "${BLUE}[INFO]${NC} $1"
+}
+
+print_success() {
+    echo -e "${GREEN}[SUCCESS]${NC} $1"
+}
+
+print_warning() {
+    echo -e "${YELLOW}[WARNING]${NC} $1"
+}
+
+print_error() {
+    echo -e "${RED}[ERROR]${NC} $1"
+}
+
+# 检查Docker是否安装
+check_docker() {
+    if ! command -v docker &> /dev/null; then
+        print_error "Docker 未安装，请先安装 Docker"
+        exit 1
+    fi
+    
+    if ! command -v docker-compose &> /dev/null; then
+        print_error "Docker Compose 未安装，请先安装 Docker Compose"
+        exit 1
+    fi
+    
+    print_success "Docker 环境检查通过"
+}
+
+# 创建必要的目录
+create_directories() {
+    print_info "创建必要的目录..."
+
+    # 创建目录
+    mkdir -p data
+    mkdir -p logs
+    mkdir -p backups
+    mkdir -p nginx/ssl
+
+    # 设置权限 (确保Docker容器可以写入)
+    chmod 755 data logs backups
+
+    # 检查权限
+    if [ ! -w "data" ]; then
+        print_error "data目录没有写权限"
+        exit 1
+    fi
+
+    if [ ! -w "logs" ]; then
+        print_error "logs目录没有写权限"
+        exit 1
+    fi
+
+    print_success "目录创建完成"
+}
+
+# 生成默认配置文件
+generate_config() {
+    # 生成.env文件
+    if [ ! -f ".env" ]; then
+        if [ -f ".env.example" ]; then
+            print_info "从模板生成 .env 文件..."
+            cp .env.example .env
+            print_success ".env 文件已生成"
+        else
+            print_warning ".env.example 文件不存在，跳过 .env 文件生成"
+        fi
+    else
+        print_info ".env 文件已存在，跳过生成"
+    fi
+
+    # 生成global_config.yml文件
+    if [ ! -f "global_config.yml" ]; then
+        print_info "生成默认配置文件..."
+        
+        cat > global_config.yml << EOF
+# 闲鱼自动回复系统配置文件
+API_ENDPOINTS:
+  login_check: https://passport.goofish.com/newlogin/hasLogin.do
+  message_headinfo: https://h5api.m.goofish.com/h5/mtop.idle.trade.pc.message.headinfo/1.0/
+  token: https://h5api.m.goofish.com/h5/mtop.taobao.idlemessage.pc.login.token/1.0/
+
+APP_CONFIG:
+  api_version: '1.0'
+  app_key: 444e9908a51d1cb236a27862abc769c9
+  app_version: '1.0'
+  platform: web
+
+AUTO_REPLY:
+  enabled: true
+  default_message: '亲爱的"{send_user_name}" 老板你好！所有宝贝都可以拍，秒发货的哈~不满意的话可以直接申请退款哈~'
+  max_retry: 3
+  retry_interval: 5
+  api:
+    enabled: false
+    host: 0.0.0.0  # 绑定所有网络接口，支持IP访问
+    port: 8080     # Web服务端口
+    url: http://0.0.0.0:8080/xianyu/reply
+    timeout: 10
+
+COOKIES:
+  last_update_time: ''
+  value: ''
+
+DEFAULT_HEADERS:
+  accept: application/json
+  accept-language: zh-CN,zh;q=0.9
+  cache-control: no-cache
+  origin: https://www.goofish.com
+  pragma: no-cache
+  referer: https://www.goofish.com/
+  sec-ch-ua: '"Google Chrome";v="119", "Chromium";v="119", "Not?A_Brand";v="24"'
+  sec-ch-ua-mobile: '?0'
+  sec-ch-ua-platform: '"Windows"'
+  sec-fetch-dest: empty
+  sec-fetch-mode: cors
+  sec-fetch-site: same-site
+  user-agent: Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/119.0.0.0 Safari/537.36
+
+WEBSOCKET_URL: wss://wss-goofish.dingtalk.com/
+HEARTBEAT_INTERVAL: 15
+HEARTBEAT_TIMEOUT: 5
+TOKEN_REFRESH_INTERVAL: 3600
+TOKEN_RETRY_INTERVAL: 300
+MESSAGE_EXPIRE_TIME: 300000
+
+LOG_CONFIG:
+  level: INFO
+  format: '{time:YYYY-MM-DD HH:mm:ss.SSS} | {level} | {name}:{function}:{line} - {message}'
+  rotation: '1 day'
+  retention: '7 days'
+EOF
+        
+        print_success "默认配置文件已生成"
+    else
+        print_info "配置文件已存在，跳过生成"
+    fi
+}
+
+# 构建Docker镜像
+build_image() {
+    print_info "构建 Docker 镜像..."
+    
+    docker build -t xianyu-auto-reply:latest .
+    
+    print_success "Docker 镜像构建完成"
+}
+
+# 启动服务
+start_services() {
+    print_info "启动服务..."
+    
+    # 检查是否需要启动 Nginx
+    if [ "$1" = "--with-nginx" ]; then
+        print_info "启动服务（包含 Nginx）..."
+        docker-compose --profile with-nginx up -d
+    else
+        print_info "启动服务（不包含 Nginx）..."
+        docker-compose up -d
+    fi
+    
+    print_success "服务启动完成"
+}
+
+# 显示服务状态
+show_status() {
+    print_info "服务状态："
+    docker-compose ps
+    
+    print_info "服务日志（最近10行）："
+    docker-compose logs --tail=10
+}
+
+# 显示访问信息
+show_access_info() {
+    print_success "部署完成！"
+    echo ""
+    print_info "访问信息："
+    echo "  Web界面: http://localhost:8080"
+    echo "  默认账号: admin"
+    echo "  默认密码: admin123"
+    echo ""
+    print_info "常用命令："
+    echo "  查看日志: docker-compose logs -f"
+    echo "  重启服务: docker-compose restart"
+    echo "  停止服务: docker-compose down"
+    echo "  更新服务: ./deploy.sh --update"
+    echo ""
+    print_info "数据目录："
+    echo "  数据库: ./data/xianyu_data.db"
+    echo "  日志: ./logs/"
+    echo "  配置: ./global_config.yml"
+}
+
+# 更新服务
+update_services() {
+    print_info "更新服务..."
+    
+    # 停止服务
+    docker-compose down
+    
+    # 重新构建镜像
+    build_image
+    
+    # 启动服务
+    start_services $1
+    
+    print_success "服务更新完成"
+}
+
+# 清理资源
+cleanup() {
+    print_warning "清理 Docker 资源..."
+    
+    # 停止并删除容器
+    docker-compose down --volumes --remove-orphans
+    
+    # 删除镜像
+    docker rmi xianyu-auto-reply:latest 2>/dev/null || true
+    
+    print_success "清理完成"
+}
+
+# 主函数
+main() {
+    echo "========================================"
+    echo "  闲鱼自动回复系统 Docker 部署脚本"
+    echo "========================================"
+    echo ""
+    
+    case "$1" in
+        --update)
+            print_info "更新模式"
+            check_docker
+            update_services $2
+            show_status
+            show_access_info
+            ;;
+        --cleanup)
+            print_warning "清理模式"
+            cleanup
+            ;;
+        --status)
+            show_status
+            ;;
+        --help)
+            echo "使用方法:"
+            echo "  $0                    # 首次部署"
+            echo "  $0 --with-nginx       # 部署并启动 Nginx"
+            echo "  $0 --update           # 更新服务"
+            echo "  $0 --update --with-nginx  # 更新服务并启动 Nginx"
+            echo "  $0 --status           # 查看服务状态"
+            echo "  $0 --cleanup          # 清理所有资源"
+            echo "  $0 --help             # 显示帮助"
+            ;;
+        *)
+            print_info "首次部署模式"
+            check_docker
+            create_directories
+            generate_config
+            build_image
+            start_services $1
+            show_status
+            show_access_info
+            ;;
+    esac
+}
+
+# 执行主函数
+main "$@"
diff --git a/docker-compose.yml b/docker-compose.yml
new file mode 100644
index 0000000..b9ffeb4
--- /dev/null
+++ b/docker-compose.yml
@@ -0,0 +1,92 @@
+services:
+  xianyu-app:
+    build:
+      context: .
+      dockerfile: Dockerfile
+    image: xianyu-auto-reply:latest
+    container_name: xianyu-auto-reply
+    restart: unless-stopped
+    # 使用root用户避免权限问题
+    user: "0:0"
+    ports:
+      - "${WEB_PORT:-8080}:8080"
+    volumes:
+      # 数据持久化
+      - ./data:/app/data:rw
+      - ./logs:/app/logs:rw
+      - ./global_config.yml:/app/global_config.yml:ro
+      # 可选：如果需要自定义配置
+      # - ./custom_config.yml:/app/global_config.yml:ro
+      # 可选：备份目录
+      - ./backups:/app/backups:rw
+    environment:
+      - PYTHONUNBUFFERED=${PYTHONUNBUFFERED:-1}
+      - PYTHONDONTWRITEBYTECODE=${PYTHONDONTWRITEBYTECODE:-1}
+      - TZ=${TZ:-Asia/Shanghai}
+      - DB_PATH=${DB_PATH:-/app/data/xianyu_data.db}
+      - LOG_LEVEL=${LOG_LEVEL:-INFO}
+      - DEBUG=${DEBUG:-false}
+      - RELOAD=${RELOAD:-false}
+      - ADMIN_USERNAME=${ADMIN_USERNAME:-admin}
+      - ADMIN_PASSWORD=${ADMIN_PASSWORD:-admin123}
+      - JWT_SECRET_KEY=${JWT_SECRET_KEY:-default-secret-key}
+      - SESSION_TIMEOUT=${SESSION_TIMEOUT:-3600}
+      - AUTO_REPLY_ENABLED=${AUTO_REPLY_ENABLED:-true}
+      - AUTO_DELIVERY_ENABLED=${AUTO_DELIVERY_ENABLED:-true}
+      - AUTO_DELIVERY_TIMEOUT=${AUTO_DELIVERY_TIMEOUT:-30}
+      - API_CARD_TIMEOUT=${API_CARD_TIMEOUT:-10}
+      - BATCH_DATA_LOCK_TIMEOUT=${BATCH_DATA_LOCK_TIMEOUT:-5}
+      - WEBSOCKET_URL=${WEBSOCKET_URL:-wss://wss-goofish.dingtalk.com/}
+      - HEARTBEAT_INTERVAL=${HEARTBEAT_INTERVAL:-15}
+      - HEARTBEAT_TIMEOUT=${HEARTBEAT_TIMEOUT:-5}
+      - TOKEN_REFRESH_INTERVAL=${TOKEN_REFRESH_INTERVAL:-3600}
+      - TOKEN_RETRY_INTERVAL=${TOKEN_RETRY_INTERVAL:-300}
+      - MESSAGE_EXPIRE_TIME=${MESSAGE_EXPIRE_TIME:-300000}
+    env_file:
+      - path: .env
+        required: false
+    networks:
+      - xianyu-network
+    healthcheck:
+      test: ["CMD", "curl", "-f", "http://localhost:8080/health"]
+      interval: 30s
+      timeout: 10s
+      retries: 3
+      start_period: 40s
+    # 资源限制
+    deploy:
+      resources:
+        limits:
+          memory: ${MEMORY_LIMIT:-512}M
+          cpus: '${CPU_LIMIT:-0.5}'
+        reservations:
+          memory: ${MEMORY_RESERVATION:-256}M
+          cpus: '${CPU_RESERVATION:-0.25}'
+
+  # 可选：添加Nginx反向代理
+  nginx:
+    image: nginx:alpine
+    container_name: xianyu-nginx
+    restart: unless-stopped
+    ports:
+      - "80:80"
+      - "443:443"
+    volumes:
+      - ./nginx/nginx.conf:/etc/nginx/nginx.conf:ro
+      - ./nginx/ssl:/etc/nginx/ssl:ro
+    depends_on:
+      - xianyu-app
+    networks:
+      - xianyu-network
+    profiles:
+      - with-nginx
+
+networks:
+  xianyu-network:
+    driver: bridge
+
+volumes:
+  xianyu-data:
+    driver: local
+  xianyu-logs:
+    driver: local
diff --git a/docker-deploy.bat b/docker-deploy.bat
new file mode 100644
index 0000000..671acb9
--- /dev/null
+++ b/docker-deploy.bat
@@ -0,0 +1,301 @@
+@echo off
+chcp 65001 >nul
+setlocal enabledelayedexpansion
+
+:: 闲鱼自动回复系统 Docker 部署脚本 (Windows版本)
+:: 支持快速部署和管理
+
+set PROJECT_NAME=xianyu-auto-reply
+set COMPOSE_FILE=docker-compose.yml
+set ENV_FILE=.env
+
+:: 颜色定义 (Windows 10+ 支持ANSI颜色)
+set "RED=[31m"
+set "GREEN=[32m"
+set "YELLOW=[33m"
+set "BLUE=[34m"
+set "NC=[0m"
+
+:: 打印带颜色的消息
+:print_info
+echo %BLUE%ℹ️  %~1%NC%
+goto :eof
+
+:print_success
+echo %GREEN%✅ %~1%NC%
+goto :eof
+
+:print_warning
+echo %YELLOW%⚠️  %~1%NC%
+goto :eof
+
+:print_error
+echo %RED%❌ %~1%NC%
+goto :eof
+
+:: 检查依赖
+:check_dependencies
+call :print_info "检查系统依赖..."
+
+docker --version >nul 2>&1
+if errorlevel 1 (
+    call :print_error "Docker 未安装，请先安装 Docker Desktop"
+    exit /b 1
+)
+
+docker-compose --version >nul 2>&1
+if errorlevel 1 (
+    call :print_error "Docker Compose 未安装，请先安装 Docker Compose"
+    exit /b 1
+)
+
+call :print_success "系统依赖检查通过"
+goto :eof
+
+:: 初始化配置
+:init_config
+call :print_info "初始化配置文件..."
+
+if not exist "%ENV_FILE%" (
+    if exist ".env.example" (
+        copy ".env.example" "%ENV_FILE%" >nul
+        call :print_success "已创建 %ENV_FILE% 配置文件"
+    ) else (
+        call :print_error ".env.example 文件不存在"
+        exit /b 1
+    )
+) else (
+    call :print_warning "%ENV_FILE% 已存在，跳过创建"
+)
+
+:: 创建必要的目录
+if not exist "data" mkdir data
+if not exist "logs" mkdir logs
+if not exist "backups" mkdir backups
+call :print_success "已创建必要的目录"
+goto :eof
+
+:: 构建镜像
+:build_image
+call :print_info "构建 Docker 镜像..."
+docker-compose build --no-cache
+if errorlevel 1 (
+    call :print_error "镜像构建失败"
+    exit /b 1
+)
+call :print_success "镜像构建完成"
+goto :eof
+
+:: 启动服务
+:start_services
+set "profile="
+if "%~1"=="with-nginx" (
+    set "profile=--profile with-nginx"
+    call :print_info "启动服务（包含 Nginx）..."
+) else (
+    call :print_info "启动基础服务..."
+)
+
+docker-compose %profile% up -d
+if errorlevel 1 (
+    call :print_error "服务启动失败"
+    exit /b 1
+)
+call :print_success "服务启动完成"
+
+:: 等待服务就绪
+call :print_info "等待服务就绪..."
+timeout /t 10 /nobreak >nul
+
+:: 检查服务状态
+docker-compose ps | findstr "Up" >nul
+if errorlevel 1 (
+    call :print_error "服务启动失败"
+    docker-compose logs
+    exit /b 1
+) else (
+    call :print_success "服务运行正常"
+    call :show_access_info "%~1"
+)
+goto :eof
+
+:: 停止服务
+:stop_services
+call :print_info "停止服务..."
+docker-compose down
+call :print_success "服务已停止"
+goto :eof
+
+:: 重启服务
+:restart_services
+call :print_info "重启服务..."
+docker-compose restart
+call :print_success "服务已重启"
+goto :eof
+
+:: 查看日志
+:show_logs
+if "%~1"=="" (
+    docker-compose logs -f
+) else (
+    docker-compose logs -f "%~1"
+)
+goto :eof
+
+:: 查看状态
+:show_status
+call :print_info "服务状态:"
+docker-compose ps
+
+call :print_info "资源使用:"
+for /f "tokens=*" %%i in ('docker-compose ps -q') do (
+    docker stats --no-stream %%i
+)
+goto :eof
+
+:: 显示访问信息
+:show_access_info
+echo.
+call :print_success "🎉 部署完成！"
+echo.
+
+if "%~1"=="with-nginx" (
+    echo 📱 访问地址:
+    echo    HTTP:  http://localhost
+    echo    HTTPS: https://localhost ^(如果配置了SSL^)
+) else (
+    echo 📱 访问地址:
+    echo    HTTP: http://localhost:8080
+)
+
+echo.
+echo 🔐 默认登录信息:
+echo    用户名: admin
+echo    密码:   admin123
+echo.
+echo 📊 管理命令:
+echo    查看状态: %~nx0 status
+echo    查看日志: %~nx0 logs
+echo    重启服务: %~nx0 restart
+echo    停止服务: %~nx0 stop
+echo.
+goto :eof
+
+:: 健康检查
+:health_check
+call :print_info "执行健康检查..."
+
+set "url=http://localhost:8080/health"
+set "max_attempts=30"
+set "attempt=1"
+
+:health_loop
+curl -f -s "%url%" >nul 2>&1
+if not errorlevel 1 (
+    call :print_success "健康检查通过"
+    goto :eof
+)
+
+call :print_info "等待服务就绪... (!attempt!/%max_attempts%)"
+timeout /t 2 /nobreak >nul
+set /a attempt+=1
+
+if !attempt! leq %max_attempts% goto health_loop
+
+call :print_error "健康检查失败"
+exit /b 1
+
+:: 备份数据
+:backup_data
+call :print_info "备份数据..."
+
+for /f "tokens=2 delims==" %%i in ('wmic OS Get localdatetime /value') do set datetime=%%i
+set backup_dir=backups\%datetime:~0,8%_%datetime:~8,6%
+mkdir "%backup_dir%" 2>nul
+
+:: 备份数据库
+if exist "data\xianyu_data.db" (
+    copy "data\xianyu_data.db" "%backup_dir%\" >nul
+    call :print_success "数据库备份完成"
+)
+
+:: 备份配置
+copy "%ENV_FILE%" "%backup_dir%\" >nul
+copy "global_config.yml" "%backup_dir%\" >nul 2>&1
+
+call :print_success "数据备份完成: %backup_dir%"
+goto :eof
+
+:: 显示帮助信息
+:show_help
+echo 闲鱼自动回复系统 Docker 部署脚本 ^(Windows版本^)
+echo.
+echo 用法: %~nx0 [命令] [选项]
+echo.
+echo 命令:
+echo   init                初始化配置文件
+echo   build               构建 Docker 镜像
+echo   start [with-nginx]  启动服务^(可选包含 Nginx^)
+echo   stop                停止服务
+echo   restart             重启服务
+echo   status              查看服务状态
+echo   logs [service]      查看日志
+echo   health              健康检查
+echo   backup              备份数据
+echo   help                显示帮助信息
+echo.
+echo 示例:
+echo   %~nx0 init             # 初始化配置
+echo   %~nx0 start            # 启动基础服务
+echo   %~nx0 start with-nginx # 启动包含 Nginx 的服务
+echo   %~nx0 logs xianyu-app  # 查看应用日志
+echo.
+goto :eof
+
+:: 主函数
+:main
+if "%~1"=="init" (
+    call :check_dependencies
+    call :init_config
+) else if "%~1"=="build" (
+    call :check_dependencies
+    call :build_image
+) else if "%~1"=="start" (
+    call :check_dependencies
+    call :init_config
+    call :build_image
+    call :start_services "%~2"
+) else if "%~1"=="stop" (
+    call :stop_services
+) else if "%~1"=="restart" (
+    call :restart_services
+) else if "%~1"=="status" (
+    call :show_status
+) else if "%~1"=="logs" (
+    call :show_logs "%~2"
+) else if "%~1"=="health" (
+    call :health_check
+) else if "%~1"=="backup" (
+    call :backup_data
+) else if "%~1"=="help" (
+    call :show_help
+) else if "%~1"=="-h" (
+    call :show_help
+) else if "%~1"=="--help" (
+    call :show_help
+) else if "%~1"=="" (
+    call :print_info "快速部署模式"
+    call :check_dependencies
+    call :init_config
+    call :build_image
+    call :start_services
+) else (
+    call :print_error "未知命令: %~1"
+    call :show_help
+    exit /b 1
+)
+
+goto :eof
+
+:: 执行主函数
+call :main %*
diff --git a/docker-deploy.sh b/docker-deploy.sh
new file mode 100644
index 0000000..c79458a
--- /dev/null
+++ b/docker-deploy.sh
@@ -0,0 +1,350 @@
+#!/bin/bash
+
+# 闲鱼自动回复系统 Docker 部署脚本
+# 支持快速部署和管理
+
+set -e
+
+# 颜色定义
+RED='\033[0;31m'
+GREEN='\033[0;32m'
+YELLOW='\033[1;33m'
+BLUE='\033[0;34m'
+NC='\033[0m' # No Color
+
+# 项目配置
+PROJECT_NAME="xianyu-auto-reply"
+COMPOSE_FILE="docker-compose.yml"
+ENV_FILE=".env"
+
+# 打印带颜色的消息
+print_info() {
+    echo -e "${BLUE}ℹ️  $1${NC}"
+}
+
+print_success() {
+    echo -e "${GREEN}✅ $1${NC}"
+}
+
+print_warning() {
+    echo -e "${YELLOW}⚠️  $1${NC}"
+}
+
+print_error() {
+    echo -e "${RED}❌ $1${NC}"
+}
+
+# 检查依赖
+check_dependencies() {
+    print_info "检查系统依赖..."
+    
+    if ! command -v docker &> /dev/null; then
+        print_error "Docker 未安装，请先安装 Docker"
+        exit 1
+    fi
+    
+    if ! command -v docker-compose &> /dev/null; then
+        print_error "Docker Compose 未安装，请先安装 Docker Compose"
+        exit 1
+    fi
+    
+    print_success "系统依赖检查通过"
+}
+
+# 初始化配置
+init_config() {
+    print_info "初始化配置文件..."
+    
+    if [ ! -f "$ENV_FILE" ]; then
+        if [ -f ".env.example" ]; then
+            cp .env.example "$ENV_FILE"
+            print_success "已创建 $ENV_FILE 配置文件"
+        else
+            print_error ".env.example 文件不存在"
+            exit 1
+        fi
+    else
+        print_warning "$ENV_FILE 已存在，跳过创建"
+    fi
+    
+    # 创建必要的目录
+    mkdir -p data logs backups
+    print_success "已创建必要的目录"
+}
+
+# 构建镜像
+build_image() {
+    print_info "构建 Docker 镜像..."
+    docker-compose build --no-cache
+    print_success "镜像构建完成"
+}
+
+# 启动服务
+start_services() {
+    local profile=""
+    if [ "$1" = "with-nginx" ]; then
+        profile="--profile with-nginx"
+        print_info "启动服务（包含 Nginx）..."
+    else
+        print_info "启动基础服务..."
+    fi
+    
+    docker-compose $profile up -d
+    print_success "服务启动完成"
+    
+    # 等待服务就绪
+    print_info "等待服务就绪..."
+    sleep 10
+    
+    # 检查服务状态
+    if docker-compose ps | grep -q "Up"; then
+        print_success "服务运行正常"
+        show_access_info "$1"
+    else
+        print_error "服务启动失败"
+        docker-compose logs
+        exit 1
+    fi
+}
+
+# 停止服务
+stop_services() {
+    print_info "停止服务..."
+    docker-compose down
+    print_success "服务已停止"
+}
+
+# 重启服务
+restart_services() {
+    print_info "重启服务..."
+    docker-compose restart
+    print_success "服务已重启"
+}
+
+# 查看日志
+show_logs() {
+    local service="$1"
+    if [ -z "$service" ]; then
+        docker-compose logs -f
+    else
+        docker-compose logs -f "$service"
+    fi
+}
+
+# 查看状态
+show_status() {
+    print_info "服务状态:"
+    docker-compose ps
+    
+    print_info "资源使用:"
+    docker stats --no-stream $(docker-compose ps -q)
+}
+
+# 显示访问信息
+show_access_info() {
+    local with_nginx="$1"
+    
+    echo ""
+    print_success "🎉 部署完成！"
+    echo ""
+    
+    if [ "$with_nginx" = "with-nginx" ]; then
+        echo "📱 访问地址:"
+        echo "   HTTP:  http://localhost"
+        echo "   HTTPS: https://localhost (如果配置了SSL)"
+    else
+        echo "📱 访问地址:"
+        echo "   HTTP: http://localhost:8080"
+    fi
+    
+    echo ""
+    echo "🔐 默认登录信息:"
+    echo "   用户名: admin"
+    echo "   密码:   admin123"
+    echo ""
+    echo "📊 管理命令:"
+    echo "   查看状态: $0 status"
+    echo "   查看日志: $0 logs"
+    echo "   重启服务: $0 restart"
+    echo "   停止服务: $0 stop"
+    echo ""
+}
+
+# 健康检查
+health_check() {
+    print_info "执行健康检查..."
+    
+    local url="http://localhost:8080/health"
+    local max_attempts=30
+    local attempt=1
+    
+    while [ $attempt -le $max_attempts ]; do
+        if curl -f -s "$url" > /dev/null 2>&1; then
+            print_success "健康检查通过"
+            return 0
+        fi
+        
+        print_info "等待服务就绪... ($attempt/$max_attempts)"
+        sleep 2
+        ((attempt++))
+    done
+    
+    print_error "健康检查失败"
+    return 1
+}
+
+# 备份数据
+backup_data() {
+    print_info "备份数据..."
+    
+    local backup_dir="backups/$(date +%Y%m%d_%H%M%S)"
+    mkdir -p "$backup_dir"
+    
+    # 备份数据库
+    if [ -f "data/xianyu_data.db" ]; then
+        cp data/xianyu_data.db "$backup_dir/"
+        print_success "数据库备份完成"
+    fi
+    
+    # 备份配置
+    cp "$ENV_FILE" "$backup_dir/"
+    cp global_config.yml "$backup_dir/" 2>/dev/null || true
+    
+    print_success "数据备份完成: $backup_dir"
+}
+
+# 更新部署
+update_deployment() {
+    print_info "更新部署..."
+    
+    # 备份数据
+    backup_data
+    
+    # 停止服务
+    stop_services
+    
+    # 拉取最新代码（如果是git仓库）
+    if [ -d ".git" ]; then
+        print_info "拉取最新代码..."
+        git pull
+    fi
+    
+    # 重新构建
+    build_image
+    
+    # 启动服务
+    start_services
+    
+    print_success "更新完成"
+}
+
+# 清理环境
+cleanup() {
+    print_warning "这将删除所有容器、镜像和数据，确定要继续吗？(y/N)"
+    read -r response
+    
+    if [[ "$response" =~ ^[Yy]$ ]]; then
+        print_info "清理环境..."
+        
+        # 停止并删除容器
+        docker-compose down -v --rmi all
+        
+        # 删除数据目录
+        rm -rf data logs backups
+        
+        print_success "环境清理完成"
+    else
+        print_info "取消清理操作"
+    fi
+}
+
+# 显示帮助信息
+show_help() {
+    echo "闲鱼自动回复系统 Docker 部署脚本"
+    echo ""
+    echo "用法: $0 [命令] [选项]"
+    echo ""
+    echo "命令:"
+    echo "  init                初始化配置文件"
+    echo "  build               构建 Docker 镜像"
+    echo "  start [with-nginx]  启动服务（可选包含 Nginx）"
+    echo "  stop                停止服务"
+    echo "  restart             重启服务"
+    echo "  status              查看服务状态"
+    echo "  logs [service]      查看日志"
+    echo "  health              健康检查"
+    echo "  backup              备份数据"
+    echo "  update              更新部署"
+    echo "  cleanup             清理环境"
+    echo "  help                显示帮助信息"
+    echo ""
+    echo "示例:"
+    echo "  $0 init             # 初始化配置"
+    echo "  $0 start            # 启动基础服务"
+    echo "  $0 start with-nginx # 启动包含 Nginx 的服务"
+    echo "  $0 logs xianyu-app  # 查看应用日志"
+    echo ""
+}
+
+# 主函数
+main() {
+    case "$1" in
+        "init")
+            check_dependencies
+            init_config
+            ;;
+        "build")
+            check_dependencies
+            build_image
+            ;;
+        "start")
+            check_dependencies
+            init_config
+            build_image
+            start_services "$2"
+            ;;
+        "stop")
+            stop_services
+            ;;
+        "restart")
+            restart_services
+            ;;
+        "status")
+            show_status
+            ;;
+        "logs")
+            show_logs "$2"
+            ;;
+        "health")
+            health_check
+            ;;
+        "backup")
+            backup_data
+            ;;
+        "update")
+            check_dependencies
+            update_deployment
+            ;;
+        "cleanup")
+            cleanup
+            ;;
+        "help"|"--help"|"-h")
+            show_help
+            ;;
+        "")
+            print_info "快速部署模式"
+            check_dependencies
+            init_config
+            build_image
+            start_services
+            ;;
+        *)
+            print_error "未知命令: $1"
+            show_help
+            exit 1
+            ;;
+    esac
+}
+
+# 执行主函数
+main "$@"
diff --git a/file_log_collector.py b/file_log_collector.py
new file mode 100644
index 0000000..7dd51e7
--- /dev/null
+++ b/file_log_collector.py
@@ -0,0 +1,240 @@
+#!/usr/bin/env python3
+"""
+基于文件监控的日志收集器
+"""
+
+import os
+import re
+import time
+import threading
+from collections import deque
+from datetime import datetime
+from typing import List, Dict, Optional
+from pathlib import Path
+
+class FileLogCollector:
+    """基于文件监控的日志收集器"""
+    
+    def __init__(self, max_logs: int = 2000):
+        self.max_logs = max_logs
+        self.logs = deque(maxlen=max_logs)
+        self.lock = threading.Lock()
+        
+        # 日志文件路径
+        self.log_file = None
+        self.last_position = 0
+        
+        # 启动文件监控
+        self.setup_file_monitoring()
+    
+    def setup_file_monitoring(self):
+        """设置文件监控"""
+        # 查找日志文件
+        possible_files = [
+            "xianyu.log",
+            "app.log", 
+            "system.log",
+            "logs/xianyu.log",
+            "logs/app.log"
+        ]
+        
+        for file_path in possible_files:
+            if os.path.exists(file_path):
+                self.log_file = file_path
+                break
+        
+        if not self.log_file:
+            # 如果没有找到现有文件，创建一个新的
+            self.log_file = "realtime.log"
+            
+        # 设置loguru输出到文件
+        self.setup_loguru_file_output()
+        
+        # 启动文件监控线程
+        self.monitor_thread = threading.Thread(target=self.monitor_file, daemon=True)
+        self.monitor_thread.start()
+    
+    def setup_loguru_file_output(self):
+        """设置loguru输出到文件"""
+        try:
+            from loguru import logger
+            
+            # 添加文件输出
+            logger.add(
+                self.log_file,
+                format="{time:YYYY-MM-DD HH:mm:ss.SSS} | {level} | {name}:{function}:{line} - {message}",
+                level="DEBUG",
+                rotation="10 MB",
+                retention="7 days",
+                enqueue=False,  # 改为False，避免队列延迟
+                buffering=1     # 行缓冲，立即写入
+            )
+            
+            logger.info("文件日志收集器已启动")
+            
+        except ImportError:
+            pass
+    
+    def monitor_file(self):
+        """监控日志文件变化"""
+        while True:
+            try:
+                if os.path.exists(self.log_file):
+                    # 获取文件大小
+                    file_size = os.path.getsize(self.log_file)
+                    
+                    if file_size > self.last_position:
+                        # 读取新增内容
+                        with open(self.log_file, 'r', encoding='utf-8') as f:
+                            f.seek(self.last_position)
+                            new_lines = f.readlines()
+                            self.last_position = f.tell()
+                        
+                        # 解析新增的日志行
+                        for line in new_lines:
+                            self.parse_log_line(line.strip())
+                
+                time.sleep(0.5)  # 每0.5秒检查一次
+                
+            except Exception as e:
+                time.sleep(1)  # 出错时等待1秒
+    
+    def parse_log_line(self, line: str):
+        """解析日志行"""
+        if not line:
+            return
+        
+        try:
+            # 解析loguru格式的日志
+            # 格式: 2025-07-23 15:46:03.430 | INFO | __main__:debug_collector:70 - 消息
+            pattern = r'(\d{4}-\d{2}-\d{2} \d{2}:\d{2}:\d{2}\.\d{3}) \| (\w+) \| ([^:]+):([^:]+):(\d+) - (.*)'
+            match = re.match(pattern, line)
+            
+            if match:
+                timestamp_str, level, source, function, line_num, message = match.groups()
+                
+                # 转换时间格式
+                try:
+                    timestamp = datetime.strptime(timestamp_str, '%Y-%m-%d %H:%M:%S.%f')
+                except:
+                    timestamp = datetime.now()
+                
+                log_entry = {
+                    "timestamp": timestamp.isoformat(),
+                    "level": level,
+                    "source": source,
+                    "function": function,
+                    "line": int(line_num),
+                    "message": message
+                }
+                
+                with self.lock:
+                    self.logs.append(log_entry)
+            
+        except Exception as e:
+            # 如果解析失败，作为普通消息处理
+            log_entry = {
+                "timestamp": datetime.now().isoformat(),
+                "level": "INFO",
+                "source": "system",
+                "function": "unknown",
+                "line": 0,
+                "message": line
+            }
+            
+            with self.lock:
+                self.logs.append(log_entry)
+    
+    def get_logs(self, lines: int = 200, level_filter: str = None, source_filter: str = None) -> List[Dict]:
+        """获取日志记录"""
+        with self.lock:
+            logs_list = list(self.logs)
+        
+        # 应用过滤器
+        if level_filter:
+            logs_list = [log for log in logs_list if log['level'] == level_filter]
+        
+        if source_filter:
+            logs_list = [log for log in logs_list if source_filter.lower() in log['source'].lower()]
+        
+        # 返回最后N行
+        return logs_list[-lines:] if len(logs_list) > lines else logs_list
+    
+    def clear_logs(self):
+        """清空日志"""
+        with self.lock:
+            self.logs.clear()
+    
+    def get_stats(self) -> Dict:
+        """获取日志统计信息"""
+        with self.lock:
+            total_logs = len(self.logs)
+            
+            # 统计各级别日志数量
+            level_counts = {}
+            source_counts = {}
+            
+            for log in self.logs:
+                level = log['level']
+                source = log['source']
+                
+                level_counts[level] = level_counts.get(level, 0) + 1
+                source_counts[source] = source_counts.get(source, 0) + 1
+            
+            return {
+                "total_logs": total_logs,
+                "level_counts": level_counts,
+                "source_counts": source_counts,
+                "max_capacity": self.max_logs,
+                "log_file": self.log_file
+            }
+
+
+# 全局文件日志收集器实例
+_file_collector = None
+_file_collector_lock = threading.Lock()
+
+
+def get_file_log_collector() -> FileLogCollector:
+    """获取全局文件日志收集器实例"""
+    global _file_collector
+    
+    if _file_collector is None:
+        with _file_collector_lock:
+            if _file_collector is None:
+                _file_collector = FileLogCollector(max_logs=2000)
+    
+    return _file_collector
+
+
+def setup_file_logging():
+    """设置文件日志系统"""
+    collector = get_file_log_collector()
+    return collector
+
+
+if __name__ == "__main__":
+    # 测试文件日志收集器
+    collector = setup_file_logging()
+    
+    # 生成一些测试日志
+    from loguru import logger
+    
+    logger.info("文件日志收集器测试开始")
+    logger.debug("这是调试信息")
+    logger.warning("这是警告信息")
+    logger.error("这是错误信息")
+    logger.info("文件日志收集器测试结束")
+    
+    # 等待文件写入和监控
+    time.sleep(2)
+    
+    # 获取日志
+    logs = collector.get_logs(10)
+    print(f"收集到 {len(logs)} 条日志:")
+    for log in logs:
+        print(f"  [{log['level']}] {log['source']}: {log['message']}")
+    
+    # 获取统计信息
+    stats = collector.get_stats()
+    print(f"\n统计信息: {stats}")
diff --git a/fix-db-permissions.bat b/fix-db-permissions.bat
new file mode 100644
index 0000000..fdcb358
--- /dev/null
+++ b/fix-db-permissions.bat
@@ -0,0 +1,156 @@
+@echo off
+chcp 65001 >nul
+setlocal enabledelayedexpansion
+
+:: 修复数据库权限问题的脚本 (Windows版本)
+:: 解决Docker容器中数据库无法创建的问题
+
+title 数据库权限修复脚本
+
+:: 颜色定义
+set "RED=[91m"
+set "GREEN=[92m"
+set "YELLOW=[93m"
+set "BLUE=[94m"
+set "NC=[0m"
+
+:: 打印带颜色的消息
+:print_info
+echo %BLUE%[INFO]%NC% %~1
+goto :eof
+
+:print_success
+echo %GREEN%[SUCCESS]%NC% %~1
+goto :eof
+
+:print_warning
+echo %YELLOW%[WARNING]%NC% %~1
+goto :eof
+
+:print_error
+echo %RED%[ERROR]%NC% %~1
+goto :eof
+
+echo ========================================
+echo   数据库权限修复脚本
+echo ========================================
+echo.
+
+:: 1. 停止现有容器
+call :print_info "停止现有容器..."
+docker-compose down >nul 2>&1
+
+:: 2. 检查并创建目录
+call :print_info "检查并创建必要目录..."
+
+for %%d in (data logs backups) do (
+    if not exist "%%d" (
+        call :print_info "创建目录: %%d"
+        mkdir "%%d"
+    )
+    
+    if not exist "%%d" (
+        call :print_error "目录 %%d 创建失败"
+        pause
+        exit /b 1
+    )
+    
+    call :print_success "目录 %%d 权限正常"
+)
+
+:: 3. 检查现有数据库文件
+if exist "data\xianyu_data.db" (
+    call :print_info "检查现有数据库文件..."
+    call :print_success "数据库文件存在"
+) else (
+    call :print_info "数据库文件不存在，将在启动时创建"
+)
+
+:: 4. 测试数据库创建
+call :print_info "测试数据库创建..."
+python -c "
+import sqlite3
+import os
+
+db_path = 'data/test_db.sqlite'
+try:
+    conn = sqlite3.connect(db_path)
+    conn.execute('CREATE TABLE IF NOT EXISTS test (id INTEGER PRIMARY KEY)')
+    conn.commit()
+    conn.close()
+    print('✅ 数据库创建测试成功')
+    if os.path.exists(db_path):
+        os.remove(db_path)
+except Exception as e:
+    print(f'❌ 数据库创建测试失败: {e}')
+    exit(1)
+"
+
+if !errorlevel! neq 0 (
+    call :print_error "数据库创建测试失败"
+    pause
+    exit /b 1
+)
+
+:: 5. 重新构建并启动
+call :print_info "重新构建并启动服务..."
+docker-compose build --no-cache
+if !errorlevel! neq 0 (
+    call :print_error "Docker镜像构建失败"
+    pause
+    exit /b 1
+)
+
+docker-compose up -d
+if !errorlevel! neq 0 (
+    call :print_error "服务启动失败"
+    pause
+    exit /b 1
+)
+
+:: 6. 等待服务启动
+call :print_info "等待服务启动..."
+timeout /t 15 /nobreak >nul
+
+:: 7. 检查服务状态
+call :print_info "检查服务状态..."
+docker-compose ps | findstr "Up" >nul
+if !errorlevel! equ 0 (
+    call :print_success "服务启动成功"
+    
+    :: 检查日志
+    call :print_info "检查启动日志..."
+    docker-compose logs --tail=20 xianyu-app
+    
+    :: 测试健康检查
+    call :print_info "测试健康检查..."
+    timeout /t 5 /nobreak >nul
+    curl -f http://localhost:8080/health >nul 2>&1
+    if !errorlevel! equ 0 (
+        call :print_success "健康检查通过"
+    ) else (
+        call :print_warning "健康检查失败，但服务可能仍在启动中"
+    )
+) else (
+    call :print_error "服务启动失败"
+    call :print_info "查看错误日志:"
+    docker-compose logs xianyu-app
+    pause
+    exit /b 1
+)
+
+echo.
+call :print_success "数据库权限修复完成！"
+echo.
+call :print_info "服务信息:"
+echo   Web界面: http://localhost:8080
+echo   健康检查: http://localhost:8080/health
+echo   默认账号: admin / admin123
+echo.
+call :print_info "常用命令:"
+echo   查看日志: docker-compose logs -f
+echo   重启服务: docker-compose restart
+echo   停止服务: docker-compose down
+echo.
+
+pause
diff --git a/fix-db-permissions.sh b/fix-db-permissions.sh
new file mode 100644
index 0000000..e6ea4ff
--- /dev/null
+++ b/fix-db-permissions.sh
@@ -0,0 +1,167 @@
+#!/bin/bash
+
+# 修复数据库权限问题的脚本
+# 解决Docker容器中数据库无法创建的问题
+
+set -e
+
+# 颜色定义
+RED='\033[0;31m'
+GREEN='\033[0;32m'
+YELLOW='\033[1;33m'
+BLUE='\033[0;34m'
+NC='\033[0m' # No Color
+
+print_info() {
+    echo -e "${BLUE}[INFO]${NC} $1"
+}
+
+print_success() {
+    echo -e "${GREEN}[SUCCESS]${NC} $1"
+}
+
+print_warning() {
+    echo -e "${YELLOW}[WARNING]${NC} $1"
+}
+
+print_error() {
+    echo -e "${RED}[ERROR]${NC} $1"
+}
+
+echo "========================================"
+echo "  数据库权限修复脚本"
+echo "========================================"
+echo ""
+
+# 1. 停止现有容器
+print_info "停止现有容器..."
+docker-compose down 2>/dev/null || true
+
+# 2. 检查并创建目录
+print_info "检查并创建必要目录..."
+for dir in data logs backups; do
+    if [ ! -d "$dir" ]; then
+        print_info "创建目录: $dir"
+        mkdir -p "$dir"
+    fi
+    
+    # 设置权限
+    chmod 755 "$dir"
+    
+    # 检查权限
+    if [ ! -w "$dir" ]; then
+        print_error "目录 $dir 没有写权限"
+        
+        # 尝试修复权限
+        print_info "尝试修复权限..."
+        sudo chmod 755 "$dir" 2>/dev/null || {
+            print_error "无法修复权限，请手动执行: sudo chmod 755 $dir"
+            exit 1
+        }
+    fi
+    
+    print_success "目录 $dir 权限正常"
+done
+
+# 3. 检查现有数据库文件
+if [ -f "data/xianyu_data.db" ]; then
+    print_info "检查现有数据库文件权限..."
+    if [ ! -w "data/xianyu_data.db" ]; then
+        print_warning "数据库文件没有写权限，尝试修复..."
+        chmod 644 "data/xianyu_data.db"
+        print_success "数据库文件权限已修复"
+    else
+        print_success "数据库文件权限正常"
+    fi
+fi
+
+# 4. 检查Docker用户映射
+print_info "检查Docker用户映射..."
+CURRENT_UID=$(id -u)
+CURRENT_GID=$(id -g)
+
+print_info "当前用户 UID:GID = $CURRENT_UID:$CURRENT_GID"
+
+# 5. 创建测试数据库
+print_info "测试数据库创建..."
+python3 -c "
+import sqlite3
+import os
+
+db_path = 'data/test_db.sqlite'
+try:
+    conn = sqlite3.connect(db_path)
+    conn.execute('CREATE TABLE IF NOT EXISTS test (id INTEGER PRIMARY KEY)')
+    conn.commit()
+    conn.close()
+    print('✅ 数据库创建测试成功')
+    os.remove(db_path)
+except Exception as e:
+    print(f'❌ 数据库创建测试失败: {e}')
+    exit(1)
+" || {
+    print_error "数据库创建测试失败"
+    exit 1
+}
+
+# 6. 更新docker-compose.yml用户映射
+print_info "检查docker-compose.yml用户映射..."
+if ! grep -q "user:" docker-compose.yml; then
+    print_info "添加用户映射到docker-compose.yml..."
+    
+    # 备份原文件
+    cp docker-compose.yml docker-compose.yml.backup
+    
+    # 在xianyu-app服务中添加user配置
+    sed -i '/container_name: xianyu-auto-reply/a\    user: "'$CURRENT_UID':'$CURRENT_GID'"' docker-compose.yml
+    
+    print_success "用户映射已添加"
+else
+    print_info "用户映射已存在"
+fi
+
+# 7. 重新构建并启动
+print_info "重新构建并启动服务..."
+docker-compose build --no-cache
+docker-compose up -d
+
+# 8. 等待服务启动
+print_info "等待服务启动..."
+sleep 10
+
+# 9. 检查服务状态
+print_info "检查服务状态..."
+if docker-compose ps | grep -q "Up"; then
+    print_success "服务启动成功"
+    
+    # 检查日志
+    print_info "检查启动日志..."
+    docker-compose logs --tail=20 xianyu-app
+    
+    # 测试健康检查
+    print_info "测试健康检查..."
+    sleep 5
+    if curl -f http://localhost:8080/health >/dev/null 2>&1; then
+        print_success "健康检查通过"
+    else
+        print_warning "健康检查失败，但服务可能仍在启动中"
+    fi
+else
+    print_error "服务启动失败"
+    print_info "查看错误日志:"
+    docker-compose logs xianyu-app
+    exit 1
+fi
+
+echo ""
+print_success "数据库权限修复完成！"
+echo ""
+print_info "服务信息:"
+echo "  Web界面: http://localhost:8080"
+echo "  健康检查: http://localhost:8080/health"
+echo "  默认账号: admin / admin123"
+echo ""
+print_info "常用命令:"
+echo "  查看日志: docker-compose logs -f"
+echo "  重启服务: docker-compose restart"
+echo "  停止服务: docker-compose down"
diff --git a/fix-docker-warnings.bat b/fix-docker-warnings.bat
new file mode 100644
index 0000000..6810784
--- /dev/null
+++ b/fix-docker-warnings.bat
@@ -0,0 +1,144 @@
+@echo off
+chcp 65001 >nul
+setlocal enabledelayedexpansion
+
+:: 修复Docker部署警告的快速脚本 (Windows版本)
+:: 解决version过时和.env文件缺失问题
+
+title Docker部署警告修复脚本
+
+:: 颜色定义
+set "RED=[91m"
+set "GREEN=[92m"
+set "YELLOW=[93m"
+set "BLUE=[94m"
+set "NC=[0m"
+
+:: 打印带颜色的消息
+:print_info
+echo %BLUE%[INFO]%NC% %~1
+goto :eof
+
+:print_success
+echo %GREEN%[SUCCESS]%NC% %~1
+goto :eof
+
+:print_warning
+echo %YELLOW%[WARNING]%NC% %~1
+goto :eof
+
+:print_error
+echo %RED%[ERROR]%NC% %~1
+goto :eof
+
+echo ========================================
+echo   Docker部署警告修复脚本
+echo ========================================
+echo.
+
+:: 1. 检查并创建.env文件
+call :print_info "检查 .env 文件..."
+if not exist ".env" (
+    if exist ".env.example" (
+        call :print_info "从 .env.example 创建 .env 文件..."
+        copy ".env.example" ".env" >nul
+        call :print_success ".env 文件已创建"
+    ) else (
+        call :print_warning ".env.example 文件不存在"
+        call :print_info "创建基本的 .env 文件..."
+        
+        (
+        echo # 闲鱼自动回复系统 Docker 环境变量配置文件
+        echo.
+        echo # 基础配置
+        echo TZ=Asia/Shanghai
+        echo PYTHONUNBUFFERED=1
+        echo LOG_LEVEL=INFO
+        echo.
+        echo # 数据库配置
+        echo DB_PATH=/app/data/xianyu_data.db
+        echo.
+        echo # 服务配置
+        echo WEB_PORT=8080
+        echo.
+        echo # 安全配置
+        echo ADMIN_USERNAME=admin
+        echo ADMIN_PASSWORD=admin123
+        echo JWT_SECRET_KEY=xianyu-auto-reply-secret-key-2024
+        echo.
+        echo # 资源限制
+        echo MEMORY_LIMIT=512
+        echo CPU_LIMIT=0.5
+        echo MEMORY_RESERVATION=256
+        echo CPU_RESERVATION=0.25
+        echo.
+        echo # 自动回复配置
+        echo AUTO_REPLY_ENABLED=true
+        echo WEBSOCKET_URL=wss://wss-goofish.dingtalk.com/
+        echo HEARTBEAT_INTERVAL=15
+        echo TOKEN_REFRESH_INTERVAL=3600
+        ) > .env
+        
+        call :print_success "基本 .env 文件已创建"
+    )
+) else (
+    call :print_success ".env 文件已存在"
+)
+
+:: 2. 检查docker-compose.yml版本问题
+call :print_info "检查 docker-compose.yml 配置..."
+findstr /B "version:" docker-compose.yml >nul 2>&1
+if !errorlevel! equ 0 (
+    call :print_warning "发现过时的 version 字段"
+    call :print_info "移除 version 字段..."
+    
+    REM 备份原文件
+    copy docker-compose.yml docker-compose.yml.backup >nul
+    
+    REM 创建临时文件，移除version行
+    (
+    for /f "tokens=*" %%a in (docker-compose.yml) do (
+        echo %%a | findstr /B "version:" >nul
+        if !errorlevel! neq 0 (
+            echo %%a
+        )
+    )
+    ) > docker-compose.yml.tmp
+    
+    REM 替换原文件
+    move docker-compose.yml.tmp docker-compose.yml >nul
+    
+    call :print_success "已移除过时的 version 字段"
+    call :print_info "原文件已备份为 docker-compose.yml.backup"
+) else (
+    call :print_success "docker-compose.yml 配置正确"
+)
+
+:: 3. 验证修复结果
+call :print_info "验证修复结果..."
+
+echo.
+call :print_info "测试 Docker Compose 配置..."
+docker-compose config >nul 2>&1
+if !errorlevel! equ 0 (
+    call :print_success "Docker Compose 配置验证通过"
+) else (
+    call :print_error "Docker Compose 配置验证失败"
+    echo 请检查 docker-compose.yml 文件
+    pause
+    exit /b 1
+)
+
+echo.
+call :print_success "所有警告已修复！"
+echo.
+call :print_info "现在可以正常使用以下命令："
+echo   docker-compose up -d     # 启动服务
+echo   docker-compose ps        # 查看状态
+echo   docker-compose logs -f   # 查看日志
+echo.
+call :print_info "如果需要恢复原配置："
+echo   move docker-compose.yml.backup docker-compose.yml
+echo.
+
+pause
diff --git a/fix-docker-warnings.sh b/fix-docker-warnings.sh
new file mode 100644
index 0000000..63d63e5
--- /dev/null
+++ b/fix-docker-warnings.sh
@@ -0,0 +1,145 @@
+#!/bin/bash
+
+# 修复Docker部署警告的快速脚本
+# 解决version过时和.env文件缺失问题
+
+set -e
+
+# 颜色定义
+RED='\033[0;31m'
+GREEN='\033[0;32m'
+YELLOW='\033[1;33m'
+BLUE='\033[0;34m'
+NC='\033[0m' # No Color
+
+print_info() {
+    echo -e "${BLUE}[INFO]${NC} $1"
+}
+
+print_success() {
+    echo -e "${GREEN}[SUCCESS]${NC} $1"
+}
+
+print_warning() {
+    echo -e "${YELLOW}[WARNING]${NC} $1"
+}
+
+print_error() {
+    echo -e "${RED}[ERROR]${NC} $1"
+}
+
+echo "========================================"
+echo "  Docker部署警告修复脚本"
+echo "========================================"
+echo ""
+
+# 1. 检查并创建.env文件
+print_info "检查 .env 文件..."
+if [ ! -f ".env" ]; then
+    if [ -f ".env.example" ]; then
+        print_info "从 .env.example 创建 .env 文件..."
+        cp .env.example .env
+        print_success ".env 文件已创建"
+    else
+        print_warning ".env.example 文件不存在"
+        print_info "创建基本的 .env 文件..."
+        cat > .env << 'EOF'
+# 闲鱼自动回复系统 Docker 环境变量配置文件
+
+# 基础配置
+TZ=Asia/Shanghai
+PYTHONUNBUFFERED=1
+LOG_LEVEL=INFO
+
+# 数据库配置
+DB_PATH=/app/data/xianyu_data.db
+
+# 服务配置
+WEB_PORT=8080
+
+# 安全配置
+ADMIN_USERNAME=admin
+ADMIN_PASSWORD=admin123
+JWT_SECRET_KEY=xianyu-auto-reply-secret-key-2024
+
+# 资源限制
+MEMORY_LIMIT=512
+CPU_LIMIT=0.5
+MEMORY_RESERVATION=256
+CPU_RESERVATION=0.25
+
+# 自动回复配置
+AUTO_REPLY_ENABLED=true
+WEBSOCKET_URL=wss://wss-goofish.dingtalk.com/
+HEARTBEAT_INTERVAL=15
+TOKEN_REFRESH_INTERVAL=3600
+EOF
+        print_success "基本 .env 文件已创建"
+    fi
+else
+    print_success ".env 文件已存在"
+fi
+
+# 2. 检查docker-compose.yml版本问题
+print_info "检查 docker-compose.yml 配置..."
+if grep -q "^version:" docker-compose.yml 2>/dev/null; then
+    print_warning "发现过时的 version 字段"
+    print_info "移除 version 字段..."
+    
+    # 备份原文件
+    cp docker-compose.yml docker-compose.yml.backup
+    
+    # 移除version行
+    sed -i '/^version:/d' docker-compose.yml
+    sed -i '/^$/N;/^\n$/d' docker-compose.yml  # 移除空行
+    
+    print_success "已移除过时的 version 字段"
+    print_info "原文件已备份为 docker-compose.yml.backup"
+else
+    print_success "docker-compose.yml 配置正确"
+fi
+
+# 3. 检查env_file配置
+print_info "检查 env_file 配置..."
+if grep -A1 "env_file:" docker-compose.yml | grep -q "required: false"; then
+    print_success "env_file 配置正确"
+else
+    print_info "更新 env_file 配置为可选..."
+    
+    # 备份文件（如果还没备份）
+    if [ ! -f "docker-compose.yml.backup" ]; then
+        cp docker-compose.yml docker-compose.yml.backup
+    fi
+    
+    # 更新env_file配置
+    sed -i '/env_file:/,+1c\
+    env_file:\
+      - path: .env\
+        required: false' docker-compose.yml
+    
+    print_success "env_file 配置已更新"
+fi
+
+# 4. 验证修复结果
+print_info "验证修复结果..."
+
+echo ""
+print_info "测试 Docker Compose 配置..."
+if docker-compose config >/dev/null 2>&1; then
+    print_success "Docker Compose 配置验证通过"
+else
+    print_error "Docker Compose 配置验证失败"
+    echo "请检查 docker-compose.yml 文件"
+    exit 1
+fi
+
+echo ""
+print_success "所有警告已修复！"
+echo ""
+print_info "现在可以正常使用以下命令："
+echo "  docker-compose up -d     # 启动服务"
+echo "  docker-compose ps        # 查看状态"
+echo "  docker-compose logs -f   # 查看日志"
+echo ""
+print_info "如果需要恢复原配置："
+echo "  mv docker-compose.yml.backup docker-compose.yml"
diff --git a/fix-websocket-issue.sh b/fix-websocket-issue.sh
new file mode 100644
index 0000000..d874a86
--- /dev/null
+++ b/fix-websocket-issue.sh
@@ -0,0 +1,121 @@
+#!/bin/bash
+
+# 快速修复WebSocket兼容性问题
+# 解决 "extra_headers" 参数不支持的问题
+
+set -e
+
+# 颜色定义
+RED='\033[0;31m'
+GREEN='\033[0;32m'
+YELLOW='\033[1;33m'
+BLUE='\033[0;34m'
+NC='\033[0m'
+
+print_info() {
+    echo -e "${BLUE}[INFO]${NC} $1"
+}
+
+print_success() {
+    echo -e "${GREEN}[SUCCESS]${NC} $1"
+}
+
+print_warning() {
+    echo -e "${YELLOW}[WARNING]${NC} $1"
+}
+
+print_error() {
+    echo -e "${RED}[ERROR]${NC} $1"
+}
+
+echo "🔧 WebSocket兼容性问题修复"
+echo "================================"
+
+# 1. 检查当前websockets版本
+print_info "检查当前websockets版本..."
+if command -v python3 &> /dev/null; then
+    PYTHON_CMD="python3"
+elif command -v python &> /dev/null; then
+    PYTHON_CMD="python"
+else
+    print_error "未找到Python解释器"
+    exit 1
+fi
+
+CURRENT_VERSION=$($PYTHON_CMD -c "import websockets; print(websockets.__version__)" 2>/dev/null || echo "未安装")
+print_info "当前websockets版本: $CURRENT_VERSION"
+
+# 2. 测试WebSocket兼容性
+print_info "测试WebSocket兼容性..."
+$PYTHON_CMD test-websocket-compatibility.py
+
+# 3. 停止现有服务
+print_info "停止现有Docker服务..."
+docker-compose down 2>/dev/null || true
+
+# 4. 更新websockets版本
+print_info "更新websockets版本到兼容版本..."
+if [ -f "requirements.txt" ]; then
+    # 备份原文件
+    cp requirements.txt requirements.txt.backup
+    
+    # 更新websockets版本
+    sed -i 's/websockets>=.*/websockets>=10.0,<13.0  # 兼容性版本范围/' requirements.txt
+    
+    print_success "requirements.txt已更新"
+else
+    print_warning "requirements.txt文件不存在"
+fi
+
+# 5. 重新构建Docker镜像
+print_info "重新构建Docker镜像..."
+docker-compose build --no-cache
+
+# 6. 启动服务
+print_info "启动服务..."
+docker-compose up -d
+
+# 7. 等待服务启动
+print_info "等待服务启动..."
+sleep 15
+
+# 8. 检查服务状态
+print_info "检查服务状态..."
+if docker-compose ps | grep -q "Up"; then
+    print_success "✅ 服务启动成功！"
+    
+    # 检查WebSocket错误
+    print_info "检查WebSocket连接状态..."
+    sleep 5
+    
+    # 查看最近的日志
+    echo ""
+    print_info "最近的服务日志："
+    docker-compose logs --tail=20 xianyu-app | grep -E "(WebSocket|extra_headers|ERROR)" || echo "未发现WebSocket相关错误"
+    
+    # 测试健康检查
+    if curl -f http://localhost:8080/health >/dev/null 2>&1; then
+        print_success "健康检查通过"
+    else
+        print_warning "健康检查失败，服务可能仍在启动中"
+    fi
+    
+else
+    print_error "❌ 服务启动失败"
+    print_info "查看错误日志:"
+    docker-compose logs --tail=30 xianyu-app
+    exit 1
+fi
+
+echo ""
+print_success "🎉 WebSocket兼容性问题修复完成！"
+echo ""
+print_info "服务信息:"
+echo "  Web界面: http://localhost:8080"
+echo "  健康检查: http://localhost:8080/health"
+echo "  默认账号: admin / admin123"
+echo ""
+print_info "如果仍有WebSocket问题，请："
+echo "  1. 查看日志: docker-compose logs -f xianyu-app"
+echo "  2. 运行测试: python test-websocket-compatibility.py"
+echo "  3. 检查网络连接和防火墙设置"
diff --git a/global_config.yml b/global_config.yml
new file mode 100644
index 0000000..467ad65
--- /dev/null
+++ b/global_config.yml
@@ -0,0 +1,73 @@
+API_ENDPOINTS:
+  login_check: https://passport.goofish.com/newlogin/hasLogin.do
+  message_headinfo: https://h5api.m.goofish.com/h5/mtop.idle.trade.pc.message.headinfo/1.0/
+  token: https://h5api.m.goofish.com/h5/mtop.taobao.idlemessage.pc.login.token/1.0/
+APP_CONFIG:
+  api_version: '1.0'
+  app_key: 444e9908a51d1cb236a27862abc769c9
+  app_version: '1.0'
+  platform: web
+AUTO_REPLY:
+  api:
+    enabled: true
+    host: 0.0.0.0  # 绑定所有网络接口，支持IP访问
+    port: 8080     # Web服务端口
+    timeout: 10
+    url: http://0.0.0.0:8080/xianyu/reply
+  default_message: 亲爱的"{send_user_name}" 老板你好！所有宝贝都可以拍，秒发货的哈~不满意的话可以直接申请退款哈~
+  enabled: true
+  max_retry: 3
+  retry_interval: 5
+ITEM_DETAIL:
+  auto_fetch:
+    enabled: true  # 是否启用自动获取商品详情
+    api_url: https://selfapi.zhinianboke.com/api/getItemDetail  # 外部API地址
+    timeout: 30  # 请求超时时间（秒）
+    max_concurrent: 3  # 最大并发请求数
+    retry_delay: 0.5  # 请求间隔（秒）
+COOKIES:
+  last_update_time: ''
+  value: ''
+DEFAULT_HEADERS:
+  accept: application/json
+  accept-language: zh-CN,zh;q=0.9
+  cache-control: no-cache
+  origin: https://www.goofish.com
+  pragma: no-cache
+  priority: u=1, i
+  referer: https://www.goofish.com/
+  sec-ch-ua: '"Not(A:Brand";v="99", "Google Chrome";v="133", "Chromium";v="133"'
+  sec-ch-ua-mobile: ?0
+  sec-ch-ua-platform: '"Windows"'
+  sec-fetch-dest: empty
+  sec-fetch-mode: cors
+  sec-fetch-site: same-site
+  user-agent: Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML,
+    like Gecko) Chrome/133.0.0.0 Safari/537.36
+HEARTBEAT_INTERVAL: 15
+HEARTBEAT_TIMEOUT: 5
+LOG_CONFIG:
+  compression: zip
+  format: '<green>{time:YYYY-MM-DD HH:mm:ss.SSS}</green> | <level>{level: <8}</level>
+    | <cyan>{name}</cyan>:<cyan>{function}</cyan>:<cyan>{line}</cyan> - <level>{message}</level>'
+  level: INFO
+  retention: 7 days
+  rotation: 1 day
+MANUAL_MODE:
+  enabled: false
+  timeout: 3600
+  toggle_keywords: []
+MESSAGE_EXPIRE_TIME: 300000
+TOKEN_REFRESH_INTERVAL: 3600
+TOKEN_RETRY_INTERVAL: 300
+WEBSOCKET_HEADERS:
+  Accept-Encoding: gzip, deflate, br, zstd
+  Accept-Language: zh-CN,zh;q=0.9
+  Cache-Control: no-cache
+  Connection: Upgrade
+  Host: wss-goofish.dingtalk.com
+  Origin: https://www.goofish.com
+  Pragma: no-cache
+  User-Agent: Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML,
+    like Gecko) Chrome/133.0.0.0 Safari/537.36
+WEBSOCKET_URL: wss://wss-goofish.dingtalk.com/
diff --git a/nginx/nginx.conf b/nginx/nginx.conf
new file mode 100644
index 0000000..cb8c977
--- /dev/null
+++ b/nginx/nginx.conf
@@ -0,0 +1,123 @@
+events {
+    worker_connections 1024;
+}
+
+http {
+    include       /etc/nginx/mime.types;
+    default_type  application/octet-stream;
+
+    # 日志格式
+    log_format main '$remote_addr - $remote_user [$time_local] "$request" '
+                    '$status $body_bytes_sent "$http_referer" '
+                    '"$http_user_agent" "$http_x_forwarded_for"';
+
+    access_log /var/log/nginx/access.log main;
+    error_log /var/log/nginx/error.log warn;
+
+    # 基本设置
+    sendfile on;
+    tcp_nopush on;
+    tcp_nodelay on;
+    keepalive_timeout 65;
+    types_hash_max_size 2048;
+    client_max_body_size 10M;
+
+    # Gzip压缩
+    gzip on;
+    gzip_vary on;
+    gzip_min_length 1024;
+    gzip_proxied any;
+    gzip_comp_level 6;
+    gzip_types
+        text/plain
+        text/css
+        text/xml
+        text/javascript
+        application/json
+        application/javascript
+        application/xml+rss
+        application/atom+xml
+        image/svg+xml;
+
+    # 上游服务器
+    upstream xianyu_backend {
+        server xianyu-app:8080;
+        keepalive 32;
+    }
+
+    # HTTP服务器配置
+    server {
+        listen 80;
+        server_name localhost;
+
+        # 安全头
+        add_header X-Frame-Options "SAMEORIGIN" always;
+        add_header X-XSS-Protection "1; mode=block" always;
+        add_header X-Content-Type-Options "nosniff" always;
+        add_header Referrer-Policy "no-referrer-when-downgrade" always;
+        add_header Content-Security-Policy "default-src 'self' http: https: data: blob: 'unsafe-inline'" always;
+
+        # 代理到后端应用
+        location / {
+            proxy_pass http://xianyu_backend;
+            proxy_http_version 1.1;
+            proxy_set_header Upgrade $http_upgrade;
+            proxy_set_header Connection 'upgrade';
+            proxy_set_header Host $host;
+            proxy_set_header X-Real-IP $remote_addr;
+            proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for;
+            proxy_set_header X-Forwarded-Proto $scheme;
+            proxy_cache_bypass $http_upgrade;
+            proxy_connect_timeout 30s;
+            proxy_send_timeout 30s;
+            proxy_read_timeout 30s;
+        }
+
+        # 静态文件缓存
+        location ~* \.(js|css|png|jpg|jpeg|gif|ico|svg)$ {
+            proxy_pass http://xianyu_backend;
+            expires 1y;
+            add_header Cache-Control "public, immutable";
+        }
+
+        # 健康检查
+        location /health {
+            proxy_pass http://xianyu_backend/health;
+            access_log off;
+        }
+
+        # 错误页面
+        error_page 500 502 503 504 /50x.html;
+        location = /50x.html {
+            root /usr/share/nginx/html;
+        }
+    }
+
+    # HTTPS服务器配置（可选）
+    # server {
+    #     listen 443 ssl http2;
+    #     server_name localhost;
+    #
+    #     ssl_certificate /etc/nginx/ssl/cert.pem;
+    #     ssl_certificate_key /etc/nginx/ssl/key.pem;
+    #     ssl_session_timeout 1d;
+    #     ssl_session_cache shared:MozTLS:10m;
+    #     ssl_session_tickets off;
+    #
+    #     ssl_protocols TLSv1.2 TLSv1.3;
+    #     ssl_ciphers ECDHE-ECDSA-AES128-GCM-SHA256:ECDHE-RSA-AES128-GCM-SHA256:ECDHE-ECDSA-AES256-GCM-SHA384:ECDHE-RSA-AES256-GCM-SHA384;
+    #     ssl_prefer_server_ciphers off;
+    #
+    #     location / {
+    #         proxy_pass http://xianyu_backend;
+    #         proxy_http_version 1.1;
+    #         proxy_set_header Upgrade $http_upgrade;
+    #         proxy_set_header Connection 'upgrade';
+    #         proxy_set_header Host $host;
+    #         proxy_set_header X-Real-IP $remote_addr;
+    #         proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for;
+    #         proxy_set_header X-Forwarded-Proto $scheme;
+    #         proxy_cache_bypass $http_upgrade;
+    #     }
+    # }
+}
diff --git a/quick-fix-permissions.bat b/quick-fix-permissions.bat
new file mode 100644
index 0000000..762e0e5
--- /dev/null
+++ b/quick-fix-permissions.bat
@@ -0,0 +1,116 @@
+@echo off
+chcp 65001 >nul
+setlocal enabledelayedexpansion
+
+:: 快速修复Docker权限问题 (Windows版本)
+
+title 快速修复Docker权限问题
+
+:: 颜色定义
+set "RED=[91m"
+set "GREEN=[92m"
+set "YELLOW=[93m"
+set "BLUE=[94m"
+set "NC=[0m"
+
+:print_info
+echo %BLUE%[INFO]%NC% %~1
+goto :eof
+
+:print_success
+echo %GREEN%[SUCCESS]%NC% %~1
+goto :eof
+
+:print_error
+echo %RED%[ERROR]%NC% %~1
+goto :eof
+
+echo 🚀 快速修复Docker权限问题
+echo ================================
+echo.
+
+:: 1. 停止容器
+call :print_info "停止现有容器..."
+docker-compose down >nul 2>&1
+
+:: 2. 确保目录存在
+call :print_info "创建必要目录..."
+if not exist "data" mkdir data
+if not exist "logs" mkdir logs
+if not exist "backups" mkdir backups
+
+:: 3. 检查并修复docker-compose.yml
+call :print_info "检查docker-compose.yml配置..."
+findstr /C:"user.*0:0" docker-compose.yml >nul 2>&1
+if !errorlevel! neq 0 (
+    call :print_info "添加root用户配置..."
+    
+    REM 备份原文件
+    copy docker-compose.yml docker-compose.yml.backup >nul
+    
+    REM 创建临时文件添加user配置
+    (
+    for /f "tokens=*" %%a in (docker-compose.yml) do (
+        echo %%a
+        echo %%a | findstr /C:"container_name: xianyu-auto-reply" >nul
+        if !errorlevel! equ 0 (
+            echo     user: "0:0"
+        )
+    )
+    ) > docker-compose.yml.tmp
+    
+    REM 替换原文件
+    move docker-compose.yml.tmp docker-compose.yml >nul
+    
+    call :print_success "已配置使用root用户运行"
+)
+
+:: 4. 重新构建镜像
+call :print_info "重新构建Docker镜像..."
+docker-compose build --no-cache
+if !errorlevel! neq 0 (
+    call :print_error "Docker镜像构建失败"
+    pause
+    exit /b 1
+)
+
+:: 5. 启动服务
+call :print_info "启动服务..."
+docker-compose up -d
+if !errorlevel! neq 0 (
+    call :print_error "服务启动失败"
+    pause
+    exit /b 1
+)
+
+:: 6. 等待启动
+call :print_info "等待服务启动..."
+timeout /t 15 /nobreak >nul
+
+:: 7. 检查状态
+call :print_info "检查服务状态..."
+docker-compose ps | findstr "Up" >nul
+if !errorlevel! equ 0 (
+    call :print_success "✅ 服务启动成功！"
+    
+    echo.
+    call :print_info "最近的日志："
+    docker-compose logs --tail=10 xianyu-app
+    
+    echo.
+    call :print_success "🎉 权限问题已修复！"
+    echo.
+    echo 访问信息：
+    echo   Web界面: http://localhost:8080
+    echo   健康检查: http://localhost:8080/health
+    echo   默认账号: admin / admin123
+    
+) else (
+    call :print_error "❌ 服务启动失败"
+    echo.
+    call :print_info "错误日志："
+    docker-compose logs xianyu-app
+)
+
+echo.
+pause
diff --git a/quick-fix-permissions.sh b/quick-fix-permissions.sh
new file mode 100644
index 0000000..fbe55de
--- /dev/null
+++ b/quick-fix-permissions.sh
@@ -0,0 +1,88 @@
+#!/bin/bash
+
+# 快速修复Docker权限问题
+# 这个脚本会立即解决权限问题并重启服务
+
+set -e
+
+# 颜色定义
+RED='\033[0;31m'
+GREEN='\033[0;32m'
+YELLOW='\033[1;33m'
+BLUE='\033[0;34m'
+NC='\033[0m'
+
+print_info() {
+    echo -e "${BLUE}[INFO]${NC} $1"
+}
+
+print_success() {
+    echo -e "${GREEN}[SUCCESS]${NC} $1"
+}
+
+print_error() {
+    echo -e "${RED}[ERROR]${NC} $1"
+}
+
+echo "🚀 快速修复Docker权限问题"
+echo "================================"
+
+# 1. 停止容器
+print_info "停止现有容器..."
+docker-compose down
+
+# 2. 确保目录存在并设置权限
+print_info "设置目录权限..."
+mkdir -p data logs backups
+chmod 777 data logs backups
+
+# 3. 检查并修复docker-compose.yml
+print_info "检查docker-compose.yml配置..."
+if ! grep -q "user.*0:0" docker-compose.yml; then
+    print_info "添加root用户配置..."
+    
+    # 备份原文件
+    cp docker-compose.yml docker-compose.yml.backup
+    
+    # 在container_name后添加user配置
+    sed -i '/container_name: xianyu-auto-reply/a\    user: "0:0"' docker-compose.yml
+    
+    print_success "已配置使用root用户运行"
+fi
+
+# 4. 重新构建镜像
+print_info "重新构建Docker镜像..."
+docker-compose build --no-cache
+
+# 5. 启动服务
+print_info "启动服务..."
+docker-compose up -d
+
+# 6. 等待启动
+print_info "等待服务启动..."
+sleep 15
+
+# 7. 检查状态
+print_info "检查服务状态..."
+if docker-compose ps | grep -q "Up"; then
+    print_success "✅ 服务启动成功！"
+    
+    # 显示日志
+    echo ""
+    print_info "最近的日志："
+    docker-compose logs --tail=10 xianyu-app
+    
+    echo ""
+    print_success "🎉 权限问题已修复！"
+    echo ""
+    echo "访问信息："
+    echo "  Web界面: http://localhost:8080"
+    echo "  健康检查: http://localhost:8080/health"
+    echo "  默认账号: admin / admin123"
+    
+else
+    print_error "❌ 服务启动失败"
+    echo ""
+    print_info "错误日志："
+    docker-compose logs xianyu-app
+fi
diff --git a/reply_server.py b/reply_server.py
new file mode 100644
index 0000000..6840cd5
--- /dev/null
+++ b/reply_server.py
@@ -0,0 +1,1152 @@
+from fastapi import FastAPI, HTTPException, Depends, status, UploadFile, File
+from fastapi.staticfiles import StaticFiles
+from fastapi.responses import HTMLResponse, RedirectResponse, JSONResponse
+from fastapi.security import HTTPBearer, HTTPAuthorizationCredentials
+from pydantic import BaseModel
+from typing import List, Tuple, Optional, Dict
+from pathlib import Path
+from urllib.parse import unquote
+import hashlib
+import secrets
+import time
+import json
+import os
+import uvicorn
+
+import cookie_manager
+from db_manager import db_manager
+from file_log_collector import setup_file_logging, get_file_log_collector
+
+# 关键字文件路径
+KEYWORDS_FILE = Path(__file__).parent / "回复关键字.txt"
+
+# 简单的用户认证配置
+ADMIN_USERNAME = "admin"
+ADMIN_PASSWORD_HASH = hashlib.sha256("admin123".encode()).hexdigest()  # 默认密码: admin123
+SESSION_TOKENS = {}  # 存储会话token
+TOKEN_EXPIRE_TIME = 24 * 60 * 60  # token过期时间：24小时
+
+# HTTP Bearer认证
+security = HTTPBearer(auto_error=False)
+
+
+def load_keywords() -> List[Tuple[str, str]]:
+    """读取关键字→回复映射表
+
+    文件格式支持：
+        关键字<空格/制表符/冒号>回复内容
+    忽略空行和以 # 开头的注释行
+    """
+    mapping: List[Tuple[str, str]] = []
+    if not KEYWORDS_FILE.exists():
+        return mapping
+
+    with KEYWORDS_FILE.open('r', encoding='utf-8') as f:
+        for line in f:
+            line = line.strip()
+            if not line or line.startswith('#'):
+                continue
+            # 尝试用\t、空格、冒号分隔
+            if '\t' in line:
+                key, reply = line.split('\t', 1)
+            elif ' ' in line:
+                key, reply = line.split(' ', 1)
+            elif ':' in line:
+                key, reply = line.split(':', 1)
+            else:
+                # 无法解析的行，跳过
+                continue
+            mapping.append((key.strip(), reply.strip()))
+    return mapping
+
+
+KEYWORDS_MAPPING = load_keywords()
+
+
+# 认证相关模型
+class LoginRequest(BaseModel):
+    username: str
+    password: str
+
+
+class LoginResponse(BaseModel):
+    success: bool
+    token: Optional[str] = None
+    message: str
+
+
+def generate_token() -> str:
+    """生成随机token"""
+    return secrets.token_urlsafe(32)
+
+
+def verify_token(credentials: Optional[HTTPAuthorizationCredentials] = Depends(security)) -> bool:
+    """验证token"""
+    if not credentials:
+        return False
+
+    token = credentials.credentials
+    if token not in SESSION_TOKENS:
+        return False
+
+    # 检查token是否过期
+    if time.time() - SESSION_TOKENS[token] > TOKEN_EXPIRE_TIME:
+        del SESSION_TOKENS[token]
+        return False
+
+    return True
+
+
+def require_auth(authenticated: bool = Depends(verify_token)):
+    """需要认证的依赖"""
+    if not authenticated:
+        raise HTTPException(status_code=401, detail="未授权访问")
+
+
+def match_reply(cookie_id: str, message: str) -> Optional[str]:
+    """根据 cookie_id 及消息内容匹配回复
+    只有启用的账号才会匹配关键字回复
+    """
+    mgr = cookie_manager.manager
+    if mgr is None:
+        return None
+
+    # 检查账号是否启用
+    if not mgr.get_cookie_status(cookie_id):
+        return None  # 禁用的账号不参与自动回复
+
+    # 优先账号级关键字
+    if mgr.get_keywords(cookie_id):
+        for k, r in mgr.get_keywords(cookie_id):
+            if k in message:
+                return r
+
+    # 全局关键字
+    for k, r in KEYWORDS_MAPPING:
+        if k in message:
+            return r
+    return None
+
+
+class RequestModel(BaseModel):
+    cookie_id: str
+    msg_time: str
+    user_url: str
+    send_user_id: str
+    send_user_name: str
+    item_id: str
+    send_message: str
+    chat_id: str
+
+
+class ResponseData(BaseModel):
+    send_msg: str
+
+
+class ResponseModel(BaseModel):
+    code: int
+    data: ResponseData
+
+
+app = FastAPI(
+    title="Xianyu Auto Reply API",
+    version="1.0.0",
+    description="闲鱼自动回复系统API",
+    docs_url="/docs",
+    redoc_url="/redoc"
+)
+
+# 初始化文件日志收集器
+setup_file_logging()
+
+# 添加一条测试日志
+from loguru import logger
+logger.info("Web服务器启动，文件日志收集器已初始化")
+
+# 添加请求日志中间件
+@app.middleware("http")
+async def log_requests(request, call_next):
+    start_time = time.time()
+    logger.info(f"🌐 API请求: {request.method} {request.url.path}")
+
+    response = await call_next(request)
+
+    process_time = time.time() - start_time
+    logger.info(f"✅ API响应: {request.method} {request.url.path} - {response.status_code} ({process_time:.3f}s)")
+
+    return response
+
+# 提供前端静态文件
+import os
+static_dir = os.path.join(os.path.dirname(__file__), 'static')
+if not os.path.exists(static_dir):
+    os.makedirs(static_dir, exist_ok=True)
+
+app.mount('/static', StaticFiles(directory=static_dir), name='static')
+
+
+# 健康检查端点
+@app.get('/health')
+async def health_check():
+    """健康检查端点，用于Docker健康检查和负载均衡器"""
+    try:
+        # 检查Cookie管理器状态
+        manager_status = "ok" if cookie_manager.manager is not None else "error"
+
+        # 检查数据库连接
+        from db_manager import db_manager
+        try:
+            db_manager.get_all_cookies()
+            db_status = "ok"
+        except Exception:
+            db_status = "error"
+
+        # 获取系统状态
+        import psutil
+        cpu_percent = psutil.cpu_percent(interval=1)
+        memory_info = psutil.virtual_memory()
+
+        status = {
+            "status": "healthy" if manager_status == "ok" and db_status == "ok" else "unhealthy",
+            "timestamp": time.time(),
+            "services": {
+                "cookie_manager": manager_status,
+                "database": db_status
+            },
+            "system": {
+                "cpu_percent": cpu_percent,
+                "memory_percent": memory_info.percent,
+                "memory_available": memory_info.available
+            }
+        }
+
+        if status["status"] == "unhealthy":
+            raise HTTPException(status_code=503, detail=status)
+
+        return status
+
+    except Exception as e:
+        return {
+            "status": "unhealthy",
+            "timestamp": time.time(),
+            "error": str(e)
+        }
+
+
+# 重定向根路径到登录页面
+@app.get('/', response_class=HTMLResponse)
+async def root():
+    login_path = os.path.join(static_dir, 'login.html')
+    if os.path.exists(login_path):
+        with open(login_path, 'r', encoding='utf-8') as f:
+            return HTMLResponse(f.read())
+    else:
+        return HTMLResponse('<h3>Login page not found</h3>')
+
+
+# 登录页面路由
+@app.get('/login.html', response_class=HTMLResponse)
+async def login_page():
+    login_path = os.path.join(static_dir, 'login.html')
+    if os.path.exists(login_path):
+        with open(login_path, 'r', encoding='utf-8') as f:
+            return HTMLResponse(f.read())
+    else:
+        return HTMLResponse('<h3>Login page not found</h3>')
+
+
+# 管理页面（不需要服务器端认证，由前端JavaScript处理）
+@app.get('/admin', response_class=HTMLResponse)
+async def admin_page():
+    index_path = os.path.join(static_dir, 'index.html')
+    if not os.path.exists(index_path):
+        return HTMLResponse('<h3>No front-end found</h3>')
+    with open(index_path, 'r', encoding='utf-8') as f:
+        return HTMLResponse(f.read())
+
+
+# 登录接口
+@app.post('/login')
+async def login(request: LoginRequest):
+    from db_manager import db_manager
+
+    # 验证用户名和密码
+    if request.username == ADMIN_USERNAME and db_manager.verify_admin_password(request.password):
+        # 生成token
+        token = generate_token()
+        SESSION_TOKENS[token] = time.time()
+
+        return LoginResponse(
+            success=True,
+            token=token,
+            message="登录成功"
+        )
+    else:
+        return LoginResponse(
+            success=False,
+            message="用户名或密码错误"
+        )
+
+
+# 验证token接口
+@app.get('/verify')
+async def verify(authenticated: bool = Depends(verify_token)):
+    return {"authenticated": authenticated}
+
+
+# 登出接口
+@app.post('/logout')
+async def logout(credentials: Optional[HTTPAuthorizationCredentials] = Depends(security)):
+    if credentials and credentials.credentials in SESSION_TOKENS:
+        del SESSION_TOKENS[credentials.credentials]
+    return {"message": "已登出"}
+
+
+@app.post("/xianyu/reply", response_model=ResponseModel)
+async def xianyu_reply(req: RequestModel):
+    msg_template = match_reply(req.cookie_id, req.send_message)
+    if not msg_template:
+        # 从数据库获取默认回复
+        from db_manager import db_manager
+        default_reply_settings = db_manager.get_default_reply(req.cookie_id)
+
+        if default_reply_settings and default_reply_settings.get('enabled', False):
+            msg_template = default_reply_settings.get('reply_content', '')
+
+        # 如果数据库中没有设置或为空，返回错误
+        if not msg_template:
+            raise HTTPException(status_code=404, detail="未找到匹配的回复规则且未设置默认回复")
+
+    # 按占位符格式化
+    try:
+        send_msg = msg_template.format(
+            send_user_id=req.send_user_id,
+            send_user_name=req.send_user_name,
+            send_message=req.send_message,
+        )
+    except Exception:
+        # 如果格式化失败，返回原始内容
+        send_msg = msg_template
+
+    return {"code": 200, "data": {"send_msg": send_msg}}
+
+# ------------------------- 账号 / 关键字管理接口 -------------------------
+
+
+class CookieIn(BaseModel):
+    id: str
+    value: str
+
+
+class CookieStatusIn(BaseModel):
+    enabled: bool
+
+
+class DefaultReplyIn(BaseModel):
+    enabled: bool
+    reply_content: Optional[str] = None
+
+
+class NotificationChannelIn(BaseModel):
+    name: str
+    type: str = "qq"
+    config: str
+
+
+class NotificationChannelUpdate(BaseModel):
+    name: str
+    config: str
+    enabled: bool = True
+
+
+class MessageNotificationIn(BaseModel):
+    channel_id: int
+    enabled: bool = True
+
+
+class SystemSettingIn(BaseModel):
+    key: str
+    value: str
+    description: Optional[str] = None
+
+
+class PasswordUpdateIn(BaseModel):
+    current_password: str
+    new_password: str
+
+
+@app.get("/cookies")
+def list_cookies(_: None = Depends(require_auth)):
+    if cookie_manager.manager is None:
+        return []
+    return cookie_manager.manager.list_cookies()
+
+
+@app.get("/cookies/details")
+def get_cookies_details(_: None = Depends(require_auth)):
+    """获取所有Cookie的详细信息（包括值和状态）"""
+    if cookie_manager.manager is None:
+        return []
+
+    result = []
+    for cookie_id in cookie_manager.manager.list_cookies():
+        cookie_value = cookie_manager.manager.cookies.get(cookie_id, '')
+        cookie_enabled = cookie_manager.manager.get_cookie_status(cookie_id)
+        result.append({
+            'id': cookie_id,
+            'value': cookie_value,
+            'enabled': cookie_enabled
+        })
+    return result
+
+
+@app.post("/cookies")
+def add_cookie(item: CookieIn, _: None = Depends(require_auth)):
+    if cookie_manager.manager is None:
+        raise HTTPException(status_code=500, detail="CookieManager 未就绪")
+    try:
+        cookie_manager.manager.add_cookie(item.id, item.value)
+        return {"msg": "success"}
+    except Exception as e:
+        raise HTTPException(status_code=400, detail=str(e))
+
+
+@app.put('/cookies/{cid}')
+def update_cookie(cid: str, item: CookieIn, _: None = Depends(require_auth)):
+    if cookie_manager.manager is None:
+        raise HTTPException(status_code=500, detail='CookieManager 未就绪')
+    try:
+        cookie_manager.manager.update_cookie(cid, item.value)
+        return {'msg': 'updated'}
+    except Exception as e:
+        raise HTTPException(status_code=400, detail=str(e))
+
+
+@app.put('/cookies/{cid}/status')
+def update_cookie_status(cid: str, status_data: CookieStatusIn, _: None = Depends(require_auth)):
+    """更新账号的启用/禁用状态"""
+    if cookie_manager.manager is None:
+        raise HTTPException(status_code=500, detail='CookieManager 未就绪')
+    try:
+        cookie_manager.manager.update_cookie_status(cid, status_data.enabled)
+        return {'msg': 'status updated', 'enabled': status_data.enabled}
+    except Exception as e:
+        raise HTTPException(status_code=400, detail=str(e))
+
+
+# ------------------------- 默认回复管理接口 -------------------------
+
+@app.get('/default-replies/{cid}')
+def get_default_reply(cid: str, _: None = Depends(require_auth)):
+    """获取指定账号的默认回复设置"""
+    from db_manager import db_manager
+    try:
+        result = db_manager.get_default_reply(cid)
+        if result is None:
+            # 如果没有设置，返回默认值
+            return {'enabled': False, 'reply_content': ''}
+        return result
+    except Exception as e:
+        raise HTTPException(status_code=500, detail=str(e))
+
+
+@app.put('/default-replies/{cid}')
+def update_default_reply(cid: str, reply_data: DefaultReplyIn, _: None = Depends(require_auth)):
+    """更新指定账号的默认回复设置"""
+    from db_manager import db_manager
+    try:
+        # 检查数据库中是否存在该账号
+        all_cookies = db_manager.get_all_cookies()
+        if cid not in all_cookies:
+            raise HTTPException(status_code=404, detail='账号不存在')
+
+        db_manager.save_default_reply(cid, reply_data.enabled, reply_data.reply_content)
+        return {'msg': 'default reply updated', 'enabled': reply_data.enabled}
+    except HTTPException:
+        raise
+    except Exception as e:
+        raise HTTPException(status_code=500, detail=str(e))
+
+
+@app.get('/default-replies')
+def get_all_default_replies(_: None = Depends(require_auth)):
+    """获取所有账号的默认回复设置"""
+    from db_manager import db_manager
+    try:
+        return db_manager.get_all_default_replies()
+    except Exception as e:
+        raise HTTPException(status_code=500, detail=str(e))
+
+
+@app.delete('/default-replies/{cid}')
+def delete_default_reply(cid: str, _: None = Depends(require_auth)):
+    """删除指定账号的默认回复设置"""
+    from db_manager import db_manager
+    try:
+        success = db_manager.delete_default_reply(cid)
+        if success:
+            return {'msg': 'default reply deleted'}
+        else:
+            raise HTTPException(status_code=400, detail='删除失败')
+    except Exception as e:
+        raise HTTPException(status_code=500, detail=str(e))
+
+
+# ------------------------- 通知渠道管理接口 -------------------------
+
+@app.get('/notification-channels')
+def get_notification_channels(_: None = Depends(require_auth)):
+    """获取所有通知渠道"""
+    from db_manager import db_manager
+    try:
+        return db_manager.get_notification_channels()
+    except Exception as e:
+        raise HTTPException(status_code=500, detail=str(e))
+
+
+@app.post('/notification-channels')
+def create_notification_channel(channel_data: NotificationChannelIn, _: None = Depends(require_auth)):
+    """创建通知渠道"""
+    from db_manager import db_manager
+    try:
+        channel_id = db_manager.create_notification_channel(
+            channel_data.name,
+            channel_data.type,
+            channel_data.config
+        )
+        return {'msg': 'notification channel created', 'id': channel_id}
+    except Exception as e:
+        raise HTTPException(status_code=400, detail=str(e))
+
+
+@app.get('/notification-channels/{channel_id}')
+def get_notification_channel(channel_id: int, _: None = Depends(require_auth)):
+    """获取指定通知渠道"""
+    from db_manager import db_manager
+    try:
+        channel = db_manager.get_notification_channel(channel_id)
+        if not channel:
+            raise HTTPException(status_code=404, detail='通知渠道不存在')
+        return channel
+    except HTTPException:
+        raise
+    except Exception as e:
+        raise HTTPException(status_code=500, detail=str(e))
+
+
+@app.put('/notification-channels/{channel_id}')
+def update_notification_channel(channel_id: int, channel_data: NotificationChannelUpdate, _: None = Depends(require_auth)):
+    """更新通知渠道"""
+    from db_manager import db_manager
+    try:
+        success = db_manager.update_notification_channel(
+            channel_id,
+            channel_data.name,
+            channel_data.config,
+            channel_data.enabled
+        )
+        if success:
+            return {'msg': 'notification channel updated'}
+        else:
+            raise HTTPException(status_code=404, detail='通知渠道不存在')
+    except HTTPException:
+        raise
+    except Exception as e:
+        raise HTTPException(status_code=400, detail=str(e))
+
+
+@app.delete('/notification-channels/{channel_id}')
+def delete_notification_channel(channel_id: int, _: None = Depends(require_auth)):
+    """删除通知渠道"""
+    from db_manager import db_manager
+    try:
+        success = db_manager.delete_notification_channel(channel_id)
+        if success:
+            return {'msg': 'notification channel deleted'}
+        else:
+            raise HTTPException(status_code=404, detail='通知渠道不存在')
+    except HTTPException:
+        raise
+    except Exception as e:
+        raise HTTPException(status_code=500, detail=str(e))
+
+
+# ------------------------- 消息通知配置接口 -------------------------
+
+@app.get('/message-notifications')
+def get_all_message_notifications(_: None = Depends(require_auth)):
+    """获取所有账号的消息通知配置"""
+    from db_manager import db_manager
+    try:
+        return db_manager.get_all_message_notifications()
+    except Exception as e:
+        raise HTTPException(status_code=500, detail=str(e))
+
+
+@app.get('/message-notifications/{cid}')
+def get_account_notifications(cid: str, _: None = Depends(require_auth)):
+    """获取指定账号的消息通知配置"""
+    from db_manager import db_manager
+    try:
+        return db_manager.get_account_notifications(cid)
+    except Exception as e:
+        raise HTTPException(status_code=500, detail=str(e))
+
+
+@app.post('/message-notifications/{cid}')
+def set_message_notification(cid: str, notification_data: MessageNotificationIn, _: None = Depends(require_auth)):
+    """设置账号的消息通知"""
+    from db_manager import db_manager
+    try:
+        # 检查账号是否存在
+        all_cookies = db_manager.get_all_cookies()
+        if cid not in all_cookies:
+            raise HTTPException(status_code=404, detail='账号不存在')
+
+        # 检查通知渠道是否存在
+        channel = db_manager.get_notification_channel(notification_data.channel_id)
+        if not channel:
+            raise HTTPException(status_code=404, detail='通知渠道不存在')
+
+        success = db_manager.set_message_notification(cid, notification_data.channel_id, notification_data.enabled)
+        if success:
+            return {'msg': 'message notification set'}
+        else:
+            raise HTTPException(status_code=400, detail='设置失败')
+    except HTTPException:
+        raise
+    except Exception as e:
+        raise HTTPException(status_code=500, detail=str(e))
+
+
+@app.delete('/message-notifications/account/{cid}')
+def delete_account_notifications(cid: str, _: None = Depends(require_auth)):
+    """删除账号的所有消息通知配置"""
+    from db_manager import db_manager
+    try:
+        success = db_manager.delete_account_notifications(cid)
+        if success:
+            return {'msg': 'account notifications deleted'}
+        else:
+            raise HTTPException(status_code=404, detail='账号通知配置不存在')
+    except HTTPException:
+        raise
+    except Exception as e:
+        raise HTTPException(status_code=500, detail=str(e))
+
+
+@app.delete('/message-notifications/{notification_id}')
+def delete_message_notification(notification_id: int, _: None = Depends(require_auth)):
+    """删除消息通知配置"""
+    from db_manager import db_manager
+    try:
+        success = db_manager.delete_message_notification(notification_id)
+        if success:
+            return {'msg': 'message notification deleted'}
+        else:
+            raise HTTPException(status_code=404, detail='通知配置不存在')
+    except HTTPException:
+        raise
+    except Exception as e:
+        raise HTTPException(status_code=500, detail=str(e))
+
+
+# ------------------------- 系统设置接口 -------------------------
+
+@app.get('/system-settings')
+def get_system_settings(_: None = Depends(require_auth)):
+    """获取系统设置（排除敏感信息）"""
+    from db_manager import db_manager
+    try:
+        settings = db_manager.get_all_system_settings()
+        # 移除敏感信息
+        if 'admin_password_hash' in settings:
+            del settings['admin_password_hash']
+        return settings
+    except Exception as e:
+        raise HTTPException(status_code=500, detail=str(e))
+
+
+@app.put('/system-settings/password')
+def update_admin_password(password_data: PasswordUpdateIn, _: None = Depends(require_auth)):
+    """更新管理员密码"""
+    from db_manager import db_manager
+    try:
+        # 验证当前密码
+        if not db_manager.verify_admin_password(password_data.current_password):
+            raise HTTPException(status_code=400, detail='当前密码错误')
+
+        # 更新密码
+        success = db_manager.update_admin_password(password_data.new_password)
+        if success:
+            return {'msg': 'password updated'}
+        else:
+            raise HTTPException(status_code=400, detail='密码更新失败')
+    except HTTPException:
+        raise
+    except Exception as e:
+        raise HTTPException(status_code=500, detail=str(e))
+
+
+@app.put('/system-settings/{key}')
+def update_system_setting(key: str, setting_data: SystemSettingIn, _: None = Depends(require_auth)):
+    """更新系统设置"""
+    from db_manager import db_manager
+    try:
+        # 禁止直接修改密码哈希
+        if key == 'admin_password_hash':
+            raise HTTPException(status_code=400, detail='请使用密码修改接口')
+
+        success = db_manager.set_system_setting(key, setting_data.value, setting_data.description)
+        if success:
+            return {'msg': 'system setting updated'}
+        else:
+            raise HTTPException(status_code=400, detail='更新失败')
+    except HTTPException:
+        raise
+    except Exception as e:
+        raise HTTPException(status_code=500, detail=str(e))
+
+
+
+
+
+@app.delete("/cookies/{cid}")
+def remove_cookie(cid: str, _: None = Depends(require_auth)):
+    if cookie_manager.manager is None:
+        raise HTTPException(status_code=500, detail="CookieManager 未就绪")
+    try:
+        cookie_manager.manager.remove_cookie(cid)
+        return {"msg": "removed"}
+    except Exception as e:
+        raise HTTPException(status_code=400, detail=str(e))
+
+
+
+
+
+class KeywordIn(BaseModel):
+    keywords: Dict[str, str]  # key -> reply
+
+
+@app.get("/keywords/{cid}")
+def get_keywords(cid: str, _: None = Depends(require_auth)):
+    if cookie_manager.manager is None:
+        raise HTTPException(status_code=500, detail="CookieManager 未就绪")
+    return cookie_manager.manager.get_keywords(cid)
+
+
+@app.post("/keywords/{cid}")
+def update_keywords(cid: str, body: KeywordIn, _: None = Depends(require_auth)):
+    if cookie_manager.manager is None:
+        raise HTTPException(status_code=500, detail="CookieManager 未就绪")
+    kw_list = [(k, v) for k, v in body.keywords.items()]
+    cookie_manager.manager.update_keywords(cid, kw_list)
+    return {"msg": "updated", "count": len(kw_list)}
+
+
+# 卡券管理API
+@app.get("/cards")
+def get_cards(_: None = Depends(require_auth)):
+    """获取卡券列表"""
+    try:
+        from db_manager import db_manager
+        cards = db_manager.get_all_cards()
+        return cards
+    except Exception as e:
+        raise HTTPException(status_code=500, detail=str(e))
+
+
+@app.post("/cards")
+def create_card(card_data: dict, _: None = Depends(require_auth)):
+    """创建新卡券"""
+    try:
+        from db_manager import db_manager
+        card_id = db_manager.create_card(
+            name=card_data.get('name'),
+            card_type=card_data.get('type'),
+            api_config=card_data.get('api_config'),
+            text_content=card_data.get('text_content'),
+            data_content=card_data.get('data_content'),
+            description=card_data.get('description'),
+            enabled=card_data.get('enabled', True)
+        )
+        return {"id": card_id, "message": "卡券创建成功"}
+    except Exception as e:
+        raise HTTPException(status_code=500, detail=str(e))
+
+
+@app.get("/cards/{card_id}")
+def get_card(card_id: int, _: None = Depends(require_auth)):
+    """获取单个卡券详情"""
+    try:
+        from db_manager import db_manager
+        card = db_manager.get_card_by_id(card_id)
+        if card:
+            return card
+        else:
+            raise HTTPException(status_code=404, detail="卡券不存在")
+    except Exception as e:
+        raise HTTPException(status_code=500, detail=str(e))
+
+
+@app.put("/cards/{card_id}")
+def update_card(card_id: int, card_data: dict, _: None = Depends(require_auth)):
+    """更新卡券"""
+    try:
+        from db_manager import db_manager
+        success = db_manager.update_card(
+            card_id=card_id,
+            name=card_data.get('name'),
+            card_type=card_data.get('type'),
+            api_config=card_data.get('api_config'),
+            text_content=card_data.get('text_content'),
+            data_content=card_data.get('data_content'),
+            description=card_data.get('description'),
+            enabled=card_data.get('enabled', True)
+        )
+        if success:
+            return {"message": "卡券更新成功"}
+        else:
+            raise HTTPException(status_code=404, detail="卡券不存在")
+    except Exception as e:
+        raise HTTPException(status_code=500, detail=str(e))
+
+
+# 自动发货规则API
+@app.get("/delivery-rules")
+def get_delivery_rules(_: None = Depends(require_auth)):
+    """获取发货规则列表"""
+    try:
+        from db_manager import db_manager
+        rules = db_manager.get_all_delivery_rules()
+        return rules
+    except Exception as e:
+        raise HTTPException(status_code=500, detail=str(e))
+
+
+@app.post("/delivery-rules")
+def create_delivery_rule(rule_data: dict, _: None = Depends(require_auth)):
+    """创建新发货规则"""
+    try:
+        from db_manager import db_manager
+        rule_id = db_manager.create_delivery_rule(
+            keyword=rule_data.get('keyword'),
+            card_id=rule_data.get('card_id'),
+            delivery_count=rule_data.get('delivery_count', 1),
+            enabled=rule_data.get('enabled', True),
+            description=rule_data.get('description')
+        )
+        return {"id": rule_id, "message": "发货规则创建成功"}
+    except Exception as e:
+        raise HTTPException(status_code=500, detail=str(e))
+
+
+@app.get("/delivery-rules/{rule_id}")
+def get_delivery_rule(rule_id: int, _: None = Depends(require_auth)):
+    """获取单个发货规则详情"""
+    try:
+        from db_manager import db_manager
+        rule = db_manager.get_delivery_rule_by_id(rule_id)
+        if rule:
+            return rule
+        else:
+            raise HTTPException(status_code=404, detail="发货规则不存在")
+    except Exception as e:
+        raise HTTPException(status_code=500, detail=str(e))
+
+
+@app.put("/delivery-rules/{rule_id}")
+def update_delivery_rule(rule_id: int, rule_data: dict, _: None = Depends(require_auth)):
+    """更新发货规则"""
+    try:
+        from db_manager import db_manager
+        success = db_manager.update_delivery_rule(
+            rule_id=rule_id,
+            keyword=rule_data.get('keyword'),
+            card_id=rule_data.get('card_id'),
+            delivery_count=rule_data.get('delivery_count', 1),
+            enabled=rule_data.get('enabled', True),
+            description=rule_data.get('description')
+        )
+        if success:
+            return {"message": "发货规则更新成功"}
+        else:
+            raise HTTPException(status_code=404, detail="发货规则不存在")
+    except Exception as e:
+        raise HTTPException(status_code=500, detail=str(e))
+
+
+@app.delete("/cards/{card_id}")
+def delete_card(card_id: int, _: None = Depends(require_auth)):
+    """删除卡券"""
+    try:
+        from db_manager import db_manager
+        success = db_manager.delete_card(card_id)
+        if success:
+            return {"message": "卡券删除成功"}
+        else:
+            raise HTTPException(status_code=404, detail="卡券不存在")
+    except Exception as e:
+        raise HTTPException(status_code=500, detail=str(e))
+
+
+@app.delete("/delivery-rules/{rule_id}")
+def delete_delivery_rule(rule_id: int, _: None = Depends(require_auth)):
+    """删除发货规则"""
+    try:
+        from db_manager import db_manager
+        success = db_manager.delete_delivery_rule(rule_id)
+        if success:
+            return {"message": "发货规则删除成功"}
+        else:
+            raise HTTPException(status_code=404, detail="发货规则不存在")
+    except Exception as e:
+        raise HTTPException(status_code=500, detail=str(e))
+
+
+# ==================== 备份和恢复 API ====================
+
+@app.get("/backup/export")
+def export_backup(_: None = Depends(require_auth)):
+    """导出系统备份"""
+    try:
+        from db_manager import db_manager
+        backup_data = db_manager.export_backup()
+
+        # 生成文件名
+        import datetime
+        timestamp = datetime.datetime.now().strftime("%Y%m%d_%H%M%S")
+        filename = f"xianyu_backup_{timestamp}.json"
+
+        # 返回JSON响应，设置下载头
+        response = JSONResponse(content=backup_data)
+        response.headers["Content-Disposition"] = f"attachment; filename={filename}"
+        response.headers["Content-Type"] = "application/json"
+
+        return response
+    except Exception as e:
+        raise HTTPException(status_code=500, detail=f"导出备份失败: {str(e)}")
+
+
+@app.post("/backup/import")
+def import_backup(file: UploadFile = File(...), _: None = Depends(require_auth)):
+    """导入系统备份"""
+    try:
+        # 验证文件类型
+        if not file.filename.endswith('.json'):
+            raise HTTPException(status_code=400, detail="只支持JSON格式的备份文件")
+
+        # 读取文件内容
+        content = file.file.read()
+        backup_data = json.loads(content.decode('utf-8'))
+
+        # 导入备份
+        from db_manager import db_manager
+        success = db_manager.import_backup(backup_data)
+
+        if success:
+            return {"message": "备份导入成功"}
+        else:
+            raise HTTPException(status_code=400, detail="备份导入失败")
+
+    except json.JSONDecodeError:
+        raise HTTPException(status_code=400, detail="备份文件格式无效")
+    except Exception as e:
+        raise HTTPException(status_code=500, detail=f"导入备份失败: {str(e)}")
+
+
+# ==================== 商品管理 API ====================
+
+@app.get("/items")
+def get_all_items(_: None = Depends(require_auth)):
+    """获取所有商品信息"""
+    try:
+        items = db_manager.get_all_items()
+        return {"items": items}
+    except Exception as e:
+        raise HTTPException(status_code=500, detail=f"获取商品信息失败: {str(e)}")
+
+
+@app.get("/items/cookie/{cookie_id}")
+def get_items_by_cookie(cookie_id: str, _: None = Depends(require_auth)):
+    """获取指定Cookie的商品信息"""
+    try:
+        items = db_manager.get_items_by_cookie(cookie_id)
+        return {"items": items}
+    except Exception as e:
+        raise HTTPException(status_code=500, detail=f"获取商品信息失败: {str(e)}")
+
+
+@app.get("/items/{cookie_id}/{item_id}")
+def get_item_detail(cookie_id: str, item_id: str, _: None = Depends(require_auth)):
+    """获取商品详情"""
+    try:
+        item = db_manager.get_item_info(cookie_id, item_id)
+        if not item:
+            raise HTTPException(status_code=404, detail="商品不存在")
+        return {"item": item}
+    except Exception as e:
+        raise HTTPException(status_code=500, detail=f"获取商品详情失败: {str(e)}")
+
+
+class ItemDetailUpdate(BaseModel):
+    item_detail: str
+
+
+@app.put("/items/{cookie_id}/{item_id}")
+def update_item_detail(
+    cookie_id: str,
+    item_id: str,
+    update_data: ItemDetailUpdate,
+    _: None = Depends(require_auth)
+):
+    """更新商品详情"""
+    try:
+        success = db_manager.update_item_detail(cookie_id, item_id, update_data.item_detail)
+        if success:
+            return {"message": "商品详情更新成功"}
+        else:
+            raise HTTPException(status_code=400, detail="更新失败")
+    except Exception as e:
+        raise HTTPException(status_code=500, detail=f"更新商品详情失败: {str(e)}")
+
+
+@app.delete("/items/{cookie_id}/{item_id}")
+def delete_item_info(
+    cookie_id: str,
+    item_id: str,
+    _: None = Depends(require_auth)
+):
+    """删除商品信息"""
+    try:
+        success = db_manager.delete_item_info(cookie_id, item_id)
+        if success:
+            return {"message": "商品信息删除成功"}
+        else:
+            raise HTTPException(status_code=404, detail="商品信息不存在")
+    except Exception as e:
+        logger.error(f"删除商品信息异常: {e}")
+        raise HTTPException(status_code=500, detail=f"服务器错误: {str(e)}")
+
+
+class BatchDeleteRequest(BaseModel):
+    items: List[dict]  # [{"cookie_id": "xxx", "item_id": "yyy"}, ...]
+
+
+@app.delete("/items/batch")
+def batch_delete_items(
+    request: BatchDeleteRequest,
+    _: None = Depends(require_auth)
+):
+    """批量删除商品信息"""
+    try:
+        if not request.items:
+            raise HTTPException(status_code=400, detail="删除列表不能为空")
+
+        success_count = db_manager.batch_delete_item_info(request.items)
+        total_count = len(request.items)
+
+        return {
+            "message": f"批量删除完成",
+            "success_count": success_count,
+            "total_count": total_count,
+            "failed_count": total_count - success_count
+        }
+    except Exception as e:
+        logger.error(f"批量删除商品信息异常: {e}")
+        raise HTTPException(status_code=500, detail=f"服务器错误: {str(e)}")
+
+
+# ==================== 日志管理API ====================
+
+@app.get("/logs")
+async def get_logs(lines: int = 200, level: str = None, source: str = None, _: None = Depends(require_auth)):
+    """获取实时系统日志"""
+    try:
+        # 获取文件日志收集器
+        collector = get_file_log_collector()
+
+        # 获取日志
+        logs = collector.get_logs(lines=lines, level_filter=level, source_filter=source)
+
+        return {"success": True, "logs": logs}
+
+    except Exception as e:
+        return {"success": False, "message": f"获取日志失败: {str(e)}", "logs": []}
+
+
+@app.get("/logs/stats")
+async def get_log_stats(_: None = Depends(require_auth)):
+    """获取日志统计信息"""
+    try:
+        collector = get_file_log_collector()
+        stats = collector.get_stats()
+
+        return {"success": True, "stats": stats}
+
+    except Exception as e:
+        return {"success": False, "message": f"获取日志统计失败: {str(e)}", "stats": {}}
+
+
+@app.post("/logs/clear")
+async def clear_logs(_: None = Depends(require_auth)):
+    """清空日志"""
+    try:
+        collector = get_file_log_collector()
+        collector.clear_logs()
+
+        return {"success": True, "message": "日志已清空"}
+
+    except Exception as e:
+        return {"success": False, "message": f"清空日志失败: {str(e)}"}
+
+
+# ==================== 商品管理API ====================
+
+@app.post("/items/get-all-from-account")
+async def get_all_items_from_account(request: dict, _: None = Depends(require_auth)):
+    """从指定账号获取所有商品信息"""
+    try:
+        cookie_id = request.get('cookie_id')
+        if not cookie_id:
+            return {"success": False, "message": "缺少cookie_id参数"}
+
+        # 获取指定账号的cookie信息
+        cookie_info = db_manager.get_cookie_by_id(cookie_id)
+        if not cookie_info:
+            return {"success": False, "message": "未找到指定的账号信息"}
+
+        cookies_str = cookie_info.get('cookies_str', '')
+        if not cookies_str:
+            return {"success": False, "message": "账号cookie信息为空"}
+
+        # 创建XianyuLive实例，传入正确的cookie_id
+        from XianyuAutoAsync import XianyuLive
+        xianyu_instance = XianyuLive(cookies_str, cookie_id)
+
+        # 调用获取商品信息的方法
+        logger.info(f"开始获取账号 {cookie_id} 的所有商品信息")
+        result = await xianyu_instance.get_item_list_info()
+
+        # 关闭session
+        await xianyu_instance.close_session()
+
+        if result.get('error'):
+            logger.error(f"获取商品信息失败: {result['error']}")
+            return {"success": False, "message": result['error']}
+        else:
+            logger.info(f"成功获取账号 {cookie_id} 的 {result.get('total_count', 0)} 个商品")
+            return {
+                "success": True,
+                "message": f"成功获取 {result.get('total_count', 0)} 个商品，详细信息已打印到控制台",
+                "total_count": result.get('total_count', 0)
+            }
+
+    except Exception as e:
+        logger.error(f"获取账号商品信息异常: {str(e)}")
+        return {"success": False, "message": f"获取商品信息异常: {str(e)}"}
+
+
+if __name__ == "__main__":
+    uvicorn.run(app, host="0.0.0.0", port=8080)
\ No newline at end of file
diff --git a/requirements.txt b/requirements.txt
new file mode 100644
index 0000000..f4a1a35
--- /dev/null
+++ b/requirements.txt
@@ -0,0 +1,29 @@
+# Web框架和API相关
+fastapi>=0.111
+uvicorn[standard]>=0.29
+pydantic>=2.7
+
+# 日志记录
+loguru>=0.7
+
+# 网络通信
+websockets>=10.0,<13.0  # 兼容性版本范围
+aiohttp>=3.9
+
+# 配置文件处理
+PyYAML>=6.0
+
+# JavaScript执行引擎
+PyExecJS>=1.5.1
+
+# 协议缓冲区解析
+blackboxprotobuf>=1.0.1
+
+# 系统监控
+psutil>=5.9.0
+
+# HTTP客户端（用于测试）
+requests>=2.31.0
+
+# 文件上传支持
+python-multipart>=0.0.6
\ No newline at end of file
diff --git a/static/index.html b/static/index.html
new file mode 100644
index 0000000..63bf6db
--- /dev/null
+++ b/static/index.html
@@ -0,0 +1,6368 @@
+<!DOCTYPE html>
+<html lang="zh-CN">
+<head>
+  <meta charset="UTF-8" />
+  <meta name="viewport" content="width=device-width, initial-scale=1.0">
+  <title>闲鱼自动回复管理系统</title>
+  <link rel="stylesheet" href="https://cdn.jsdelivr.net/npm/bootstrap@5.3.2/dist/css/bootstrap.min.css">
+  <link rel="stylesheet" href="https://cdn.jsdelivr.net/npm/bootstrap-icons@1.11.0/font/bootstrap-icons.css">
+  <style>
+    :root {
+      --primary-color: #4f46e5;
+      --primary-hover: #4338ca;
+      --primary-light: #6366f1;
+      --secondary-color: #6b7280;
+      --success-color: #10b981;
+      --danger-color: #ef4444;
+      --warning-color: #f59e0b;
+      --light-color: #f9fafb;
+      --dark-color: #1f2937;
+      --border-color: #e5e7eb;
+      --shadow-sm: 0 1px 2px 0 rgba(0, 0, 0, 0.05);
+      --shadow-md: 0 4px 6px -1px rgba(0, 0, 0, 0.1), 0 2px 4px -1px rgba(0, 0, 0, 0.06);
+      --shadow-lg: 0 10px 15px -3px rgba(0, 0, 0, 0.1), 0 4px 6px -2px rgba(0, 0, 0, 0.05);
+    }
+
+    body {
+      font-family: 'Inter', 'Segoe UI', Tahoma, Geneva, Verdana, sans-serif;
+      background: #f8fafc;
+      min-height: 100vh;
+      padding: 0;
+      margin: 0;
+    }
+
+    /* 侧边栏样式 */
+    .sidebar {
+      position: fixed;
+      top: 0;
+      left: 0;
+      height: 100vh;
+      width: 250px;
+      background: linear-gradient(135deg, var(--primary-color) 0%, var(--primary-hover) 100%);
+      color: white;
+      z-index: 1000;
+      transition: all 0.3s ease;
+      box-shadow: 2px 0 10px rgba(0,0,0,0.1);
+    }
+
+    .sidebar-header {
+      padding: 1.5rem 1rem;
+      border-bottom: 1px solid rgba(255,255,255,0.1);
+    }
+
+    .sidebar-brand {
+      font-size: 1.25rem;
+      font-weight: 700;
+      color: white;
+      text-decoration: none;
+      display: flex;
+      align-items: center;
+    }
+
+    .sidebar-nav {
+      padding: 1rem 0;
+    }
+
+    .nav-item {
+      margin: 0.25rem 0;
+    }
+
+    .nav-link {
+      display: flex;
+      align-items: center;
+      padding: 0.75rem 1.5rem;
+      color: rgba(255,255,255,0.8);
+      text-decoration: none;
+      transition: all 0.3s ease;
+      border-left: 3px solid transparent;
+    }
+
+    .nav-link:hover {
+      color: white;
+      background: rgba(255,255,255,0.1);
+      border-left-color: rgba(255,255,255,0.5);
+    }
+
+    .nav-link.active {
+      color: white;
+      background: rgba(255,255,255,0.15);
+      border-left-color: white;
+    }
+
+    .nav-link i {
+      margin-right: 0.75rem;
+      width: 20px;
+      text-align: center;
+    }
+
+    /* 主内容区域 */
+    .main-content {
+      margin-left: 250px;
+      min-height: 100vh;
+      background: #f8fafc;
+    }
+
+    .content-header {
+      background: white;
+      padding: 1.5rem 2rem;
+      border-bottom: 1px solid var(--border-color);
+      box-shadow: var(--shadow-sm);
+    }
+
+    .content-body {
+      padding: 2rem;
+    }
+
+    /* 响应式设计 */
+    @media (max-width: 768px) {
+      .sidebar {
+        transform: translateX(-100%);
+      }
+
+      .sidebar.show {
+        transform: translateX(0);
+      }
+
+      .main-content {
+        margin-left: 0;
+      }
+
+      .mobile-toggle {
+        display: block !important;
+      }
+    }
+
+    .mobile-toggle {
+      display: none;
+      position: fixed;
+      top: 1rem;
+      left: 1rem;
+      z-index: 1001;
+      background: var(--primary-color);
+      color: white;
+      border: none;
+      border-radius: 8px;
+      padding: 0.5rem;
+      box-shadow: var(--shadow-md);
+    }
+
+    /* 仪表盘样式 */
+    .dashboard-stats {
+      display: grid;
+      grid-template-columns: repeat(auto-fit, minmax(250px, 1fr));
+      gap: 1.5rem;
+      margin-bottom: 2rem;
+    }
+
+    .stat-card {
+      background: white;
+      border-radius: 12px;
+      padding: 1.5rem;
+      box-shadow: var(--shadow-sm);
+      border: 1px solid var(--border-color);
+      transition: all 0.3s ease;
+    }
+
+    .stat-card:hover {
+      transform: translateY(-2px);
+      box-shadow: var(--shadow-md);
+    }
+
+    .stat-icon {
+      width: 48px;
+      height: 48px;
+      border-radius: 12px;
+      display: flex;
+      align-items: center;
+      justify-content: center;
+      font-size: 1.5rem;
+      margin-bottom: 1rem;
+    }
+
+    .stat-icon.primary {
+      background: rgba(79, 70, 229, 0.1);
+      color: var(--primary-color);
+    }
+
+    .stat-icon.success {
+      background: rgba(16, 185, 129, 0.1);
+      color: var(--success-color);
+    }
+
+    .stat-icon.warning {
+      background: rgba(245, 158, 11, 0.1);
+      color: var(--warning-color);
+    }
+
+    .stat-number {
+      font-size: 2rem;
+      font-weight: 700;
+      color: var(--dark-color);
+      margin-bottom: 0.5rem;
+    }
+
+    .stat-label {
+      color: var(--secondary-color);
+      font-size: 0.875rem;
+      font-weight: 500;
+    }
+
+    /* 内容区域样式 */
+    .content-section {
+      display: none;
+    }
+
+    .content-section.active {
+      display: block;
+    }
+
+    /* 日志管理样式 */
+    .log-container {
+      height: 70vh;
+      overflow-y: auto;
+      background-color: #1e1e1e;
+      color: #d4d4d4;
+      font-family: 'Consolas', 'Monaco', 'Courier New', monospace;
+      font-size: 12px;
+      line-height: 1.2;
+      padding: 8px;
+      border-radius: 4px;
+    }
+
+    .log-entry {
+      margin-bottom: 0px;
+      padding: 1px 0;
+      word-wrap: break-word;
+      white-space: pre-wrap;
+      line-height: 1.2;
+    }
+
+    .log-entry.DEBUG {
+      color: #9cdcfe;
+    }
+
+    .log-entry.INFO {
+      color: #4ec9b0;
+    }
+
+    .log-entry.WARNING {
+      color: #dcdcaa;
+    }
+
+    .log-entry.ERROR {
+      color: #f48771;
+    }
+
+    .log-entry.CRITICAL {
+      color: #ff6b6b;
+      font-weight: bold;
+    }
+
+    .log-timestamp {
+      color: #808080;
+    }
+
+    .log-level {
+      font-weight: bold;
+      margin: 0 5px;
+    }
+
+    .log-source {
+      color: #569cd6;
+    }
+
+    .log-message {
+      color: inherit;
+    }
+
+    .log-container::-webkit-scrollbar {
+      width: 8px;
+    }
+
+    .log-container::-webkit-scrollbar-track {
+      background: #2d2d30;
+    }
+
+    .log-container::-webkit-scrollbar-thumb {
+      background: #464647;
+      border-radius: 4px;
+    }
+
+    .log-container::-webkit-scrollbar-thumb:hover {
+      background: #5a5a5c;
+    }
+
+    /* 关键词管理现代化样式 */
+    .keyword-container {
+      background: white;
+      border-radius: 16px;
+      box-shadow: 0 4px 6px -1px rgba(0, 0, 0, 0.1);
+      overflow: hidden;
+      transition: all 0.3s ease;
+    }
+
+    .keyword-header {
+      background: linear-gradient(135deg, var(--primary-color) 0%, var(--primary-hover) 100%);
+      color: white;
+      padding: 1.5rem 2rem;
+      display: flex;
+      align-items: center;
+      justify-content: space-between;
+    }
+
+    .keyword-header h3 {
+      margin: 0;
+      font-weight: 600;
+      display: flex;
+      align-items: center;
+    }
+
+    .keyword-header .account-badge {
+      background: rgba(255, 255, 255, 0.2);
+      padding: 0.5rem 1rem;
+      border-radius: 20px;
+      font-size: 0.875rem;
+      font-weight: 500;
+    }
+
+    .keyword-input-area {
+      padding: 2rem;
+      background: #f8fafc;
+      border-bottom: 1px solid #e5e7eb;
+    }
+
+    .keyword-input-group {
+      display: grid;
+      grid-template-columns: 1fr 2fr auto;
+      gap: 1rem;
+      align-items: end;
+    }
+
+    .input-field {
+      position: relative;
+    }
+
+    .input-field label {
+      position: absolute;
+      top: -0.5rem;
+      left: 0.75rem;
+      background: #f8fafc;
+      padding: 0 0.5rem;
+      font-size: 0.75rem;
+      font-weight: 500;
+      color: #6b7280;
+      z-index: 1;
+    }
+
+    .input-field input {
+      width: 100%;
+      padding: 1rem 0.75rem 0.75rem;
+      border: 2px solid #e5e7eb;
+      border-radius: 12px;
+      font-size: 0.875rem;
+      transition: all 0.3s ease;
+      background: white;
+    }
+
+    .input-field input:focus {
+      outline: none;
+      border-color: #667eea;
+      box-shadow: 0 0 0 3px rgba(102, 126, 234, 0.1);
+    }
+
+    .add-btn {
+      background: linear-gradient(135deg, #10b981 0%, #059669 100%);
+      color: white;
+      border: none;
+      border-radius: 12px;
+      padding: 1rem 1.5rem;
+      font-weight: 600;
+      cursor: pointer;
+      transition: all 0.3s ease;
+      display: flex;
+      align-items: center;
+      gap: 0.5rem;
+    }
+
+    .add-btn:hover {
+      transform: translateY(-2px);
+      box-shadow: 0 8px 25px rgba(16, 185, 129, 0.3);
+    }
+
+    .add-btn:active {
+      transform: translateY(0);
+    }
+
+    .keywords-list {
+      padding: 1.5rem 2rem 2rem;
+      max-height: 500px;
+      overflow-y: auto;
+    }
+
+    .keyword-item {
+      background: white;
+      border: 1px solid #e5e7eb;
+      border-radius: 12px;
+      margin-bottom: 1rem;
+      transition: all 0.3s ease;
+      overflow: hidden;
+    }
+
+    .keyword-item:hover {
+      border-color: #667eea;
+      box-shadow: 0 4px 12px rgba(102, 126, 234, 0.15);
+      transform: translateY(-1px);
+    }
+
+    .keyword-item-header {
+      padding: 1rem 1.5rem;
+      background: #f8fafc;
+      border-bottom: 1px solid #e5e7eb;
+      display: flex;
+      align-items: center;
+      justify-content: space-between;
+    }
+
+    .keyword-tag {
+      background: linear-gradient(135deg, var(--primary-color) 0%, var(--primary-hover) 100%);
+      color: white;
+      padding: 0.5rem 1rem;
+      border-radius: 20px;
+      font-size: 0.875rem;
+      font-weight: 500;
+      display: flex;
+      align-items: center;
+      gap: 0.5rem;
+    }
+
+    .keyword-actions {
+      display: flex;
+      gap: 0.5rem;
+    }
+
+    .action-btn {
+      width: 36px;
+      height: 36px;
+      border: none;
+      border-radius: 8px;
+      cursor: pointer;
+      transition: all 0.3s ease;
+      display: flex;
+      align-items: center;
+      justify-content: center;
+    }
+
+    .edit-btn {
+      background: #f3f4f6;
+      color: #6b7280;
+    }
+
+    .edit-btn:hover {
+      background: #e5e7eb;
+      color: #374151;
+    }
+
+    .delete-btn {
+      background: #fef2f2;
+      color: #ef4444;
+    }
+
+    .delete-btn:hover {
+      background: #fee2e2;
+      color: #dc2626;
+    }
+
+    .keyword-content {
+      padding: 1.5rem;
+    }
+
+    .reply-text {
+      color: #374151;
+      line-height: 1.6;
+      margin: 0;
+      font-size: 0.875rem;
+    }
+
+    .empty-state {
+      text-align: center;
+      padding: 4rem 2rem;
+      color: #6b7280;
+    }
+
+    .empty-state i {
+      font-size: 4rem;
+      margin-bottom: 1rem;
+      opacity: 0.5;
+    }
+
+    .empty-state h3 {
+      margin: 0 0 0.5rem;
+      color: #374151;
+    }
+
+    .empty-state p {
+      margin: 0 0 2rem;
+      font-size: 0.875rem;
+    }
+
+    .quick-add-btn {
+      background: linear-gradient(135deg, var(--primary-color) 0%, var(--primary-hover) 100%);
+      color: white;
+      border: none;
+      border-radius: 12px;
+      padding: 0.75rem 1.5rem;
+      font-weight: 500;
+      cursor: pointer;
+      transition: all 0.3s ease;
+    }
+
+    .quick-add-btn:hover {
+      transform: translateY(-2px);
+      box-shadow: 0 8px 25px rgba(102, 126, 234, 0.3);
+    }
+
+    /* 账号选择器现代化 */
+    .account-selector {
+      background: white;
+      border-radius: 16px;
+      box-shadow: 0 2px 4px rgba(0, 0, 0, 0.1);
+      padding: 2rem;
+      margin-bottom: 2rem;
+    }
+
+    .selector-header {
+      display: flex;
+      align-items: center;
+      gap: 1rem;
+      margin-bottom: 1.5rem;
+    }
+
+    .selector-icon {
+      width: 48px;
+      height: 48px;
+      background: linear-gradient(135deg, var(--primary-color) 0%, var(--primary-hover) 100%);
+      border-radius: 12px;
+      display: flex;
+      align-items: center;
+      justify-content: center;
+      color: white;
+      font-size: 1.25rem;
+    }
+
+    .selector-title {
+      margin: 0;
+      color: #1f2937;
+      font-weight: 600;
+    }
+
+    .selector-subtitle {
+      margin: 0;
+      color: #6b7280;
+      font-size: 0.875rem;
+    }
+
+    .account-select-wrapper {
+      position: relative;
+    }
+
+    .account-select {
+      width: 100%;
+      padding: 1rem 1.25rem;
+      border: 2px solid #e5e7eb;
+      border-radius: 12px;
+      font-size: 1rem;
+      background: white;
+      cursor: pointer;
+      transition: all 0.3s ease;
+    }
+
+    .account-select:focus {
+      outline: none;
+      border-color: #667eea;
+      box-shadow: 0 0 0 3px rgba(102, 126, 234, 0.1);
+    }
+
+    /* 账号状态样式 */
+    .status-toggle {
+      position: relative;
+      display: inline-block;
+      width: 50px;
+      height: 24px;
+    }
+
+    .status-toggle input {
+      opacity: 0;
+      width: 0;
+      height: 0;
+    }
+
+    .status-slider {
+      position: absolute;
+      cursor: pointer;
+      top: 0;
+      left: 0;
+      right: 0;
+      bottom: 0;
+      background-color: #ccc;
+      transition: .4s;
+      border-radius: 24px;
+    }
+
+    .status-slider:before {
+      position: absolute;
+      content: "";
+      height: 18px;
+      width: 18px;
+      left: 3px;
+      bottom: 3px;
+      background-color: white;
+      transition: .4s;
+      border-radius: 50%;
+    }
+
+    input:checked + .status-slider {
+      background-color: #10b981;
+    }
+
+    input:checked + .status-slider:before {
+      transform: translateX(26px);
+    }
+
+    .status-badge {
+      display: inline-flex;
+      align-items: center;
+      gap: 0.5rem;
+      padding: 0.25rem 0.75rem;
+      border-radius: 12px;
+      font-size: 0.75rem;
+      font-weight: 500;
+    }
+
+    .status-badge.enabled {
+      background: #dcfce7;
+      color: #166534;
+      border: 1px solid #bbf7d0;
+    }
+
+    .status-badge.disabled {
+      background: #fef2f2;
+      color: #991b1b;
+      border: 1px solid #fecaca;
+    }
+
+    .account-row.disabled {
+      opacity: 0.6;
+      background-color: #f9fafb;
+    }
+
+    .account-row.disabled .cookie-value {
+      background-color: #f3f4f6;
+    }
+
+    /* 关键词管理界面的状态提示 */
+    .account-badge .badge.bg-warning {
+      animation: pulse 2s infinite;
+    }
+
+    @keyframes pulse {
+      0% { opacity: 1; }
+      50% { opacity: 0.7; }
+      100% { opacity: 1; }
+    }
+
+    .disabled-account-notice {
+      background: #fef3c7;
+      border: 1px solid #f59e0b;
+      border-radius: 8px;
+      padding: 0.75rem;
+      margin-bottom: 1rem;
+      color: #92400e;
+    }
+
+    .disabled-account-notice .bi {
+      color: #f59e0b;
+    }
+
+
+
+    /* 响应式设计 */
+    @media (max-width: 768px) {
+      .keyword-input-group {
+        grid-template-columns: 1fr;
+        gap: 1rem;
+      }
+
+      .keyword-item-header {
+        flex-direction: column;
+        align-items: flex-start;
+        gap: 1rem;
+      }
+
+      .keyword-actions {
+        align-self: flex-end;
+      }
+
+      .status-toggle {
+        width: 40px;
+        height: 20px;
+      }
+
+      .status-slider:before {
+        height: 14px;
+        width: 14px;
+        left: 3px;
+        bottom: 3px;
+      }
+
+      input:checked + .status-slider:before {
+        transform: translateX(20px);
+      }
+    }
+    .card {
+      background: rgba(255, 255, 255, 0.95);
+      backdrop-filter: blur(10px);
+      border: 1px solid rgba(255, 255, 255, 0.2);
+      border-radius: 16px;
+      box-shadow: 0 10px 15px -3px rgba(0, 0, 0, 0.1), 0 4px 6px -2px rgba(0, 0, 0, 0.05);
+      transition: all 0.3s ease;
+      margin-bottom: 2rem;
+    }
+
+    .card:hover {
+      transform: translateY(-4px);
+      box-shadow: 0 20px 25px -5px rgba(0, 0, 0, 0.1), 0 10px 10px -5px rgba(0, 0, 0, 0.04);
+    }
+
+    .card-header {
+      background: linear-gradient(135deg, var(--primary-color), var(--primary-hover));
+      color: white;
+      border: none;
+      border-radius: 16px 16px 0 0 !important;
+      font-weight: 600;
+      font-size: 1.1rem;
+      padding: 1.25rem 1.5rem;
+    }
+
+    .card-body {
+      padding: 1.5rem;
+    }
+    .btn {
+      border-radius: 10px;
+      font-weight: 500;
+      transition: all 0.3s ease;
+      padding: 0.5rem 1rem;
+    }
+
+    .btn:hover {
+      transform: translateY(-2px);
+      box-shadow: 0 4px 6px -1px rgba(0, 0, 0, 0.1), 0 2px 4px -1px rgba(0, 0, 0, 0.06);
+    }
+
+    .btn-primary {
+      background: linear-gradient(135deg, var(--primary-color), var(--primary-hover));
+      border: none;
+    }
+
+    .btn-success {
+      background: linear-gradient(135deg, var(--success-color), #059669);
+      border: none;
+    }
+
+    .btn-danger {
+      background: linear-gradient(135deg, var(--danger-color), #dc2626);
+      border: none;
+    }
+
+    .btn-outline-primary {
+      border: 2px solid var(--primary-color);
+      color: var(--primary-color);
+    }
+
+    .btn-outline-primary:hover {
+      background: var(--primary-color);
+      border-color: var(--primary-color);
+      color: white;
+    }
+
+    .btn-outline-success {
+      border: 2px solid var(--success-color);
+      color: var(--success-color);
+    }
+
+    .btn-outline-success:hover {
+      background: var(--success-color);
+      border-color: var(--success-color);
+      color: white;
+    }
+
+    .btn-outline-info {
+      border: 2px solid #0dcaf0;
+      color: #0dcaf0;
+    }
+
+    .btn-outline-info:hover {
+      background: #0dcaf0;
+      border-color: #0dcaf0;
+      color: white;
+    }
+
+    .btn-outline-danger {
+      border: 2px solid var(--danger-color);
+      color: var(--danger-color);
+    }
+
+    .btn-outline-danger:hover {
+      background: var(--danger-color);
+      border-color: var(--danger-color);
+      color: white;
+    }
+
+    .table {
+      margin-bottom: 0;
+      background: transparent;
+    }
+
+    .table th {
+      border-top: none;
+      border-bottom: 2px solid var(--border-color);
+      font-weight: 600;
+      color: var(--dark-color);
+      background: rgba(79, 70, 229, 0.05);
+      padding: 1rem;
+    }
+
+    .table td {
+      padding: 1rem;
+      border-bottom: 1px solid var(--border-color);
+      vertical-align: middle;
+    }
+
+    .table tbody tr:hover {
+      background: rgba(79, 70, 229, 0.02);
+    }
+    .badge {
+      font-weight: 500;
+      padding: 5px 10px;
+    }
+    .form-control:focus {
+      border-color: var(--primary-color);
+      box-shadow: 0 0 0 0.25rem rgba(13, 110, 253, 0.25);
+    }
+    .cookie-value {
+      font-family: 'JetBrains Mono', 'Fira Code', 'Courier New', monospace;
+      font-size: 0.85rem;
+      background: #f8fafc;
+      padding: 0.75rem;
+      border-radius: 8px;
+      border: 1px solid #e5e7eb;
+      word-break: break-all;
+      line-height: 1.4;
+      max-height: 120px;
+      overflow-y: auto;
+      white-space: pre-wrap;
+    }
+    .loading {
+      position: fixed;
+      top: 0;
+      left: 0;
+      right: 0;
+      bottom: 0;
+      background-color: rgba(255,255,255,0.7);
+      display: flex;
+      align-items: center;
+      justify-content: center;
+      z-index: 9999;
+    }
+    .loading-spinner {
+      width: 3rem;
+      height: 3rem;
+    }
+    .keyword-editor {
+      border-radius: 10px;
+      box-shadow: 0 0 10px rgba(0,0,0,0.1);
+    }
+    .modal-content {
+      border-radius: 10px;
+      border: none;
+    }
+    .modal-header {
+      border-bottom: 1px solid rgba(0,0,0,0.05);
+    }
+    .modal-footer {
+      border-top: 1px solid rgba(0,0,0,0.05);
+    }
+    .cookie-id {
+      font-weight: 600;
+      color: var(--primary-color);
+      font-size: 1rem;
+    }
+
+    .empty-state {
+      text-align: center;
+      padding: 3rem 2rem;
+      color: var(--secondary-color);
+    }
+
+    .empty-state i {
+      opacity: 0.5;
+    }
+
+    .form-control, .form-select {
+      border-radius: 10px;
+      border: 2px solid var(--border-color);
+      transition: all 0.3s ease;
+      padding: 0.75rem 1rem;
+    }
+
+    .form-control:focus, .form-select:focus {
+      border-color: var(--primary-color);
+      box-shadow: 0 0 0 4px rgba(79, 70, 229, 0.1);
+      transform: translateY(-1px);
+    }
+
+    .form-label {
+      font-weight: 600;
+      color: var(--dark-color);
+      margin-bottom: 0.5rem;
+    }
+
+    .modal-content {
+      border: none;
+      border-radius: 16px;
+      box-shadow: 0 10px 15px -3px rgba(0, 0, 0, 0.1), 0 4px 6px -2px rgba(0, 0, 0, 0.05);
+      backdrop-filter: blur(10px);
+    }
+
+    .modal-header {
+      background: linear-gradient(135deg, var(--primary-color), var(--primary-hover));
+      color: white;
+      border: none;
+      border-radius: 16px 16px 0 0;
+    }
+
+    .toast-container {
+      position: fixed;
+      bottom: 20px;
+      right: 20px;
+      z-index: 9999;
+    }
+
+    .toast {
+      border: none;
+      border-radius: 12px;
+      box-shadow: 0 10px 15px -3px rgba(0, 0, 0, 0.1), 0 4px 6px -2px rgba(0, 0, 0, 0.05);
+      backdrop-filter: blur(10px);
+    }
+
+    .btn-group .btn {
+      margin-right: 0.25rem;
+    }
+
+    .btn-group .btn:last-child {
+      margin-right: 0;
+    }
+
+    @media (max-width: 768px) {
+      .container {
+        margin-top: 1rem;
+        padding: 0 1rem;
+      }
+
+      .card-body {
+        padding: 1rem;
+      }
+
+      .btn {
+        font-size: 0.875rem;
+        padding: 0.375rem 0.75rem;
+      }
+
+      .cookie-value {
+        font-size: 0.75rem;
+        max-height: 80px;
+      }
+
+      .btn-group {
+        flex-direction: column;
+      }
+
+      .btn-group .btn {
+        margin-right: 0;
+        margin-bottom: 0.25rem;
+      }
+
+      /* 移动端商品表格优化 */
+      #itemsTableBody .btn-group {
+        flex-direction: row;
+      }
+
+      #itemsTableBody .btn-group .btn {
+        padding: 0.2rem 0.4rem;
+        font-size: 0.75rem;
+      }
+    }
+
+    /* 商品管理表格优化 */
+    #itemsTableBody .btn-group {
+      white-space: nowrap;
+    }
+
+    #itemsTableBody .btn-group .btn {
+      padding: 0.25rem 0.5rem;
+      font-size: 0.875rem;
+      border-radius: 0.25rem;
+    }
+
+    #itemsTableBody .btn-group .btn:first-child {
+      border-top-right-radius: 0;
+      border-bottom-right-radius: 0;
+    }
+
+    #itemsTableBody .btn-group .btn:last-child {
+      border-top-left-radius: 0;
+      border-bottom-left-radius: 0;
+      border-left: 0;
+    }
+
+    #itemsTableBody .btn-group .btn i {
+      font-size: 0.875rem;
+    }
+
+    /* 表格操作列样式 */
+    .table td:last-child {
+      text-align: center;
+      vertical-align: middle;
+      padding: 0.5rem 0.25rem;
+    }
+
+    /* 表格文本截断优化 */
+    .table td {
+      vertical-align: middle;
+    }
+
+    .table td[title] {
+      cursor: help;
+    }
+
+    /* 商品表格特定优化 */
+    #itemsTableBody td:nth-child(4),
+    #itemsTableBody td:nth-child(5) {
+      max-width: 200px;
+      overflow: hidden;
+      text-overflow: ellipsis;
+      white-space: nowrap;
+    }
+  </style>
+</head>
+<body>
+  <!-- 移动端菜单切换按钮 -->
+  <button class="mobile-toggle" onclick="toggleSidebar()">
+    <i class="bi bi-list"></i>
+  </button>
+
+  <!-- 侧边栏 -->
+  <div class="sidebar" id="sidebar">
+    <div class="sidebar-header">
+      <a href="#" class="sidebar-brand">
+        <i class="bi bi-chat-dots-fill me-2"></i>
+        闲鱼管理系统
+      </a>
+    </div>
+    <nav class="sidebar-nav">
+      <div class="nav-item">
+        <a href="#" class="nav-link active" onclick="showSection('dashboard')">
+          <i class="bi bi-speedometer2"></i>
+          仪表盘
+        </a>
+      </div>
+      <div class="nav-item">
+        <a href="#" class="nav-link" onclick="showSection('accounts')">
+          <i class="bi bi-person-circle"></i>
+          账号管理
+        </a>
+      </div>
+      <div class="nav-item">
+        <a href="#" class="nav-link" onclick="showSection('items')">
+          <i class="bi bi-box-seam"></i>
+          商品管理
+        </a>
+      </div>
+      <div class="nav-item">
+        <a href="#" class="nav-link" onclick="showSection('auto-reply')">
+          <i class="bi bi-chat-left-text"></i>
+          自动回复
+        </a>
+      </div>
+      <div class="nav-item">
+        <a href="#" class="nav-link" onclick="showSection('cards')">
+          <i class="bi bi-credit-card"></i>
+          卡券管理
+        </a>
+      </div>
+      <div class="nav-item">
+        <a href="#" class="nav-link" onclick="showSection('auto-delivery')">
+          <i class="bi bi-truck"></i>
+          自动发货
+        </a>
+      </div>
+      <div class="nav-item">
+        <a href="#" class="nav-link" onclick="showSection('notification-channels')">
+          <i class="bi bi-bell"></i>
+          通知渠道
+        </a>
+      </div>
+      <div class="nav-item">
+        <a href="#" class="nav-link" onclick="showSection('message-notifications')">
+          <i class="bi bi-chat-dots"></i>
+          消息通知
+        </a>
+      </div>
+      <div class="nav-item">
+        <a href="#" class="nav-link" onclick="showSection('logs')">
+          <i class="bi bi-file-text"></i>
+          日志管理
+        </a>
+      </div>
+      <div class="nav-item">
+        <a href="#" class="nav-link" onclick="showSection('system-settings')">
+          <i class="bi bi-gear"></i>
+          系统设置
+        </a>
+      </div>
+      <div class="nav-item">
+        <a href="#" class="nav-link" onclick="showSection('about')">
+          <i class="bi bi-info-circle"></i>
+          关于
+        </a>
+      </div>
+      <div class="nav-item mt-auto" style="position: absolute; bottom: 2rem; width: 100%;">
+        <a href="#" class="nav-link" onclick="logout()">
+          <i class="bi bi-box-arrow-right"></i>
+          登出
+        </a>
+      </div>
+    </nav>
+  </div>
+
+  <!-- 主内容区域 -->
+  <div class="main-content">
+    <!-- 仪表盘内容 -->
+    <div id="dashboard-section" class="content-section active">
+      <div class="content-header">
+        <h2 class="mb-0">
+          <i class="bi bi-speedometer2 me-2"></i>
+          仪表盘
+        </h2>
+        <p class="text-muted mb-0">系统概览和统计信息</p>
+      </div>
+      <div class="content-body">
+        <div class="dashboard-stats">
+          <div class="stat-card">
+            <div class="stat-icon primary">
+              <i class="bi bi-person-circle"></i>
+            </div>
+            <div class="stat-number" id="totalAccounts">0</div>
+            <div class="stat-label">总账号数</div>
+          </div>
+          <div class="stat-card">
+            <div class="stat-icon success">
+              <i class="bi bi-chat-left-text"></i>
+            </div>
+            <div class="stat-number" id="totalKeywords">0</div>
+            <div class="stat-label">总关键词数</div>
+          </div>
+          <div class="stat-card">
+            <div class="stat-icon warning">
+              <i class="bi bi-activity"></i>
+            </div>
+            <div class="stat-number" id="activeAccounts">0</div>
+            <div class="stat-label">启用账号数</div>
+          </div>
+        </div>
+
+        <!-- 账号详情列表 -->
+        <div class="card">
+          <div class="card-header">
+            <h5 class="mb-0">
+              <i class="bi bi-list-ul me-2"></i>
+              账号详情
+            </h5>
+          </div>
+          <div class="card-body p-0">
+            <div class="table-responsive">
+              <table class="table table-hover mb-0">
+                <thead>
+                  <tr>
+                    <th>账号ID</th>
+                    <th>关键词数量</th>
+                    <th>状态</th>
+                    <th>最后更新</th>
+                  </tr>
+                </thead>
+                <tbody id="dashboardAccountsList">
+                  <!-- 动态生成 -->
+                </tbody>
+              </table>
+            </div>
+          </div>
+        </div>
+      </div>
+    </div>
+
+    <!-- 账号管理内容 -->
+    <div id="accounts-section" class="content-section">
+      <div class="content-header">
+        <h2 class="mb-0">
+          <i class="bi bi-person-circle me-2"></i>
+          账号管理
+        </h2>
+        <p class="text-muted mb-0">管理闲鱼账号Cookie信息</p>
+      </div>
+      <div class="content-body">
+        <!-- 添加Cookie卡片 -->
+        <div class="card mb-4">
+          <div class="card-header d-flex justify-content-between align-items-center">
+            <span><i class="bi bi-plus-circle me-2"></i>添加新账号</span>
+          </div>
+          <div class="card-body">
+            <form id="addForm" class="row g-3">
+              <div class="col-md-3">
+                <label for="cookieId" class="form-label">账号ID</label>
+                <input type="text" class="form-control" id="cookieId" placeholder="唯一标识" required>
+              </div>
+              <div class="col-md-9">
+                <label for="cookieValue" class="form-label">Cookie值</label>
+                <input type="text" class="form-control" id="cookieValue" placeholder="完整Cookie字符串" required>
+              </div>
+              <div class="col-12">
+                <button type="submit" class="btn btn-primary">
+                  <i class="bi bi-plus-lg me-1"></i>添加账号
+                </button>
+              </div>
+            </form>
+          </div>
+        </div>
+
+        <!-- Cookie列表卡片 -->
+        <div class="card">
+          <div class="card-header d-flex justify-content-between align-items-center">
+            <span><i class="bi bi-list-ul me-2"></i>账号列表</span>
+            <div class="btn-group">
+              <button class="btn btn-sm btn-outline-success" onclick="openDefaultReplyManager()">
+                <i class="bi bi-chat-text me-1"></i>默认回复管理
+              </button>
+              <button class="btn btn-sm btn-outline-primary" onclick="loadCookies()">
+                <i class="bi bi-arrow-clockwise me-1"></i>刷新
+              </button>
+            </div>
+          </div>
+          <div class="card-body p-0">
+            <div class="table-responsive">
+              <table class="table table-hover" id="cookieTable">
+                <thead>
+                  <tr>
+                    <th style="width: 10%">账号ID</th>
+                    <th style="width: 25%">Cookie值</th>
+                    <th style="width: 10%">关键词</th>
+                    <th style="width: 10%">状态</th>
+                    <th style="width: 12%">默认回复</th>
+                    <th style="width: 33%">操作</th>
+                  </tr>
+                </thead>
+                <tbody></tbody>
+              </table>
+            </div>
+          </div>
+        </div>
+      </div>
+    </div>
+
+    <!-- 商品管理内容 -->
+    <div id="items-section" class="content-section">
+      <div class="content-header">
+        <h2 class="mb-0">
+          <i class="bi bi-box-seam me-2"></i>
+          商品管理
+        </h2>
+        <p class="text-muted mb-0">管理各账号的商品信息</p>
+      </div>
+
+      <div class="content-body">
+        <!-- Cookie筛选 -->
+        <div class="card mb-4">
+          <div class="card-body">
+            <div class="row align-items-center">
+              <div class="col-md-6">
+                <label for="itemCookieFilter" class="form-label">筛选账号</label>
+                <select class="form-select" id="itemCookieFilter" onchange="loadItemsByCookie()">
+                  <option value="">所有账号</option>
+                </select>
+              </div>
+              <div class="col-md-6">
+                <div class="d-flex justify-content-end align-items-end h-100 gap-2">
+                  <button class="btn btn-success" onclick="getAllItemsFromAccount()">
+                    <i class="bi bi-download me-1"></i>获取所有商品
+                  </button>
+                  <button class="btn btn-primary" onclick="refreshItems()">
+                    <i class="bi bi-arrow-clockwise me-1"></i>刷新
+                  </button>
+                </div>
+              </div>
+            </div>
+          </div>
+        </div>
+
+        <!-- 商品列表 -->
+        <div class="card">
+          <div class="card-header d-flex justify-content-between align-items-center">
+            <h5 class="mb-0">商品列表(自动发货根据商品标题和商品详情匹配关键字)</h5>
+            <button class="btn btn-sm btn-outline-danger" onclick="batchDeleteItems()" id="batchDeleteBtn" disabled>
+              <i class="bi bi-trash"></i> 批量删除
+            </button>
+          </div>
+          <div class="card-body">
+            <div class="table-responsive">
+              <table class="table table-hover">
+                <thead>
+                  <tr>
+                    <th style="width: 5%">
+                      <input type="checkbox" id="selectAllItems" onchange="toggleSelectAll(this)">
+                    </th>
+                    <th style="width: 15%">账号ID</th>
+                    <th style="width: 15%">商品ID</th>
+                    <th style="width: 20%">商品标题</th>
+                    <th style="width: 25%">商品详情</th>
+                    <th style="width: 12%">更新时间</th>
+                    <th style="width: 8%">操作</th>
+                  </tr>
+                </thead>
+                <tbody id="itemsTableBody">
+                  <tr>
+                    <td colspan="7" class="text-center text-muted">加载中...</td>
+                  </tr>
+                </tbody>
+              </table>
+            </div>
+          </div>
+        </div>
+      </div>
+    </div>
+
+    <!-- 自动回复内容 -->
+    <div id="auto-reply-section" class="content-section">
+      <div class="content-header">
+        <h2 class="mb-0">
+          <i class="bi bi-chat-left-text me-2"></i>
+          自动回复
+        </h2>
+        <p class="text-muted mb-0">设置账号的关键词自动回复</p>
+      </div>
+      <div class="content-body">
+        <!-- 现代化账号选择器 -->
+        <div class="account-selector">
+          <div class="selector-header">
+            <div class="selector-icon">
+              <i class="bi bi-person-circle"></i>
+            </div>
+            <div>
+              <h3 class="selector-title">选择账号</h3>
+              <p class="selector-subtitle">选择要配置自动回复的闲鱼账号</p>
+            </div>
+          </div>
+          <div class="row g-3 align-items-end">
+            <div class="col-md-8">
+              <div class="account-select-wrapper">
+                <select class="account-select" id="accountSelect" onchange="loadAccountKeywords()">
+                  <option value="">🔍 请选择一个账号开始配置...</option>
+                </select>
+              </div>
+            </div>
+            <div class="col-md-4">
+              <button class="btn btn-outline-primary w-100" onclick="refreshAccountList()">
+                <i class="bi bi-arrow-clockwise me-2"></i>刷新列表
+              </button>
+            </div>
+          </div>
+        </div>
+
+        <!-- 现代化关键词管理容器 -->
+        <div class="keyword-container" id="keywordManagement" style="display: none;">
+          <div class="keyword-header">
+            <h3>
+              <i class="bi bi-chat-dots me-2"></i>
+              关键词管理
+            </h3>
+            <div class="account-badge" id="currentAccountBadge">
+              <!-- 动态显示当前账号 -->
+            </div>
+          </div>
+
+          <!-- 添加关键词区域 -->
+          <div class="keyword-input-area">
+            <div class="keyword-input-group">
+              <div class="input-field">
+                <label>关键词</label>
+                <input type="text" id="newKeyword" placeholder="例如：你好、价格、发货...">
+              </div>
+              <div class="input-field">
+                <label>自动回复内容</label>
+                <input type="text" id="newReply" placeholder="例如：您好，欢迎咨询！有什么可以帮助您的吗？">
+              </div>
+              <button class="add-btn" onclick="addKeyword()">
+                <i class="bi bi-plus-lg"></i>
+                添加
+              </button>
+            </div>
+            <div class="mt-3">
+              <small class="text-muted">
+                <i class="bi bi-lightbulb me-1"></i>
+                <strong>支持变量：</strong>
+                <code>{send_user_name}</code> 用户昵称，
+                <code>{send_user_id}</code> 用户ID，
+                <code>{send_message}</code> 用户消息
+              </small>
+            </div>
+          </div>
+
+          <!-- 关键词列表 -->
+          <div class="keywords-list" id="keywordsList">
+            <!-- 动态生成的关键词列表 -->
+          </div>
+        </div>
+      </div>
+    </div>
+
+    <!-- 卡券管理内容 -->
+    <div id="cards-section" class="content-section">
+      <div class="content-header">
+        <h2 class="mb-0">
+          <i class="bi bi-credit-card me-2"></i>
+          卡券管理
+        </h2>
+        <p class="text-muted mb-0">管理虚拟商品的卡券数据，支持API、固定文字和批量数据</p>
+      </div>
+      <div class="content-body">
+        <!-- 卡券列表 -->
+        <div class="row">
+          <div class="col-md-8">
+            <div class="card">
+              <div class="card-header d-flex justify-content-between align-items-center">
+                <h5 class="mb-0">卡券列表</h5>
+                <button class="btn btn-primary btn-sm" onclick="showAddCardModal()">
+                  <i class="bi bi-plus-lg me-1"></i>添加卡券
+                </button>
+              </div>
+              <div class="card-body">
+                <div class="table-responsive">
+                  <table class="table table-hover">
+                    <thead>
+                      <tr>
+                        <th>卡券名称</th>
+                        <th>类型</th>
+                        <th>数据量</th>
+                        <th>状态</th>
+                        <th>创建时间</th>
+                        <th>操作</th>
+                      </tr>
+                    </thead>
+                    <tbody id="cardsTableBody">
+                      <tr>
+                        <td colspan="6" class="text-center py-4 text-muted">
+                          <i class="bi bi-credit-card fs-1 d-block mb-3"></i>
+                          <h5>暂无卡券数据</h5>
+                          <p class="mb-0">点击"添加卡券"开始创建您的第一个卡券</p>
+                        </td>
+                      </tr>
+                    </tbody>
+                  </table>
+                </div>
+              </div>
+            </div>
+          </div>
+          <div class="col-md-4">
+            <div class="card">
+              <div class="card-header">
+                <h5 class="mb-0">统计信息</h5>
+              </div>
+              <div class="card-body">
+                <div class="stat-item mb-3">
+                  <div class="d-flex justify-content-between">
+                    <span>总卡券数</span>
+                    <span class="badge bg-primary" id="totalCards">0</span>
+                  </div>
+                </div>
+                <div class="stat-item mb-3">
+                  <div class="d-flex justify-content-between">
+                    <span>API类型</span>
+                    <span class="badge bg-info" id="apiCards">0</span>
+                  </div>
+                </div>
+                <div class="stat-item mb-3">
+                  <div class="d-flex justify-content-between">
+                    <span>固定文字</span>
+                    <span class="badge bg-success" id="textCards">0</span>
+                  </div>
+                </div>
+                <div class="stat-item">
+                  <div class="d-flex justify-content-between">
+                    <span>批量数据</span>
+                    <span class="badge bg-warning" id="dataCards">0</span>
+                  </div>
+                </div>
+              </div>
+            </div>
+          </div>
+        </div>
+      </div>
+    </div>
+
+    <!-- 自动发货内容 -->
+    <div id="auto-delivery-section" class="content-section">
+      <div class="content-header">
+        <h2 class="mb-0">
+          <i class="bi bi-truck me-2"></i>
+          自动发货
+        </h2>
+        <p class="text-muted mb-0">根据商品关键字自动匹配卡券进行发货</p>
+      </div>
+      <div class="content-body">
+        <!-- 发货规则列表 -->
+        <div class="row">
+          <div class="col-md-8">
+            <div class="card">
+              <div class="card-header d-flex justify-content-between align-items-center">
+                <h5 class="mb-0">发货规则</h5>
+                <button class="btn btn-primary btn-sm" onclick="showAddDeliveryRuleModal()">
+                  <i class="bi bi-plus-lg me-1"></i>添加规则
+                </button>
+              </div>
+              <div class="card-body">
+                <div class="table-responsive">
+                  <table class="table table-hover">
+                    <thead>
+                      <tr>
+                        <th>商品关键字</th>
+                        <th>匹配卡券</th>
+                        <th>卡券类型</th>
+                        <th>发货数量</th>
+                        <th>状态</th>
+                        <th>已发货次数</th>
+                        <th>操作</th>
+                      </tr>
+                    </thead>
+                    <tbody id="deliveryRulesTableBody">
+                      <tr>
+                        <td colspan="7" class="text-center py-4 text-muted">
+                          <i class="bi bi-truck fs-1 d-block mb-3"></i>
+                          <h5>暂无发货规则</h5>
+                          <p class="mb-0">点击"添加规则"开始配置自动发货规则</p>
+                        </td>
+                      </tr>
+                    </tbody>
+                  </table>
+                </div>
+              </div>
+            </div>
+          </div>
+          <div class="col-md-4">
+            <div class="card">
+              <div class="card-header">
+                <h5 class="mb-0">发货统计</h5>
+              </div>
+              <div class="card-body">
+                <div class="stat-item mb-3">
+                  <div class="d-flex justify-content-between">
+                    <span>总规则数</span>
+                    <span class="badge bg-primary" id="totalRules">0</span>
+                  </div>
+                </div>
+                <div class="stat-item mb-3">
+                  <div class="d-flex justify-content-between">
+                    <span>启用规则</span>
+                    <span class="badge bg-success" id="activeRules">0</span>
+                  </div>
+                </div>
+                <div class="stat-item mb-3">
+                  <div class="d-flex justify-content-between">
+                    <span>今日发货</span>
+                    <span class="badge bg-info" id="todayDeliveries">0</span>
+                  </div>
+                </div>
+                <div class="stat-item">
+                  <div class="d-flex justify-content-between">
+                    <span>总发货量</span>
+                    <span class="badge bg-warning" id="totalDeliveries">0</span>
+                  </div>
+                </div>
+              </div>
+            </div>
+          </div>
+        </div>
+      </div>
+    </div>
+
+    <!-- 通知渠道管理内容 -->
+    <div id="notification-channels-section" class="content-section">
+      <div class="content-header">
+        <h2 class="mb-0">
+          <i class="bi bi-bell me-2"></i>
+          通知渠道管理
+        </h2>
+        <p class="text-muted mb-0">管理消息通知渠道，支持QQ通知等多种方式</p>
+      </div>
+      <div class="content-body">
+        <!-- 添加通知渠道 -->
+        <div class="card mb-4">
+          <div class="card-header">
+            <span><i class="bi bi-plus-circle me-2"></i>添加QQ通知渠道</span>
+          </div>
+          <div class="card-body">
+            <div class="alert alert-info">
+              <i class="bi bi-info-circle me-2"></i>
+              <strong>使用说明：</strong>需要添加QQ号 <code>3668943488</code> 为好友才能正常接收消息通知
+            </div>
+            <form id="addChannelForm" class="row g-3">
+              <div class="col-md-4">
+                <label for="channelName" class="form-label">渠道名称</label>
+                <input type="text" class="form-control" id="channelName" placeholder="例如：我的QQ通知" required>
+              </div>
+              <div class="col-md-4">
+                <label for="channelQQ" class="form-label">接收QQ号码</label>
+                <input type="text" class="form-control" id="channelQQ" placeholder="输入QQ号码" required>
+              </div>
+              <div class="col-md-4 d-flex align-items-end">
+                <button type="submit" class="btn btn-primary">
+                  <i class="bi bi-plus-lg me-1"></i>添加渠道
+                </button>
+              </div>
+            </form>
+          </div>
+        </div>
+
+        <!-- 通知渠道列表 -->
+        <div class="card">
+          <div class="card-header d-flex justify-content-between align-items-center">
+            <span><i class="bi bi-list-ul me-2"></i>通知渠道列表</span>
+            <button class="btn btn-sm btn-outline-primary" onclick="loadNotificationChannels()">
+              <i class="bi bi-arrow-clockwise me-1"></i>刷新
+            </button>
+          </div>
+          <div class="card-body">
+            <div class="table-responsive">
+              <table class="table table-hover" id="channelsTable">
+                <thead>
+                  <tr>
+                    <th style="width: 10%">ID</th>
+                    <th style="width: 25%">名称</th>
+                    <th style="width: 15%">类型</th>
+                    <th style="width: 20%">配置</th>
+                    <th style="width: 10%">状态</th>
+                    <th style="width: 20%">操作</th>
+                  </tr>
+                </thead>
+                <tbody id="channelsTableBody">
+                  <!-- 动态生成 -->
+                </tbody>
+              </table>
+            </div>
+          </div>
+        </div>
+      </div>
+    </div>
+
+    <!-- 消息通知配置内容 -->
+    <div id="message-notifications-section" class="content-section">
+      <div class="content-header">
+        <h2 class="mb-0">
+          <i class="bi bi-chat-dots me-2"></i>
+          消息通知配置
+        </h2>
+        <p class="text-muted mb-0">为每个账号配置消息通知渠道</p>
+      </div>
+      <div class="content-body">
+        <div class="card">
+          <div class="card-header d-flex justify-content-between align-items-center">
+            <span><i class="bi bi-gear me-2"></i>账号通知配置</span>
+            <button class="btn btn-sm btn-outline-primary" onclick="loadMessageNotifications()">
+              <i class="bi bi-arrow-clockwise me-1"></i>刷新
+            </button>
+          </div>
+          <div class="card-body">
+            <div class="table-responsive">
+              <table class="table table-hover" id="notificationsTable">
+                <thead>
+                  <tr>
+                    <th style="width: 20%">账号ID</th>
+                    <th style="width: 30%">通知渠道</th>
+                    <th style="width: 15%">状态</th>
+                    <th style="width: 35%">操作</th>
+                  </tr>
+                </thead>
+                <tbody id="notificationsTableBody">
+                  <!-- 动态生成 -->
+                </tbody>
+              </table>
+            </div>
+          </div>
+        </div>
+      </div>
+    </div>
+
+    <!-- 日志管理内容 -->
+    <div id="logs-section" class="content-section">
+      <div class="content-header">
+        <h2 class="mb-0">
+          <i class="bi bi-file-text me-2"></i>
+          日志管理
+        </h2>
+        <p class="text-muted mb-0">实时显示系统日志，支持自动刷新和统计分析</p>
+      </div>
+
+      <div class="content-body">
+        <!-- 日志控制 -->
+        <div class="row mb-3">
+          <div class="col-md-3">
+            <label for="logLines" class="form-label">显示行数</label>
+            <select class="form-select" id="logLines" onchange="refreshLogs()">
+              <option value="100">100行</option>
+              <option value="200" selected>200行</option>
+              <option value="500">500行</option>
+              <option value="1000">1000行</option>
+              <option value="2000">2000行</option>
+            </select>
+          </div>
+          <div class="col-md-9">
+            <label class="form-label">&nbsp;</label>
+            <div class="d-flex gap-2">
+              <button class="btn btn-outline-primary" onclick="refreshLogs()">
+                <i class="bi bi-arrow-clockwise me-1"></i>刷新日志
+              </button>
+              <button class="btn btn-outline-secondary" onclick="clearLogsDisplay()">
+                <i class="bi bi-trash me-1"></i>清空显示
+              </button>
+              <button class="btn btn-outline-danger" onclick="clearLogsServer()">
+                <i class="bi bi-trash3 me-1"></i>清空服务器日志
+              </button>
+              <button class="btn btn-outline-info" onclick="showLogStats()">
+                <i class="bi bi-bar-chart me-1"></i>统计信息
+              </button>
+              <button class="btn btn-outline-info" onclick="toggleAutoRefresh()">
+                <i class="bi bi-play-circle me-1"></i><span id="autoRefreshText">开启自动刷新</span>
+              </button>
+            </div>
+          </div>
+        </div>
+
+        <!-- 日志显示区域 -->
+        <div class="card">
+          <div class="card-header d-flex justify-content-between align-items-center">
+            <span>系统日志</span>
+            <div class="d-flex gap-2">
+              <span class="badge bg-secondary" id="logCount">0 条日志</span>
+              <span class="badge bg-info" id="lastUpdate">未更新</span>
+            </div>
+          </div>
+          <div class="card-body p-0">
+            <div id="logContainer" class="log-container">
+              <div class="text-center p-4 text-muted">
+                <i class="bi bi-file-text fs-1"></i>
+                <p class="mt-2">点击刷新按钮加载日志</p>
+              </div>
+            </div>
+          </div>
+        </div>
+      </div>
+    </div>
+
+    <!-- 系统设置内容 -->
+    <div id="system-settings-section" class="content-section">
+      <div class="content-header">
+        <h2 class="mb-0">
+          <i class="bi bi-gear me-2"></i>
+          系统设置
+        </h2>
+        <p class="text-muted mb-0">管理系统配置和用户设置</p>
+      </div>
+      <div class="content-body">
+        <div class="row">
+          <!-- 密码设置 -->
+          <div class="col-md-6">
+            <div class="card">
+              <div class="card-header">
+                <i class="bi bi-shield-lock me-2"></i>密码设置
+              </div>
+              <div class="card-body">
+                <form id="passwordForm">
+                  <div class="mb-3">
+                    <label for="currentPassword" class="form-label">当前密码</label>
+                    <input type="password" class="form-control" id="currentPassword" required>
+                  </div>
+                  <div class="mb-3">
+                    <label for="newPassword" class="form-label">新密码</label>
+                    <input type="password" class="form-control" id="newPassword" required>
+                  </div>
+                  <div class="mb-3">
+                    <label for="confirmPassword" class="form-label">确认新密码</label>
+                    <input type="password" class="form-control" id="confirmPassword" required>
+                  </div>
+                  <button type="submit" class="btn btn-primary">
+                    <i class="bi bi-check-circle me-1"></i>更新密码
+                  </button>
+                </form>
+              </div>
+            </div>
+          </div>
+
+          <!-- 主题设置 -->
+          <div class="col-md-6">
+            <div class="card">
+              <div class="card-header">
+                <i class="bi bi-palette me-2"></i>主题设置
+              </div>
+              <div class="card-body">
+                <form id="themeForm">
+                  <div class="mb-3">
+                    <label for="themeColor" class="form-label">主题颜色</label>
+                    <select class="form-select" id="themeColor">
+                      <option value="blue">蓝色</option>
+                      <option value="green">绿色</option>
+                      <option value="purple">紫色</option>
+                      <option value="red">红色</option>
+                      <option value="orange">橙色</option>
+                    </select>
+                  </div>
+                  <button type="submit" class="btn btn-primary">
+                    <i class="bi bi-check-circle me-1"></i>应用主题
+                  </button>
+                </form>
+              </div>
+            </div>
+          </div>
+        </div>
+
+        <!-- 备份管理 -->
+        <div class="row mt-4">
+          <div class="col-12">
+            <div class="card">
+              <div class="card-header">
+                <i class="bi bi-archive me-2"></i>备份管理
+              </div>
+              <div class="card-body">
+                <div class="row">
+                  <!-- 导出备份 -->
+                  <div class="col-md-6">
+                    <h6 class="mb-3">
+                      <i class="bi bi-download me-2"></i>导出备份
+                    </h6>
+                    <p class="text-muted mb-3">导出系统的所有设置、账号管理、自动回复、卡券管理等数据</p>
+                    <button type="button" class="btn btn-success" onclick="exportBackup()">
+                      <i class="bi bi-download me-1"></i>导出备份
+                    </button>
+                  </div>
+
+                  <!-- 导入备份 -->
+                  <div class="col-md-6">
+                    <h6 class="mb-3">
+                      <i class="bi bi-upload me-2"></i>导入备份
+                    </h6>
+                    <p class="text-muted mb-3">导入之前导出的备份文件，将覆盖当前所有数据</p>
+                    <div class="mb-3">
+                      <input type="file" class="form-control" id="backupFile" accept=".json">
+                    </div>
+                    <button type="button" class="btn btn-warning" onclick="importBackup()">
+                      <i class="bi bi-upload me-1"></i>导入备份
+                    </button>
+                  </div>
+                </div>
+
+                <div class="alert alert-warning mt-4" role="alert">
+                  <i class="bi bi-exclamation-triangle me-2"></i>
+                  <strong>注意：</strong>导入备份将会覆盖当前系统的所有数据，请谨慎操作！建议在导入前先导出当前数据作为备份。
+                </div>
+              </div>
+            </div>
+          </div>
+        </div>
+      </div>
+    </div>
+
+    <!-- 关于页面内容 -->
+    <div id="about-section" class="content-section">
+      <div class="content-header">
+        <h2 class="mb-0">
+          <i class="bi bi-info-circle me-2"></i>
+          关于
+        </h2>
+        <p class="text-muted mb-0">联系我们和技术支持</p>
+      </div>
+      <div class="content-body">
+        <div class="row">
+          <div class="col-md-6">
+            <div class="card">
+              <div class="card-header">
+                <i class="bi bi-wechat me-2"></i>微信群
+              </div>
+              <div class="card-body text-center">
+                <img src="https://img.zhinianboke.com/img/5527" alt="微信群二维码" class="img-fluid" style="max-width: 200px;">
+                <p class="mt-3 text-muted">扫码加入微信技术交流群</p>
+              </div>
+            </div>
+          </div>
+          <div class="col-md-6">
+            <div class="card">
+              <div class="card-header">
+                <i class="bi bi-chat-square me-2"></i>QQ群
+              </div>
+              <div class="card-body text-center">
+                <img src="https://img.zhinianboke.com/img/5526" alt="QQ群二维码" class="img-fluid" style="max-width: 200px;">
+                <p class="mt-3 text-muted">扫码加入QQ技术交流群</p>
+              </div>
+            </div>
+          </div>
+        </div>
+      </div>
+    </div>
+
+  </div> <!-- 结束 main-content -->
+
+  <!-- 编辑通知渠道模态框 -->
+  <div class="modal fade" id="editChannelModal" tabindex="-1">
+    <div class="modal-dialog">
+      <div class="modal-content">
+        <div class="modal-header">
+          <h5 class="modal-title">
+            <i class="bi bi-pencil me-2"></i>
+            编辑通知渠道
+          </h5>
+          <button type="button" class="btn-close" data-bs-dismiss="modal"></button>
+        </div>
+        <div class="modal-body">
+          <form id="editChannelForm">
+            <input type="hidden" id="editChannelId">
+            <div class="mb-3">
+              <label for="editChannelName" class="form-label">渠道名称 <span class="text-danger">*</span></label>
+              <input type="text" class="form-control" id="editChannelName" placeholder="例如：我的QQ通知" required>
+            </div>
+            <div class="mb-3">
+              <label for="editChannelQQ" class="form-label">接收QQ号码 <span class="text-danger">*</span></label>
+              <input type="text" class="form-control" id="editChannelQQ" placeholder="输入QQ号码" required>
+            </div>
+            <div class="mb-3">
+              <div class="form-check">
+                <input class="form-check-input" type="checkbox" id="editChannelEnabled" checked>
+                <label class="form-check-label" for="editChannelEnabled">
+                  启用此通知渠道
+                </label>
+              </div>
+            </div>
+          </form>
+        </div>
+        <div class="modal-footer">
+          <button type="button" class="btn btn-secondary" data-bs-dismiss="modal">取消</button>
+          <button type="button" class="btn btn-primary" onclick="updateNotificationChannel()">保存修改</button>
+        </div>
+      </div>
+    </div>
+  </div>
+
+  <!-- 配置账号通知模态框 -->
+  <div class="modal fade" id="configNotificationModal" tabindex="-1">
+    <div class="modal-dialog">
+      <div class="modal-content">
+        <div class="modal-header">
+          <h5 class="modal-title">
+            <i class="bi bi-gear me-2"></i>
+            配置账号通知
+          </h5>
+          <button type="button" class="btn-close" data-bs-dismiss="modal"></button>
+        </div>
+        <div class="modal-body">
+          <form id="configNotificationForm">
+            <input type="hidden" id="configAccountId">
+            <div class="mb-3">
+              <label class="form-label">账号ID</label>
+              <input type="text" class="form-control" id="displayAccountId" readonly>
+            </div>
+            <div class="mb-3">
+              <label for="notificationChannel" class="form-label">选择通知渠道 <span class="text-danger">*</span></label>
+              <select class="form-select" id="notificationChannel" required>
+                <option value="">请选择通知渠道</option>
+              </select>
+              <small class="form-text text-muted">选择要接收此账号消息通知的渠道</small>
+            </div>
+            <div class="mb-3">
+              <div class="form-check">
+                <input class="form-check-input" type="checkbox" id="notificationEnabled" checked>
+                <label class="form-check-label" for="notificationEnabled">
+                  启用消息通知
+                </label>
+              </div>
+            </div>
+          </form>
+        </div>
+        <div class="modal-footer">
+          <button type="button" class="btn btn-secondary" data-bs-dismiss="modal">取消</button>
+          <button type="button" class="btn btn-primary" onclick="saveAccountNotification()">保存配置</button>
+        </div>
+      </div>
+    </div>
+  </div>
+
+  <!-- 添加卡券模态框 -->
+  <div class="modal fade" id="addCardModal" tabindex="-1">
+    <div class="modal-dialog modal-lg">
+      <div class="modal-content">
+        <div class="modal-header">
+          <h5 class="modal-title">
+            <i class="bi bi-credit-card me-2"></i>
+            添加卡券
+          </h5>
+          <button type="button" class="btn-close" data-bs-dismiss="modal"></button>
+        </div>
+        <div class="modal-body">
+          <form id="addCardForm">
+            <div class="mb-3">
+              <label class="form-label">卡券名称 <span class="text-danger">*</span></label>
+              <input type="text" class="form-control" id="cardName" placeholder="例如：游戏点卡、会员卡等" required>
+            </div>
+            <div class="mb-3">
+              <label class="form-label">卡券类型 <span class="text-danger">*</span></label>
+              <select class="form-select" id="cardType" onchange="toggleCardTypeFields()" required>
+                <option value="">请选择类型</option>
+                <option value="api">API接口</option>
+                <option value="text">固定文字</option>
+                <option value="data">批量数据</option>
+              </select>
+            </div>
+
+            <!-- API配置 -->
+            <div id="apiFields" class="card mb-3" style="display: none;">
+              <div class="card-header">
+                <h6 class="mb-0">API配置</h6>
+              </div>
+              <div class="card-body">
+                <div class="mb-3">
+                  <label class="form-label">API地址</label>
+                  <input type="url" class="form-control" id="apiUrl" placeholder="https://api.example.com/get-card">
+                </div>
+                <div class="row">
+                  <div class="col-md-6">
+                    <label class="form-label">请求方法</label>
+                    <select class="form-select" id="apiMethod">
+                      <option value="GET">GET</option>
+                      <option value="POST">POST</option>
+                    </select>
+                  </div>
+                  <div class="col-md-6">
+                    <label class="form-label">超时时间(秒)</label>
+                    <input type="number" class="form-control" id="apiTimeout" value="10" min="1" max="60">
+                  </div>
+                </div>
+                <div class="mb-3">
+                  <label class="form-label">请求头 (JSON格式)</label>
+                  <textarea class="form-control" id="apiHeaders" rows="3" placeholder='{"Authorization": "Bearer token", "Content-Type": "application/json"}'></textarea>
+                </div>
+                <div class="mb-3">
+                  <label class="form-label">请求参数 (JSON格式)</label>
+                  <textarea class="form-control" id="apiParams" rows="3" placeholder='{"type": "card", "count": 1}'></textarea>
+                </div>
+              </div>
+            </div>
+
+            <!-- 固定文字配置 -->
+            <div id="textFields" class="card mb-3" style="display: none;">
+              <div class="card-header">
+                <h6 class="mb-0">固定文字配置</h6>
+              </div>
+              <div class="card-body">
+                <div class="mb-3">
+                  <label class="form-label">固定文字内容</label>
+                  <textarea class="form-control" id="textContent" rows="5" placeholder="请输入要发送的固定文字内容..."></textarea>
+                </div>
+              </div>
+            </div>
+
+            <!-- 批量数据配置 -->
+            <div id="dataFields" class="card mb-3" style="display: none;">
+              <div class="card-header">
+                <h6 class="mb-0">批量数据配置</h6>
+              </div>
+              <div class="card-body">
+                <div class="mb-3">
+                  <label class="form-label">数据内容 (一行一个)</label>
+                  <textarea class="form-control" id="dataContent" rows="10" placeholder="请输入数据，每行一个：&#10;卡号1:密码1&#10;卡号2:密码2&#10;或者&#10;兑换码1&#10;兑换码2"></textarea>
+                  <small class="form-text text-muted">支持格式：卡号:密码 或 单独的兑换码</small>
+                </div>
+              </div>
+            </div>
+
+            <div class="mb-3">
+              <label class="form-label">备注</label>
+              <textarea class="form-control" id="cardDescription" rows="2" placeholder="可选的备注信息..."></textarea>
+            </div>
+          </form>
+        </div>
+        <div class="modal-footer">
+          <button type="button" class="btn btn-secondary" data-bs-dismiss="modal">取消</button>
+          <button type="button" class="btn btn-primary" onclick="saveCard()">保存卡券</button>
+        </div>
+      </div>
+    </div>
+  </div>
+
+  <!-- 编辑卡券模态框 -->
+  <div class="modal fade" id="editCardModal" tabindex="-1">
+    <div class="modal-dialog modal-lg">
+      <div class="modal-content">
+        <div class="modal-header">
+          <h5 class="modal-title">
+            <i class="bi bi-pencil me-2"></i>
+            编辑卡券
+          </h5>
+          <button type="button" class="btn-close" data-bs-dismiss="modal"></button>
+        </div>
+        <div class="modal-body">
+          <form id="editCardForm">
+            <input type="hidden" id="editCardId">
+            <div class="mb-3">
+              <label class="form-label">卡券名称 <span class="text-danger">*</span></label>
+              <input type="text" class="form-control" id="editCardName" required>
+            </div>
+            <div class="mb-3">
+              <label class="form-label">卡券类型 <span class="text-danger">*</span></label>
+              <select class="form-select" id="editCardType" onchange="toggleEditCardTypeFields()" required>
+                <option value="api">API接口</option>
+                <option value="text">固定文字</option>
+                <option value="data">批量数据</option>
+              </select>
+            </div>
+
+            <!-- API配置 -->
+            <div id="editApiFields" class="card mb-3" style="display: none;">
+              <div class="card-header">
+                <h6 class="mb-0">API配置</h6>
+              </div>
+              <div class="card-body">
+                <div class="mb-3">
+                  <label class="form-label">API地址</label>
+                  <input type="url" class="form-control" id="editApiUrl">
+                </div>
+                <div class="row">
+                  <div class="col-md-6">
+                    <label class="form-label">请求方法</label>
+                    <select class="form-select" id="editApiMethod">
+                      <option value="GET">GET</option>
+                      <option value="POST">POST</option>
+                    </select>
+                  </div>
+                  <div class="col-md-6">
+                    <label class="form-label">超时时间(秒)</label>
+                    <input type="number" class="form-control" id="editApiTimeout" value="10" min="1" max="60">
+                  </div>
+                </div>
+                <div class="mb-3">
+                  <label class="form-label">请求头 (JSON格式)</label>
+                  <textarea class="form-control" id="editApiHeaders" rows="3"></textarea>
+                </div>
+                <div class="mb-3">
+                  <label class="form-label">请求参数 (JSON格式)</label>
+                  <textarea class="form-control" id="editApiParams" rows="3"></textarea>
+                </div>
+              </div>
+            </div>
+
+            <!-- 固定文字配置 -->
+            <div id="editTextFields" class="card mb-3" style="display: none;">
+              <div class="card-header">
+                <h6 class="mb-0">固定文字配置</h6>
+              </div>
+              <div class="card-body">
+                <div class="mb-3">
+                  <label class="form-label">固定文字内容</label>
+                  <textarea class="form-control" id="editTextContent" rows="5"></textarea>
+                </div>
+              </div>
+            </div>
+
+            <!-- 批量数据配置 -->
+            <div id="editDataFields" class="card mb-3" style="display: none;">
+              <div class="card-header">
+                <h6 class="mb-0">批量数据配置</h6>
+              </div>
+              <div class="card-body">
+                <div class="mb-3">
+                  <label class="form-label">数据内容 (一行一个)</label>
+                  <textarea class="form-control" id="editDataContent" rows="10"></textarea>
+                  <small class="form-text text-muted">支持格式：卡号:密码 或 单独的兑换码</small>
+                </div>
+              </div>
+            </div>
+
+            <div class="mb-3">
+              <div class="form-check">
+                <input class="form-check-input" type="checkbox" id="editCardEnabled">
+                <label class="form-check-label" for="editCardEnabled">
+                  启用此卡券
+                </label>
+              </div>
+            </div>
+
+            <div class="mb-3">
+              <label class="form-label">备注</label>
+              <textarea class="form-control" id="editCardDescription" rows="2"></textarea>
+            </div>
+          </form>
+        </div>
+        <div class="modal-footer">
+          <button type="button" class="btn btn-secondary" data-bs-dismiss="modal">取消</button>
+          <button type="button" class="btn btn-primary" onclick="updateCard()">保存修改</button>
+        </div>
+      </div>
+    </div>
+  </div>
+
+  <!-- 添加发货规则模态框 -->
+  <div class="modal fade" id="addDeliveryRuleModal" tabindex="-1">
+    <div class="modal-dialog">
+      <div class="modal-content">
+        <div class="modal-header">
+          <h5 class="modal-title">
+            <i class="bi bi-truck me-2"></i>
+            添加发货规则
+          </h5>
+          <button type="button" class="btn-close" data-bs-dismiss="modal"></button>
+        </div>
+        <div class="modal-body">
+          <form id="addDeliveryRuleForm">
+            <div class="mb-3">
+              <label class="form-label">商品关键字 <span class="text-danger">*</span></label>
+              <input type="text" class="form-control" id="productKeyword" placeholder="例如：游戏点卡、会员卡等" required>
+              <small class="form-text text-muted">当商品标题包含此关键字时触发自动发货</small>
+            </div>
+            <div class="mb-3">
+              <label class="form-label">匹配卡券 <span class="text-danger">*</span></label>
+              <select class="form-select" id="selectedCard" required>
+                <option value="">请选择卡券</option>
+              </select>
+            </div>
+            <div class="mb-3">
+              <label class="form-label">发货数量</label>
+              <input type="number" class="form-control" id="deliveryCount" value="1" min="1" max="10">
+              <small class="form-text text-muted">每次发货的数量</small>
+            </div>
+            <div class="mb-3">
+              <div class="form-check">
+                <input class="form-check-input" type="checkbox" id="ruleEnabled" checked>
+                <label class="form-check-label" for="ruleEnabled">
+                  启用此规则
+                </label>
+              </div>
+            </div>
+            <div class="mb-3">
+              <label class="form-label">备注</label>
+              <textarea class="form-control" id="ruleDescription" rows="2" placeholder="可选的备注信息..."></textarea>
+            </div>
+          </form>
+        </div>
+        <div class="modal-footer">
+          <button type="button" class="btn btn-secondary" data-bs-dismiss="modal">取消</button>
+          <button type="button" class="btn btn-primary" onclick="saveDeliveryRule()">保存规则</button>
+        </div>
+      </div>
+    </div>
+  </div>
+
+  <!-- 编辑发货规则模态框 -->
+  <div class="modal fade" id="editDeliveryRuleModal" tabindex="-1">
+    <div class="modal-dialog">
+      <div class="modal-content">
+        <div class="modal-header">
+          <h5 class="modal-title">
+            <i class="bi bi-pencil me-2"></i>
+            编辑发货规则
+          </h5>
+          <button type="button" class="btn-close" data-bs-dismiss="modal"></button>
+        </div>
+        <div class="modal-body">
+          <form id="editDeliveryRuleForm">
+            <input type="hidden" id="editRuleId">
+            <div class="mb-3">
+              <label class="form-label">商品关键字 <span class="text-danger">*</span></label>
+              <input type="text" class="form-control" id="editProductKeyword" required>
+              <small class="form-text text-muted">当商品标题包含此关键字时触发自动发货</small>
+            </div>
+            <div class="mb-3">
+              <label class="form-label">匹配卡券 <span class="text-danger">*</span></label>
+              <select class="form-select" id="editSelectedCard" required>
+                <option value="">请选择卡券</option>
+              </select>
+            </div>
+            <div class="mb-3">
+              <label class="form-label">发货数量</label>
+              <input type="number" class="form-control" id="editDeliveryCount" value="1" min="1" max="10">
+              <small class="form-text text-muted">每次发货的数量</small>
+            </div>
+            <div class="mb-3">
+              <div class="form-check">
+                <input class="form-check-input" type="checkbox" id="editRuleEnabled">
+                <label class="form-check-label" for="editRuleEnabled">
+                  启用此规则
+                </label>
+              </div>
+            </div>
+            <div class="mb-3">
+              <label class="form-label">备注</label>
+              <textarea class="form-control" id="editRuleDescription" rows="2"></textarea>
+            </div>
+          </form>
+        </div>
+        <div class="modal-footer">
+          <button type="button" class="btn btn-secondary" data-bs-dismiss="modal">取消</button>
+          <button type="button" class="btn btn-primary" onclick="updateDeliveryRule()">保存修改</button>
+        </div>
+      </div>
+    </div>
+  </div>
+
+  <!-- 加载动画 -->
+  <div class="loading d-none" id="loading">
+    <div class="spinner-border text-primary loading-spinner" role="status">
+      <span class="visually-hidden">加载中...</span>
+    </div>
+  </div>
+
+  <!-- 提示消息容器 -->
+  <div class="toast-container"></div>
+
+  <!-- JS依赖 -->
+  <script src="https://cdn.jsdelivr.net/npm/bootstrap@5.3.2/dist/js/bootstrap.bundle.min.js"></script>
+  <script>
+    // 全局变量
+    const apiBase = location.origin;
+    let keywordsData = {};
+    let currentCookieId = '';
+    let editCookieId = '';
+    let authToken = localStorage.getItem('auth_token');
+    let dashboardData = {
+      accounts: [],
+      totalKeywords: 0
+    };
+
+    // 账号关键词缓存
+    let accountKeywordCache = {};
+    let cacheTimestamp = 0;
+    const CACHE_DURATION = 30000; // 30秒缓存
+
+    // 菜单切换功能
+    function showSection(sectionName) {
+      console.log('切换到页面:', sectionName); // 调试信息
+
+      // 隐藏所有内容区域
+      document.querySelectorAll('.content-section').forEach(section => {
+        section.classList.remove('active');
+      });
+
+      // 移除所有菜单项的active状态
+      document.querySelectorAll('.nav-link').forEach(link => {
+        link.classList.remove('active');
+      });
+
+      // 显示选中的内容区域
+      const targetSection = document.getElementById(sectionName + '-section');
+      if (targetSection) {
+        targetSection.classList.add('active');
+        console.log('页面已激活:', sectionName + '-section'); // 调试信息
+      } else {
+        console.error('找不到页面元素:', sectionName + '-section'); // 调试信息
+      }
+
+      // 设置对应菜单项为active（修复event.target问题）
+      const menuLinks = document.querySelectorAll('.nav-link');
+      menuLinks.forEach(link => {
+        if (link.onclick && link.onclick.toString().includes(`showSection('${sectionName}')`)) {
+          link.classList.add('active');
+        }
+      });
+
+      // 根据不同section加载对应数据
+      switch(sectionName) {
+        case 'dashboard':
+          loadDashboard();
+          break;
+        case 'accounts':
+          loadCookies();
+          break;
+        case 'items':
+          loadItems();
+          break;
+        case 'auto-reply':
+          refreshAccountList();
+          break;
+        case 'cards':
+          loadCards();
+          break;
+        case 'auto-delivery':
+          loadDeliveryRules();
+          break;
+        case 'notification-channels':
+          loadNotificationChannels();
+          break;
+        case 'message-notifications':
+          loadMessageNotifications();
+          break;
+        case 'logs':
+          // 如果没有日志数据，则加载
+          setTimeout(() => {
+            if (!window.allLogs || window.allLogs.length === 0) {
+              refreshLogs();
+            }
+          }, 100);
+          break;
+      }
+
+      // 如果切换到非日志页面，停止自动刷新
+      if (sectionName !== 'logs' && window.autoRefreshInterval) {
+        clearInterval(window.autoRefreshInterval);
+        window.autoRefreshInterval = null;
+        const button = document.querySelector('#autoRefreshText');
+        const icon = button?.previousElementSibling;
+        if (button) {
+          button.textContent = '开启自动刷新';
+          if (icon) icon.className = 'bi bi-play-circle me-1';
+        }
+      }
+    }
+
+    // 移动端侧边栏切换
+    function toggleSidebar() {
+      document.getElementById('sidebar').classList.toggle('show');
+    }
+
+    // 加载仪表盘数据
+    async function loadDashboard() {
+      try {
+        toggleLoading(true);
+
+        // 获取账号列表
+        const cookiesResponse = await fetch(`${apiBase}/cookies/details`, {
+          headers: {
+            'Authorization': `Bearer ${authToken}`
+          }
+        });
+
+        if (cookiesResponse.ok) {
+          const cookiesData = await cookiesResponse.json();
+
+          // 为每个账号获取关键词信息
+          const accountsWithKeywords = await Promise.all(
+            cookiesData.map(async (account) => {
+              try {
+                const keywordsResponse = await fetch(`${apiBase}/keywords/${account.id}`, {
+                  headers: {
+                    'Authorization': `Bearer ${authToken}`
+                  }
+                });
+
+                if (keywordsResponse.ok) {
+                  const keywordsData = await keywordsResponse.json();
+                  return {
+                    ...account,
+                    keywords: keywordsData
+                  };
+                } else {
+                  return {
+                    ...account,
+                    keywords: []
+                  };
+                }
+              } catch (error) {
+                console.error(`获取账号 ${account.id} 关键词失败:`, error);
+                return {
+                  ...account,
+                  keywords: []
+                };
+              }
+            })
+          );
+
+          dashboardData.accounts = accountsWithKeywords;
+
+          // 计算统计数据
+          let totalKeywords = 0;
+          let activeAccounts = 0;
+          let enabledAccounts = 0;
+
+          accountsWithKeywords.forEach(account => {
+            const keywordCount = account.keywords ? account.keywords.length : 0;
+            const isEnabled = account.enabled === undefined ? true : account.enabled;
+
+            if (isEnabled) {
+              enabledAccounts++;
+              totalKeywords += keywordCount;
+              if (keywordCount > 0) {
+                activeAccounts++;
+              }
+            }
+          });
+
+          dashboardData.totalKeywords = totalKeywords;
+
+          // 更新仪表盘显示
+          updateDashboardStats(accountsWithKeywords.length, totalKeywords, enabledAccounts);
+          updateDashboardAccountsList(accountsWithKeywords);
+        }
+      } catch (error) {
+        console.error('加载仪表盘数据失败:', error);
+        showToast('加载仪表盘数据失败', 'danger');
+      } finally {
+        toggleLoading(false);
+      }
+    }
+
+    // 更新仪表盘统计数据
+    function updateDashboardStats(totalAccounts, totalKeywords, enabledAccounts) {
+      document.getElementById('totalAccounts').textContent = totalAccounts;
+      document.getElementById('totalKeywords').textContent = totalKeywords;
+      document.getElementById('activeAccounts').textContent = enabledAccounts;
+    }
+
+    // 更新仪表盘账号列表
+    function updateDashboardAccountsList(accounts) {
+      const tbody = document.getElementById('dashboardAccountsList');
+      tbody.innerHTML = '';
+
+      if (accounts.length === 0) {
+        tbody.innerHTML = `
+          <tr>
+            <td colspan="4" class="text-center text-muted py-4">
+              <i class="bi bi-inbox fs-1 d-block mb-2"></i>
+              暂无账号数据
+            </td>
+          </tr>
+        `;
+        return;
+      }
+
+      accounts.forEach(account => {
+        const keywordCount = account.keywords ? account.keywords.length : 0;
+        const isEnabled = account.enabled === undefined ? true : account.enabled;
+
+        let status = '';
+        if (!isEnabled) {
+          status = '<span class="badge bg-danger">已禁用</span>';
+        } else if (keywordCount > 0) {
+          status = '<span class="badge bg-success">活跃</span>';
+        } else {
+          status = '<span class="badge bg-secondary">未配置</span>';
+        }
+
+        const row = document.createElement('tr');
+        row.className = isEnabled ? '' : 'table-secondary';
+        row.innerHTML = `
+          <td>
+            <strong class="text-primary ${!isEnabled ? 'text-muted' : ''}">${account.id}</strong>
+            ${!isEnabled ? '<i class="bi bi-pause-circle-fill text-danger ms-1" title="已禁用"></i>' : ''}
+          </td>
+          <td>
+            <span class="badge ${isEnabled ? 'bg-primary' : 'bg-secondary'}">${keywordCount} 个关键词</span>
+          </td>
+          <td>${status}</td>
+          <td>
+            <small class="text-muted">${new Date().toLocaleString()}</small>
+          </td>
+        `;
+        tbody.appendChild(row);
+      });
+    }
+
+    // 获取账号关键词数量（带缓存）
+    async function getAccountKeywordCount(accountId) {
+      const now = Date.now();
+
+      // 检查缓存
+      if (accountKeywordCache[accountId] && (now - cacheTimestamp) < CACHE_DURATION) {
+        return accountKeywordCache[accountId];
+      }
+
+      try {
+        const response = await fetch(`${apiBase}/keywords/${accountId}`, {
+          headers: {
+            'Authorization': `Bearer ${authToken}`
+          }
+        });
+
+        if (response.ok) {
+          const keywordsData = await response.json();
+          const count = keywordsData.length;
+
+          // 更新缓存
+          accountKeywordCache[accountId] = count;
+          cacheTimestamp = now;
+
+          return count;
+        } else {
+          return 0;
+        }
+      } catch (error) {
+        console.error(`获取账号 ${accountId} 关键词失败:`, error);
+        return 0;
+      }
+    }
+
+    // 清除关键词缓存
+    function clearKeywordCache() {
+      accountKeywordCache = {};
+      cacheTimestamp = 0;
+    }
+
+    // 刷新账号列表（用于自动回复页面）
+    async function refreshAccountList() {
+      try {
+        toggleLoading(true);
+
+        // 获取账号列表
+        const response = await fetch(`${apiBase}/cookies/details`, {
+          headers: {
+            'Authorization': `Bearer ${authToken}`
+          }
+        });
+
+        if (response.ok) {
+          const accounts = await response.json();
+          const select = document.getElementById('accountSelect');
+          select.innerHTML = '<option value="">🔍 请选择一个账号开始配置...</option>';
+
+          // 为每个账号获取关键词数量
+          const accountsWithKeywords = await Promise.all(
+            accounts.map(async (account) => {
+              try {
+                const keywordsResponse = await fetch(`${apiBase}/keywords/${account.id}`, {
+                  headers: {
+                    'Authorization': `Bearer ${authToken}`
+                  }
+                });
+
+                if (keywordsResponse.ok) {
+                  const keywordsData = await keywordsResponse.json();
+                  return {
+                    ...account,
+                    keywordCount: keywordsData.length
+                  };
+                } else {
+                  return {
+                    ...account,
+                    keywordCount: 0
+                  };
+                }
+              } catch (error) {
+                console.error(`获取账号 ${account.id} 关键词失败:`, error);
+                return {
+                  ...account,
+                  keywordCount: 0
+                };
+              }
+            })
+          );
+
+          // 渲染账号选项（显示所有账号，但标识禁用状态）
+          if (accountsWithKeywords.length === 0) {
+            select.innerHTML = '<option value="">❌ 暂无账号，请先添加账号</option>';
+            return;
+          }
+
+          // 分组显示：先显示启用的账号，再显示禁用的账号
+          const enabledAccounts = accountsWithKeywords.filter(account => {
+            const enabled = account.enabled === undefined ? true : account.enabled;
+            console.log(`账号 ${account.id} 过滤状态: enabled=${account.enabled}, 判断为启用=${enabled}`); // 调试信息
+            return enabled;
+          });
+          const disabledAccounts = accountsWithKeywords.filter(account => {
+            const enabled = account.enabled === undefined ? true : account.enabled;
+            return !enabled;
+          });
+
+          // 渲染启用的账号
+          enabledAccounts.forEach(account => {
+            const option = document.createElement('option');
+            option.value = account.id;
+
+            // 根据关键词数量显示不同的图标和样式
+            let icon = '📝';
+            let status = '';
+            if (account.keywordCount === 0) {
+              icon = '⚪';
+              status = ' (未配置)';
+            } else if (account.keywordCount >= 5) {
+              icon = '🟢';
+              status = ` (${account.keywordCount} 个关键词)`;
+            } else {
+              icon = '🟡';
+              status = ` (${account.keywordCount} 个关键词)`;
+            }
+
+            option.textContent = `${icon} ${account.id}${status}`;
+            select.appendChild(option);
+          });
+
+          // 如果有禁用的账号，添加分隔线和禁用账号
+          if (disabledAccounts.length > 0) {
+            // 添加分隔线
+            const separatorOption = document.createElement('option');
+            separatorOption.disabled = true;
+            separatorOption.textContent = `--- 禁用账号 (${disabledAccounts.length} 个) ---`;
+            select.appendChild(separatorOption);
+
+            // 渲染禁用的账号
+            disabledAccounts.forEach(account => {
+              const option = document.createElement('option');
+              option.value = account.id;
+
+              // 禁用账号使用特殊图标和样式
+              let icon = '🔴';
+              let status = '';
+              if (account.keywordCount === 0) {
+                status = ' (未配置) [已禁用]';
+              } else {
+                status = ` (${account.keywordCount} 个关键词) [已禁用]`;
+              }
+
+              option.textContent = `${icon} ${account.id}${status}`;
+              option.style.color = '#6b7280';
+              option.style.fontStyle = 'italic';
+              select.appendChild(option);
+            });
+          }
+
+          console.log('账号列表刷新完成，关键词统计:', accountsWithKeywords.map(a => ({id: a.id, keywords: a.keywordCount})));
+        } else {
+          showToast('获取账号列表失败', 'danger');
+        }
+      } catch (error) {
+        console.error('刷新账号列表失败:', error);
+        showToast('刷新账号列表失败', 'danger');
+      } finally {
+        toggleLoading(false);
+      }
+    }
+
+    // 加载账号关键词
+    async function loadAccountKeywords() {
+      const accountId = document.getElementById('accountSelect').value;
+      const keywordManagement = document.getElementById('keywordManagement');
+
+      if (!accountId) {
+        keywordManagement.style.display = 'none';
+        return;
+      }
+
+      try {
+        toggleLoading(true);
+        currentCookieId = accountId;
+
+        // 获取账号详情以检查状态
+        const accountResponse = await fetch(`${apiBase}/cookies/details`, {
+          headers: {
+            'Authorization': `Bearer ${authToken}`
+          }
+        });
+
+        let accountStatus = true; // 默认启用
+        if (accountResponse.ok) {
+          const accounts = await accountResponse.json();
+          const currentAccount = accounts.find(acc => acc.id === accountId);
+          accountStatus = currentAccount ? (currentAccount.enabled === undefined ? true : currentAccount.enabled) : true;
+          console.log(`加载关键词时账号 ${accountId} 状态: enabled=${currentAccount?.enabled}, accountStatus=${accountStatus}`); // 调试信息
+        }
+
+        const response = await fetch(`${apiBase}/keywords/${accountId}`, {
+          headers: {
+            'Authorization': `Bearer ${authToken}`
+          }
+        });
+
+        if (response.ok) {
+          const data = await response.json();
+          console.log('从服务器获取的关键词数据:', data); // 调试信息
+
+          // 后端返回的是 [[keyword, reply], ...] 格式，转换为前端需要的格式
+          const formattedData = data.map(([keyword, reply]) => ({
+            keyword: keyword,
+            reply: reply
+          }));
+
+          console.log('格式化后的关键词数据:', formattedData); // 调试信息
+          keywordsData[accountId] = formattedData;
+          renderKeywordsList(formattedData);
+
+          // 更新账号徽章显示
+          updateAccountBadge(accountId, accountStatus);
+
+          keywordManagement.style.display = 'block';
+        } else {
+          showToast('加载关键词失败', 'danger');
+        }
+      } catch (error) {
+        console.error('加载关键词失败:', error);
+        showToast('加载关键词失败', 'danger');
+      } finally {
+        toggleLoading(false);
+      }
+    }
+
+    // 更新账号徽章显示
+    function updateAccountBadge(accountId, isEnabled) {
+      const badge = document.getElementById('currentAccountBadge');
+      if (!badge) return;
+
+      const statusIcon = isEnabled ? '🟢' : '🔴';
+      const statusText = isEnabled ? '启用' : '禁用';
+      const statusClass = isEnabled ? 'bg-success' : 'bg-warning';
+
+      badge.innerHTML = `
+        <span class="badge ${statusClass} me-2">
+          ${statusIcon} ${accountId}
+        </span>
+        <small class="text-muted">
+          状态: ${statusText}
+          ${!isEnabled ? ' (配置的关键词不会参与自动回复)' : ''}
+        </small>
+      `;
+    }
+
+    // 显示添加关键词表单
+    function showAddKeywordForm() {
+      const form = document.getElementById('addKeywordForm');
+      form.style.display = form.style.display === 'none' ? 'block' : 'none';
+
+      if (form.style.display === 'block') {
+        document.getElementById('newKeyword').focus();
+      }
+    }
+
+    // 添加或更新关键词
+    async function addKeyword() {
+      const keyword = document.getElementById('newKeyword').value.trim();
+      const reply = document.getElementById('newReply').value.trim();
+
+      if (!keyword || !reply) {
+        showToast('请填写关键词和回复内容', 'warning');
+        return;
+      }
+
+      if (!currentCookieId) {
+        showToast('请先选择账号', 'warning');
+        return;
+      }
+
+      // 检查是否为编辑模式
+      const isEditMode = typeof window.editingIndex !== 'undefined';
+      const actionText = isEditMode ? '更新' : '添加';
+
+      try {
+        toggleLoading(true);
+
+        // 获取当前关键词列表
+        let currentKeywords = [...(keywordsData[currentCookieId] || [])];
+
+        // 如果是编辑模式，先移除原关键词
+        if (isEditMode) {
+          currentKeywords.splice(window.editingIndex, 1);
+        }
+
+        // 检查关键词是否已存在（排除编辑的原关键词）
+        const existingKeyword = currentKeywords.find(item => item.keyword === keyword);
+        if (existingKeyword && (!isEditMode || keyword !== window.originalKeyword)) {
+          showToast(`关键词 "${keyword}" 已存在，请使用其他关键词`, 'warning');
+          toggleLoading(false);
+          return;
+        }
+
+        // 转换为后端期望的格式
+        const keywordsObj = {};
+        currentKeywords.forEach(item => {
+          keywordsObj[item.keyword] = item.reply;
+        });
+
+        // 添加新关键词或更新的关键词
+        keywordsObj[keyword] = reply;
+
+        const response = await fetch(`${apiBase}/keywords/${currentCookieId}`, {
+          method: 'POST',
+          headers: {
+            'Content-Type': 'application/json',
+            'Authorization': `Bearer ${authToken}`
+          },
+          body: JSON.stringify({
+            keywords: keywordsObj
+          })
+        });
+
+        if (response.ok) {
+          showToast(`✨ 关键词 "${keyword}" ${actionText}成功！`, 'success');
+
+          // 清空输入框并重置样式
+          const keywordInput = document.getElementById('newKeyword');
+          const replyInput = document.getElementById('newReply');
+          const addBtn = document.querySelector('.add-btn');
+
+          keywordInput.value = '';
+          replyInput.value = '';
+          keywordInput.style.borderColor = '#e5e7eb';
+          replyInput.style.borderColor = '#e5e7eb';
+          addBtn.style.opacity = '0.7';
+          addBtn.style.transform = 'scale(0.95)';
+
+          // 如果是编辑模式，重置编辑状态
+          if (isEditMode) {
+            delete window.editingIndex;
+            delete window.originalKeyword;
+
+            // 恢复添加按钮
+            addBtn.innerHTML = '<i class="bi bi-plus-lg"></i>添加';
+            addBtn.style.background = 'linear-gradient(135deg, #10b981 0%, #059669 100%)';
+
+            // 移除取消按钮
+            const cancelBtn = document.getElementById('cancelEditBtn');
+            if (cancelBtn) {
+              cancelBtn.remove();
+            }
+          }
+
+          // 聚焦到关键词输入框，方便连续添加
+          setTimeout(() => {
+            keywordInput.focus();
+          }, 100);
+
+          loadAccountKeywords(); // 重新加载关键词列表
+          clearKeywordCache(); // 清除缓存
+        } else {
+          const errorText = await response.text();
+          console.error('关键词添加失败:', errorText);
+          showToast('关键词添加失败', 'danger');
+        }
+      } catch (error) {
+        console.error('添加关键词失败:', error);
+        showToast('添加关键词失败', 'danger');
+      } finally {
+        toggleLoading(false);
+      }
+    }
+
+    // 渲染现代化关键词列表
+    function renderKeywordsList(keywords) {
+      console.log('渲染关键词列表:', keywords); // 调试信息
+      const container = document.getElementById('keywordsList');
+
+      if (!container) {
+        console.error('找不到关键词列表容器元素');
+        return;
+      }
+
+      container.innerHTML = '';
+
+      if (!keywords || keywords.length === 0) {
+        console.log('关键词列表为空，显示空状态');
+        container.innerHTML = `
+          <div class="empty-state">
+            <i class="bi bi-chat-dots"></i>
+            <h3>还没有关键词</h3>
+            <p>添加第一个关键词，让您的闲鱼店铺自动回复客户消息</p>
+            <button class="quick-add-btn" onclick="focusKeywordInput()">
+              <i class="bi bi-plus-lg me-2"></i>立即添加
+            </button>
+          </div>
+        `;
+        return;
+      }
+
+      console.log(`开始渲染 ${keywords.length} 个关键词`);
+
+      keywords.forEach((item, index) => {
+        console.log(`渲染关键词 ${index + 1}:`, item); // 调试信息
+
+        const keywordItem = document.createElement('div');
+        keywordItem.className = 'keyword-item';
+        keywordItem.innerHTML = `
+          <div class="keyword-item-header">
+            <div class="keyword-tag">
+              <i class="bi bi-tag-fill"></i>
+              ${item.keyword}
+            </div>
+            <div class="keyword-actions">
+              <button class="action-btn edit-btn" onclick="editKeyword(${index})" title="编辑">
+                <i class="bi bi-pencil"></i>
+              </button>
+              <button class="action-btn delete-btn" onclick="deleteKeyword('${currentCookieId}', ${index})" title="删除">
+                <i class="bi bi-trash"></i>
+              </button>
+            </div>
+          </div>
+          <div class="keyword-content">
+            <p class="reply-text">${item.reply}</p>
+          </div>
+        `;
+        container.appendChild(keywordItem);
+      });
+
+      console.log('关键词列表渲染完成');
+    }
+
+    // 聚焦到关键词输入框
+    function focusKeywordInput() {
+      document.getElementById('newKeyword').focus();
+    }
+
+    // 编辑关键词 - 改进版本
+    function editKeyword(index) {
+      const keywords = keywordsData[currentCookieId] || [];
+      const keyword = keywords[index];
+
+      if (!keyword) {
+        showToast('关键词不存在', 'warning');
+        return;
+      }
+
+      // 将关键词信息填入输入框
+      document.getElementById('newKeyword').value = keyword.keyword;
+      document.getElementById('newReply').value = keyword.reply;
+
+      // 设置编辑模式标识
+      window.editingIndex = index;
+      window.originalKeyword = keyword.keyword;
+
+      // 更新按钮文本和样式
+      const addBtn = document.querySelector('.add-btn');
+      addBtn.innerHTML = '<i class="bi bi-check-lg"></i>更新';
+      addBtn.style.background = 'linear-gradient(135deg, #f59e0b 0%, #d97706 100%)';
+
+      // 显示取消按钮
+      showCancelEditButton();
+
+      // 聚焦到关键词输入框并选中文本
+      setTimeout(() => {
+        const keywordInput = document.getElementById('newKeyword');
+        keywordInput.focus();
+        keywordInput.select();
+      }, 100);
+
+      showToast('📝 编辑模式：修改后点击"更新"按钮保存', 'info');
+    }
+
+    // 显示取消编辑按钮
+    function showCancelEditButton() {
+      // 检查是否已存在取消按钮
+      if (document.getElementById('cancelEditBtn')) {
+        return;
+      }
+
+      const addBtn = document.querySelector('.add-btn');
+      const cancelBtn = document.createElement('button');
+      cancelBtn.id = 'cancelEditBtn';
+      cancelBtn.className = 'btn btn-outline-secondary';
+      cancelBtn.style.marginLeft = '0.5rem';
+      cancelBtn.innerHTML = '<i class="bi bi-x-lg"></i>取消';
+      cancelBtn.onclick = cancelEdit;
+
+      addBtn.parentNode.appendChild(cancelBtn);
+    }
+
+    // 取消编辑
+    function cancelEdit() {
+      // 清空输入框
+      document.getElementById('newKeyword').value = '';
+      document.getElementById('newReply').value = '';
+
+      // 重置编辑状态
+      delete window.editingIndex;
+      delete window.originalKeyword;
+
+      // 恢复添加按钮
+      const addBtn = document.querySelector('.add-btn');
+      addBtn.innerHTML = '<i class="bi bi-plus-lg"></i>添加';
+      addBtn.style.background = 'linear-gradient(135deg, #10b981 0%, #059669 100%)';
+
+      // 移除取消按钮
+      const cancelBtn = document.getElementById('cancelEditBtn');
+      if (cancelBtn) {
+        cancelBtn.remove();
+      }
+
+      showToast('已取消编辑', 'info');
+    }
+
+    // 删除关键词
+    async function deleteKeyword(cookieId, index) {
+      if (!confirm('确定要删除这个关键词吗？')) {
+        return;
+      }
+
+      try {
+        toggleLoading(true);
+
+        // 获取当前关键词列表
+        const currentKeywords = keywordsData[cookieId] || [];
+        // 移除指定索引的关键词
+        currentKeywords.splice(index, 1);
+
+        // 转换为后端期望的格式
+        const keywordsObj = {};
+        currentKeywords.forEach(item => {
+          keywordsObj[item.keyword] = item.reply;
+        });
+
+        // 更新服务器
+        const response = await fetch(`${apiBase}/keywords/${cookieId}`, {
+          method: 'POST',
+          headers: {
+            'Content-Type': 'application/json',
+            'Authorization': `Bearer ${authToken}`
+          },
+          body: JSON.stringify({
+            keywords: keywordsObj
+          })
+        });
+
+        if (response.ok) {
+          showToast('关键词删除成功', 'success');
+          keywordsData[cookieId] = currentKeywords;
+          renderKeywordsList(currentKeywords);
+          clearKeywordCache(); // 清除缓存
+        } else {
+          const errorText = await response.text();
+          console.error('关键词删除失败:', errorText);
+          showToast('关键词删除失败', 'danger');
+        }
+      } catch (error) {
+        console.error('删除关键词失败:', error);
+        showToast('删除关键词删除失败', 'danger');
+      } finally {
+        toggleLoading(false);
+      }
+    }
+
+    // 显示/隐藏加载动画
+    function toggleLoading(show) {
+      document.getElementById('loading').classList.toggle('d-none', !show);
+    }
+
+    // 显示提示消息
+    function showToast(message, type = 'success') {
+      const toastContainer = document.querySelector('.toast-container');
+      const toast = document.createElement('div');
+      toast.className = `toast align-items-center text-white bg-${type} border-0`;
+      toast.setAttribute('role', 'alert');
+      toast.setAttribute('aria-live', 'assertive');
+      toast.setAttribute('aria-atomic', 'true');
+
+      toast.innerHTML = `
+        <div class="d-flex">
+          <div class="toast-body">
+            ${message}
+          </div>
+          <button type="button" class="btn-close btn-close-white me-2 m-auto" data-bs-dismiss="toast" aria-label="Close"></button>
+        </div>
+      `;
+
+      toastContainer.appendChild(toast);
+      const bsToast = new bootstrap.Toast(toast, { delay: 3000 });
+      bsToast.show();
+
+      // 自动移除
+      toast.addEventListener('hidden.bs.toast', () => {
+        toast.remove();
+      });
+    }
+
+    // 错误处理
+    async function handleApiError(err) {
+      console.error(err);
+      showToast(err.message || '操作失败', 'danger');
+      toggleLoading(false);
+    }
+
+    // API请求包装
+    async function fetchJSON(url, opts = {}) {
+      toggleLoading(true);
+      try {
+        // 添加认证头
+        if (authToken) {
+          opts.headers = opts.headers || {};
+          opts.headers['Authorization'] = `Bearer ${authToken}`;
+        }
+
+        const res = await fetch(url, opts);
+        if (res.status === 401) {
+          // 未授权，跳转到登录页面
+          localStorage.removeItem('auth_token');
+          window.location.href = '/';
+          return;
+        }
+        if (!res.ok) {
+          let errorMessage = `HTTP ${res.status}`;
+          try {
+            const errorText = await res.text();
+            if (errorText) {
+              // 尝试解析JSON错误信息
+              try {
+                const errorJson = JSON.parse(errorText);
+                errorMessage = errorJson.detail || errorJson.message || errorText;
+              } catch {
+                errorMessage = errorText;
+              }
+            }
+          } catch {
+            errorMessage = `HTTP ${res.status} ${res.statusText}`;
+          }
+          throw new Error(errorMessage);
+        }
+        const data = await res.json();
+        toggleLoading(false);
+        return data;
+      } catch (err) {
+        handleApiError(err);
+        throw err;
+      }
+    }
+
+    // 加载Cookie列表
+    async function loadCookies() {
+      try {
+        toggleLoading(true);
+        const tbody = document.querySelector('#cookieTable tbody');
+        tbody.innerHTML = '';
+
+        const cookieDetails = await fetchJSON(apiBase + '/cookies/details');
+
+        if (cookieDetails.length === 0) {
+          tbody.innerHTML = `
+            <tr>
+              <td colspan="6" class="text-center py-4 text-muted empty-state">
+                <i class="bi bi-inbox fs-1 d-block mb-3"></i>
+                <h5>暂无账号</h5>
+                <p class="mb-0">请添加新的闲鱼账号开始使用</p>
+              </td>
+            </tr>
+          `;
+          return;
+        }
+
+        // 为每个账号获取关键词数量和默认回复设置并渲染
+        const accountsWithKeywords = await Promise.all(
+          cookieDetails.map(async (cookie) => {
+            try {
+              // 获取关键词数量
+              const keywordsResponse = await fetch(`${apiBase}/keywords/${cookie.id}`, {
+                headers: { 'Authorization': `Bearer ${authToken}` }
+              });
+
+              let keywordCount = 0;
+              if (keywordsResponse.ok) {
+                const keywordsData = await keywordsResponse.json();
+                keywordCount = keywordsData.length;
+              }
+
+              // 获取默认回复设置
+              const defaultReplyResponse = await fetch(`${apiBase}/default-replies/${cookie.id}`, {
+                headers: { 'Authorization': `Bearer ${authToken}` }
+              });
+
+              let defaultReply = { enabled: false, reply_content: '' };
+              if (defaultReplyResponse.ok) {
+                defaultReply = await defaultReplyResponse.json();
+              }
+
+              return {
+                ...cookie,
+                keywordCount: keywordCount,
+                defaultReply: defaultReply
+              };
+            } catch (error) {
+              return {
+                ...cookie,
+                keywordCount: 0,
+                defaultReply: { enabled: false, reply_content: '' }
+              };
+            }
+          })
+        );
+
+        accountsWithKeywords.forEach(cookie => {
+          // 使用数据库中的实际状态，默认为启用
+          const isEnabled = cookie.enabled === undefined ? true : cookie.enabled;
+
+          console.log(`账号 ${cookie.id} 状态: enabled=${cookie.enabled}, isEnabled=${isEnabled}`); // 调试信息
+
+          const tr = document.createElement('tr');
+          tr.className = `account-row ${isEnabled ? 'enabled' : 'disabled'}`;
+          // 默认回复状态标签
+          const defaultReplyBadge = cookie.defaultReply.enabled ?
+            '<span class="badge bg-success">启用</span>' :
+            '<span class="badge bg-secondary">禁用</span>';
+
+          tr.innerHTML = `
+            <td class="align-middle">
+              <div class="cookie-id">
+                <strong class="text-primary">${cookie.id}</strong>
+              </div>
+            </td>
+            <td class="align-middle">
+              <div class="cookie-value" title="点击复制Cookie" style="font-family: monospace; font-size: 0.875rem; max-width: 200px; overflow: hidden; text-overflow: ellipsis; white-space: nowrap;">
+                ${cookie.value || '未设置'}
+              </div>
+            </td>
+            <td class="align-middle">
+              <span class="badge ${cookie.keywordCount > 0 ? 'bg-success' : 'bg-secondary'}">
+                ${cookie.keywordCount} 个关键词
+              </span>
+            </td>
+            <td class="align-middle">
+              <div class="d-flex align-items-center gap-2">
+                <label class="status-toggle" title="${isEnabled ? '点击禁用' : '点击启用'}">
+                  <input type="checkbox" ${isEnabled ? 'checked' : ''} onchange="toggleAccountStatus('${cookie.id}', this.checked)">
+                  <span class="status-slider"></span>
+                </label>
+                <span class="status-badge ${isEnabled ? 'enabled' : 'disabled'}">
+                  <i class="bi bi-${isEnabled ? 'check-circle-fill' : 'x-circle-fill'}"></i>
+                  ${isEnabled ? '启用' : '禁用'}
+                </span>
+              </div>
+            </td>
+            <td class="align-middle">
+              ${defaultReplyBadge}
+            </td>
+            <td class="align-middle">
+              <div class="btn-group" role="group">
+                <button class="btn btn-sm btn-outline-primary" onclick="editCookieInline('${cookie.id}', '${cookie.value}')" title="修改Cookie" ${!isEnabled ? 'disabled' : ''}>
+                  <i class="bi bi-pencil"></i>
+                </button>
+                <button class="btn btn-sm btn-outline-success" onclick="goToAutoReply('${cookie.id}')" title="${isEnabled ? '设置自动回复' : '配置关键词 (账号已禁用)'}">
+                  <i class="bi bi-arrow-right-circle"></i>
+                </button>
+                <button class="btn btn-sm btn-outline-info" onclick="copyCookie('${cookie.id}', '${cookie.value}')" title="复制Cookie">
+                  <i class="bi bi-clipboard"></i>
+                </button>
+                <button class="btn btn-sm btn-outline-danger" onclick="delCookie('${cookie.id}')" title="删除账号">
+                  <i class="bi bi-trash"></i>
+                </button>
+              </div>
+            </td>
+          `;
+          tbody.appendChild(tr);
+        });
+
+        // 为Cookie值添加点击复制功能
+        document.querySelectorAll('.cookie-value').forEach(element => {
+          element.style.cursor = 'pointer';
+          element.addEventListener('click', function() {
+            const cookieValue = this.textContent;
+            if (cookieValue && cookieValue !== '未设置') {
+              navigator.clipboard.writeText(cookieValue).then(() => {
+                showToast('Cookie已复制到剪贴板', 'success');
+              }).catch(() => {
+                showToast('复制失败，请手动复制', 'error');
+              });
+            }
+          });
+        });
+
+      } catch (err) {
+        // 错误已在fetchJSON中处理
+      } finally {
+        toggleLoading(false);
+      }
+    }
+
+    // 复制Cookie
+    function copyCookie(id, value) {
+      if (!value || value === '未设置') {
+        showToast('该账号暂无Cookie值', 'warning');
+        return;
+      }
+
+      navigator.clipboard.writeText(value).then(() => {
+        showToast(`账号 "${id}" 的Cookie已复制到剪贴板`, 'success');
+      }).catch(() => {
+        // 降级方案：创建临时文本框
+        const textArea = document.createElement('textarea');
+        textArea.value = value;
+        document.body.appendChild(textArea);
+        textArea.select();
+        try {
+          document.execCommand('copy');
+          showToast(`账号 "${id}" 的Cookie已复制到剪贴板`, 'success');
+        } catch (err) {
+          showToast('复制失败，请手动复制', 'error');
+        }
+        document.body.removeChild(textArea);
+      });
+    }
+
+    // 删除Cookie
+    async function delCookie(id) {
+      if (!confirm(`确定要删除账号 "${id}" 吗？此操作不可恢复。`)) return;
+
+      try {
+        await fetchJSON(apiBase + `/cookies/${id}`, { method: 'DELETE' });
+        showToast(`账号 "${id}" 已删除`, 'success');
+        loadCookies();
+      } catch (err) {
+        // 错误已在fetchJSON中处理
+      }
+    }
+
+    // 内联编辑Cookie
+    function editCookieInline(id, currentValue) {
+      const row = event.target.closest('tr');
+      const cookieValueCell = row.querySelector('.cookie-value');
+      const originalContent = cookieValueCell.innerHTML;
+
+      // 存储原始数据到全局变量，避免HTML注入问题
+      window.editingCookieData = {
+        id: id,
+        originalContent: originalContent,
+        originalValue: currentValue || ''
+      };
+
+      // 创建编辑界面容器
+      const editContainer = document.createElement('div');
+      editContainer.className = 'd-flex gap-2';
+
+      // 创建输入框
+      const input = document.createElement('input');
+      input.type = 'text';
+      input.className = 'form-control form-control-sm';
+      input.id = `edit-${id}`;
+      input.value = currentValue || '';
+      input.placeholder = '输入新的Cookie值';
+
+      // 创建保存按钮
+      const saveBtn = document.createElement('button');
+      saveBtn.className = 'btn btn-sm btn-success';
+      saveBtn.title = '保存';
+      saveBtn.innerHTML = '<i class="bi bi-check"></i>';
+      saveBtn.onclick = () => saveCookieInline(id);
+
+      // 创建取消按钮
+      const cancelBtn = document.createElement('button');
+      cancelBtn.className = 'btn btn-sm btn-secondary';
+      cancelBtn.title = '取消';
+      cancelBtn.innerHTML = '<i class="bi bi-x"></i>';
+      cancelBtn.onclick = () => cancelCookieEdit(id);
+
+      // 组装编辑界面
+      editContainer.appendChild(input);
+      editContainer.appendChild(saveBtn);
+      editContainer.appendChild(cancelBtn);
+
+      // 替换原内容
+      cookieValueCell.innerHTML = '';
+      cookieValueCell.appendChild(editContainer);
+
+      // 聚焦输入框
+      input.focus();
+      input.select();
+
+      // 添加键盘事件监听
+      input.addEventListener('keydown', function(e) {
+        if (e.key === 'Enter') {
+          e.preventDefault();
+          saveCookieInline(id);
+        } else if (e.key === 'Escape') {
+          e.preventDefault();
+          cancelCookieEdit(id);
+        }
+      });
+
+      // 禁用该行的其他按钮
+      const actionButtons = row.querySelectorAll('.btn-group button');
+      actionButtons.forEach(btn => btn.disabled = true);
+    }
+
+    // 保存内联编辑的Cookie
+    async function saveCookieInline(id) {
+      const input = document.getElementById(`edit-${id}`);
+      const newValue = input.value.trim();
+
+      if (!newValue) {
+        showToast('Cookie值不能为空', 'warning');
+        return;
+      }
+
+      try {
+        toggleLoading(true);
+
+        await fetchJSON(apiBase + `/cookies/${id}`, {
+          method: 'PUT',
+          headers: { 'Content-Type': 'application/json' },
+          body: JSON.stringify({
+            id: id,
+            value: newValue
+          })
+        });
+
+        showToast(`账号 "${id}" Cookie已更新`, 'success');
+        loadCookies(); // 重新加载列表
+
+      } catch (err) {
+        console.error('Cookie更新失败:', err);
+        showToast(`Cookie更新失败: ${err.message || '未知错误'}`, 'danger');
+        // 恢复原内容
+        cancelCookieEdit(id);
+      } finally {
+        toggleLoading(false);
+      }
+    }
+
+    // 取消Cookie编辑
+    function cancelCookieEdit(id) {
+      if (!window.editingCookieData || window.editingCookieData.id !== id) {
+        console.error('编辑数据不存在');
+        return;
+      }
+
+      const row = document.querySelector(`#edit-${id}`).closest('tr');
+      const cookieValueCell = row.querySelector('.cookie-value');
+
+      // 恢复原内容
+      cookieValueCell.innerHTML = window.editingCookieData.originalContent;
+
+      // 恢复按钮状态
+      const actionButtons = row.querySelectorAll('.btn-group button');
+      actionButtons.forEach(btn => btn.disabled = false);
+
+      // 清理全局数据
+      delete window.editingCookieData;
+    }
+
+
+
+    // 切换账号启用/禁用状态
+    async function toggleAccountStatus(accountId, enabled) {
+      try {
+        toggleLoading(true);
+
+        // 这里需要调用后端API来更新账号状态
+        // 由于当前后端可能没有enabled字段，我们先在前端模拟
+        // 实际项目中需要后端支持
+
+        const response = await fetch(`${apiBase}/cookies/${accountId}/status`, {
+          method: 'PUT',
+          headers: {
+            'Content-Type': 'application/json',
+            'Authorization': `Bearer ${authToken}`
+          },
+          body: JSON.stringify({ enabled: enabled })
+        });
+
+        if (response.ok) {
+          showToast(`账号 "${accountId}" 已${enabled ? '启用' : '禁用'}`, 'success');
+
+          // 清除相关缓存，确保数据一致性
+          clearKeywordCache();
+
+          // 更新界面显示
+          updateAccountRowStatus(accountId, enabled);
+
+          // 刷新自动回复页面的账号列表
+          refreshAccountList();
+
+          // 如果禁用的账号在自动回复页面被选中，更新显示
+          const accountSelect = document.getElementById('accountSelect');
+          if (accountSelect && accountSelect.value === accountId) {
+            if (!enabled) {
+              // 更新徽章显示禁用状态
+              updateAccountBadge(accountId, false);
+              showToast('账号已禁用，配置的关键词不会参与自动回复', 'warning');
+            } else {
+              // 更新徽章显示启用状态
+              updateAccountBadge(accountId, true);
+              showToast('账号已启用，配置的关键词将参与自动回复', 'success');
+            }
+          }
+
+        } else {
+          // 如果后端不支持，先在前端模拟
+          console.warn('后端暂不支持账号状态切换，使用前端模拟');
+          showToast(`账号 "${accountId}" 已${enabled ? '启用' : '禁用'} (前端模拟)`, enabled ? 'success' : 'warning');
+          updateAccountRowStatus(accountId, enabled);
+        }
+
+      } catch (error) {
+        console.error('切换账号状态失败:', error);
+
+        // 后端不支持时的降级处理
+        showToast(`账号 "${accountId}" 已${enabled ? '启用' : '禁用'} (本地模拟)`, enabled ? 'success' : 'warning');
+        updateAccountRowStatus(accountId, enabled);
+
+        // 恢复切换按钮状态
+        const toggle = document.querySelector(`input[onchange*="${accountId}"]`);
+        if (toggle) {
+          toggle.checked = enabled;
+        }
+      } finally {
+        toggleLoading(false);
+      }
+    }
+
+    // 更新账号行的状态显示
+    function updateAccountRowStatus(accountId, enabled) {
+      const toggle = document.querySelector(`input[onchange*="${accountId}"]`);
+      if (!toggle) return;
+
+      const row = toggle.closest('tr');
+      const statusBadge = row.querySelector('.status-badge');
+      const actionButtons = row.querySelectorAll('.btn-group .btn:not(.btn-outline-info):not(.btn-outline-danger)');
+
+      // 更新行样式
+      row.className = `account-row ${enabled ? 'enabled' : 'disabled'}`;
+
+      // 更新状态徽章
+      statusBadge.className = `status-badge ${enabled ? 'enabled' : 'disabled'}`;
+      statusBadge.innerHTML = `
+        <i class="bi bi-${enabled ? 'check-circle-fill' : 'x-circle-fill'}"></i>
+        ${enabled ? '启用' : '禁用'}
+      `;
+
+      // 更新按钮状态（只禁用编辑Cookie按钮，其他按钮保持可用）
+      actionButtons.forEach(btn => {
+        if (btn.onclick && btn.onclick.toString().includes('editCookieInline')) {
+          btn.disabled = !enabled;
+        }
+        // 设置自动回复按钮始终可用，但更新提示文本
+        if (btn.onclick && btn.onclick.toString().includes('goToAutoReply')) {
+          btn.title = enabled ? '设置自动回复' : '配置关键词 (账号已禁用)';
+        }
+      });
+
+      // 更新切换按钮的提示
+      const label = toggle.closest('.status-toggle');
+      label.title = enabled ? '点击禁用' : '点击启用';
+    }
+
+    // 跳转到自动回复页面并选择指定账号
+    function goToAutoReply(accountId) {
+      // 切换到自动回复页面
+      showSection('auto-reply');
+
+      // 设置账号选择器的值
+      setTimeout(() => {
+        const accountSelect = document.getElementById('accountSelect');
+        if (accountSelect) {
+          accountSelect.value = accountId;
+          // 触发change事件来加载关键词
+          loadAccountKeywords();
+        }
+      }, 100);
+
+      showToast(`已切换到自动回复页面，账号 "${accountId}" 已选中`, 'info');
+    }
+
+
+
+
+
+    // 登出功能
+    async function logout() {
+      try {
+        if (authToken) {
+          await fetch('/logout', {
+            method: 'POST',
+            headers: {
+              'Authorization': `Bearer ${authToken}`
+            }
+          });
+        }
+        localStorage.removeItem('auth_token');
+        window.location.href = '/';
+      } catch (err) {
+        console.error('登出失败:', err);
+        localStorage.removeItem('auth_token');
+        window.location.href = '/';
+      }
+    }
+
+    // 检查认证状态
+    async function checkAuth() {
+      if (!authToken) {
+        window.location.href = '/';
+        return false;
+      }
+
+      try {
+        const response = await fetch('/verify', {
+          headers: {
+            'Authorization': `Bearer ${authToken}`
+          }
+        });
+        const result = await response.json();
+
+        if (!result.authenticated) {
+          localStorage.removeItem('auth_token');
+          window.location.href = '/';
+          return false;
+        }
+        return true;
+      } catch (err) {
+        localStorage.removeItem('auth_token');
+        window.location.href = '/';
+        return false;
+      }
+    }
+
+    // 初始化事件监听
+    document.addEventListener('DOMContentLoaded', async () => {
+      // 首先检查认证状态
+      const isAuthenticated = await checkAuth();
+      if (!isAuthenticated) return;
+      // 添加Cookie表单提交
+      document.getElementById('addForm').addEventListener('submit', async (e) => {
+        e.preventDefault();
+        const id = document.getElementById('cookieId').value.trim();
+        const value = document.getElementById('cookieValue').value.trim();
+
+        if (!id || !value) return;
+
+        try {
+          await fetchJSON(apiBase + '/cookies', {
+            method: 'POST',
+            headers: { 'Content-Type': 'application/json' },
+            body: JSON.stringify({ id, value })
+          });
+
+          document.getElementById('cookieId').value = '';
+          document.getElementById('cookieValue').value = '';
+          showToast(`账号 "${id}" 添加成功`);
+          loadCookies();
+        } catch (err) {
+          // 错误已在fetchJSON中处理
+        }
+      });
+
+      // 增强的键盘快捷键和用户体验
+      document.getElementById('newKeyword')?.addEventListener('keypress', function(e) {
+        if (e.key === 'Enter') {
+          e.preventDefault();
+          document.getElementById('newReply').focus();
+        }
+      });
+
+      document.getElementById('newReply')?.addEventListener('keypress', function(e) {
+        if (e.key === 'Enter') {
+          e.preventDefault();
+          addKeyword();
+        }
+      });
+
+      // ESC键取消编辑
+      document.addEventListener('keydown', function(e) {
+        if (e.key === 'Escape' && typeof window.editingIndex !== 'undefined') {
+          e.preventDefault();
+          cancelEdit();
+        }
+      });
+
+      // 输入框实时验证和提示
+      document.getElementById('newKeyword')?.addEventListener('input', function(e) {
+        const value = e.target.value.trim();
+        const addBtn = document.querySelector('.add-btn');
+        const replyInput = document.getElementById('newReply');
+
+        if (value.length > 0) {
+          e.target.style.borderColor = '#10b981';
+          if (replyInput.value.trim().length > 0) {
+            addBtn.style.opacity = '1';
+            addBtn.style.transform = 'scale(1)';
+          }
+        } else {
+          e.target.style.borderColor = '#e5e7eb';
+          addBtn.style.opacity = '0.7';
+          addBtn.style.transform = 'scale(0.95)';
+        }
+      });
+
+      document.getElementById('newReply')?.addEventListener('input', function(e) {
+        const value = e.target.value.trim();
+        const addBtn = document.querySelector('.add-btn');
+        const keywordInput = document.getElementById('newKeyword');
+
+        if (value.length > 0) {
+          e.target.style.borderColor = '#10b981';
+          if (keywordInput.value.trim().length > 0) {
+            addBtn.style.opacity = '1';
+            addBtn.style.transform = 'scale(1)';
+          }
+        } else {
+          e.target.style.borderColor = '#e5e7eb';
+          addBtn.style.opacity = '0.7';
+          addBtn.style.transform = 'scale(0.95)';
+        }
+      });
+
+      // 初始加载仪表盘
+      loadDashboard();
+
+      // 点击侧边栏外部关闭移动端菜单
+      document.addEventListener('click', function(e) {
+        const sidebar = document.getElementById('sidebar');
+        const toggle = document.querySelector('.mobile-toggle');
+
+        if (window.innerWidth <= 768 &&
+            !sidebar.contains(e.target) &&
+            !toggle.contains(e.target) &&
+            sidebar.classList.contains('show')) {
+          sidebar.classList.remove('show');
+        }
+      });
+    });
+
+    // ==================== 默认回复管理功能 ====================
+
+    // 打开默认回复管理器
+    async function openDefaultReplyManager() {
+      try {
+        await loadDefaultReplies();
+        const modal = new bootstrap.Modal(document.getElementById('defaultReplyModal'));
+        modal.show();
+      } catch (error) {
+        console.error('打开默认回复管理器失败:', error);
+        showToast('打开默认回复管理器失败', 'danger');
+      }
+    }
+
+    // 加载默认回复列表
+    async function loadDefaultReplies() {
+      try {
+        // 获取所有账号
+        const accountsResponse = await fetch(`${apiBase}/cookies`, {
+          headers: {
+            'Authorization': `Bearer ${authToken}`
+          }
+        });
+
+        if (!accountsResponse.ok) {
+          throw new Error('获取账号列表失败');
+        }
+
+        const accounts = await accountsResponse.json();
+
+        // 获取所有默认回复设置
+        const repliesResponse = await fetch(`${apiBase}/default-replies`, {
+          headers: {
+            'Authorization': `Bearer ${authToken}`
+          }
+        });
+
+        let defaultReplies = {};
+        if (repliesResponse.ok) {
+          defaultReplies = await repliesResponse.json();
+        }
+
+        renderDefaultRepliesList(accounts, defaultReplies);
+      } catch (error) {
+        console.error('加载默认回复列表失败:', error);
+        showToast('加载默认回复列表失败', 'danger');
+      }
+    }
+
+    // 渲染默认回复列表
+    function renderDefaultRepliesList(accounts, defaultReplies) {
+      const tbody = document.getElementById('defaultReplyTableBody');
+      tbody.innerHTML = '';
+
+      if (accounts.length === 0) {
+        tbody.innerHTML = `
+          <tr>
+            <td colspan="4" class="text-center py-4 text-muted">
+              <i class="bi bi-chat-text fs-1 d-block mb-3"></i>
+              <h5>暂无账号数据</h5>
+              <p class="mb-0">请先添加账号</p>
+            </td>
+          </tr>
+        `;
+        return;
+      }
+
+      accounts.forEach(accountId => {
+        const replySettings = defaultReplies[accountId] || { enabled: false, reply_content: '' };
+        const tr = document.createElement('tr');
+
+        // 状态标签
+        const statusBadge = replySettings.enabled ?
+          '<span class="badge bg-success">启用</span>' :
+          '<span class="badge bg-secondary">禁用</span>';
+
+        // 回复内容预览
+        let contentPreview = replySettings.reply_content || '未设置';
+        if (contentPreview.length > 50) {
+          contentPreview = contentPreview.substring(0, 50) + '...';
+        }
+
+        tr.innerHTML = `
+          <td>
+            <strong class="text-primary">${accountId}</strong>
+          </td>
+          <td>${statusBadge}</td>
+          <td>
+            <div class="text-truncate" style="max-width: 300px;" title="${replySettings.reply_content || ''}">
+              ${contentPreview}
+            </div>
+          </td>
+          <td>
+            <div class="btn-group" role="group">
+              <button class="btn btn-sm btn-outline-primary" onclick="editDefaultReply('${accountId}')" title="编辑">
+                <i class="bi bi-pencil"></i>
+              </button>
+              <button class="btn btn-sm btn-outline-info" onclick="testDefaultReply('${accountId}')" title="测试">
+                <i class="bi bi-play"></i>
+              </button>
+            </div>
+          </td>
+        `;
+
+        tbody.appendChild(tr);
+      });
+    }
+
+    // 编辑默认回复
+    async function editDefaultReply(accountId) {
+      try {
+        // 获取当前设置
+        const response = await fetch(`${apiBase}/default-replies/${accountId}`, {
+          headers: {
+            'Authorization': `Bearer ${authToken}`
+          }
+        });
+
+        let settings = { enabled: false, reply_content: '' };
+        if (response.ok) {
+          settings = await response.json();
+        }
+
+        // 填充编辑表单
+        document.getElementById('editAccountId').value = accountId;
+        document.getElementById('editAccountIdDisplay').value = accountId;
+        document.getElementById('editDefaultReplyEnabled').checked = settings.enabled;
+        document.getElementById('editReplyContent').value = settings.reply_content || '';
+
+        // 根据启用状态显示/隐藏内容输入框
+        toggleReplyContentVisibility();
+
+        // 显示编辑模态框
+        const modal = new bootstrap.Modal(document.getElementById('editDefaultReplyModal'));
+        modal.show();
+      } catch (error) {
+        console.error('获取默认回复设置失败:', error);
+        showToast('获取默认回复设置失败', 'danger');
+      }
+    }
+
+    // 切换回复内容输入框的显示/隐藏
+    function toggleReplyContentVisibility() {
+      const enabled = document.getElementById('editDefaultReplyEnabled').checked;
+      const contentGroup = document.getElementById('editReplyContentGroup');
+      contentGroup.style.display = enabled ? 'block' : 'none';
+    }
+
+    // 保存默认回复设置
+    async function saveDefaultReply() {
+      try {
+        const accountId = document.getElementById('editAccountId').value;
+        const enabled = document.getElementById('editDefaultReplyEnabled').checked;
+        const replyContent = document.getElementById('editReplyContent').value;
+
+        if (enabled && !replyContent.trim()) {
+          showToast('启用默认回复时必须设置回复内容', 'warning');
+          return;
+        }
+
+        const data = {
+          enabled: enabled,
+          reply_content: enabled ? replyContent : null
+        };
+
+        const response = await fetch(`${apiBase}/default-replies/${accountId}`, {
+          method: 'PUT',
+          headers: {
+            'Authorization': `Bearer ${authToken}`,
+            'Content-Type': 'application/json'
+          },
+          body: JSON.stringify(data)
+        });
+
+        if (response.ok) {
+          showToast('默认回复设置保存成功', 'success');
+          bootstrap.Modal.getInstance(document.getElementById('editDefaultReplyModal')).hide();
+          loadDefaultReplies(); // 刷新列表
+          loadCookies(); // 刷新账号列表以更新默认回复状态显示
+        } else {
+          const error = await response.text();
+          showToast(`保存失败: ${error}`, 'danger');
+        }
+      } catch (error) {
+        console.error('保存默认回复设置失败:', error);
+        showToast('保存默认回复设置失败', 'danger');
+      }
+    }
+
+    // 测试默认回复（占位函数）
+    function testDefaultReply(accountId) {
+      showToast('测试功能开发中...', 'info');
+    }
+
+
+
+    // 监听默认回复启用状态变化
+    document.addEventListener('DOMContentLoaded', function() {
+      const enabledCheckbox = document.getElementById('editDefaultReplyEnabled');
+      if (enabledCheckbox) {
+        enabledCheckbox.addEventListener('change', toggleReplyContentVisibility);
+      }
+    });
+
+    // ==================== 通知渠道管理功能 ====================
+
+    // 加载通知渠道列表
+    async function loadNotificationChannels() {
+      try {
+        const response = await fetch(`${apiBase}/notification-channels`, {
+          headers: {
+            'Authorization': `Bearer ${authToken}`
+          }
+        });
+
+        if (!response.ok) {
+          throw new Error('获取通知渠道失败');
+        }
+
+        const channels = await response.json();
+        renderNotificationChannels(channels);
+      } catch (error) {
+        console.error('加载通知渠道失败:', error);
+        showToast('加载通知渠道失败', 'danger');
+      }
+    }
+
+    // 渲染通知渠道列表
+    function renderNotificationChannels(channels) {
+      const tbody = document.getElementById('channelsTableBody');
+      tbody.innerHTML = '';
+
+      if (channels.length === 0) {
+        tbody.innerHTML = `
+          <tr>
+            <td colspan="6" class="text-center py-4 text-muted">
+              <i class="bi bi-bell fs-1 d-block mb-3"></i>
+              <h5>暂无通知渠道</h5>
+              <p class="mb-0">请添加QQ通知渠道</p>
+            </td>
+          </tr>
+        `;
+        return;
+      }
+
+      channels.forEach(channel => {
+        const tr = document.createElement('tr');
+
+        const statusBadge = channel.enabled ?
+          '<span class="badge bg-success">启用</span>' :
+          '<span class="badge bg-secondary">禁用</span>';
+
+        tr.innerHTML = `
+          <td><strong class="text-primary">${channel.id}</strong></td>
+          <td>${channel.name}</td>
+          <td><span class="badge bg-info">QQ</span></td>
+          <td><code>${channel.config}</code></td>
+          <td>${statusBadge}</td>
+          <td>
+            <div class="btn-group" role="group">
+              <button class="btn btn-sm btn-outline-primary" onclick="editNotificationChannel(${channel.id})" title="编辑">
+                <i class="bi bi-pencil"></i>
+              </button>
+              <button class="btn btn-sm btn-outline-danger" onclick="deleteNotificationChannel(${channel.id})" title="删除">
+                <i class="bi bi-trash"></i>
+              </button>
+            </div>
+          </td>
+        `;
+
+        tbody.appendChild(tr);
+      });
+    }
+
+    // 添加通知渠道表单提交
+    document.addEventListener('DOMContentLoaded', function() {
+      const addChannelForm = document.getElementById('addChannelForm');
+      if (addChannelForm) {
+        addChannelForm.addEventListener('submit', async function(e) {
+          e.preventDefault();
+
+          const name = document.getElementById('channelName').value;
+          const qq = document.getElementById('channelQQ').value;
+
+          try {
+            const response = await fetch(`${apiBase}/notification-channels`, {
+              method: 'POST',
+              headers: {
+                'Authorization': `Bearer ${authToken}`,
+                'Content-Type': 'application/json'
+              },
+              body: JSON.stringify({
+                name: name,
+                type: 'qq',
+                config: qq
+              })
+            });
+
+            if (response.ok) {
+              showToast('通知渠道添加成功', 'success');
+              addChannelForm.reset();
+              loadNotificationChannels();
+            } else {
+              const error = await response.text();
+              showToast(`添加失败: ${error}`, 'danger');
+            }
+          } catch (error) {
+            console.error('添加通知渠道失败:', error);
+            showToast('添加通知渠道失败', 'danger');
+          }
+        });
+      }
+    });
+
+    // 删除通知渠道
+    async function deleteNotificationChannel(channelId) {
+      if (!confirm('确定要删除这个通知渠道吗？')) {
+        return;
+      }
+
+      try {
+        const response = await fetch(`${apiBase}/notification-channels/${channelId}`, {
+          method: 'DELETE',
+          headers: {
+            'Authorization': `Bearer ${authToken}`
+          }
+        });
+
+        if (response.ok) {
+          showToast('通知渠道删除成功', 'success');
+          loadNotificationChannels();
+        } else {
+          const error = await response.text();
+          showToast(`删除失败: ${error}`, 'danger');
+        }
+      } catch (error) {
+        console.error('删除通知渠道失败:', error);
+        showToast('删除通知渠道失败', 'danger');
+      }
+    }
+
+    // 编辑通知渠道
+    async function editNotificationChannel(channelId) {
+      try {
+        // 获取渠道详情
+        const response = await fetch(`${apiBase}/notification-channels`, {
+          headers: {
+            'Authorization': `Bearer ${authToken}`
+          }
+        });
+
+        if (!response.ok) {
+          throw new Error('获取通知渠道失败');
+        }
+
+        const channels = await response.json();
+        const channel = channels.find(c => c.id === channelId);
+
+        if (!channel) {
+          showToast('通知渠道不存在', 'danger');
+          return;
+        }
+
+        // 填充编辑表单
+        document.getElementById('editChannelId').value = channel.id;
+        document.getElementById('editChannelName').value = channel.name;
+        document.getElementById('editChannelQQ').value = channel.config;
+        document.getElementById('editChannelEnabled').checked = channel.enabled;
+
+        // 显示编辑模态框
+        const modal = new bootstrap.Modal(document.getElementById('editChannelModal'));
+        modal.show();
+      } catch (error) {
+        console.error('编辑通知渠道失败:', error);
+        showToast('编辑通知渠道失败', 'danger');
+      }
+    }
+
+    // 更新通知渠道
+    async function updateNotificationChannel() {
+      const channelId = document.getElementById('editChannelId').value;
+      const name = document.getElementById('editChannelName').value;
+      const qq = document.getElementById('editChannelQQ').value;
+      const enabled = document.getElementById('editChannelEnabled').checked;
+
+      if (!name || !qq) {
+        showToast('请填写完整信息', 'warning');
+        return;
+      }
+
+      try {
+        const response = await fetch(`${apiBase}/notification-channels/${channelId}`, {
+          method: 'PUT',
+          headers: {
+            'Authorization': `Bearer ${authToken}`,
+            'Content-Type': 'application/json'
+          },
+          body: JSON.stringify({
+            name: name,
+            config: qq,
+            enabled: enabled
+          })
+        });
+
+        if (response.ok) {
+          showToast('通知渠道更新成功', 'success');
+          const modal = bootstrap.Modal.getInstance(document.getElementById('editChannelModal'));
+          modal.hide();
+          loadNotificationChannels();
+        } else {
+          const error = await response.text();
+          showToast(`更新失败: ${error}`, 'danger');
+        }
+      } catch (error) {
+        console.error('更新通知渠道失败:', error);
+        showToast('更新通知渠道失败', 'danger');
+      }
+    }
+
+    // ==================== 消息通知配置功能 ====================
+
+    // 加载消息通知配置
+    async function loadMessageNotifications() {
+      try {
+        // 获取所有账号
+        const accountsResponse = await fetch(`${apiBase}/cookies`, {
+          headers: {
+            'Authorization': `Bearer ${authToken}`
+          }
+        });
+
+        if (!accountsResponse.ok) {
+          throw new Error('获取账号列表失败');
+        }
+
+        const accounts = await accountsResponse.json();
+
+        // 获取所有通知配置
+        const notificationsResponse = await fetch(`${apiBase}/message-notifications`, {
+          headers: {
+            'Authorization': `Bearer ${authToken}`
+          }
+        });
+
+        let notifications = {};
+        if (notificationsResponse.ok) {
+          notifications = await notificationsResponse.json();
+        }
+
+        renderMessageNotifications(accounts, notifications);
+      } catch (error) {
+        console.error('加载消息通知配置失败:', error);
+        showToast('加载消息通知配置失败', 'danger');
+      }
+    }
+
+    // 渲染消息通知配置
+    function renderMessageNotifications(accounts, notifications) {
+      const tbody = document.getElementById('notificationsTableBody');
+      tbody.innerHTML = '';
+
+      if (accounts.length === 0) {
+        tbody.innerHTML = `
+          <tr>
+            <td colspan="4" class="text-center py-4 text-muted">
+              <i class="bi bi-chat-dots fs-1 d-block mb-3"></i>
+              <h5>暂无账号数据</h5>
+              <p class="mb-0">请先添加账号</p>
+            </td>
+          </tr>
+        `;
+        return;
+      }
+
+      accounts.forEach(accountId => {
+        const accountNotifications = notifications[accountId] || [];
+        const tr = document.createElement('tr');
+
+        let channelsList = '';
+        if (accountNotifications.length > 0) {
+          channelsList = accountNotifications.map(n =>
+            `<span class="badge bg-${n.enabled ? 'success' : 'secondary'} me-1">${n.channel_name}</span>`
+          ).join('');
+        } else {
+          channelsList = '<span class="text-muted">未配置</span>';
+        }
+
+        const status = accountNotifications.some(n => n.enabled) ?
+          '<span class="badge bg-success">启用</span>' :
+          '<span class="badge bg-secondary">禁用</span>';
+
+        tr.innerHTML = `
+          <td><strong class="text-primary">${accountId}</strong></td>
+          <td>${channelsList}</td>
+          <td>${status}</td>
+          <td>
+            <div class="btn-group" role="group">
+              <button class="btn btn-sm btn-outline-primary" onclick="configAccountNotification('${accountId}')" title="配置">
+                <i class="bi bi-gear"></i> 配置
+              </button>
+              ${accountNotifications.length > 0 ? `
+              <button class="btn btn-sm btn-outline-danger" onclick="deleteAccountNotification('${accountId}')" title="删除配置">
+                <i class="bi bi-trash"></i>
+              </button>
+              ` : ''}
+            </div>
+          </td>
+        `;
+
+        tbody.appendChild(tr);
+      });
+    }
+
+    // 配置账号通知
+    async function configAccountNotification(accountId) {
+      try {
+        // 获取所有通知渠道
+        const channelsResponse = await fetch(`${apiBase}/notification-channels`, {
+          headers: {
+            'Authorization': `Bearer ${authToken}`
+          }
+        });
+
+        if (!channelsResponse.ok) {
+          throw new Error('获取通知渠道失败');
+        }
+
+        const channels = await channelsResponse.json();
+
+        if (channels.length === 0) {
+          showToast('请先添加通知渠道', 'warning');
+          return;
+        }
+
+        // 获取当前账号的通知配置
+        const notificationResponse = await fetch(`${apiBase}/message-notifications/${accountId}`, {
+          headers: {
+            'Authorization': `Bearer ${authToken}`
+          }
+        });
+
+        let currentNotifications = [];
+        if (notificationResponse.ok) {
+          currentNotifications = await notificationResponse.json();
+        }
+
+        // 填充表单
+        document.getElementById('configAccountId').value = accountId;
+        document.getElementById('displayAccountId').value = accountId;
+
+        // 填充通知渠道选项
+        const channelSelect = document.getElementById('notificationChannel');
+        channelSelect.innerHTML = '<option value="">请选择通知渠道</option>';
+
+        // 获取当前配置的第一个通知渠道（如果存在）
+        const currentNotification = currentNotifications.length > 0 ? currentNotifications[0] : null;
+
+        channels.forEach(channel => {
+          if (channel.enabled) {
+            const option = document.createElement('option');
+            option.value = channel.id;
+            option.textContent = `${channel.name} (${channel.config})`;
+            if (currentNotification && currentNotification.channel_id === channel.id) {
+              option.selected = true;
+            }
+            channelSelect.appendChild(option);
+          }
+        });
+
+        // 设置启用状态
+        document.getElementById('notificationEnabled').checked =
+          currentNotification ? currentNotification.enabled : true;
+
+        // 显示配置模态框
+        const modal = new bootstrap.Modal(document.getElementById('configNotificationModal'));
+        modal.show();
+      } catch (error) {
+        console.error('配置账号通知失败:', error);
+        showToast('配置账号通知失败', 'danger');
+      }
+    }
+
+    // 删除账号通知配置
+    async function deleteAccountNotification(accountId) {
+      if (!confirm(`确定要删除账号 ${accountId} 的通知配置吗？`)) {
+        return;
+      }
+
+      try {
+        const response = await fetch(`${apiBase}/message-notifications/account/${accountId}`, {
+          method: 'DELETE',
+          headers: {
+            'Authorization': `Bearer ${authToken}`
+          }
+        });
+
+        if (response.ok) {
+          showToast('通知配置删除成功', 'success');
+          loadMessageNotifications();
+        } else {
+          const error = await response.text();
+          showToast(`删除失败: ${error}`, 'danger');
+        }
+      } catch (error) {
+        console.error('删除通知配置失败:', error);
+        showToast('删除通知配置失败', 'danger');
+      }
+    }
+
+    // 保存账号通知配置
+    async function saveAccountNotification() {
+      const accountId = document.getElementById('configAccountId').value;
+      const channelId = document.getElementById('notificationChannel').value;
+      const enabled = document.getElementById('notificationEnabled').checked;
+
+      if (!channelId) {
+        showToast('请选择通知渠道', 'warning');
+        return;
+      }
+
+      try {
+        const response = await fetch(`${apiBase}/message-notifications/${accountId}`, {
+          method: 'POST',
+          headers: {
+            'Authorization': `Bearer ${authToken}`,
+            'Content-Type': 'application/json'
+          },
+          body: JSON.stringify({
+            channel_id: parseInt(channelId),
+            enabled: enabled
+          })
+        });
+
+        if (response.ok) {
+          showToast('通知配置保存成功', 'success');
+          const modal = bootstrap.Modal.getInstance(document.getElementById('configNotificationModal'));
+          modal.hide();
+          loadMessageNotifications();
+        } else {
+          const error = await response.text();
+          showToast(`保存失败: ${error}`, 'danger');
+        }
+      } catch (error) {
+        console.error('保存通知配置失败:', error);
+        showToast('保存通知配置失败', 'danger');
+      }
+    }
+
+    // ==================== 卡券管理功能 ====================
+
+    // 加载卡券列表
+    async function loadCards() {
+      try {
+        const response = await fetch(`${apiBase}/cards`, {
+          headers: {
+            'Authorization': `Bearer ${authToken}`
+          }
+        });
+
+        if (response.ok) {
+          const cards = await response.json();
+          renderCardsList(cards);
+          updateCardsStats(cards);
+        } else {
+          showToast('加载卡券列表失败', 'danger');
+        }
+      } catch (error) {
+        console.error('加载卡券列表失败:', error);
+        showToast('加载卡券列表失败', 'danger');
+      }
+    }
+
+    // 渲染卡券列表
+    function renderCardsList(cards) {
+      const tbody = document.getElementById('cardsTableBody');
+
+      if (cards.length === 0) {
+        tbody.innerHTML = `
+          <tr>
+            <td colspan="6" class="text-center py-4 text-muted">
+              <i class="bi bi-credit-card fs-1 d-block mb-3"></i>
+              <h5>暂无卡券数据</h5>
+              <p class="mb-0">点击"添加卡券"开始创建您的第一个卡券</p>
+            </td>
+          </tr>
+        `;
+        return;
+      }
+
+      tbody.innerHTML = '';
+
+      cards.forEach(card => {
+        const tr = document.createElement('tr');
+
+        // 类型标签
+        let typeBadge = '';
+        switch(card.type) {
+          case 'api':
+            typeBadge = '<span class="badge bg-info">API接口</span>';
+            break;
+          case 'text':
+            typeBadge = '<span class="badge bg-success">固定文字</span>';
+            break;
+          case 'data':
+            typeBadge = '<span class="badge bg-warning">批量数据</span>';
+            break;
+        }
+
+        // 状态标签
+        const statusBadge = card.enabled ?
+          '<span class="badge bg-success">启用</span>' :
+          '<span class="badge bg-secondary">禁用</span>';
+
+        // 数据量显示
+        let dataCount = '-';
+        if (card.type === 'data' && card.data_content) {
+          const lines = card.data_content.split('\n').filter(line => line.trim());
+          dataCount = lines.length;
+        } else if (card.type === 'api') {
+          dataCount = '∞';
+        } else if (card.type === 'text') {
+          dataCount = '1';
+        }
+
+        tr.innerHTML = `
+          <td>
+            <div class="fw-bold">${card.name}</div>
+            ${card.description ? `<small class="text-muted">${card.description}</small>` : ''}
+          </td>
+          <td>${typeBadge}</td>
+          <td>${dataCount}</td>
+          <td>${statusBadge}</td>
+          <td>
+            <small class="text-muted">${new Date(card.created_at).toLocaleString('zh-CN')}</small>
+          </td>
+          <td>
+            <div class="btn-group" role="group">
+              <button class="btn btn-sm btn-outline-primary" onclick="editCard(${card.id})" title="编辑">
+                <i class="bi bi-pencil"></i>
+              </button>
+              <button class="btn btn-sm btn-outline-info" onclick="testCard(${card.id})" title="测试">
+                <i class="bi bi-play"></i>
+              </button>
+              <button class="btn btn-sm btn-outline-danger" onclick="deleteCard(${card.id})" title="删除">
+                <i class="bi bi-trash"></i>
+              </button>
+            </div>
+          </td>
+        `;
+
+        tbody.appendChild(tr);
+      });
+    }
+
+    // 更新卡券统计
+    function updateCardsStats(cards) {
+      const totalCards = cards.length;
+      const apiCards = cards.filter(card => card.type === 'api').length;
+      const textCards = cards.filter(card => card.type === 'text').length;
+      const dataCards = cards.filter(card => card.type === 'data').length;
+
+      document.getElementById('totalCards').textContent = totalCards;
+      document.getElementById('apiCards').textContent = apiCards;
+      document.getElementById('textCards').textContent = textCards;
+      document.getElementById('dataCards').textContent = dataCards;
+    }
+
+    // 显示添加卡券模态框
+    function showAddCardModal() {
+      document.getElementById('addCardForm').reset();
+      toggleCardTypeFields();
+      const modal = new bootstrap.Modal(document.getElementById('addCardModal'));
+      modal.show();
+    }
+
+    // 切换卡券类型字段显示
+    function toggleCardTypeFields() {
+      const cardType = document.getElementById('cardType').value;
+
+      document.getElementById('apiFields').style.display = cardType === 'api' ? 'block' : 'none';
+      document.getElementById('textFields').style.display = cardType === 'text' ? 'block' : 'none';
+      document.getElementById('dataFields').style.display = cardType === 'data' ? 'block' : 'none';
+    }
+
+    // 保存卡券
+    async function saveCard() {
+      try {
+        const cardType = document.getElementById('cardType').value;
+        const cardName = document.getElementById('cardName').value;
+
+        if (!cardType || !cardName) {
+          showToast('请填写必填字段', 'warning');
+          return;
+        }
+
+        const cardData = {
+          name: cardName,
+          type: cardType,
+          description: document.getElementById('cardDescription').value,
+          enabled: true
+        };
+
+        // 根据类型添加特定配置
+        switch(cardType) {
+          case 'api':
+            // 验证和解析JSON字段
+            let headers = '{}';
+            let params = '{}';
+
+            try {
+              const headersInput = document.getElementById('apiHeaders').value.trim();
+              if (headersInput) {
+                JSON.parse(headersInput); // 验证JSON格式
+                headers = headersInput;
+              }
+            } catch (e) {
+              showToast('请求头格式错误，请输入有效的JSON', 'warning');
+              return;
+            }
+
+            try {
+              const paramsInput = document.getElementById('apiParams').value.trim();
+              if (paramsInput) {
+                JSON.parse(paramsInput); // 验证JSON格式
+                params = paramsInput;
+              }
+            } catch (e) {
+              showToast('请求参数格式错误，请输入有效的JSON', 'warning');
+              return;
+            }
+
+            cardData.api_config = {
+              url: document.getElementById('apiUrl').value,
+              method: document.getElementById('apiMethod').value,
+              timeout: parseInt(document.getElementById('apiTimeout').value),
+              headers: headers,
+              params: params
+            };
+            break;
+          case 'text':
+            cardData.text_content = document.getElementById('textContent').value;
+            break;
+          case 'data':
+            cardData.data_content = document.getElementById('dataContent').value;
+            break;
+        }
+
+        const response = await fetch(`${apiBase}/cards`, {
+          method: 'POST',
+          headers: {
+            'Authorization': `Bearer ${authToken}`,
+            'Content-Type': 'application/json'
+          },
+          body: JSON.stringify(cardData)
+        });
+
+        if (response.ok) {
+          showToast('卡券保存成功', 'success');
+          bootstrap.Modal.getInstance(document.getElementById('addCardModal')).hide();
+          loadCards();
+        } else {
+          const error = await response.text();
+          showToast(`保存失败: ${error}`, 'danger');
+        }
+      } catch (error) {
+        console.error('保存卡券失败:', error);
+        showToast('保存卡券失败', 'danger');
+      }
+    }
+    // ==================== 自动发货功能 ====================
+
+    // 加载发货规则列表
+    async function loadDeliveryRules() {
+      try {
+        const response = await fetch(`${apiBase}/delivery-rules`, {
+          headers: {
+            'Authorization': `Bearer ${authToken}`
+          }
+        });
+
+        if (response.ok) {
+          const rules = await response.json();
+          renderDeliveryRulesList(rules);
+          updateDeliveryStats(rules);
+
+          // 同时加载卡券列表用于下拉选择
+          loadCardsForSelect();
+        } else {
+          showToast('加载发货规则失败', 'danger');
+        }
+      } catch (error) {
+        console.error('加载发货规则失败:', error);
+        showToast('加载发货规则失败', 'danger');
+      }
+    }
+
+    // 渲染发货规则列表
+    function renderDeliveryRulesList(rules) {
+      const tbody = document.getElementById('deliveryRulesTableBody');
+
+      if (rules.length === 0) {
+        tbody.innerHTML = `
+          <tr>
+            <td colspan="7" class="text-center py-4 text-muted">
+              <i class="bi bi-truck fs-1 d-block mb-3"></i>
+              <h5>暂无发货规则</h5>
+              <p class="mb-0">点击"添加规则"开始配置自动发货规则</p>
+            </td>
+          </tr>
+        `;
+        return;
+      }
+
+      tbody.innerHTML = '';
+
+      rules.forEach(rule => {
+        const tr = document.createElement('tr');
+
+        // 状态标签
+        const statusBadge = rule.enabled ?
+          '<span class="badge bg-success">启用</span>' :
+          '<span class="badge bg-secondary">禁用</span>';
+
+        // 卡券类型标签
+        let cardTypeBadge = '<span class="badge bg-secondary">未知</span>';
+        if (rule.card_type) {
+          switch(rule.card_type) {
+            case 'api':
+              cardTypeBadge = '<span class="badge bg-info">API接口</span>';
+              break;
+            case 'text':
+              cardTypeBadge = '<span class="badge bg-success">固定文字</span>';
+              break;
+            case 'data':
+              cardTypeBadge = '<span class="badge bg-warning">批量数据</span>';
+              break;
+          }
+        }
+
+        tr.innerHTML = `
+          <td>
+            <div class="fw-bold">${rule.keyword}</div>
+            ${rule.description ? `<small class="text-muted">${rule.description}</small>` : ''}
+          </td>
+          <td>
+            <span class="badge bg-primary">${rule.card_name || '未知卡券'}</span>
+          </td>
+          <td>${cardTypeBadge}</td>
+          <td>
+            <span class="badge bg-info">${rule.delivery_count || 1}</span>
+          </td>
+          <td>${statusBadge}</td>
+          <td>
+            <span class="badge bg-warning">${rule.delivery_times || 0}</span>
+          </td>
+          <td>
+            <div class="btn-group" role="group">
+              <button class="btn btn-sm btn-outline-primary" onclick="editDeliveryRule(${rule.id})" title="编辑">
+                <i class="bi bi-pencil"></i>
+              </button>
+              <button class="btn btn-sm btn-outline-info" onclick="testDeliveryRule(${rule.id})" title="测试">
+                <i class="bi bi-play"></i>
+              </button>
+              <button class="btn btn-sm btn-outline-danger" onclick="deleteDeliveryRule(${rule.id})" title="删除">
+                <i class="bi bi-trash"></i>
+              </button>
+            </div>
+          </td>
+        `;
+
+        tbody.appendChild(tr);
+      });
+    }
+
+    // 更新发货统计
+    function updateDeliveryStats(rules) {
+      const totalRules = rules.length;
+      const activeRules = rules.filter(rule => rule.enabled).length;
+      const todayDeliveries = 0; // 需要从后端获取今日发货统计
+      const totalDeliveries = rules.reduce((sum, rule) => sum + (rule.delivery_times || 0), 0);
+
+      document.getElementById('totalRules').textContent = totalRules;
+      document.getElementById('activeRules').textContent = activeRules;
+      document.getElementById('todayDeliveries').textContent = todayDeliveries;
+      document.getElementById('totalDeliveries').textContent = totalDeliveries;
+    }
+
+    // 显示添加发货规则模态框
+    function showAddDeliveryRuleModal() {
+      document.getElementById('addDeliveryRuleForm').reset();
+      loadCardsForSelect(); // 加载卡券选项
+      const modal = new bootstrap.Modal(document.getElementById('addDeliveryRuleModal'));
+      modal.show();
+    }
+
+    // 加载卡券列表用于下拉选择
+    async function loadCardsForSelect() {
+      try {
+        const response = await fetch(`${apiBase}/cards`, {
+          headers: {
+            'Authorization': `Bearer ${authToken}`
+          }
+        });
+
+        if (response.ok) {
+          const cards = await response.json();
+          const select = document.getElementById('selectedCard');
+
+          // 清空现有选项
+          select.innerHTML = '<option value="">请选择卡券</option>';
+
+          cards.forEach(card => {
+            if (card.enabled) { // 只显示启用的卡券
+              const option = document.createElement('option');
+              option.value = card.id;
+              option.textContent = `${card.name} (${card.type === 'api' ? 'API' : card.type === 'text' ? '固定文字' : '批量数据'})`;
+              select.appendChild(option);
+            }
+          });
+        }
+      } catch (error) {
+        console.error('加载卡券选项失败:', error);
+      }
+    }
+
+    // 保存发货规则
+    async function saveDeliveryRule() {
+      try {
+        const keyword = document.getElementById('productKeyword').value;
+        const cardId = document.getElementById('selectedCard').value;
+        const deliveryCount = document.getElementById('deliveryCount').value;
+        const enabled = document.getElementById('ruleEnabled').checked;
+        const description = document.getElementById('ruleDescription').value;
+
+        if (!keyword || !cardId) {
+          showToast('请填写必填字段', 'warning');
+          return;
+        }
+
+        const ruleData = {
+          keyword: keyword,
+          card_id: parseInt(cardId),
+          delivery_count: parseInt(deliveryCount),
+          enabled: enabled,
+          description: description
+        };
+
+        const response = await fetch(`${apiBase}/delivery-rules`, {
+          method: 'POST',
+          headers: {
+            'Authorization': `Bearer ${authToken}`,
+            'Content-Type': 'application/json'
+          },
+          body: JSON.stringify(ruleData)
+        });
+
+        if (response.ok) {
+          showToast('发货规则保存成功', 'success');
+          bootstrap.Modal.getInstance(document.getElementById('addDeliveryRuleModal')).hide();
+          loadDeliveryRules();
+        } else {
+          const error = await response.text();
+          showToast(`保存失败: ${error}`, 'danger');
+        }
+      } catch (error) {
+        console.error('保存发货规则失败:', error);
+        showToast('保存发货规则失败', 'danger');
+      }
+    }
+
+    // 编辑卡券
+    async function editCard(cardId) {
+      try {
+        // 获取卡券详情
+        const response = await fetch(`${apiBase}/cards/${cardId}`, {
+          headers: {
+            'Authorization': `Bearer ${authToken}`
+          }
+        });
+
+        if (response.ok) {
+          const card = await response.json();
+
+          // 填充编辑表单
+          document.getElementById('editCardId').value = card.id;
+          document.getElementById('editCardName').value = card.name;
+          document.getElementById('editCardType').value = card.type;
+          document.getElementById('editCardDescription').value = card.description || '';
+          document.getElementById('editCardEnabled').checked = card.enabled;
+
+          // 根据类型填充特定字段
+          if (card.type === 'api' && card.api_config) {
+            document.getElementById('editApiUrl').value = card.api_config.url || '';
+            document.getElementById('editApiMethod').value = card.api_config.method || 'GET';
+            document.getElementById('editApiTimeout').value = card.api_config.timeout || 10;
+            document.getElementById('editApiHeaders').value = card.api_config.headers || '{}';
+            document.getElementById('editApiParams').value = card.api_config.params || '{}';
+          } else if (card.type === 'text') {
+            document.getElementById('editTextContent').value = card.text_content || '';
+          } else if (card.type === 'data') {
+            document.getElementById('editDataContent').value = card.data_content || '';
+          }
+
+          // 显示对应的字段
+          toggleEditCardTypeFields();
+
+          // 显示模态框
+          const modal = new bootstrap.Modal(document.getElementById('editCardModal'));
+          modal.show();
+        } else {
+          showToast('获取卡券详情失败', 'danger');
+        }
+      } catch (error) {
+        console.error('获取卡券详情失败:', error);
+        showToast('获取卡券详情失败', 'danger');
+      }
+    }
+
+    // 切换编辑卡券类型字段显示
+    function toggleEditCardTypeFields() {
+      const cardType = document.getElementById('editCardType').value;
+
+      document.getElementById('editApiFields').style.display = cardType === 'api' ? 'block' : 'none';
+      document.getElementById('editTextFields').style.display = cardType === 'text' ? 'block' : 'none';
+      document.getElementById('editDataFields').style.display = cardType === 'data' ? 'block' : 'none';
+    }
+
+    // 更新卡券
+    async function updateCard() {
+      try {
+        const cardId = document.getElementById('editCardId').value;
+        const cardType = document.getElementById('editCardType').value;
+        const cardName = document.getElementById('editCardName').value;
+
+        if (!cardType || !cardName) {
+          showToast('请填写必填字段', 'warning');
+          return;
+        }
+
+        const cardData = {
+          name: cardName,
+          type: cardType,
+          description: document.getElementById('editCardDescription').value,
+          enabled: document.getElementById('editCardEnabled').checked
+        };
+
+        // 根据类型添加特定配置
+        switch(cardType) {
+          case 'api':
+            // 验证和解析JSON字段
+            let headers = '{}';
+            let params = '{}';
+
+            try {
+              const headersInput = document.getElementById('editApiHeaders').value.trim();
+              if (headersInput) {
+                JSON.parse(headersInput);
+                headers = headersInput;
+              }
+            } catch (e) {
+              showToast('请求头格式错误，请输入有效的JSON', 'warning');
+              return;
+            }
+
+            try {
+              const paramsInput = document.getElementById('editApiParams').value.trim();
+              if (paramsInput) {
+                JSON.parse(paramsInput);
+                params = paramsInput;
+              }
+            } catch (e) {
+              showToast('请求参数格式错误，请输入有效的JSON', 'warning');
+              return;
+            }
+
+            cardData.api_config = {
+              url: document.getElementById('editApiUrl').value,
+              method: document.getElementById('editApiMethod').value,
+              timeout: parseInt(document.getElementById('editApiTimeout').value),
+              headers: headers,
+              params: params
+            };
+            break;
+          case 'text':
+            cardData.text_content = document.getElementById('editTextContent').value;
+            break;
+          case 'data':
+            cardData.data_content = document.getElementById('editDataContent').value;
+            break;
+        }
+
+        const response = await fetch(`${apiBase}/cards/${cardId}`, {
+          method: 'PUT',
+          headers: {
+            'Authorization': `Bearer ${authToken}`,
+            'Content-Type': 'application/json'
+          },
+          body: JSON.stringify(cardData)
+        });
+
+        if (response.ok) {
+          showToast('卡券更新成功', 'success');
+          bootstrap.Modal.getInstance(document.getElementById('editCardModal')).hide();
+          loadCards();
+        } else {
+          const error = await response.text();
+          showToast(`更新失败: ${error}`, 'danger');
+        }
+      } catch (error) {
+        console.error('更新卡券失败:', error);
+        showToast('更新卡券失败', 'danger');
+      }
+    }
+
+    // 测试卡券（占位函数）
+    function testCard(cardId) {
+      showToast('测试功能开发中...', 'info');
+    }
+
+    // 删除卡券
+    async function deleteCard(cardId) {
+      if (confirm('确定要删除这个卡券吗？删除后无法恢复！')) {
+        try {
+          const response = await fetch(`${apiBase}/cards/${cardId}`, {
+            method: 'DELETE',
+            headers: {
+              'Authorization': `Bearer ${authToken}`
+            }
+          });
+
+          if (response.ok) {
+            showToast('卡券删除成功', 'success');
+            loadCards();
+          } else {
+            const error = await response.text();
+            showToast(`删除失败: ${error}`, 'danger');
+          }
+        } catch (error) {
+          console.error('删除卡券失败:', error);
+          showToast('删除卡券失败', 'danger');
+        }
+      }
+    }
+
+    // 编辑发货规则
+    async function editDeliveryRule(ruleId) {
+      try {
+        // 获取发货规则详情
+        const response = await fetch(`${apiBase}/delivery-rules/${ruleId}`, {
+          headers: {
+            'Authorization': `Bearer ${authToken}`
+          }
+        });
+
+        if (response.ok) {
+          const rule = await response.json();
+
+          // 填充编辑表单
+          document.getElementById('editRuleId').value = rule.id;
+          document.getElementById('editProductKeyword').value = rule.keyword;
+          document.getElementById('editDeliveryCount').value = rule.delivery_count || 1;
+          document.getElementById('editRuleEnabled').checked = rule.enabled;
+          document.getElementById('editRuleDescription').value = rule.description || '';
+
+          // 加载卡券选项并设置当前选中的卡券
+          await loadCardsForEditSelect();
+          document.getElementById('editSelectedCard').value = rule.card_id;
+
+          // 显示模态框
+          const modal = new bootstrap.Modal(document.getElementById('editDeliveryRuleModal'));
+          modal.show();
+        } else {
+          showToast('获取发货规则详情失败', 'danger');
+        }
+      } catch (error) {
+        console.error('获取发货规则详情失败:', error);
+        showToast('获取发货规则详情失败', 'danger');
+      }
+    }
+
+    // 加载卡券列表用于编辑时的下拉选择
+    async function loadCardsForEditSelect() {
+      try {
+        const response = await fetch(`${apiBase}/cards`, {
+          headers: {
+            'Authorization': `Bearer ${authToken}`
+          }
+        });
+
+        if (response.ok) {
+          const cards = await response.json();
+          const select = document.getElementById('editSelectedCard');
+
+          // 清空现有选项
+          select.innerHTML = '<option value="">请选择卡券</option>';
+
+          cards.forEach(card => {
+            if (card.enabled) { // 只显示启用的卡券
+              const option = document.createElement('option');
+              option.value = card.id;
+              option.textContent = `${card.name} (${card.type === 'api' ? 'API' : card.type === 'text' ? '固定文字' : '批量数据'})`;
+              select.appendChild(option);
+            }
+          });
+        }
+      } catch (error) {
+        console.error('加载卡券选项失败:', error);
+      }
+    }
+
+    // 更新发货规则
+    async function updateDeliveryRule() {
+      try {
+        const ruleId = document.getElementById('editRuleId').value;
+        const keyword = document.getElementById('editProductKeyword').value;
+        const cardId = document.getElementById('editSelectedCard').value;
+        const deliveryCount = document.getElementById('editDeliveryCount').value;
+        const enabled = document.getElementById('editRuleEnabled').checked;
+        const description = document.getElementById('editRuleDescription').value;
+
+        if (!keyword || !cardId) {
+          showToast('请填写必填字段', 'warning');
+          return;
+        }
+
+        const ruleData = {
+          keyword: keyword,
+          card_id: parseInt(cardId),
+          delivery_count: parseInt(deliveryCount),
+          enabled: enabled,
+          description: description
+        };
+
+        const response = await fetch(`${apiBase}/delivery-rules/${ruleId}`, {
+          method: 'PUT',
+          headers: {
+            'Authorization': `Bearer ${authToken}`,
+            'Content-Type': 'application/json'
+          },
+          body: JSON.stringify(ruleData)
+        });
+
+        if (response.ok) {
+          showToast('发货规则更新成功', 'success');
+          bootstrap.Modal.getInstance(document.getElementById('editDeliveryRuleModal')).hide();
+          loadDeliveryRules();
+        } else {
+          const error = await response.text();
+          showToast(`更新失败: ${error}`, 'danger');
+        }
+      } catch (error) {
+        console.error('更新发货规则失败:', error);
+        showToast('更新发货规则失败', 'danger');
+      }
+    }
+
+    // 测试发货规则（占位函数）
+    function testDeliveryRule(ruleId) {
+      showToast('测试功能开发中...', 'info');
+    }
+
+    // 删除发货规则
+    async function deleteDeliveryRule(ruleId) {
+      if (confirm('确定要删除这个发货规则吗？删除后无法恢复！')) {
+        try {
+          const response = await fetch(`${apiBase}/delivery-rules/${ruleId}`, {
+            method: 'DELETE',
+            headers: {
+              'Authorization': `Bearer ${authToken}`
+            }
+          });
+
+          if (response.ok) {
+            showToast('发货规则删除成功', 'success');
+            loadDeliveryRules();
+          } else {
+            const error = await response.text();
+            showToast(`删除失败: ${error}`, 'danger');
+          }
+        } catch (error) {
+          console.error('删除发货规则失败:', error);
+          showToast('删除发货规则失败', 'danger');
+        }
+      }
+    }
+
+
+
+
+
+  </script>
+
+  <!-- 默认回复管理模态框 -->
+  <div class="modal fade" id="defaultReplyModal" tabindex="-1" aria-labelledby="defaultReplyModalLabel" aria-hidden="true">
+    <div class="modal-dialog modal-xl">
+      <div class="modal-content">
+        <div class="modal-header">
+          <h5 class="modal-title" id="defaultReplyModalLabel">
+            <i class="bi bi-chat-text me-2"></i>默认回复管理
+          </h5>
+          <button type="button" class="btn-close" data-bs-dismiss="modal" aria-label="Close"></button>
+        </div>
+        <div class="modal-body">
+          <div class="alert alert-info">
+            <i class="bi bi-info-circle me-2"></i>
+            <strong>功能说明：</strong>当没有匹配到关键词时，系统会使用默认回复。支持以下变量：
+            <code>{send_user_name}</code> 用户昵称、
+            <code>{send_user_id}</code> 用户ID、
+            <code>{send_message}</code> 用户消息
+          </div>
+
+          <div class="table-responsive">
+            <table class="table table-hover" id="defaultReplyTable">
+              <thead>
+                <tr>
+                  <th style="width: 15%">账号ID</th>
+                  <th style="width: 15%">状态</th>
+                  <th style="width: 50%">默认回复内容</th>
+                  <th style="width: 20%">操作</th>
+                </tr>
+              </thead>
+              <tbody id="defaultReplyTableBody">
+                <!-- 动态生成 -->
+              </tbody>
+            </table>
+          </div>
+        </div>
+        <div class="modal-footer">
+          <div class="text-muted me-auto">
+            <small><i class="bi bi-info-circle me-1"></i>请点击每个账号的"编辑"按钮进行单独设置</small>
+          </div>
+          <button type="button" class="btn btn-primary" data-bs-dismiss="modal">
+            <i class="bi bi-check-circle me-1"></i>完成
+          </button>
+        </div>
+      </div>
+    </div>
+  </div>
+
+  <!-- 编辑默认回复模态框 -->
+  <div class="modal fade" id="editDefaultReplyModal" tabindex="-1" aria-labelledby="editDefaultReplyModalLabel" aria-hidden="true">
+    <div class="modal-dialog modal-lg">
+      <div class="modal-content">
+        <div class="modal-header">
+          <h5 class="modal-title" id="editDefaultReplyModalLabel">
+            <i class="bi bi-pencil-square me-2"></i>编辑默认回复
+          </h5>
+          <button type="button" class="btn-close" data-bs-dismiss="modal" aria-label="Close"></button>
+        </div>
+        <div class="modal-body">
+          <form id="editDefaultReplyForm">
+            <input type="hidden" id="editAccountId" />
+
+            <div class="mb-3">
+              <label class="form-label">账号ID</label>
+              <input type="text" class="form-control" id="editAccountIdDisplay" readonly />
+            </div>
+
+            <div class="mb-3">
+              <div class="form-check form-switch">
+                <input class="form-check-input" type="checkbox" id="editDefaultReplyEnabled" onchange="toggleReplyContentVisibility()" />
+                <label class="form-check-label" for="editDefaultReplyEnabled">
+                  启用默认回复
+                </label>
+              </div>
+            </div>
+
+            <div class="mb-3" id="editReplyContentGroup">
+              <label for="editReplyContent" class="form-label">默认回复内容</label>
+              <textarea class="form-control" id="editReplyContent" rows="4"
+                placeholder="请输入默认回复内容，支持变量：{send_user_name} {send_user_id} {send_message}"></textarea>
+              <div class="form-text">
+                <strong>可用变量：</strong>
+                <span class="badge bg-secondary me-1">{send_user_name}</span>
+                <span class="badge bg-secondary me-1">{send_user_id}</span>
+                <span class="badge bg-secondary me-1">{send_message}</span>
+              </div>
+            </div>
+          </form>
+        </div>
+        <div class="modal-footer">
+          <button type="button" class="btn btn-secondary" data-bs-dismiss="modal">取消</button>
+          <button type="button" class="btn btn-primary" onclick="saveDefaultReply()">
+            <i class="bi bi-check-circle me-1"></i>保存
+          </button>
+        </div>
+      </div>
+    </div>
+  </div>
+
+  <!-- 编辑商品详情模态框 -->
+  <div class="modal fade" id="editItemModal" tabindex="-1">
+    <div class="modal-dialog modal-xl">
+      <div class="modal-content">
+        <div class="modal-header">
+          <h5 class="modal-title">
+            <i class="bi bi-pencil me-2"></i>编辑商品详情
+          </h5>
+          <button type="button" class="btn-close" data-bs-dismiss="modal"></button>
+        </div>
+        <div class="modal-body">
+          <form id="editItemForm">
+            <input type="hidden" id="editItemCookieId">
+            <input type="hidden" id="editItemId">
+
+            <div class="row mb-3">
+              <div class="col-md-6">
+                <label class="form-label">账号ID</label>
+                <input type="text" class="form-control" id="editItemCookieIdDisplay" readonly>
+              </div>
+              <div class="col-md-6">
+                <label class="form-label">商品ID</label>
+                <input type="text" class="form-control" id="editItemIdDisplay" readonly>
+              </div>
+            </div>
+
+            <div class="mb-3">
+              <label for="editItemDetail" class="form-label">商品详情 <span class="text-danger">*</span></label>
+              <textarea class="form-control" id="editItemDetail" rows="20"
+                        placeholder="请输入商品详情内容..."></textarea>
+              <div class="form-text">
+                <i class="bi bi-info-circle me-1"></i>
+                请输入商品详情内容，这些内容将用于自动发货时的关键词匹配。
+              </div>
+            </div>
+          </form>
+        </div>
+        <div class="modal-footer">
+          <button type="button" class="btn btn-secondary" data-bs-dismiss="modal">取消</button>
+          <button type="button" class="btn btn-primary" onclick="saveItemDetail()">
+            <i class="bi bi-check-circle me-1"></i>保存
+          </button>
+        </div>
+      </div>
+    </div>
+  </div>
+
+  <script>
+    // ==================== 系统设置功能 ====================
+
+    // 主题颜色映射
+    const themeColors = {
+      blue: '#4f46e5',
+      green: '#10b981',
+      purple: '#8b5cf6',
+      red: '#ef4444',
+      orange: '#f59e0b'
+    };
+
+    // 加载系统设置
+    async function loadSystemSettings() {
+      try {
+        const response = await fetch(`${apiBase}/system-settings`, {
+          headers: {
+            'Authorization': `Bearer ${authToken}`
+          }
+        });
+
+        if (response.ok) {
+          const settings = await response.json();
+
+          // 设置主题颜色
+          if (settings.theme_color) {
+            document.getElementById('themeColor').value = settings.theme_color;
+            applyThemeColor(settings.theme_color);
+          }
+        }
+      } catch (error) {
+        console.error('加载系统设置失败:', error);
+      }
+    }
+
+    // 应用主题颜色
+    function applyThemeColor(colorName) {
+      const color = themeColors[colorName];
+      if (color) {
+        document.documentElement.style.setProperty('--primary-color', color);
+
+        // 计算hover颜色（稍微深一点）
+        const hoverColor = adjustBrightness(color, -20);
+        document.documentElement.style.setProperty('--primary-hover', hoverColor);
+
+        // 计算浅色版本（用于某些UI元素）
+        const lightColor = adjustBrightness(color, 10);
+        document.documentElement.style.setProperty('--primary-light', lightColor);
+      }
+    }
+
+    // 调整颜色亮度
+    function adjustBrightness(hex, percent) {
+      const num = parseInt(hex.replace("#", ""), 16);
+      const amt = Math.round(2.55 * percent);
+      const R = (num >> 16) + amt;
+      const G = (num >> 8 & 0x00FF) + amt;
+      const B = (num & 0x0000FF) + amt;
+      return "#" + (0x1000000 + (R < 255 ? R < 1 ? 0 : R : 255) * 0x10000 +
+        (G < 255 ? G < 1 ? 0 : G : 255) * 0x100 +
+        (B < 255 ? B < 1 ? 0 : B : 255)).toString(16).slice(1);
+    }
+
+    // 主题表单提交处理
+    document.addEventListener('DOMContentLoaded', function() {
+      const themeForm = document.getElementById('themeForm');
+      if (themeForm) {
+        themeForm.addEventListener('submit', async function(e) {
+          e.preventDefault();
+
+          const selectedColor = document.getElementById('themeColor').value;
+
+          try {
+            const response = await fetch(`${apiBase}/system-settings/theme_color`, {
+              method: 'PUT',
+              headers: {
+                'Authorization': `Bearer ${authToken}`,
+                'Content-Type': 'application/json'
+              },
+              body: JSON.stringify({
+                key: 'theme_color',
+                value: selectedColor,
+                description: '主题颜色'
+              })
+            });
+
+            if (response.ok) {
+              applyThemeColor(selectedColor);
+              showToast('主题颜色应用成功', 'success');
+            } else {
+              const error = await response.text();
+              showToast(`主题设置失败: ${error}`, 'danger');
+            }
+          } catch (error) {
+            console.error('主题设置失败:', error);
+            showToast('主题设置失败', 'danger');
+          }
+        });
+      }
+
+      // 密码表单提交处理
+      const passwordForm = document.getElementById('passwordForm');
+      if (passwordForm) {
+        passwordForm.addEventListener('submit', async function(e) {
+          e.preventDefault();
+
+          const currentPassword = document.getElementById('currentPassword').value;
+          const newPassword = document.getElementById('newPassword').value;
+          const confirmPassword = document.getElementById('confirmPassword').value;
+
+          if (newPassword !== confirmPassword) {
+            showToast('新密码和确认密码不匹配', 'warning');
+            return;
+          }
+
+          if (newPassword.length < 6) {
+            showToast('新密码长度至少6位', 'warning');
+            return;
+          }
+
+          try {
+            const response = await fetch(`${apiBase}/system-settings/password`, {
+              method: 'PUT',
+              headers: {
+                'Authorization': `Bearer ${authToken}`,
+                'Content-Type': 'application/json'
+              },
+              body: JSON.stringify({
+                current_password: currentPassword,
+                new_password: newPassword
+              })
+            });
+
+            if (response.ok) {
+              showToast('密码更新成功，请重新登录', 'success');
+              passwordForm.reset();
+              // 3秒后跳转到登录页面
+              setTimeout(() => {
+                localStorage.removeItem('auth_token');
+                window.location.href = '/login.html';
+              }, 3000);
+            } else {
+              const error = await response.text();
+              showToast(`密码更新失败: ${error}`, 'danger');
+            }
+          } catch (error) {
+            console.error('密码更新失败:', error);
+            showToast('密码更新失败', 'danger');
+          }
+        });
+      }
+
+      // 页面加载时加载系统设置
+      loadSystemSettings();
+    });
+
+    // ==================== 备份管理功能 ====================
+
+    // 导出备份
+    async function exportBackup() {
+      try {
+        showToast('正在导出备份，请稍候...', 'info');
+
+        const response = await fetch(`${apiBase}/backup/export`, {
+          headers: {
+            'Authorization': `Bearer ${authToken}`
+          }
+        });
+
+        if (response.ok) {
+          const backupData = await response.json();
+
+          // 生成文件名
+          const now = new Date();
+          const timestamp = now.getFullYear() +
+                          String(now.getMonth() + 1).padStart(2, '0') +
+                          String(now.getDate()).padStart(2, '0') + '_' +
+                          String(now.getHours()).padStart(2, '0') +
+                          String(now.getMinutes()).padStart(2, '0') +
+                          String(now.getSeconds()).padStart(2, '0');
+          const filename = `xianyu_backup_${timestamp}.json`;
+
+          // 创建下载链接
+          const blob = new Blob([JSON.stringify(backupData, null, 2)], { type: 'application/json' });
+          const url = window.URL.createObjectURL(blob);
+          const a = document.createElement('a');
+          a.href = url;
+          a.download = filename;
+          document.body.appendChild(a);
+          a.click();
+          document.body.removeChild(a);
+          window.URL.revokeObjectURL(url);
+
+          showToast('备份导出成功', 'success');
+        } else {
+          const error = await response.text();
+          showToast(`导出失败: ${error}`, 'danger');
+        }
+      } catch (error) {
+        console.error('导出备份失败:', error);
+        showToast('导出备份失败', 'danger');
+      }
+    }
+
+    // 导入备份
+    async function importBackup() {
+      const fileInput = document.getElementById('backupFile');
+      const file = fileInput.files[0];
+
+      if (!file) {
+        showToast('请选择备份文件', 'warning');
+        return;
+      }
+
+      if (!file.name.endsWith('.json')) {
+        showToast('只支持JSON格式的备份文件', 'warning');
+        return;
+      }
+
+      if (!confirm('导入备份将覆盖当前所有数据，确定要继续吗？')) {
+        return;
+      }
+
+      try {
+        showToast('正在导入备份，请稍候...', 'info');
+
+        const formData = new FormData();
+        formData.append('file', file);
+
+        const response = await fetch(`${apiBase}/backup/import`, {
+          method: 'POST',
+          headers: {
+            'Authorization': `Bearer ${authToken}`
+          },
+          body: formData
+        });
+
+        if (response.ok) {
+          showToast('备份导入成功，页面将在3秒后刷新', 'success');
+
+          // 清空文件选择
+          fileInput.value = '';
+
+          // 3秒后刷新页面
+          setTimeout(() => {
+            window.location.reload();
+          }, 3000);
+        } else {
+          const error = await response.text();
+          showToast(`导入失败: ${error}`, 'danger');
+        }
+      } catch (error) {
+        console.error('导入备份失败:', error);
+        showToast('导入备份失败', 'danger');
+      }
+    }
+
+    // ==================== 商品管理功能 ====================
+
+    // 加载商品列表
+    async function loadItems() {
+      try {
+        // 先加载Cookie列表用于筛选
+        await loadCookieFilter();
+
+        // 加载商品列表
+        const selectedCookie = document.getElementById('itemCookieFilter').value;
+        if (selectedCookie) {
+          await loadItemsByCookie();
+        } else {
+          await loadAllItems();
+        }
+      } catch (error) {
+        console.error('加载商品列表失败:', error);
+        showToast('加载商品列表失败', 'danger');
+      }
+    }
+
+    // 加载Cookie筛选选项
+    async function loadCookieFilter() {
+      try {
+        const response = await fetch(`${apiBase}/cookies/details`, {
+          headers: {
+            'Authorization': `Bearer ${authToken}`
+          }
+        });
+
+        if (response.ok) {
+          const accounts = await response.json();
+          const select = document.getElementById('itemCookieFilter');
+
+          // 清空现有选项（保留"所有账号"）
+          select.innerHTML = '<option value="">所有账号</option>';
+
+          if (accounts.length === 0) {
+            const option = document.createElement('option');
+            option.value = '';
+            option.textContent = '❌ 暂无账号';
+            option.disabled = true;
+            select.appendChild(option);
+            return;
+          }
+
+          // 分组显示：先显示启用的账号，再显示禁用的账号
+          const enabledAccounts = accounts.filter(account => {
+            const enabled = account.enabled === undefined ? true : account.enabled;
+            return enabled;
+          });
+          const disabledAccounts = accounts.filter(account => {
+            const enabled = account.enabled === undefined ? true : account.enabled;
+            return !enabled;
+          });
+
+          // 添加启用的账号
+          enabledAccounts.forEach(account => {
+            const option = document.createElement('option');
+            option.value = account.id;
+            option.textContent = `🟢 ${account.id}`;
+            select.appendChild(option);
+          });
+
+          // 添加禁用的账号
+          if (disabledAccounts.length > 0) {
+            // 添加分隔线
+            if (enabledAccounts.length > 0) {
+              const separator = document.createElement('option');
+              separator.value = '';
+              separator.textContent = '────────────────';
+              separator.disabled = true;
+              select.appendChild(separator);
+            }
+
+            disabledAccounts.forEach(account => {
+              const option = document.createElement('option');
+              option.value = account.id;
+              option.textContent = `🔴 ${account.id} (已禁用)`;
+              select.appendChild(option);
+            });
+          }
+        }
+      } catch (error) {
+        console.error('加载Cookie列表失败:', error);
+        showToast('加载账号列表失败', 'danger');
+      }
+    }
+
+    // 加载所有商品
+    async function loadAllItems() {
+      try {
+        const response = await fetch(`${apiBase}/items`, {
+          headers: {
+            'Authorization': `Bearer ${authToken}`
+          }
+        });
+
+        if (response.ok) {
+          const data = await response.json();
+          displayItems(data.items);
+        } else {
+          throw new Error('获取商品列表失败');
+        }
+      } catch (error) {
+        console.error('加载商品列表失败:', error);
+        showToast('加载商品列表失败', 'danger');
+      }
+    }
+
+    // 按Cookie加载商品
+    async function loadItemsByCookie() {
+      const cookieId = document.getElementById('itemCookieFilter').value;
+
+      if (!cookieId) {
+        await loadAllItems();
+        return;
+      }
+
+      try {
+        const response = await fetch(`${apiBase}/items/cookie/${encodeURIComponent(cookieId)}`, {
+          headers: {
+            'Authorization': `Bearer ${authToken}`
+          }
+        });
+
+        if (response.ok) {
+          const data = await response.json();
+          displayItems(data.items);
+        } else {
+          throw new Error('获取商品列表失败');
+        }
+      } catch (error) {
+        console.error('加载商品列表失败:', error);
+        showToast('加载商品列表失败', 'danger');
+      }
+    }
+
+    // 显示商品列表
+    function displayItems(items) {
+      const tbody = document.getElementById('itemsTableBody');
+
+      if (!items || items.length === 0) {
+        tbody.innerHTML = '<tr><td colspan="7" class="text-center text-muted">暂无商品数据</td></tr>';
+        // 重置选择状态
+        const selectAllCheckbox = document.getElementById('selectAllItems');
+        if (selectAllCheckbox) {
+          selectAllCheckbox.checked = false;
+          selectAllCheckbox.indeterminate = false;
+        }
+        updateBatchDeleteButton();
+        return;
+      }
+
+      const itemsHtml = items.map(item => {
+        // 处理商品标题显示
+        let itemTitleDisplay = item.item_title || '未设置';
+        if (itemTitleDisplay.length > 30) {
+          itemTitleDisplay = itemTitleDisplay.substring(0, 30) + '...';
+        }
+
+        // 处理商品详情显示
+        let itemDetailDisplay = '未设置';
+        if (item.item_detail) {
+          try {
+            // 尝试解析JSON并提取有用信息
+            const detail = JSON.parse(item.item_detail);
+            if (detail.content) {
+              itemDetailDisplay = detail.content.substring(0, 50) + (detail.content.length > 50 ? '...' : '');
+            } else {
+              // 如果是纯文本或其他格式，直接显示前50个字符
+              itemDetailDisplay = item.item_detail.substring(0, 50) + (item.item_detail.length > 50 ? '...' : '');
+            }
+          } catch (e) {
+            // 如果不是JSON格式，直接显示前50个字符
+            itemDetailDisplay = item.item_detail.substring(0, 50) + (item.item_detail.length > 50 ? '...' : '');
+          }
+        }
+
+        return `
+          <tr>
+            <td>
+              <input type="checkbox" name="itemCheckbox"
+                     data-cookie-id="${escapeHtml(item.cookie_id)}"
+                     data-item-id="${escapeHtml(item.item_id)}"
+                     onchange="updateSelectAllState()">
+            </td>
+            <td>${escapeHtml(item.cookie_id)}</td>
+            <td>${escapeHtml(item.item_id)}</td>
+            <td title="${escapeHtml(item.item_title || '未设置')}">${escapeHtml(itemTitleDisplay)}</td>
+            <td title="${escapeHtml(item.item_detail || '未设置')}">${escapeHtml(itemDetailDisplay)}</td>
+            <td>${formatDateTime(item.updated_at)}</td>
+            <td>
+              <div class="btn-group" role="group">
+                <button class="btn btn-sm btn-outline-primary" onclick="editItem('${escapeHtml(item.cookie_id)}', '${escapeHtml(item.item_id)}')" title="编辑详情">
+                  <i class="bi bi-pencil"></i>
+                </button>
+                <button class="btn btn-sm btn-outline-danger" onclick="deleteItem('${escapeHtml(item.cookie_id)}', '${escapeHtml(item.item_id)}', '${escapeHtml(item.item_title || item.item_id)}')" title="删除">
+                  <i class="bi bi-trash"></i>
+                </button>
+              </div>
+            </td>
+          </tr>
+        `;
+      }).join('');
+
+      // 更新表格内容
+      tbody.innerHTML = itemsHtml;
+
+      // 重置选择状态
+      const selectAllCheckbox = document.getElementById('selectAllItems');
+      if (selectAllCheckbox) {
+        selectAllCheckbox.checked = false;
+        selectAllCheckbox.indeterminate = false;
+      }
+      updateBatchDeleteButton();
+    }
+
+    // 刷新商品列表
+    async function refreshItems() {
+      await loadItems();
+      showToast('商品列表已刷新', 'success');
+    }
+
+    // 获取所有商品信息
+    async function getAllItemsFromAccount() {
+      const cookieSelect = document.getElementById('itemCookieFilter');
+      const selectedCookieId = cookieSelect.value;
+
+      if (!selectedCookieId) {
+        showToast('请先选择一个账号', 'warning');
+        return;
+      }
+
+      // 显示加载状态
+      const button = event.target;
+      const originalText = button.innerHTML;
+      button.innerHTML = '<i class="bi bi-hourglass-split me-1"></i>获取中...';
+      button.disabled = true;
+
+      try {
+        const response = await fetch(`${apiBase}/items/get-all-from-account`, {
+          method: 'POST',
+          headers: {
+            'Content-Type': 'application/json',
+            'Authorization': `Bearer ${authToken}`
+          },
+          body: JSON.stringify({
+            cookie_id: selectedCookieId
+          })
+        });
+
+        if (response.ok) {
+          const data = await response.json();
+          if (data.success) {
+            showToast(`成功获取商品信息，请查看控制台日志`, 'success');
+            // 刷新商品列表
+            await loadItems();
+          } else {
+            showToast(data.message || '获取商品信息失败', 'danger');
+          }
+        } else {
+          throw new Error(`HTTP ${response.status}`);
+        }
+      } catch (error) {
+        console.error('获取商品信息失败:', error);
+        showToast('获取商品信息失败', 'danger');
+      } finally {
+        // 恢复按钮状态
+        button.innerHTML = originalText;
+        button.disabled = false;
+      }
+    }
+
+    // 编辑商品详情
+    async function editItem(cookieId, itemId) {
+      try {
+        const response = await fetch(`${apiBase}/items/${encodeURIComponent(cookieId)}/${encodeURIComponent(itemId)}`, {
+          headers: {
+            'Authorization': `Bearer ${authToken}`
+          }
+        });
+
+        if (response.ok) {
+          const data = await response.json();
+          const item = data.item;
+
+          // 填充表单
+          document.getElementById('editItemCookieId').value = item.cookie_id;
+          document.getElementById('editItemId').value = item.item_id;
+          document.getElementById('editItemCookieIdDisplay').value = item.cookie_id;
+          document.getElementById('editItemIdDisplay').value = item.item_id;
+          document.getElementById('editItemDetail').value = item.item_detail || '';
+
+          // 显示模态框
+          const modal = new bootstrap.Modal(document.getElementById('editItemModal'));
+          modal.show();
+        } else {
+          throw new Error('获取商品详情失败');
+        }
+      } catch (error) {
+        console.error('获取商品详情失败:', error);
+        showToast('获取商品详情失败', 'danger');
+      }
+    }
+
+    // 保存商品详情
+    async function saveItemDetail() {
+      const cookieId = document.getElementById('editItemCookieId').value;
+      const itemId = document.getElementById('editItemId').value;
+      const itemDetail = document.getElementById('editItemDetail').value.trim();
+
+      if (!itemDetail) {
+        showToast('请输入商品详情', 'warning');
+        return;
+      }
+
+      try {
+        const response = await fetch(`${apiBase}/items/${encodeURIComponent(cookieId)}/${encodeURIComponent(itemId)}`, {
+          method: 'PUT',
+          headers: {
+            'Content-Type': 'application/json',
+            'Authorization': `Bearer ${authToken}`
+          },
+          body: JSON.stringify({
+            item_detail: itemDetail
+          })
+        });
+
+        if (response.ok) {
+          showToast('商品详情更新成功', 'success');
+
+          // 关闭模态框
+          const modal = bootstrap.Modal.getInstance(document.getElementById('editItemModal'));
+          modal.hide();
+
+          // 刷新列表
+          await loadItems();
+        } else {
+          const error = await response.text();
+          showToast(`更新失败: ${error}`, 'danger');
+        }
+      } catch (error) {
+        console.error('更新商品详情失败:', error);
+        showToast('更新商品详情失败', 'danger');
+      }
+    }
+
+    // 删除商品信息
+    async function deleteItem(cookieId, itemId, itemTitle) {
+      try {
+        // 确认删除
+        const confirmed = confirm(`确定要删除商品信息吗？\n\n商品ID: ${itemId}\n商品标题: ${itemTitle || '未设置'}\n\n此操作不可撤销！`);
+        if (!confirmed) {
+          return;
+        }
+
+        const response = await fetch(`${apiBase}/items/${encodeURIComponent(cookieId)}/${encodeURIComponent(itemId)}`, {
+          method: 'DELETE',
+          headers: {
+            'Authorization': `Bearer ${authToken}`
+          }
+        });
+
+        if (response.ok) {
+          showToast('商品信息删除成功', 'success');
+          // 刷新列表
+          await loadItems();
+        } else {
+          const error = await response.text();
+          showToast(`删除失败: ${error}`, 'danger');
+        }
+      } catch (error) {
+        console.error('删除商品信息失败:', error);
+        showToast('删除商品信息失败', 'danger');
+      }
+    }
+
+    // 批量删除商品信息
+    async function batchDeleteItems() {
+      try {
+        // 获取所有选中的复选框
+        const checkboxes = document.querySelectorAll('input[name="itemCheckbox"]:checked');
+        if (checkboxes.length === 0) {
+          showToast('请选择要删除的商品', 'warning');
+          return;
+        }
+
+        // 确认删除
+        const confirmed = confirm(`确定要删除选中的 ${checkboxes.length} 个商品信息吗？\n\n此操作不可撤销！`);
+        if (!confirmed) {
+          return;
+        }
+
+        // 构造删除列表
+        const itemsToDelete = Array.from(checkboxes).map(checkbox => {
+          const row = checkbox.closest('tr');
+          return {
+            cookie_id: checkbox.dataset.cookieId,
+            item_id: checkbox.dataset.itemId
+          };
+        });
+
+        const response = await fetch(`${apiBase}/items/batch`, {
+          method: 'DELETE',
+          headers: {
+            'Content-Type': 'application/json',
+            'Authorization': `Bearer ${authToken}`
+          },
+          body: JSON.stringify({ items: itemsToDelete })
+        });
+
+        if (response.ok) {
+          const result = await response.json();
+          showToast(`批量删除完成: 成功 ${result.success_count} 个，失败 ${result.failed_count} 个`, 'success');
+          // 刷新列表
+          await loadItems();
+        } else {
+          const error = await response.text();
+          showToast(`批量删除失败: ${error}`, 'danger');
+        }
+      } catch (error) {
+        console.error('批量删除商品信息失败:', error);
+        showToast('批量删除商品信息失败', 'danger');
+      }
+    }
+
+    // 全选/取消全选
+    function toggleSelectAll(selectAllCheckbox) {
+      const checkboxes = document.querySelectorAll('input[name="itemCheckbox"]');
+      checkboxes.forEach(checkbox => {
+        checkbox.checked = selectAllCheckbox.checked;
+      });
+      updateBatchDeleteButton();
+    }
+
+    // 更新全选状态
+    function updateSelectAllState() {
+      const checkboxes = document.querySelectorAll('input[name="itemCheckbox"]');
+      const checkedCheckboxes = document.querySelectorAll('input[name="itemCheckbox"]:checked');
+      const selectAllCheckbox = document.getElementById('selectAllItems');
+
+      if (checkboxes.length === 0) {
+        selectAllCheckbox.checked = false;
+        selectAllCheckbox.indeterminate = false;
+      } else if (checkedCheckboxes.length === checkboxes.length) {
+        selectAllCheckbox.checked = true;
+        selectAllCheckbox.indeterminate = false;
+      } else if (checkedCheckboxes.length > 0) {
+        selectAllCheckbox.checked = false;
+        selectAllCheckbox.indeterminate = true;
+      } else {
+        selectAllCheckbox.checked = false;
+        selectAllCheckbox.indeterminate = false;
+      }
+
+      updateBatchDeleteButton();
+    }
+
+    // 更新批量删除按钮状态
+    function updateBatchDeleteButton() {
+      const checkedCheckboxes = document.querySelectorAll('input[name="itemCheckbox"]:checked');
+      const batchDeleteBtn = document.getElementById('batchDeleteBtn');
+
+      if (checkedCheckboxes.length > 0) {
+        batchDeleteBtn.disabled = false;
+        batchDeleteBtn.innerHTML = `<i class="bi bi-trash"></i> 批量删除 (${checkedCheckboxes.length})`;
+      } else {
+        batchDeleteBtn.disabled = true;
+        batchDeleteBtn.innerHTML = '<i class="bi bi-trash"></i> 批量删除';
+      }
+    }
+
+    // 格式化日期时间
+    function formatDateTime(dateString) {
+      if (!dateString) return '未知';
+      const date = new Date(dateString);
+      return date.toLocaleString('zh-CN');
+    }
+
+    // HTML转义函数
+    function escapeHtml(text) {
+      if (!text) return '';
+      const div = document.createElement('div');
+      div.textContent = text;
+      return div.innerHTML;
+    }
+
+    // ==================== 日志管理功能 ====================
+
+    window.autoRefreshInterval = null;
+    window.allLogs = [];
+    window.filteredLogs = [];
+
+    // 刷新日志
+    async function refreshLogs() {
+      try {
+        const lines = document.getElementById('logLines').value;
+
+        const response = await fetch(`${apiBase}/logs?lines=${lines}`, {
+          headers: {
+            'Authorization': `Bearer ${authToken}`
+          }
+        });
+
+        if (response.ok) {
+          const data = await response.json();
+          window.allLogs = data.logs || [];
+          window.filteredLogs = window.allLogs; // 不再过滤，直接显示所有日志
+          displayLogs();
+          updateLogStats();
+          showToast('日志已刷新', 'success');
+        } else {
+          throw new Error(`HTTP ${response.status}`);
+        }
+      } catch (error) {
+        console.error('刷新日志失败:', error);
+        showToast('刷新日志失败', 'danger');
+      }
+    }
+
+
+
+    // 显示日志
+    function displayLogs() {
+      const container = document.getElementById('logContainer');
+
+      if (window.filteredLogs.length === 0) {
+        container.innerHTML = `
+          <div class="text-center p-4 text-muted">
+            <i class="bi bi-file-text fs-1"></i>
+            <p class="mt-2">暂无日志数据</p>
+          </div>
+        `;
+        return;
+      }
+
+      const logsHtml = window.filteredLogs.map(log => {
+        const timestamp = formatLogTimestamp(log.timestamp);
+        const levelClass = log.level || 'INFO';
+
+        return `
+          <div class="log-entry ${levelClass}">
+            <span class="log-timestamp">${timestamp}</span>
+            <span class="log-level">[${log.level}]</span>
+            <span class="log-source">${log.source}:</span>
+            <span class="log-message">${escapeHtml(log.message)}</span>
+          </div>
+        `;
+      }).join('');
+
+      container.innerHTML = logsHtml;
+
+      // 滚动到底部
+      container.scrollTop = container.scrollHeight;
+    }
+
+    // 格式化日志时间戳
+    function formatLogTimestamp(timestamp) {
+      if (!timestamp) return '';
+      const date = new Date(timestamp);
+      return date.toLocaleString('zh-CN', {
+        year: 'numeric',
+        month: '2-digit',
+        day: '2-digit',
+        hour: '2-digit',
+        minute: '2-digit',
+        second: '2-digit',
+        fractionalSecondDigits: 3
+      });
+    }
+
+    // 更新日志统计信息
+    function updateLogStats() {
+      document.getElementById('logCount').textContent = `${window.filteredLogs.length} 条日志`;
+      document.getElementById('lastUpdate').textContent = new Date().toLocaleTimeString('zh-CN');
+    }
+
+    // 清空日志显示
+    function clearLogsDisplay() {
+      window.allLogs = [];
+      window.filteredLogs = [];
+      document.getElementById('logContainer').innerHTML = `
+        <div class="text-center p-4 text-muted">
+          <i class="bi bi-file-text fs-1"></i>
+          <p class="mt-2">日志显示已清空</p>
+        </div>
+      `;
+      updateLogStats();
+      showToast('日志显示已清空', 'info');
+    }
+
+    // 切换自动刷新
+    function toggleAutoRefresh() {
+      const button = document.querySelector('#autoRefreshText');
+      const icon = button.previousElementSibling;
+
+      if (window.autoRefreshInterval) {
+        // 停止自动刷新
+        clearInterval(window.autoRefreshInterval);
+        window.autoRefreshInterval = null;
+        button.textContent = '开启自动刷新';
+        icon.className = 'bi bi-play-circle me-1';
+        showToast('自动刷新已停止', 'info');
+      } else {
+        // 开启自动刷新
+        window.autoRefreshInterval = setInterval(refreshLogs, 5000); // 每5秒刷新一次
+        button.textContent = '停止自动刷新';
+        icon.className = 'bi bi-pause-circle me-1';
+        showToast('自动刷新已开启（每5秒）', 'success');
+
+        // 立即刷新一次
+        refreshLogs();
+      }
+    }
+
+    // 清空服务器日志
+    async function clearLogsServer() {
+      if (!confirm('确定要清空服务器端的所有日志吗？此操作不可恢复！')) {
+        return;
+      }
+
+      try {
+        const response = await fetch(`${apiBase}/logs/clear`, {
+          method: 'POST',
+          headers: {
+            'Authorization': `Bearer ${authToken}`
+          }
+        });
+
+        if (response.ok) {
+          const data = await response.json();
+          if (data.success) {
+            window.allLogs = [];
+            window.filteredLogs = [];
+            displayLogs();
+            updateLogStats();
+            showToast('服务器日志已清空', 'success');
+          } else {
+            showToast(data.message || '清空失败', 'danger');
+          }
+        } else {
+          throw new Error(`HTTP ${response.status}`);
+        }
+      } catch (error) {
+        console.error('清空服务器日志失败:', error);
+        showToast('清空服务器日志失败', 'danger');
+      }
+    }
+
+    // 显示日志统计信息
+    async function showLogStats() {
+      try {
+        const response = await fetch(`${apiBase}/logs/stats`, {
+          headers: {
+            'Authorization': `Bearer ${authToken}`
+          }
+        });
+
+        if (response.ok) {
+          const data = await response.json();
+          if (data.success) {
+            const stats = data.stats;
+
+            let statsHtml = `
+              <div class="row">
+                <div class="col-md-6">
+                  <h6>总体统计</h6>
+                  <ul class="list-unstyled">
+                    <li>总日志数: <strong>${stats.total_logs}</strong></li>
+                    <li>最大容量: <strong>${stats.max_capacity}</strong></li>
+                    <li>使用率: <strong>${((stats.total_logs / stats.max_capacity) * 100).toFixed(1)}%</strong></li>
+                  </ul>
+                </div>
+                <div class="col-md-6">
+                  <h6>级别分布</h6>
+                  <ul class="list-unstyled">
+            `;
+
+            for (const [level, count] of Object.entries(stats.level_counts || {})) {
+              const percentage = ((count / stats.total_logs) * 100).toFixed(1);
+              statsHtml += `<li>${level}: <strong>${count}</strong> (${percentage}%)</li>`;
+            }
+
+            statsHtml += `
+                  </ul>
+                </div>
+              </div>
+              <div class="row mt-3">
+                <div class="col-12">
+                  <h6>来源分布</h6>
+                  <div class="row">
+            `;
+
+            const sources = Object.entries(stats.source_counts || {});
+            sources.forEach(([source, count], index) => {
+              if (index % 2 === 0) statsHtml += '<div class="col-md-6"><ul class="list-unstyled">';
+              const percentage = ((count / stats.total_logs) * 100).toFixed(1);
+              statsHtml += `<li>${source}: <strong>${count}</strong> (${percentage}%)</li>`;
+              if (index % 2 === 1 || index === sources.length - 1) statsHtml += '</ul></div>';
+            });
+
+            statsHtml += `
+                  </div>
+                </div>
+              </div>
+            `;
+
+            // 显示模态框
+            const modalHtml = `
+              <div class="modal fade" id="logStatsModal" tabindex="-1">
+                <div class="modal-dialog modal-lg">
+                  <div class="modal-content">
+                    <div class="modal-header">
+                      <h5 class="modal-title">日志统计信息</h5>
+                      <button type="button" class="btn-close" data-bs-dismiss="modal"></button>
+                    </div>
+                    <div class="modal-body">
+                      ${statsHtml}
+                    </div>
+                    <div class="modal-footer">
+                      <button type="button" class="btn btn-secondary" data-bs-dismiss="modal">关闭</button>
+                    </div>
+                  </div>
+                </div>
+              </div>
+            `;
+
+            // 移除旧的模态框
+            const oldModal = document.getElementById('logStatsModal');
+            if (oldModal) oldModal.remove();
+
+            // 添加新的模态框
+            document.body.insertAdjacentHTML('beforeend', modalHtml);
+
+            // 显示模态框
+            const modal = new bootstrap.Modal(document.getElementById('logStatsModal'));
+            modal.show();
+
+          } else {
+            showToast(data.message || '获取统计信息失败', 'danger');
+          }
+        } else {
+          throw new Error(`HTTP ${response.status}`);
+        }
+      } catch (error) {
+        console.error('获取日志统计失败:', error);
+        showToast('获取日志统计失败', 'danger');
+      }
+    }
+
+
+
+  </script>
+
+</body>
+</html>
\ No newline at end of file
diff --git a/static/login.html b/static/login.html
new file mode 100644
index 0000000..0391cff
--- /dev/null
+++ b/static/login.html
@@ -0,0 +1,281 @@
+<!DOCTYPE html>
+<html lang="zh-CN">
+<head>
+  <meta charset="UTF-8">
+  <meta name="viewport" content="width=device-width, initial-scale=1.0">
+  <title>登录 - 闲鱼自动回复管理系统</title>
+  <link rel="stylesheet" href="https://cdn.jsdelivr.net/npm/bootstrap@5.3.2/dist/css/bootstrap.min.css">
+  <link rel="stylesheet" href="https://cdn.jsdelivr.net/npm/bootstrap-icons@1.11.0/font/bootstrap-icons.css">
+  <style>
+    :root {
+      --primary-color: #0d6efd;
+      --secondary-color: #6c757d;
+      --success-color: #198754;
+      --danger-color: #dc3545;
+    }
+    
+    body {
+      font-family: 'Segoe UI', Tahoma, Geneva, Verdana, sans-serif;
+      background: linear-gradient(135deg, #667eea 0%, #764ba2 100%);
+      min-height: 100vh;
+      display: flex;
+      align-items: center;
+      justify-content: center;
+    }
+    
+    .login-container {
+      background: white;
+      border-radius: 20px;
+      box-shadow: 0 20px 40px rgba(0,0,0,0.1);
+      overflow: hidden;
+      width: 100%;
+      max-width: 400px;
+    }
+    
+    .login-header {
+      background: var(--primary-color);
+      color: white;
+      padding: 30px;
+      text-align: center;
+    }
+    
+    .login-header h2 {
+      margin: 0;
+      font-weight: 600;
+    }
+    
+    .login-header p {
+      margin: 10px 0 0 0;
+      opacity: 0.9;
+    }
+    
+    .login-body {
+      padding: 40px 30px;
+    }
+    
+    .form-control {
+      border-radius: 10px;
+      border: 2px solid #e9ecef;
+      padding: 12px 15px;
+      font-size: 16px;
+      transition: all 0.3s ease;
+    }
+    
+    .form-control:focus {
+      border-color: var(--primary-color);
+      box-shadow: 0 0 0 0.25rem rgba(13, 110, 253, 0.25);
+    }
+    
+    .btn-login {
+      background: var(--primary-color);
+      border: none;
+      border-radius: 10px;
+      padding: 12px;
+      font-size: 16px;
+      font-weight: 600;
+      width: 100%;
+      transition: all 0.3s ease;
+    }
+    
+    .btn-login:hover {
+      background: #0b5ed7;
+      transform: translateY(-2px);
+    }
+    
+    .input-group {
+      position: relative;
+      margin-bottom: 20px;
+    }
+    
+    .input-group i {
+      position: absolute;
+      left: 15px;
+      top: 50%;
+      transform: translateY(-50%);
+      color: var(--secondary-color);
+      z-index: 10;
+    }
+    
+    .input-group .form-control {
+      padding-left: 45px;
+    }
+    
+    .alert {
+      border-radius: 10px;
+      border: none;
+    }
+    
+    .loading {
+      display: none;
+    }
+    
+    .loading.show {
+      display: inline-block;
+    }
+  </style>
+</head>
+<body>
+  <div class="login-container">
+    <div class="login-header">
+      <i class="bi bi-chat-dots-fill fs-1 mb-3"></i>
+      <h2>闲鱼自动回复</h2>
+      <p>管理系统登录</p>
+    </div>
+    
+    <div class="login-body">
+      <form id="loginForm">
+        <div class="input-group">
+          <i class="bi bi-person-fill"></i>
+          <input type="text" class="form-control" id="username" placeholder="请输入用户名" required>
+        </div>
+
+        <div class="input-group">
+          <i class="bi bi-lock-fill"></i>
+          <input type="password" class="form-control" id="password" placeholder="请输入密码" required>
+        </div>
+        
+        <div id="errorAlert" class="alert alert-danger d-none" role="alert">
+          <i class="bi bi-exclamation-triangle-fill me-2"></i>
+          <span id="errorMessage"></span>
+        </div>
+        
+        <button type="submit" class="btn btn-primary btn-login">
+          <span class="loading spinner-border spinner-border-sm me-2" role="status"></span>
+          <span id="loginText">登录</span>
+        </button>
+      </form>
+
+      <!-- 默认账号提示 -->
+      <div class="mt-4 p-3 bg-light rounded-3">
+        <div class="text-center">
+          <small class="text-muted">
+            <i class="bi bi-info-circle me-1"></i>
+            默认登录账号
+          </small>
+        </div>
+        <div class="mt-2">
+          <div class="d-flex justify-content-between align-items-center mb-1">
+            <small class="text-muted">用户名：</small>
+            <code class="bg-white px-2 py-1 rounded">admin</code>
+          </div>
+          <div class="d-flex justify-content-between align-items-center">
+            <small class="text-muted">密码：</small>
+            <code class="bg-white px-2 py-1 rounded">admin123</code>
+          </div>
+        </div>
+        <div class="text-center mt-2">
+          <button type="button" class="btn btn-sm btn-outline-primary" onclick="fillDefaultCredentials()">
+            <i class="bi bi-arrow-down-circle me-1"></i>
+            使用默认账号
+          </button>
+        </div>
+      </div>
+
+    </div>
+  </div>
+
+  <script src="https://cdn.jsdelivr.net/npm/bootstrap@5.3.2/dist/js/bootstrap.bundle.min.js"></script>
+  <script>
+    const loginForm = document.getElementById('loginForm');
+    const errorAlert = document.getElementById('errorAlert');
+    const errorMessage = document.getElementById('errorMessage');
+    const loading = document.querySelector('.loading');
+    const loginText = document.getElementById('loginText');
+    
+    function showError(message) {
+      errorMessage.textContent = message;
+      errorAlert.classList.remove('d-none');
+    }
+    
+    function hideError() {
+      errorAlert.classList.add('d-none');
+    }
+    
+    function setLoading(isLoading) {
+      if (isLoading) {
+        loading.classList.add('show');
+        loginText.textContent = '登录中...';
+        loginForm.querySelector('button').disabled = true;
+      } else {
+        loading.classList.remove('show');
+        loginText.textContent = '登录';
+        loginForm.querySelector('button').disabled = false;
+      }
+    }
+
+    // 填充默认登录凭据
+    function fillDefaultCredentials() {
+      document.getElementById('username').value = 'admin';
+      document.getElementById('password').value = 'admin123';
+      hideError();
+
+      // 添加一个小动画效果
+      const usernameInput = document.getElementById('username');
+      const passwordInput = document.getElementById('password');
+
+      usernameInput.style.backgroundColor = '#e3f2fd';
+      passwordInput.style.backgroundColor = '#e3f2fd';
+
+      setTimeout(() => {
+        usernameInput.style.backgroundColor = '';
+        passwordInput.style.backgroundColor = '';
+      }, 1000);
+    }
+    
+    loginForm.addEventListener('submit', async (e) => {
+      e.preventDefault();
+      hideError();
+      setLoading(true);
+      
+      const username = document.getElementById('username').value;
+      const password = document.getElementById('password').value;
+      
+      try {
+        const response = await fetch('/login', {
+          method: 'POST',
+          headers: {
+            'Content-Type': 'application/json',
+          },
+          body: JSON.stringify({ username, password })
+        });
+        
+        const result = await response.json();
+        
+        if (result.success) {
+          // 保存token到localStorage
+          localStorage.setItem('auth_token', result.token);
+          // 跳转到管理页面
+          window.location.href = '/admin';
+        } else {
+          showError(result.message);
+        }
+      } catch (error) {
+        showError('登录失败，请检查网络连接');
+      } finally {
+        setLoading(false);
+      }
+    });
+    
+    // 检查是否已经登录
+    const token = localStorage.getItem('auth_token');
+    if (token) {
+      // 验证token是否有效
+      fetch('/verify', {
+        headers: {
+          'Authorization': `Bearer ${token}`
+        }
+      })
+      .then(response => response.json())
+      .then(result => {
+        if (result.authenticated) {
+          window.location.href = '/admin';
+        }
+      })
+      .catch(() => {
+        // token无效，清除
+        localStorage.removeItem('auth_token');
+      });
+    }
+  </script>
+</body>
+</html>
diff --git a/static/xianyu_js_version_2.js b/static/xianyu_js_version_2.js
new file mode 100644
index 0000000..7c8b7d7
--- /dev/null
+++ b/static/xianyu_js_version_2.js
@@ -0,0 +1,568 @@
+const crypto = require('crypto')
+
+const generate_mid = () => {
+    return "" + Math.floor(1e3 * Math.random()) + new Date().getTime() + " 0"
+}
+
+const generate_uuid = () => {
+    return "-" + Date.now() + "1"
+}
+
+const generate_device_id = (user_id) => {
+    for (var ee, et = "0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz".split(""), en = [], eo = Math.random, ei = 0; ei < 36; ei++)
+        8 === ei || 13 === ei || 18 === ei || 23 === ei ? en[ei] = "-" : 14 === ei ? en[ei] = "4" : (ee = 0 | 16 * eo(),
+            en[ei] = et[19 === ei ? 3 & ee | 8 : ee]);
+    return en.join("") + "-" + user_id
+}
+
+
+const generate_sign = (t, token, data) => {
+    const j = t
+    const h = 34839810
+    const msg = token + "&" + j + "&" + h + "&" + data
+    const md5 = crypto.createHash('md5')
+    md5.update(msg)
+    return md5.digest('hex')
+}
+eM = new TextDecoder("utf-8");
+eL = null
+var sv = Array(4096);
+
+function sg() {
+    var ee, et = eI[aG++];
+    if (!(et >= 160) || !(et < 192))
+        return aG--,
+            sy(a5());
+    if (et -= 160,
+    aX >= aG)
+        return eR.slice(aG - aq, (aG += et) - aq);
+    if (!(0 == aX && eO < 180))
+        return se(et);
+    var en = (et << 5 ^ (et > 1 ? eZ.getUint16(aG) : et > 0 ? eI[aG] : 0)) & 4095
+        , eo = sv[en]
+        , ei = aG
+        , ec = aG + et - 3
+        , eu = 0;
+    if (eo && eo.bytes == et) {
+        for (; ei < ec;) {
+            if ((ee = eZ.getUint32(ei)) != eo[eu++]) {
+                ei = 1879048192;
+                break
+            }
+            ei += 4
+        }
+        for (ec += 3; ei < ec;)
+            if ((ee = eI[ei++]) != eo[eu++]) {
+                ei = 1879048192;
+                break
+            }
+        if (ei === ec)
+            return aG = ei,
+                eo.string;
+        ec -= 3,
+            ei = aG
+    }
+    for (eo = [],
+             sv[en] = eo,
+             eo.bytes = et; ei < ec;)
+        ee = eZ.getUint32(ei),
+            eo.push(ee),
+            ei += 4;
+    for (ec += 3; ei < ec;)
+        ee = eI[ei++],
+            eo.push(ee);
+    var ed = et < 16 ? su(et) : sl(et);
+    return null != ed ? eo.string = ed : eo.string = se(et)
+}
+
+function sy(ee) {
+    if ("string" == typeof ee)
+        return ee;
+    if ("number" == typeof ee || "boolean" == typeof ee || "bigint" == typeof ee)
+        return ee.toString();
+    if (null == ee)
+        return ee + "";
+    throw Error("Invalid property type for record", typeof ee)
+}
+
+r9 = function (ee) {
+    return atob(rW(ee))
+}
+rW = function (ee) {
+    return ee.replace(/[^A-Za-z0-9\+\/]/g, "")
+}
+aW = {
+    "useRecords": false,
+    "mapsAsObjects": true
+}
+aJ = false
+eP = []
+
+function a3(ee) {
+    if (!aW.trusted && !aJ) {
+        var et, en, eo = eP.sharedLength || 0;
+        eo < eP.length && (eP.length = eo)
+    }
+    if (aW.randomAccessStructure && eI[aG] < 64 && eI[aG] >= 32 && ej ? (et = ej(eI, aG, eO, aW),
+        eI = null,
+    !(ee && ee.lazy) && et && (et = et.toJSON()),
+        aG = eO) : et = a5(),
+    eD && (aG = eD.postBundlePosition,
+        eD = null),
+    aJ && (eP.restoreStructures = null),
+    aG == eO)
+        eP && eP.restoreStructures && a4(),
+            eP = null,
+            eI = null,
+        eL && (eL = null);
+    else if (aG > eO)
+        throw Error("Unexpected end of MessagePack data");
+    else if (!aJ) {
+        try {
+            en = JSON.stringify(et, function (ee, et) {
+                return "bigint" == typeof et ? "".concat(et, "n") : et
+            }).slice(0, 100)
+        } catch (ee) {
+            en = "(JSON view not available " + ee + ")"
+        }
+        throw Error("Data read, but end of buffer not reached " + en)
+    }
+    return et
+
+}
+
+function so(ee) {
+    if (ee < 16 && (et = su(ee)))
+        return et;
+    if (ee > 64 && eM)
+        return eM.decode(eI.subarray(aG, aG += ee));
+    var et, en = aG + ee, eo = [];
+    for (et = ""; aG < en;) {
+        var ei = eI[aG++];
+        if ((128 & ei) === 0)
+            eo.push(ei);
+        else if ((224 & ei) === 192) {
+            var ec = 63 & eI[aG++];
+            eo.push((31 & ei) << 6 | ec)
+        } else if ((240 & ei) === 224) {
+            var eu = 63 & eI[aG++]
+                , ed = 63 & eI[aG++];
+            eo.push((31 & ei) << 12 | eu << 6 | ed)
+        } else if ((248 & ei) === 240) {
+            var ef = (7 & ei) << 18 | (63 & eI[aG++]) << 12 | (63 & eI[aG++]) << 6 | 63 & eI[aG++];
+            ef > 65535 && (ef -= 65536,
+                eo.push(ef >>> 10 & 1023 | 55296),
+                ef = 56320 | 1023 & ef),
+                eo.push(ef)
+        } else
+            eo.push(ei);
+        eo.length >= 4096 && (et += sc.apply(String, eo),
+            eo.length = 0)
+    }
+    return eo.length > 0 && (et += sc.apply(String, eo)),
+        et
+}
+
+se = so;
+var sc = String.fromCharCode;
+
+function sl(ee) {
+    for (var et = aG, en = Array(ee), eo = 0; eo < ee; eo++) {
+        var ei = eI[aG++];
+        if ((128 & ei) > 0) {
+            aG = et;
+            return
+        }
+        en[eo] = ei
+    }
+    return sc.apply(String, en)
+}
+
+function su(ee) {
+    if (ee < 4) {
+        if (ee < 2) {
+            if (0 === ee)
+                return "";
+            var et = eI[aG++];
+            if ((128 & et) > 1) {
+                aG -= 1;
+                return
+            }
+            return sc(et)
+        }
+        var en = eI[aG++]
+            , eo = eI[aG++];
+        if ((128 & en) > 0 || (128 & eo) > 0) {
+            aG -= 2;
+            return
+        }
+        if (ee < 3)
+            return sc(en, eo);
+        var ei = eI[aG++];
+        if ((128 & ei) > 0) {
+            aG -= 3;
+            return
+        }
+        return sc(en, eo, ei)
+    }
+    var ec = eI[aG++]
+        , eu = eI[aG++]
+        , ed = eI[aG++]
+        , ef = eI[aG++];
+    if ((128 & ec) > 0 || (128 & eu) > 0 || (128 & ed) > 0 || (128 & ef) > 0) {
+        aG -= 4;
+        return
+    }
+    if (ee < 6) {
+        if (4 === ee)
+            return sc(ec, eu, ed, ef);
+        var ep = eI[aG++];
+        if ((128 & ep) > 0) {
+            aG -= 5;
+            return
+        }
+        return sc(ec, eu, ed, ef, ep)
+    }
+    if (ee < 8) {
+        var em = eI[aG++]
+            , eh = eI[aG++];
+        if ((128 & em) > 0 || (128 & eh) > 0) {
+            aG -= 6;
+            return
+        }
+        if (ee < 7)
+            return sc(ec, eu, ed, ef, em, eh);
+        var ev = eI[aG++];
+        if ((128 & ev) > 0) {
+            aG -= 7;
+            return
+        }
+        return sc(ec, eu, ed, ef, em, eh, ev)
+    }
+    var eg = eI[aG++]
+        , eC = eI[aG++]
+        , eS = eI[aG++]
+        , ew = eI[aG++];
+    if ((128 & eg) > 0 || (128 & eC) > 0 || (128 & eS) > 0 || (128 & ew) > 0) {
+        aG -= 8;
+        return
+    }
+    if (ee < 10) {
+        if (8 === ee)
+            return sc(ec, eu, ed, ef, eg, eC, eS, ew);
+        var eE = eI[aG++];
+        if ((128 & eE) > 0) {
+            aG -= 9;
+            return
+        }
+        return sc(ec, eu, ed, ef, eg, eC, eS, ew, eE)
+    }
+    if (ee < 12) {
+        var ek = eI[aG++]
+            , e_ = eI[aG++];
+        if ((128 & ek) > 0 || (128 & e_) > 0) {
+            aG -= 10;
+            return
+        }
+        if (ee < 11)
+            return sc(ec, eu, ed, ef, eg, eC, eS, ew, ek, e_);
+        var eT = eI[aG++];
+        if ((128 & eT) > 0) {
+            aG -= 11;
+            return
+        }
+        return sc(ec, eu, ed, ef, eg, eC, eS, ew, ek, e_, eT)
+    }
+    var eN = eI[aG++]
+        , eM = eI[aG++]
+        , eO = eI[aG++]
+        , eP = eI[aG++];
+    if ((128 & eN) > 0 || (128 & eM) > 0 || (128 & eO) > 0 || (128 & eP) > 0) {
+        aG -= 12;
+        return
+    }
+    if (ee < 14) {
+        if (12 === ee)
+            return sc(ec, eu, ed, ef, eg, eC, eS, ew, eN, eM, eO, eP);
+        var eR = eI[aG++];
+        if ((128 & eR) > 0) {
+            aG -= 13;
+            return
+        }
+        return sc(ec, eu, ed, ef, eg, eC, eS, ew, eN, eM, eO, eP, eR)
+    }
+    var eD = eI[aG++]
+        , eL = eI[aG++];
+    if ((128 & eD) > 0 || (128 & eL) > 0) {
+        aG -= 14;
+        return
+    }
+    if (ee < 15)
+        return sc(ec, eu, ed, ef, eg, eC, eS, ew, eN, eM, eO, eP, eD, eL);
+    var eZ = eI[aG++];
+    if ((128 & eZ) > 0) {
+        aG -= 15;
+        return
+    }
+    return sc(ec, eu, ed, ef, eg, eC, eS, ew, eN, eM, eO, eP, eD, eL, eZ)
+}
+
+function ss(ee) {
+    if (aW.mapsAsObjects) {
+        for (var et = {}, en = 0; en < ee; en++) {
+            var eo = sg();
+            "__proto__" === eo && (eo = "__proto_"),
+                et[eo] = a5()
+        }
+        return et
+    }
+    for (var ei = new Map, ec = 0; ec < ee; ec++)
+        ei.set(a5(), a5());
+    return ei
+}
+
+function a5() {
+    var ee, et = eI[aG++];
+    if (et < 160) {
+        if (et < 128) {
+            if (et < 64)
+                return et;
+            var en = eP[63 & et] || aW.getStructures && a9()[63 & et];
+            return en ? (en.read || (en.read = a8(en, 63 & et)),
+                en.read()) : et
+        }
+        if (et < 144) {
+            if (et -= 128,
+                aW.mapsAsObjects) {
+                for (var eo = {}, ei = 0; ei < et; ei++) {
+                    var ec = sg();
+                    "__proto__" === ec && (ec = "__proto_"),
+                        eo[ec] = a5()
+                }
+                return eo
+            }
+            for (var eu = new Map, ed = 0; ed < et; ed++)
+                eu.set(a5(), a5());
+            return eu
+        }
+        for (var ef = Array(et -= 144), ep = 0; ep < et; ep++)
+            ef[ep] = a5();
+        return aW.freezeData ? Object.freeze(ef) : ef
+    }
+    if (et < 192) {
+        var em = et - 160;
+        if (aX >= aG)
+            return eR.slice(aG - aq, (aG += em) - aq);
+        if (0 == aX && eO < 140) {
+            var eh = em < 16 ? su(em) : sl(em);
+            if (null != eh)
+                return eh
+        }
+        return se(em)
+    }
+    switch (et) {
+        case 192:
+            return null;
+        case 193:
+            if (eD) {
+                if ((ee = a5()) > 0)
+                    return eD[1].slice(eD.position1, eD.position1 += ee);
+                return eD[0].slice(eD.position0, eD.position0 -= ee)
+            }
+            return aY;
+        case 194:
+            return !1;
+        case 195:
+            return !0;
+        case 196:
+            if (void 0 === (ee = eI[aG++]))
+                throw Error("Unexpected end of buffer");
+            return sm(ee);
+        case 197:
+            return ee = eZ.getUint16(aG),
+                aG += 2,
+                sm(ee);
+        case 198:
+            return ee = eZ.getUint32(aG),
+                aG += 4,
+                sm(ee);
+        case 199:
+            return sh(eI[aG++]);
+        case 200:
+            return ee = eZ.getUint16(aG),
+                aG += 2,
+                sh(ee);
+        case 201:
+            return ee = eZ.getUint32(aG),
+                aG += 4,
+                sh(ee);
+        case 202:
+            if (ee = eZ.getFloat32(aG),
+            aW.useFloat32 > 2) {
+                var ev = sT[(127 & eI[aG]) << 1 | eI[aG + 1] >> 7];
+                return aG += 4,
+                (ev * ee + (ee > 0 ? .5 : -.5) >> 0) / ev
+            }
+            return aG += 4,
+                ee;
+        case 203:
+            return ee = eZ.getFloat64(aG),
+                aG += 8,
+                ee;
+        case 204:
+            return eI[aG++];
+        case 205:
+            return ee = eZ.getUint16(aG),
+                aG += 2,
+                ee;
+        case 206:
+            return ee = eZ.getUint32(aG),
+                aG += 4,
+                ee;
+        case 207:
+            return "number" === aW.int64AsType ? ee = 4294967296 * eZ.getUint32(aG) + eZ.getUint32(aG + 4) : "string" === aW.int64AsType ? ee = eZ.getBigUint64(aG).toString() : "auto" === aW.int64AsType ? (ee = eZ.getBigUint64(aG)) <= BigInt(2) << BigInt(52) && (ee = Number(ee)) : ee = eZ.getBigUint64(aG),
+                aG += 8,
+                ee;
+        case 208:
+            return eZ.getInt8(aG++);
+        case 209:
+            return ee = eZ.getInt16(aG),
+                aG += 2,
+                ee;
+        case 210:
+            return ee = eZ.getInt32(aG),
+                aG += 4,
+                ee;
+        case 211:
+            return "number" === aW.int64AsType ? ee = 4294967296 * eZ.getInt32(aG) + eZ.getUint32(aG + 4) : "string" === aW.int64AsType ? ee = eZ.getBigInt64(aG).toString() : "auto" === aW.int64AsType ? (ee = eZ.getBigInt64(aG)) >= BigInt(-2) << BigInt(52) && ee <= BigInt(2) << BigInt(52) && (ee = Number(ee)) : ee = eZ.getBigInt64(aG),
+                aG += 8,
+                ee;
+        case 212:
+            if (114 == (ee = eI[aG++]))
+                return sC(63 & eI[aG++]);
+            var eg = aK[ee];
+            if (eg) {
+                if (eg.read)
+                    return aG++,
+                        eg.read(a5());
+                if (eg.noBuffer)
+                    return aG++,
+                        eg();
+                return eg(eI.subarray(aG, ++aG))
+            }
+            throw Error("Unknown extension " + ee);
+        case 213:
+            if (114 == (ee = eI[aG]))
+                return aG++,
+                    sC(63 & eI[aG++], eI[aG++]);
+            return sh(2);
+        case 214:
+            return sh(4);
+        case 215:
+            return sh(8);
+        case 216:
+            return sh(16);
+        case 217:
+            if (ee = eI[aG++],
+            aX >= aG)
+                return eR.slice(aG - aq, (aG += ee) - aq);
+            return st(ee);
+        case 218:
+            if (ee = eZ.getUint16(aG),
+                aG += 2,
+            aX >= aG)
+                return eR.slice(aG - aq, (aG += ee) - aq);
+            return sn(ee);
+        case 219:
+            if (ee = eZ.getUint32(aG),
+                aG += 4,
+            aX >= aG)
+                return eR.slice(aG - aq, (aG += ee) - aq);
+            return sr(ee);
+        case 220:
+            return ee = eZ.getUint16(aG),
+                aG += 2,
+                si(ee);
+        case 221:
+            return ee = eZ.getUint32(aG),
+                aG += 4,
+                si(ee);
+        case 222:
+            return ee = eZ.getUint16(aG),
+                aG += 2,
+                ss(ee);
+        case 223:
+            return ee = eZ.getUint32(aG),
+                aG += 4,
+                ss(ee);
+        default:
+            if (et >= 224)
+                return et - 256;
+            if (void 0 === et) {
+                var eC = Error("Unexpected end of MessagePack data");
+                throw eC.incomplete = !0,
+                    eC
+            }
+            throw Error("Unknown MessagePack token " + et)
+    }
+}
+
+sn = so
+var a6 = /^[a-zA-Z_$][a-zA-Z\d_$]*$/;
+const decrypt = (ee) => {
+    for (var et, en, eo = r9(ee), ei = eo.length, ec = new Uint8Array(ei), eu = 0; eu < ei; eu++) {
+        var ed = eo.charCodeAt(eu);
+        ec[eu] = ed
+    }
+    en = {}
+    et = ec;
+    et.buffer || et.constructor !== ArrayBuffer || (et = "undefined" != typeof Buffer ? Buffer.from(et) : new Uint8Array(et)),
+        "object" == typeof en ? (eO = en.end || et.length,
+            aG = en.start || 0) : (aG = 0,
+            eO = en > -1 ? en : et.length),
+        aX = 0,
+        eR = null,
+        eD = null,
+        eI = et;
+    eM = new TextDecoder("utf-8");
+    eL = null
+
+    eP = [];
+    eZ = et.dataView || (et.dataView = new DataView(et.buffer, et.byteOffset, et.byteLength))
+    res = a3(en)
+    // ec = ecc;
+    // rA = 0;
+    // rB = 0;
+    // ed = [];
+    // eu = ec.length;
+    // rj = {
+    //     "useRecords": false,
+    //     "mapsAsObjects": true
+    // }
+    // // ei 是 TextDecoder
+    // ei = new TextDecoder("utf-8");
+    // eh = new DataView(ec.buffer, ec.byteOffset, ec.byteLength);
+    // ec.dataView = eh;
+    // let res = rK()
+    const replacer = (key, value) => {
+        if (typeof value === 'bigint') {
+            return value.toString();
+        }
+        return value;
+    };
+
+    res = JSON.stringify(res, replacer);
+    return res;
+}
+
+
+// console.log(generate_mid())
+// console.log(generate_uuid())
+// console.log(generate_device_id())
+// console.log(generate_sign('5f65b00f83994987e334f97360d69557', '{"sessionTypes":"1,19"}'))
+// let msg = "ggGLAYEBtTIyMDI2NDA5MTgwNzlAZ29vZmlzaAKzNDc4MTI4NzAwMDBAZ29vZmlzaAOxMzQwMjM5MTQ3MjUwMy5QTk0EAAXPAAABlYW04bIGggFlA4UBoAKjMTExA6AEAQXaADR7ImF0VXNlcnMiOltdLCJjb250ZW50VHlwZSI6MSwidGV4dCI6eyJ0ZXh0IjoiMTExIn19BwIIAQkACoupX3BsYXRmb3Jtp2FuZHJvaWSmYml6VGFn2gBBeyJzb3VyY2VJZCI6IlM6MSIsIm1lc3NhZ2VJZCI6ImYzNjkwMmVmZjQ1NDQ1YmRiMmQxYjBmZDE2OGY4MjY0In2sZGV0YWlsTm90aWNlozExMadleHRKc29u2gBLeyJxdWlja1JlcGx5IjoiMSIsIm1lc3NhZ2VJZCI6ImYzNjkwMmVmZjQ1NDQ1YmRiMmQxYjBmZDE2OGY4MjY0IiwidGFnIjoidSJ9r3JlbWluZGVyQ29udGVudKMxMTGucmVtaW5kZXJOb3RpY2W15Y+R5p2l5LiA5p2h5paw5raI5oGvrXJlbWluZGVyVGl0bGWmc2hh5L+uq3JlbWluZGVyVXJs2gCbZmxlYW1hcmtldDovL21lc3NhZ2VfY2hhdD9pdGVtSWQ9ODk3NzQyNzQ4MDExJnBlZXJVc2VySWQ9MjIwMjY0MDkxODA3OSZwZWVyVXNlck5pY2s9dCoqKjEmc2lkPTQ3ODEyODcwMDAwJm1lc3NhZ2VJZD1mMzY5MDJlZmY0NTQ0NWJkYjJkMWIwZmQxNjhmODI2NCZhZHY9bm+sc2VuZGVyVXNlcklkrTIyMDI2NDA5MTgwNzmuc2VuZGVyVXNlclR5cGWhMKtzZXNzaW9uVHlwZaExDAEDgahuZWVkUHVzaKR0cnVl";
+//
+// msg = "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"
+// msg = "hAGzNDc5ODMzODkwOTZAZ29vZmlzaAIBA4KrcmVkUmVtaW5kZXKy562J5b6F5Lmw5a625LuY5qy+sHJlZFJlbWluZGVyU3R5bGWhMQTPAAABlbMlNng="
+// res = decrypt(msg);
+// console.log(res);
diff --git a/test_fix.py b/test_fix.py
new file mode 100644
index 0000000..c8360e4
--- /dev/null
+++ b/test_fix.py
@@ -0,0 +1,27 @@
+#!/usr/bin/env python3
+"""
+测试修复
+"""
+
+def test_imports():
+    print("🧪 测试导入修复")
+    
+    try:
+        from file_log_collector import setup_file_logging, get_file_log_collector
+        print("✅ file_log_collector 导入成功")
+        
+        # 测试初始化
+        collector = setup_file_logging()
+        print("✅ 文件日志收集器初始化成功")
+        
+        # 生成测试日志
+        from loguru import logger
+        logger.info("测试日志修复")
+        
+        print("✅ 所有导入和初始化都正常")
+        
+    except Exception as e:
+        print(f"❌ 导入失败: {e}")
+
+if __name__ == "__main__":
+    test_imports()
diff --git a/utils/message_utils.py b/utils/message_utils.py
new file mode 100644
index 0000000..dc558a6
--- /dev/null
+++ b/utils/message_utils.py
@@ -0,0 +1,29 @@
+import time
+from typing import Dict, Any
+
+def format_message(message_data: Dict[str, Any], is_outgoing: bool = False, is_manual: bool = False) -> str:
+    """格式化消息输出"""
+    try:
+        # 获取消息内容
+        content = message_data.get('content', '')
+        if not content:
+            return ''
+            
+        # 获取发送时间
+        timestamp = message_data.get('time', time.time() * 1000)
+        time_str = time.strftime('%Y-%m-%d %H:%M:%S', time.localtime(timestamp / 1000))
+        
+        # 确定消息方向
+        direction = '【发出】' if is_outgoing else '【收到】'
+        if is_manual:
+            direction = '【手动发出】'
+            
+        # 格式化输出
+        return f"{time_str} {direction} {content}"
+    except Exception as e:
+        return f"消息格式化错误: {str(e)}"
+
+def format_system_message(message: str) -> str:
+    """格式化系统消息输出"""
+    time_str = time.strftime('%Y-%m-%d %H:%M:%S', time.localtime())
+    return f"{time_str} 【系统】 {message}" 
\ No newline at end of file
diff --git a/utils/ws_utils.py b/utils/ws_utils.py
new file mode 100644
index 0000000..c83ad30
--- /dev/null
+++ b/utils/ws_utils.py
@@ -0,0 +1,89 @@
+import asyncio
+import websockets
+from typing import Optional, Dict, Any, Callable
+from loguru import logger
+
+class WebSocketClient:
+    def __init__(self, url: str, headers: Dict[str, str], on_message: Callable[[Dict[str, Any]], None]):
+        """初始化WebSocket客户端"""
+        self.url = url
+        self.headers = headers
+        self.on_message = on_message
+        self.websocket: Optional[websockets.WebSocketClientProtocol] = None
+        self.is_connected = False
+        self.reconnect_delay = 5  # 重连延迟，单位秒
+        
+    async def connect(self):
+        """建立WebSocket连接"""
+        try:
+            self.websocket = await websockets.connect(
+                self.url,
+                extra_headers=self.headers,
+                ping_interval=None,
+                ping_timeout=None
+            )
+            self.is_connected = True
+            logger.info("WebSocket连接建立成功")
+            return True
+        except Exception as e:
+            logger.error(f"WebSocket连接失败: {e}")
+            return False
+            
+    async def disconnect(self):
+        """关闭WebSocket连接"""
+        if self.websocket:
+            await self.websocket.close()
+            self.is_connected = False
+            logger.info("WebSocket连接已关闭")
+            
+    async def send(self, message: str):
+        """发送消息"""
+        if not self.is_connected:
+            logger.warning("WebSocket未连接，无法发送消息")
+            return False
+            
+        try:
+            await self.websocket.send(message)
+            return True
+        except Exception as e:
+            logger.error(f"消息发送失败: {e}")
+            self.is_connected = False
+            return False
+            
+    async def receive(self):
+        """接收消息"""
+        if not self.is_connected:
+            logger.warning("WebSocket未连接，无法接收消息")
+            return None
+            
+        try:
+            message = await self.websocket.recv()
+            return message
+        except Exception as e:
+            logger.error(f"消息接收失败: {e}")
+            self.is_connected = False
+            return None
+            
+    async def reconnect(self):
+        """重新连接"""
+        logger.info(f"准备在{self.reconnect_delay}秒后重新连接...")
+        await asyncio.sleep(self.reconnect_delay)
+        return await self.connect()
+        
+    async def run(self):
+        """运行WebSocket客户端"""
+        while True:
+            if not self.is_connected:
+                success = await self.connect()
+                if not success:
+                    await self.reconnect()
+                    continue
+                    
+            try:
+                message = await self.receive()
+                if message:
+                    await self.on_message(message)
+            except Exception as e:
+                logger.error(f"消息处理失败: {e}")
+                await self.disconnect()
+                await self.reconnect() 
\ No newline at end of file
diff --git a/utils/xianyu_utils.py b/utils/xianyu_utils.py
new file mode 100644
index 0000000..5e117e3
--- /dev/null
+++ b/utils/xianyu_utils.py
@@ -0,0 +1,332 @@
+import base64
+import json
+import subprocess
+from functools import partial
+import time
+import hashlib
+import struct
+import os
+from typing import Any, Dict, List
+
+import blackboxprotobuf
+
+subprocess.Popen = partial(subprocess.Popen, encoding="utf-8")
+import execjs
+
+def get_js_path():
+    """获取JavaScript文件的路径"""
+    current_dir = os.path.dirname(os.path.abspath(__file__))
+    root_dir = os.path.dirname(current_dir)
+    js_path = os.path.join(root_dir, 'static', 'xianyu_js_version_2.js')
+    return js_path
+
+try:
+    xianyu_js = execjs.compile(open(get_js_path(), 'r', encoding='utf-8').read())
+except Exception as e:
+    raise RuntimeError(f"无法加载JavaScript文件: {e}")
+
+def trans_cookies(cookies_str: str) -> dict:
+    """将cookies字符串转换为字典"""
+    if not cookies_str:
+        raise ValueError("cookies不能为空")
+        
+    cookies = {}
+    for cookie in cookies_str.split("; "):
+        if "=" in cookie:
+            key, value = cookie.split("=", 1)
+            cookies[key] = value
+    return cookies
+
+
+def generate_mid() -> str:
+    """生成mid"""
+    import random
+    random_part = int(1000 * random.random())
+    timestamp = int(time.time() * 1000)
+    return f"{random_part}{timestamp} 0"
+
+
+def generate_uuid() -> str:
+    """生成uuid"""
+    timestamp = int(time.time() * 1000)
+    return f"-{timestamp}1"
+
+
+def generate_device_id(user_id: str) -> str:
+    """生成设备ID"""
+    import random
+    
+    # 字符集
+    chars = "0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz"
+    result = []
+    
+    for i in range(36):
+        if i in [8, 13, 18, 23]:
+            result.append("-")
+        elif i == 14:
+            result.append("4")
+        else:
+            if i == 19:
+                # 对于位置19，需要特殊处理
+                rand_val = int(16 * random.random())
+                result.append(chars[(rand_val & 0x3) | 0x8])
+            else:
+                rand_val = int(16 * random.random())
+                result.append(chars[rand_val])
+    
+    return ''.join(result) + "-" + user_id
+
+
+def generate_sign(t: str, token: str, data: str) -> str:
+    """生成签名"""
+    app_key = "34839810"
+    msg = f"{token}&{t}&{app_key}&{data}"
+    
+    # 使用MD5生成签名
+    md5_hash = hashlib.md5()
+    md5_hash.update(msg.encode('utf-8'))
+    return md5_hash.hexdigest()
+
+
+class MessagePackDecoder:
+    """MessagePack解码器的纯Python实现"""
+    
+    def __init__(self, data: bytes):
+        self.data = data
+        self.pos = 0
+        self.length = len(data)
+    
+    def read_byte(self) -> int:
+        if self.pos >= self.length:
+            raise ValueError("Unexpected end of data")
+        byte = self.data[self.pos]
+        self.pos += 1
+        return byte
+    
+    def read_bytes(self, count: int) -> bytes:
+        if self.pos + count > self.length:
+            raise ValueError("Unexpected end of data")
+        result = self.data[self.pos:self.pos + count]
+        self.pos += count
+        return result
+    
+    def read_uint8(self) -> int:
+        return self.read_byte()
+    
+    def read_uint16(self) -> int:
+        return struct.unpack('>H', self.read_bytes(2))[0]
+    
+    def read_uint32(self) -> int:
+        return struct.unpack('>I', self.read_bytes(4))[0]
+    
+    def read_uint64(self) -> int:
+        return struct.unpack('>Q', self.read_bytes(8))[0]
+    
+    def read_int8(self) -> int:
+        return struct.unpack('>b', self.read_bytes(1))[0]
+    
+    def read_int16(self) -> int:
+        return struct.unpack('>h', self.read_bytes(2))[0]
+    
+    def read_int32(self) -> int:
+        return struct.unpack('>i', self.read_bytes(4))[0]
+    
+    def read_int64(self) -> int:
+        return struct.unpack('>q', self.read_bytes(8))[0]
+    
+    def read_float32(self) -> float:
+        return struct.unpack('>f', self.read_bytes(4))[0]
+    
+    def read_float64(self) -> float:
+        return struct.unpack('>d', self.read_bytes(8))[0]
+    
+    def read_string(self, length: int) -> str:
+        return self.read_bytes(length).decode('utf-8')
+    
+    def decode_value(self) -> Any:
+        """解码单个MessagePack值"""
+        if self.pos >= self.length:
+            raise ValueError("Unexpected end of data")
+            
+        format_byte = self.read_byte()
+        
+        # Positive fixint (0xxxxxxx)
+        if format_byte <= 0x7f:
+            return format_byte
+        
+        # Fixmap (1000xxxx)
+        elif 0x80 <= format_byte <= 0x8f:
+            size = format_byte & 0x0f
+            return self.decode_map(size)
+        
+        # Fixarray (1001xxxx)
+        elif 0x90 <= format_byte <= 0x9f:
+            size = format_byte & 0x0f
+            return self.decode_array(size)
+        
+        # Fixstr (101xxxxx)
+        elif 0xa0 <= format_byte <= 0xbf:
+            size = format_byte & 0x1f
+            return self.read_string(size)
+        
+        # nil
+        elif format_byte == 0xc0:
+            return None
+        
+        # false
+        elif format_byte == 0xc2:
+            return False
+        
+        # true
+        elif format_byte == 0xc3:
+            return True
+        
+        # bin 8
+        elif format_byte == 0xc4:
+            size = self.read_uint8()
+            return self.read_bytes(size)
+        
+        # bin 16
+        elif format_byte == 0xc5:
+            size = self.read_uint16()
+            return self.read_bytes(size)
+        
+        # bin 32
+        elif format_byte == 0xc6:
+            size = self.read_uint32()
+            return self.read_bytes(size)
+        
+        # float 32
+        elif format_byte == 0xca:
+            return self.read_float32()
+        
+        # float 64
+        elif format_byte == 0xcb:
+            return self.read_float64()
+        
+        # uint 8
+        elif format_byte == 0xcc:
+            return self.read_uint8()
+        
+        # uint 16
+        elif format_byte == 0xcd:
+            return self.read_uint16()
+        
+        # uint 32
+        elif format_byte == 0xce:
+            return self.read_uint32()
+        
+        # uint 64
+        elif format_byte == 0xcf:
+            return self.read_uint64()
+        
+        # int 8
+        elif format_byte == 0xd0:
+            return self.read_int8()
+        
+        # int 16
+        elif format_byte == 0xd1:
+            return self.read_int16()
+        
+        # int 32
+        elif format_byte == 0xd2:
+            return self.read_int32()
+        
+        # int 64
+        elif format_byte == 0xd3:
+            return self.read_int64()
+        
+        # str 8
+        elif format_byte == 0xd9:
+            size = self.read_uint8()
+            return self.read_string(size)
+        
+        # str 16
+        elif format_byte == 0xda:
+            size = self.read_uint16()
+            return self.read_string(size)
+        
+        # str 32
+        elif format_byte == 0xdb:
+            size = self.read_uint32()
+            return self.read_string(size)
+        
+        # array 16
+        elif format_byte == 0xdc:
+            size = self.read_uint16()
+            return self.decode_array(size)
+        
+        # array 32
+        elif format_byte == 0xdd:
+            size = self.read_uint32()
+            return self.decode_array(size)
+        
+        # map 16
+        elif format_byte == 0xde:
+            size = self.read_uint16()
+            return self.decode_map(size)
+        
+        # map 32
+        elif format_byte == 0xdf:
+            size = self.read_uint32()
+            return self.decode_map(size)
+        
+        # Negative fixint (111xxxxx)
+        elif format_byte >= 0xe0:
+            return format_byte - 0x100
+        
+        raise ValueError(f"Unknown format byte: {format_byte:02x}")
+
+    def decode_array(self, size: int) -> List[Any]:
+        """解码数组"""
+        return [self.decode_value() for _ in range(size)]
+
+    def decode_map(self, size: int) -> Dict[Any, Any]:
+        """解码字典"""
+        result = {}
+        for _ in range(size):
+            key = self.decode_value()
+            value = self.decode_value()
+            result[key] = value
+        return result
+
+    def decode(self) -> Any:
+        """解码整个MessagePack数据"""
+        return self.decode_value()
+
+
+def decrypt(data: str) -> str:
+    """解密消息数据"""
+    try:
+        # Base64解码
+        decoded_data = base64.b64decode(data)
+        
+        # 使用MessagePack解码器解码数据
+        decoder = MessagePackDecoder(decoded_data)
+        decoded_value = decoder.decode()
+        
+        # 如果解码后的值是字典，转换为JSON字符串
+        if isinstance(decoded_value, dict):
+            def json_serializer(obj):
+                if isinstance(obj, bytes):
+                    return obj.decode('utf-8', errors='ignore')
+                raise TypeError(f"Type {type(obj)} not serializable")
+            
+            return json.dumps(decoded_value, default=json_serializer)
+        
+        # 如果是其他类型，尝试转换为字符串
+        return str(decoded_value)
+        
+    except Exception as e:
+        raise Exception(f"解密失败: {str(e)}")
+
+if __name__ == '__main__':
+    # t = 1741667630548
+    # token = 'b7e897bf9767618a32b439c6103fe1cb'
+    # data = '{"appKey":"444e9908a51d1cb236a27862abc769c9","deviceId":"ED4CBA2C-5DA0-4154-A902-BF5CB52409E2-3888777108"}'
+    # print(generate_sign(t, token, data))
+    msg = "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"
+    msg = "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"
+
+    res = decrypt(msg)
+    print(res)
\ No newline at end of file
diff --git a/xianyu_data.db b/xianyu_data.db
new file mode 100644
index 0000000..b726b50
Binary files /dev/null and b/xianyu_data.db differ
diff --git a/使用说明.md b/使用说明.md
new file mode 100644
index 0000000..008c929
--- /dev/null
+++ b/使用说明.md
@@ -0,0 +1,178 @@
+# 闲鱼自动回复管理系统 - 使用说明
+
+## 🎉 系统功能概述
+
+本系统已完全实现您要求的所有功能：
+
+### ✅ 已实现功能
+1. **多Cookies支持** - 支持同时管理多个闲鱼账号
+2. **美观前端界面** - 响应式设计，支持Cookies和关键词的CRUD操作
+3. **SQLite数据库存储** - 持久化存储Cookies和关键词数据
+4. **关键词管理** - 每个账号独立的关键词回复设置
+5. **API接口** - 完整实现 `/xianyu/reply` 接口
+6. **智能回复** - 根据Cookie ID匹配对应关键词进行回复
+7. **用户认证** - 安全的登录认证系统
+
+## 🚀 快速开始
+
+### 1. 安装依赖
+```bash
+pip install -r requirements.txt
+```
+
+### 2. 启动系统
+```bash
+python Start.py
+```
+
+### 3. 访问系统
+- 打开浏览器访问：`http://localhost:8080`
+- 默认登录账号：
+  - **用户名**：`admin`
+  - **密码**：`admin123`
+
+## 📋 系统使用流程
+
+### 步骤1：登录系统
+1. 访问 `http://localhost:8080`
+2. 输入用户名和密码登录
+3. 成功登录后进入管理界面
+
+### 步骤2：添加闲鱼账号
+1. 在"添加新账号"区域填写：
+   - **账号ID**：唯一标识（如：account1, 主账号等）
+   - **Cookie值**：完整的闲鱼Cookie字符串
+2. 点击"添加账号"按钮
+
+### 步骤3：设置关键词回复
+1. 在账号列表中点击"关键词"按钮
+2. 添加关键词和对应的回复内容
+3. 支持变量替换：
+   - `{send_user_name}` - 发送者昵称
+   - `{send_user_id}` - 发送者ID
+   - `{send_message}` - 发送的消息内容
+4. 点击"保存更改"
+
+### 步骤4：系统自动运行
+- 系统会自动监控闲鱼消息
+- 根据关键词匹配自动回复
+- 所有操作都有详细日志记录
+
+## 🔧 功能详解
+
+### 多账号管理
+- **添加账号**：支持添加无限数量的闲鱼账号
+- **修改Cookie**：可以随时更新账号的Cookie值
+- **删除账号**：删除不需要的账号及其关键词
+- **独立运行**：每个账号独立运行，互不干扰
+
+### 关键词回复系统
+- **精确匹配**：支持关键词精确匹配
+- **变量替换**：回复内容支持动态变量
+- **优先级**：账号级关键词优先于全局关键词
+- **默认回复**：未匹配关键词时使用默认回复
+
+### API接口
+- **接口地址**：`POST http://localhost:8080/xianyu/reply`
+- **功能**：根据cookie_id和消息内容返回回复内容
+- **自动调用**：系统收到消息时自动调用此接口
+
+## 📊 系统架构
+
+```
+用户界面 (Web) ←→ FastAPI服务器 ←→ SQLite数据库
+                      ↓
+                 CookieManager
+                      ↓
+                 XianyuLive (多实例)
+                      ↓
+                 闲鱼WebSocket连接
+```
+
+## 🔐 安全说明
+
+### 登录认证
+- 所有管理功能都需要登录认证
+- Session token有效期24小时
+- 自动登录状态检查
+
+### 数据安全
+- Cookie数据加密存储在SQLite数据库
+- 界面上不显示完整Cookie值
+- 支持安全的Cookie更新机制
+
+## 📝 日志系统
+
+### 日志文件位置
+- 日志目录：`logs/`
+- 文件格式：`xianyu_YYYY-MM-DD.log`
+- 自动轮转：每天一个文件，保留7天
+
+### 日志内容
+- 系统启动和关闭
+- 账号添加、修改、删除
+- 消息接收和发送
+- 错误和异常信息
+
+## 🛠️ 故障排除
+
+### 常见问题
+
+#### 1. Cookie过期
+**现象**：日志显示"Session过期"
+**解决**：在Web界面更新对应账号的Cookie值
+
+#### 2. 无法连接闲鱼
+**现象**：WebSocket连接失败
+**解决**：检查网络连接和Cookie是否有效
+
+#### 3. 关键词不匹配
+**现象**：收到消息但没有自动回复
+**解决**：检查关键词设置，确保关键词包含在消息中
+
+#### 4. 登录失败
+**现象**：无法登录管理界面
+**解决**：确认用户名密码正确（admin/admin123）
+
+### 系统要求
+- Python 3.7+
+- Windows/Linux/macOS
+- 网络连接
+- 有效的闲鱼账号Cookie
+
+## 🔄 更新和维护
+
+### 配置文件
+- 主配置：`global_config.yml`
+- 数据库：`xianyu_data.db`
+- 静态文件：`static/` 目录
+
+### 备份建议
+- 定期备份 `xianyu_data.db` 文件
+- 备份 `global_config.yml` 配置文件
+- 备份自定义的关键词文件
+
+## 📞 技术支持
+
+### 测试系统
+运行测试脚本检查系统状态：
+```bash
+python test_system.py
+```
+
+### 重新创建配置
+如果配置文件损坏，运行：
+```bash
+python create_config.py
+```
+
+## 🎯 使用建议
+
+1. **Cookie获取**：使用浏览器开发者工具获取完整Cookie
+2. **关键词设置**：设置常用的咨询关键词和回复
+3. **定期检查**：定期查看日志确保系统正常运行
+4. **备份数据**：重要数据请及时备份
+
+---
+
+**注意**：本系统仅供学习交流使用，请遵守相关法律法规和平台规则。
diff --git a/商品管理功能说明.md b/商品管理功能说明.md
new file mode 100644
index 0000000..9ece907
--- /dev/null
+++ b/商品管理功能说明.md
@@ -0,0 +1,199 @@
+# 🛍️ 商品管理功能使用说明
+
+## 📋 功能概述
+
+新增的商品管理功能可以自动收集和管理各个闲鱼账号的商品信息，为自动发货提供更准确的商品数据支持。
+
+## 🎯 核心特性
+
+### 1. 自动商品信息收集
+- **消息触发收集**：接收消息时自动提取商品ID并保存到数据库
+- **API获取详情**：通过闲鱼API获取完整商品信息
+- **智能去重**：商品ID唯一，避免重复存储
+- **增量更新**：有详情的商品不会被空数据覆盖
+
+### 2. 多账号商品管理
+- **账号隔离**：每个Cookie账号的商品信息独立管理
+- **批量查看**：支持查看所有账号或指定账号的商品
+- **筛选功能**：可按账号ID筛选商品列表
+
+### 3. 商品详情编辑
+- **可视化编辑**：提供专门的编辑界面修改商品详情
+- **JSON格式**：支持复杂的商品信息结构
+- **实时保存**：修改后立即保存到数据库
+
+### 4. 自动发货增强
+- **优先级策略**：优先使用API获取商品信息，失败时从数据库获取
+- **智能匹配**：基于商品标题、描述、分类进行关键词匹配
+- **容错机制**：API失败时自动降级到数据库数据
+
+## 🗄️ 数据库结构
+
+### 商品信息表 (item_info)
+```sql
+CREATE TABLE item_info (
+    id INTEGER PRIMARY KEY AUTOINCREMENT,
+    cookie_id TEXT NOT NULL,              -- 所属账号ID
+    item_id TEXT NOT NULL,                -- 商品ID
+    item_title TEXT,                      -- 商品标题
+    item_description TEXT,                -- 商品描述
+    item_category TEXT,                   -- 商品分类
+    item_price TEXT,                      -- 商品价格
+    item_detail TEXT,                     -- 完整商品详情(JSON)
+    created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP,
+    updated_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP,
+    UNIQUE(cookie_id, item_id)            -- 联合唯一索引
+);
+```
+
+## 🚀 使用方法
+
+### 1. 访问商品管理
+1. 登录系统后，点击侧边栏"商品管理"菜单
+2. 系统会自动加载所有账号的商品信息
+
+### 2. 筛选商品
+1. 使用"筛选账号"下拉框选择特定账号
+2. 点击"刷新"按钮更新商品列表
+
+### 3. 编辑商品详情
+1. 在商品列表中点击"编辑详情"按钮
+2. 在弹出的编辑框中修改商品详情（JSON格式）
+3. 点击"保存"按钮保存修改
+
+### 4. 商品信息自动收集
+- **无需手动操作**：系统会在以下情况自动收集商品信息：
+  - 接收到闲鱼消息时
+  - 自动发货时获取商品详情
+  - 调用商品信息API时
+
+## 🔧 技术实现
+
+### 1. 数据收集流程
+```
+接收消息 → 提取商品ID → 调用API获取详情 → 保存到数据库
+    ↓
+如果API失败 → 仅保存商品ID → 后续可手动补充详情
+```
+
+### 2. 自动发货增强流程
+```
+触发自动发货 → 优先调用API获取商品信息
+    ↓
+API成功 → 使用API数据进行关键词匹配
+    ↓
+API失败 → 从数据库获取商品信息 → 使用数据库数据匹配
+```
+
+### 3. 数据更新策略
+- **新商品**：直接插入数据库
+- **已存在且无详情**：更新为有详情的数据
+- **已存在且有详情**：跳过更新，保护现有数据
+
+## 📊 API接口
+
+### 获取所有商品
+```http
+GET /items
+Authorization: Bearer {token}
+```
+
+### 获取指定账号商品
+```http
+GET /items/cookie/{cookie_id}
+Authorization: Bearer {token}
+```
+
+### 获取商品详情
+```http
+GET /items/{cookie_id}/{item_id}
+Authorization: Bearer {token}
+```
+
+### 更新商品详情
+```http
+PUT /items/{cookie_id}/{item_id}
+Content-Type: application/json
+Authorization: Bearer {token}
+
+{
+    "item_detail": "{JSON格式的商品详情}"
+}
+```
+
+## 🎨 界面功能
+
+### 商品列表显示
+- **账号ID**：商品所属的闲鱼账号
+- **商品ID**：闲鱼商品的唯一标识
+- **商品标题**：从API获取的商品标题
+- **商品分类**：商品所属分类
+- **价格**：商品价格信息
+- **更新时间**：最后更新时间
+- **操作按钮**：编辑详情功能
+
+### 编辑详情界面
+- **大文本框**：支持编辑大量JSON数据
+- **格式验证**：保存前验证JSON格式
+- **实时保存**：修改后立即生效
+
+## 🔍 故障排除
+
+### 常见问题
+
+1. **商品信息为空**
+   - 原因：API获取失败，只保存了商品ID
+   - 解决：手动编辑商品详情，补充信息
+
+2. **自动发货匹配失败**
+   - 原因：商品信息不完整，关键词匹配失败
+   - 解决：编辑商品详情，添加相关关键词
+
+3. **商品重复显示**
+   - 原因：不同账号可能有相同商品ID
+   - 说明：这是正常现象，系统按账号隔离
+
+### 调试方法
+
+1. **查看日志**
+   ```bash
+   # 查看商品信息收集日志
+   grep "商品信息" logs/xianyu_*.log
+   
+   # 查看自动发货日志
+   grep "自动发货" logs/xianyu_*.log
+   ```
+
+2. **数据库查询**
+   ```python
+   from db_manager import db_manager
+   
+   # 查看所有商品
+   items = db_manager.get_all_items()
+   print(f"共有 {len(items)} 个商品")
+   
+   # 查看特定账号商品
+   items = db_manager.get_items_by_cookie("account_id")
+   print(f"该账号有 {len(items)} 个商品")
+   ```
+
+## 💡 最佳实践
+
+1. **定期检查商品信息**
+   - 定期查看商品管理页面
+   - 补充缺失的商品详情
+   - 优化关键词匹配规则
+
+2. **合理设置发货规则**
+   - 根据商品信息设置精确的关键词
+   - 利用商品分类进行规则匹配
+   - 测试匹配效果
+
+3. **监控系统日志**
+   - 关注商品信息收集日志
+   - 监控自动发货匹配情况
+   - 及时处理异常情况
+
+---
+
+🎉 **商品管理功能让您的闲鱼自动发货更加智能和准确！**
diff --git a/日志管理功能说明.md b/日志管理功能说明.md
new file mode 100644
index 0000000..5ed5981
--- /dev/null
+++ b/日志管理功能说明.md
@@ -0,0 +1,296 @@
+# 📋 实时日志管理功能说明
+
+## 📋 功能概述
+
+新增了**实时日志管理功能**，可以实时收集和显示系统的控制台日志输出，支持滚动查看、过滤搜索、自动刷新和统计分析。
+
+## 🔥 实时日志特色
+
+### 📡 真正的实时日志
+- **实时收集**：直接从Python logging系统收集日志
+- **内存缓存**：在内存中保存最新的2000条日志
+- **零延迟**：无需读取文件，直接从内存获取
+- **控制台同步**：与控制台输出完全同步
+
+## ✨ 主要功能
+
+### 1. 实时日志显示
+- 📊 **实时收集**：直接从Python logging系统收集日志
+- 🔄 **自动刷新**：支持每5秒自动刷新日志
+- 📜 **滚动查看**：支持滚动查看所有历史日志
+- 🎨 **语法高亮**：不同日志级别使用不同颜色显示
+- 💾 **内存缓存**：最多保存2000条最新日志
+
+### 2. 强大的过滤功能
+- 🏷️ **日志级别过滤**：DEBUG、INFO、WARNING、ERROR、CRITICAL
+- 📦 **来源模块过滤**：自动化模块、Web服务器、数据库管理、Cookie管理
+- 🔍 **关键词搜索**：支持实时搜索日志内容
+- 📏 **行数控制**：可选择显示100/200/500/1000行日志
+- 🎯 **服务器端过滤**：支持在API层面进行过滤，提高性能
+
+### 3. 便捷的操作功能
+- 🔄 **手动刷新**：点击刷新按钮立即获取最新日志
+- 🗑️ **清空显示**：清空当前显示的日志内容
+- 💥 **清空服务器日志**：清空服务器内存中的所有日志
+- ⏯️ **自动刷新开关**：一键开启/关闭自动刷新
+- 📊 **统计信息**：显示详细的日志统计和分析
+
+### 4. 统计分析功能
+- 📈 **总体统计**：总日志数、内存使用率
+- 📊 **级别分布**：各日志级别的数量和百分比
+- 🏷️ **来源分布**：各模块的日志数量和百分比
+- 📋 **实时更新**：统计信息实时更新
+
+## 🎯 界面设计
+
+### 菜单位置
+在左侧导航栏中，位于"商品管理"和"系统设置"之间：
+```
+📦 商品管理
+📋 日志管理  ← 新增
+⚙️ 系统设置
+```
+
+### 页面布局
+```
+┌─────────────────────────────────────────────────────────────────────┐
+│ 📋 日志管理        [刷新] [清空显示] [清空服务器] [统计] [自动刷新]    │
+├─────────────────────────────────────────────────────────────────────┤
+│ [日志级别▼] [来源模块▼] [搜索框] [显示行数▼]                        │
+├─────────────────────────────────────────────────────────────────────┤
+│ 系统日志                                   [1250条日志] [刚刚更新]    │
+│ ┌─────────────────────────────────────────────────────────────────┐ │
+│ │ 2025-01-23 12:30:45.123 [INFO] reply_server: 服务启动          │ │
+│ │ 2025-01-23 12:30:46.456 [ERROR] db_manager: 连接失败           │ │
+│ │ 2025-01-23 12:30:47.789 [WARNING] cookie_manager: 令牌过期     │ │
+│ │ 2025-01-23 12:30:48.012 [DEBUG] XianyuAutoAsync: 处理消息      │ │
+│ │ ...                                                           │ │
+│ └─────────────────────────────────────────────────────────────────┘ │
+└─────────────────────────────────────────────────────────────────────┘
+```
+
+## 🔧 技术实现
+
+### 核心架构：实时日志收集器
+1. **LogCollector类**
+   ```python
+   class LogCollector:
+       def __init__(self, max_logs: int = 2000):
+           self.logs = deque(maxlen=max_logs)  # 循环缓冲区
+           self.handler = LogHandler(self)     # 自定义日志处理器
+   ```
+
+2. **LogHandler处理器**
+   ```python
+   class LogHandler(logging.Handler):
+       def emit(self, record: logging.LogRecord):
+           self.collector.add_log(record)  # 实时收集日志
+   ```
+
+3. **全局集成**
+   - 在Start.py中初始化日志收集器
+   - 自动注册到Python logging系统
+   - 所有模块的日志都会被自动收集
+
+### 前端实现
+1. **HTML结构**
+   - 添加日志管理菜单项
+   - 创建日志显示页面
+   - 设计过滤器和控制按钮
+   - 新增统计信息模态框
+
+2. **CSS样式**
+   - 深色主题的日志容器
+   - 不同级别的颜色区分
+   - 滚动条美化
+   - 响应式布局
+
+3. **JavaScript功能**
+   - 实时日志获取和显示
+   - 客户端和服务器端过滤
+   - 自动刷新机制
+   - 统计信息展示
+   - 页面切换处理
+
+### 后端API接口
+1. **获取日志**
+   ```python
+   @app.get("/logs")
+   async def get_logs(lines: int = 200, level: str = None, source: str = None):
+   ```
+
+2. **日志统计**
+   ```python
+   @app.get("/logs/stats")
+   async def get_log_stats():
+   ```
+
+3. **清空日志**
+   ```python
+   @app.post("/logs/clear")
+   async def clear_logs():
+   ```
+
+## 📊 实时日志格式
+
+### 收集的日志信息
+```json
+{
+  "timestamp": "2025-01-23T12:30:45.123000",
+  "level": "INFO",
+  "source": "XianyuAutoAsync",
+  "function": "process_message",
+  "line": 1234,
+  "message": "处理消息成功"
+}
+```
+
+### 日志来源
+- **XianyuAutoAsync**: 自动化核心模块
+- **reply_server**: Web服务器
+- **db_manager**: 数据库管理
+- **cookie_manager**: Cookie管理
+- **log_collector**: 日志收集器
+- **Start**: 启动模块
+- **test_***: 测试模块
+
+### 支持的日志级别
+- 🔵 **DEBUG**：调试信息（蓝色）
+- 🟢 **INFO**：一般信息（绿色）
+- 🟡 **WARNING**：警告信息（黄色）
+- 🔴 **ERROR**：错误信息（红色）
+- 🟣 **CRITICAL**：严重错误（紫色，加粗）
+
+## 🚀 使用方法
+
+### 1. 访问日志管理
+1. 登录系统后，点击左侧菜单的"日志管理"
+2. 系统会自动加载最新的200条日志
+3. 日志以时间倒序显示，最新的在底部
+
+### 2. 过滤日志
+- **按级别过滤**：选择特定的日志级别（如只看ERROR）
+- **按来源过滤**：选择特定的模块（如只看数据库相关）
+- **关键词搜索**：输入关键词实时搜索日志内容
+- **调整行数**：选择显示更多或更少的日志行数
+
+### 3. 自动刷新
+1. 点击"开启自动刷新"按钮
+2. 系统每5秒自动获取最新日志
+3. 再次点击可停止自动刷新
+
+### 4. 手动操作
+- **刷新**：立即获取最新日志
+- **清空显示**：清空当前显示的日志（不删除服务器数据）
+- **清空服务器日志**：清空服务器内存中的所有日志
+- **统计信息**：查看详细的日志统计和分析
+- **滚动查看**：使用鼠标滚轮或滚动条查看历史日志
+
+### 5. 统计分析
+- **总体统计**：查看日志总数和内存使用情况
+- **级别分布**：查看各日志级别的数量和百分比
+- **来源分布**：查看各模块的日志数量和百分比
+- **实时更新**：统计信息随日志实时更新
+
+## 💾 内存日志管理
+
+### 内存缓存机制
+- **循环缓冲区**：使用deque实现，最多保存2000条日志
+- **自动清理**：超出容量时自动删除最旧的日志
+- **线程安全**：使用锁机制确保多线程安全
+- **零文件依赖**：完全基于内存，无需读取日志文件
+
+### 性能优势
+- **零延迟**：直接从内存获取，无文件I/O
+- **实时性**：与控制台输出完全同步
+- **高效过滤**：在内存中进行过滤，速度极快
+- **低资源消耗**：内存占用可控，不会无限增长
+
+## ⚠️ 注意事项
+
+### 1. 性能考虑
+- 大日志文件可能影响加载速度
+- 建议设置合理的显示行数
+- 自动刷新会增加服务器负载
+
+### 2. 权限要求
+- 需要管理员权限才能访问
+- 确保日志文件有读取权限
+- 网络连接稳定性影响实时性
+
+### 3. 浏览器兼容性
+- 建议使用现代浏览器
+- 支持WebSocket的浏览器效果更佳
+- 移动端可能显示效果有限
+
+## 🔮 未来扩展
+
+### 1. 高级功能
+- 📊 **日志统计**：错误率、调用频率统计
+- 📈 **图表展示**：日志趋势图表
+- 🔔 **实时告警**：错误日志实时通知
+- 💾 **日志下载**：支持导出日志文件
+
+### 2. 性能优化
+- 🚀 **WebSocket**：实时推送新日志
+- 💾 **缓存机制**：减少文件读取次数
+- 🔄 **增量更新**：只获取新增日志
+- 📦 **压缩传输**：减少网络传输量
+
+### 3. 用户体验
+- 🎨 **主题切换**：支持亮色/暗色主题
+- 🔍 **高级搜索**：正则表达式搜索
+- 📌 **书签功能**：标记重要日志
+- 📱 **移动适配**：优化移动端显示
+
+## 🎉 功能特色
+
+### 1. 实时性
+- 自动刷新机制确保日志实时性
+- 页面切换时智能停止刷新
+- 手动刷新立即获取最新内容
+
+### 2. 易用性
+- 直观的界面设计
+- 丰富的过滤选项
+- 便捷的操作按钮
+
+### 3. 专业性
+- 类似IDE的日志显示效果
+- 语法高亮和颜色区分
+- 专业的等宽字体
+
+### 4. 可扩展性
+- 模块化的代码结构
+- 易于添加新功能
+- 支持多种日志格式
+
+## 🆚 对比：文件日志 vs 实时日志
+
+| 特性 | 文件日志 | 实时日志 |
+|------|---------|---------|
+| **实时性** | 需要刷新文件 | 完全实时 |
+| **性能** | 文件I/O开销 | 内存访问，极快 |
+| **同步性** | 可能有延迟 | 与控制台同步 |
+| **资源消耗** | 磁盘I/O | 内存占用 |
+| **历史记录** | 永久保存 | 最新2000条 |
+| **过滤效率** | 需要解析 | 内存中过滤 |
+| **部署复杂度** | 需要日志文件 | 无额外依赖 |
+
+## 🎯 使用建议
+
+### 适用场景
+- ✅ **开发调试**：实时查看程序运行状态
+- ✅ **问题排查**：快速定位错误和异常
+- ✅ **性能监控**：监控系统运行情况
+- ✅ **用户支持**：协助用户解决问题
+
+### 最佳实践
+1. **开启自动刷新**：实时监控系统状态
+2. **使用过滤器**：快速找到关注的日志
+3. **查看统计信息**：了解系统整体状况
+4. **定期清空**：避免内存占用过多
+
+---
+
+🎉 **实时日志管理功能已完成，提供了真正的实时日志查看、过滤和分析能力！**
diff --git a/自动发货功能说明.md b/自动发货功能说明.md
new file mode 100644
index 0000000..059cdcb
--- /dev/null
+++ b/自动发货功能说明.md
@@ -0,0 +1,265 @@
+# 🚚 自动发货功能使用说明
+
+## 📋 功能概述
+
+自动发货功能可以在买家付款成功后，根据商品信息自动匹配发货规则，并发送对应的卡券内容给买家。
+
+## 🎯 工作流程
+
+### 1. 触发条件
+- 系统收到"等待卖家发货"消息时自动触发
+- 表示买家已完成付款，等待卖家发货
+
+### 2. 商品信息获取
+```
+买家付款成功 → 提取商品ID → 调用闲鱼API → 获取商品详情
+```
+
+**获取的信息包括：**
+- 商品标题
+- 商品描述
+- 商品分类
+- 商品价格
+- 其他相关信息
+
+### 3. 智能匹配规则
+```
+商品信息 → 组合搜索文本 → 匹配发货规则 → 选择最佳规则
+```
+
+**匹配策略：**
+- 优先匹配关键字长度较长的规则（更精确）
+- 支持商品标题、描述、分类的综合匹配
+- 支持模糊匹配和部分匹配
+
+### 4. 自动发货执行
+```
+匹配规则 → 获取卡券内容 → 发送给买家 → 更新统计
+```
+
+## 🎫 卡券类型说明
+
+### 1. API接口类型
+**适用场景：** 需要动态获取内容的卡券
+- 调用外部API获取实时数据
+- 支持GET/POST请求
+- 可配置请求头和参数
+- 自动处理API响应
+
+**配置示例：**
+```json
+{
+  "url": "https://api.example.com/get-card",
+  "method": "GET",
+  "timeout": 10,
+  "headers": "{\"Authorization\": \"Bearer token\"}",
+  "params": "{\"type\": \"recharge\", \"amount\": 100}"
+}
+```
+
+### 2. 固定文字类型
+**适用场景：** 标准化的文字内容
+- 发送预设的固定文字
+- 适合使用说明、激活码等
+- 内容固定不变
+
+**内容示例：**
+```
+🎉 恭喜您获得VIP会员卡！
+
+会员卡号：VIP2024001
+有效期：2024年12月31日
+
+专属权益：
+✅ 免费配送
+✅ 专属客服
+✅ 会员折扣
+
+感谢您的支持！
+```
+
+### 3. 批量数据类型
+**适用场景：** 唯一性数据，如卡密
+- 逐条消费预设数据
+- 线程安全，防止重复发送
+- 自动管理库存
+
+**数据格式：**
+```
+CARD001:PASS001
+CARD002:PASS002
+CARD003:PASS003
+```
+
+## ⚙️ 配置步骤
+
+### 1. 创建卡券
+1. 登录管理界面
+2. 点击"卡券管理"菜单
+3. 点击"添加卡券"按钮
+4. 选择卡券类型并配置相应参数
+5. 启用卡券
+
+### 2. 配置发货规则
+1. 点击"自动发货"菜单
+2. 点击"添加规则"按钮
+3. 设置商品关键字
+4. 选择对应的卡券
+5. 设置发货数量
+6. 启用规则
+
+### 3. 关键字配置建议
+
+**商品分类关键字：**
+- `手机` - 匹配手机类商品
+- `数码` - 匹配数码产品
+- `服装` - 匹配服装类商品
+- `鞋子` - 匹配鞋类商品
+- `家居` - 匹配家居用品
+
+**品牌关键字：**
+- `iPhone` - 匹配iPhone商品
+- `小米` - 匹配小米商品
+- `华为` - 匹配华为商品
+
+**功能关键字：**
+- `充值` - 匹配充值类商品
+- `会员` - 匹配会员服务
+- `游戏` - 匹配游戏相关商品
+
+## 📊 统计功能
+
+### 发货统计
+- 总发货次数
+- 各规则发货次数
+- 发货成功率
+- 卡券消耗情况
+
+### 库存管理
+- 批量数据剩余数量
+- 卡券启用状态
+- 规则启用状态
+
+## 🔧 高级配置
+
+### 环境变量
+```bash
+# 启用自动发货
+AUTO_DELIVERY_ENABLED=true
+
+# 自动发货超时时间
+AUTO_DELIVERY_TIMEOUT=30
+
+# API卡券请求超时
+API_CARD_TIMEOUT=10
+
+# 批量数据并发保护
+BATCH_DATA_LOCK_TIMEOUT=5
+```
+
+### 日志配置
+系统会记录详细的发货日志：
+- 商品信息获取日志
+- 规则匹配日志
+- 发货执行日志
+- 错误处理日志
+
+## 🚨 注意事项
+
+### 1. 商品ID提取
+- 系统会尝试从多个字段提取商品ID
+- 如果提取失败，会使用默认ID
+- 建议检查日志确认提取是否成功
+
+### 2. API卡券配置
+- 确保API地址可访问
+- 检查请求头和参数格式
+- 设置合适的超时时间
+- 处理API异常情况
+
+### 3. 批量数据管理
+- 定期检查数据库存
+- 及时补充批量数据
+- 监控消耗速度
+- 设置库存预警
+
+### 4. 规则优先级
+- 关键字越长，优先级越高
+- 避免关键字冲突
+- 定期优化匹配规则
+- 测试匹配效果
+
+## 🧪 测试方法
+
+### 1. 功能测试
+```bash
+python test-item-info-delivery.py
+```
+
+### 2. 手动测试
+1. 创建测试卡券和规则
+2. 模拟"等待卖家发货"消息
+3. 检查发货是否正常
+4. 验证统计数据更新
+
+### 3. 日志检查
+查看日志文件确认：
+- 商品信息获取是否成功
+- 规则匹配是否正确
+- 发货内容是否正确发送
+
+## 🔍 故障排除
+
+### 常见问题
+
+**1. 未触发自动发货**
+- 检查发货规则是否启用
+- 检查卡券是否启用
+- 检查关键字是否匹配
+- 查看错误日志
+
+**2. 商品信息获取失败**
+- 检查Cookie是否有效
+- 检查网络连接
+- 检查商品ID是否正确
+- 查看API调用日志
+
+**3. 批量数据用完**
+- 检查数据库存
+- 及时补充数据
+- 考虑使用其他类型卡券
+
+**4. API卡券调用失败**
+- 检查API地址和参数
+- 检查网络连接
+- 增加超时时间
+- 查看API响应日志
+
+## 📈 性能优化
+
+### 1. 数据库优化
+- 定期清理过期数据
+- 优化查询索引
+- 监控数据库性能
+
+### 2. 网络优化
+- 设置合适的超时时间
+- 使用连接池
+- 实现重试机制
+
+### 3. 并发控制
+- 批量数据消费使用锁机制
+- 避免重复发货
+- 控制并发数量
+
+## 💡 最佳实践
+
+1. **规则设计**：关键字要具体明确，避免过于宽泛
+2. **库存管理**：定期检查批量数据库存，及时补充
+3. **监控告警**：设置发货失败告警，及时处理异常
+4. **测试验证**：新规则上线前充分测试
+5. **日志分析**：定期分析发货日志，优化匹配规则
+
+---
+
+🎉 **自动发货功能让您的闲鱼店铺实现真正的自动化运营！**
diff --git a/获取所有商品功能说明.md b/获取所有商品功能说明.md
new file mode 100644
index 0000000..ca70f87
--- /dev/null
+++ b/获取所有商品功能说明.md
@@ -0,0 +1,203 @@
+# 📦 获取所有商品功能说明
+
+## 📋 功能概述
+
+在商品管理界面新增了"获取所有商品"功能，支持选择指定账号，一键获取该账号下的所有商品信息，并将详细结果打印到控制台。
+
+## ✨ 主要功能
+
+### 1. 界面功能
+- 🎯 **账号选择**：使用现有的账号筛选下拉框选择目标账号
+- 🔄 **一键获取**：点击"获取所有商品"按钮开始获取
+- 📊 **状态显示**：按钮显示获取进度状态
+- 🔔 **结果通知**：获取完成后显示成功消息和商品数量
+
+### 2. 后端功能
+- 🔐 **账号验证**：验证选中账号的有效性
+- 🔄 **自动重试**：支持token失效时自动刷新重试（最多3次）
+- 📝 **详细日志**：完整的获取过程日志记录
+- 🖨️ **控制台输出**：格式化的商品信息打印到控制台
+
+## 🎯 使用方法
+
+### 1. 访问商品管理
+1. 登录系统后，点击左侧菜单的"商品管理"
+2. 进入商品管理页面
+
+### 2. 选择账号
+1. 在页面上方的"筛选账号"下拉框中选择目标账号
+2. 确保选择了有效的账号（不是"全部账号"）
+
+### 3. 获取商品
+1. 点击"获取所有商品"按钮
+2. 按钮会显示"获取中..."状态
+3. 等待获取完成
+
+### 4. 查看结果
+1. 获取完成后会显示成功消息
+2. 控制台会打印详细的商品信息
+3. 商品列表会自动刷新
+
+## 🔧 技术实现
+
+### 前端实现
+```javascript
+// 获取所有商品信息
+async function getAllItemsFromAccount() {
+  const cookieSelect = document.getElementById('itemCookieFilter');
+  const selectedCookieId = cookieSelect.value;
+  
+  // 调用后端API
+  const response = await fetch(`${apiBase}/items/get-all-from-account`, {
+    method: 'POST',
+    headers: {
+      'Content-Type': 'application/json',
+      'Authorization': `Bearer ${authToken}`
+    },
+    body: JSON.stringify({
+      cookie_id: selectedCookieId
+    })
+  });
+}
+```
+
+### 后端API
+```python
+@app.post("/items/get-all-from-account")
+async def get_all_items_from_account(request: dict, _: None = Depends(require_auth)):
+    """从指定账号获取所有商品信息"""
+    # 1. 验证参数
+    # 2. 获取账号信息
+    # 3. 创建XianyuLive实例
+    # 4. 调用get_item_list_info方法
+    # 5. 返回结果
+```
+
+### 核心方法
+```python
+async def get_item_list_info(self, retry_count=0):
+    """获取商品信息，自动处理token失效的情况"""
+    # 1. 检查重试次数
+    # 2. 刷新token（如果需要）
+    # 3. 构造请求参数
+    # 4. 发送API请求
+    # 5. 处理响应结果
+    # 6. 打印商品信息到控制台
+```
+
+## 📊 API参数说明
+
+### 请求参数
+```json
+{
+  "cookie_id": "账号ID"
+}
+```
+
+### 响应格式
+```json
+{
+  "success": true,
+  "message": "成功获取 5 个商品，详细信息已打印到控制台",
+  "total_count": 5
+}
+```
+
+### 错误响应
+```json
+{
+  "success": false,
+  "message": "错误信息"
+}
+```
+
+## 🖨️ 控制台输出格式
+
+```
+================================================================================
+📦 账号 12345678 的商品列表 (5 个商品)
+================================================================================
+
+🔸 商品 1:
+   商品ID: 123456789
+   商品标题: iPhone 13 Pro Max 256G
+   价格: 6999
+   状态: 在售
+   创建时间: 2025-07-23 10:30:00
+   更新时间: 2025-07-23 16:45:00
+   图片数量: 8
+   详细信息: {
+     "id": "123456789",
+     "title": "iPhone 13 Pro Max 256G",
+     "price": "6999",
+     "status": "在售",
+     ...
+   }
+
+🔸 商品 2:
+   ...
+
+================================================================================
+✅ 商品列表获取完成
+================================================================================
+```
+
+## ⚠️ 注意事项
+
+### 1. 使用限制
+- 需要选择有效的账号（不能是"全部账号"）
+- 需要账号的cookie信息有效
+- 需要网络连接正常
+
+### 2. 错误处理
+- Token失效时会自动刷新重试
+- 最多重试3次，避免无限循环
+- 网络异常时会显示错误信息
+
+### 3. 性能考虑
+- 获取过程可能需要几秒钟时间
+- 大量商品时控制台输出较多
+- 建议在网络良好时使用
+
+## 🔮 功能特色
+
+### 1. 智能重试机制
+- 自动检测token失效
+- 智能刷新token后重试
+- 避免因token问题导致的失败
+
+### 2. 详细信息输出
+- 完整的商品信息展示
+- 格式化的控制台输出
+- 便于调试和分析
+
+### 3. 用户友好界面
+- 直观的操作按钮
+- 实时状态反馈
+- 清晰的成功/失败提示
+
+### 4. 完整的日志记录
+- 详细的操作日志
+- 错误信息记录
+- 便于问题排查
+
+## 🚀 扩展可能
+
+### 1. 批量操作
+- 支持多个账号批量获取
+- 导出商品信息到文件
+- 商品信息对比分析
+
+### 2. 数据处理
+- 商品信息入库存储
+- 商品状态监控
+- 价格变化追踪
+
+### 3. 界面优化
+- 商品信息表格显示
+- 商品图片预览
+- 筛选和搜索功能
+
+---
+
+🎉 **获取所有商品功能已完成，支持一键获取指定账号的所有商品信息！**