free-short-video 7.0.3 → 7.0.5

package/README.md

@@ -1,26 +1,21 @@
 ---
 
-# What's New in v7.0.3
+# What's New in v7.0.5
 
 ## What's New
 
 ### Features & Improvements
 
-* **Survive Agnes queue saturation.** When Agnes rejects submissions with `503 video_queue_full` (the free Video 2.5 Flash queue can stay full for 10+ minutes), the app now retries on a dedicated track — every 30–60s for up to 900s (`AGNES_VIDEO_QUEUE_RETRY_SECONDS`) — without consuming the normal retry budget, so you no longer get a premature "generation failed" while you were simply never queued. Nothing is consumed by a rejected submit. The progress panel shows it live: `Agnes 视频队列已满（HTTP 503 · video_queue_full），正在排队重试（第 N 次 / 已等 X 分钟）。建议错峰重试或稍后再试。`
-* **Honest error messages.** Upstream failures now surface the real reason instead of a generic `HTTP 503: server error` or a raw dict dump: the submitted error's `code` and `message` are kept end-to-end (e.g. `ComfyUI internal error: inference not finished after 15 minutes (code=500)`), so "queue full" and "queued but stuck" are no longer indistinguishable. `error_logs/` stores readable text plus the upstream code.
-* **Queue notices in your language (all 22 locales).** Queue-full progress and failure notices are now rendered by the frontend from structured i18n keys, so Japanese, Arabic, Russian, etc. users see their own language instead of a Chinese fallback. The raw upstream error (HTTP status, `video_queue_full`) is quoted untranslated, as it comes from the API.
-* **Config panels start collapsed.** All four configuration cards (provider management, model selection, workspace, privacy) now start collapsed instead of expanded; your manual expand/collapse preference is still remembered per browser.
-* **Know when a model is not adapted.** Video models that appear in the upstream model list but have no capability entry in your installed version are now marked with `⚠` plus an explicit notice, instead of being silently submitted with the old v2.0 pixel protocol. The app version is shown in the page footer and returned by `GET /api/models`.
+* **Readable, localized error when ffmpeg is missing.** If no usable ffmpeg executable can be found, the task now fails with a clear message in the user's UI language that names the problem and tells you how to fix it — install ffmpeg, make sure it is on `PATH`, or point the `FFMPEG_BINARY` environment variable at its absolute path — instead of the raw `[WinError 2]` that gave no clue about what was wrong.
 
 ### Bug Fixes
 
-* **Switching the text model provider back to Agnes now works.** Previously the switch only changed the UI: the backend kept the previously selected third-party provider and kept calling its endpoint (an empty value was dropped by the form layer and treated as "no change"). The selection is now sent explicitly, and it persists when you click **Save**.
-* **Frontend no longer breaks after an update.** The app entry page is now served with `Cache-Control: no-cache`, so browsers can no longer keep a stale entry page that references deleted build assets — the "task list (or the whole app) silently stopped working after pulling a new version" failure mode is gone. After upgrading, do one hard refresh (`Cmd/Ctrl+Shift+R`); afterwards updates apply on normal reload.
-* Fixed the queue-full messaging to name Agnes, quote the raw upstream error, and include an actionable suggestion (retry off-peak), instead of the vague "upstream video queue is full".
+* **The silent audio track no longer breaks tasks on machines without a system-wide ffmpeg.** Generating the silent narration track (used when narration is turned off, or as an automatic fallback when text-to-speech is unavailable) launched `ffmpeg` by name, so the task failed at the `audio` step with `[WinError 2] The system cannot find the file specified` even though video concatenation, watermarking and the rest of the app already used the bundled binary. Last-frame extraction and end-frame normalization had the same problem and are fixed as well.
+* **Duration, audio-stream and resolution probes no longer degrade silently when `ffprobe` is missing.** In lean environments — notably the Docker image, which ships only the bundled `ffmpeg` — media probing fell back to empty values, so narration/subtitle timing, watermark placement and anchor compositing could quietly proceed on wrong assumptions. Probing now falls back to `ffmpeg -i` output and returns real values.
 
 ---
 
-No action is required after upgrading. If your tasks sit at 0% for a long time, that is the Agnes free queue — the app now retries and tells you so; off-peak retries or switching to Video 2.0 (separate queue) remain the practical workarounds.
+After upgrading, tasks that previously failed in the `audio` step can be resumed from the task list and will continue from the failed step — no system-wide ffmpeg installation is required.
 
 ---
 

package/core/api/agnes_video.py

@@ -461,6 +461,12 @@ class AgnesVideoAPI:
         last_status = ""
         poll_count = 0
         consecutive_failures = 0
+        # U9（v7.0.4）：提交返回的是网关路由键，任务记录入库可见有延迟——
+        # 轮询侧 404 "task not found" 是「任务还没准备好」的中间态而非错误
+        # （实测上游高峰期可见性延迟可从历史 ~20s 劣化到 10min+），单独计数、
+        # 只做周期性 info 日志，不进 error_logs、不消耗连续失败配额；
+        # 最终兜底是循环顶部的 max_poll_duration 整体超时。
+        not_found_count = 0
         start_time = asyncio.get_event_loop().time()
         # 2.5 系列查询需带 model_name（text 模式可省略，但带上更通用）
         model_param = f"&model_name={self.model}" if is_v25_video_model(self.model) else ""
@@ -511,6 +517,18 @@ class AgnesVideoAPI:
                         logger.warning("[KeyRotation] HTTP 429 on poll, 换 Key 立即重试")
                         continue
                     break
+                # U9：404（task not found）= 记录尚未在网关任务库可见，中间态
+                if resp.status_code == 404:
+                    not_found_count += 1
+                    poll_count += 1  # 计入自适应间隔与周期日志的推进
+                    if not_found_count == 1 or not_found_count % 10 == 0:
+                        logger.info(
+                            f"[AgnesVideo] Video {video_id[:16]}... not yet visible "
+                            f"(404 task not found), poll #{not_found_count}, "
+                            f"elapsed {elapsed:.0f}s"
+                        )
+                    await asyncio.sleep(_adaptive_poll_interval(interval, poll_count))
+                    continue
                 resp.raise_for_status()
                 result = resp.json()
                 status = result.get("status", "")

package/core/api/error_collector.py

@@ -33,6 +33,63 @@ _WORKSPACE_ROOT: Optional[Path] = None
 # 用 contextvar 而非逐层传参，将改动面收敛到 API 模块内部（PRD FR9）。
 _TASK_ID_CTX: ContextVar[str] = ContextVar("error_collector_task_id", default="")
 
+# ── GA 埋点：上游接口报错聚合（内存态，按 task_id 分组）──
+# 结构：{task_id: {"{status_code}|{model_type}|{api_method}": {
+#     "status_code": int, "model_type": str, "api_method": str,
+#     "count": int, "first_ts": iso, "last_ts": iso}}}
+#
+# 设计说明：故意**不写入 task_state.json**——流水线持有自己的 TaskManager
+# 缓存实例，每次 update_state 都会拿缓存快照整份覆盖落盘，error_collector
+# 若单独写盘会被下一次流水线落盘冲掉。改为内存聚合 +
+# GET /api/tasks/{id}（web/routes/task_routes.py）读取时合并下发，
+# 前端轮询到新增量即上报 GA `api_error` 事件（503 趋势分析用）。
+# 进程重启后内存聚合清零属预期：前端埋点本身只覆盖"页面开着"的窗口，
+# 完整离线趋势仍以 error_logs/ 落盘文件为准。
+_TASK_ERROR_AGG: dict = {}
+_MAX_AGG_ENTRIES_PER_TASK = 32  # 按维度聚合后条目数上限，防异常状态码刷爆
+
+
+def _bump_upstream_error(task_id: str, status_code: int, model_type: str, api_method: str) -> None:
+    """累加一次带 HTTP 状态码的上游报错（内存聚合，失败静默不影响主流程）。"""
+    try:
+        now = datetime.now().isoformat(timespec="seconds")
+        per_task = _TASK_ERROR_AGG.setdefault(task_id, {})
+        key = f"{status_code}|{model_type}|{api_method}"
+        entry = per_task.get(key)
+        if entry is None:
+            if len(per_task) >= _MAX_AGG_ENTRIES_PER_TASK:
+                logger.warning(
+                    f"[ErrorCollector] Upstream error agg cap "
+                    f"({_MAX_AGG_ENTRIES_PER_TASK}) reached for task {task_id}, dropping"
+                )
+                return
+            per_task[key] = {
+                "status_code": status_code,
+                "model_type": model_type,
+                "api_method": api_method,
+                "count": 1,
+                "first_ts": now,
+                "last_ts": now,
+            }
+        else:
+            entry["count"] += 1
+            entry["last_ts"] = now
+    except Exception as e:
+        logger.debug(f"[ErrorCollector] Failed to bump upstream error agg: {e}")
+
+
+def get_task_upstream_errors(task_id: str) -> list:
+    """返回某任务聚合后的上游报错列表（按首次发生时间排序，供任务详情端点合并下发）。"""
+    per_task = _TASK_ERROR_AGG.get(task_id or "")
+    if not per_task:
+        return []
+    return sorted(per_task.values(), key=lambda e: e.get("first_ts", ""))
+
+
+def clear_task_upstream_errors(task_id: str) -> None:
+    """任务删除时清理对应聚合（防内存缓慢增长）。"""
+    _TASK_ERROR_AGG.pop(task_id or "", None)
+
 
 def set_workspace_root(path: str) -> None:
     """设置错误日志存储的根目录（通常为激活的工作空间路径）。
@@ -198,6 +255,12 @@ def collect_error(
         with open(filepath, "w", encoding="utf-8") as f:
             json.dump(error_data, f, ensure_ascii=False, indent=2)
 
+        # GA 埋点：带 HTTP 状态码的报错同步累加进任务级内存聚合
+        if status_code and error_data["task_id"]:
+            _bump_upstream_error(
+                error_data["task_id"], status_code, model_type, api_method
+            )
+
         # 优化路线图 1.5b：按数量轮转，防止 error_logs 无限膨胀
         _rotate_error_logs(log_dir)
 

package/core/audio/tts.py

@@ -12,6 +12,8 @@ from typing import Optional, Tuple
 import edge_tts
 
 from core.async_io import async_open
+from core.compositor.ffmpeg_tool import resolve_binary
+from core.i18n_backend import translate
 
 logger = logging.getLogger(__name__)
 
@@ -171,9 +173,15 @@ class SilentTTSEngine(TTSEngine):
 
         os.makedirs(os.path.dirname(output_path) or ".", exist_ok=True)
 
+        # 统一解析 ffmpeg 路径（Issue #78）：裸 "ffmpeg" 在无系统 ffmpeg 的
+        # Windows 上会让 CreateProcess 抛 [WinError 2]，且错误信息完全不可读
+        ffmpeg = resolve_binary("ffmpeg")
+        if not ffmpeg:
+            raise RuntimeError(translate("error.ffmpeg_missing"))
+
         # 使用 ffmpeg 生成静音音频
         proc = await asyncio.create_subprocess_exec(
-            "ffmpeg", "-y",
+            ffmpeg, "-y",
             "-f", "lavfi",
             "-i", "anullsrc=r=44100:cl=mono",
             "-t", str(duration_sec),

package/core/compositor/ffmpeg_tool.py

@@ -15,7 +15,9 @@
 """
 import logging
 import os
+import re
 import shutil
+import subprocess
 
 logger = logging.getLogger(__name__)
 
@@ -52,6 +54,153 @@ def resolve_ffprobe() -> "str | None":
     return resolve_binary("ffprobe")
 
 
+def probe_duration(path: str, default: float = 0.0) -> float:
+    """探测媒体时长（秒），三级兜底，**永不抛异常**。
+
+    背景（Issue #78）：此前多处探测用裸 ``["ffprobe", ...]`` 直接交给
+    ``subprocess.run``，在只带 imageio-ffmpeg 内置二进制（无 ffprobe）的环境里
+    要么抛异常被静默吞掉、要么把 ``None`` 塞进命令行，最终统一降级为 0.0/None，
+    连「ffmpeg 可用时的兜底探测」也没有。此处按可用性依次尝试：
+
+    1. ``ffprobe``（解析到真实路径时才用）；
+    2. ``ffmpeg -i`` 的 stderr ``Duration:`` 行（ffmpeg 为硬依赖，必有兜底）；
+    3. 调用方给定的 ``default``。
+
+    Args:
+        path: 媒体文件路径。
+        default: 全部探测失败时返回的兜底值（秒）。
+
+    Returns:
+        时长（秒）；无法探测时返回 ``default``。
+    """
+    if not path or not os.path.exists(path):
+        return default
+
+    ffprobe = resolve_binary("ffprobe")
+    if ffprobe:
+        try:
+            r = subprocess.run(
+                [ffprobe, "-v", "error", "-show_entries", "format=duration",
+                 "-of", "default=noprint_wrappers=1:nokey=1", path],
+                stdin=subprocess.DEVNULL, capture_output=True, text=True, timeout=15,
+            )
+            val = float((r.stdout or "").strip() or 0)
+            if val > 0:
+                return val
+        except Exception as e:
+            logger.warning(f"[Compositor] ffprobe duration failed: {e}")
+
+    ffmpeg = resolve_binary("ffmpeg")
+    if ffmpeg:
+        try:
+            r = subprocess.run(
+                [ffmpeg, "-hide_banner", "-i", path],
+                stdin=subprocess.DEVNULL, capture_output=True, text=True, timeout=15,
+            )
+            m = re.search(
+                r"Duration:\s*(\d+):(\d+):(\d+(?:\.\d+)?)", r.stderr or ""
+            )
+            if m:
+                h, mi, s = m.groups()
+                val = int(h) * 3600 + int(mi) * 60 + float(s)
+                if val > 0:
+                    logger.info(
+                        f"[Compositor] duration via ffmpeg fallback: {val:.2f}s ({path})"
+                    )
+                    return val
+        except Exception as e:
+            logger.warning(f"[Compositor] ffmpeg duration probe failed: {e}")
+
+    logger.warning(f"[Compositor] duration probe unavailable for {path}, using default {default}")
+    return default
+
+
+def has_audio_stream(path: str) -> bool:
+    """检测媒体容器是否含音频流（Issue #78：不再依赖裸 ffprobe）。
+
+    优先 ``ffprobe -select_streams a``；ffprobe 不可用时回退解析
+    ``ffmpeg -i`` 的 stderr 流信息（``Stream #0:1: Audio: ...``）。
+    两者都不可用或探测异常时返回 ``False``（调用方按「无音频」保守处理）。
+
+    Args:
+        path: 媒体文件路径。
+
+    Returns:
+        含音频流返回 True。
+    """
+    if not path or not os.path.exists(path):
+        return False
+
+    ffprobe = resolve_binary("ffprobe")
+    if ffprobe:
+        try:
+            r = subprocess.run(
+                [ffprobe, "-v", "error", "-select_streams", "a",
+                 "-show_entries", "stream=codec_type", "-of", "csv=p=0", path],
+                stdin=subprocess.DEVNULL, capture_output=True, text=True, timeout=15,
+            )
+            if r.returncode == 0:
+                return "audio" in (r.stdout or "")
+        except Exception as e:
+            logger.warning(f"[Compositor] ffprobe audio-stream probe failed: {e}")
+
+    ffmpeg = resolve_binary("ffmpeg")
+    if ffmpeg:
+        try:
+            r = subprocess.run(
+                [ffmpeg, "-hide_banner", "-i", path],
+                stdin=subprocess.DEVNULL, capture_output=True, text=True, timeout=15,
+            )
+            if re.search(r"Stream #\S+.*?: Audio:", r.stderr or ""):
+                return True
+        except Exception as e:
+            logger.warning(f"[Compositor] ffmpeg audio-stream probe failed: {e}")
+
+    return False
+
+
+def probe_video_dimensions(path: str) -> "tuple[int | None, int | None]":
+    """探测视频宽高（像素），失败返回 ``(None, None)``（Issue #78）。
+
+    优先 ``ffprobe`` JSON 输出；ffprobe 不可用时回退解析 ``ffmpeg -i``
+    stderr 里的 ``768x1152`` 分辨率描述。
+    """
+    if not path or not os.path.exists(path):
+        return None, None
+
+    ffprobe = resolve_binary("ffprobe")
+    if ffprobe:
+        try:
+            r = subprocess.run(
+                [ffprobe, "-v", "quiet", "-print_format", "json",
+                 "-show_streams", path],
+                stdin=subprocess.DEVNULL, capture_output=True, text=True, timeout=30,
+            )
+            import json
+            info = json.loads(r.stdout or "{}")
+            for s in info.get("streams", []):
+                if s.get("codec_type") == "video":
+                    return s.get("width"), s.get("height")
+        except Exception as e:
+            logger.warning(f"[Compositor] ffprobe size probe failed: {e}")
+
+    ffmpeg = resolve_binary("ffmpeg")
+    if ffmpeg:
+        try:
+            r = subprocess.run(
+                [ffmpeg, "-hide_banner", "-i", path],
+                stdin=subprocess.DEVNULL, capture_output=True, text=True, timeout=30,
+            )
+            m = re.search(r"Video:.*?(\d{2,5})x(\d{2,5})", r.stderr or "")
+            if m:
+                return int(m.group(1)), int(m.group(2))
+        except Exception as e:
+            logger.warning(f"[Compositor] ffmpeg size probe failed: {e}")
+
+    logger.warning(f"[Compositor] cannot detect dimensions: {path}")
+    return None, None
+
+
 def _resolve(name: str) -> "str | None":
     # 1) 显式指定
     override = os.environ.get(_EXE_OVERRIDE[name])
@@ -99,4 +248,35 @@ def _sibling(exe: str, stem: str) -> "str | None":
     candidate = os.path.join(
         os.path.dirname(exe), stem + (".exe" if os.name == "nt" else "")
     )
-    return candidate if os.path.exists(candidate) else None
+    return candidate if os.path.exists(candidate) else None
+
+
+def resolve_cmd_binary(cmd: list) -> list:
+    """把命令列表首元素里的裸 ``ffmpeg`` / ``ffprobe`` 替换为解析后的绝对路径。
+
+    Issue #78：多处调用方按 ``["ffmpeg", "-y", ...]`` 拼命令，未统一走
+    ``resolve_binary``。传入本函数后：
+
+    - 首元素是 ``ffmpeg`` / ``ffprobe``（含带路径后缀的写法）→ 替换为真实路径；
+    - 解析不到可执行文件 → 抛 ``RuntimeError``（i18n 文案），而非在下游
+      抛不可读的 ``[WinError 2]`` / ``FileNotFoundError``；
+    - 其他命令（首元素非 ffmpeg 系）原样返回，不做任何假设。
+
+    Args:
+        cmd: 原始命令列表。
+
+    Returns:
+        处理后的命令列表（新列表，不修改入参）。
+    """
+    if not cmd:
+        return cmd
+    head = os.path.basename(str(cmd[0]))
+    stem = os.path.splitext(head)[0].lower()
+    if stem not in _EXE_OVERRIDE:
+        return cmd
+    resolved = resolve_binary(stem)
+    if not resolved:
+        from core.i18n_backend import translate
+
+        raise RuntimeError(translate("error.ffmpeg_missing"))
+    return [resolved, *cmd[1:]]

package/core/compositor/watermark.py

@@ -11,7 +11,7 @@ import subprocess
 import tempfile
 from typing import NamedTuple, Optional
 
-from core.compositor.ffmpeg_tool import resolve_binary
+from core.compositor.ffmpeg_tool import probe_video_dimensions, resolve_binary
 from core.config import resolve_font_path
 
 logger = logging.getLogger(__name__)
@@ -62,19 +62,8 @@ def _build_watermark_text(language: str) -> str:
 
 
 def _get_video_dimensions(input_path: str) -> tuple:
-    try:
-        result = subprocess.run(
-            ["ffprobe", "-v", "quiet", "-print_format", "json",
-             "-show_streams", input_path],
-            capture_output=True, text=True, timeout=30,
-        )
-        info = __import__('json').loads(result.stdout)
-        for s in info.get("streams", []):
-            if s.get("codec_type") == "video":
-                return s["width"], s["height"]
-    except Exception:
-        pass
-    return None, None
+    """探测视频宽高；Issue #78：统一走 ffmpeg_tool（ffprobe → ffmpeg 兜底）。"""
+    return probe_video_dimensions(input_path)
 
 
 def _render_watermark_png(

package/core/config.py

@@ -18,7 +18,7 @@ CONFIG_FILE = os.path.join(CONFIG_DIR, "config.json")
 # ═══════════════════════════════════════════════════
 # 应用版本号（v6.1 新增：发版时同步更新，见 docs/dev/release_process.md）
 # ═══════════════════════════════════════════════════
-APP_VERSION = "7.0.3"
+APP_VERSION = "7.0.5"
 
 # 未配置 API Key 时的统一报错文案（含免费获取与在线体验兜底，全站路由共用）
 #

package/core/i18n_backend.py

@@ -247,6 +247,21 @@ CATALOG: Dict[str, Dict[str, str]] = {
         "en": "the Agnes service domain",
     },
 
+    # ── ffmpeg 缺失（core/audio/tts.py::SilentTTSEngine，Issue #78）──
+    "error.ffmpeg_missing": {
+        "zh": (
+            "未找到可用的 ffmpeg 可执行文件，无法生成音频/视频文件。"
+            "请安装 ffmpeg（Windows 可执行 winget install Gyan.FFmpeg）并确保它在 PATH 中，"
+            "或通过环境变量 FFMPEG_BINARY 指定其绝对路径，然后重试任务。"
+        ),
+        "en": (
+            "No usable ffmpeg executable was found, so audio/video files cannot be produced. "
+            "Please install ffmpeg (on Windows: winget install Gyan.FFmpeg), make sure it is on "
+            "your PATH, or point the FFMPEG_BINARY environment variable at its absolute path, "
+            "then retry the task."
+        ),
+    },
+
     # ── API Key 缺失（core/config.py::API_KEY_MISSING_MSG 的替代）──
     "config.api_key_missing": {
         "zh": (

package/core/pipelines/__init__.py

@@ -9,7 +9,6 @@ import functools
 import json
 import logging
 import os
-import subprocess
 import time
 from abc import ABC, abstractmethod
 from types import SimpleNamespace
@@ -25,6 +24,7 @@ _ENCODING_EXECUTOR = concurrent.futures.ThreadPoolExecutor(
 )
 
 from core.async_io import read_text, write_text
+from core.compositor.ffmpeg_tool import probe_duration, resolve_cmd_binary
 from core.compositor.watermark import add_watermark, detect_language
 from core.config import get_watermark_config
 from core.i18n_backend import translate
@@ -517,21 +517,16 @@ class BasePipeline(ABC):
 
     @staticmethod
     def get_audio_duration(audio_path: str) -> float:
-        """通过 ffprobe 获取音频文件时长（秒），失败返回 0.0。"""
+        """获取音频文件时长（秒），失败返回 0.0。
+
+        Issue #78：改用 ``ffmpeg_tool.probe_duration`` 统一解析可执行文件，
+        ffprobe 缺失时回退 ffmpeg stderr 解析，不再静默降级为 0.0。
+        """
         if not audio_path or not os.path.exists(audio_path):
             return 0.0
         if os.path.getsize(audio_path) == 0:
             return 0.0
-        try:
-            r = subprocess.run(
-                ["ffprobe", "-v", "error", "-show_entries", "format=duration",
-                 "-of", "csv=p=0", audio_path],
-                stdin=subprocess.DEVNULL,
-                capture_output=True, text=True, timeout=15,
-            )
-            return float(r.stdout.strip())
-        except Exception:
-            return 0.0
+        return probe_duration(audio_path, default=0.0)
 
     async def generate_subtitles_common(
         self,
@@ -947,7 +942,12 @@ class BasePipeline(ABC):
 
     @staticmethod
     async def run_ffmpeg_async(cmd: List[str], timeout: float = 30.0) -> None:
-        """异步执行 ffmpeg 命令（不阻塞事件循环）。等价于 subprocess.run(check=True)。"""
+        """异步执行 ffmpeg 命令（不阻塞事件循环）。等价于 subprocess.run(check=True)。
+
+        Issue #78：命令首元素为 ``"ffmpeg"``/``"ffprobe"`` 时统一解析为真实路径，
+        避免在无系统 ffmpeg 的环境里抛裸 ``[WinError 2]``。
+        """
+        cmd = resolve_cmd_binary(cmd)
         proc = await asyncio.create_subprocess_exec(
             *cmd,
             stdout=asyncio.subprocess.PIPE,

package/core/pipelines/creative/steps_frames.py

@@ -6,6 +6,7 @@ import os
 import re
 from typing import List, Optional
 
+from core.compositor.ffmpeg_tool import resolve_cmd_binary
 from core.pipelines import PipelineShutdown
 from models.task import StepStatus
 from utils.image_normalizer import PAD, normalize_image_async
@@ -52,6 +53,7 @@ async def _run_ffmpeg_async(cmd: List[str], timeout: float = 30.0) -> None:
         RuntimeError: ffmpeg 退出码非 0（等价原 ``check=True`` 语义）。
         asyncio.TimeoutError: 超时。
     """
+    cmd = resolve_cmd_binary(cmd)
     proc = await asyncio.create_subprocess_exec(
         *cmd,
         stdout=asyncio.subprocess.PIPE,

package/core/pipelines/poetry_video.py

@@ -19,6 +19,7 @@ from core.api.agnes_video import AgnesVideoAPI
 from core.audio.subtitle import SubtitleGenerator
 from core.audio.tts import SilentTTSEngine
 from core.compositor.concatenator import VideoConcatenator
+from core.compositor.ffmpeg_tool import has_audio_stream, probe_duration
 from core.config import DEFAULT_TEXT_MODEL
 from core.pipelines import MultiScenePipeline
 from core.screenwriter import Screenwriter, clean_narration_text
@@ -268,8 +269,6 @@ class PoetryVideoPipeline(MultiScenePipeline):
         可能提前截断（仅前半段有声音、后半段丢失且不抛异常）。
         因此每个场景间加入延迟，并在生成后校验音频时长。
         """
-        import subprocess as _sp
-
         scenes = self._state.scenes
         audio_config = self._state.audio_config
         has_audio = audio_config.enabled
@@ -333,7 +332,7 @@ class PoetryVideoPipeline(MultiScenePipeline):
 
             # 时长校验（仅真实 EdgeTTS 产物）：实际时长不足预期 60% → 删除 + Silent 重生成
             if has_audio:
-                actual_dur = self._probe_duration(audio_path, _sp)
+                actual_dur = self._probe_duration(audio_path)
                 if actual_dur is not None and actual_dur < min_dur * 0.6:
                     logger.warning(
                         f"[Poetry] scene {idx} audio incomplete "
@@ -355,38 +354,22 @@ class PoetryVideoPipeline(MultiScenePipeline):
         return None
 
     @staticmethod
-    def _probe_duration(filepath: str, _sp=None) -> Optional[float]:
-        """ffprobe 获取音频时长（秒），失败返回 None。"""
-        try:
-            if _sp is None:
-                import subprocess as _sp2
-                _sp = _sp2
-            proc = _sp.run(
-                ["ffprobe", "-v", "error", "-show_entries",
-                 "format=duration", "-of", "default=noprint_wrappers=1:nokey=1",
-                 filepath],
-                capture_output=True, text=True, timeout=10,
-            )
-            if proc.returncode == 0 and proc.stdout.strip():
-                return float(proc.stdout.strip())
-        except Exception:
-            pass
-        return None
+    def _probe_duration(filepath: str) -> Optional[float]:
+        """获取音频时长（秒），失败返回 None。
+
+        Issue #78：改走 ``ffmpeg_tool.probe_duration``（ffprobe → ffmpeg 兜底），
+        不再因 ffprobe 缺失而静默返回 None。
+        """
+        val = probe_duration(filepath, default=0.0)
+        return val if val > 0 else None
 
     @staticmethod
     def _has_audio_stream(filepath: str) -> bool:
-        """ffprobe 检测视频文件是否包含音频流（防止复用不完整合成产物）。"""
-        try:
-            import subprocess as _sp
-            proc = _sp.run(
-                ["ffprobe", "-v", "error", "-select_streams", "a",
-                 "-show_entries", "stream=codec_type", "-of", "csv=p=0",
-                 filepath],
-                capture_output=True, text=True, timeout=10,
-            )
-            return "audio" in proc.stdout
-        except Exception:
-            return False
+        """检测视频文件是否包含音频流（防止复用不完整合成产物）。
+
+        Issue #78：改走 ``ffmpeg_tool.has_audio_stream``（ffprobe → ffmpeg 兜底）。
+        """
+        return has_audio_stream(filepath)
 
     # ------------------------------------------------------------------
     # Phase 5: 字幕（逐场景 SRT，定时对齐朗诵）

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "free-short-video",
-  "version": "7.0.3",
+  "version": "7.0.5",
   "description": "Free AI short-video generator — run the full free-short-video service locally with one command. Text-to-video, image generation, Edge-TTS narration, subtitles, and compositing, all free. Official site: https://video.lichuanyang.top",
   "bin": {
     "free-short-video": "bin/cli.js",