feat: 敏感词管理页面(脱敏词后台化,限 lqq 账号)

- 后端 /api/sensitive-words:全局共享词表,开放读、admin 或 lqq 整体替换写
- 前端 desensitize 种子化:SEED_DESENSITIZE_MAP + 运行时 replaceDesensitizeMap
- 启动加载后台配置回灌脱敏映射;管理页支持增删改启停 + 一键导入种子词
- 入口置于左下角设置下拉(全量/简洁两种侧边栏均有),仅用户名 lqq 可见

Co-Authored-By: Claude Opus 4.8 (1M context) <noreply@anthropic.com>
This commit is contained in:
董宏凯andClaude Opus 4.8 committed 2026-06-17 18:05:07 +08:00
1 parent 39d7dab3e2
commit 25e4e3dbc9
18 files changed
+788 -5

No files matched your search

@@ -55,6 +55,7 @@ from deerflow.persistence.roundtable_drafts.model import (
)
from deerflow.persistence.roundtable_jobs.model import RoundtableJobRow
from deerflow.persistence.run.model import RunRow
from deerflow.persistence.sensitive_words.model import SensitiveWordRow
from deerflow.persistence.scheduled_tasks.model import (
ScheduledTaskDeliveryProfileRow,
ScheduledTaskRow,
@@ -112,6 +113,7 @@ __all__ = [
"ScheduledTaskRunRow",
"ScheduledTaskSubscriptionRow",
"SchedulerThreadRow",
"SensitiveWordRow",
"SkillRow",
"SkillDisplayAdapterRow",
"SkillFavoriteRow",
@@ -0,0 +1,22 @@
"""Sensitive-word (脱敏词 / 敏感词管理) persistence."""
from __future__ import annotations
from deerflow.persistence.sensitive_words.base import SensitiveWordStore
from deerflow.persistence.sensitive_words.memory import MemorySensitiveWordStore
from deerflow.persistence.sensitive_words.model import SensitiveWordRow
from deerflow.persistence.sensitive_words.sql import SensitiveWordRepository
__all__ = [
"MemorySensitiveWordStore",
"SensitiveWordRepository",
"SensitiveWordRow",
"SensitiveWordStore",
"make_sensitive_word_store",
]
def make_sensitive_word_store(session_factory):
if session_factory is None:
return MemorySensitiveWordStore()
return SensitiveWordRepository(session_factory)
@@ -0,0 +1,33 @@
"""Abstract sensitive-word (脱敏词) persistence API.
Global / shared store: no ``user_id`` scoping; every account desensitizes with
the same word map. Reads are open to any caller (the frontend needs the map to
render desensitized text); the router gates writes behind admin. ``updated_by``
is audit-only.
The whole word map is treated as one document: the management page computes the
full desired set and replaces every row atomically via :meth:`replace_all`, so
the stored set never drifts out of sync with what the admin sees. This mirrors
the menu-override store.
"""
from __future__ import annotations
from abc import ABC, abstractmethod
from typing import Any
class SensitiveWordStore(ABC):
@abstractmethod
async def list_words(self) -> list[dict[str, Any]]:
"""Return every stored word row, ordered by ``sort_order``."""
raise NotImplementedError
@abstractmethod
async def replace_all(self, rows: list[dict[str, Any]], *, updated_by: str | None = None) -> list[dict[str, Any]]:
"""Atomically replace the entire word set with ``rows``.
Each row is ``{word, replacement, enabled, sort_order}``. Returns the
persisted rows.
"""
raise NotImplementedError
@@ -0,0 +1,36 @@
"""In-memory sensitive-word store (used when no DB is configured / tests)."""
from __future__ import annotations
from datetime import UTC, datetime
from typing import Any
from deerflow.persistence.sensitive_words.base import SensitiveWordStore
def _normalize(data: dict[str, Any], updated_by: str | None) -> dict[str, Any]:
return {
"word": str(data["word"]),
"replacement": str(data.get("replacement") or ""),
"enabled": bool(data.get("enabled", True)),
"sort_order": int(data.get("sort_order", 0)),
"updated_by": updated_by,
"updated_at": datetime.now(UTC).isoformat(),
}
class MemorySensitiveWordStore(SensitiveWordStore):
def __init__(self) -> None:
self._rows: dict[str, dict[str, Any]] = {}
async def list_words(self) -> list[dict[str, Any]]:
return [dict(r) for r in sorted(self._rows.values(), key=lambda r: (r.get("sort_order", 0), r.get("word", "")))]
async def replace_all(self, rows: list[dict[str, Any]], *, updated_by: str | None = None) -> list[dict[str, Any]]:
self._rows = {}
for r in rows:
word = r.get("word")
if word in (None, ""):
continue
self._rows[str(word)] = _normalize(r, updated_by)
return await self.list_words()
@@ -0,0 +1,38 @@
"""ORM model for sensitive words (脱敏词 / 敏感词管理).
Global / shared — there is no ``user_id`` scoping; every account desensitizes
with the same map. The frontend ships a seed map in code (used as the default on
a fresh deployment); once an admin saves here, this table is the source of truth.
Each row maps an original term (``word``, the primary key) to its desensitized
replacement (``replacement``). ``enabled`` lets an admin park a word without
deleting it; ``sort_order`` controls display order in the management page. The
desensitize regex is rebuilt from the **enabled** rows. ``updated_by`` is
audit-only.
``word`` is the primary key at ``String(191)`` so the utf8mb4 index stays within
the 767-byte legacy limit (191 × 4 = 764) — sensitive terms are never that long.
"""
from __future__ import annotations
from datetime import UTC, datetime
from sqlalchemy import Boolean, Integer, String
from sqlalchemy.orm import Mapped, mapped_column
from deerflow.persistence.base import Base
from deerflow.persistence.types import BeijingDateTime
class SensitiveWordRow(Base):
__tablename__ = "sensitive_words"
word: Mapped[str] = mapped_column(String(191), primary_key=True)
replacement: Mapped[str] = mapped_column(String(191), default="")
enabled: Mapped[bool] = mapped_column(Boolean, default=True)
sort_order: Mapped[int] = mapped_column(Integer, default=0)
updated_by: Mapped[str | None] = mapped_column(String(64))
updated_at: Mapped[datetime] = mapped_column(
BeijingDateTime(), default=lambda: datetime.now(UTC), onupdate=lambda: datetime.now(UTC)
)
@@ -0,0 +1,57 @@
"""SQLAlchemy-backed sensitive-word store (global / shared)."""
from __future__ import annotations
from datetime import datetime
from typing import Any
from sqlalchemy import delete, select
from sqlalchemy.ext.asyncio import AsyncSession, async_sessionmaker
from deerflow.persistence.sensitive_words.base import SensitiveWordStore
from deerflow.persistence.sensitive_words.model import SensitiveWordRow
def _to_dict(row: SensitiveWordRow) -> dict[str, Any]:
data = row.to_dict()
value = data.get("updated_at")
if isinstance(value, datetime):
data["updated_at"] = value.isoformat()
return data
def _row_from(data: dict[str, Any], updated_by: str | None) -> SensitiveWordRow:
return SensitiveWordRow(
word=str(data["word"]),
replacement=str(data.get("replacement") or ""),
enabled=bool(data.get("enabled", True)),
sort_order=int(data.get("sort_order", 0)),
updated_by=updated_by,
)
class SensitiveWordRepository(SensitiveWordStore):
def __init__(self, session_factory: async_sessionmaker[AsyncSession]) -> None:
self._sf = session_factory
async def list_words(self) -> list[dict[str, Any]]:
stmt = select(SensitiveWordRow).order_by(SensitiveWordRow.sort_order.asc(), SensitiveWordRow.word.asc())
async with self._sf() as session:
result = await session.execute(stmt)
return [_to_dict(row) for row in result.scalars()]
async def replace_all(self, rows: list[dict[str, Any]], *, updated_by: str | None = None) -> list[dict[str, Any]]:
# De-dupe by word (last wins) so a malformed payload can't violate the PK.
by_word: dict[str, dict[str, Any]] = {}
for r in rows:
word = r.get("word")
if word not in (None, ""):
by_word[str(word)] = r
async with self._sf() as session:
await session.execute(delete(SensitiveWordRow))
new_rows = [_row_from(r, updated_by) for r in by_word.values()]
session.add_all(new_rows)
await session.commit()
for row in new_rows:
await session.refresh(row)
return [_to_dict(row) for row in new_rows]