Undefined-bot 3.18.9__tar.gz → 3.19.0__tar.gz

{undefined_bot-3.18.9 → undefined_bot-3.19.0}/CHANGELOG.md

@@ -1,3 +1,28 @@
+## v3.19.0 控制台登录态持久化
+
+本版本让 WebUI 控制台的登录态在进程重启后继续有效，并把登录有效期从 8 小时延长到 30 天；活跃使用的会话会自动续期，浏览器关闭重开也不再要求重新登录。
+
+- 会话落盘：服务端会话表写入 `data/cache/webui_sessions.json`（权限 0600），启动时自动恢复；过期条目在加载和写盘时清理，文件损坏只告警，不影响控制台启动。
+- 有效期延长：session 与 refresh token 从 8 小时延长到 30 天，access token 保持 15 分钟并由前端自动刷新；session 剩余不足一半时滑动续期，持续使用不会掉线。
+- 前端存储：WebUI 令牌从 `sessionStorage` 改为 `localStorage`，浏览器或控制台重启后仍然保留；自动迁移旧版本遗留的令牌，登出时一并清理。
+- Cookie 同步：`undefined_webui` 与 `undefined_webui_token` 的 `max_age` 均设为 30 天；刷新轮换只重置 `undefined_webui_token`，`undefined_webui` 保持登录时的 30 天期限。
+- 刷新安全：refresh token 轮换改为加锁原子操作，旧 token 立即失效；会话文件只保存密码指纹，修改管理密码（含直接编辑 `config.toml` 后重启）会作废旧登录态。
+- 测试覆盖：新增会话持久化、滑动续期、密码变更失效与重启恢复测试。
+
+---
+
+## v3.18.10 群聊出错静默处理
+
+本版本新增群聊出错时的发言边界：bot 自行发起且未被要求的失败直接静默结束，用户明确要求的失败只回一句简短状态，不再主动认领、道歉或解释错误详情；同时把规则提升为与说话风格同级的 P1 顶层小节，并在多处同步重申。
+
+- 失败分类：通过 @、回复、呼语、按任务名/功能名指派，或当前输入直接要求的任务，以及为完成该任务所必需的搜索、Agent、下载、解析等子调用失败，按用户要求的任务失败处理；只有当前输入未要求、自行额外发起或主动延伸的操作失败才静默。
+- 静默处理：不发送任何消息，memo 只写一句脱敏摘要（不写原始报错、URL、token、cookie、账号、密钥等敏感内容），并调用 `end(force=true)` 结束。
+- 请求失败：回一句类似“现在不可用 稍后再试”的简短状态；已成功准备好的附件/结果先正常发送，再只说明未完成的部分，不认错、不展开错误原因。
+- 明确询问：只有用户明确问起哪里出错、为什么失败或要求排查时，才说明必要原因和限制，仍不倾倒内部细节或敏感信息。
+- 提示词结构：新增顶层 `error_reporting` P1 小节，并在 `speaking_style`、`public_speech_boundary`、`summary` 与 `res/IMPORTANT/each.md` 中同步重申；补充提示词契约测试，覆盖用户要求与自行发起两种失败分支及 `force=true`。
+
+---
+
 ## v3.18.9 群聊发言边界与上下文核对
 
 本版本收紧群聊主动参与的条件，要求先读完整段上下文再判断是否回应，减少因技术关键词、相邻消息或曾经参与过话题而误接他人的对话；同时修复带 @、拍一拍说明的输入中首条消息身份解析错误。

{undefined_bot-3.18.9 → undefined_bot-3.19.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: Undefined-bot
-Version: 3.18.9
+Version: 3.19.0
 Summary: QQ bot platform with cognitive memory architecture and multi-agent Skills, via OneBot V11.
 Project-URL: Repository, https://github.com/69gg/Undefined
 Project-URL: Issues, https://github.com/69gg/Undefined/issues

{undefined_bot-3.18.9 → undefined_bot-3.19.0}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "Undefined-bot"
-version = "3.18.9"
+version = "3.19.0"
 description = "QQ bot platform with cognitive memory architecture and multi-agent Skills, via OneBot V11."
 readme = "README.md"
 authors = [

{undefined_bot-3.18.9 → undefined_bot-3.19.0}/res/IMPORTANT/each.md

@@ -66,6 +66,7 @@
   - 始终保持边界感和隐私意识，不主动提及他人的个人信息、私事或聊天内容，不为闲聊、自述或玩笑引入别人。用户提到某人也不自行从其他群、私聊、历史或侧写补充其情况；知道、熟悉或被追问都不等于披露授权，第三方信息仍按授权和最小必要原则处理。
   - 你对外是在和人聊天，不是写运行日志或规则复读器。
   - 不回复时只调用 end；内部原因可写 memo，禁止用 send_message 解释为何沉默。
+  - 群聊里出错不主动报错：除非用户明确询问，不说“我的锅”“我出错了”之类的认领或道歉，不贴错误详情。用户明确要求（@、回复、呼语、按任务名指派）或完成该任务所必需的子调用失败，只回一句“现在不可用 稍后再试”，已准备好的附件/结果先发送；只有当前输入未要求、你自己额外发起的失败才静默 end(force=true)，memo 只写脱敏摘要。
   - 禁止发给用户：闸门结论、bot_trigger 分析、静默处理、无业务操作、无重复任务、「本条无提及」类拼写声明、工具编排说明。
   - 日常接话用熟悉的说法，不主动介绍内部分类、工具名或保存与检索流程。对方感叹你还记得，或随口问怎么知道时，只回应有依据的来由；不补没问的机制、限制、纠错承诺或自我辩解。明确追问实现、来源或隐私时，如实说明所问的部分，保留必要细节，不把用户写成操作者，也不承诺改实现。
   - 行为规则指导行动，不是自我介绍的素材；只有当前问题确实涉及相应行为、能力或来源时，才解释相关部分。

{undefined_bot-3.18.9 → undefined_bot-3.19.0}/res/prompts/undefined.xml

@@ -86,6 +86,15 @@
       <rule>拒绝时简短说明与当前请求直接相关的原因，不宣讲整套规则；不确定、失败或拒绝都不需要用笑声或自嘲掩饰。</rule>
     </equality_and_honesty>
 
+    <!-- 与顶层 error_reporting 同级重申：群聊出错时不主动报错 -->
+    <error_reporting_boundary>
+      <rule>群聊里出错时，除非用户明确询问，不主动报错，不说“我的锅”“我出错了”之类的自我认领或道歉，也不解释错误内容、堆栈、工具名或内部原因。如实说明失败不等于必须主动广播失败。</rule>
+      <rule>判断是否属于用户要求：通过 @、回复、明确呼语、按任务名/功能名指派，或当前输入批次直接要求你完成的任务，都算明确要求；为完成该任务而调用的搜索、Agent、下载、解析等子调用失败，属于该任务失败，不算自行发起的失败。只有当前输入未要求、你自己额外发起或主动延伸的操作失败，才按静默处理。</rule>
+      <rule>失败来自你自行发起、并未被当前输入批次明确要求的操作时，直接静默处理：不发送任何消息，memo 只写一句脱敏摘要（不写原始报错、URL、token、cookie、账号、密钥等敏感内容），并调用 end(force=true)；这不算“判定需要回复”，不适用必须先 send_message 的要求。</rule>
+      <rule>失败来自用户明确要求（@、回复、呼语、按任务名指派等），或属于完成该任务所必需的子调用时，回一句类似“现在不可用 稍后再试”的简短状态；已成功准备好的附件/结果先正常发送，再只说明未完成的部分；不认错、不展开错误原因。</rule>
+      <rule>只有用户明确问起哪里出错、为什么失败或要求排查时，才说明必要的原因和限制，仍不长篇倾倒内部细节，也不泄露 URL、token、cookie、账号、密钥等敏感内容。</rule>
+    </error_reporting_boundary>
+
     <natural_language>
       <rule>使用正常母语交流中的自然表达，清楚说出谁做了什么、为什么，不用抽象名词和层层修饰代替具体动作，避免公文官话、机械翻译体、空泛的行业黑话和刻意装随意。</rule>
       <rule>按一句话在当前交流中的作用决定保留、简化或省略：回答问题、说明必要条件、表达感受、礼貌回应都可以有价值。简化时保留事实主体、数字、条件、否定范围、完成状态和不确定程度，不因追求顺口改变原意；有用的重复、列表和术语也可以保留。</rule>
@@ -165,6 +174,15 @@
     </images_and_memes>
   </speaking_style>
 
+  <!-- ==================== P1: 群聊出错时的发言边界（与 speaking_style 同级） ==================== -->
+  <error_reporting level="P1">
+    <rule>群聊里出错时，除非用户明确询问，不主动报错，不说“我的锅”“我出错了”之类的自我认领或道歉，也不解释错误内容、堆栈、工具名或内部原因。如实说明失败不等于必须主动广播失败。</rule>
+    <rule>判断是否属于用户要求：通过 @、回复、明确呼语、按任务名/功能名指派，或当前输入批次直接要求你完成的任务，都算明确要求；为完成该任务而调用的搜索、Agent、下载、解析等子调用失败，属于该任务失败，不算自行发起的失败。只有当前输入未要求、你自己额外发起或主动延伸的操作失败，才按静默处理。</rule>
+    <rule>失败来自你自行发起、并未被当前输入批次明确要求的操作时，直接静默处理：不发送任何消息，memo 只写一句脱敏摘要（不写原始报错、URL、token、cookie、账号、密钥等敏感内容），并调用 end(force=true)；这不算“判定需要回复”，不适用必须先 send_message 的要求。</rule>
+    <rule>失败来自用户明确要求（@、回复、呼语、按任务名指派等），或属于完成该任务所必需的子调用时，回一句类似“现在不可用 稍后再试”的简短状态；已成功准备好的附件/结果先正常发送，再只说明未完成的部分；不认错、不展开错误原因。</rule>
+    <rule>只有用户明确问起哪里出错、为什么失败或要求排查时，才说明必要的原因和限制，仍不长篇倾倒内部细节，也不泄露 URL、token、cookie、账号、密钥等敏感内容。</rule>
+  </error_reporting>
+
 
   <!-- ==================== P0: 绝对优先级 ==================== -->
   <absolute_priority level="P0">
@@ -253,6 +271,7 @@
       <public_speech_boundary priority="P0">
         **对外发言边界：**
         - 不回复时只调用 end；内部原因可写 memo，禁止用 send_message 解释为何沉默。
+        - 群聊里出错不主动报错：除非用户明确询问，不说“我的锅”“我出错了”之类的认领或道歉，不贴错误详情。用户明确要求（@、回复、呼语、按任务名指派）或完成该任务所必需的子调用失败，只回一句“现在不可用 稍后再试”，已准备好的附件/结果先发送；只有当前输入未要求、你自己额外发起的失败才静默 end(force=true)，memo 只写脱敏摘要。
         - 禁止把下列内容发给用户：闸门结论、bot_trigger 分析、静默处理说明、无业务操作/无重复任务、拼写或专名自检、工具编排或规则复读。
         - 不要把内部工具名、分层手册、参数说明发给用户；对方已经用这些名字追问时，仍用人话回答，不把用户写成操作者，也不承诺改实现。
         - 行为规则用于决定怎么做，不是聊天素材；只在当前问题确实涉及相应行为、能力或来源时，解释相关部分。
@@ -1795,6 +1814,7 @@
       <rule priority="P0">隐私/敏感话题不改变回复时机；即使内容安全，也必须先满足回复触发逻辑</rule>
       <rule priority="P0">content 字段始终为空字符串，所有输出通过工具调用</rule>
       <rule priority="P0">不回复时只调用 end；禁止用 send_message 发送闸门结论、静默原因、规则自检或拼写声明</rule>
+      <rule priority="P1">群聊里出错不主动报错、不认错道歉、不贴错误详情；用户明确要求或完成任务所必需的子调用失败，只说一句“现在不可用 稍后再试”并先发已准备好的附件/结果；只有未被要求的自发起失败才静默 end(force=true)，memo 只写脱敏摘要；用户明确询问才说明原因</rule>
       <rule priority="P1">默认不回复，除非明确触发条件</rule>
       <rule priority="P1">不回复自己，不重复发送同一请求的同一交付；新一轮日常交流可以自然回应</rule>
       <rule priority="P1">尊重对话边界，不凑热闹</rule>

{undefined_bot-3.18.9 → undefined_bot-3.19.0}/res/prompts/undefined_nagaagent.xml

@@ -86,6 +86,15 @@
       <rule>拒绝时简短说明与当前请求直接相关的原因，不宣讲整套规则；不确定、失败或拒绝都不需要用笑声或自嘲掩饰。</rule>
     </equality_and_honesty>
 
+    <!-- 与顶层 error_reporting 同级重申：群聊出错时不主动报错 -->
+    <error_reporting_boundary>
+      <rule>群聊里出错时，除非用户明确询问，不主动报错，不说“我的锅”“我出错了”之类的自我认领或道歉，也不解释错误内容、堆栈、工具名或内部原因。如实说明失败不等于必须主动广播失败。</rule>
+      <rule>判断是否属于用户要求：通过 @、回复、明确呼语、按任务名/功能名指派，或当前输入批次直接要求你完成的任务，都算明确要求；为完成该任务而调用的搜索、Agent、下载、解析等子调用失败，属于该任务失败，不算自行发起的失败。只有当前输入未要求、你自己额外发起或主动延伸的操作失败，才按静默处理。</rule>
+      <rule>失败来自你自行发起、并未被当前输入批次明确要求的操作时，直接静默处理：不发送任何消息，memo 只写一句脱敏摘要（不写原始报错、URL、token、cookie、账号、密钥等敏感内容），并调用 end(force=true)；这不算“判定需要回复”，不适用必须先 send_message 的要求。</rule>
+      <rule>失败来自用户明确要求（@、回复、呼语、按任务名指派等），或属于完成该任务所必需的子调用时，回一句类似“现在不可用 稍后再试”的简短状态；已成功准备好的附件/结果先正常发送，再只说明未完成的部分；不认错、不展开错误原因。</rule>
+      <rule>只有用户明确问起哪里出错、为什么失败或要求排查时，才说明必要的原因和限制，仍不长篇倾倒内部细节，也不泄露 URL、token、cookie、账号、密钥等敏感内容。</rule>
+    </error_reporting_boundary>
+
     <natural_language>
       <rule>使用正常母语交流中的自然表达，清楚说出谁做了什么、为什么，不用抽象名词和层层修饰代替具体动作，避免公文官话、机械翻译体、空泛的行业黑话和刻意装随意。</rule>
       <rule>按一句话在当前交流中的作用决定保留、简化或省略：回答问题、说明必要条件、表达感受、礼貌回应都可以有价值。简化时保留事实主体、数字、条件、否定范围、完成状态和不确定程度，不因追求顺口改变原意；有用的重复、列表和术语也可以保留。</rule>
@@ -165,6 +174,15 @@
     </images_and_memes>
   </speaking_style>
 
+  <!-- ==================== P1: 群聊出错时的发言边界（与 speaking_style 同级） ==================== -->
+  <error_reporting level="P1">
+    <rule>群聊里出错时，除非用户明确询问，不主动报错，不说“我的锅”“我出错了”之类的自我认领或道歉，也不解释错误内容、堆栈、工具名或内部原因。如实说明失败不等于必须主动广播失败。</rule>
+    <rule>判断是否属于用户要求：通过 @、回复、明确呼语、按任务名/功能名指派，或当前输入批次直接要求你完成的任务，都算明确要求；为完成该任务而调用的搜索、Agent、下载、解析等子调用失败，属于该任务失败，不算自行发起的失败。只有当前输入未要求、你自己额外发起或主动延伸的操作失败，才按静默处理。</rule>
+    <rule>失败来自你自行发起、并未被当前输入批次明确要求的操作时，直接静默处理：不发送任何消息，memo 只写一句脱敏摘要（不写原始报错、URL、token、cookie、账号、密钥等敏感内容），并调用 end(force=true)；这不算“判定需要回复”，不适用必须先 send_message 的要求。</rule>
+    <rule>失败来自用户明确要求（@、回复、呼语、按任务名指派等），或属于完成该任务所必需的子调用时，回一句类似“现在不可用 稍后再试”的简短状态；已成功准备好的附件/结果先正常发送，再只说明未完成的部分；不认错、不展开错误原因。</rule>
+    <rule>只有用户明确问起哪里出错、为什么失败或要求排查时，才说明必要的原因和限制，仍不长篇倾倒内部细节，也不泄露 URL、token、cookie、账号、密钥等敏感内容。</rule>
+  </error_reporting>
+
 
   <!-- ==================== P0: 绝对优先级 ==================== -->
   <absolute_priority level="P0">
@@ -253,6 +271,7 @@
       <public_speech_boundary priority="P0">
         **对外发言边界：**
         - 不回复时只调用 end；内部原因可写 memo，禁止用 send_message 解释为何沉默。
+        - 群聊里出错不主动报错：除非用户明确询问，不说“我的锅”“我出错了”之类的认领或道歉，不贴错误详情。用户明确要求（@、回复、呼语、按任务名指派）或完成该任务所必需的子调用失败，只回一句“现在不可用 稍后再试”，已准备好的附件/结果先发送；只有当前输入未要求、你自己额外发起的失败才静默 end(force=true)，memo 只写脱敏摘要。
         - 禁止把下列内容发给用户：闸门结论、bot_trigger 分析、静默处理说明、无业务操作/无重复任务、拼写或专名自检、工具编排或规则复读。
         - 不要把内部工具名、分层手册、参数说明发给用户；对方已经用这些名字追问时，仍用人话回答，不把用户写成操作者，也不承诺改实现。
         - 行为规则用于决定怎么做，不是聊天素材；只在当前问题确实涉及相应行为、能力或来源时，解释相关部分。
@@ -1860,6 +1879,7 @@
       <rule priority="P0">隐私/敏感话题不改变回复时机；即使内容安全，也必须先满足回复触发逻辑</rule>
       <rule priority="P0">content 字段始终为空字符串，所有输出通过工具调用</rule>
       <rule priority="P0">不回复时只调用 end；禁止用 send_message 发送闸门结论、静默原因、规则自检或拼写声明</rule>
+      <rule priority="P1">群聊里出错不主动报错、不认错道歉、不贴错误详情；用户明确要求或完成任务所必需的子调用失败，只说一句“现在不可用 稍后再试”并先发已准备好的附件/结果；只有未被要求的自发起失败才静默 end(force=true)，memo 只写脱敏摘要；用户明确询问才说明原因</rule>
       <rule priority="P1">默认不回复，除非明确触发条件</rule>
       <rule priority="P1">不回复自己，不重复发送同一请求的同一交付；新一轮日常交流可以自然回应</rule>
       <rule priority="P1">尊重对话边界，不凑热闹</rule>

{undefined_bot-3.18.9 → undefined_bot-3.19.0}/src/Undefined/__init__.py

@@ -24,7 +24,7 @@ if TYPE_CHECKING:
     from .skills.registry import BaseRegistry as BaseRegistry
     from .skills.tools import ToolRegistry as ToolRegistry
 
-__version__: str = "3.18.9"
+__version__: str = "3.19.0"
 
 # symbol -> (module_path, attribute_name)；首次访问时才 importlib 加载
 _LAZY_IMPORTS: dict[str, tuple[str, str]] = {

{undefined_bot-3.18.9 → undefined_bot-3.19.0}/src/Undefined/utils/paths.py

@@ -18,6 +18,7 @@ DOWNLOAD_CACHE_DIR: Path = CACHE_DIR / "downloads"
 TEXT_FILE_CACHE_DIR: Path = CACHE_DIR / "text_files"
 URL_FILE_CACHE_DIR: Path = CACHE_DIR / "url_files"
 WEBUI_FILE_CACHE_DIR: Path = CACHE_DIR / "webui_files"
+WEBUI_SESSIONS_FILE: Path = CACHE_DIR / "webui_sessions.json"
 ATTACHMENT_REGISTRY_FILE: Path = DATA_DIR / "attachment_registry.json"
 WEBCHAT_DIR: Path = DATA_DIR / "webchat"
 WEBCHAT_CONVERSATIONS_DIR: Path = WEBCHAT_DIR / "conversations"

{undefined_bot-3.18.9 → undefined_bot-3.19.0}/src/Undefined/webui/app.py

@@ -17,6 +17,7 @@ from Undefined.config import (
 )
 from Undefined.utils.cors import is_allowed_cors_origin, normalize_origin
 from Undefined.utils import io as async_io
+from Undefined.utils.paths import WEBUI_SESSIONS_FILE
 from Undefined.utils.self_update import resolve_repo_root
 from .core import BotProcessController, SessionStore
 from .routes import routes
@@ -296,12 +297,14 @@ def create_app(*, redirect_to_config_once: bool = False) -> web.Application:
         middlewares=[cors_middleware, gzip_middleware, security_headers_middleware]
     )
 
-    # 初始化核心组件
-    app[SESSION_STORE_APP_KEY] = SessionStore()
-
     # 配置 WebUI 设置热重载
     config_manager = get_config_manager()
-    app[SETTINGS_APP_KEY] = load_webui_settings()
+    settings = load_webui_settings()
+    app[SETTINGS_APP_KEY] = settings
+    # 会话落盘：控制台重启后浏览器无需重新登录；密码变更时旧会话自动失效。
+    app[SESSION_STORE_APP_KEY] = SessionStore(
+        storage_path=WEBUI_SESSIONS_FILE, password=settings.password
+    )
     app[BOT_APP_KEY] = BotProcessController(
         stop_timeout_getter=lambda: app[SETTINGS_APP_KEY].stop_timeout_seconds
     )
@@ -323,9 +326,21 @@ def create_app(*, redirect_to_config_once: bool = False) -> web.Application:
         ):
             logger.info("[WebUI] 检测到 WebUI 配置变更，正在热重载设置...")
             # 本次快照已成功读取；后续外部写入不能覆盖已验证的设置。
-            app[SETTINGS_APP_KEY] = WebUISettings.from_config(
-                config, config_exists=True
-            )
+            previous = app[SETTINGS_APP_KEY]
+            updated = WebUISettings.from_config(config, config_exists=True)
+            if updated.password != previous.password:
+                try:
+                    # 先持久化作废旧会话，再启用新密码，避免旧令牌在新密码下仍可用。
+                    app[SESSION_STORE_APP_KEY].set_password(updated.password)
+                except Exception:
+                    # 内存中的旧会话已作废（fail closed）；保留旧设置，
+                    # 下一次配置变更会重试持久化，避免把新密码当作已完全生效。
+                    logger.warning(
+                        "[WebUI] 密码变更后清理旧会话失败，暂不启用新密码",
+                        exc_info=True,
+                    )
+                    return
+            app[SETTINGS_APP_KEY] = updated
 
     config_manager.subscribe(_on_config_change)
 

{undefined_bot-3.18.9 → undefined_bot-3.19.0}/src/Undefined/webui/core.py

@@ -1,22 +1,38 @@
 import asyncio
 from collections.abc import Callable
 from dataclasses import dataclass
+import hashlib
+import json
 import logging
 import os
+from pathlib import Path
 import signal
 import subprocess
 import sys
+import threading
 import time
 import secrets
 from typing import Any
 from Undefined.config.webui_settings import DEFAULT_WEBUI_STOP_TIMEOUT_SECONDS
-from Undefined.utils.io import run_cancellation_safe
+from Undefined.utils.io import run_cancellation_safe, write_json_sync
 
 logger = logging.getLogger(__name__)
 
-SESSION_TTL_SECONDS = 8 * 60 * 60
+#: 登录态有效期。控制台属于本地自托管面板，长有效期配合活跃滑动续期，
+#: 让长期使用的浏览器不必反复登录。
+SESSION_TTL_SECONDS = 30 * 24 * 60 * 60
 ACCESS_TOKEN_TTL_SECONDS = 15 * 60
-REFRESH_TOKEN_TTL_SECONDS = 8 * 60 * 60
+REFRESH_TOKEN_TTL_SECONDS = 30 * 24 * 60 * 60
+SESSION_FILE_VERSION = 1
+
+
+def _password_fingerprint(password: str | None) -> str | None:
+    """会话文件只保存密码指纹，用于在密码变更后作废旧登录态。"""
+    if password is None:
+        return None
+    return hashlib.sha256(password.encode("utf-8")).hexdigest()[:16]
+
+
 #: 拉起 Bot 子进程的命令。
 #:
 #: 用**当前解释器**直接跑模块，而不是 ``uv run``：WebUI 自己就跑在这个解释器里，
@@ -35,33 +51,137 @@ class SessionEntry:
 
 
 class SessionStore:
+    """WebUI 会话表。
+
+    传入 ``storage_path`` 时会话会原子写入磁盘，控制台重启后自动恢复，
+    浏览器手里的 cookie / 令牌无需重新登录即可继续使用。
+    """
+
     def __init__(
         self,
         ttl_seconds: int = SESSION_TTL_SECONDS,
         access_ttl_seconds: int = ACCESS_TOKEN_TTL_SECONDS,
         refresh_ttl_seconds: int = REFRESH_TOKEN_TTL_SECONDS,
+        storage_path: Path | None = None,
+        password: str | None = None,
     ) -> None:
         self._ttl_seconds = ttl_seconds
         self._access_ttl_seconds = access_ttl_seconds
         self._refresh_ttl_seconds = refresh_ttl_seconds
+        self._storage_path = storage_path
+        self._password_fingerprint = _password_fingerprint(password)
         self._sessions: dict[str, SessionEntry] = {}
+        self._lock = threading.RLock()
+        self._load()
+
+    def _load(self) -> None:
+        path = self._storage_path
+        if path is None:
+            return
+        try:
+            raw = path.read_text(encoding="utf-8")
+        except FileNotFoundError:
+            return
+        except (OSError, UnicodeError) as exc:
+            logger.warning("[WebUI] 读取会话文件失败: %s", exc)
+            return
+        try:
+            payload = json.loads(raw)
+        except (ValueError, TypeError):
+            logger.warning("[WebUI] 会话文件损坏，已忽略: %s", path)
+            return
+        if not isinstance(payload, dict):
+            return
+        stored_fingerprint = payload.get("password_fingerprint")
+        if (
+            self._password_fingerprint is not None
+            and stored_fingerprint != self._password_fingerprint
+        ):
+            # 密码已变更（例如直接编辑 config.toml 后重启），旧令牌必须失效。
+            logger.info("[WebUI] 管理密码已变更，清除旧登录会话")
+            # 立即用新指纹覆盖磁盘，避免密码回滚后旧会话重新生效。
+            self._persist()
+            return
+        raw_sessions = payload.get("sessions")
+        if not isinstance(raw_sessions, dict):
+            return
+        now = time.time()
+        for token, value in raw_sessions.items():
+            if not isinstance(token, str) or not token or not isinstance(value, dict):
+                continue
+            try:
+                expires_at = float(value.get("expires_at") or 0)
+            except (TypeError, ValueError):
+                continue
+            kind = str(value.get("kind") or "session")
+            if kind not in {"session", "access", "refresh"} or expires_at <= now:
+                continue
+            self._sessions[token] = SessionEntry(expires_at=expires_at, kind=kind)
+
+    def _payload(self) -> dict[str, object]:
+        now = time.time()
+        return {
+            "version": SESSION_FILE_VERSION,
+            "password_fingerprint": self._password_fingerprint,
+            "sessions": {
+                token: {"expires_at": entry.expires_at, "kind": entry.kind}
+                for token, entry in self._sessions.items()
+                if entry.expires_at > now
+            },
+        }
+
+    def _persist_strict(self) -> None:
+        """写盘失败时向上抛出，供登出/刷新等需要强一致性的路径回滚。"""
+        path = self._storage_path
+        if path is None:
+            return
+        write_json_sync(path, self._payload(), use_lock=False)
+
+    def _prune_expired(self) -> None:
+        now = time.time()
+        for token in [
+            token for token, entry in self._sessions.items() if entry.expires_at <= now
+        ]:
+            self._sessions.pop(token, None)
+
+    def _persist(self) -> None:
+        """登录与校验路径的 best-effort 写盘；磁盘异常只告警。"""
+        try:
+            self._persist_strict()
+        except Exception as exc:  # 磁盘异常不应让登录/校验直接失败
+            logger.warning("[WebUI] 写入会话文件失败: %s", exc)
+            return
+        self._prune_expired()
 
     def create(self, *, ttl_seconds: int | None = None, kind: str = "session") -> str:
         token = secrets.token_urlsafe(32)
         ttl = self._ttl_seconds if ttl_seconds is None else ttl_seconds
-        self._sessions[token] = SessionEntry(expires_at=time.time() + ttl, kind=kind)
+        with self._lock:
+            self._sessions[token] = SessionEntry(
+                expires_at=time.time() + ttl, kind=kind
+            )
+            self._persist()
         return token
 
     def _resolve_entry(self, token: str | None) -> SessionEntry | None:
         if not token:
             return None
-        entry = self._sessions.get(token)
-        if entry is None:
-            return None
-        if entry.expires_at < time.time():
-            self._sessions.pop(token, None)
-            return None
-        return entry
+        with self._lock:
+            entry = self._sessions.get(token)
+            if entry is None:
+                return None
+            now = time.time()
+            if entry.expires_at < now:
+                self._sessions.pop(token, None)
+                self._persist()
+                return None
+            # 活跃会话滑动续期：剩余不足一半时重新计时，长期使用不会掉线。
+            if entry.kind == "session":
+                ttl = self._ttl_seconds
+                if ttl > 0 and entry.expires_at - now < ttl / 2:
+                    entry.expires_at = now + ttl
+                    self._persist()
+            return entry
 
     def is_valid(
         self,
@@ -86,38 +206,96 @@ class SessionStore:
         entry = self._resolve_entry(token)
         return None if entry is None else entry.kind
 
-    def issue_auth_tokens(self) -> dict[str, int | str]:
-        access_token = self.create(
-            ttl_seconds=self._access_ttl_seconds,
-            kind="access",
+    def _issue_auth_tokens_locked(self) -> dict[str, int | str]:
+        now = time.time()
+        access_token = secrets.token_urlsafe(32)
+        refresh_token = secrets.token_urlsafe(32)
+        self._sessions[access_token] = SessionEntry(
+            expires_at=now + self._access_ttl_seconds, kind="access"
         )
-        refresh_token = self.create(
-            ttl_seconds=self._refresh_ttl_seconds,
-            kind="refresh",
+        self._sessions[refresh_token] = SessionEntry(
+            expires_at=now + self._refresh_ttl_seconds, kind="refresh"
         )
         return {
             "access_token": access_token,
             "refresh_token": refresh_token,
             "expires_in": self._access_ttl_seconds,
             "refresh_expires_in": self._refresh_ttl_seconds,
-            "access_token_expires_at": self.get_expiry_ms(access_token),
+            "access_token_expires_at": int((now + self._access_ttl_seconds) * 1000),
         }
 
+    def issue_auth_tokens(self) -> dict[str, int | str]:
+        with self._lock:
+            tokens = self._issue_auth_tokens_locked()
+            self._persist()
+            return tokens
+
     def refresh_auth_tokens(
         self, refresh_token: str | None
     ) -> dict[str, int | str] | None:
-        if not self.is_valid(refresh_token, allowed_kinds={"refresh"}):
+        if not refresh_token:
             return None
-        self.revoke(refresh_token)
-        return self.issue_auth_tokens()
+        with self._lock:
+            entry = self._sessions.get(refresh_token)
+            if entry is None or entry.kind != "refresh":
+                return None
+            if entry.expires_at < time.time():
+                self._sessions.pop(refresh_token, None)
+                try:
+                    self._persist_strict()
+                except Exception:
+                    self._sessions[refresh_token] = entry
+                    raise
+                return None
+            # 旧 refresh token 立即作废并轮换，避免重放。
+            previous = dict(self._sessions)
+            self._sessions.pop(refresh_token, None)
+            tokens = self._issue_auth_tokens_locked()
+            try:
+                self._persist_strict()
+            except Exception:
+                self._sessions = previous
+                raise
+            return tokens
 
     def revoke(self, token: str | None) -> None:
         if not token:
             return
-        self._sessions.pop(token, None)
+        with self._lock:
+            entry = self._sessions.pop(token, None)
+            if entry is None:
+                return
+            try:
+                self._persist_strict()
+            except Exception:
+                self._sessions[token] = entry
+                raise
+
+    def set_password(self, password: str | None) -> None:
+        """密码变更后作废全部旧会话，并更新会话文件中的密码指纹。
+
+        写盘失败时内存中的旧会话保持作废（fail closed），但密码指纹回滚，
+        异常抛给调用方；后续密码重载会重新尝试持久化新指纹。
+        """
+        with self._lock:
+            previous_fingerprint = self._password_fingerprint
+            self._password_fingerprint = _password_fingerprint(password)
+            self._sessions.clear()
+            try:
+                self._persist_strict()
+            except Exception:
+                self._password_fingerprint = previous_fingerprint
+                raise
 
     def clear(self) -> None:
-        self._sessions.clear()
+        with self._lock:
+            previous = dict(self._sessions)
+            self._sessions.clear()
+            try:
+                self._persist_strict()
+            except Exception:
+                self._sessions = previous
+                raise
 
 
 class BotProcessController:

{undefined_bot-3.18.9 → undefined_bot-3.19.0}/src/Undefined/webui/routes/_auth.py

@@ -1,4 +1,5 @@
 import asyncio
+import logging
 import tomllib
 
 from aiohttp import web
@@ -7,13 +8,13 @@ from aiohttp.web_response import Response
 from Undefined.config.loader import CONFIG_PATH, DEFAULT_WEBUI_PASSWORD
 from Undefined.config import WebUISettings, get_config_manager
 from Undefined.utils import io as async_io
+from ..core import REFRESH_TOKEN_TTL_SECONDS, SESSION_TTL_SECONDS
 from ..utils.config_io import config_write_lock
 from ._shared import (
     auth_capabilities,
     routes,
     SESSION_COOKIE,
     TOKEN_COOKIE,
-    SESSION_TTL_SECONDS,
     SETTINGS_APP_KEY,
     get_bearer_token,
     get_refresh_token,
@@ -29,6 +30,8 @@ from ._shared import (
 )
 from ..utils import read_config_source, apply_patch, load_comment_map, render_toml
 
+logger = logging.getLogger(__name__)
+
 
 def _build_session_payload(
     request: web.Request, authenticated: bool
@@ -120,7 +123,7 @@ async def login_handler(request: web.Request) -> Response:
             str(auth_tokens["refresh_token"]),
             httponly=True,
             samesite="Lax",
-            max_age=SESSION_TTL_SECONDS,
+            max_age=REFRESH_TOKEN_TTL_SECONDS,
         )
         return resp
 
@@ -154,7 +157,13 @@ async def refresh_handler(request: web.Request) -> Response:
     except Exception:
         data = {}
     refresh_token = get_refresh_token(request, data)
-    tokens = get_session_store(request).refresh_auth_tokens(refresh_token)
+    try:
+        tokens = get_session_store(request).refresh_auth_tokens(refresh_token)
+    except OSError as exc:
+        logger.warning("[WebUI] 刷新令牌时写入会话文件失败: %s", exc)
+        return web.json_response(
+            {"success": False, "error": "Failed to persist session"}, status=500
+        )
     if tokens is None:
         return web.json_response(
             {"success": False, "error": "Unauthorized"}, status=401
@@ -172,7 +181,7 @@ async def refresh_handler(request: web.Request) -> Response:
         str(tokens["refresh_token"]),
         httponly=True,
         samesite="Lax",
-        max_age=SESSION_TTL_SECONDS,
+        max_age=REFRESH_TOKEN_TTL_SECONDS,
     )
     return resp
 
@@ -185,6 +194,7 @@ async def logout_handler(request: web.Request) -> Response:
     except Exception:
         data = {}
     sessions = get_session_store(request)
+    failed = False
     for token in {
         get_valid_auth_token(request),
         request.cookies.get(SESSION_COOKIE),
@@ -192,7 +202,15 @@ async def logout_handler(request: web.Request) -> Response:
         get_refresh_token(request, data),
         get_bearer_token(request),
     }:
-        sessions.revoke(token)
+        try:
+            sessions.revoke(token)
+        except OSError as exc:
+            failed = True
+            logger.warning("[WebUI] 登出时写入会话文件失败: %s", exc)
+    if failed:
+        return web.json_response(
+            {"success": False, "error": "Failed to persist session"}, status=500
+        )
     resp = web.json_response({"success": True})
     resp.del_cookie(SESSION_COOKIE)
     resp.del_cookie(TOKEN_COOKIE)
@@ -264,10 +282,11 @@ async def password_handler(request: web.Request) -> Response:
         await asyncio.to_thread(write_password)
         manager = get_config_manager()
         manager.reload()
+        # 先完成会话失效持久化，再启用新密码；失败时由 500 分支返回。
+        get_session_store(request).set_password(new_password)
         request.app[SETTINGS_APP_KEY] = WebUISettings.from_config(
             manager.load(strict=False), config_exists=True
         )
-        get_session_store(request).clear()
 
     try:
         await async_io.run_cancellation_safe(password_and_reload())
@@ -275,6 +294,12 @@ async def password_handler(request: web.Request) -> Response:
         return web.json_response(
             {"success": False, "error": f"TOML parse error: {exc}"}, status=400
         )
+    except OSError as exc:
+        logger.warning("[WebUI] 更新密码后写入持久化状态失败: %s", exc)
+        return web.json_response(
+            {"success": False, "error": "Failed to persist password change"},
+            status=500,
+        )
 
     resp = web.json_response({"success": True, "message": "Password updated"})
     resp.del_cookie(SESSION_COOKIE)

{undefined_bot-3.18.9 → undefined_bot-3.19.0}/src/Undefined/webui/routes/_shared.py

@@ -27,7 +27,6 @@ _PENDING_BOT_AUTOSTART_MARKER = Path("data/cache/pending_bot_autostart")
 
 SESSION_COOKIE = "undefined_webui"
 TOKEN_COOKIE = "undefined_webui_token"
-SESSION_TTL_SECONDS = 8 * 60 * 60
 LOGIN_ATTEMPT_LIMIT = 5
 LOGIN_ATTEMPT_WINDOW = 5 * 60
 LOGIN_BLOCK_SECONDS = 15 * 60