free-short-video 7.0.4 → 7.0.5

package/README.md

@@ -1,25 +1,21 @@
 ---
 
-# What's New in v7.0.4
+# What's New in v7.0.5
 
 ## What's New
 
 ### Features & Improvements
 
-* **Upstream API error trends.** Errors that carry an HTTP status code are now aggregated per task — by status code, model type (chat / image / video) and API method — and returned by the task detail API. The frontend reports them anonymously as `api_error` events, and task-failure / creation-failure events now carry the extracted status code as well, so recurring upstream failures (for example `503 video_queue_full`) can be tracked as a trend over time instead of being seen as unrelated single errors. The aggregation lives in memory for the lifetime of the task and is cleared with it; `error_logs/` remains the offline source of truth.
-* **Honest "not ready yet" state while polling.** A transient `404` while waiting for a submitted video is now an expected intermediate state rather than an error. It no longer consumes the consecutive-failure budget and no longer gets flushed into `error_logs`, so the failure panel and the logs stop reporting failures for tasks that were in fact still queued upstream.
-
-### Refactoring & Optimizations
-
-* Regression coverage for the upstream error-handling path: consecutive `404`s followed by a successful completion, and a permanent `404` that correctly falls back to the overall polling timeout.
+* **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
 
-* Fixed video tasks failing with a spurious error when the upstream gateway had not made the task record visible yet — a state observed for 420s and even 1100s+ under peak load. The overall polling timeout stays as the final backstop, and it keeps the `video_id` so the task can be resumed rather than reported as a server-confirmed failure.
+* **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 a task still fails, the failure panel now shows the real upstream reason with its HTTP status code, and repeated upstream errors of the same kind become visible as a trend.
+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/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.4"
+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.4",
+  "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",