vibego 0.2.53__py3-none-any.whl → 0.2.55__py3-none-any.whl

bot.py

@@ -7,7 +7,7 @@
 
 from __future__ import annotations
 
-import asyncio, os, sys, time, uuid, shlex, subprocess, socket, re, json, shutil, hashlib, html
+import asyncio, os, sys, time, uuid, shlex, subprocess, socket, re, json, shutil, hashlib, html, mimetypes
 from datetime import datetime, UTC
 from pathlib import Path
 from typing import Any, Dict, Optional, Sequence, Tuple, List, Callable, Awaitable, Literal
@@ -37,8 +37,6 @@ from aiogram.types import (
     ReplyKeyboardRemove,
     Update,
     User,
-    PhotoSize,
-    Document,
 )
 from aiogram.client.session.aiohttp import AiohttpSession
 from aiogram.enums import ParseMode
@@ -87,15 +85,6 @@ def load_env(p: str = ".env"):
 
 load_env()
 
-# 导入媒体处理器
-try:
-    from media_handler import MediaHandler, MediaConfig
-    HAS_MEDIA_HANDLER = True
-except ImportError:
-    HAS_MEDIA_HANDLER = False
-    MediaHandler = None
-    MediaConfig = None
-
 # --- 日志 & 上下文 ---
 PROJECT_NAME = os.environ.get("PROJECT_NAME", "").strip()
 ACTIVE_MODEL = (os.environ.get("ACTIVE_MODEL") or os.environ.get("MODEL_NAME") or "").strip()
@@ -119,6 +108,19 @@ def _env_int(name: str, default: int) -> int:
         worker_log.warning("环境变量 %s=%r 解析为整数失败，已使用默认值 %s", name, raw, default)
         return default
 
+
+def _env_float(name: str, default: float) -> float:
+    """读取浮点型环境变量，解析失败时回退默认值。"""
+
+    raw = os.environ.get(name)
+    if raw is None or not raw.strip():
+        return default
+    try:
+        return float(raw.strip())
+    except ValueError:
+        worker_log.warning("环境变量 %s=%r 解析为浮点数失败，已使用默认值 %s", name, raw, default)
+        return default
+
 _PARSE_MODE_CANDIDATES: Dict[str, Optional[ParseMode]] = {
     "": None,
     "none": None,
@@ -1171,7 +1173,6 @@ async def _push_task_to_model(
     supplement: Optional[str],
     actor: Optional[str],
     is_bug_report: bool = False,
-    media_files: Optional[List[Dict[str, Any]]] = None,
 ) -> tuple[bool, str, Optional[Path]]:
     """推送任务信息到模型，并附带补充描述。
 
@@ -1182,30 +1183,17 @@ async def _push_task_to_model(
         supplement: 补充描述
         actor: 操作者
         is_bug_report: 是否为缺陷报告推送
-        media_files: 媒体文件列表
     """
 
     history_text, history_count = await _build_history_context_for_model(task.id)
     notes = await TASK_SERVICE.list_notes(task.id)
-
-    # 使用增强版函数（如果有媒体文件）
-    if media_files:
-        prompt = _build_model_push_payload_with_media(
-            task,
-            supplement=supplement,
-            history=history_text,
-            notes=notes,
-            media_files=media_files,
-            is_bug_report=is_bug_report,
-        )
-    else:
-        prompt = _build_model_push_payload(
-            task,
-            supplement=supplement,
-            history=history_text,
-            notes=notes,
-            is_bug_report=is_bug_report,
-        )
+    prompt = _build_model_push_payload(
+        task,
+        supplement=supplement,
+        history=history_text,
+        notes=notes,
+        is_bug_report=is_bug_report,
+    )
     success, session_path = await _dispatch_prompt_to_model(
         chat_id,
         prompt,
@@ -1315,6 +1303,439 @@ PROJECT_SLUG = (PROJECT_NAME or "default").replace("/", "-") or "default"
 TASK_DB_PATH = DATA_ROOT / f"{PROJECT_SLUG}.db"
 TASK_SERVICE = TaskService(TASK_DB_PATH, PROJECT_SLUG)
 
+ATTACHMENT_STORAGE_ROOT = (DATA_ROOT / "telegram").expanduser()
+ATTACHMENT_STORAGE_ROOT.mkdir(parents=True, exist_ok=True)
+_ATTACHMENT_TOTAL_MB = max(_env_int("TELEGRAM_ATTACHMENT_MAX_TOTAL_MB", 512), 16)
+ATTACHMENT_TOTAL_LIMIT_BYTES = _ATTACHMENT_TOTAL_MB * 1024 * 1024
+MEDIA_GROUP_AGGREGATION_DELAY = max(_env_float("TELEGRAM_MEDIA_GROUP_DELAY", 0.8), 0.1)
+
+
+@dataclass
+class TelegramSavedAttachment:
+    """记录单个附件的落地信息，便于提示模型读取。"""
+
+    kind: str
+    display_name: str
+    mime_type: str
+    absolute_path: Path
+    relative_path: str
+
+
+@dataclass
+class PendingMediaGroupState:
+    """聚合 Telegram 媒体组的临时缓存。"""
+
+    chat_id: int
+    origin_message: Message
+    attachment_dir: Path
+    attachments: list[TelegramSavedAttachment]
+    captions: list[str]
+    finalize_task: Optional[asyncio.Task] = None
+
+
+MEDIA_GROUP_STATE: dict[str, PendingMediaGroupState] = {}
+MEDIA_GROUP_LOCK = asyncio.Lock()
+
+ATTACHMENT_USAGE_HINT = (
+    "请按需读取附件：图片可使用 Codex 的 view_image 功能或 Claude Code 的文件引用能力；"
+    "文本/日志可直接通过 @<路径> 打开；若需其他处理请说明。"
+)
+
+_FS_SAFE_PATTERN = re.compile(r"[^A-Za-z0-9._-]")
+
+
+def _sanitize_fs_component(value: str, fallback: str) -> str:
+    """清理路径片段中的特殊字符，避免越权访问。"""
+
+    stripped = (value or "").strip()
+    cleaned = _FS_SAFE_PATTERN.sub("_", stripped)
+    cleaned = cleaned.strip("._")
+    return cleaned or fallback
+
+
+def _format_relative_path(path: Path) -> str:
+    """将绝对路径转换为模型更易识别的相对路径。"""
+
+    try:
+        rel = path.relative_to(ROOT_DIR_PATH)
+        rel_str = rel.as_posix()
+        if not rel_str.startswith("."):
+            return f"./{rel_str}"
+        return rel_str
+    except ValueError:
+        return path.resolve().as_posix()
+
+
+def _directory_size(path: Path) -> int:
+    """计算目录占用的总字节数。"""
+
+    total = 0
+    if not path.exists():
+        return 0
+    for entry in path.rglob("*"):
+        try:
+            if entry.is_file():
+                total += entry.stat().st_size
+        except FileNotFoundError:
+            continue
+    return total
+
+
+def _cleanup_attachment_storage() -> None:
+    """控制附件目录容量，避免磁盘被占满。"""
+
+    if ATTACHMENT_TOTAL_LIMIT_BYTES <= 0:
+        return
+    total = _directory_size(ATTACHMENT_STORAGE_ROOT)
+    if total <= ATTACHMENT_TOTAL_LIMIT_BYTES:
+        return
+    candidates = sorted(
+        (p for p in ATTACHMENT_STORAGE_ROOT.iterdir() if p.is_dir()),
+        key=lambda item: item.stat().st_mtime,
+    )
+    for folder in candidates:
+        try:
+            shutil.rmtree(folder, ignore_errors=True)
+        except Exception as exc:  # noqa: BLE001
+            worker_log.warning(
+                "清理旧附件目录失败：%s",
+                exc,
+                extra=_session_extra(path=folder),
+            )
+        if _directory_size(ATTACHMENT_STORAGE_ROOT) <= ATTACHMENT_TOTAL_LIMIT_BYTES:
+            break
+
+
+def _guess_extension(mime_type: Optional[str], fallback: str = ".bin") -> str:
+    """根据 MIME 类型推断扩展名。"""
+
+    if mime_type:
+        guessed = mimetypes.guess_extension(mime_type, strict=False)
+        if guessed:
+            return guessed
+    return fallback
+
+
+def _attachment_dir_for_message(message: Message, media_group_id: Optional[str] = None) -> Path:
+    """为当前消息（或媒体组）生成稳定的附件目录。"""
+
+    chat_part = _sanitize_fs_component(str(message.chat.id), "chat")
+    base = ATTACHMENT_STORAGE_ROOT / chat_part
+    if media_group_id:
+        group_part = _sanitize_fs_component(media_group_id, str(message.message_id))
+        target = base / f"group_{group_part}"
+    else:
+        timestamp = int((message.date or datetime.now(UTC)).timestamp())
+        target = base / f"msg_{timestamp}_{message.message_id}"
+    target.mkdir(parents=True, exist_ok=True)
+    return target
+
+
+async def _download_telegram_file(
+    message: Message,
+    *,
+    file_id: str,
+    file_name_hint: str,
+    mime_type: Optional[str],
+    target_dir: Path,
+) -> Path:
+    """从 Telegram 下载文件并返回本地路径。"""
+
+    bot = message.bot or current_bot()
+    telegram_file = await bot.get_file(file_id)
+    stem = _sanitize_fs_component(Path(file_name_hint).stem, "file")
+    extension = Path(file_name_hint).suffix or _guess_extension(mime_type, ".bin")
+    if not extension.startswith("."):
+        extension = f".{extension}"
+    filename = f"{stem}{extension}"
+    destination = target_dir / filename
+    counter = 1
+    while destination.exists():
+        destination = target_dir / f"{stem}_{counter}{extension}"
+        counter += 1
+    await bot.download_file(telegram_file.file_path, destination=destination)
+    return destination
+
+
+async def _collect_saved_attachments(message: Message, target_dir: Path) -> list[TelegramSavedAttachment]:
+    """下载消息中的所有附件，并返回保存记录。"""
+
+    saved: list[TelegramSavedAttachment] = []
+
+    if message.photo:
+        photo = message.photo[-1]
+        path = await _download_telegram_file(
+            message,
+            file_id=photo.file_id,
+            file_name_hint=f"photo_{photo.file_unique_id}.jpg",
+            mime_type="image/jpeg",
+            target_dir=target_dir,
+        )
+        saved.append(
+            TelegramSavedAttachment(
+                kind="photo",
+                display_name=path.name,
+                mime_type="image/jpeg",
+                absolute_path=path,
+                relative_path=_format_relative_path(path),
+            )
+        )
+
+    document = message.document
+    if document:
+        file_name = document.file_name or f"document_{document.file_unique_id}"
+        path = await _download_telegram_file(
+            message,
+            file_id=document.file_id,
+            file_name_hint=file_name,
+            mime_type=document.mime_type or "application/octet-stream",
+            target_dir=target_dir,
+        )
+        saved.append(
+            TelegramSavedAttachment(
+                kind="document",
+                display_name=file_name,
+                mime_type=document.mime_type or "application/octet-stream",
+                absolute_path=path,
+                relative_path=_format_relative_path(path),
+            )
+        )
+
+    video = message.video
+    if video:
+        file_name = video.file_name or f"video_{video.file_unique_id}"
+        path = await _download_telegram_file(
+            message,
+            file_id=video.file_id,
+            file_name_hint=file_name,
+            mime_type=video.mime_type or "video/mp4",
+            target_dir=target_dir,
+        )
+        saved.append(
+            TelegramSavedAttachment(
+                kind="video",
+                display_name=file_name,
+                mime_type=video.mime_type or "video/mp4",
+                absolute_path=path,
+                relative_path=_format_relative_path(path),
+            )
+        )
+
+    audio = message.audio
+    if audio:
+        file_name = audio.file_name or f"audio_{audio.file_unique_id}"
+        path = await _download_telegram_file(
+            message,
+            file_id=audio.file_id,
+            file_name_hint=file_name,
+            mime_type=audio.mime_type or "audio/mpeg",
+            target_dir=target_dir,
+        )
+        saved.append(
+            TelegramSavedAttachment(
+                kind="audio",
+                display_name=file_name,
+                mime_type=audio.mime_type or "audio/mpeg",
+                absolute_path=path,
+                relative_path=_format_relative_path(path),
+            )
+        )
+
+    voice = message.voice
+    if voice:
+        file_name = f"voice_{voice.file_unique_id}.ogg"
+        path = await _download_telegram_file(
+            message,
+            file_id=voice.file_id,
+            file_name_hint=file_name,
+            mime_type=voice.mime_type or "audio/ogg",
+            target_dir=target_dir,
+        )
+        saved.append(
+            TelegramSavedAttachment(
+                kind="voice",
+                display_name=file_name,
+                mime_type=voice.mime_type or "audio/ogg",
+                absolute_path=path,
+                relative_path=_format_relative_path(path),
+            )
+        )
+
+    animation = message.animation
+    if animation:
+        file_name = animation.file_name or f"animation_{animation.file_unique_id}"
+        path = await _download_telegram_file(
+            message,
+            file_id=animation.file_id,
+            file_name_hint=file_name,
+            mime_type=animation.mime_type or "video/mp4",
+            target_dir=target_dir,
+        )
+        saved.append(
+            TelegramSavedAttachment(
+                kind="animation",
+                display_name=file_name,
+                mime_type=animation.mime_type or "video/mp4",
+                absolute_path=path,
+                relative_path=_format_relative_path(path),
+            )
+        )
+
+    video_note = message.video_note
+    if video_note:
+        file_name = f"video_note_{video_note.file_unique_id}.mp4"
+        path = await _download_telegram_file(
+            message,
+            file_id=video_note.file_id,
+            file_name_hint=file_name,
+            mime_type=video_note.mime_type or "video/mp4",
+            target_dir=target_dir,
+        )
+        saved.append(
+            TelegramSavedAttachment(
+                kind="video_note",
+                display_name=file_name,
+                mime_type=video_note.mime_type or "video/mp4",
+                absolute_path=path,
+                relative_path=_format_relative_path(path),
+            )
+        )
+
+    if saved:
+        _cleanup_attachment_storage()
+    return saved
+
+
+def _build_prompt_with_attachments(
+    text_part: Optional[str],
+    attachments: Sequence[TelegramSavedAttachment],
+) -> str:
+    """将文字与附件描述拼接成模型可读的提示。"""
+
+    sections: list[str] = []
+    base_text = (text_part or "").strip()
+    if base_text:
+        sections.append(base_text)
+    if attachments:
+        lines = ["附件列表（文件位于项目工作目录，可直接读取）："]
+        for idx, item in enumerate(attachments, 1):
+            lines.append(
+                f"{idx}. {item.display_name}（{item.mime_type}）→ {item.relative_path}"
+            )
+        lines.append("")
+        lines.append(ATTACHMENT_USAGE_HINT)
+        sections.append("\n".join(lines))
+    if not sections:
+        fallback = [
+            "收到一条仅包含附件的消息，没有额外文字说明。",
+            "请直接阅读列出的附件并给出观察结果或结论。",
+        ]
+        sections.append("\n".join(fallback))
+    return "\n\n".join(sections).strip()
+
+
+async def _finalize_media_group_after_delay(media_group_id: str) -> None:
+    """在短暂延迟后合并媒体组消息，确保 Telegram 全部照片到齐。"""
+
+    try:
+        await asyncio.sleep(MEDIA_GROUP_AGGREGATION_DELAY)
+    except asyncio.CancelledError:
+        return
+
+    async with MEDIA_GROUP_LOCK:
+        state = MEDIA_GROUP_STATE.pop(media_group_id, None)
+
+    if state is None:
+        return
+
+    text_block = "\n".join(state.captions).strip()
+    prompt = _build_prompt_with_attachments(text_block, state.attachments)
+    try:
+        await _handle_prompt_dispatch(state.origin_message, prompt)
+    except Exception as exc:  # noqa: BLE001
+        worker_log.exception(
+            "媒体组消息推送模型失败：%s",
+            exc,
+            extra=_session_extra(media_group=media_group_id),
+        )
+
+
+async def _enqueue_media_group_message(message: Message, text_part: Optional[str]) -> None:
+    """收集媒体组中的每一条消息，统一延迟推送。"""
+
+    media_group_id = message.media_group_id
+    if not media_group_id:
+        return
+
+    async with MEDIA_GROUP_LOCK:
+        state = MEDIA_GROUP_STATE.get(media_group_id)
+        if state is None:
+            attachment_dir = _attachment_dir_for_message(message, media_group_id=media_group_id)
+            state = PendingMediaGroupState(
+                chat_id=message.chat.id,
+                origin_message=message,
+                attachment_dir=attachment_dir,
+                attachments=[],
+                captions=[],
+            )
+            MEDIA_GROUP_STATE[media_group_id] = state
+        else:
+            attachment_dir = state.attachment_dir
+
+    attachments = await _collect_saved_attachments(message, attachment_dir)
+    caption = (text_part or "").strip()
+
+    async with MEDIA_GROUP_LOCK:
+        state = MEDIA_GROUP_STATE.get(media_group_id)
+        if state is None:
+            # 若期间被清理，重新创建并继续积累，避免丢失后续内容。
+            state = PendingMediaGroupState(
+                chat_id=message.chat.id,
+                origin_message=message,
+                attachment_dir=attachment_dir,
+                attachments=[],
+                captions=[],
+            )
+            MEDIA_GROUP_STATE[media_group_id] = state
+        state.attachments.extend(attachments)
+        if caption:
+            state.captions.append(caption)
+        # 使用首条消息作为引用对象，便于 Telegram 回复。
+        if state.origin_message.message_id > message.message_id:
+            state.origin_message = message
+        if state.finalize_task and not state.finalize_task.done():
+            state.finalize_task.cancel()
+        state.finalize_task = asyncio.create_task(_finalize_media_group_after_delay(media_group_id))
+
+
+async def _handle_prompt_dispatch(message: Message, prompt: str) -> None:
+    """统一封装向模型推送提示词的流程。"""
+
+    if ENV_ISSUES:
+        message_text = _format_env_issue_message()
+        worker_log.warning(
+            "拒绝处理消息，环境异常: %s",
+            message_text,
+            extra={**_session_extra(), "chat": message.chat.id},
+        )
+        await message.answer(message_text)
+        return
+
+    bot = current_bot()
+    await bot.send_chat_action(message.chat.id, "typing")
+
+    if MODE == "A":
+        if not AGENT_CMD:
+            await message.answer("AGENT_CMD 未配置（.env）")
+            return
+        rc, out = run_subprocess_capture(AGENT_CMD, input_text=prompt)
+        out = out or ""
+        out = out + ("" if rc == 0 else f"\n(exit={rc})")
+        await reply_large_text(message.chat.id, out)
+        return
+
+    await _dispatch_prompt_to_model(message.chat.id, prompt, reply_to=message)
+
 BOT_COMMANDS: list[tuple[str, str]] = [
     ("help", "查看全部命令"),
     ("tasks", "任务命令清单"),
@@ -2023,57 +2444,6 @@ def _build_model_push_payload(
     return _strip_legacy_bug_header(result or body)
 
 
-def _build_model_push_payload_with_media(
-    task: TaskRecord,
-    supplement: Optional[str] = None,
-    history: Optional[str] = None,
-    notes: Optional[Sequence[TaskNoteRecord]] = None,
-    media_files: Optional[List[Dict[str, Any]]] = None,
-    is_bug_report: bool = False,
-) -> str:
-    """构造包含媒体文件引用的模型推送 payload"""
-
-    # 先构造基础 payload
-    base_payload = _build_model_push_payload(
-        task=task,
-        supplement=supplement,
-        history=history,
-        notes=notes,
-        is_bug_report=is_bug_report
-    )
-
-    # 如果没有媒体文件，直接返回
-    if not media_files:
-        return base_payload
-
-    # 添加媒体文件信息
-    lines = [base_payload]
-    lines.append("\n相关文件：")
-
-    for idx, media in enumerate(media_files, 1):
-        file_type = media["type"]
-        file_path = media["file_path"]
-
-        if file_type == "image":
-            width = media.get("width", "?")
-            height = media.get("height", "?")
-            lines.append(f"{idx}. 图片 ({width}×{height}): {file_path}")
-        elif file_type == "document":
-            original_name = media.get("original_name", "未命名文档")
-            size_mb = media.get("size", 0) / 1024 / 1024
-            lines.append(f"{idx}. 文档 [{original_name}] ({size_mb:.1f}MB): {file_path}")
-
-    # 为不同模型添加特定指令
-    if _is_claudecode_model():
-        lines.append("\n请使用 Read 工具查看上述文件以理解其内容。")
-    elif MODEL_CANONICAL_NAME == "codex":
-        lines.append("\n请分析上述文件并结合任务要求进行处理。")
-    elif "gemini" in MODEL_CANONICAL_NAME:
-        lines.append("\n请查看并分析上述文件。")
-
-    return "\n".join(lines)
-
-
 try:
     SHANGHAI_TZ = ZoneInfo("Asia/Shanghai")
 except ZoneInfoNotFoundError:
@@ -3051,61 +3421,6 @@ def _collect_message_payload(message: Message) -> str:
     return "\n".join(parts).strip()
 
 
-async def _collect_message_payload_with_media(
-    message: Message,
-    task_id: Optional[str] = None
-) -> Tuple[str, List[Dict[str, Any]], Optional[str]]:
-    """
-    收集消息内容和媒体文件（增强版）
-    返回: (文本内容, 媒体文件列表, 用户提示消息)
-    """
-    parts = []
-    media_files = []
-    user_feedback = None
-
-    # 处理文本
-    text = _normalize_choice_token(message.text or message.caption)
-    if text:
-        parts.append(text)
-
-    # 处理媒体文件
-    if media_handler and (message.photo or message.document):
-        media_info, feedback_msg = await media_handler.process_message_media(
-            message, task_id
-        )
-
-        if media_info["type"] not in ["none", "error"]:
-            media_files.append(media_info)
-            # 添加文件引用到文本
-            if media_info["type"] == "image":
-                parts.append(f"[图片: {media_info['file_path']}]")
-            elif media_info["type"] == "document":
-                parts.append(f"[文档: {media_info['file_path']}]")
-        elif media_info["type"] == "error":
-            # 添加错误信息到文本
-            parts.append(f"[媒体处理失败: {media_info.get('error', '未知错误')}]")
-
-        # 设置用户反馈
-        user_feedback = feedback_msg
-    else:
-        # 没有媒体处理器时，使用原有逻辑
-        if message.photo:
-            file_id = message.photo[-1].file_id
-            parts.append(f"[图片:{file_id}]")
-        if message.document:
-            doc = message.document
-            name = doc.file_name or doc.file_id
-            parts.append(f"[文件:{name}]")
-
-    # 处理其他媒体类型（保持原有逻辑）
-    if message.voice:
-        parts.append(f"[语音: {message.voice.file_id}]")
-    if message.video:
-        parts.append(f"[视频: {message.video.file_id}]")
-
-    return "\n".join(parts).strip(), media_files, user_feedback
-
-
 def _summarize_note_text(value: str) -> str:
     """压缩备注内容，维持主要信息并控制长度。"""
 
@@ -3562,9 +3877,6 @@ def tmux_capture_since(log_path: Path | str, start_pos: int, idle: float = 2.0,
     return "".join(buf)
 
 
-# 全局媒体处理器
-media_handler: Optional[MediaHandler] = None
-
 SESSION_OFFSETS: Dict[str, int] = {}
 CHAT_SESSION_MAP: Dict[int, str] = {}
 CHAT_WATCHERS: Dict[int, asyncio.Task] = {}
@@ -5311,7 +5623,6 @@ async def on_help_command(message: Message) -> None:
         "*指令总览*\n"
         "- /help — 查看全部命令\n"
         "- /tasks — 任务管理命令清单\n"
-        "- /media — 查看媒体文件统计和管理\n"
         "- /task_new — 创建任务（交互式或附带参数）\n"
         "- /task_list — 查看任务列表，支持 status/limit/offset\n"
         "- /task_show — 查看某个任务详情\n"
@@ -5340,158 +5651,6 @@ async def on_tasks_help(message: Message) -> None:
     await _answer_with_markdown(message, text)
 
 
-@router.message(Command("media"))
-async def on_media_command(message: Message) -> None:
-    """处理 /media 命令，显示媒体文件统计和管理选项"""
-    global media_handler
-
-    if not media_handler:
-        await message.reply("❌ 媒体处理功能未初始化")
-        return
-
-    try:
-        # 获取媒体文件统计
-        stats = await media_handler.get_stats()
-
-        # 构建统计信息文本
-        lines = [
-            "*📊 媒体文件统计*",
-            "",
-            f"📁 存储位置: `{stats['storage_path']}`",
-            f"📷 图片文件: {stats['image_count']} 个",
-            f"📄 文档文件: {stats['document_count']} 个",
-            f"💾 总占用空间: {stats['total_size_mb']:.2f} MB",
-            "",
-            f"⏰ 普通文件保留: {stats['normal_retention_days']} 天",
-            f"🎯 任务文件保留: {stats['task_retention_days']} 天",
-            "",
-            f"🗑️ 待清理文件: {stats['expired_count']} 个",
-        ]
-
-        if stats['expired_count'] > 0:
-            lines.append(f"   ({stats['expired_size_mb']:.2f} MB 可释放)")
-
-        # 最近的文件
-        if stats['recent_files']:
-            lines.extend([
-                "",
-                "*📝 最近下载的文件:*"
-            ])
-            for file_info in stats['recent_files'][:5]:
-                file_type = "📷" if file_info['type'] == 'image' else "📄"
-                lines.append(f"{file_type} {file_info['name']} ({file_info['size_mb']:.2f} MB)")
-
-        text = "\n".join(lines)
-
-        # 创建管理按钮
-        keyboard = InlineKeyboardMarkup(
-            inline_keyboard=[
-                [
-                    InlineKeyboardButton(text="🗑️ 立即清理过期文件", callback_data="media_cleanup"),
-                    InlineKeyboardButton(text="🔄 刷新统计", callback_data="media_refresh")
-                ]
-            ]
-        )
-
-        await _answer_with_markdown(message, text, reply_markup=keyboard)
-
-    except Exception as e:
-        worker_log.error(f"获取媒体统计失败: {e}", exc_info=True)
-        await message.reply(f"❌ 获取媒体统计失败: {e}")
-
-
-@router.callback_query(F.data == "media_cleanup")
-async def on_media_cleanup_callback(callback: CallbackQuery) -> None:
-    """处理清理过期文件的回调"""
-    global media_handler
-
-    if not media_handler:
-        await callback.answer("❌ 媒体处理功能未初始化", show_alert=True)
-        return
-
-    try:
-        # 执行清理
-        cleaned_count = await media_handler.cleanup_old_files()
-
-        if cleaned_count > 0:
-            await callback.answer(f"✅ 已清理 {cleaned_count} 个过期文件", show_alert=True)
-        else:
-            await callback.answer("📭 没有需要清理的文件", show_alert=True)
-
-        # 更新统计信息
-        await on_media_refresh_callback(callback)
-
-    except Exception as e:
-        worker_log.error(f"清理媒体文件失败: {e}", exc_info=True)
-        await callback.answer(f"❌ 清理失败: {e}", show_alert=True)
-
-
-@router.callback_query(F.data == "media_refresh")
-async def on_media_refresh_callback(callback: CallbackQuery) -> None:
-    """处理刷新统计的回调"""
-    global media_handler
-
-    if not media_handler:
-        await callback.answer("❌ 媒体处理功能未初始化", show_alert=True)
-        return
-
-    try:
-        # 获取最新统计
-        stats = await media_handler.get_stats()
-
-        # 构建更新的文本
-        lines = [
-            "*📊 媒体文件统计*",
-            "",
-            f"📁 存储位置: `{stats['storage_path']}`",
-            f"📷 图片文件: {stats['image_count']} 个",
-            f"📄 文档文件: {stats['document_count']} 个",
-            f"💾 总占用空间: {stats['total_size_mb']:.2f} MB",
-            "",
-            f"⏰ 普通文件保留: {stats['normal_retention_days']} 天",
-            f"🎯 任务文件保留: {stats['task_retention_days']} 天",
-            "",
-            f"🗑️ 待清理文件: {stats['expired_count']} 个",
-        ]
-
-        if stats['expired_count'] > 0:
-            lines.append(f"   ({stats['expired_size_mb']:.2f} MB 可释放)")
-
-        # 最近的文件
-        if stats['recent_files']:
-            lines.extend([
-                "",
-                "*📝 最近下载的文件:*"
-            ])
-            for file_info in stats['recent_files'][:5]:
-                file_type = "📷" if file_info['type'] == 'image' else "📄"
-                lines.append(f"{file_type} {file_info['name']} ({file_info['size_mb']:.2f} MB)")
-
-        text = "\n".join(lines)
-
-        # 保持按钮
-        keyboard = InlineKeyboardMarkup(
-            inline_keyboard=[
-                [
-                    InlineKeyboardButton(text="🗑️ 立即清理过期文件", callback_data="media_cleanup"),
-                    InlineKeyboardButton(text="🔄 刷新统计", callback_data="media_refresh")
-                ]
-            ]
-        )
-
-        await callback.message.edit_text(
-            text,
-            parse_mode="MarkdownV2" if _IS_MARKDOWN_V2 else "Markdown",
-            reply_markup=keyboard
-        )
-
-        await callback.answer("✅ 统计已更新")
-
-    except Exception as e:
-        worker_log.error(f"刷新媒体统计失败: {e}", exc_info=True)
-        await callback.answer(f"❌ 刷新失败: {e}", show_alert=True)
-
-
 def _normalize_status(value: Optional[str]) -> Optional[str]:
     if not value:
         return None
@@ -7172,40 +7331,21 @@ async def on_task_bug_report(callback: CallbackQuery, state: FSMContext) -> None
 
 @router.message(TaskBugReportStates.waiting_description)
 async def on_task_bug_description(message: Message, state: FSMContext) -> None:
-    """处理缺陷描述输入（支持图片和文档）。"""
+    """处理缺陷描述输入。"""
 
     if _is_cancel_message(message.text):
         await state.clear()
         await message.answer("已取消缺陷上报。", reply_markup=_build_worker_main_keyboard())
         return
-
-    # 获取任务 ID
-    data = await state.get_data()
-    task_id = data.get("task_id")
-
-    # 使用增强版收集函数（如果有媒体处理器）
-    if media_handler:
-        content, media_files, feedback = await _collect_message_payload_with_media(
-            message, task_id
-        )
-        # 发送用户反馈
-        if feedback:
-            await message.answer(feedback)
-    else:
-        # 使用原有函数
-        content = _collect_message_payload(message)
-        media_files = []
-
-    if not content and not media_files:
+    content = _collect_message_payload(message)
+    if not content:
         await message.answer(
             "缺陷描述不能为空，请重新输入：",
             reply_markup=_build_description_keyboard(),
         )
         return
-
     await state.update_data(
         description=content,
-        media_files=media_files,
         reporter=_actor_from_message(message),
     )
     await state.set_state(TaskBugReportStates.waiting_reproduction)
@@ -7214,36 +7354,18 @@ async def on_task_bug_description(message: Message, state: FSMContext) -> None:
 
 @router.message(TaskBugReportStates.waiting_reproduction)
 async def on_task_bug_reproduction(message: Message, state: FSMContext) -> None:
-    """处理复现步骤输入（支持图片）。"""
+    """处理复现步骤输入。"""
 
     if _is_cancel_message(message.text):
         await state.clear()
         await message.answer("已取消缺陷上报。", reply_markup=_build_worker_main_keyboard())
         return
-
     options = [SKIP_TEXT, "取消"]
     resolved = _resolve_reply_choice(message.text or "", options=options)
     reproduction = ""
-    reproduction_media = []
-
     if resolved not in {SKIP_TEXT, "取消"}:
-        # 获取任务 ID
-        data = await state.get_data()
-        task_id = data.get("task_id")
-
-        if media_handler:
-            reproduction, reproduction_media, feedback = await _collect_message_payload_with_media(
-                message, task_id
-            )
-            if feedback:
-                await message.answer(feedback)
-        else:
-            reproduction = _collect_message_payload(message)
-
-    await state.update_data(
-        reproduction=reproduction,
-        reproduction_media=reproduction_media
-    )
+        reproduction = _collect_message_payload(message)
+    await state.update_data(reproduction=reproduction)
     await state.set_state(TaskBugReportStates.waiting_logs)
     await message.answer(_build_bug_log_prompt(), reply_markup=_build_description_keyboard())
 
@@ -7321,21 +7443,11 @@ async def on_task_bug_confirm(message: Message, state: FSMContext) -> None:
     reproduction = data.get("reproduction", "")
     logs = data.get("logs", "")
     reporter = data.get("reporter") or _actor_from_message(message)
-
-    # 收集所有媒体文件
-    all_media_files = []
-    if "media_files" in data:
-        all_media_files.extend(data["media_files"])
-    if "reproduction_media" in data:
-        all_media_files.extend(data["reproduction_media"])
-
     payload = {
         "action": "bug_report",
         "description_length": len(description),
         "has_reproduction": bool(reproduction.strip()),
         "has_logs": bool(logs.strip()),
-        "has_media": len(all_media_files) > 0,
-        "media_count": len(all_media_files),
         "description": description,
         "reproduction": reproduction,
         "logs": logs,
@@ -7349,12 +7461,7 @@ async def on_task_bug_confirm(message: Message, state: FSMContext) -> None:
         payload=payload,
     )
     await state.clear()
-    await _auto_push_after_bug_report(
-        task,
-        message=message,
-        actor=reporter,
-        media_files=all_media_files
-    )
+    await _auto_push_after_bug_report(task, message=message, actor=reporter)
 
 
 @router.callback_query(F.data.startswith("task:add_note:"))
@@ -7729,6 +7836,28 @@ async def on_edit_new_value(message: Message, state: FSMContext) -> None:
     await _answer_with_markdown(message, f"任务已更新：\n{detail_text}", reply_markup=markup)
 
 
+@router.message(
+    F.photo | F.document | F.video | F.audio | F.voice | F.animation | F.video_note
+)
+async def on_media_message(message: Message) -> None:
+    """处理带附件的普通消息，将附件下载并拼接提示词。"""
+
+    _auto_record_chat_id(message.chat.id)
+    text_part = (message.caption or message.text or "").strip()
+
+    if message.media_group_id:
+        await _enqueue_media_group_message(message, text_part)
+        return
+
+    attachment_dir = _attachment_dir_for_message(message)
+    attachments = await _collect_saved_attachments(message, attachment_dir)
+    if not attachments and not text_part:
+        await message.answer("未检测到可处理的附件或文字内容。")
+        return
+    prompt = _build_prompt_with_attachments(text_part, attachments)
+    await _handle_prompt_dispatch(message, prompt)
+
+
 @router.message(CommandStart())
 async def on_start(m: Message):
     # 首次收到消息时自动记录 chat_id 到 state 文件
@@ -7747,76 +7876,21 @@ async def on_start(m: Message):
     if ENV_ISSUES:
         await m.answer(_format_env_issue_message())
 
-@router.message(F.text | F.photo | F.document | F.caption)
+@router.message(F.text)
 async def on_text(m: Message):
-    """
-    处理用户消息：支持纯文本、带图片和文档的消息
-    - 纯文本消息：使用 m.text
-    - 带媒体消息：使用 m.caption，并下载媒体文件
-    """
     # 首次收到消息时自动记录 chat_id 到 state 文件
     _auto_record_chat_id(m.chat.id)
 
-    # 提取文本内容（优先使用 caption，用于带媒体的消息）
-    prompt = (m.caption or m.text or "").strip()
-
-    # 如果有媒体文件，使用增强收集函数
-    has_media = m.photo or m.document
-    if media_handler and has_media:
-        try:
-            content, media_files, feedback = await _collect_message_payload_with_media(m, None)
-            # 发送用户反馈（下载成功/失败提示）
-            if feedback:
-                await m.answer(feedback)
-            # 使用包含媒体路径引用的完整内容
-            prompt = content
-        except Exception as e:
-            worker_log.error(
-                "处理媒体文件失败: %s",
-                e,
-                exc_info=True,
-                extra={**_session_extra(), "chat": m.chat.id}
-            )
-            # 降级处理：继续使用文本部分
-            await m.answer(f"⚠️ 媒体文件处理失败，仅使用文本内容：{str(e)}")
-
+    prompt = (m.text or "").strip()
     if not prompt:
         return await m.answer("请输入非空提示词")
-
-    # 快捷查询任务详情（如输入 TASK_0001）
     task_id_candidate = _normalize_task_id(prompt)
     if task_id_candidate:
         await _reply_task_detail_message(m, task_id_candidate)
         return
-
-    # 忽略以 / 开头的未识别命令
     if prompt.startswith("/"):
         return
-
-    # 环境异常检查
-    if ENV_ISSUES:
-        message = _format_env_issue_message()
-        worker_log.warning(
-            "拒绝处理消息，环境异常: %s",
-            message,
-            extra={**_session_extra(), "chat": m.chat.id},
-        )
-        await m.answer(message)
-        return
-
-    bot = current_bot()
-    await bot.send_chat_action(m.chat.id, "typing")  # "正在输入"提示
-
-    if MODE == "A":
-        if not AGENT_CMD:
-            return await m.answer("AGENT_CMD 未配置（.env）")
-        rc, out = run_subprocess_capture(AGENT_CMD, input_text=prompt)
-        out = out or ""
-        out = out + ("" if rc == 0 else f"\n(exit={rc})")
-        await reply_large_text(m.chat.id, out)
-
-    else:
-        await _dispatch_prompt_to_model(m.chat.id, prompt, reply_to=m)
+    await _handle_prompt_dispatch(m, prompt)
 
 
 async def ensure_telegram_connectivity(bot: Bot, timeout: float = 30.0):
@@ -7888,28 +7962,8 @@ async def _ensure_worker_menu_button(bot: Bot) -> None:
             extra={**_session_extra(), "text": WORKER_MENU_BUTTON_TEXT},
         )
 
-async def _media_cleanup_worker():
-    """媒体文件定期清理任务"""
-    if not media_handler or not MediaConfig:
-        return
-
-    while True:
-        try:
-            await asyncio.sleep(MediaConfig.AUTO_CLEANUP_INTERVAL_HOURS * 3600)
-
-            if media_handler:
-                cleaned = await media_handler.cleanup_old_files()
-                worker_log.info(
-                    "定期清理完成，删除了 %d 个过期文件",
-                    cleaned,
-                    extra=_session_extra()
-                )
-
-        except Exception as e:
-            worker_log.error("媒体清理任务失败: %s", e, extra=_session_extra())
-
 async def main():
-    global _bot, CHAT_LONG_POLL_LOCK, media_handler
+    global _bot, CHAT_LONG_POLL_LOCK
     # 初始化长轮询锁
     CHAT_LONG_POLL_LOCK = asyncio.Lock()
     _bot = build_bot()
@@ -7927,16 +7981,6 @@ async def main():
         if _bot:
             await _bot.session.close()
         raise SystemExit(1)
-
-    # 初始化媒体处理器
-    if HAS_MEDIA_HANDLER and _bot:
-        try:
-            media_handler = MediaHandler(_bot)
-            # 启动定期清理任务
-            asyncio.create_task(_media_cleanup_worker())
-            worker_log.info("媒体处理器已初始化", extra=_session_extra())
-        except Exception as exc:
-            worker_log.error("媒体处理器初始化失败：%s", exc, extra=_session_extra())
     await _ensure_bot_commands(_bot)
     await _ensure_worker_menu_button(_bot)
     await _broadcast_worker_keyboard(_bot)

{vibego-0.2.53.dist-info → vibego-0.2.55.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: vibego
-Version: 0.2.53
+Version: 0.2.55
 Summary: vibego CLI：用于初始化与管理 Telegram Master Bot 的工具
 Author: Hypha
 License-Expression: LicenseRef-Proprietary

{vibego-0.2.53.dist-info → vibego-0.2.55.dist-info}/RECORD

@@ -1,4 +1,4 @@
-bot.py,sha256=CesIqaHDsd3Y17WifLCXuVBIzNHM4PNNokdS67HfNFc,288481
+bot.py,sha256=hjebHpgW7tR9fNxkdbgNLFNYaz4MNgtsq_Sci2VljPM,289835
 logging_setup.py,sha256=gvxHi8mUwK3IhXJrsGNTDo-DR6ngkyav1X-tvlBF_IE,4613
 master.py,sha256=Jwxf6I94jOADzb9Xio1wb-tWy5wgQ9PlmdpKW4mhQMg,117114
 project_repository.py,sha256=UcthtSGOJK0cTE5bQCneo3xkomRG-kyc1N1QVqxeHIs,17577
@@ -426,14 +426,14 @@ tasks/constants.py,sha256=tS1kZxBIUm3JJUMHm25XI-KHNUZl5NhbbuzjzL_rF-c,299
 tasks/fsm.py,sha256=rKXXLEieQQU4r2z_CZUvn1_70FXiZXBBugF40gpe_tQ,1476
 tasks/models.py,sha256=N_qqRBo9xMSV0vbn4k6bLBXT8C_dp_oTFUxvdx16ZQM,2459
 tasks/service.py,sha256=w_S_aWiVqRXzXEpimLDsuCCCX2lB5uDkff9aKThBw9c,41916
-vibego_cli/__init__.py,sha256=RhKQDIl5t7O807Y4ZeWjiOuiBu1fCdsMftRxALaJgVM,311
+vibego_cli/__init__.py,sha256=asbT5tFazlPcS692PW0b6GBg_fWkYpf-mZn02hiG-p4,311
 vibego_cli/__main__.py,sha256=qqTrYmRRLe4361fMzbI3-CqpZ7AhTofIHmfp4ykrrBY,158
 vibego_cli/config.py,sha256=VxkPJMq01tA3h3cOkH-z_tiP7pMgfSGGicRvUnCWkhI,3054
 vibego_cli/deps.py,sha256=1nRXI7Dd-S1hYE8DligzK5fIluQWETRUj4_OKL0DikQ,1419
 vibego_cli/main.py,sha256=X__NXwZnIDIFbdKSTbNyZgZHKcPlN0DQz9sqTI1aQ9E,12158
 vibego_cli/data/worker_requirements.txt,sha256=QSt30DSSSHtfucTFPpc7twk9kLS5rVLNTcvDiagxrZg,62
-vibego-0.2.53.dist-info/METADATA,sha256=TnDy-BLDytwFiwIDwpjsFhZEbdk-LAbFIB8GY199oSQ,10519
-vibego-0.2.53.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-vibego-0.2.53.dist-info/entry_points.txt,sha256=Lsy_zm-dlyxt8-9DL9blBReIwU2k22c8-kifr46ND1M,48
-vibego-0.2.53.dist-info/top_level.txt,sha256=R56CT3nW5H5v3ce0l3QDN4-C4qxTrNWzRTwrxnkDX4U,69
-vibego-0.2.53.dist-info/RECORD,,
+vibego-0.2.55.dist-info/METADATA,sha256=McMxELuZfQ_ByCmOD3gRCEIqec4IHYK1pPNjMpn8xxM,10519
+vibego-0.2.55.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+vibego-0.2.55.dist-info/entry_points.txt,sha256=Lsy_zm-dlyxt8-9DL9blBReIwU2k22c8-kifr46ND1M,48
+vibego-0.2.55.dist-info/top_level.txt,sha256=R56CT3nW5H5v3ce0l3QDN4-C4qxTrNWzRTwrxnkDX4U,69
+vibego-0.2.55.dist-info/RECORD,,

vibego_cli/__init__.py

@@ -7,6 +7,6 @@ from __future__ import annotations
 
 __all__ = ["main", "__version__"]
 
-__version__ = "0.2.53"
+__version__ = "0.2.55"
 
 from .main import main  # noqa: E402