fix(aibox): round-5 audit batch K - max_turns clamp, task input validation, XSS hardening, atomic writes, broadcast timeout

第五轮审计（J1~J16）全量修复 + 子代理 max_turns 钳制： - 子代理 max_turns 钳制（0/None 回退默认 10，负数钳制 1）+ 14 项回归测试 - J1 任务系统投毒：add_memo 入库校验（时间/间隔/类型）、调度器预检与触发事务防御、展示路径兜底、register 移入 try、add_user_task 补 repeat_end_time 透传 - J2/J13 前端 XSS：三页面 marked 输出经 DOMPurify 净化、entry1 系统消息/任务分隔条改 textContent、CDN 脚本补 SRI - J3 FTS 删除换序（先 fts 后内容表，索引不再残留） - J5 原子写推广：新增 common/atomic.py（mkstemp+fsync+os.replace），config/prompt/ history 全部接入；损坏配置备份后回退 - J6 单例初始化加锁（PromptManager/ConfigManager 并发首例不双重加载） - J7 broadcast 并发发送 + wait_for 超时回收僵死连接 - J4/J8/J9~J12/J14~J16：验证异常脱敏、交互输入容错、MemoDatabase WAL+busy_timeout、 memo 批量删除、/new 竞态、skills 引号转义、voice_client 清理、死代码移除、 skill_manager 同名键/help 截断
2026-08-19 07:01:13 +08:00
1 parent f4fcf175ec
commit 457bb900fb
@@ -22,6 +22,7 @@ from pathlib import Path
 from typing import TYPE_CHECKING, Dict, List, Optional

 from common import ConfigManager, Logger, constants
+from common.atomic import atomic_write_text

 if TYPE_CHECKING:
    # 仅用于类型注解，避免运行时循环导入；MemoryDatabase 来自同包 subsystems.db
@@ -73,11 +74,9 @@ class ConversationHistory:
    def _atomic_write_json(path: Path, data) -> None:
        """原子写 JSON（I 批，审计 2026-08-18）：先写同目录临时文件再
        os.replace——此前 'w' 直写，进程中断/崩溃留半截 JSON（current 损坏
-        后仅静默置 None，历史内容丢失）"""
-        tmp = path.with_suffix(path.suffix + ".tmp")
-        with open(tmp, 'w', encoding='utf-8') as f:
-            json.dump(data, f, ensure_ascii=False, indent=2)
-        os.replace(tmp, path)
+        后仅静默置 None，历史内容丢失）。J5（2026-08-19）：委托 common.atomic
+        （mkstemp 随机名），修复旧实现固定 .tmp 名在多进程并发写同路径互踩。"""
+        atomic_write_text(str(path), json.dumps(data, ensure_ascii=False, indent=2))

    def _save_history_index(self):
        """保存历史索引"""
@@ -141,11 +141,14 @@ class MemoryDatabase:
        """删除记忆"""
        with sqlite3.connect(self.db_path) as conn:
            cursor = conn.cursor()
+            # J3（审计 2026-08-19）：必须先删 fts 再删内容表——外部内容表
+            # （content=memories）删除索引条目需从内容表回读旧值，内容行
+            # 先删会导致索引条目永久残留（MATCH 仍可命中已删 rowid）
+            cursor.execute('DELETE FROM memories_fts WHERE rowid = ?', (memory_id,))
            cursor.execute('DELETE FROM memories WHERE id = ?', (memory_id,))
            deleted = cursor.rowcount > 0

            if deleted:
-                cursor.execute('DELETE FROM memories_fts WHERE rowid = ?', (memory_id,))
                conn.commit()
                self.logger.info(f"已删除记忆 ID: {memory_id}")

@@ -274,11 +277,12 @@ class MemoryDatabase:
        with sqlite3.connect(self.db_path) as conn:
            cursor = conn.cursor()
            placeholders = ','.join(['?'] * len(memory_ids))
+            # J3：同 delete_memory——先删 fts 再删内容表，防索引条目残留
+            cursor.execute(f'DELETE FROM memories_fts WHERE rowid IN ({placeholders})', memory_ids)
            cursor.execute(f'DELETE FROM memories WHERE id IN ({placeholders})', memory_ids)
            deleted_count = cursor.rowcount

            if deleted_count > 0:
-                cursor.execute(f'DELETE FROM memories_fts WHERE rowid IN ({placeholders})', memory_ids)
                conn.commit()
                self.logger.info(f"已批量删除 {deleted_count} 条记忆")

@@ -300,10 +304,19 @@ class MemoDatabase:
        self.logger = Logger("MemoDB")
        self._init_database()

+    def _connect(self) -> sqlite3.Connection:
+        """统一连接工厂（J9，审计 2026-08-19）：busy_timeout 覆盖全部写路径，
+        不再只有 mark_as_triggered 一条路径等待锁释放"""
+        conn = sqlite3.connect(self.db_path)
+        conn.execute("PRAGMA busy_timeout = 10000")
+        return conn
+
    def _init_database(self):
        """初始化备忘录表"""
-        with sqlite3.connect(self.db_path) as conn:
+        with self._connect() as conn:
            cursor = conn.cursor()
+            # J9：WAL 显式设置——与 MemoryDatabase 同库文件时不再依赖创建顺序
+            cursor.execute("PRAGMA journal_mode=WAL")

            cursor.execute('''
                CREATE TABLE IF NOT EXISTS memos (
@@ -349,10 +362,34 @@ class MemoDatabase:
                 repeat_interval_unit: str = 'days', repeat_end_time: str = None,
                 is_immediate: bool = False) -> int:
        """添加任务 - 所有任务都是对话任务，不再需要metadata和任务类型"""
+        # J1（审计 2026-08-19）：入库校验——畸形时间/数字字段此前原样入库，
+        # 下游无防护解析点引发调度器失败热循环与新连接握手崩溃（审计报告
+        # §13.1 J1）。CLI/WS/memo 工具三入口均经本方法，校验一处覆盖。
+        if reminder_time:
+            try:
+                datetime.strptime(reminder_time, constants.DATETIME_FORMAT)
+            except (ValueError, TypeError):
+                raise ValueError(
+                    f"提醒时间格式非法: {reminder_time!r}（应为 {constants.DATETIME_FORMAT}）")
+        if repeat_end_time:
+            try:
+                datetime.strptime(repeat_end_time, constants.DATETIME_FORMAT)
+            except (ValueError, TypeError):
+                raise ValueError(
+                    f"重复结束时间格式非法: {repeat_end_time!r}（应为 {constants.DATETIME_FORMAT}）")
+        if repeat_type not in ("none", "daily", "weekly", "monthly", "custom"):
+            raise ValueError(f"无效的重复类型: {repeat_type!r}")
+        try:
+            repeat_interval = int(repeat_interval)
+        except (ValueError, TypeError):
+            raise ValueError(f"重复间隔必须是整数: {repeat_interval!r}")
+        if repeat_type == "custom" and repeat_interval <= 0:
+            raise ValueError("自定义重复需要设置有效的 repeat_interval (>0)")
+
        created_at = datetime.now().strftime(constants.DATETIME_FORMAT)
        tags_str = ",".join(tags) if tags else ""

-        with sqlite3.connect(self.db_path) as conn:
+        with self._connect() as conn:
            cursor = conn.cursor()
            cursor.execute('''
                INSERT INTO memos
@@ -377,7 +414,7 @@ class MemoDatabase:

    def get_memo(self, memo_id: int) -> Optional[Dict]:
        """获取单个任务"""
-        with sqlite3.connect(self.db_path) as conn:
+        with self._connect() as conn:
            conn.row_factory = sqlite3.Row
            cursor = conn.cursor()
            cursor.execute('SELECT * FROM memos WHERE id = ?', (memo_id,))
@@ -392,7 +429,7 @@ class MemoDatabase:

    def get_pending_memos(self, limit: int = None, before_time: str = None, include_immediate: bool = False) -> List[Dict]:
        """获取待执行的任务 - 严格使用当前时间比较"""
-        with sqlite3.connect(self.db_path) as conn:
+        with self._connect() as conn:
            conn.row_factory = sqlite3.Row
            cursor = conn.cursor()

@@ -458,7 +495,7 @@ class MemoDatabase:

    def get_immediate_memos(self, limit: int = None) -> List[Dict]:
        """获取待执行的即时任务"""
-        with sqlite3.connect(self.db_path) as conn:
+        with self._connect() as conn:
            conn.row_factory = sqlite3.Row
            cursor = conn.cursor()

@@ -494,7 +531,7 @@ class MemoDatabase:

    def get_all_memos(self, include_completed: bool = False, limit: int = 50) -> List[Dict]:
        """获取所有任务"""
-        with sqlite3.connect(self.db_path) as conn:
+        with self._connect() as conn:
            conn.row_factory = sqlite3.Row
            cursor = conn.cursor()

@@ -533,13 +570,11 @@ class MemoDatabase:
        now = datetime.now()
        next_reminder = None

-        with sqlite3.connect(self.db_path) as conn:
+        with self._connect() as conn:
            conn.row_factory = sqlite3.Row
            cursor = conn.cursor()
-            # I 批（审计 2026-08-18）：多进程同库（CLI --memo-add + 服务调度）
-            # 写竞争时默认 5s 后直接报 database is locked——busy_timeout 让
-            # SQLite 等待锁释放（最长 10s）而不是立即失败
-            cursor.execute("PRAGMA busy_timeout = 10000")
+            # J9：busy_timeout 已由 _connect() 工厂统一设置（全部写路径一致），
+            # 多进程同库（CLI --memo-add + 服务调度）写竞争等待锁释放而非立即失败
            cursor.execute("BEGIN IMMEDIATE")
            try:
                cursor.execute('SELECT * FROM memos WHERE id = ?', (memo_id,))
@@ -608,7 +643,11 @@ class MemoDatabase:
    def _should_end_repeat(self, memo: Dict, current_time: datetime) -> bool:
        """检查是否应该结束重复"""
        if memo['repeat_end_time']:
-            end_time = datetime.strptime(memo['repeat_end_time'], constants.DATETIME_FORMAT)
+            try:
+                end_time = datetime.strptime(memo['repeat_end_time'], constants.DATETIME_FORMAT)
+            except (ValueError, TypeError):
+                # J1：存量脏数据防御——解析失败视为无结束时间，不打断触发事务
+                return False
            if current_time > end_time:
                return True
        return False
@@ -638,24 +677,37 @@ class MemoDatabase:
                    next_time = current_time.replace(year=current_time.year + 1, month=1, day=1) - timedelta(days=1)
                else:
                    next_time = current_time.replace(month=current_time.month + 1, day=1) - timedelta(days=1)
-        elif memo['repeat_type'] == 'custom' and memo['repeat_interval'] > 0:
-            unit = memo.get('repeat_interval_unit', 'days')
-            if unit == 'minutes':
-                # 每N分钟重复：当前时间 + N分钟
-                next_time = current_time + timedelta(minutes=memo['repeat_interval'])
-            elif unit == 'hours':
-                # 每N小时重复：当前时间 + N小时
-                next_time = current_time + timedelta(hours=memo['repeat_interval'])
-            else:  # days
-                # 每N天重复：当前时间 + N天
-                next_time = current_time + timedelta(days=memo['repeat_interval'])
+        elif memo['repeat_type'] == 'custom':
+            # J1：repeat_interval 类型异常（存量脏数据）按 0 处理，
+            # 不再抛 TypeError 打崩触发事务引发热循环
+            try:
+                repeat_interval = int(memo.get('repeat_interval') or 0)
+            except (ValueError, TypeError):
+                repeat_interval = 0
+            if repeat_interval > 0:
+                unit = memo.get('repeat_interval_unit', 'days')
+                if unit == 'minutes':
+                    # 每N分钟重复：当前时间 + N分钟
+                    next_time = current_time + timedelta(minutes=repeat_interval)
+                elif unit == 'hours':
+                    # 每N小时重复：当前时间 + N小时
+                    next_time = current_time + timedelta(hours=repeat_interval)
+                else:  # days
+                    # 每N天重复：当前时间 + N天
+                    next_time = current_time + timedelta(days=repeat_interval)
+            else:
+                return None
        else:
            return None

        # 检查是否超过重复结束时间
        if memo['repeat_end_time']:
-            end_time = datetime.strptime(memo['repeat_end_time'], constants.DATETIME_FORMAT)
-            if next_time > end_time:
+            try:
+                end_time = datetime.strptime(memo['repeat_end_time'], constants.DATETIME_FORMAT)
+            except (ValueError, TypeError):
+                # J1：存量脏数据防御——解析失败视为无结束时间
+                end_time = None
+            if end_time and next_time > end_time:
                return None

        return next_time
@@ -672,7 +724,7 @@ class MemoDatabase:

        completed_at = datetime.now().strftime(constants.DATETIME_FORMAT)

-        with sqlite3.connect(self.db_path) as conn:
+        with self._connect() as conn:
            cursor = conn.cursor()
            cursor.execute('''
                UPDATE memos
@@ -691,7 +743,7 @@ class MemoDatabase:
    def delete_memo(self, memo_id: int) -> bool:
        """物理删除任务（M5：delete 语义此前被 complete_memo 顶替——只标记
        完成不删行，重复任务还会被推进而非移除，stats 计数失真）"""
-        with sqlite3.connect(self.db_path) as conn:
+        with self._connect() as conn:
            cursor = conn.cursor()
            cursor.execute("DELETE FROM memos WHERE id = ?", (memo_id,))
            conn.commit()
@@ -699,7 +751,7 @@ class MemoDatabase:

    def get_memo_stats(self) -> Dict:
        """获取任务统计信息"""
-        with sqlite3.connect(self.db_path) as conn:
+        with self._connect() as conn:
            cursor = conn.cursor()

            cursor.execute('SELECT COUNT(*) FROM memos')
@@ -732,8 +784,9 @@ class MemoDatabase:
            }

    def add_user_task(self, title: str, content: str = None, reminder_time: str = None,
-                     repeat_type: str = 'none', repeat_interval: int = 0,
-                     repeat_interval_unit: str = 'days', is_immediate: bool = False) -> int:
+                      repeat_type: str = 'none', repeat_interval: int = 0,
+                      repeat_interval_unit: str = 'days', repeat_end_time: str = None,
+                      is_immediate: bool = False) -> int:
        """添加用户任务（前端直接调用的任务）- 所有任务都是对话任务"""
        if not constants.MEMO_ALLOW_USER_TASKS:
            raise Exception("用户任务功能已禁用")
@@ -745,11 +798,23 @@ class MemoDatabase:
            repeat_type=repeat_type,
            repeat_interval=repeat_interval,
            repeat_interval_unit=repeat_interval_unit,
+            repeat_end_time=repeat_end_time,
            created_by="user",
            source="websocket",
            is_immediate=is_immediate
        )

+    @staticmethod
+    def _is_overdue_time(reminder_time: str, now: datetime) -> bool:
+        """J1：展示路径时间解析防御——格式异常按到期处理（对齐 Q5 语义），
+        不再抛 ValueError 打崩新连接握手流程"""
+        if not reminder_time:
+            return False
+        try:
+            return datetime.strptime(reminder_time, constants.DATETIME_FORMAT) < now
+        except (ValueError, TypeError):
+            return True
+
    def get_pending_tasks_for_user(self) -> List[Dict]:
        """获取待执行任务列表（用于前端显示）"""
        pending = self.get_pending_memos(include_immediate=False)
@@ -764,7 +829,7 @@ class MemoDatabase:
                "content": memo['content'],
                "reminder_time": memo['reminder_time'],
                "priority": memo['priority'],
-                "is_overdue": datetime.strptime(memo['reminder_time'], constants.DATETIME_FORMAT) < now if memo['reminder_time'] else False,
+                "is_overdue": self._is_overdue_time(memo['reminder_time'], now),
                "repeat_type": memo['repeat_type'],
                "repeat_interval": memo.get('repeat_interval', 0),
                "repeat_interval_unit": memo.get('repeat_interval_unit', 'days'),
@@ -144,6 +144,8 @@ class SubprocessCommandExecutor(CommandExecutor):
        shell_dead_since = None  # shell 进程已死但 reader 未收到 EOF 的起始时刻
        while True:
            # 检查超时（readline 阻塞不再影响本判断）
+            # J16（审计 2026-08-19）：timeout<=0 语义为"不设超时"（有意为之，
+            # 调用方显式传 0 禁用）；registry 层 3600s 流式兜底仍生效
            if timeout > 0 and time.time() - start_time > timeout:
                self._terminate_tree(process)
                timeout_occurred = True
@@ -23,6 +23,7 @@ from datetime import datetime
 from typing import Dict, List, Optional

 from common import ConfigManager
+from common.atomic import atomic_write_text


 class PromptManager:
@@ -60,8 +61,12 @@ class PromptManager:
        return cls._instance

    def __init__(self):
-        if not self._prompts:
-            self._load_prompts()
+        # J6（审计 2026-08-19）：__new__ 的锁只防双实例，多线程首例并发
+        # 同时进入 __init__ 会使 _load_prompts 双重执行，_prompts（类属性）
+        # 整份翻倍——初始化检查与加载收进同一把锁
+        with self._instance_lock:
+            if not self._prompts:
+                self._load_prompts()

    def _get_prompts_dir(self) -> str:
        config = ConfigManager()
@@ -172,8 +177,8 @@ class PromptManager:
 【更新记录】
 - 上次更新：{timestamp}
 """
-            with open(identity_path, 'w', encoding='utf-8') as f:
-                f.write(updated_content)
+            # J5：原子写，崩溃不留半截提示词文件
+            atomic_write_text(identity_path, updated_content)
            self.reload()
            return True
        except Exception as e:
@@ -195,8 +200,8 @@ class PromptManager:
 【更新记录】
 - 上次更新：{timestamp}
 """
-            with open(status_path, 'w', encoding='utf-8') as f:
-                f.write(updated_content)
+            # J5：原子写，崩溃不留半截提示词文件
+            atomic_write_text(status_path, updated_content)
            self.reload()
            return True
        except Exception as e:
@@ -218,8 +223,8 @@ class PromptManager:
 【更新记录】
 - 上次更新：{timestamp}
 """
-            with open(soul_path, 'w', encoding='utf-8') as f:
-                f.write(updated_content)
+            # J5：原子写，崩溃不留半截提示词文件
+            atomic_write_text(soul_path, updated_content)
            self.reload()
            return True
        except Exception as e:
@@ -27,6 +27,9 @@ class SkillManager:
    2. Markdown 文件 (.md)：第一行为简介（# 标题或普通文本），其余为技能内容
    """

+    # J16（审计 2026-08-19）：--help 输出上限——内容会进系统提示词
+    MAX_HELP_LENGTH = 2000
+
    def __init__(self, logger: Optional[Logger] = None):
        self.logger = logger or Logger("SkillManager")
        # name -> {path, file, summary, content, is_markdown}
@@ -38,7 +41,11 @@ class SkillManager:
    # ------------------------------------------------------------------

    def _run_help(self, skill_path: str) -> str:
-        """执行 skill_path --help 并返回完整输出（stdout 优先，否则 stderr）。"""
+        """执行 skill_path --help 并返回完整输出（stdout 优先，否则 stderr）。
+
+        J16（审计 2026-08-19）：输出截断到 MAX_HELP_LENGTH——技能 --help
+        输出会进系统提示词，异常/恶意脚本可撑爆上下文。
+        """
        try:
            result = subprocess.run(
                [skill_path, "--help"],
@@ -50,6 +57,8 @@ class SkillManager:
            output = result.stdout.strip()
            if not output:
                output = result.stderr.strip()
+            if len(output) > self.MAX_HELP_LENGTH:
+                output = output[:self.MAX_HELP_LENGTH] + "\n…（已截断）"
            return output
        except Exception as e:
            self.logger.warning(f"运行 {skill_path} --help 失败: {e}")
@@ -129,12 +138,26 @@ class SkillManager:
            and not f.startswith('.')
        ]

-        for skill_file in skill_files:
+        # J16（审计 2026-08-19）：同名键冲突（foo 可执行文件与 foo.md）此前
+        # 由 listdir 顺序决定谁覆盖谁，行为不确定。改为可执行优先 + 确定性：
+        # 先加载可执行技能，Markdown 遇到已占用的同名键时跳过并告警
+        executable_files = [
+            f for f in skill_files
+            if not self._is_markdown_file(f)
+        ]
+        markdown_files = [f for f in skill_files if self._is_markdown_file(f)]
+
+        for skill_file in executable_files + markdown_files:
            skill_path = os.path.join(skills_dir, skill_file)
            skill_name = os.path.splitext(skill_file)[0]
            is_markdown = self._is_markdown_file(skill_file)

            if is_markdown:
+                if skill_name in self.skills:
+                    self.logger.warning(
+                        f"Markdown 技能 '{skill_file}' 与同名可执行技能冲突，已跳过"
+                        f"（可执行技能优先）")
+                    continue
                # Markdown 格式技能：直接读取内容
                summary, content = self._read_markdown_skill(skill_path)
                if content: