同步更新：重构路由、服务模块，更新前端构建

db/__init__.py

@@ -0,0 +1,10 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+"""
+DB 包：按领域拆分的 DAO + schema/migrations。
+
+约束：
+- 外部仍通过 `import database` 访问稳定 API
+- 本包仅提供内部实现与组织结构（P2 / O-07）
+"""
+

db/accounts.py

@@ -0,0 +1,150 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+from __future__ import annotations
+
+import db_pool
+from crypto_utils import decrypt_password, encrypt_password
+from db.utils import get_cst_now_str
+
+
+def create_account(user_id, account_id, username, password, remember=True, remark=""):
+    """创建账号（密码加密存储）"""
+    with db_pool.get_db() as conn:
+        cursor = conn.cursor()
+        cst_time = get_cst_now_str()
+        encrypted_password = encrypt_password(password)
+        cursor.execute(
+            """
+            INSERT INTO accounts (id, user_id, username, password, remember, remark, created_at)
+            VALUES (?, ?, ?, ?, ?, ?, ?)
+            """,
+            (account_id, user_id, username, encrypted_password, 1 if remember else 0, remark, cst_time),
+        )
+        conn.commit()
+        return cursor.lastrowid
+
+
+def get_user_accounts(user_id):
+    """获取用户的所有账号（自动解密密码）"""
+    with db_pool.get_db() as conn:
+        cursor = conn.cursor()
+        cursor.execute("SELECT * FROM accounts WHERE user_id = ? ORDER BY created_at DESC", (user_id,))
+        accounts = []
+        for row in cursor.fetchall():
+            account = dict(row)
+            account["password"] = decrypt_password(account.get("password", ""))
+            accounts.append(account)
+        return accounts
+
+
+def get_account(account_id):
+    """获取单个账号（自动解密密码）"""
+    with db_pool.get_db() as conn:
+        cursor = conn.cursor()
+        cursor.execute("SELECT * FROM accounts WHERE id = ?", (account_id,))
+        row = cursor.fetchone()
+        if row:
+            account = dict(row)
+            account["password"] = decrypt_password(account.get("password", ""))
+            return account
+        return None
+
+
+def update_account_remark(account_id, remark):
+    """更新账号备注"""
+    with db_pool.get_db() as conn:
+        cursor = conn.cursor()
+        cursor.execute("UPDATE accounts SET remark = ? WHERE id = ?", (remark, account_id))
+        conn.commit()
+        return cursor.rowcount > 0
+
+
+def delete_account(account_id):
+    """删除账号"""
+    with db_pool.get_db() as conn:
+        cursor = conn.cursor()
+        cursor.execute("DELETE FROM accounts WHERE id = ?", (account_id,))
+        conn.commit()
+        return cursor.rowcount > 0
+
+
+def increment_account_login_fail(account_id, error_message):
+    """增加账号登录失败次数，如果达到3次则暂停账号"""
+    with db_pool.get_db() as conn:
+        cursor = conn.cursor()
+
+        cursor.execute("SELECT login_fail_count FROM accounts WHERE id = ?", (account_id,))
+        row = cursor.fetchone()
+        if not row:
+            return False
+
+        fail_count = (row["login_fail_count"] or 0) + 1
+
+        if fail_count >= 3:
+            cursor.execute(
+                """
+                UPDATE accounts
+                SET login_fail_count = ?,
+                    last_login_error = ?,
+                    status = 'suspended'
+                WHERE id = ?
+                """,
+                (fail_count, error_message, account_id),
+            )
+            conn.commit()
+            return True
+
+        cursor.execute(
+            """
+            UPDATE accounts
+            SET login_fail_count = ?,
+                last_login_error = ?
+            WHERE id = ?
+            """,
+            (fail_count, error_message, account_id),
+        )
+        conn.commit()
+        return False
+
+
+def reset_account_login_status(account_id):
+    """重置账号登录状态（修改密码后调用）"""
+    with db_pool.get_db() as conn:
+        cursor = conn.cursor()
+        cursor.execute(
+            """
+            UPDATE accounts
+            SET login_fail_count = 0,
+                last_login_error = NULL,
+                status = 'active'
+            WHERE id = ?
+            """,
+            (account_id,),
+        )
+        conn.commit()
+        return cursor.rowcount > 0
+
+
+def get_account_status(account_id):
+    """获取账号状态信息"""
+    with db_pool.get_db() as conn:
+        cursor = conn.cursor()
+        cursor.execute(
+            """
+            SELECT status, login_fail_count, last_login_error
+            FROM accounts
+            WHERE id = ?
+            """,
+            (account_id,),
+        )
+        return cursor.fetchone()
+
+
+def delete_user_accounts(user_id):
+    """删除用户的所有账号"""
+    with db_pool.get_db() as conn:
+        cursor = conn.cursor()
+        cursor.execute("DELETE FROM accounts WHERE user_id = ?", (user_id,))
+        conn.commit()
+        return cursor.rowcount
+

db/admin.py

@@ -0,0 +1,419 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+from __future__ import annotations
+
+import sqlite3
+from datetime import datetime, timedelta
+
+import pytz
+
+import db_pool
+from db.utils import get_cst_now_str
+from password_utils import (
+    hash_password_bcrypt,
+    is_sha256_hash,
+    verify_password_bcrypt,
+    verify_password_sha256,
+)
+
+
+def ensure_default_admin() -> bool:
+    """确保存在默认管理员账号（行为保持不变）。"""
+    import secrets
+    import string
+
+    with db_pool.get_db() as conn:
+        cursor = conn.cursor()
+        cursor.execute("SELECT COUNT(*) as count FROM admins")
+        result = cursor.fetchone()
+
+        if result["count"] == 0:
+            alphabet = string.ascii_letters + string.digits
+            random_password = "".join(secrets.choice(alphabet) for _ in range(12))
+
+            default_password_hash = hash_password_bcrypt(random_password)
+            cursor.execute(
+                "INSERT INTO admins (username, password_hash, created_at) VALUES (?, ?, ?)",
+                ("admin", default_password_hash, get_cst_now_str()),
+            )
+            conn.commit()
+            print("=" * 60)
+            print("安全提醒：已创建默认管理员账号")
+            print("用户名: admin")
+            print(f"密码: {random_password}")
+            print("请立即登录后修改密码！")
+            print("=" * 60)
+            return True
+        return False
+
+
+def verify_admin(username: str, password: str):
+    """验证管理员登录 - 自动从SHA256升级到bcrypt（行为保持不变）。"""
+    with db_pool.get_db() as conn:
+        cursor = conn.cursor()
+        cursor.execute("SELECT * FROM admins WHERE username = ?", (username,))
+        admin = cursor.fetchone()
+
+        if not admin:
+            return None
+
+        admin_dict = dict(admin)
+        password_hash = admin_dict["password_hash"]
+
+        if is_sha256_hash(password_hash):
+            if verify_password_sha256(password, password_hash):
+                new_hash = hash_password_bcrypt(password)
+                cursor.execute("UPDATE admins SET password_hash = ? WHERE username = ?", (new_hash, username))
+                conn.commit()
+                print(f"管理员 {username} 密码已自动升级到bcrypt")
+                return admin_dict
+            return None
+
+        if verify_password_bcrypt(password, password_hash):
+            return admin_dict
+        return None
+
+
+def update_admin_password(username: str, new_password: str) -> bool:
+    """更新管理员密码"""
+    with db_pool.get_db() as conn:
+        cursor = conn.cursor()
+        password_hash = hash_password_bcrypt(new_password)
+        cursor.execute("UPDATE admins SET password_hash = ? WHERE username = ?", (password_hash, username))
+        conn.commit()
+        return cursor.rowcount > 0
+
+
+def update_admin_username(old_username: str, new_username: str) -> bool:
+    """更新管理员用户名"""
+    with db_pool.get_db() as conn:
+        cursor = conn.cursor()
+        try:
+            cursor.execute("UPDATE admins SET username = ? WHERE username = ?", (new_username, old_username))
+            conn.commit()
+            return True
+        except sqlite3.IntegrityError:
+            return False
+
+
+def get_system_stats() -> dict:
+    """获取系统统计信息"""
+    with db_pool.get_db() as conn:
+        cursor = conn.cursor()
+
+        cursor.execute("SELECT COUNT(*) as count FROM users")
+        total_users = cursor.fetchone()["count"]
+
+        cursor.execute("SELECT COUNT(*) as count FROM users WHERE status = 'approved'")
+        approved_users = cursor.fetchone()["count"]
+
+        cursor.execute("SELECT COUNT(*) as count FROM users WHERE status = 'pending'")
+        pending_users = cursor.fetchone()["count"]
+
+        cursor.execute("SELECT COUNT(*) as count FROM accounts")
+        total_accounts = cursor.fetchone()["count"]
+
+        cursor.execute(
+            """
+            SELECT COUNT(*) as count FROM users
+            WHERE vip_expire_time IS NOT NULL
+            AND datetime(vip_expire_time) > datetime('now', 'localtime')
+            """
+        )
+        vip_users = cursor.fetchone()["count"]
+
+        return {
+            "total_users": total_users,
+            "approved_users": approved_users,
+            "pending_users": pending_users,
+            "total_accounts": total_accounts,
+            "vip_users": vip_users,
+        }
+
+
+def get_system_config_raw() -> dict:
+    """获取系统配置（无缓存，供 facade 做缓存/失效）。"""
+    with db_pool.get_db() as conn:
+        cursor = conn.cursor()
+        cursor.execute("SELECT * FROM system_config WHERE id = 1")
+        row = cursor.fetchone()
+
+        if row:
+            return dict(row)
+
+        return {
+            "max_concurrent_global": 2,
+            "max_concurrent_per_account": 1,
+            "max_screenshot_concurrent": 3,
+            "schedule_enabled": 0,
+            "schedule_time": "02:00",
+            "schedule_browse_type": "应读",
+            "schedule_weekdays": "1,2,3,4,5,6,7",
+            "proxy_enabled": 0,
+            "proxy_api_url": "",
+            "proxy_expire_minutes": 3,
+            "enable_screenshot": 1,
+            "auto_approve_enabled": 0,
+            "auto_approve_hourly_limit": 10,
+            "auto_approve_vip_days": 7,
+        }
+
+
+def update_system_config(
+    *,
+    max_concurrent=None,
+    schedule_enabled=None,
+    schedule_time=None,
+    schedule_browse_type=None,
+    schedule_weekdays=None,
+    max_concurrent_per_account=None,
+    max_screenshot_concurrent=None,
+    proxy_enabled=None,
+    proxy_api_url=None,
+    proxy_expire_minutes=None,
+    auto_approve_enabled=None,
+    auto_approve_hourly_limit=None,
+    auto_approve_vip_days=None,
+) -> bool:
+    """更新系统配置（仅更新DB，不做缓存处理）。"""
+    allowed_fields = {
+        "max_concurrent_global",
+        "schedule_enabled",
+        "schedule_time",
+        "schedule_browse_type",
+        "schedule_weekdays",
+        "max_concurrent_per_account",
+        "max_screenshot_concurrent",
+        "proxy_enabled",
+        "proxy_api_url",
+        "proxy_expire_minutes",
+        "auto_approve_enabled",
+        "auto_approve_hourly_limit",
+        "auto_approve_vip_days",
+        "updated_at",
+    }
+
+    with db_pool.get_db() as conn:
+        cursor = conn.cursor()
+        updates = []
+        params = []
+
+        if max_concurrent is not None:
+            updates.append("max_concurrent_global = ?")
+            params.append(max_concurrent)
+        if schedule_enabled is not None:
+            updates.append("schedule_enabled = ?")
+            params.append(schedule_enabled)
+        if schedule_time is not None:
+            updates.append("schedule_time = ?")
+            params.append(schedule_time)
+        if schedule_browse_type is not None:
+            updates.append("schedule_browse_type = ?")
+            params.append(schedule_browse_type)
+        if max_concurrent_per_account is not None:
+            updates.append("max_concurrent_per_account = ?")
+            params.append(max_concurrent_per_account)
+        if max_screenshot_concurrent is not None:
+            updates.append("max_screenshot_concurrent = ?")
+            params.append(max_screenshot_concurrent)
+        if schedule_weekdays is not None:
+            updates.append("schedule_weekdays = ?")
+            params.append(schedule_weekdays)
+        if proxy_enabled is not None:
+            updates.append("proxy_enabled = ?")
+            params.append(proxy_enabled)
+        if proxy_api_url is not None:
+            updates.append("proxy_api_url = ?")
+            params.append(proxy_api_url)
+        if proxy_expire_minutes is not None:
+            updates.append("proxy_expire_minutes = ?")
+            params.append(proxy_expire_minutes)
+        if auto_approve_enabled is not None:
+            updates.append("auto_approve_enabled = ?")
+            params.append(auto_approve_enabled)
+        if auto_approve_hourly_limit is not None:
+            updates.append("auto_approve_hourly_limit = ?")
+            params.append(auto_approve_hourly_limit)
+        if auto_approve_vip_days is not None:
+            updates.append("auto_approve_vip_days = ?")
+            params.append(auto_approve_vip_days)
+
+        if not updates:
+            return False
+
+        updates.append("updated_at = ?")
+        params.append(get_cst_now_str())
+
+        for update_clause in updates:
+            field_name = update_clause.split("=")[0].strip()
+            if field_name not in allowed_fields:
+                raise ValueError(f"非法字段名: {field_name}")
+
+        sql = f"UPDATE system_config SET {', '.join(updates)} WHERE id = 1"
+        cursor.execute(sql, params)
+        conn.commit()
+        return True
+
+
+def get_hourly_registration_count() -> int:
+    """获取最近一小时内的注册用户数"""
+    with db_pool.get_db() as conn:
+        cursor = conn.cursor()
+        cursor.execute(
+            """
+            SELECT COUNT(*) FROM users
+            WHERE created_at >= datetime('now', 'localtime', '-1 hour')
+            """
+        )
+        return cursor.fetchone()[0]
+
+
+# ==================== 密码重置（管理员） ====================
+
+
+def create_password_reset_request(user_id: int, new_password: str):
+    """创建密码重置申请（存储哈希）"""
+    with db_pool.get_db() as conn:
+        cursor = conn.cursor()
+        password_hash = hash_password_bcrypt(new_password)
+        cst_time = get_cst_now_str()
+
+        try:
+            cursor.execute(
+                """
+                INSERT INTO password_reset_requests (user_id, new_password_hash, status, created_at)
+                VALUES (?, ?, 'pending', ?)
+                """,
+                (user_id, password_hash, cst_time),
+            )
+            conn.commit()
+            return cursor.lastrowid
+        except Exception as e:
+            print(f"创建密码重置申请失败: {e}")
+            return None
+
+
+def get_pending_password_resets():
+    """获取待审核的密码重置申请列表"""
+    with db_pool.get_db() as conn:
+        cursor = conn.cursor()
+        cursor.execute(
+            """
+            SELECT r.id, r.user_id, r.created_at, r.status,
+                   u.username, u.email
+            FROM password_reset_requests r
+            JOIN users u ON r.user_id = u.id
+            WHERE r.status = 'pending'
+            ORDER BY r.created_at DESC
+            """
+        )
+        return [dict(row) for row in cursor.fetchall()]
+
+
+def approve_password_reset(request_id: int) -> bool:
+    """批准密码重置申请"""
+    with db_pool.get_db() as conn:
+        cursor = conn.cursor()
+        cst_time = get_cst_now_str()
+
+        try:
+            cursor.execute(
+                """
+                SELECT user_id, new_password_hash
+                FROM password_reset_requests
+                WHERE id = ? AND status = 'pending'
+                """,
+                (request_id,),
+            )
+
+            result = cursor.fetchone()
+            if not result:
+                return False
+
+            user_id = result["user_id"]
+            new_password_hash = result["new_password_hash"]
+
+            cursor.execute("UPDATE users SET password_hash = ? WHERE id = ?", (new_password_hash, user_id))
+
+            cursor.execute(
+                """
+                UPDATE password_reset_requests
+                SET status = 'approved', processed_at = ?
+                WHERE id = ?
+                """,
+                (cst_time, request_id),
+            )
+
+            conn.commit()
+            return True
+        except Exception as e:
+            print(f"批准密码重置失败: {e}")
+            return False
+
+
+def reject_password_reset(request_id: int) -> bool:
+    """拒绝密码重置申请"""
+    with db_pool.get_db() as conn:
+        cursor = conn.cursor()
+        cst_time = get_cst_now_str()
+
+        try:
+            cursor.execute(
+                """
+                UPDATE password_reset_requests
+                SET status = 'rejected', processed_at = ?
+                WHERE id = ? AND status = 'pending'
+                """,
+                (cst_time, request_id),
+            )
+            conn.commit()
+            return cursor.rowcount > 0
+        except Exception as e:
+            print(f"拒绝密码重置失败: {e}")
+            return False
+
+
+def admin_reset_user_password(user_id: int, new_password: str) -> bool:
+    """管理员直接重置用户密码"""
+    with db_pool.get_db() as conn:
+        cursor = conn.cursor()
+        password_hash = hash_password_bcrypt(new_password)
+        try:
+            cursor.execute("UPDATE users SET password_hash = ? WHERE id = ?", (password_hash, user_id))
+            conn.commit()
+            return cursor.rowcount > 0
+        except Exception as e:
+            print(f"管理员重置密码失败: {e}")
+            return False
+
+
+def clean_old_operation_logs(days: int = 30) -> int:
+    """清理指定天数前的操作日志（如果存在operation_logs表）"""
+    with db_pool.get_db() as conn:
+        cursor = conn.cursor()
+
+        cursor.execute(
+            """
+            SELECT name FROM sqlite_master
+            WHERE type='table' AND name='operation_logs'
+            """
+        )
+
+        if not cursor.fetchone():
+            return 0
+
+        try:
+            cursor.execute(
+                """
+                DELETE FROM operation_logs
+                WHERE created_at < datetime('now', 'localtime', '-' || ? || ' days')
+                """,
+                (days,),
+            )
+            deleted_count = cursor.rowcount
+            conn.commit()
+            print(f"已清理 {deleted_count} 条旧操作日志 (>{days}天)")
+            return deleted_count
+        except Exception as e:
+            print(f"清理旧操作日志失败: {e}")
+            return 0

db/announcements.py

@@ -0,0 +1,132 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+from __future__ import annotations
+
+import db_pool
+from db.utils import get_cst_now_str
+
+
+def create_announcement(title, content, is_active=True):
+    """创建公告（默认启用；启用时会自动停用其他公告）"""
+    title = (title or "").strip()
+    content = (content or "").strip()
+    if not title or not content:
+        return None
+
+    with db_pool.get_db() as conn:
+        cursor = conn.cursor()
+        cst_time = get_cst_now_str()
+
+        if is_active:
+            cursor.execute("UPDATE announcements SET is_active = 0, updated_at = ? WHERE is_active = 1", (cst_time,))
+
+        cursor.execute(
+            """
+            INSERT INTO announcements (title, content, is_active, created_at, updated_at)
+            VALUES (?, ?, ?, ?, ?)
+            """,
+            (title, content, 1 if is_active else 0, cst_time, cst_time),
+        )
+        conn.commit()
+        return cursor.lastrowid
+
+
+def get_announcement_by_id(announcement_id):
+    """根据ID获取公告"""
+    with db_pool.get_db() as conn:
+        cursor = conn.cursor()
+        cursor.execute("SELECT * FROM announcements WHERE id = ?", (announcement_id,))
+        row = cursor.fetchone()
+        return dict(row) if row else None
+
+
+def get_announcements(limit=50, offset=0):
+    """获取公告列表（管理员用）"""
+    with db_pool.get_db() as conn:
+        cursor = conn.cursor()
+        cursor.execute(
+            """
+            SELECT * FROM announcements
+            ORDER BY created_at DESC, id DESC
+            LIMIT ? OFFSET ?
+            """,
+            (limit, offset),
+        )
+        return [dict(row) for row in cursor.fetchall()]
+
+
+def set_announcement_active(announcement_id, is_active):
+    """启用/停用公告；启用时会自动停用其他公告"""
+    with db_pool.get_db() as conn:
+        cursor = conn.cursor()
+        cst_time = get_cst_now_str()
+
+        if is_active:
+            cursor.execute("UPDATE announcements SET is_active = 0, updated_at = ? WHERE is_active = 1", (cst_time,))
+            cursor.execute(
+                """
+                UPDATE announcements
+                SET is_active = 1, updated_at = ?
+                WHERE id = ?
+                """,
+                (cst_time, announcement_id),
+            )
+        else:
+            cursor.execute(
+                """
+                UPDATE announcements
+                SET is_active = 0, updated_at = ?
+                WHERE id = ?
+                """,
+                (cst_time, announcement_id),
+            )
+
+        conn.commit()
+        return cursor.rowcount > 0
+
+
+def delete_announcement(announcement_id):
+    """删除公告（同时清理用户关闭记录）"""
+    with db_pool.get_db() as conn:
+        cursor = conn.cursor()
+        cursor.execute("DELETE FROM announcement_dismissals WHERE announcement_id = ?", (announcement_id,))
+        cursor.execute("DELETE FROM announcements WHERE id = ?", (announcement_id,))
+        conn.commit()
+        return cursor.rowcount > 0
+
+
+def get_active_announcement_for_user(user_id):
+    """获取当前用户应展示的启用公告（已永久关闭的不再返回）"""
+    with db_pool.get_db() as conn:
+        cursor = conn.cursor()
+        cursor.execute(
+            """
+            SELECT a.*
+            FROM announcements a
+            LEFT JOIN announcement_dismissals d
+              ON d.announcement_id = a.id AND d.user_id = ?
+            WHERE a.is_active = 1 AND d.announcement_id IS NULL
+            ORDER BY a.created_at DESC, a.id DESC
+            LIMIT 1
+            """,
+            (user_id,),
+        )
+        row = cursor.fetchone()
+        return dict(row) if row else None
+
+
+def dismiss_announcement_for_user(user_id, announcement_id):
+    """用户永久关闭某条公告（幂等）"""
+    with db_pool.get_db() as conn:
+        cursor = conn.cursor()
+        cst_time = get_cst_now_str()
+        cursor.execute(
+            """
+            INSERT OR IGNORE INTO announcement_dismissals (user_id, announcement_id, dismissed_at)
+            VALUES (?, ?, ?)
+            """,
+            (user_id, announcement_id, cst_time),
+        )
+        conn.commit()
+        return cursor.rowcount >= 0
+

db/email.py

@@ -0,0 +1,62 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+from __future__ import annotations
+
+import db_pool
+
+
+def get_user_by_email(email):
+    """根据邮箱获取用户"""
+    with db_pool.get_db() as conn:
+        cursor = conn.cursor()
+        cursor.execute("SELECT * FROM users WHERE email = ?", (email,))
+        user = cursor.fetchone()
+        return dict(user) if user else None
+
+
+def update_user_email(user_id, email, verified=False):
+    """更新用户邮箱"""
+    with db_pool.get_db() as conn:
+        cursor = conn.cursor()
+
+        cursor.execute(
+            """
+            UPDATE users
+            SET email = ?, email_verified = ?
+            WHERE id = ?
+            """,
+            (email, int(verified), user_id),
+        )
+        conn.commit()
+        return cursor.rowcount > 0
+
+
+def update_user_email_notify(user_id, enabled):
+    """更新用户邮件通知偏好"""
+    with db_pool.get_db() as conn:
+        cursor = conn.cursor()
+
+        cursor.execute(
+            """
+            UPDATE users
+            SET email_notify_enabled = ?
+            WHERE id = ?
+            """,
+            (int(enabled), user_id),
+        )
+        conn.commit()
+        return cursor.rowcount > 0
+
+
+def get_user_email_notify(user_id):
+    """获取用户邮件通知偏好（默认开启）"""
+    with db_pool.get_db() as conn:
+        cursor = conn.cursor()
+        try:
+            cursor.execute("SELECT email_notify_enabled FROM users WHERE id = ?", (user_id,))
+            row = cursor.fetchone()
+            if row is None:
+                return True
+            return bool(row[0]) if row[0] is not None else True
+        except Exception:
+            return True

db/feedbacks.py

@@ -0,0 +1,144 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+from __future__ import annotations
+
+from datetime import datetime
+
+import pytz
+
+import db_pool
+from db.utils import escape_html
+
+
+def create_bug_feedback(user_id, username, title, description, contact=""):
+    """创建Bug反馈（带XSS防护）"""
+    with db_pool.get_db() as conn:
+        cursor = conn.cursor()
+        cst_tz = pytz.timezone("Asia/Shanghai")
+        cst_time = datetime.now(cst_tz).strftime("%Y-%m-%d %H:%M:%S")
+
+        safe_title = escape_html(title) if title else ""
+        safe_description = escape_html(description) if description else ""
+        safe_contact = escape_html(contact) if contact else ""
+        safe_username = escape_html(username) if username else ""
+
+        cursor.execute(
+            """
+            INSERT INTO bug_feedbacks (user_id, username, title, description, contact, created_at)
+            VALUES (?, ?, ?, ?, ?, ?)
+            """,
+            (user_id, safe_username, safe_title, safe_description, safe_contact, cst_time),
+        )
+
+        conn.commit()
+        return cursor.lastrowid
+
+
+def get_bug_feedbacks(limit=100, offset=0, status_filter=None):
+    """获取Bug反馈列表（管理员用）"""
+    with db_pool.get_db() as conn:
+        cursor = conn.cursor()
+
+        sql = "SELECT * FROM bug_feedbacks WHERE 1=1"
+        params = []
+
+        if status_filter:
+            sql += " AND status = ?"
+            params.append(status_filter)
+
+        sql += " ORDER BY created_at DESC LIMIT ? OFFSET ?"
+        params.extend([limit, offset])
+
+        cursor.execute(sql, params)
+        return [dict(row) for row in cursor.fetchall()]
+
+
+def get_user_feedbacks(user_id, limit=50):
+    """获取用户自己的反馈列表"""
+    with db_pool.get_db() as conn:
+        cursor = conn.cursor()
+        cursor.execute(
+            """
+            SELECT * FROM bug_feedbacks
+            WHERE user_id = ?
+            ORDER BY created_at DESC
+            LIMIT ?
+            """,
+            (user_id, limit),
+        )
+        return [dict(row) for row in cursor.fetchall()]
+
+
+def get_feedback_by_id(feedback_id):
+    """根据ID获取反馈详情"""
+    with db_pool.get_db() as conn:
+        cursor = conn.cursor()
+        cursor.execute("SELECT * FROM bug_feedbacks WHERE id = ?", (feedback_id,))
+        row = cursor.fetchone()
+        return dict(row) if row else None
+
+
+def reply_feedback(feedback_id, admin_reply):
+    """管理员回复反馈（带XSS防护）"""
+    with db_pool.get_db() as conn:
+        cursor = conn.cursor()
+        cst_tz = pytz.timezone("Asia/Shanghai")
+        cst_time = datetime.now(cst_tz).strftime("%Y-%m-%d %H:%M:%S")
+
+        safe_reply = escape_html(admin_reply) if admin_reply else ""
+
+        cursor.execute(
+            """
+            UPDATE bug_feedbacks
+            SET admin_reply = ?, status = 'replied', replied_at = ?
+            WHERE id = ?
+            """,
+            (safe_reply, cst_time, feedback_id),
+        )
+
+        conn.commit()
+        return cursor.rowcount > 0
+
+
+def close_feedback(feedback_id):
+    """关闭反馈"""
+    with db_pool.get_db() as conn:
+        cursor = conn.cursor()
+        cursor.execute(
+            """
+            UPDATE bug_feedbacks
+            SET status = 'closed'
+            WHERE id = ?
+            """,
+            (feedback_id,),
+        )
+        conn.commit()
+        return cursor.rowcount > 0
+
+
+def delete_feedback(feedback_id):
+    """删除反馈"""
+    with db_pool.get_db() as conn:
+        cursor = conn.cursor()
+        cursor.execute("DELETE FROM bug_feedbacks WHERE id = ?", (feedback_id,))
+        conn.commit()
+        return cursor.rowcount > 0
+
+
+def get_feedback_stats():
+    """获取反馈统计"""
+    with db_pool.get_db() as conn:
+        cursor = conn.cursor()
+        cursor.execute(
+            """
+            SELECT
+                COUNT(*) as total,
+                SUM(CASE WHEN status = 'pending' THEN 1 ELSE 0 END) as pending,
+                SUM(CASE WHEN status = 'replied' THEN 1 ELSE 0 END) as replied,
+                SUM(CASE WHEN status = 'closed' THEN 1 ELSE 0 END) as closed
+            FROM bug_feedbacks
+            """
+        )
+        row = cursor.fetchone()
+        return dict(row) if row else {"total": 0, "pending": 0, "replied": 0, "closed": 0}
+

db/migrations.py

@@ -0,0 +1,452 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+from __future__ import annotations
+
+import sqlite3
+
+from db.utils import get_cst_now_str
+
+
+def get_current_version(conn) -> int:
+    cursor = conn.cursor()
+    cursor.execute("SELECT version FROM db_version WHERE id = 1")
+    row = cursor.fetchone()
+    if not row:
+        return 0
+    try:
+        return int(row["version"])
+    except Exception:
+        try:
+            return int(row[0])
+        except Exception:
+            return 0
+
+
+def set_current_version(conn, version: int) -> None:
+    cursor = conn.cursor()
+    cursor.execute("UPDATE db_version SET version = ?, updated_at = ? WHERE id = 1", (int(version), get_cst_now_str()))
+    conn.commit()
+
+
+def migrate_database(conn, target_version: int) -> None:
+    """数据库迁移：按版本增量升级（向前兼容）。"""
+    cursor = conn.cursor()
+    cursor.execute("INSERT OR IGNORE INTO db_version (id, version, updated_at) VALUES (1, 0, ?)", (get_cst_now_str(),))
+    conn.commit()
+
+    current_version = get_current_version(conn)
+
+    if current_version < 1:
+        _migrate_to_v1(conn)
+        current_version = 1
+    if current_version < 2:
+        _migrate_to_v2(conn)
+        current_version = 2
+    if current_version < 3:
+        _migrate_to_v3(conn)
+        current_version = 3
+    if current_version < 4:
+        _migrate_to_v4(conn)
+        current_version = 4
+    if current_version < 5:
+        _migrate_to_v5(conn)
+        current_version = 5
+    if current_version < 6:
+        _migrate_to_v6(conn)
+        current_version = 6
+    if current_version < 7:
+        _migrate_to_v7(conn)
+        current_version = 7
+    if current_version < 8:
+        _migrate_to_v8(conn)
+        current_version = 8
+    if current_version < 9:
+        _migrate_to_v9(conn)
+        current_version = 9
+    if current_version < 10:
+        _migrate_to_v10(conn)
+        current_version = 10
+
+    if current_version != int(target_version):
+        set_current_version(conn, int(target_version))
+
+
+def _migrate_to_v1(conn):
+    """迁移到版本1 - 添加缺失字段"""
+    cursor = conn.cursor()
+
+    cursor.execute("PRAGMA table_info(system_config)")
+    columns = [col[1] for col in cursor.fetchall()]
+
+    if "schedule_weekdays" not in columns:
+        cursor.execute('ALTER TABLE system_config ADD COLUMN schedule_weekdays TEXT DEFAULT "1,2,3,4,5,6,7"')
+        print("  ✓ 添加 schedule_weekdays 字段")
+
+    if "max_screenshot_concurrent" not in columns:
+        cursor.execute("ALTER TABLE system_config ADD COLUMN max_screenshot_concurrent INTEGER DEFAULT 3")
+        print("  ✓ 添加 max_screenshot_concurrent 字段")
+    if "max_concurrent_per_account" not in columns:
+        cursor.execute("ALTER TABLE system_config ADD COLUMN max_concurrent_per_account INTEGER DEFAULT 1")
+        print("  ✓ 添加 max_concurrent_per_account 字段")
+    if "auto_approve_enabled" not in columns:
+        cursor.execute("ALTER TABLE system_config ADD COLUMN auto_approve_enabled INTEGER DEFAULT 0")
+        print("  ✓ 添加 auto_approve_enabled 字段")
+    if "auto_approve_hourly_limit" not in columns:
+        cursor.execute("ALTER TABLE system_config ADD COLUMN auto_approve_hourly_limit INTEGER DEFAULT 10")
+        print("  ✓ 添加 auto_approve_hourly_limit 字段")
+    if "auto_approve_vip_days" not in columns:
+        cursor.execute("ALTER TABLE system_config ADD COLUMN auto_approve_vip_days INTEGER DEFAULT 7")
+        print("  ✓ 添加 auto_approve_vip_days 字段")
+
+    cursor.execute("PRAGMA table_info(task_logs)")
+    columns = [col[1] for col in cursor.fetchall()]
+    if "duration" not in columns:
+        cursor.execute("ALTER TABLE task_logs ADD COLUMN duration INTEGER")
+        print("  ✓ 添加 duration 字段到 task_logs")
+
+    conn.commit()
+
+
+def _migrate_to_v2(conn):
+    """迁移到版本2 - 添加代理配置字段"""
+    cursor = conn.cursor()
+
+    cursor.execute("PRAGMA table_info(system_config)")
+    columns = [col[1] for col in cursor.fetchall()]
+
+    if "proxy_enabled" not in columns:
+        cursor.execute("ALTER TABLE system_config ADD COLUMN proxy_enabled INTEGER DEFAULT 0")
+        print("  ✓ 添加 proxy_enabled 字段")
+
+    if "proxy_api_url" not in columns:
+        cursor.execute('ALTER TABLE system_config ADD COLUMN proxy_api_url TEXT DEFAULT ""')
+        print("  ✓ 添加 proxy_api_url 字段")
+
+    if "proxy_expire_minutes" not in columns:
+        cursor.execute("ALTER TABLE system_config ADD COLUMN proxy_expire_minutes INTEGER DEFAULT 3")
+        print("  ✓ 添加 proxy_expire_minutes 字段")
+
+    if "enable_screenshot" not in columns:
+        cursor.execute("ALTER TABLE system_config ADD COLUMN enable_screenshot INTEGER DEFAULT 1")
+        print("  ✓ 添加 enable_screenshot 字段")
+
+    conn.commit()
+
+
+def _migrate_to_v3(conn):
+    """迁移到版本3 - 添加账号状态和登录失败计数字段"""
+    cursor = conn.cursor()
+
+    cursor.execute("PRAGMA table_info(accounts)")
+    columns = [col[1] for col in cursor.fetchall()]
+
+    if "status" not in columns:
+        cursor.execute('ALTER TABLE accounts ADD COLUMN status TEXT DEFAULT "active"')
+        print("  ✓ 添加 accounts.status 字段 (账号状态)")
+
+    if "login_fail_count" not in columns:
+        cursor.execute("ALTER TABLE accounts ADD COLUMN login_fail_count INTEGER DEFAULT 0")
+        print("  ✓ 添加 accounts.login_fail_count 字段 (登录失败计数)")
+
+    if "last_login_error" not in columns:
+        cursor.execute("ALTER TABLE accounts ADD COLUMN last_login_error TEXT")
+        print("  ✓ 添加 accounts.last_login_error 字段 (最后登录错误)")
+
+    conn.commit()
+
+
+def _migrate_to_v4(conn):
+    """迁移到版本4 - 添加任务来源字段"""
+    cursor = conn.cursor()
+
+    cursor.execute("PRAGMA table_info(task_logs)")
+    columns = [col[1] for col in cursor.fetchall()]
+
+    if "source" not in columns:
+        cursor.execute('ALTER TABLE task_logs ADD COLUMN source TEXT DEFAULT "manual"')
+        print("  ✓ 添加 task_logs.source 字段 (任务来源: manual/scheduled/immediate)")
+
+    conn.commit()
+
+
+def _migrate_to_v5(conn):
+    """迁移到版本5 - 添加用户定时任务表"""
+    cursor = conn.cursor()
+
+    cursor.execute("SELECT name FROM sqlite_master WHERE type='table' AND name='user_schedules'")
+    if not cursor.fetchone():
+        cursor.execute(
+            """
+            CREATE TABLE IF NOT EXISTS user_schedules (
+                id INTEGER PRIMARY KEY AUTOINCREMENT,
+                user_id INTEGER NOT NULL,
+                name TEXT DEFAULT '我的定时任务',
+                enabled INTEGER DEFAULT 0,
+                schedule_time TEXT NOT NULL DEFAULT '08:00',
+                weekdays TEXT NOT NULL DEFAULT '1,2,3,4,5',
+                browse_type TEXT NOT NULL DEFAULT '应读',
+                enable_screenshot INTEGER DEFAULT 1,
+                account_ids TEXT,
+                last_run_at TIMESTAMP,
+                next_run_at TIMESTAMP,
+                created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP,
+                updated_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP,
+                FOREIGN KEY (user_id) REFERENCES users (id) ON DELETE CASCADE
+            )
+            """
+        )
+        print("  ✓ 创建 user_schedules 表 (用户定时任务)")
+
+        cursor.execute(
+            """
+            CREATE TABLE IF NOT EXISTS schedule_execution_logs (
+                id INTEGER PRIMARY KEY AUTOINCREMENT,
+                schedule_id INTEGER NOT NULL,
+                user_id INTEGER NOT NULL,
+                schedule_name TEXT,
+                execute_time TIMESTAMP DEFAULT CURRENT_TIMESTAMP,
+                total_accounts INTEGER DEFAULT 0,
+                success_accounts INTEGER DEFAULT 0,
+                failed_accounts INTEGER DEFAULT 0,
+                total_items INTEGER DEFAULT 0,
+                total_attachments INTEGER DEFAULT 0,
+                total_screenshots INTEGER DEFAULT 0,
+                duration_seconds INTEGER DEFAULT 0,
+                status TEXT DEFAULT 'running',
+                error_message TEXT,
+                FOREIGN KEY (schedule_id) REFERENCES user_schedules (id) ON DELETE CASCADE,
+                FOREIGN KEY (user_id) REFERENCES users (id) ON DELETE CASCADE
+            )
+            """
+        )
+        print("  ✓ 创建 schedule_execution_logs 表 (定时任务执行日志)")
+
+        cursor.execute("CREATE INDEX IF NOT EXISTS idx_user_schedules_user_id ON user_schedules(user_id)")
+        cursor.execute("CREATE INDEX IF NOT EXISTS idx_user_schedules_enabled ON user_schedules(enabled)")
+        cursor.execute("CREATE INDEX IF NOT EXISTS idx_user_schedules_next_run ON user_schedules(next_run_at)")
+        print("  ✓ 创建 user_schedules 表索引")
+
+    conn.commit()
+
+
+def _migrate_to_v6(conn):
+    """迁移到版本6 - 添加公告功能相关表"""
+    cursor = conn.cursor()
+
+    cursor.execute("SELECT name FROM sqlite_master WHERE type='table' AND name='announcements'")
+    if not cursor.fetchone():
+        cursor.execute(
+            """
+            CREATE TABLE IF NOT EXISTS announcements (
+                id INTEGER PRIMARY KEY AUTOINCREMENT,
+                title TEXT NOT NULL,
+                content TEXT NOT NULL,
+                is_active INTEGER DEFAULT 1,
+                created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP,
+                updated_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP
+            )
+            """
+        )
+        print("  ✓ 创建 announcements 表 (公告)")
+        cursor.execute("CREATE INDEX IF NOT EXISTS idx_announcements_active ON announcements(is_active)")
+        cursor.execute("CREATE INDEX IF NOT EXISTS idx_announcements_created_at ON announcements(created_at)")
+        print("  ✓ 创建 announcements 表索引")
+
+    cursor.execute("SELECT name FROM sqlite_master WHERE type='table' AND name='announcement_dismissals'")
+    if not cursor.fetchone():
+        cursor.execute(
+            """
+            CREATE TABLE IF NOT EXISTS announcement_dismissals (
+                user_id INTEGER NOT NULL,
+                announcement_id INTEGER NOT NULL,
+                dismissed_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP,
+                PRIMARY KEY (user_id, announcement_id),
+                FOREIGN KEY (user_id) REFERENCES users (id) ON DELETE CASCADE,
+                FOREIGN KEY (announcement_id) REFERENCES announcements (id) ON DELETE CASCADE
+            )
+            """
+        )
+        print("  ✓ 创建 announcement_dismissals 表 (公告永久关闭记录)")
+        cursor.execute("CREATE INDEX IF NOT EXISTS idx_announcement_dismissals_user ON announcement_dismissals(user_id)")
+        print("  ✓ 创建 announcement_dismissals 表索引")
+
+    conn.commit()
+
+
+def _migrate_to_v7(conn):
+    """迁移到版本7 - 统一存储北京时间（将历史UTC时间字段整体+8小时）"""
+    cursor = conn.cursor()
+
+    def table_exists(table_name: str) -> bool:
+        cursor.execute("SELECT name FROM sqlite_master WHERE type='table' AND name=?", (table_name,))
+        return cursor.fetchone() is not None
+
+    def column_exists(table_name: str, column_name: str) -> bool:
+        cursor.execute(f"PRAGMA table_info({table_name})")
+        return any(row[1] == column_name for row in cursor.fetchall())
+
+    def shift_utc_to_cst(table_name: str, column_name: str) -> None:
+        if not table_exists(table_name):
+            return
+        if not column_exists(table_name, column_name):
+            return
+        cursor.execute(
+            f"""
+            UPDATE {table_name}
+            SET {column_name} = datetime({column_name}, '+8 hours')
+            WHERE {column_name} IS NOT NULL AND {column_name} != ''
+            """
+        )
+
+    for table, col in [
+        ("users", "created_at"),
+        ("users", "approved_at"),
+        ("admins", "created_at"),
+        ("accounts", "created_at"),
+        ("password_reset_requests", "created_at"),
+        ("password_reset_requests", "processed_at"),
+    ]:
+        shift_utc_to_cst(table, col)
+
+    for table, col in [
+        ("smtp_configs", "created_at"),
+        ("smtp_configs", "updated_at"),
+        ("smtp_configs", "last_success_at"),
+        ("email_settings", "updated_at"),
+        ("email_tokens", "created_at"),
+        ("email_logs", "created_at"),
+        ("email_stats", "last_updated"),
+    ]:
+        shift_utc_to_cst(table, col)
+
+    for table, col in [
+        ("task_checkpoints", "created_at"),
+        ("task_checkpoints", "updated_at"),
+        ("task_checkpoints", "completed_at"),
+    ]:
+        shift_utc_to_cst(table, col)
+
+    conn.commit()
+    print("  ✓ 时区迁移：历史UTC时间已转换为北京时间")
+
+
+def _migrate_to_v8(conn):
+    """迁移到版本8 - 用户定时 next_run_at 随机延迟落库（O-08）"""
+    cursor = conn.cursor()
+
+    # 1) 增量字段：random_delay（旧库可能不存在）
+    cursor.execute("PRAGMA table_info(user_schedules)")
+    columns = [col[1] for col in cursor.fetchall()]
+    if "random_delay" not in columns:
+        cursor.execute("ALTER TABLE user_schedules ADD COLUMN random_delay INTEGER DEFAULT 0")
+        print("  ✓ 添加 user_schedules.random_delay 字段")
+
+    if "next_run_at" not in columns:
+        cursor.execute("ALTER TABLE user_schedules ADD COLUMN next_run_at TIMESTAMP")
+        print("  ✓ 添加 user_schedules.next_run_at 字段")
+
+    cursor.execute("CREATE INDEX IF NOT EXISTS idx_user_schedules_next_run ON user_schedules(next_run_at)")
+    conn.commit()
+
+    # 2) 为历史 enabled schedule 补算 next_run_at（保证索引驱动可用）
+    try:
+        from services.schedule_utils import compute_next_run_at, format_cst
+        from services.time_utils import get_beijing_now
+
+        now_dt = get_beijing_now()
+        now_str = format_cst(now_dt)
+
+        cursor.execute(
+            """
+            SELECT id, schedule_time, weekdays, random_delay, last_run_at, next_run_at
+            FROM user_schedules
+            WHERE enabled = 1
+            """
+        )
+        rows = cursor.fetchall() or []
+
+        fixed = 0
+        for row in rows:
+            try:
+                schedule_id = row["id"] if isinstance(row, sqlite3.Row) else row[0]
+                schedule_time = row["schedule_time"] if isinstance(row, sqlite3.Row) else row[1]
+                weekdays = row["weekdays"] if isinstance(row, sqlite3.Row) else row[2]
+                random_delay = row["random_delay"] if isinstance(row, sqlite3.Row) else row[3]
+                last_run_at = row["last_run_at"] if isinstance(row, sqlite3.Row) else row[4]
+                next_run_at = row["next_run_at"] if isinstance(row, sqlite3.Row) else row[5]
+            except Exception:
+                continue
+
+            next_run_text = str(next_run_at or "").strip()
+            # 若 next_run_at 为空/非法/已过期，则重算
+            if (not next_run_text) or (next_run_text <= now_str):
+                next_dt = compute_next_run_at(
+                    now=now_dt,
+                    schedule_time=str(schedule_time or "08:00"),
+                    weekdays=str(weekdays or "1,2,3,4,5"),
+                    random_delay=int(random_delay or 0),
+                    last_run_at=str(last_run_at or "") if last_run_at else None,
+                )
+                next_run_text = format_cst(next_dt)
+                cursor.execute(
+                    "UPDATE user_schedules SET next_run_at = ?, updated_at = ? WHERE id = ?",
+                    (next_run_text, get_cst_now_str(), int(schedule_id)),
+                )
+                fixed += 1
+
+        conn.commit()
+        if fixed:
+            print(f"  ✓ 已为 {fixed} 条启用定时任务补算 next_run_at")
+    except Exception as e:
+        # 迁移过程中不阻断主流程；上线后由 worker 兜底补算
+        print(f"  ⚠ v8 迁移补算 next_run_at 失败: {e}")
+
+
+def _migrate_to_v9(conn):
+    """迁移到版本9 - 邮件设置字段迁移（清理 email_service scattered ALTER TABLE）"""
+    cursor = conn.cursor()
+
+    cursor.execute("SELECT name FROM sqlite_master WHERE type='table' AND name='email_settings'")
+    if not cursor.fetchone():
+        # 邮件表由 email_service.init_email_tables 创建；此处仅做增量字段迁移
+        return
+
+    cursor.execute("PRAGMA table_info(email_settings)")
+    columns = [col[1] for col in cursor.fetchall()]
+
+    changed = False
+    if "register_verify_enabled" not in columns:
+        cursor.execute("ALTER TABLE email_settings ADD COLUMN register_verify_enabled INTEGER DEFAULT 0")
+        print("  ✓ 添加 email_settings.register_verify_enabled 字段")
+        changed = True
+    if "base_url" not in columns:
+        cursor.execute("ALTER TABLE email_settings ADD COLUMN base_url TEXT DEFAULT ''")
+        print("  ✓ 添加 email_settings.base_url 字段")
+        changed = True
+    if "task_notify_enabled" not in columns:
+        cursor.execute("ALTER TABLE email_settings ADD COLUMN task_notify_enabled INTEGER DEFAULT 0")
+        print("  ✓ 添加 email_settings.task_notify_enabled 字段")
+        changed = True
+
+    if changed:
+        conn.commit()
+
+
+def _migrate_to_v10(conn):
+    """迁移到版本10 - users 邮箱字段迁移（避免运行时 ALTER TABLE）"""
+    cursor = conn.cursor()
+    cursor.execute("PRAGMA table_info(users)")
+    columns = [col[1] for col in cursor.fetchall()]
+
+    changed = False
+    if "email_verified" not in columns:
+        cursor.execute("ALTER TABLE users ADD COLUMN email_verified INTEGER DEFAULT 0")
+        print("  ✓ 添加 users.email_verified 字段")
+        changed = True
+    if "email_notify_enabled" not in columns:
+        cursor.execute("ALTER TABLE users ADD COLUMN email_notify_enabled INTEGER DEFAULT 1")
+        print("  ✓ 添加 users.email_notify_enabled 字段")
+        changed = True
+
+    if changed:
+        conn.commit()

db/schedules.py

@@ -0,0 +1,485 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+from __future__ import annotations
+
+from datetime import datetime
+
+import db_pool
+from services.schedule_utils import compute_next_run_at, format_cst
+from services.time_utils import get_beijing_now
+
+
+def get_user_schedules(user_id):
+    """获取用户的所有定时任务"""
+    with db_pool.get_db() as conn:
+        cursor = conn.cursor()
+        cursor.execute(
+            """
+            SELECT * FROM user_schedules
+            WHERE user_id = ?
+            ORDER BY created_at DESC
+            """,
+            (user_id,),
+        )
+        return [dict(row) for row in cursor.fetchall()]
+
+
+def get_schedule_by_id(schedule_id):
+    """根据ID获取定时任务"""
+    with db_pool.get_db() as conn:
+        cursor = conn.cursor()
+        cursor.execute("SELECT * FROM user_schedules WHERE id = ?", (schedule_id,))
+        row = cursor.fetchone()
+        return dict(row) if row else None
+
+
+def create_user_schedule(
+    user_id,
+    name="我的定时任务",
+    schedule_time="08:00",
+    weekdays="1,2,3,4,5",
+    browse_type="应读",
+    enable_screenshot=1,
+    random_delay=0,
+    account_ids=None,
+):
+    """创建用户定时任务"""
+    import json
+
+    with db_pool.get_db() as conn:
+        cursor = conn.cursor()
+        cst_time = format_cst(get_beijing_now())
+
+        account_ids_str = json.dumps(account_ids) if account_ids else "[]"
+
+        cursor.execute(
+            """
+            INSERT INTO user_schedules (
+                user_id, name, enabled, schedule_time, weekdays,
+                browse_type, enable_screenshot, random_delay, account_ids, created_at, updated_at
+            ) VALUES (?, ?, 0, ?, ?, ?, ?, ?, ?, ?, ?)
+            """,
+            (
+                user_id,
+                name,
+                schedule_time,
+                weekdays,
+                browse_type,
+                enable_screenshot,
+                int(random_delay or 0),
+                account_ids_str,
+                cst_time,
+                cst_time,
+            ),
+        )
+
+        conn.commit()
+        return cursor.lastrowid
+
+
+def update_user_schedule(schedule_id, **kwargs):
+    """更新用户定时任务"""
+    import json
+
+    with db_pool.get_db() as conn:
+        cursor = conn.cursor()
+        now_dt = get_beijing_now()
+        now_str = format_cst(now_dt)
+
+        updates = []
+        params = []
+
+        allowed_fields = [
+            "name",
+            "enabled",
+            "schedule_time",
+            "weekdays",
+            "browse_type",
+            "enable_screenshot",
+            "random_delay",
+            "account_ids",
+        ]
+
+        # 读取旧值，用于决定是否需要重算 next_run_at
+        cursor.execute(
+            """
+            SELECT enabled, schedule_time, weekdays, random_delay, last_run_at
+            FROM user_schedules
+            WHERE id = ?
+            """,
+            (schedule_id,),
+        )
+        current = cursor.fetchone()
+        if not current:
+            return False
+        current_enabled = int(current[0] or 0)
+        current_time = current[1]
+        current_weekdays = current[2]
+        current_random_delay = int(current[3] or 0)
+        current_last_run_at = current[4]
+
+        will_enabled = current_enabled
+        next_time = current_time
+        next_weekdays = current_weekdays
+        next_random_delay = current_random_delay
+
+        for field in allowed_fields:
+            if field in kwargs:
+                value = kwargs[field]
+                if field == "account_ids" and isinstance(value, list):
+                    value = json.dumps(value)
+                if field == "enabled":
+                    will_enabled = 1 if value else 0
+                if field == "schedule_time":
+                    next_time = value
+                if field == "weekdays":
+                    next_weekdays = value
+                if field == "random_delay":
+                    next_random_delay = int(value or 0)
+                updates.append(f"{field} = ?")
+                params.append(value)
+
+        if not updates:
+            return False
+
+        updates.append("updated_at = ?")
+        params.append(now_str)
+
+        # enabled 状态下，关键字段变更后要重算 next_run_at，确保索引驱动不会跑偏
+        should_recompute_next = will_enabled == 1 and any(
+            key in kwargs for key in ["enabled", "schedule_time", "weekdays", "random_delay"]
+        )
+        if should_recompute_next:
+            next_dt = compute_next_run_at(
+                now=now_dt,
+                schedule_time=str(next_time or "08:00"),
+                weekdays=str(next_weekdays or "1,2,3,4,5"),
+                random_delay=int(next_random_delay or 0),
+                last_run_at=str(current_last_run_at or "") if current_last_run_at else None,
+            )
+            updates.append("next_run_at = ?")
+            params.append(format_cst(next_dt))
+        params.append(schedule_id)
+
+        sql = f"UPDATE user_schedules SET {', '.join(updates)} WHERE id = ?"
+        cursor.execute(sql, params)
+        conn.commit()
+        return cursor.rowcount > 0
+
+
+def delete_user_schedule(schedule_id):
+    """删除用户定时任务"""
+    with db_pool.get_db() as conn:
+        cursor = conn.cursor()
+        cursor.execute("DELETE FROM user_schedules WHERE id = ?", (schedule_id,))
+        conn.commit()
+        return cursor.rowcount > 0
+
+
+def toggle_user_schedule(schedule_id, enabled):
+    """启用/禁用用户定时任务"""
+    with db_pool.get_db() as conn:
+        cursor = conn.cursor()
+        now_dt = get_beijing_now()
+        now_str = format_cst(now_dt)
+
+        next_run_at = None
+        if enabled:
+            cursor.execute(
+                """
+                SELECT schedule_time, weekdays, random_delay, last_run_at
+                FROM user_schedules
+                WHERE id = ?
+                """,
+                (schedule_id,),
+            )
+            row = cursor.fetchone()
+            if row:
+                schedule_time, weekdays, random_delay, last_run_at = row[0], row[1], row[2], row[3]
+                next_dt = compute_next_run_at(
+                    now=now_dt,
+                    schedule_time=str(schedule_time or "08:00"),
+                    weekdays=str(weekdays or "1,2,3,4,5"),
+                    random_delay=int(random_delay or 0),
+                    last_run_at=str(last_run_at or "") if last_run_at else None,
+                )
+                next_run_at = format_cst(next_dt)
+
+        cursor.execute(
+            """
+            UPDATE user_schedules
+            SET enabled = ?, next_run_at = ?, updated_at = ?
+            WHERE id = ?
+            """,
+            (1 if enabled else 0, next_run_at, now_str, schedule_id),
+        )
+        conn.commit()
+        return cursor.rowcount > 0
+
+
+def get_enabled_user_schedules():
+    """获取所有启用的用户定时任务"""
+    with db_pool.get_db() as conn:
+        cursor = conn.cursor()
+        cursor.execute(
+            """
+            SELECT us.*, u.username as user_username
+            FROM user_schedules us
+            JOIN users u ON us.user_id = u.id
+            WHERE us.enabled = 1
+            ORDER BY us.schedule_time
+            """
+        )
+        return [dict(row) for row in cursor.fetchall()]
+
+
+def update_schedule_last_run(schedule_id):
+    """更新定时任务最后运行时间，并推进 next_run_at（O-08）"""
+    with db_pool.get_db() as conn:
+        cursor = conn.cursor()
+        now_dt = get_beijing_now()
+        now_str = format_cst(now_dt)
+
+        cursor.execute(
+            """
+            SELECT schedule_time, weekdays, random_delay
+            FROM user_schedules
+            WHERE id = ?
+            """,
+            (schedule_id,),
+        )
+        row = cursor.fetchone()
+        if not row:
+            return False
+        schedule_time, weekdays, random_delay = row[0], row[1], row[2]
+
+        next_dt = compute_next_run_at(
+            now=now_dt,
+            schedule_time=str(schedule_time or "08:00"),
+            weekdays=str(weekdays or "1,2,3,4,5"),
+            random_delay=int(random_delay or 0),
+            last_run_at=now_str,
+        )
+        next_run_at = format_cst(next_dt)
+
+        cursor.execute(
+            """
+            UPDATE user_schedules
+            SET last_run_at = ?, next_run_at = ?, updated_at = ?
+            WHERE id = ?
+            """,
+            (now_str, next_run_at, now_str, schedule_id),
+        )
+        conn.commit()
+        return cursor.rowcount > 0
+
+
+def update_schedule_next_run(schedule_id: int, next_run_at: str) -> bool:
+    """仅更新 next_run_at（不改变 last_run_at），用于跳过执行时推进。"""
+    with db_pool.get_db() as conn:
+        cursor = conn.cursor()
+        cursor.execute(
+            """
+            UPDATE user_schedules
+            SET next_run_at = ?, updated_at = ?
+            WHERE id = ?
+            """,
+            (str(next_run_at or "").strip() or None, format_cst(get_beijing_now()), int(schedule_id)),
+        )
+        conn.commit()
+        return cursor.rowcount > 0
+
+
+def recompute_schedule_next_run(schedule_id: int, *, now_dt=None) -> bool:
+    """按当前配置重算 next_run_at（不改变 last_run_at）。"""
+    now_dt = now_dt or get_beijing_now()
+    with db_pool.get_db() as conn:
+        cursor = conn.cursor()
+        cursor.execute(
+            """
+            SELECT schedule_time, weekdays, random_delay, last_run_at
+            FROM user_schedules
+            WHERE id = ?
+            """,
+            (int(schedule_id),),
+        )
+        row = cursor.fetchone()
+        if not row:
+            return False
+
+        schedule_time, weekdays, random_delay, last_run_at = row[0], row[1], row[2], row[3]
+        next_dt = compute_next_run_at(
+            now=now_dt,
+            schedule_time=str(schedule_time or "08:00"),
+            weekdays=str(weekdays or "1,2,3,4,5"),
+            random_delay=int(random_delay or 0),
+            last_run_at=str(last_run_at or "") if last_run_at else None,
+        )
+        return update_schedule_next_run(int(schedule_id), format_cst(next_dt))
+
+
+def get_due_user_schedules(now_cst: str, limit: int = 50):
+    """获取到期需要执行的用户定时任务（索引驱动）。"""
+    now_cst = str(now_cst or "").strip()
+    if not now_cst:
+        now_cst = format_cst(get_beijing_now())
+
+    with db_pool.get_db() as conn:
+        cursor = conn.cursor()
+        cursor.execute(
+            """
+            SELECT us.*, u.username as user_username
+            FROM user_schedules us
+            JOIN users u ON us.user_id = u.id
+            WHERE us.enabled = 1
+              AND us.next_run_at IS NOT NULL
+              AND us.next_run_at <= ?
+            ORDER BY us.next_run_at ASC
+            LIMIT ?
+            """,
+            (now_cst, int(limit)),
+        )
+        return [dict(row) for row in cursor.fetchall()]
+
+
+# ==================== 定时任务执行日志 ====================
+
+
+def create_schedule_execution_log(schedule_id, user_id, schedule_name):
+    """创建定时任务执行日志"""
+    with db_pool.get_db() as conn:
+        cursor = conn.cursor()
+        execute_time = format_cst(get_beijing_now())
+
+        cursor.execute(
+            """
+            INSERT INTO schedule_execution_logs (
+                schedule_id, user_id, schedule_name, execute_time, status
+            ) VALUES (?, ?, ?, ?, 'running')
+            """,
+            (schedule_id, user_id, schedule_name, execute_time),
+        )
+
+        conn.commit()
+        return cursor.lastrowid
+
+
+def update_schedule_execution_log(log_id, **kwargs):
+    """更新定时任务执行日志"""
+    with db_pool.get_db() as conn:
+        cursor = conn.cursor()
+
+        updates = []
+        params = []
+
+        allowed_fields = [
+            "total_accounts",
+            "success_accounts",
+            "failed_accounts",
+            "total_items",
+            "total_attachments",
+            "total_screenshots",
+            "duration_seconds",
+            "status",
+            "error_message",
+        ]
+
+        for field in allowed_fields:
+            if field in kwargs:
+                updates.append(f"{field} = ?")
+                params.append(kwargs[field])
+
+        if not updates:
+            return False
+
+        params.append(log_id)
+        sql = f"UPDATE schedule_execution_logs SET {', '.join(updates)} WHERE id = ?"
+
+        cursor.execute(sql, params)
+        conn.commit()
+        return cursor.rowcount > 0
+
+
+def get_schedule_execution_logs(schedule_id, limit=10):
+    """获取定时任务执行日志"""
+    try:
+        with db_pool.get_db() as conn:
+            cursor = conn.cursor()
+            cursor.execute(
+                """
+                SELECT * FROM schedule_execution_logs
+                WHERE schedule_id = ?
+                ORDER BY execute_time DESC
+                LIMIT ?
+                """,
+                (schedule_id, limit),
+            )
+
+            logs = []
+            rows = cursor.fetchall()
+
+            for row in rows:
+                try:
+                    log = dict(row)
+                    log["created_at"] = log.get("execute_time")
+                    log["success_count"] = log.get("success_accounts", 0)
+                    log["failed_count"] = log.get("failed_accounts", 0)
+                    log["duration"] = log.get("duration_seconds", 0)
+                    logs.append(log)
+                except Exception as e:
+                    print(f"[数据库] 处理日志行时出错: {e}")
+                    continue
+
+            return logs
+    except Exception as e:
+        print(f"[数据库] 查询定时任务日志时出错: {e}")
+        import traceback
+
+        traceback.print_exc()
+        return []
+
+
+def get_user_all_schedule_logs(user_id, limit=50):
+    """获取用户所有定时任务的执行日志"""
+    with db_pool.get_db() as conn:
+        cursor = conn.cursor()
+        cursor.execute(
+            """
+            SELECT * FROM schedule_execution_logs
+            WHERE user_id = ?
+            ORDER BY execute_time DESC
+            LIMIT ?
+            """,
+            (user_id, limit),
+        )
+        return [dict(row) for row in cursor.fetchall()]
+
+
+def delete_schedule_logs(schedule_id, user_id):
+    """删除指定定时任务的所有执行日志（需验证用户权限）"""
+    with db_pool.get_db() as conn:
+        cursor = conn.cursor()
+        cursor.execute(
+            """
+            DELETE FROM schedule_execution_logs
+            WHERE schedule_id = ? AND user_id = ?
+            """,
+            (schedule_id, user_id),
+        )
+        conn.commit()
+        return cursor.rowcount
+
+
+def clean_old_schedule_logs(days=30):
+    """清理指定天数前的定时任务执行日志"""
+    with db_pool.get_db() as conn:
+        cursor = conn.cursor()
+        cursor.execute(
+            """
+            DELETE FROM schedule_execution_logs
+            WHERE execute_time < datetime('now', 'localtime', '-' || ? || ' days')
+            """,
+            (days,),
+        )
+        conn.commit()
+        return cursor.rowcount

db/schema.py

@@ -0,0 +1,288 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+from __future__ import annotations
+
+import sqlite3
+
+from db.utils import get_cst_now_str
+
+
+def ensure_schema(conn) -> None:
+    """创建当前版本所需的所有表与索引（新库可直接得到完整 schema）。"""
+    cursor = conn.cursor()
+
+    # 管理员表
+    cursor.execute(
+        """
+        CREATE TABLE IF NOT EXISTS admins (
+            id INTEGER PRIMARY KEY AUTOINCREMENT,
+            username TEXT UNIQUE NOT NULL,
+            password_hash TEXT NOT NULL,
+            created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP
+        )
+        """
+    )
+
+    # 用户表
+    cursor.execute(
+        """
+        CREATE TABLE IF NOT EXISTS users (
+            id INTEGER PRIMARY KEY AUTOINCREMENT,
+            username TEXT UNIQUE NOT NULL,
+            password_hash TEXT NOT NULL,
+            email TEXT,
+            email_verified INTEGER DEFAULT 0,
+            email_notify_enabled INTEGER DEFAULT 1,
+            status TEXT DEFAULT 'pending',
+            vip_expire_time TIMESTAMP,
+            created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP,
+            approved_at TIMESTAMP
+        )
+        """
+    )
+
+    # 账号表(关联用户)
+    cursor.execute(
+        """
+        CREATE TABLE IF NOT EXISTS accounts (
+            id TEXT PRIMARY KEY,
+            user_id INTEGER NOT NULL,
+            username TEXT NOT NULL,
+            password TEXT NOT NULL,
+            remember INTEGER DEFAULT 1,
+            remark TEXT,
+            created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP,
+            FOREIGN KEY (user_id) REFERENCES users (id) ON DELETE CASCADE
+        )
+        """
+    )
+
+    # VIP配置表
+    cursor.execute(
+        """
+        CREATE TABLE IF NOT EXISTS vip_config (
+            id INTEGER PRIMARY KEY CHECK (id = 1),
+            default_vip_days INTEGER DEFAULT 0,
+            updated_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP
+        )
+        """
+    )
+
+    # 系统配置表
+    cursor.execute(
+        """
+        CREATE TABLE IF NOT EXISTS system_config (
+            id INTEGER PRIMARY KEY CHECK (id = 1),
+            max_concurrent_global INTEGER DEFAULT 2,
+            schedule_enabled INTEGER DEFAULT 0,
+            schedule_time TEXT DEFAULT '02:00',
+            schedule_browse_type TEXT DEFAULT '应读',
+            proxy_enabled INTEGER DEFAULT 0,
+            proxy_api_url TEXT DEFAULT '',
+            proxy_expire_minutes INTEGER DEFAULT 3,
+            max_screenshot_concurrent INTEGER DEFAULT 3,
+            max_concurrent_per_account INTEGER DEFAULT 1,
+            schedule_weekdays TEXT DEFAULT '1,2,3,4,5,6,7',
+            enable_screenshot INTEGER DEFAULT 1,
+            auto_approve_enabled INTEGER DEFAULT 0,
+            auto_approve_hourly_limit INTEGER DEFAULT 10,
+            auto_approve_vip_days INTEGER DEFAULT 7,
+            updated_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP
+        )
+        """
+    )
+
+    # 任务日志表
+    cursor.execute(
+        """
+        CREATE TABLE IF NOT EXISTS task_logs (
+            id INTEGER PRIMARY KEY AUTOINCREMENT,
+            user_id INTEGER NOT NULL,
+            account_id TEXT NOT NULL,
+            username TEXT NOT NULL,
+            browse_type TEXT NOT NULL,
+            status TEXT NOT NULL,
+            total_items INTEGER DEFAULT 0,
+            total_attachments INTEGER DEFAULT 0,
+            error_message TEXT,
+            duration INTEGER,
+            created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP,
+            source TEXT DEFAULT 'manual',
+            FOREIGN KEY (user_id) REFERENCES users (id) ON DELETE CASCADE
+        )
+        """
+    )
+
+    # 密码重置申请表
+    cursor.execute(
+        """
+        CREATE TABLE IF NOT EXISTS password_reset_requests (
+            id INTEGER PRIMARY KEY AUTOINCREMENT,
+            user_id INTEGER NOT NULL,
+            new_password_hash TEXT NOT NULL,
+            status TEXT NOT NULL DEFAULT 'pending',
+            created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP,
+            processed_at TIMESTAMP,
+            FOREIGN KEY (user_id) REFERENCES users (id) ON DELETE CASCADE
+        )
+        """
+    )
+
+    # 数据库版本表
+    cursor.execute(
+        """
+        CREATE TABLE IF NOT EXISTS db_version (
+            id INTEGER PRIMARY KEY CHECK (id = 1),
+            version INTEGER NOT NULL,
+            updated_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP
+        )
+        """
+    )
+
+    # Bug反馈表
+    cursor.execute(
+        """
+        CREATE TABLE IF NOT EXISTS bug_feedbacks (
+            id INTEGER PRIMARY KEY AUTOINCREMENT,
+            user_id INTEGER NOT NULL,
+            username TEXT NOT NULL,
+            title TEXT NOT NULL,
+            description TEXT NOT NULL,
+            contact TEXT,
+            status TEXT DEFAULT 'pending',
+            admin_reply TEXT,
+            created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP,
+            replied_at TIMESTAMP,
+            FOREIGN KEY (user_id) REFERENCES users (id) ON DELETE CASCADE
+        )
+        """
+    )
+
+    # 公告表
+    cursor.execute(
+        """
+        CREATE TABLE IF NOT EXISTS announcements (
+            id INTEGER PRIMARY KEY AUTOINCREMENT,
+            title TEXT NOT NULL,
+            content TEXT NOT NULL,
+            is_active INTEGER DEFAULT 1,
+            created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP,
+            updated_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP
+        )
+        """
+    )
+
+    # 公告永久关闭记录表（用户维度）
+    cursor.execute(
+        """
+        CREATE TABLE IF NOT EXISTS announcement_dismissals (
+            user_id INTEGER NOT NULL,
+            announcement_id INTEGER NOT NULL,
+            dismissed_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP,
+            PRIMARY KEY (user_id, announcement_id),
+            FOREIGN KEY (user_id) REFERENCES users (id) ON DELETE CASCADE,
+            FOREIGN KEY (announcement_id) REFERENCES announcements (id) ON DELETE CASCADE
+        )
+        """
+    )
+
+    # 用户定时任务表
+    cursor.execute(
+        """
+        CREATE TABLE IF NOT EXISTS user_schedules (
+            id INTEGER PRIMARY KEY AUTOINCREMENT,
+            user_id INTEGER NOT NULL,
+            name TEXT DEFAULT '我的定时任务',
+            enabled INTEGER DEFAULT 0,
+            schedule_time TEXT NOT NULL DEFAULT '08:00',
+            weekdays TEXT NOT NULL DEFAULT '1,2,3,4,5',
+            browse_type TEXT NOT NULL DEFAULT '应读',
+            enable_screenshot INTEGER DEFAULT 1,
+            random_delay INTEGER DEFAULT 0,
+            account_ids TEXT,
+            last_run_at TIMESTAMP,
+            next_run_at TIMESTAMP,
+            created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP,
+            updated_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP,
+            FOREIGN KEY (user_id) REFERENCES users (id) ON DELETE CASCADE
+        )
+        """
+    )
+
+    # 定时任务执行日志表（历史上在迁移中创建；这里补齐，避免新库缺表）
+    cursor.execute(
+        """
+        CREATE TABLE IF NOT EXISTS schedule_execution_logs (
+            id INTEGER PRIMARY KEY AUTOINCREMENT,
+            schedule_id INTEGER NOT NULL,
+            user_id INTEGER NOT NULL,
+            schedule_name TEXT,
+            execute_time TIMESTAMP DEFAULT CURRENT_TIMESTAMP,
+            total_accounts INTEGER DEFAULT 0,
+            success_accounts INTEGER DEFAULT 0,
+            failed_accounts INTEGER DEFAULT 0,
+            total_items INTEGER DEFAULT 0,
+            total_attachments INTEGER DEFAULT 0,
+            total_screenshots INTEGER DEFAULT 0,
+            duration_seconds INTEGER DEFAULT 0,
+            status TEXT DEFAULT 'running',
+            error_message TEXT,
+            FOREIGN KEY (schedule_id) REFERENCES user_schedules (id) ON DELETE CASCADE,
+            FOREIGN KEY (user_id) REFERENCES users (id) ON DELETE CASCADE
+        )
+        """
+    )
+
+    # ========== 创建索引 ==========
+    cursor.execute("CREATE INDEX IF NOT EXISTS idx_users_username ON users(username)")
+    cursor.execute("CREATE INDEX IF NOT EXISTS idx_users_status ON users(status)")
+    cursor.execute("CREATE INDEX IF NOT EXISTS idx_users_vip_expire ON users(vip_expire_time)")
+
+    cursor.execute("CREATE INDEX IF NOT EXISTS idx_accounts_user_id ON accounts(user_id)")
+    cursor.execute("CREATE INDEX IF NOT EXISTS idx_accounts_username ON accounts(username)")
+
+    cursor.execute("CREATE INDEX IF NOT EXISTS idx_task_logs_user_id ON task_logs(user_id)")
+    cursor.execute("CREATE INDEX IF NOT EXISTS idx_task_logs_status ON task_logs(status)")
+    cursor.execute("CREATE INDEX IF NOT EXISTS idx_task_logs_created_at ON task_logs(created_at)")
+    cursor.execute("CREATE INDEX IF NOT EXISTS idx_task_logs_user_date ON task_logs(user_id, created_at)")
+
+    cursor.execute("CREATE INDEX IF NOT EXISTS idx_password_reset_status ON password_reset_requests(status)")
+    cursor.execute("CREATE INDEX IF NOT EXISTS idx_password_reset_user_id ON password_reset_requests(user_id)")
+
+    cursor.execute("CREATE INDEX IF NOT EXISTS idx_bug_feedbacks_user_id ON bug_feedbacks(user_id)")
+    cursor.execute("CREATE INDEX IF NOT EXISTS idx_bug_feedbacks_status ON bug_feedbacks(status)")
+    cursor.execute("CREATE INDEX IF NOT EXISTS idx_bug_feedbacks_created_at ON bug_feedbacks(created_at)")
+
+    cursor.execute("CREATE INDEX IF NOT EXISTS idx_announcements_active ON announcements(is_active)")
+    cursor.execute("CREATE INDEX IF NOT EXISTS idx_announcements_created_at ON announcements(created_at)")
+    cursor.execute("CREATE INDEX IF NOT EXISTS idx_announcement_dismissals_user ON announcement_dismissals(user_id)")
+
+    cursor.execute("CREATE INDEX IF NOT EXISTS idx_user_schedules_user_id ON user_schedules(user_id)")
+    cursor.execute("CREATE INDEX IF NOT EXISTS idx_user_schedules_enabled ON user_schedules(enabled)")
+    cursor.execute("CREATE INDEX IF NOT EXISTS idx_user_schedules_next_run ON user_schedules(next_run_at)")
+
+    # 初始化VIP配置（幂等）
+    try:
+        cursor.execute("INSERT INTO vip_config (id, default_vip_days) VALUES (1, 0)")
+    except sqlite3.IntegrityError:
+        pass
+
+    # 初始化系统配置（幂等）
+    try:
+        cursor.execute(
+            """
+            INSERT INTO system_config (
+                id, max_concurrent_global, max_concurrent_per_account, max_screenshot_concurrent,
+                schedule_enabled, schedule_time, schedule_browse_type, schedule_weekdays,
+                proxy_enabled, proxy_api_url, proxy_expire_minutes, enable_screenshot,
+                auto_approve_enabled, auto_approve_hourly_limit, auto_approve_vip_days
+            ) VALUES (1, 2, 1, 3, 0, '02:00', '应读', '1,2,3,4,5,6,7', 0, '', 3, 1, 0, 10, 7)
+            """
+        )
+    except sqlite3.IntegrityError:
+        pass
+
+    # 确保 db_version 记录存在（默认 0，由迁移统一更新）
+    cursor.execute("INSERT OR IGNORE INTO db_version (id, version, updated_at) VALUES (1, 0, ?)", (get_cst_now_str(),))
+
+    conn.commit()

db/tasks.py

@@ -0,0 +1,235 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+from __future__ import annotations
+
+from datetime import datetime
+
+import pytz
+
+import db_pool
+from db.utils import sanitize_sql_like_pattern
+
+
+def create_task_log(
+    user_id,
+    account_id,
+    username,
+    browse_type,
+    status,
+    total_items=0,
+    total_attachments=0,
+    error_message="",
+    duration=None,
+    source="manual",
+):
+    """创建任务日志记录"""
+    with db_pool.get_db() as conn:
+        cursor = conn.cursor()
+        cst_tz = pytz.timezone("Asia/Shanghai")
+        cst_time = datetime.now(cst_tz).strftime("%Y-%m-%d %H:%M:%S")
+
+        cursor.execute(
+            """
+            INSERT INTO task_logs (
+                user_id, account_id, username, browse_type, status,
+                total_items, total_attachments, error_message, duration, created_at, source
+            ) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
+            """,
+            (
+                user_id,
+                account_id,
+                username,
+                browse_type,
+                status,
+                total_items,
+                total_attachments,
+                error_message,
+                duration,
+                cst_time,
+                source,
+            ),
+        )
+
+        conn.commit()
+        return cursor.lastrowid
+
+
+def get_task_logs(
+    limit=100,
+    offset=0,
+    date_filter=None,
+    status_filter=None,
+    source_filter=None,
+    user_id_filter=None,
+    account_filter=None,
+):
+    """获取任务日志列表（支持分页和多种筛选）"""
+    with db_pool.get_db() as conn:
+        cursor = conn.cursor()
+
+        where_clauses = ["1=1"]
+        params = []
+
+        if date_filter:
+            where_clauses.append("date(tl.created_at) = ?")
+            params.append(date_filter)
+
+        if status_filter:
+            where_clauses.append("tl.status = ?")
+            params.append(status_filter)
+
+        if source_filter:
+            where_clauses.append("tl.source = ?")
+            params.append(source_filter)
+
+        if user_id_filter:
+            where_clauses.append("tl.user_id = ?")
+            params.append(user_id_filter)
+
+        if account_filter:
+            safe_filter = sanitize_sql_like_pattern(account_filter)
+            where_clauses.append("tl.username LIKE ? ESCAPE '\\\\'")
+            params.append(f"%{safe_filter}%")
+
+        where_sql = " AND ".join(where_clauses)
+
+        count_sql = f"""
+            SELECT COUNT(*) as total
+            FROM task_logs tl
+            LEFT JOIN users u ON tl.user_id = u.id
+            WHERE {where_sql}
+        """
+        cursor.execute(count_sql, params)
+        total = cursor.fetchone()["total"]
+
+        data_sql = f"""
+            SELECT
+                tl.*,
+                u.username as user_username
+            FROM task_logs tl
+            LEFT JOIN users u ON tl.user_id = u.id
+            WHERE {where_sql}
+            ORDER BY tl.created_at DESC
+            LIMIT ? OFFSET ?
+        """
+        params.extend([limit, offset])
+
+        cursor.execute(data_sql, params)
+        logs = [dict(row) for row in cursor.fetchall()]
+
+        return {"logs": logs, "total": total}
+
+
+def get_task_stats(date_filter=None):
+    """获取任务统计信息"""
+    with db_pool.get_db() as conn:
+        cursor = conn.cursor()
+        cst_tz = pytz.timezone("Asia/Shanghai")
+
+        if date_filter is None:
+            date_filter = datetime.now(cst_tz).strftime("%Y-%m-%d")
+
+        cursor.execute(
+            """
+            SELECT
+                COUNT(*) as total_tasks,
+                SUM(CASE WHEN status = 'success' THEN 1 ELSE 0 END) as success_tasks,
+                SUM(CASE WHEN status = 'failed' THEN 1 ELSE 0 END) as failed_tasks,
+                SUM(total_items) as total_items,
+                SUM(total_attachments) as total_attachments
+            FROM task_logs
+            WHERE date(created_at) = ?
+            """,
+            (date_filter,),
+        )
+        today_stats = cursor.fetchone()
+
+        cursor.execute(
+            """
+            SELECT
+                COUNT(*) as total_tasks,
+                SUM(CASE WHEN status = 'success' THEN 1 ELSE 0 END) as success_tasks,
+                SUM(CASE WHEN status = 'failed' THEN 1 ELSE 0 END) as failed_tasks,
+                SUM(total_items) as total_items,
+                SUM(total_attachments) as total_attachments
+            FROM task_logs
+            """
+        )
+        total_stats = cursor.fetchone()
+
+        return {
+            "today": {
+                "total_tasks": today_stats["total_tasks"] or 0,
+                "success_tasks": today_stats["success_tasks"] or 0,
+                "failed_tasks": today_stats["failed_tasks"] or 0,
+                "total_items": today_stats["total_items"] or 0,
+                "total_attachments": today_stats["total_attachments"] or 0,
+            },
+            "total": {
+                "total_tasks": total_stats["total_tasks"] or 0,
+                "success_tasks": total_stats["success_tasks"] or 0,
+                "failed_tasks": total_stats["failed_tasks"] or 0,
+                "total_items": total_stats["total_items"] or 0,
+                "total_attachments": total_stats["total_attachments"] or 0,
+            },
+        }
+
+
+def delete_old_task_logs(days=30, batch_size=1000):
+    """删除N天前的任务日志（分批删除，避免长时间锁表）"""
+    total_deleted = 0
+    while True:
+        with db_pool.get_db() as conn:
+            cursor = conn.cursor()
+            cursor.execute(
+                """
+                DELETE FROM task_logs
+                WHERE rowid IN (
+                    SELECT rowid FROM task_logs
+                    WHERE created_at < datetime('now', 'localtime', '-' || ? || ' days')
+                    LIMIT ?
+                )
+                """,
+                (days, batch_size),
+            )
+            deleted = cursor.rowcount
+            conn.commit()
+
+            if deleted == 0:
+                break
+            total_deleted += deleted
+
+    return total_deleted
+
+
+def get_user_run_stats(user_id, date_filter=None):
+    """获取用户的运行统计信息"""
+    with db_pool.get_db() as conn:
+        cst_tz = pytz.timezone("Asia/Shanghai")
+        cursor = conn.cursor()
+
+        if date_filter is None:
+            date_filter = datetime.now(cst_tz).strftime("%Y-%m-%d")
+
+        cursor.execute(
+            """
+            SELECT
+                SUM(CASE WHEN status = 'success' THEN 1 ELSE 0 END) as completed,
+                SUM(CASE WHEN status = 'failed' THEN 1 ELSE 0 END) as failed,
+                SUM(total_items) as total_items,
+                SUM(total_attachments) as total_attachments
+            FROM task_logs
+            WHERE user_id = ? AND date(created_at) = ?
+            """,
+            (user_id, date_filter),
+        )
+
+        stats = cursor.fetchone()
+
+        return {
+            "completed": stats["completed"] or 0,
+            "failed": stats["failed"] or 0,
+            "total_items": stats["total_items"] or 0,
+            "total_attachments": stats["total_attachments"] or 0,
+        }
+

db/users.py

@@ -0,0 +1,284 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+from __future__ import annotations
+
+import sqlite3
+from datetime import datetime, timedelta
+
+import pytz
+
+import db_pool
+from db.utils import get_cst_now_str
+from password_utils import (
+    hash_password_bcrypt,
+    is_sha256_hash,
+    verify_password_bcrypt,
+    verify_password_sha256,
+)
+
+
+def get_vip_config():
+    """获取VIP配置"""
+    with db_pool.get_db() as conn:
+        cursor = conn.cursor()
+        cursor.execute("SELECT * FROM vip_config WHERE id = 1")
+        config = cursor.fetchone()
+        return dict(config) if config else {"default_vip_days": 0}
+
+
+def set_default_vip_days(days):
+    """设置默认VIP天数"""
+    with db_pool.get_db() as conn:
+        cursor = conn.cursor()
+        cst_time = get_cst_now_str()
+        cursor.execute(
+            """
+            INSERT OR REPLACE INTO vip_config (id, default_vip_days, updated_at)
+            VALUES (1, ?, ?)
+            """,
+            (days, cst_time),
+        )
+        conn.commit()
+        return True
+
+
+def set_user_vip(user_id, days):
+    """设置用户VIP - days: 7=一周, 30=一个月, 365=一年, 999999=永久"""
+    with db_pool.get_db() as conn:
+        cst_tz = pytz.timezone("Asia/Shanghai")
+        cursor = conn.cursor()
+
+        if days == 999999:
+            expire_time = "2099-12-31 23:59:59"
+        else:
+            expire_time = (datetime.now(cst_tz) + timedelta(days=days)).strftime("%Y-%m-%d %H:%M:%S")
+
+        cursor.execute("UPDATE users SET vip_expire_time = ? WHERE id = ?", (expire_time, user_id))
+        conn.commit()
+        return cursor.rowcount > 0
+
+
+def extend_user_vip(user_id, days):
+    """延长用户VIP时间"""
+    user = get_user_by_id(user_id)
+    cst_tz = pytz.timezone("Asia/Shanghai")
+
+    if not user:
+        return False
+
+    with db_pool.get_db() as conn:
+        cursor = conn.cursor()
+        current_expire = user.get("vip_expire_time")
+
+        if current_expire and current_expire != "2099-12-31 23:59:59":
+            try:
+                expire_time_naive = datetime.strptime(current_expire, "%Y-%m-%d %H:%M:%S")
+                expire_time = cst_tz.localize(expire_time_naive)
+                now = datetime.now(cst_tz)
+                if expire_time < now:
+                    expire_time = now
+                new_expire = (expire_time + timedelta(days=days)).strftime("%Y-%m-%d %H:%M:%S")
+            except (ValueError, AttributeError) as e:
+                print(f"解析VIP过期时间失败: {e}, 使用当前时间")
+                new_expire = (datetime.now(cst_tz) + timedelta(days=days)).strftime("%Y-%m-%d %H:%M:%S")
+        else:
+            new_expire = (datetime.now(cst_tz) + timedelta(days=days)).strftime("%Y-%m-%d %H:%M:%S")
+
+        cursor.execute("UPDATE users SET vip_expire_time = ? WHERE id = ?", (new_expire, user_id))
+        conn.commit()
+        return cursor.rowcount > 0
+
+
+def remove_user_vip(user_id):
+    """移除用户VIP"""
+    with db_pool.get_db() as conn:
+        cursor = conn.cursor()
+        cursor.execute("UPDATE users SET vip_expire_time = NULL WHERE id = ?", (user_id,))
+        conn.commit()
+        return cursor.rowcount > 0
+
+
+def is_user_vip(user_id):
+    """检查用户是否是VIP
+
+    注意：数据库中存储的时间统一使用CST（Asia/Shanghai）时区
+    """
+    cst_tz = pytz.timezone("Asia/Shanghai")
+    user = get_user_by_id(user_id)
+
+    if not user or not user.get("vip_expire_time"):
+        return False
+
+    try:
+        expire_time_naive = datetime.strptime(user["vip_expire_time"], "%Y-%m-%d %H:%M:%S")
+        expire_time = cst_tz.localize(expire_time_naive)
+        now = datetime.now(cst_tz)
+        return now < expire_time
+    except (ValueError, AttributeError) as e:
+        print(f"检查VIP状态失败 (user_id={user_id}): {e}")
+        return False
+
+
+def get_user_vip_info(user_id):
+    """获取用户VIP信息"""
+    cst_tz = pytz.timezone("Asia/Shanghai")
+    user = get_user_by_id(user_id)
+
+    if not user:
+        return {"is_vip": False, "expire_time": None, "days_left": 0, "username": ""}
+
+    vip_expire_time = user.get("vip_expire_time")
+    if not vip_expire_time:
+        return {"is_vip": False, "expire_time": None, "days_left": 0, "username": user.get("username", "")}
+
+    try:
+        expire_time_naive = datetime.strptime(vip_expire_time, "%Y-%m-%d %H:%M:%S")
+        expire_time = cst_tz.localize(expire_time_naive)
+        now = datetime.now(cst_tz)
+        is_vip = now < expire_time
+        days_left = (expire_time - now).days if is_vip else 0
+
+        return {"username": user.get("username", ""), "is_vip": is_vip, "expire_time": vip_expire_time, "days_left": max(0, days_left)}
+    except Exception as e:
+        print(f"VIP信息获取错误: {e}")
+        return {"is_vip": False, "expire_time": None, "days_left": 0, "username": user.get("username", "")}
+
+
+# ==================== 用户相关 ====================
+
+
+def create_user(username, password, email=""):
+    """创建新用户(待审核状态,赠送默认VIP)"""
+    cst_tz = pytz.timezone("Asia/Shanghai")
+
+    with db_pool.get_db() as conn:
+        cursor = conn.cursor()
+        password_hash = hash_password_bcrypt(password)
+        cst_time = get_cst_now_str()
+
+        default_vip_days = get_vip_config()["default_vip_days"]
+        vip_expire_time = None
+
+        if default_vip_days > 0:
+            if default_vip_days == 999999:
+                vip_expire_time = "2099-12-31 23:59:59"
+            else:
+                vip_expire_time = (datetime.now(cst_tz) + timedelta(days=default_vip_days)).strftime("%Y-%m-%d %H:%M:%S")
+
+        try:
+            cursor.execute(
+                """
+                INSERT INTO users (username, password_hash, email, status, vip_expire_time, created_at)
+                VALUES (?, ?, ?, 'pending', ?, ?)
+                """,
+                (username, password_hash, email, vip_expire_time, cst_time),
+            )
+            conn.commit()
+            return cursor.lastrowid
+        except sqlite3.IntegrityError:
+            return None
+
+
+def verify_user(username, password):
+    """验证用户登录 - 自动从SHA256升级到bcrypt"""
+    with db_pool.get_db() as conn:
+        cursor = conn.cursor()
+        cursor.execute("SELECT * FROM users WHERE username = ? AND status = 'approved'", (username,))
+        user = cursor.fetchone()
+
+        if not user:
+            return None
+
+        user_dict = dict(user)
+        password_hash = user_dict["password_hash"]
+
+        if is_sha256_hash(password_hash):
+            if verify_password_sha256(password, password_hash):
+                new_hash = hash_password_bcrypt(password)
+                cursor.execute("UPDATE users SET password_hash = ? WHERE id = ?", (new_hash, user_dict["id"]))
+                conn.commit()
+                print(f"用户 {username} 密码已自动升级到bcrypt")
+                return user_dict
+            return None
+
+        if verify_password_bcrypt(password, password_hash):
+            return user_dict
+        return None
+
+
+def get_user_by_id(user_id):
+    """根据ID获取用户"""
+    with db_pool.get_db() as conn:
+        cursor = conn.cursor()
+        cursor.execute("SELECT * FROM users WHERE id = ?", (user_id,))
+        user = cursor.fetchone()
+        return dict(user) if user else None
+
+
+def get_user_by_username(username):
+    """根据用户名获取用户"""
+    with db_pool.get_db() as conn:
+        cursor = conn.cursor()
+        cursor.execute("SELECT * FROM users WHERE username = ?", (username,))
+        user = cursor.fetchone()
+        return dict(user) if user else None
+
+
+def get_all_users():
+    """获取所有用户"""
+    with db_pool.get_db() as conn:
+        cursor = conn.cursor()
+        cursor.execute("SELECT * FROM users ORDER BY created_at DESC")
+        return [dict(row) for row in cursor.fetchall()]
+
+
+def get_pending_users():
+    """获取待审核用户"""
+    with db_pool.get_db() as conn:
+        cursor = conn.cursor()
+        cursor.execute("SELECT * FROM users WHERE status = 'pending' ORDER BY created_at DESC")
+        return [dict(row) for row in cursor.fetchall()]
+
+
+def approve_user(user_id):
+    """审核通过用户"""
+    with db_pool.get_db() as conn:
+        cursor = conn.cursor()
+        cst_time = get_cst_now_str()
+        cursor.execute(
+            """
+            UPDATE users
+            SET status = 'approved', approved_at = ?
+            WHERE id = ?
+            """,
+            (cst_time, user_id),
+        )
+        conn.commit()
+        return cursor.rowcount > 0
+
+
+def reject_user(user_id):
+    """拒绝用户"""
+    with db_pool.get_db() as conn:
+        cursor = conn.cursor()
+        cursor.execute("UPDATE users SET status = 'rejected' WHERE id = ?", (user_id,))
+        conn.commit()
+        return cursor.rowcount > 0
+
+
+def delete_user(user_id):
+    """删除用户(级联删除相关账号)"""
+    with db_pool.get_db() as conn:
+        cursor = conn.cursor()
+        cursor.execute("DELETE FROM users WHERE id = ?", (user_id,))
+        conn.commit()
+        return cursor.rowcount > 0
+
+
+def get_user_stats(user_id):
+    """获取用户统计信息"""
+    with db_pool.get_db() as conn:
+        cursor = conn.cursor()
+        cursor.execute("SELECT COUNT(*) as count FROM accounts WHERE user_id = ?", (user_id,))
+        account_count = cursor.fetchone()["count"]
+        return {"account_count": account_count}

db/utils.py

@@ -0,0 +1,52 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+from __future__ import annotations
+
+import html
+from datetime import datetime
+from typing import Optional
+
+import pytz
+
+# ==================== 时区处理工具函数 ====================
+
+CST_TZ = pytz.timezone("Asia/Shanghai")
+
+
+def get_cst_now() -> datetime:
+    return datetime.now(CST_TZ)
+
+
+def get_cst_now_str() -> str:
+    return get_cst_now().strftime("%Y-%m-%d %H:%M:%S")
+
+
+def parse_cst_datetime(datetime_str: str) -> datetime:
+    naive = datetime.strptime(datetime_str, "%Y-%m-%d %H:%M:%S")
+    return CST_TZ.localize(naive)
+
+
+# ==================== 安全工具（与 app_security 保持兼容） ====================
+
+
+def escape_html(text: Optional[object]) -> str:
+    try:
+        from app_security import escape_html as _escape_html
+
+        return _escape_html(text)
+    except Exception:
+        if text is None:
+            return ""
+        return html.escape(str(text))
+
+
+def sanitize_sql_like_pattern(pattern: Optional[object]) -> str:
+    try:
+        from app_security import sanitize_sql_like_pattern as _sanitize_sql_like_pattern
+
+        return _sanitize_sql_like_pattern(pattern)
+    except Exception:
+        if pattern is None:
+            return ""
+        return str(pattern).replace("\\", "\\\\").replace("%", "\\%").replace("_", "\\_")
+