feat: 新增备份恢复与公网加固

- 新增备份管理页与 API：在线快照、自动周期备份、按份数清理、下载、一键恢复（恢复前自动兜底）
- 新增 /profile/export，普通用户可导出本人全部数据（不含 Cookie 明文）
- 修复 X-Forwarded-For 可伪造导致三道 IP 防线失效，统一走 client_ip() 取客户端地址
- 取消 admin123 硬编码默认口令，留空则生成随机初始口令并仅打印一次
- .dockerignore 排除 backups/ 并加构建期断言，防止密钥随镜像分发
- 新增会话版本号，改密/停用/删除及恢复备份后其他会话立即失效
- 新增容器资源上限、采集跨度硬顶 31 天、重操作最小间隔与并发 409
- 新增访问日志、HSTS 条件下发、口令黑名单、验证码抗模板匹配、instance.json 0600
- 版本号升至 1.4.0，同步更新 README、SECURITY、.env.example 与 compose 配置

workbuddy_portal/web/api.py

@@ -23,9 +23,9 @@
 import os
 from datetime import datetime
 
-from flask import Blueprint, jsonify, request
+from flask import Blueprint, jsonify, request, send_file, session
 
-from .. import collect, config, db, query, scheduler, security
+from .. import backup, collect, config, db, query, scheduler, security
 from ..security import admin_required, current_user, is_admin, login_required
 
 bp = Blueprint("api", __name__, url_prefix="/api")
@@ -36,6 +36,12 @@ def _uid():
     return u["id"] if u else 0
 
 
+def _ip():
+    """客户端地址。一律走 security.client_ip() —— 见那里的注释：
+    直接取 X-Forwarded-For 第 0 段会让「来源」变成请求方自己填的字符串。"""
+    return security.client_ip()
+
+
 def _arg(name, default=None):
     v = request.args.get(name)
     return v if v not in (None, "") else default
@@ -193,14 +199,26 @@ def api_status():
     running = conn.execute("SELECT COUNT(*) FROM collect_runs WHERE user_id=? AND status='running'",
                            (uid,)).fetchone()[0]
     cred = db.secret_state(conn, "cookie", uid)
+    nxt_bk = backup.next_auto_at(conn) if u["is_admin"] else None
     return jsonify({
         "server_time": db.now_str(),
         # 角色能力：大屏等**静态页**拿不到 Jinja 上下文，只能靠这个字段
-        # 决定要不要渲染管理员专属入口（如「日志管理」）。服务端仍会
+        # 决定要不要渲染管理员专属入口（如「日志管理」「备份管理」）。服务端仍会
         # 对这些入口再做一次鉴权，前端隐藏只是为了不给出误导性的按钮。
         "is_admin": bool(u["is_admin"]),
         "can_edit_schedule": bool(u["is_admin"]),
         "can_view_logs": bool(u["is_admin"]),
+        "can_manage_backups": bool(u["is_admin"]),
+        "limits": {
+            # 对外提供服务时的三道闸门，前端据此提前禁用按钮而不是等 409
+            "collect_min_interval_seconds": collect.min_interval_seconds(conn),
+            "collect_max_range_days": collect.max_range_days(conn),
+            "schedule_slots": len(scheduler.slots(conn, uid)),
+            "schedule_slots_cap":
+                max(1, min(config.SCHEDULE_SLOTS_HARD_MAX,
+                           db.get_int(conn, "max_schedule_slots_per_day", 6))),
+        },
+        "running_lock": os.path.exists(collect.LOCK_PATH),
         "scheduler": {
             "running": sch.running,
             "enabled": db.get_bool(conn, "schedule_enabled", True, uid),
@@ -209,6 +227,13 @@ def api_status():
             "catch_up": db.get_bool(conn, "catch_up", True, uid),
             "lockfile": os.path.exists(collect.LOCK_PATH),
         },
+        "backup": {
+            "enabled": db.get_bool(conn, "backup_enabled", True),
+            "interval_hours": db.get_int(conn, "backup_interval_hours", 24),
+            "keep": db.get_int(conn, "backup_keep", 7),
+            "last": backup.last_auto_at(conn) or None,
+            "next": nxt_bk.strftime("%Y-%m-%d %H:%M:%S") if nxt_bk else None,
+        },
         "running_runs": running,
         "last_run": dict(last) if last else None,
         # 只回「有没有配」与字符数，绝不回凭证内容
@@ -221,10 +246,40 @@ def api_status():
 @bp.post("/collect")
 @login_required
 def api_collect():
-    """手动触发一次采集（后台线程之外同步执行，页面等待结果）。"""
+    """手动触发一次采集（同步执行，页面等待结果）。
+
+    对外提供服务后，这里必须有三道闸门，缺一不可：
+
+    1. **已有任务在跑就拒绝新任务**。采集是全局单写者（SQLite 同一时刻只允许
+       一个写进程，见 collect._Lock）。原来的实现是「后来者在锁上等」，
+       而 waitress 只有 8 个线程 —— 一个人连点几下就能把线程占满，
+       表现为整个站点变慢甚至无响应。现在明确回 409。
+    2. **同一账号的最小间隔**。挡住「连点按钮 / 脚本循环调」这种形态；
+       间隔由 `collect_min_interval_seconds` 控制（实例级，管理员可调）。
+    3. **跨度上限**。`from=2000-01-01` 会让服务端对云端发出成百上千次请求，
+       这是最省力的资源耗尽方式。上限 `collect_max_range_days`（硬顶 31 天）。
+    """
     u = current_user()
+    conn = db.get_db()
+    uid = u["id"]
     body = _json_body()
+
+    # ---- 闸门 1：不能有别的任务在跑 ----
+    if os.path.exists(collect.LOCK_PATH):
+        return jsonify({"ok": False, "error": "busy",
+                        "message": "已有采集任务正在运行，请等它结束后再试"
+                                   "（进度见「任务管理」）"}), 409
+
+    # ---- 闸门 2：频率 ----
+    gap = collect.min_interval_seconds(conn)
+    allowed, wait = security.action_allowed("collect:%d" % uid, gap)
+    if not allowed:
+        return jsonify({"ok": False, "error": "too_frequent",
+                        "message": "同一账号两次采集之间需间隔 %d 秒，请 %d 秒后再试"
+                                   % (gap, wait)}), 429
+
     frm, to = body.get("from"), body.get("to")
+    limit = collect.max_range_days(conn)
     try:
         kw = {}
         if frm:
@@ -239,7 +294,16 @@ def api_collect():
             kw["to_dt"] = datetime.strptime(d, "%Y-%m-%d").replace(hour=23, minute=59, second=59)
         if kw.get("from_dt") and kw.get("to_dt") and kw["from_dt"] > kw["to_dt"]:
             raise BadParam("起始日期不能晚于结束日期")
-        r = collect.run_sync(trigger="manual", uid=u["id"], **kw)
+        # ---- 闸门 3：跨度 ----
+        if kw.get("from_dt"):
+            end = kw.get("to_dt") or datetime.now()
+            days = (end - kw["from_dt"]).days
+            if days > limit:
+                raise BadParam(
+                    "采集跨度最长 %d 天，本次请求是 %d 天。"
+                    "请缩小日期范围后分批采集（每次最多 %d 天）。"
+                    % (limit, days, limit))
+        r = collect.run_sync(trigger="manual", uid=uid, **kw)
     except BadParam as e:
         return jsonify({"ok": False, "error": "bad_request", "message": str(e)}), 400
     except collect.Busy as e:
@@ -256,7 +320,7 @@ def api_collect():
                         "message": str(e)}), code
     except Exception as e:                      # noqa: BLE001
         return jsonify({"ok": False, "error": "internal", "message": str(e)}), 500
-    db.audit(db.get_db(), "collect", u["username"], r["message"], request.remote_addr, u["id"])
+    db.audit(conn, "collect", u["username"], r["message"], _ip(), uid)
     return jsonify({"ok": True, "result": r})
 
 
@@ -307,6 +371,14 @@ def api_maintenance(action):
     if action == "vacuum" and not u["is_admin"]:
         return jsonify({"ok": False, "error": "forbidden",
                         "message": "数据库整理是整库操作，仅管理员可执行"}), 403
+    # 这四类动作都是「整库扫一遍」级别：导出会全表流式扫、补全会连续打云端、
+    # vacuum 会锁库。各自加一个按账号的最小间隔，挡住脚本循环调用。
+    hvy = {"fill-prompt": 60, "export-csv": 15, "vacuum": 120, "recount": 5}
+    if action in hvy:
+        ok, wait = security.action_allowed("maint:%s:%d" % (action, uid), hvy[action])
+        if not ok:
+            return jsonify({"ok": False, "error": "too_frequent",
+                            "message": "该动作刚执行过，请 %d 秒后再试" % wait}), 429
     try:
         if action == "fill-prompt":
             try:
@@ -336,10 +408,118 @@ def api_maintenance(action):
             return jsonify({"ok": False, "error": "unknown", "message": "未知维护动作"}), 404
     except Exception as e:                      # noqa: BLE001
         return jsonify({"ok": False, "error": "internal", "message": str(e)}), 500
-    db.audit(conn, "maintenance:" + action, u["username"], msg, request.remote_addr, uid)
+    db.audit(conn, "maintenance:" + action, u["username"], msg, _ip(), uid)
     return jsonify({"ok": True, "message": msg})
 
 
+# ---------------- 备份管理（仅管理员） ----------------
+def _backup_error(e):
+    return jsonify({"ok": False, "error": "backup", "message": str(e)}), 400
+
+
+@bp.get("/backups")
+@admin_required
+def api_backups():
+    conn = db.get_db()
+    backup.sync_index(conn)
+    return jsonify({
+        "items": backup.listing(conn),
+        "dir": config.BACKUP_DIR,
+        "total_human": backup.human(backup.total_bytes(conn)),
+        "enabled": db.get_bool(conn, "backup_enabled", True),
+        "interval_hours": db.get_int(conn, "backup_interval_hours", 24),
+        "keep": db.get_int(conn, "backup_keep", 7),
+        "last_auto": backup.last_auto_at(conn),
+    })
+
+
+@bp.post("/backups")
+@admin_required
+def api_backup_create():
+    conn = db.get_db()
+    u = current_user()
+    # 打一份整库快照是重活（整库读一遍 + 压缩），别让脚本连打
+    ok, wait = security.action_allowed("backup:create", 30)
+    if not ok:
+        return jsonify({"ok": False, "error": "too_frequent",
+                        "message": "刚打过备份，请 %d 秒后再试" % wait}), 429
+    note = str(_json_body().get("note") or "").strip()[:200]
+    try:
+        r = backup.create(conn, trigger="manual", actor=u["username"], note=note)
+    except backup.BackupError as e:
+        return _backup_error(e)
+    except Exception as e:                      # noqa: BLE001
+        return jsonify({"ok": False, "error": "internal", "message": str(e)}), 500
+    removed = backup.prune(conn, actor=u["username"])
+    if removed:
+        r["message"] += "；按保留份数清理了 %d 份旧备份" % len(removed)
+    r["pruned"] = removed
+    return jsonify(r)
+
+
+@bp.get("/backups/<filename>")
+@admin_required
+def api_backup_download(filename):
+    """下载一份归档。文件名必须过 backup.safe_name 的收口。"""
+    try:
+        p = backup.path_of(filename)
+    except backup.BackupError as e:
+        return _backup_error(e)
+    if not os.path.exists(p):
+        return jsonify({"ok": False, "error": "not_found",
+                        "message": "备份文件不存在或已被删除"}), 404
+    db.audit(db.get_db(), "backup_download", current_user()["username"],
+             "下载备份 %s" % os.path.basename(p), _ip(), 0)
+    return send_file(p, as_attachment=True, download_name=os.path.basename(p),
+                     mimetype="application/zip")
+
+
+@bp.post("/backups/<filename>/restore")
+@admin_required
+def api_backup_restore(filename):
+    """从归档恢复整库。
+
+    这是本系统里**破坏性最强**的一个操作：它会把当前所有账号、所有用量、
+    所有配置替换成归档里的那一份。所以：
+      * 恢复前自动给当前库打一份 pre-restore 快照（错了能回去）
+      * 默认把 instance.json 一并恢复（否则 Cookie 密文解不开）
+      * 完成后所有既有会话失效（密钥与账号可能都变了），必须重新登录
+    """
+    conn = db.get_db()
+    u = current_user()
+    body = _json_body()
+    include_instance = str(body.get("include_instance", "1")).lower() not in ("0", "false", "off", "no")
+    try:
+        r = backup.restore(conn, filename, include_instance=include_instance,
+                           actor=u["username"])
+    except backup.BackupError as e:
+        return _backup_error(e)
+    except Exception as e:                      # noqa: BLE001
+        return jsonify({"ok": False, "error": "internal", "message": str(e)}), 500
+    return jsonify(r)
+
+
+@bp.post("/backups/<filename>/delete")
+@admin_required
+def api_backup_delete(filename):
+    conn = db.get_db()
+    try:
+        r = backup.delete(conn, filename, actor=current_user()["username"])
+    except backup.BackupError as e:
+        return _backup_error(e)
+    return jsonify(r)
+
+
+@bp.post("/backups/prune")
+@admin_required
+def api_backup_prune():
+    conn = db.get_db()
+    removed = backup.prune(conn, actor=current_user()["username"])
+    return jsonify({"ok": True, "removed": removed,
+                    "message": ("已清理 %d 份旧备份" % len(removed)) if removed
+                               else "没有需要清理的备份"})
+
+
 def _human(n):
     for unit in ("B", "KB", "MB", "GB"):
         if n < 1024 or unit == "GB":
@@ -363,6 +543,7 @@ def api_settings_get():
     s["_globalKeys"] = sorted(config.GLOBAL_KEYS)
     s["_userKeys"] = sorted(config.USER_EDITABLE_KEYS)
     s["_canEditGlobal"] = bool(u["is_admin"])
+    s["_canManageBackups"] = bool(u["is_admin"])
     s["_role"] = "admin" if u["is_admin"] else "user"
     return jsonify(s)
 
@@ -397,7 +578,7 @@ def api_settings_post():
                 db.set_secret(conn, "cookie", "", uid)
                 changed.append(k)
                 continue
-        val, err = config.normalize_setting(k, v)
+        val, err = config.normalize_setting(k, v, conn)
         if err:
             errors.append(err)
             continue
@@ -412,7 +593,7 @@ def api_settings_post():
                       % "、".join(sorted(denied)))
     if errors:
         db.audit(conn, "settings_rejected", u["username"], "；".join(errors)[:500],
-                 request.remote_addr, uid)
+                 _ip(), uid)
         return jsonify({"ok": False, "error": "invalid", "message": "；".join(errors),
                         "errors": errors, "changed": sorted(changed)}), 400
     # 改了每日时刻：清掉**不再存在的**槽位标记（所有账号一起清）。
@@ -425,8 +606,17 @@ def api_settings_post():
             if r["key"][len(scheduler.SLOT_PREFIX):] not in keep]
         for row_uid, skey in stale:
             conn.execute("DELETE FROM settings WHERE user_id=? AND key=?", (row_uid, skey))
+    # 调小时刻数上限后，多余的槽位标记也该跟着清，否则「缩到 2 个时刻」之后
+    # 另外几个时刻的标记会一直躺在库里，看着像系统还在按旧配置跑。
+    if "max_schedule_slots_per_day" in changed:
+        keep = set(scheduler.slots(conn, 0))
+        for r in conn.execute("SELECT user_id,key FROM settings WHERE key LIKE ?",
+                              (scheduler.SLOT_PREFIX + "%",)).fetchall():
+            if r["key"][len(scheduler.SLOT_PREFIX):] not in keep:
+                conn.execute("DELETE FROM settings WHERE user_id=? AND key=?",
+                             (r["user_id"], r["key"]))
     db.audit(conn, "settings", u["username"],
-             "修改：" + (",".join(sorted(changed)) or "（无变化）"), request.remote_addr, uid)
+             "修改：" + (",".join(sorted(changed)) or "（无变化）"), _ip(), uid)
     return jsonify({"ok": True, "changed": sorted(changed), "ignored": sorted(ignored)})
 
 
@@ -445,8 +635,16 @@ def api_password():
         return jsonify({"ok": False, "message": err}), 400
     conn.execute("UPDATE users SET password_hash=? WHERE id=?",
                  (security.hash_password(new), u["id"]))
-    db.audit(conn, "password", u["username"], "修改登录密码", request.remote_addr, u["id"])
-    return jsonify({"ok": True, "message": "密码已更新"})
+    # 改密即作废**其他**设备的会话：改密码的动机往往就是怀疑它泄漏了，
+    # 只改散列却留着旧会话，等于给自己一个假的安心。
+    db.bump_session_ver(conn, u["id"])
+    # 当前这次会话跟着刷新到新版本，否则用户改完密码立刻被自己踢下线。
+    # （安全上「全部踢掉」更好，但体验太差会让人不敢改密码。）
+    with_row = conn.execute("SELECT * FROM users WHERE id=?", (u["id"],)).fetchone()
+    session["sv"] = db.session_ver_of(with_row)
+    db.audit(conn, "password", u["username"], "修改登录密码（其他设备会话已失效）",
+             _ip(), u["id"])
+    return jsonify({"ok": True, "message": "密码已更新，其他设备上的登录已失效"})
 
 
 @bp.post("/profile")
@@ -470,7 +668,7 @@ def api_profile():
     if not changed:
         return jsonify({"ok": False, "message": "没有要修改的内容"}), 400
     db.audit(conn, "profile", u["username"], "修改：" + "、".join(changed),
-             request.remote_addr, u["id"])
+             _ip(), u["id"])
     return jsonify({"ok": True, "message": "已更新：" + "、".join(changed)})
 
 
@@ -514,7 +712,7 @@ def api_user_create():
          (body.get("display_name") or name).strip()[:64],
          (body.get("email") or "").strip()[:128] or None, adm, db.now_str()))
     db.audit(conn, "user_create", me["username"],
-             "新建用户 %s（%s）" % (name, "管理员" if adm else "普通"), request.remote_addr, me["id"])
+             "新建用户 %s（%s）" % (name, "管理员" if adm else "普通"), _ip(), me["id"])
     return jsonify({"ok": True, "message": "已创建用户 %s" % name, "id": cur.lastrowid})
 
 
@@ -561,6 +759,11 @@ def api_user_update(uid):
                 return jsonify({"ok": False,
                                 "message": "至少要保留一个启用状态的管理员"}), 400
         conn.execute("UPDATE users SET status=? WHERE id=?", (v, uid))
+        if v != "active":
+            # 停用必须**连会话一起断**：只改 status 的话，对方手上那台设备
+            # 要到下一个请求才被拦（也不是不行），但版本号一并推掉更干净 ——
+            # 将来若有人把 current_user 的状态检查挪走，这里还有一道。
+            db.bump_session_ver(conn, uid)
         changed.append("状态→" + ("启用" if v == "active" else "停用"))
     pwd = (body.get("password") or "").strip()
     if pwd:
@@ -569,12 +772,15 @@ def api_user_update(uid):
             return jsonify({"ok": False, "message": err}), 400
         conn.execute("UPDATE users SET password_hash=? WHERE id=?",
                      (security.hash_password(pwd), uid))
+        # 管理员重置口令后，该账号在别处的登录必须立刻失效 ——
+        # 重置口令的典型场景就是「怀疑账号被盗」。
+        db.bump_session_ver(conn, uid)
         changed.append("密码")
     if not changed:
         return jsonify({"ok": False, "message": "没有要修改的内容"}), 400
     db.audit(conn, "user_update", me["username"],
              "修改用户 %s：%s" % (row["username"], "、".join(changed)),
-             request.remote_addr, me["id"])
+             _ip(), me["id"])
     return jsonify({"ok": True, "message": "已更新：" + "、".join(changed)})
 
 
@@ -605,7 +811,7 @@ def api_user_delete(uid):
     conn.execute("DELETE FROM users WHERE id=?", (uid,))
     db.audit(conn, "user_delete", me["username"],
              "删除用户 %s（%s）" % (row["username"], "保留其数据" if keep else "连同数据一并删除"),
-             request.remote_addr, me["id"])
+             _ip(), me["id"])
     return jsonify({"ok": True, "message": "已删除 " + row["username"]})
 
 

workbuddy_portal/web/templates/backups.html

@@ -0,0 +1,236 @@
+{% extends "base.html" %}
+{% block title %}备份管理 · {{ project_title }}{% endblock %}
+{% block body %}
+
+<div class="pagehead">
+  <div>
+    <h1>备份管理</h1>
+    <p class="lead">
+      整库<b>一致性快照</b>：可自动按周期备份、按份数自动清理，也能手工下载与恢复到任意一份
+    </p>
+  </div>
+  <div class="actions">
+    <span class="tag accent">仅管理员可见</span>
+    <button class="btn primary" id="btnBackupNow" type="button">立即备份</button>
+  </div>
+</div>
+<div id="collectMsg" class="flash" style="display:none"></div>
+
+<div class="kpis">
+  <div class="kpi" style="--c:var(--cyan)">
+    <span>归档份数</span><b>{{ info.count }}</b>
+    <i>保留上限 {{ info.keep }} 份</i>
+  </div>
+  <div class="kpi" style="--c:var(--violet)">
+    <span>备份占用</span><b>{{ info.total }}</b>
+    <i>当前库 {{ info.db_bytes }}</i>
+  </div>
+  <div class="kpi" style="--c:{{ 'var(--green)' if info.enabled else 'var(--red)' }}">
+    <span>自动备份</span><b>{{ '已开启' if info.enabled else '已关闭' }}</b>
+    <i>每 {{ info.interval }} 小时一次</i>
+  </div>
+  <div class="kpi" style="--c:var(--blue)">
+    <span>上次 / 下次自动备份</span>
+    <b>{{ info.last_auto[5:16] if info.last_auto != '—' else '还没有' }}</b>
+    <i>{% if info.never_auto %}等待调度线程首轮检查（约 20 秒）
+       {%- elif info.next_auto != '—' %}下次 {{ info.next_auto[5:16] }}
+       {%- else %}未开启{% endif %}</i>
+  </div>
+</div>
+
+<div class="flash warn" style="margin-bottom:16px">
+  <b>恢复会覆盖当前全部数据</b>（账号、用量、配置一起换成归档里的那一份）。
+  系统会在恢复前<b>自动先备份一次当前库</b>并保留在列表里，恢复错了可以再恢复到那一份。
+  恢复完成后所有既有登录会话失效，需要重新登录。
+</div>
+
+<div class="grid2">
+  <section class="card">
+    <div class="cardhead">
+      <h2>自动备份设置</h2>
+      <span class="tag accent">实例级</span>
+    </div>
+    <form id="formBackup">
+      {% set b = num_settings %}
+      <label class="row"><span>启用自动备份</span>
+        <select name="backup_enabled">
+          <option value="1" {{ 'selected' if s.backup_enabled != '0' }}>启用</option>
+          <option value="0" {{ 'selected' if s.backup_enabled == '0' }}>关闭</option>
+        </select>
+      </label>
+      <label class="row"><span>备份周期</span>
+        <input name="backup_interval_hours" type="number"
+               min="{{ b.backup_interval_hours[0] }}" max="{{ b.backup_interval_hours[1] }}"
+               value="{{ s.backup_interval_hours }}">
+        <em class="unit">{{ b.backup_interval_hours[0] }}~{{ b.backup_interval_hours[1] }} 小时</em></label>
+      <label class="row"><span>保留份数</span>
+        <input name="backup_keep" type="number"
+               min="{{ b.backup_keep[0] }}" max="{{ b.backup_keep[1] }}"
+               value="{{ s.backup_keep }}">
+        <em class="unit">份（超出的自动删最旧的）</em></label>
+      <button class="btn primary" type="submit">保存备份设置</button>
+      <p class="hint">
+        自动备份在调度线程里执行，有采集任务在跑时会自动让路、下一轮再打。
+        备份使用 SQLite 的在线备份 API，<b>采集写入期间也能拿到一致快照</b> ——
+        这一点是手工 <code>cp usage.sqlite</code> 做不到的。
+        每份归档打完后按「保留份数」清理最旧的那些。
+      </p>
+    </form>
+  </section>
+
+  <section class="card">
+    <div class="cardhead">
+      <h2>归档里有什么</h2>
+      <span class="tag mute">安全提示</span>
+    </div>
+    <table class="kv">
+      <tr><th>备份目录</th><td class="mono" style="word-break:break-all">{{ info.dir }}</td></tr>
+      <tr><th>内容</th><td>
+        所有 <code>*.sqlite</code> 的一致性快照<br>
+        <code>instance.json</code>（含两把主密钥）<br>
+        <code>manifest.json</code>（时间、行数、积分、逐文件校验值）
+      </td></tr>
+      <tr><th>为什么带上密钥</th><td>
+        没有 <code>instance.json</code> 里的 <code>cookie_key</code>，归档里的凭证密文
+        就永远解不开 —— 那样的「恢复」等于把所有账号的 Cookie 弄丢。
+      </td></tr>
+      <tr><th>因此</th><td>
+        <b>归档等于全库数据 + 密钥</b>，下载后请当作机密文件保管；
+        它<b>不会</b>进入代码仓库、也不会被打进镜像（见 <code>.gitignore</code> /
+        <code>.dockerignore</code>）。
+      </td></tr>
+      <tr><th>目录独立</th><td>
+        备份目录刻意<b>不在 <code>data/</code> 里面</b>：容器里 <code>data/</code> 是数据卷，
+        <code>docker compose down -v</code> 会把正本和副本一起删掉。
+        容器里它挂在独立卷 <code>wb_backups</code> 上。
+      </td></tr>
+    </table>
+  </section>
+</div>
+
+<section class="card">
+  <div class="cardhead">
+    <h2>备份列表</h2>
+    <span class="hint">新 → 旧，共 {{ rows|length }} 条（含已丢失的条目）</span>
+  </div>
+  <div class="tablewrap">
+    <table class="tbl" id="backupTable">
+      <thead><tr>
+        <th>文件名</th><th>生成时间</th><th>来源</th><th class="num">大小</th>
+        <th class="num">记录</th><th class="num">积分</th><th class="num">账号</th>
+        <th>库版本</th><th>操作</th>
+      </tr></thead>
+      <tbody>
+      {% for r in rows %}
+        <tr data-file="{{ r.filename }}" data-exists="{{ 1 if r.exists else 0 }}">
+          <td class="mono sm" style="word-break:break-all">
+            {{ r.filename }}
+            {% if not r.exists %}<br><span class="tag bad">文件已丢失</span>{% endif %}
+          </td>
+          <td class="mono sm nowrap">{{ r.created_at or '—' }}</td>
+          <td class="nowrap">
+            <span class="tag {{ 'accent' if r.trigger == 'manual' else ('warn' if r.trigger == 'pre-restore' else 'mute') }}">
+              {{ r.trigger }}</span>
+            {# CLI 造的备份 trigger 与 actor 都是 "cli"，印两遍是纯噪音；
+               只在两者不同时（auto/system、manual/张三）才补一行操作者 #}
+            {% if r.actor and r.actor != r.trigger %}
+            <br><span class="muted sm">{{ r.actor }}</span>{% endif %}
+          </td>
+          <td class="num nowrap">{{ r.size_h }}</td>
+          <td class="num">{% if r.records %}{{ '{:,}'.format(r.records) }}{% else %}—{% endif %}</td>
+          <td class="num">{% if r.credits %}{{ '%.2f'|format(r.credits) }}{% else %}—{% endif %}</td>
+          <td class="num">{% if r.users %}{{ r.users }}{% else %}—{% endif %}</td>
+          <td class="mono sm">uv={{ r.schema_ver }}</td>
+          <td class="nowrap">
+            {% if r.exists %}
+              <a class="btn sm ghost" href="{{ url_for('api.api_backup_download', filename=r.filename) }}">下载</a>
+              <button class="btn sm" type="button" data-act="restore">恢复</button>
+              <button class="btn sm danger" type="button" data-act="del">删除</button>
+            {% else %}
+              <button class="btn sm ghost" type="button" data-act="forget"
+                      title="文件已不在磁盘上，只清掉这条索引记录">移除条目</button>
+            {% endif %}
+          </td>
+        </tr>
+      {% else %}
+        <tr><td colspan="9" class="empty">还没有任何备份。点右上角「立即备份」生成第一份。</td></tr>
+      {% endfor %}
+      </tbody>
+    </table>
+  </div>
+  <p class="hint">
+    列表里的「记录 / 积分 / 账号」是归档生成时的计数，用来挑一份合适的恢复 ——
+    恢复前程序还会再校验一次归档的完整性与库结构版本，校验不过不会动你的数据。
+    档案文件名只能由本程序生成（服务端会拒绝任何带路径的文件名）。
+  </p>
+</section>
+
+{% endblock %}
+
+{% block scripts %}
+<script src="{{ url_for('static', filename='js/app.js') }}"></script>
+<script>
+  WBU.bindForm('#formBackup', '/api/settings');
+
+  document.getElementById('btnBackupNow').addEventListener('click', function () {
+    var btn = this, old = btn.textContent;
+    btn.disabled = true; btn.textContent = '备份中…';
+    WBU.post('/api/backups', {}).then(function (j) {
+      if (j.ok === false) { WBU.say(j.message || '备份失败', 'error'); return; }
+      WBU.say(j.message || '备份完成', 'ok');
+      window.setTimeout(function () { location.reload(); }, 1200);
+    }).catch(function (e) {
+      if (String(e.message) !== 'unauthorized') WBU.say('请求失败：' + e.message, 'error');
+    }).finally(function () { btn.disabled = false; btn.textContent = old; });
+  });
+
+  document.getElementById('backupTable').addEventListener('click', function (e) {
+    var btn = e.target.closest('button[data-act]');
+    if (!btn) return;
+    var row = btn.closest('tr'), file = row.dataset.file, act = btn.dataset.act;
+    var old = btn.textContent;
+    btn.disabled = true; btn.textContent = '…';
+
+    function restore_(finish) {
+      if (!window.confirm('确定从「' + file + '」恢复吗？\n\n'
+        + '当前所有账号、用量数据与配置都会被这份归档替换。\n'
+        + '系统会在替换前自动先备份当前库，恢复错了可以再恢复到那一份。')) {
+        finish(); return;
+      }
+      var inc = window.confirm('是否同时恢复 instance.json（含 Cookie 加密主密钥）？\n\n'
+        + '点「确定」= 一并恢复（跨机器迁移必须选这个，否则已存的 Cookie 解密不出来）\n'
+        + '点「取消」= 只恢复数据库（保留本机现有密钥）');
+      WBU.post('/api/backups/' + encodeURIComponent(file) + '/restore',
+               { include_instance: inc ? '1' : '0' })
+        .then(function (j) {
+          if (j.ok === false) { WBU.say(j.message || '恢复失败', 'error'); return; }
+          WBU.say(j.message || '已恢复', 'ok');
+          window.setTimeout(function () { location.href = '/'; }, 2500);
+        })
+        .catch(function (err) {
+          if (String(err.message) !== 'unauthorized') WBU.say('请求失败：' + err.message, 'error');
+        })
+        .finally(finish);
+    }
+
+    if (act === 'restore') {
+      restore_(function () { btn.disabled = false; btn.textContent = old; });
+    } else if (act === 'del') {
+      if (!window.confirm('删除备份文件「' + file + '」？此操作不可撤销。')) {
+        btn.disabled = false; btn.textContent = old; return;
+      }
+      WBU.post('/api/backups/' + encodeURIComponent(file) + '/delete', {})
+        .then(function (j) {
+          if (j.ok === false) { WBU.say(j.message || '删除失败', 'error'); return; }
+          WBU.say(j.message || '已删除', 'ok');
+          window.setTimeout(function () { location.reload(); }, 900);
+        })
+        .catch(function (err) { if (String(err.message) !== 'unauthorized') WBU.say('请求失败：' + err.message, 'error'); })
+        .finally(function () { btn.disabled = false; btn.textContent = old; });
+    } else if (act === 'forget') {
+      WBU.say('该文件已不在磁盘上，删除索引条目请用「清理旧备份」或手工删除数据库行。', 'warn');
+      btn.disabled = false; btn.textContent = old;
+    }
+  });
+</script>
+{% endblock %}

workbuddy_portal/web/templates/base.html

@@ -32,6 +32,9 @@
     {# 日志管理里是实例运行信息（数据库路径 / 账号名 / 来源 IP），仅管理员可见；
        服务端另有 @admin_required 兜底，这里隐藏只是不给出会 403 的死链。 #}
     {% if cur.is_admin %}
+    <a href="{{ url_for('views.backups_page') }}" class="{{ 'on' if nav=='backups' }}">备份管理</a>
+    {% endif %}
+    {% if cur.is_admin %}
     <a href="{{ url_for('views.logs') }}"      class="{{ 'on' if nav=='logs' }}">日志管理</a>
     {% endif %}
     {% if cur.is_admin %}

workbuddy_portal/web/templates/profile.html

@@ -10,6 +10,8 @@
   </div>
   <div class="actions">
     <a class="btn" href="{{ url_for('views.config_page') }}">管理我的凭证</a>
+    <a class="btn ghost" href="{{ url_for('views.profile_export') }}"
+       title="导出你的全部用量明细、采集历史、操作审计与有效配置（不含 Cookie 明文）">导出我的全部数据</a>
   </div>
 </div>
 
@@ -57,12 +59,32 @@
       <label class="col">新密码<input name="new" type="password" autocomplete="new-password"></label>
       <label class="col">确认新密码<input name="new2" type="password" autocomplete="new-password"></label>
       <button class="btn primary" type="submit">修改密码</button>
-      <p class="hint">至少 {{ pwd_min }} 位，且需包含大写字母、小写字母、数字、符号中的至少两类。
-        修改成功后当前会话仍有效，不必重新登录。</p>
+      <p class="hint">至少 {{ pwd_min }} 位，且需包含大写字母、小写字母、数字、符号中的至少两类，
+        且不能是常见弱口令。
+        <b>修改成功后其他设备上的登录会立刻失效</b>（本机这次会话保留，不必重新登录）——
+        「怀疑被盗所以改密码」才能真正生效。</p>
     </form>
   </section>
 </div>
 
+<section class="card">
+  <div class="cardhead">
+    <h2>导出我的全部数据</h2>
+    <span class="tag mute">数据可携带</span>
+  </div>
+  <p class="hint" style="margin-top:0">
+    打包下载<b>属于你账号</b>的所有内容：用量明细、采集历史、与你相关的操作审计、
+    以及账号信息与对你有效的配置。
+    <br><b>不含</b> Cookie 明文（只写「配没配、多少字符、什么时候更新的」）、
+    也不含其他任何账号的数据与实例级运行日志。
+  </p>
+  <div class="btnrow">
+    <a class="btn primary" href="{{ url_for('views.profile_export') }}">导出我的全部数据（zip）</a>
+    <a class="btn ghost" href="{{ url_for('views.records') }}">只导出用量明细（CSV）</a>
+  </div>
+  <p class="hint">导出动作按账号有最小间隔（10 秒）保护，避免脚本反复触发整表扫描。</p>
+</section>
+
 <section class="card">
   <div class="cardhead">
     <h2>我的采集凭证</h2>

workbuddy_portal/web/templates/tasks.html

@@ -31,7 +31,10 @@
         <input name="schedule_times" value="{{ s_times }}" placeholder="09:00,17:00" spellcheck="false">
       </label>
       <p class="hint">本地时区，逗号分隔，支持 <code>HH:MM</code>（也可只写 <code>9</code>）。
-        保存后立即生效；已经过去且不再存在的时刻会被清掉，新的时刻当天就会接管。</p>
+        保存后立即生效；已经过去且不再存在的时刻会被清掉，新的时刻当天就会接管。
+        <br><b>最多 {{ max_slots }} 个时刻</b>（当前 {{ sch.times|length }} 个）—— 时刻数量直接决定
+        采集频次，是对外提供服务时控制云端压力的旋钮。需要更多请先到「配置管理」
+        把「每日调度时刻上限」调大。</p>
       <label class="row"><span>启动补跑</span>
         <select name="catch_up">
           <option value="1" {{ 'selected' if sch.catch_up }}>开启（错过的时刻在宽限期内补跑）</option>
@@ -75,11 +78,16 @@
     <hr class="sect-divider">
     <h3>历史回填</h3>
     <form id="formBackfill">
-      <label class="row"><span>起始日期</span><input type="date" name="from" max="{{ sch.now[:10] }}"></label>
+      <label class="row"><span>起始日期</span>
+        <input type="date" name="from" max="{{ sch.now[:10] }}"
+               data-min-days="{{ max_days }}"></label>
       <label class="row"><span>结束日期</span><input type="date" name="to" value="{{ sch.now[:10] }}" max="{{ sch.now[:10] }}"></label>
       <button class="btn" type="submit">按区间补采</button>
       <p class="hint">指定区间重新拉取云端明细，已存在的记录按 <code>RequestID</code> 去重，不会重复计入。
-        区间越大耗时越长（云端按天分页拉取）。</p>
+        <br><b>单次最长 {{ max_days }} 天</b>（超过会被服务端拒绝，请分批补），
+        且<b>同一账号两次采集之间需间隔 {{ min_gap }} 秒</b>、<b>有任务在跑时不能再发起</b> ——
+        这三条是为了避免把云端接口与本站线程池打满。
+        手动点「立即采集一次」只走增量（从最后一条记录续拉），通常几秒完成。</p>
     </form>
   </section>
 </div>

workbuddy_portal/web/views.py

@@ -28,13 +28,16 @@
 """
 import csv
 import io
+import json
 import os
 import sqlite3
+import tempfile
+import zipfile
 
 from flask import (Blueprint, current_app, flash, jsonify, redirect, render_template,
                    request, send_from_directory, session, url_for)
 
-from .. import collect, config, db, query, scheduler, security
+from .. import backup, collect, config, db, query, scheduler, security
 from ..security import (admin_required, current_user, is_admin, login_required,
                         safe_next)
 
@@ -42,7 +45,13 @@ bp = Blueprint("views", __name__)
 
 
 def _ip():
-    return request.headers.get("X-Forwarded-For", request.remote_addr or "").split(",")[0].strip()
+    """客户端地址。**全站统一走 security.client_ip()**。
+
+    原来这里直接取 `X-Forwarded-For` 的第 0 段，等于把「来源 IP」交给请求方
+    自己申报：验证码出图限速、注册配额、登录锁定三道 IP 防线会一起失效。
+    具体取法与开关见 security.client_ip 的注释。
+    """
+    return security.client_ip()
 
 
 def _uid():
@@ -104,10 +113,15 @@ def login():
         username = (request.form.get("username") or "").strip()
         pwd = request.form.get("password") or ""
 
+        # 先记一次「尝试」（含成功）。只按失败计数会被「慢慢撞」绕过：
+        # 攻击者只要把失败次数控制在阈值以下就能无限试。
+        security.note_try(ip)
         left = security.auth_locked(ip, username)
         if left:
-            security.audit_login_fail(conn, username, "已锁定，剩余 %d 秒" % left, ip)
-            flash("登录失败次数过多，请 %d 秒后再试" % left, "error")
+            reason = security.auth_block_reason(ip, username)
+            security.audit_login_fail(conn, username,
+                                      "已限速（%s），剩余 %d 秒" % (reason, left), ip)
+            flash(security.auth_block_message(reason, left), "error")
             return render_template("login.html",
                                    **_login_ctx(conn, next_url=nxt, username=username,
                                                 need_captcha=True)), 429
@@ -127,7 +141,9 @@ def login():
         if user is None:
             n = security.note_auth_fail(ip, username)
             security.audit_login_fail(conn, username, err + "（第 %d 次）" % n, ip)
-            flash("%s（剩余尝试 %d 次）" % (err, max(0, config.MAX_LOGIN_FAILS - n)), "error")
+            # 不再报「剩余 N 次」：用户名维度的计数已经在攻击者手里了，
+            # 报出来的数字会变成「还差几次就能把这个人锁住」的倒计时。
+            flash("%s（本来源连续失败 %d 次）" % (err, n), "error")
             # 必须把 next 显式回填：失败后 request.args 为空，
             # 若模板从 request.args 取值会导致跳转目标丢失（历史 bug）。
             return render_template("login.html",
@@ -176,9 +192,11 @@ def register():
         ctx = _register_ctx(username=username, display_name=display, email=email,
                             need_captcha=True)
 
+        security.note_try(ip)
         left = security.auth_locked(ip, username)
         if left:
-            flash("操作过于频繁，请 %d 秒后再试" % left, "error")
+            reason = security.auth_block_reason(ip, username)
+            flash(security.auth_block_message(reason, left), "error")
             return render_template("register.html", **ctx), 429
 
         # 注册一律要验证码：这是唯一能让陌生人写库的入口
@@ -313,9 +331,14 @@ def tasks():
                         " LIMIT ? OFFSET ?", (uid, size, (page - 1) * size)).fetchall()
     s = db.get_settings(conn, uid=uid)
     pages = max(1, (total + size - 1) // size)
+    # 三道闸门的当前取值，直接交给页面：前端据此提前禁用/限位，
+    # 而不是让用户填完了再吃一个 400/409/429。
     return render_template("tasks.html", runs=runs, sch=_sch_info(conn, uid),
                            s_times=s.get("schedule_times") or "",
                            s_grace=s.get("catch_up_grace_hours") or "12",
+                           max_slots=s.get("max_schedule_slots_per_day") or "6",
+                           max_days=collect.max_range_days(conn),
+                           min_gap=collect.min_interval_seconds(conn),
                            can_edit=is_admin(),
                            page=page, pages=pages, total=total,
                            page_window=_page_window(page, pages),
@@ -572,6 +595,190 @@ def records_export():
     return resp
 
 
+# ---------------- 备份管理（仅管理员） ----------------
+@bp.get("/backups")
+@admin_required
+def backups_page():
+    """备份管理 —— **仅管理员**。
+
+    这一页能下载整库归档、也能把整库恢复回某个时刻，权限等价于
+    「拿到所有人的数据并覆盖它」，所以必须是管理员专属：页面用
+    @admin_required，接口层另有同样的一层。
+    """
+    conn = db.get_db()
+    backup.sync_index(conn)                 # 磁盘才是事实来源，进页面对一次账
+    rows = backup.listing(conn)
+    last_auto = backup.last_auto_at(conn)
+    nxt = backup.next_auto_at(conn)
+    info = {
+        "dir": config.BACKUP_DIR,
+        "count": len([r for r in rows if r["exists"]]),
+        "total": backup.human(backup.total_bytes(conn)),
+        "enabled": db.get_bool(conn, "backup_enabled", True),
+        "interval": db.get_int(conn, "backup_interval_hours", 24),
+        "keep": db.get_int(conn, "backup_keep", 7),
+        "last_auto": last_auto or "—",
+        # 从来没有跑过自动备份时，next_auto_at() 返回的是**当前时间**
+        # （语义是「马上就轮到它」）。直接印成时间会让人以为那是个已经过去的
+        # 计划点，所以这里区分成「还没跑过」与「下次某时刻」两种显示。
+        "next_auto": nxt.strftime("%Y-%m-%d %H:%M:%S") if (nxt and last_auto) else "—",
+        "never_auto": not last_auto,
+        "db_bytes": backup.human(os.path.getsize(config.SQLITE_PATH)
+                                 if os.path.exists(config.SQLITE_PATH) else 0),
+    }
+    s = db.get_settings(conn)
+    return render_template("backups.html", rows=rows, info=info, s=s,
+                           num_settings=config.NUM_SETTINGS, active="backups")
+
+
+# ---------------- 个人数据导出（每个账号都能导自己的） ----------------
+def _zip_stream(buf, filename, mimetype="application/zip"):
+    """把已生成好的临时缓冲流给浏览器，并在流结束后关掉它。"""
+    from flask import Response
+
+    def gen():
+        try:
+            buf.seek(0)
+            while True:
+                chunk = buf.read(65536)
+                if not chunk:
+                    break
+                yield chunk
+        finally:
+            try:
+                buf.close()
+            except Exception:           # noqa: BLE001
+                pass
+
+    resp = Response(gen(), mimetype=mimetype,
+                    headers={"Content-Disposition": 'attachment; filename="%s"' % filename})
+    resp.headers["X-Accel-Buffering"] = "no"
+    return resp
+
+
+@bp.get("/profile/export")
+@login_required
+def profile_export():
+    """导出「我的全部数据」。
+
+    这是普通账号的数据可携带出口，所以**只含本人的数据**，且
+    **绝不含 Cookie 明文**（只写「有没有配、多少字符、什么时候更新的」）。
+    归档里放使用记录、采集历史、本人审计与本人配置四份，另加一份说明。
+    """
+    u = current_user()
+    uid = u["id"]
+    ok, wait = security.action_allowed("export:%d" % uid, 10)
+    if not ok:
+        return render_template("error.html", code=429,
+                               message="导出太频繁了，请 %d 秒后再试" % wait), 429
+
+    conn = db.get_db()
+    buf = tempfile.SpooledTemporaryFile(max_size=16 * 1024 * 1024)
+    with zipfile.ZipFile(buf, "w", zipfile.ZIP_DEFLATED) as z:
+        # ---- 1. 使用记录（与官网 xlsx、CSV 导出同构的列）----
+        with z.open("使用记录.csv", "w") as f:
+            f.write("\ufeff".encode("utf-8"))
+            b = io.StringIO()
+            w = csv.writer(b, lineterminator="\r\n")
+            w.writerow(collect.FIELDS)
+            f.write(b.getvalue().encode("utf-8"))
+            for r in query.iter_records(conn, uid, None, None):
+                b.seek(0)
+                b.truncate(0)
+                w.writerow([r["request_id"], "%.2f" % r["credits"], r["prompt"] or "",
+                            r["model"], r["client"], r["ts"]])
+                f.write(b.getvalue().encode("utf-8"))
+
+        # ---- 2. 采集历史 ----
+        with z.open("采集历史.csv", "w") as f:
+            f.write("\ufeff".encode("utf-8"))
+            b = io.StringIO()
+            w = csv.writer(b, lineterminator="\r\n")
+            w.writerow(["id", "触发方式", "状态", "开始", "结束", "耗时ms",
+                        "窗口起", "窗口止", "云端返回", "新增", "重复", "存档总数",
+                        "冲突", "结论"])
+            for r in conn.execute(
+                    "SELECT id,trigger,status,started_at,finished_at,duration_ms,win_from,"
+                    "win_to,fetched,added,dup,total,conflicts,message FROM collect_runs"
+                    " WHERE user_id=? ORDER BY id", (uid,)):
+                b.seek(0)
+                b.truncate(0)
+                w.writerow(list(r))
+                f.write(b.getvalue().encode("utf-8"))
+
+        # ---- 3. 本人相关的操作审计 ----
+        with z.open("操作审计.csv", "w") as f:
+            f.write("\ufeff".encode("utf-8"))
+            b = io.StringIO()
+            w = csv.writer(b, lineterminator="\r\n")
+            w.writerow(["时间", "操作者", "动作", "说明", "来源 IP"])
+            for r in conn.execute(
+                    "SELECT at,actor,action,detail,ip FROM audit_log"
+                    " WHERE user_id=? ORDER BY id", (uid,)):
+                b.seek(0)
+                b.truncate(0)
+                w.writerow(list(r))
+                f.write(b.getvalue().encode("utf-8"))
+
+        # ---- 4. 账号与有效配置（凭证只回状态）----
+        row = db.user_by_id(conn, uid)
+        st = db.secret_state(conn, "cookie", uid)
+        cfg = db.get_settings(conn, uid=uid)
+        for k in [k for k in list(cfg) if config.is_internal_key(k)]:
+            cfg.pop(k, None)
+        cfg.pop("cookie", None)
+        snaps = {k: v for k, v in cfg.items()
+                 if not (isinstance(v, str) and len(v) > 200)}
+        payload = {
+            "导出时间": db.now_str(),
+            "程序版本": _app_version(),
+            "账号": {
+                "id": row["id"], "用户名": row["username"],
+                "显示名": row["display_name"], "邮箱": row["email"],
+                "角色": "管理员" if row["is_admin"] else "普通账号",
+                "状态": row["status"], "注册时间": row["created_at"],
+                "注册来源 IP": row["register_ip"],
+                "最后登录": row["last_login_at"], "登录次数": row["login_count"],
+            },
+            "数据量": {
+                "记录条数": conn.execute("SELECT COUNT(*) FROM usage_records"
+                                         " WHERE user_id=?", (uid,)).fetchone()[0],
+                "积分合计": round(conn.execute(
+                    "SELECT COALESCE(SUM(credits),0) FROM usage_records"
+                    " WHERE user_id=?", (uid,)).fetchone()[0], 2),
+            },
+            "凭证状态": {
+                "Cookie": ("已配置 %d 字符，尾部 …%s" % (st["chars"], st["tail"])) if st["set"]
+                          else ("无法解密" if st["broken"] else "未配置"),
+                "说明": "出于安全考虑，导出文件里不含 Cookie 明文；如需迁移请到「配置管理」重新粘贴。",
+            },
+            "有效配置": snaps,
+        }
+        with z.open("我的账号与配置.json", "w") as f:
+            f.write(json.dumps(payload, ensure_ascii=False, indent=2).encode("utf-8"))
+
+        with z.open("说明.txt", "w") as f:
+            f.write(("本归档是账号「%s」在本站的全部数据副本。\n\n"
+                     "包含：\n"
+                     "  使用记录.csv        —— 你的全部用量明细（与官网导出同构）\n"
+                     "  采集历史.csv        —— 你的采集任务运行历史\n"
+                     "  操作审计.csv        —— 与你账号相关的操作记录\n"
+                     "  我的账号与配置.json —— 账号信息与对你有有效的配置\n\n"
+                     "不包含：Cookie 明文、任何他人的数据、实例级运行日志。\n"
+                     "导出时间：%s\n程序版本：%s\n"
+                     % (u["username"], db.now_str(), _app_version())).encode("utf-8"))
+
+    name = "my-data_%s_%s.zip" % (u["username"], db.now_str()[:10])
+    db.audit(conn, "export_self", u["username"], "导出个人全部数据（%s）" % name,
+             _ip(), uid)
+    return _zip_stream(buf, name)
+
+
+def _app_version():
+    from .. import __version__
+    return __version__
+
+
 # ---------------- 兼容旧地址 ----------------
 @bp.get("/index.html")
 def legacy_index():