feat(video-analysis): 群策略 v3 / 群文件投递通道 / Web 管理页

- policy.py：per-group 正交策略（自动解析 / 自动策略 / 禁用策略 / 存储 A·B·C /
  公网 / 链接 / 群文件 + 平台限定），list.json v1/v2 → v3 自动迁移，
  写入统一走 PolicyStore（加锁 + .tmp 原子替换 + 字段归一）
- 群文件并行通道 group_file.py：打包 zip（可选 pyzipper AES-256）后优先走 S3 预签名、
  本地直传兜底；设了密码但 pyzipper 不可用就放弃上传，不退化成明文
- list_proc.py 收敛到「视频策略」统一入口，权限判定改走 policy
- Web 管理页 /hub/video_analysis（群策略 + 链接解析面板）与 services/web_jobs.py
  （只复用纯函数层，Web 上下文不发消息；内存任务表 + 并发闸门 + 超时）
- 媒体命名统一到 utils.py（{作者}_{作者id}/{作品名}[_短码]），cleanup 回收空目录
- 测试：policy / 命名 / 群文件 / web_jobs 四组

顺带 pyproject 的 pytest 加 testpaths=tests（避免收进 debug/ 下的调试脚本）。

Co-Authored-By: Claude Code <noreply@anthropic.com>

hexi/plugins/nonebot_plugin_video_analysis/handlers/douyin.py

@@ -12,6 +12,7 @@ from ..services.fetchers.douyin_api import fetch_douyin_content
 from ..services.fetchers.douyin_ssr import MOBILE_UA, fetch_douyin_note_ssr
 from ..models import DouyinFetchError
 from ..utils import get_data_dir, parse_netscape_cookies
+from ..policy import Policy
 from .sender import PendingMedia, _as_paths
 
 SHORT_LINK_PATTERN = re.compile(r"(v\.douyin\.com/[A-Za-z0-9_\-]+)")
@@ -111,11 +112,13 @@ async def process_douyin_res(
     file_paths: Union[Path, list[Path]],
     is_private: bool,
     image_post: bool,
-    plan: str | None = None,
+    policy: Policy | None = None,
+    platform: str | None = None,
 ) -> tuple[Optional[PendingMedia], Optional[str]]:
     """下载已完成 → 打包为待发送媒体（不上传、不发送、不清理）
 
-    多级发送（temp 本地 → S3 链接 → 回退本地）由 send_pending_media 统一处理。
+    多级发送（temp 本地 → S3 链接 → 回退本地）与群文件上传由
+    send_pending_media 统一按 policy 处理；platform 用于群文件限定平台。
     """
     if not file_paths:
         return None, None
@@ -124,7 +127,8 @@ async def process_douyin_res(
             files=_as_paths(file_paths),
             image_post=image_post,
             is_private=is_private,
-            plan=plan,
+            policy=policy,
+            platform=platform,
             title=title,
         ),
         None,

hexi/plugins/nonebot_plugin_video_analysis/handlers/entry.py

@@ -16,7 +16,8 @@ from ..services.fetchers.rednote_content import fetch_rednote_content
 from .douyin import parse_douyin, process_douyin_res
 from .sender import PendingMedia, send_pending_media
 from .universal import handle_universal
-from ..list_proc import AUTO_LINK_KEYWORDS, get_group_auto_link, verify_user
+from ..list_proc import get_policy, is_group_whitelisted, is_user_blacklisted
+from ..policy import Policy, match_platform
 
 URL_PATTERN = re.compile(r"(https?://\S+)")
 XCX_PATTERN = r"QQ小程序(?:]|]|\])"
@@ -44,106 +45,119 @@ active_video_handler = on_message(priority=10, block=False, rule=to_me())
 
 async def _check_access(
     event: Event, *, auto_only: bool = False, msg: str | None = None
-) -> tuple[bool, str | None]:
+) -> tuple[bool, Policy | None]:
     """统一权限检查。
 
-    auto_only=True  → 自动解析：需白名单 + 开启自动解析，或 auto_link 关键词命中。
-    auto_only=False → 主动触发：需非黑名单，群聊还需白名单。
+    auto_only=True  → 自动解析：需白名单群 + （开启自动解析或消息命中自动策略）。
+    auto_only=False → 主动触发：需白名单群 + 非黑名单用户。
+
+    私聊不做自动解析，读 default 节策略后直接解析。
+    禁用策略（ban_link）是消息级的（按链接判定），见 match_message。
 
     Returns:
-        (allowed, plan) — plan 用于 S3 路由，不允许时为 None
+        (allowed, policy) — policy 决定存储/投递，不允许时为 None
     """
-    white, black, auto, plan = await verify_user(event)
     target = get_target(event)
 
     if target.private:
         if auto_only:
             logger.info("权限分析：自动解析不处理私聊")
             return False, None
-        if black:
+        if is_user_blacklisted(event):
             logger.info(f"权限分析：黑名单用户私聊，不回复: {event.get_user_id()}")
             return False, None
         logger.info("权限分析：私聊，直接解析")
-        return True, None
+        return True, get_policy(event)
 
     group_id = str(event.group_id)
 
-    if not white:
+    if not is_group_whitelisted(event):
         logger.info(f"权限分析：群 {group_id} 不在白名单，不做处理")
         return False, None
 
-    if auto_only and not auto:
-        if msg is not None and await _match_auto_link(event, msg):
-            logger.info(f"权限分析：群 {group_id} 未开启自动解析，但自动链接关键词命中")
-        else:
-            logger.info(f"权限分析：群 {group_id} 未开启自动解析")
-            return False, None
-
-    if not auto_only and black:
+    if is_user_blacklisted(event):
         logger.info(f"权限分析：黑名单用户，不回复: {event.get_user_id()}")
         return False, None
 
+    policy = get_policy(event)
+
+    if auto_only and not policy.auto and not _match_auto_link(msg or "", policy):
+        logger.info(f"权限分析：群 {group_id} 未开启自动解析且未命中自动策略")
+        return False, None
+
     logger.info(
-        f"权限分析：群 {group_id} 权限通过 — "
-        f"自动解析: {auto}, 方案: {plan or '默认(PLANC)'}"
+        f"权限分析：群 {group_id} 权限通过 — 自动解析: {policy.auto}, "
+        f"存储: {policy.plan}, 公网: {policy.upload_public}, "
+        f"群文件: {policy.upload_group_file}"
     )
-    return True, plan
+    return True, policy
 
 
-async def _match_auto_link(event: Event, msg: str) -> bool:
-    """消息中的 URL 是否命中群配置的 auto_link 关键词。"""
-    keywords = await get_group_auto_link(event)
-    if not keywords:
+def _match_auto_link(msg: str, policy: Policy) -> bool:
+    """消息中的 URL 是否命中群策略的自动策略（auto_link）。"""
+    if not policy.auto_link:
         return False
-    urls = URL_PATTERN.findall(msg)
-    if not urls:
-        return False
-    for kw in keywords:
-        domains = AUTO_LINK_KEYWORDS.get(kw, (kw,))
-        if any(any(domain in url for domain in domains) for url in urls):
-            logger.info(f"自动链接：关键词 {kw} 命中消息 {urls}")
+    for url in URL_PATTERN.findall(msg):
+        platform = policy.auto_matched(url)
+        if platform:
+            logger.info(f"自动策略：{platform} 命中消息 {url}")
             return True
     return False
 
 
+def _skip_banned(url: str, policy: Policy) -> bool:
+    """链接是否命中禁用策略（命中即静默丢弃，只记日志）。"""
+    platform = policy.banned(url)
+    if platform:
+        logger.info(f"禁用策略：{platform} 已禁用，忽略链接 {url}")
+        return True
+    return False
+
+
 @auto_video_handler.handle()
 async def handle_auto_video(event: Event):
     msg = str(event.get_message()).strip()
-    allowed, plan = await _check_access(event, auto_only=True, msg=msg)
-    if allowed:
-        await match_message(event, plan=plan)
+    allowed, policy = await _check_access(event, auto_only=True, msg=msg)
+    if allowed and policy is not None:
+        await match_message(event, policy)
 
 
 @active_video_handler.handle()
 async def handle_active_video(event: Event):
-    allowed, plan = await _check_access(event, auto_only=False)
-    if allowed:
-        await match_message(event, plan=plan)
+    allowed, policy = await _check_access(event, auto_only=False)
+    if allowed and policy is not None:
+        await match_message(event, policy)
 
 
-async def match_message(event: Event, plan: str | None = None):
-    """消息匹配与分派：文本链接 / QQ小程序卡片统一走 dispatch_url。"""
+async def match_message(event: Event, policy: Policy):
+    """消息匹配与分派：文本链接 / QQ小程序卡片统一走 dispatch_url。
+
+    命中禁用策略的链接在这里丢弃；消息里还有其它可用链接则继续解析。
+    """
     msg = str(event.get_message()).strip()
     logger.info(f"消息解析：获取到的消息：{msg}")
     is_private = get_target(event).private
 
     message = None
     public_url = None
+    url = ""
 
     if re.search(XCX_PATTERN, msg) or "CQ:json" in msg or "CQ:share" in msg:
         logger.info("消息解析：检测到 CQ 卡片")
-        url = await _extract_xcx_url(msg)
+        url = await _extract_xcx_url(msg) or ""
         logger.info(f"消息解析：卡片链接：{url}")
         if not url or not any(domain in url for domain in VALID_HOSTS):
             return
-        message, public_url = await dispatch_url(url, is_private, plan=plan)
+        if _skip_banned(url, policy):
+            return
+        message, public_url = await dispatch_url(url, is_private, policy)
         if not message:
             return
     else:
-        urls = URL_PATTERN.findall(msg)
+        urls = [u for u in URL_PATTERN.findall(msg) if not _skip_banned(u, policy)]
         for url in urls:
             logger.info(f"消息解析：作品链接：{url}")
-            message, public_url = await dispatch_url(url, is_private, plan=plan)
+            message, public_url = await dispatch_url(url, is_private, policy)
             if message:
                 break
         if not message:
@@ -151,12 +165,12 @@ async def match_message(event: Event, plan: str | None = None):
 
     if isinstance(message, PendingMedia):
         ok, pub = await send_pending_media(message, event)
-        if pub:
+        if pub and policy.sends_link:
             await UniMessage.text(f"{pub}").send()
         if not ok:
             await UniMessage.text(f"媒体发送失败：{url}").send()
     else:
-        if public_url:
+        if public_url and policy.sends_link:
             await UniMessage.text(f"{public_url}").send()
         await message.send()
 
@@ -164,7 +178,7 @@ async def match_message(event: Event, plan: str | None = None):
 async def dispatch_url(
     url: str,
     is_private: bool,
-    plan: str | None = None,
+    policy: Policy,
 ) -> tuple[UniMessage | None, str | None]:
     """按平台分派解析（文本链接与小程序卡片共用）。"""
     url = url.rstrip("，。！？、；：）】》\"'）")
@@ -175,6 +189,9 @@ async def dispatch_url(
             logger.info(f"b23 短链重定向: {url} -> {resolved}")
             url = resolved
 
+    # 平台标签：短链重定向之后再判定（群文件限定平台用）
+    platform = match_platform(url)
+
     if "douyin.com" in url or "v.douyin.com" in url or "iesdouyin.com" in url:
         await UniMessage.text("检测到链接，正在处理，请稍候...").send()
         try:
@@ -186,7 +203,8 @@ async def dispatch_url(
                 logger.warning(f"媒体解析：未能获取到作品：{url}")
                 return None, None
             return await process_douyin_res(
-                title, parsed_path, is_private, image_post, plan=plan
+                title, parsed_path, is_private, image_post,
+                policy=policy, platform=platform,
             )
         except Exception:
             await UniMessage.text(f"无法解析到媒体：{url}").send()
@@ -213,7 +231,7 @@ async def dispatch_url(
                 return None, None
             return await process_douyin_res(
                 title, parsed_path, is_private,
-                isinstance(parsed_path, list), plan=plan,
+                isinstance(parsed_path, list), policy=policy, platform=platform,
             )
         except Exception:
             await UniMessage.text(f"无法解析到内容：{url}").send()
@@ -232,7 +250,7 @@ async def dispatch_url(
                 return None, None
             return await process_douyin_res(
                 title, parsed_path, is_private,
-                isinstance(parsed_path, list), plan=plan,
+                isinstance(parsed_path, list), policy=policy, platform=platform,
             )
         except Exception:
             await UniMessage.text(f"无法解析到内容：{url}").send()
@@ -242,7 +260,7 @@ async def dispatch_url(
     if any(domain in url for domain in VALID_HOSTS):
         await UniMessage.text("检测到链接，正在处理，请稍候...").send()
         try:
-            return await handle_universal(url, is_private, plan=plan)
+            return await handle_universal(url, is_private, policy, platform)
         except Exception as e:
             logger.exception(e)
             await UniMessage.text("下载过程中出现错误。").send()

hexi/plugins/nonebot_plugin_video_analysis/handlers/sender.py

@@ -10,6 +10,10 @@
 （视频段不能与其他段混合，一条消息也放不下多段视频/图集体验差）
 → 统一走合并转发，一个图/视频一个节点。
 
+群文件（并行通道）: `policy.upload_group_file` 开着时，消息链跑完后额外把文件
+传到群文件（默认打包成一个 zip，可配解压密码，见 config.group_file_settings），
+失败只记日志、不影响发送结果（打包/上传实现在 services/storage/group_file.py）。
+
 temp 下的文件发送成功后也不清理（用户手动处理 data/temp）。
 """
 
@@ -20,7 +24,11 @@ from nonebot import get_bot, get_driver, logger
 from nonebot.adapters import Event
 from nonebot_plugin_alconna import UniMessage
 
+from ..config import group_file_settings
+from ..policy import Policy
+from ..services.storage.group_file import upload_group_files
 from ..services.storage.s3 import upload_with_plan
+from ..utils import media_rel_dir_of
 
 
 @dataclass
@@ -30,7 +38,9 @@ class PendingMedia:
     files: list[Path]
     image_post: bool = False
     is_private: bool = False
-    plan: str | None = None
+    policy: Policy | None = None
+    #: 平台规范标签（见 policy.match_platform），群文件限定平台用
+    platform: str | None = None
     title: str = ""
 
 
@@ -43,8 +53,12 @@ def _as_paths(file_paths: Path | list[Path]) -> list[Path]:
 # ─────────────────────── 合并转发（多媒体专用） ───────────────────────
 
 
+#: 按视频段发送的扩展名（其余按图片发；直链下载可能落 webm/mov 等）
+_VIDEO_SUFFIXES = {".mp4", ".webm", ".mov", ".flv", ".mkv", ".ts"}
+
+
 def _is_video(fp: Path) -> bool:
-    return fp.suffix.lower() == ".mp4"
+    return fp.suffix.lower() in _VIDEO_SUFFIXES
 
 
 def _needs_forward(files: list[Path]) -> bool:
@@ -117,13 +131,7 @@ async def _build_s3_forward_items(
     items: list[tuple[Path, str | None]] = []
     public_url = None
     for fp in media.files:
-        local_url, pub = upload_with_plan(
-            fp,
-            plan=media.plan,
-            is_private=media.is_private,
-            title=media.title,
-            image_post=media.image_post,
-        )
+        local_url, pub = upload_with_plan(fp, policy=media.policy)
         if not local_url:
             raise RuntimeError(f"上传本地 S3 失败: {fp}")
         if pub:
@@ -136,10 +144,10 @@ async def _build_s3_forward_items(
 
 
 def _build_local_msg(files: list[Path], image_post: bool) -> UniMessage:
-    """本地文件版消息（mp4 → 视频，其余 → 图片）"""
+    """本地文件版消息（视频扩展名 → 视频段，其余 → 图片段）"""
     msg = UniMessage()
     for fp in files:
-        if fp.suffix.lower() == ".mp4":
+        if _is_video(fp):
             msg.video(path=fp)
         else:
             msg.image(path=fp)
@@ -153,28 +161,22 @@ def _build_s3_msg(
     msg = UniMessage()
     public_url = None
     for fp in media.files:
-        local_url, pub = upload_with_plan(
-            fp,
-            plan=media.plan,
-            is_private=media.is_private,
-            title=media.title,
-            image_post=media.image_post,
-        )
+        local_url, pub = upload_with_plan(fp, policy=media.policy)
         if not local_url:
             raise RuntimeError(f"上传本地 S3 失败: {fp}")
         if pub:
             public_url = pub
-        if fp.suffix.lower() == ".mp4":
+        if _is_video(fp):
             msg.video(url=local_url)
         else:
             msg.image(url=local_url)
     return msg, public_url
 
 
-async def send_pending_media(
+async def _send_media_core(
     media: PendingMedia, event: Event | None = None
 ) -> tuple[bool, str | None]:
-    """多级发送，返回 (是否成功, public_url)
+    """多级发送主体，返回 (是否成功, public_url)
 
     public_url 仅在走 S3 链接发送成功时返回（调用方决定是否发文字）。
     temp 文件发送成功后保留（用户手动清理 data/temp）。
@@ -236,3 +238,47 @@ async def send_pending_media(
     except Exception as e:
         logger.exception(f"回退发送失败: {e}")
         return False, None
+
+
+async def _upload_group_files(media: PendingMedia, event: Event | None) -> None:
+    """群文件并行通道：消息链跑完后按策略额外传一份（失败只记日志）。
+
+    是否打包成 zip / 是否加密由全局配置决定（config.group_file_settings）；
+    平台清单（policy.group_file_platforms）非空时只传清单里的平台，其余平台
+    照常走消息、不传群文件。
+    """
+    policy = media.policy
+    if policy is None or event is None:
+        return
+    if not policy.allows_group_file(media.platform):
+        if policy.upload_group_file:
+            logger.info(
+                f"群文件限定平台 {policy.group_file_platforms}，"
+                f"本次为 {media.platform or '未知平台'}，跳过群文件上传"
+            )
+        return
+    group_id = getattr(event, "group_id", None)
+    if group_id is None:
+        return
+    zip_files, password = group_file_settings()
+    await upload_group_files(
+        media.files,
+        int(group_id),
+        title=media.title,
+        zip_files=zip_files,
+        password=password,
+        policy=policy,
+        rel_dir=media_rel_dir_of(media.files[0]),
+    )
+
+
+async def send_pending_media(
+    media: PendingMedia, event: Event | None = None
+) -> tuple[bool, str | None]:
+    """多级发送 + 群文件并行通道，返回 (是否成功, public_url)。"""
+    if not media.files:
+        return False, None
+
+    ok, public_url = await _send_media_core(media, event)
+    await _upload_group_files(media, event)
+    return ok, public_url

hexi/plugins/nonebot_plugin_video_analysis/handlers/universal.py

@@ -1,11 +1,11 @@
 """通用平台视频解析编排层 — B站 / YouTube / Twitter 等"""
 
-from pathlib import Path
 from typing import Optional
 
 from nonebot import logger
 from nonebot_plugin_alconna import UniMessage
 
+from ..policy import Policy
 from ..services.fetchers.video_downloader import download_video
 from .sender import PendingMedia, _as_paths
 
@@ -13,15 +13,16 @@ from .sender import PendingMedia, _as_paths
 async def handle_universal(
     url: str,
     is_private: bool,
-    plan: str | None = None,
+    policy: Policy | None = None,
+    platform: str | None = None,
 ) -> tuple[Optional[PendingMedia], Optional[str]]:
     """
-    下载通用平台视频 → 打包待发送媒体（上传/发送由 sender 多级处理）
+    下载通用平台视频 → 打包待发送媒体（上传/发送由 sender 按 policy 多级处理）
 
     Returns:
         (PendingMedia, public_url) — None 表示下载失败
     """
-    video_file = await download_video(url)
+    video_file, title = await download_video(url)
     if not video_file:
         await UniMessage.text("视频下载失败。").send()
         return None, None
@@ -33,8 +34,9 @@ async def handle_universal(
             files=_as_paths(video_file),
             image_post=False,
             is_private=is_private,
-            plan=plan,
-            title="title",
+            policy=policy,
+            platform=platform,
+            title=title,
         ),
         None,
     )