Fix screen-recording capture on macOS without Homebrew ffmpeg

The user's "EE4802 screen recording not captured" bug wasn't in the
download path — it was in frame_extractor.py, which still used bare
"ffmpeg" and "ffprobe" subprocess literals. On macOS users whose only
ffmpeg comes from the imageio-ffmpeg wheel (which doesn't ship ffprobe),
every scene-detection / frame-extraction call silently FileNotFoundError'd.
The output PNG never appeared, so the video got classified as "camera"
(no frames = default), screen-recording frame extraction was skipped, and
notes ended up with no slide content.

frame_extractor.py:
- Add _resolve_ffmpeg() / _resolve_ffprobe() / _parse_ffmpeg_duration(),
  mirroring the resolver introduced in extract_caption.py for issue #7.
- Cache resolved paths at module level (hot path: one call per scene frame).
- Replace all 4 "ffmpeg" and 1 "ffprobe" literals with resolved paths.
- get_video_duration falls back to parsing ffmpeg stderr when ffprobe absent.

downloader.py (_run_ffmpeg_hls hardening):
- Add -y flag (idempotent against stale partial files).
- Add -loglevel error + -map 0 (keep all selected-variant streams).
- Check output-file size after FfmpegProgress run — progress library
  doesn't raise on non-zero exit, so a silent failure would otherwise
  write a 0-byte mp4 that downstream stages mangled.
- Surface last 10 lines of stderr when returncode != 0 in the
  no-progress-library fallback.

test/test_v0_12_fixes.py: +15 tests (now 65 total)
- Frame-extractor resolver coverage (cache, system/imageio fallback, errors).
- get_video_duration cross-validation (both paths agree, zero on garbage).
- _run_ffmpeg_hls hardening (raises on missing/tiny output, -y presence,
  stderr surfaced on non-zero exit).
- Source scan asserts no bare ["ffmpeg", ...] / ["ffprobe", ...] launch
  lists remain in frame_extractor.py.

Release: v0.12.10.

Author: nodeeeeee

downloader.py

@@ -946,6 +946,12 @@ def _run_ffmpeg_hls(stream_url: str, out_path: Path, progress_cb) -> None:
 
     Uses the bundled `imageio-ffmpeg` binary when no system ffmpeg is
     present, so macOS users without Homebrew get a working downloader.
+
+    Dropping `-f hls` lets ffmpeg auto-detect from the URL — this is more
+    robust when the master playlist references a mixed-protocol variant set.
+    `-map 0` keeps all streams from the selected variant (video + audio).
+    Non-zero exit codes are surfaced as RuntimeError so partial/empty files
+    don't silently get written to disk.
     """
     ff_bin = _resolve_ffmpeg()
     if not ff_bin:
@@ -954,17 +960,40 @@ def _run_ffmpeg_hls(stream_url: str, out_path: Path, progress_cb) -> None:
             "macOS or `choco install ffmpeg` on Windows), or `pip install "
             "imageio-ffmpeg` for a bundled fallback."
         )
-    cmd = [ff_bin, "-f", "hls", "-i", stream_url, "-c", "copy", str(out_path)]
+    # -y            : overwrite partial leftovers from a prior failed attempt
+    # -loglevel error: only surface real errors (progress plugin reads stderr)
+    # -map 0        : keep every stream of the selected variant (a/v)
+    # -c copy       : no re-encoding; lossless + fast
+    cmd = [
+        ff_bin, "-y", "-loglevel", "error",
+        "-i", stream_url,
+        "-map", "0",
+        "-c", "copy",
+        str(out_path),
+    ]
     try:
         from ffmpeg_progress_yield import FfmpegProgress
         ff = FfmpegProgress(cmd)
         for pct in ff.run_command_with_progress():
             progress_cb(pct)
+        # FfmpegProgress doesn't raise on non-zero exit; inspect the
+        # resulting file to catch silent failures.
+        if not out_path.exists() or out_path.stat().st_size < 1024:
+            raise RuntimeError(
+                f"ffmpeg produced no output for {out_path.name} — "
+                f"check network connectivity or stream auth."
+            )
     except ImportError:
-        import subprocess
         tqdm.write("  (ffmpeg-progress-yield not available, running ffmpeg without progress)")
-        cmd_y = [ff_bin, "-y", "-f", "hls", "-i", stream_url, "-c", "copy", str(out_path)]
-        subprocess.run(cmd_y, capture_output=True, timeout=3600)
+        result = subprocess.run(
+            cmd, capture_output=True, text=True, timeout=3600,
+        )
+        if result.returncode != 0:
+            tail = (result.stderr or "").strip().splitlines()[-10:]
+            raise RuntimeError(
+                f"ffmpeg failed (exit {result.returncode}):\n"
+                + "\n".join(tail)
+            )
         progress_cb(100)
 
 

electron/package.json

@@ -1,6 +1,6 @@
 {
   "name": "auto-note",
-  "version": "0.12.9",
+  "version": "0.12.10",
   "description": "AutoNote — lecture notes generator from Canvas recordings",
   "homepage": "https://github.com/nodeeeeee/Auto-Note",
   "author": {

frame_extractor.py

@@ -43,6 +43,97 @@
 # Prevent console windows flashing on Windows
 _SUBPROCESS_FLAGS = subprocess.CREATE_NO_WINDOW if sys.platform == "win32" else 0
 
+
+# ── ffmpeg/ffprobe resolution ─────────────────────────────────────────────────
+# macOS users without Homebrew get ffmpeg via the `imageio-ffmpeg` wheel, which
+# does NOT ship `ffprobe`. Without these resolvers, every subprocess call below
+# raised FileNotFoundError and produced zero frames — silently, because the
+# code only checks whether the output PNG exists afterwards. That turned into
+# "screen recording not captured" in generated notes on EE4802 test runs.
+
+_FFMPEG_BIN: str | None = None
+_FFPROBE_BIN: str | None = None  # None sentinel means "resolved; unavailable"
+_FFPROBE_RESOLVED = False
+
+
+def _resolve_ffmpeg() -> str:
+    """Locate an ffmpeg executable.
+
+    Order: system PATH → imageio-ffmpeg bundled binary → auto-install. Raises
+    RuntimeError if none works. Result is cached so resolution cost is paid
+    once per process.
+    """
+    global _FFMPEG_BIN
+    if _FFMPEG_BIN:
+        return _FFMPEG_BIN
+
+    from shutil import which
+    sys_ff = which("ffmpeg")
+    if sys_ff:
+        _FFMPEG_BIN = sys_ff
+        return sys_ff
+
+    def _try_imageio() -> str | None:
+        try:
+            import imageio_ffmpeg
+            return imageio_ffmpeg.get_ffmpeg_exe()
+        except ImportError:
+            return None
+        except Exception as e:
+            print(f"  [warn] imageio-ffmpeg get_ffmpeg_exe failed: {e}")
+            return None
+
+    ff = _try_imageio()
+    if ff:
+        _FFMPEG_BIN = ff
+        return ff
+
+    print("  ffmpeg not found locally — installing imageio-ffmpeg fallback…")
+    try:
+        subprocess.run(
+            [sys.executable, "-m", "pip", "install", "--quiet",
+             "--disable-pip-version-check", "imageio-ffmpeg"],
+            check=True, timeout=180,
+        )
+    except Exception as e:
+        raise RuntimeError(f"ffmpeg unavailable and auto-install failed: {e}") from e
+
+    ff = _try_imageio()
+    if not ff:
+        raise RuntimeError("ffmpeg unavailable after imageio-ffmpeg install")
+    _FFMPEG_BIN = ff
+    return ff
+
+
+def _resolve_ffprobe() -> str | None:
+    """Locate ffprobe on system PATH. Returns None when unavailable.
+
+    imageio-ffmpeg doesn't bundle ffprobe, so when only it is available we
+    fall back to parsing `ffmpeg -i` stderr for duration.
+    """
+    global _FFPROBE_BIN, _FFPROBE_RESOLVED
+    if _FFPROBE_RESOLVED:
+        return _FFPROBE_BIN
+    from shutil import which
+    _FFPROBE_BIN = which("ffprobe")
+    _FFPROBE_RESOLVED = True
+    return _FFPROBE_BIN
+
+
+_DURATION_RE = re.compile(r"Duration:\s*(\d+):(\d+):(\d+(?:\.\d+)?)")
+
+
+def _parse_ffmpeg_duration(stderr: str | None) -> float | None:
+    """Parse 'Duration: HH:MM:SS.ss' from ffmpeg -i stderr."""
+    if not stderr:
+        return None
+    m = _DURATION_RE.search(stderr)
+    if not m:
+        return None
+    h, mi, s = m.group(1), m.group(2), m.group(3)
+    return int(h) * 3600 + int(mi) * 60 + float(s)
+
+
 # ── Tunable constants ────────────────────────────────────────────────────────
 
 # Scene detection threshold: lower = more sensitive (more frames extracted).
@@ -115,10 +206,11 @@ def classify_video(video_path: Path) -> str:
 
     tmp_dir = Path(tempfile.mkdtemp(prefix="classify_"))
     frame_paths = []
+    ff_bin = _resolve_ffmpeg()
     for i, ts in enumerate(timestamps):
         png = tmp_dir / f"sample_{i}.png"
         subprocess.run(
-            ["ffmpeg", "-ss", f"{ts:.1f}", "-i", str(video_path),
+            [ff_bin, "-ss", f"{ts:.1f}", "-i", str(video_path),
              "-frames:v", "1", "-q:v", "2", str(png), "-y"],
             capture_output=True, timeout=30,
             creationflags=_SUBPROCESS_FLAGS,
@@ -287,8 +379,9 @@ def detect_scenes(video_path: Path, threshold: float = SCENE_THRESHOLD,
         always_periodic = False
 
     # ── Pass 1: ffmpeg scene detection ───────────────────────────────────────
+    ff_bin = _resolve_ffmpeg()
     cmd = [
-        "ffmpeg", "-i", str(video_path),
+        ff_bin, "-i", str(video_path),
         "-vf", f"select='gt(scene\\,{threshold})',showinfo",
         "-vsync", "vfr",
         "-f", "null", "-"
@@ -348,7 +441,7 @@ def detect_scenes(video_path: Path, threshold: float = SCENE_THRESHOLD,
         for ts in raw_timestamps[:MAX_FRAMES * 2]:
             png = tmp_dir / f"cand_{ts:.1f}.png"
             subprocess.run(
-                ["ffmpeg", "-ss", f"{ts:.3f}", "-i", str(video_path),
+                [ff_bin, "-ss", f"{ts:.3f}", "-i", str(video_path),
                  "-frames:v", "1", "-q:v", "3", str(png), "-y"],
                 capture_output=True, timeout=30,
                 creationflags=_SUBPROCESS_FLAGS,
@@ -409,19 +502,37 @@ def detect_scenes(video_path: Path, threshold: float = SCENE_THRESHOLD,
 
 
 def get_video_duration(video_path: Path) -> float:
-    """Get video duration in seconds using ffprobe."""
-    cmd = [
-        "ffprobe", "-v", "quiet", "-show_entries", "format=duration",
-        "-of", "default=noprint_wrappers=1:nokey=1", str(video_path)
-    ]
+    """Return video duration in seconds.
+
+    Uses ffprobe when available, falls back to parsing ffmpeg's stderr
+    ('Duration: HH:MM:SS.ss'). The fallback is the path macOS users hit
+    when they only have the imageio-ffmpeg wheel — which bundles ffmpeg
+    but not ffprobe.
+    """
+    ffprobe = _resolve_ffprobe()
+    if ffprobe:
+        result = subprocess.run(
+            [ffprobe, "-v", "quiet", "-show_entries", "format=duration",
+             "-of", "default=noprint_wrappers=1:nokey=1", str(video_path)],
+            capture_output=True, text=True, timeout=30,
+            creationflags=_SUBPROCESS_FLAGS,
+        )
+        try:
+            return float(result.stdout.strip())
+        except (ValueError, AttributeError):
+            return 0.0
+
+    try:
+        ff = _resolve_ffmpeg()
+    except RuntimeError:
+        return 0.0
     result = subprocess.run(
-        cmd, capture_output=True, text=True, timeout=30,
+        [ff, "-hide_banner", "-i", str(video_path)],
+        capture_output=True, text=True, timeout=30,
         creationflags=_SUBPROCESS_FLAGS,
     )
-    try:
-        return float(result.stdout.strip())
-    except (ValueError, AttributeError):
-        return 0.0
+    dur = _parse_ffmpeg_duration(result.stderr)
+    return dur if dur is not None else 0.0
 
 
 # ── Per-frame screen/camera classification ────────────────────────────────────
@@ -658,7 +769,7 @@ def extract_frames(video_path: Path, timestamps: list[float],
             continue
 
         cmd = [
-            "ffmpeg", "-ss", f"{ts:.3f}",
+            _resolve_ffmpeg(), "-ss", f"{ts:.3f}",
             "-i", str(video_path),
             "-frames:v", "1",
             "-q:v", "2",