release: promote release/0.5.x to main for v0.5.11

CHANGELOG.md

@@ -5,6 +5,18 @@ All notable changes to the Fovea project will be documented in this file.
 The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.1.0/),
 and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
 
+## [0.5.11] - 2026-07-02
+
+The 0.5.11 patch is the third and final release remediating the second swarm audit — the model-service slice — fixing event-loop starvation, ffmpeg subprocess leaks, a shared-model inference race, and a DNS-rebinding SSRF gap in the Python inference service ([#198](https://github.com/parafovea/fovea/pull/198)). Nothing is breaking. This completes the second-audit three-patch series (0.5.9 backend, 0.5.10 frontend, 0.5.11 model-service).
+
+### Fixed
+
+- The summarize-with-audio pipeline ran Whisper transcription and pyannote diarization directly on the asyncio event loop — the 0.5.8 offload reached the standalone `/transcribe` and `/diarize` routes and the VLM path but missed the summarizer's own audio path — so a `POST /summarize` with audio froze the `/health` probe, metric export, and every concurrent request for the tens of seconds to minutes the inference took. The load/transcribe/diarize/unload sequence now runs on a worker thread via `asyncio.to_thread` (`model-service/src/infrastructure/adapters/outbound/transcriber_whisper.py`).
+- Two ffmpeg extraction helpers on the transcription hot path (`extract_audio_track`, `extract_audio_segment`) awaited a timeout that cancelled only the coroutine, leaving the ffmpeg child running as an orphan; they now go through the shared kill-and-reap helper so the timeout path terminates and reaps the subprocess (`model-service/src/application/services/audio_processing.py`).
+- The video processor's `extract_audio` and `extract_thumbnail` awaited ffmpeg with no timeout at all, so a malformed or truncated video could wedge the request forever and leak the child; both now use a bounded timeout that kills and reaps on expiry (`model-service/src/infrastructure/adapters/outbound/video/processor.py`).
+- The standalone transcribe and diarize routes fetched the single cached model instance and ran its native inference in a worker thread with no serialization, so two concurrent requests called the same non-thread-safe object (faster-whisper / pyannote) at once, risking garbled output or a crash inside the native code. Inference is now serialized per task type by an `asyncio.Lock`, while distinct tasks still run in parallel (`model-service/src/infrastructure/adapters/inbound/fastapi/routes/transcribe.py`, `diarize.py`, `inference_locks.py`).
+- The video downloader's SSRF allow-list resolved the host and required a public IP but then fetched by hostname, so DNS could be rebound between the check and the connect (a TOCTOU). The connection is now pinned to the address vetted during preflight while still presenting the hostname for TLS, so a rebind cannot redirect it to a private or internal host (`model-service/src/infrastructure/adapters/outbound/video/downloader.py`).
+
 ## [0.5.10] - 2026-07-01
 
 The 0.5.10 patch is the second of three releases remediating the second swarm audit — the frontend slice — fixing auto-save data-loss and stale-cache defects in the annotation UI ([#196](https://github.com/parafovea/fovea/pull/196)). Several were gaps in the first audit's own frontend fixes, which closed one instance of a defect class without closing every instance. Nothing is breaking.

annotation-tool/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@fovea/annotation-tool",
   "private": true,
-  "version": "0.5.10",
+  "version": "0.5.11",
   "type": "module",
   "scripts": {
     "dev": "vite",

docs/docs/project/changelog.md

@@ -11,6 +11,18 @@ All notable changes to the Fovea project will be documented in this file.
 The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.1.0/),
 and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
 
+## [0.5.11] - 2026-07-02
+
+The 0.5.11 patch is the third and final release remediating the second swarm audit — the model-service slice — fixing event-loop starvation, ffmpeg subprocess leaks, a shared-model inference race, and a DNS-rebinding SSRF gap in the Python inference service ([#198](https://github.com/parafovea/fovea/pull/198)). Nothing is breaking. This completes the second-audit three-patch series (0.5.9 backend, 0.5.10 frontend, 0.5.11 model-service).
+
+### Fixed
+
+- The summarize-with-audio pipeline ran Whisper transcription and pyannote diarization directly on the asyncio event loop — the 0.5.8 offload reached the standalone `/transcribe` and `/diarize` routes and the VLM path but missed the summarizer's own audio path — so a `POST /summarize` with audio froze the `/health` probe, metric export, and every concurrent request for the tens of seconds to minutes the inference took. The load/transcribe/diarize/unload sequence now runs on a worker thread via `asyncio.to_thread` (`model-service/src/infrastructure/adapters/outbound/transcriber_whisper.py`).
+- Two ffmpeg extraction helpers on the transcription hot path (`extract_audio_track`, `extract_audio_segment`) awaited a timeout that cancelled only the coroutine, leaving the ffmpeg child running as an orphan; they now go through the shared kill-and-reap helper so the timeout path terminates and reaps the subprocess (`model-service/src/application/services/audio_processing.py`).
+- The video processor's `extract_audio` and `extract_thumbnail` awaited ffmpeg with no timeout at all, so a malformed or truncated video could wedge the request forever and leak the child; both now use a bounded timeout that kills and reaps on expiry (`model-service/src/infrastructure/adapters/outbound/video/processor.py`).
+- The standalone transcribe and diarize routes fetched the single cached model instance and ran its native inference in a worker thread with no serialization, so two concurrent requests called the same non-thread-safe object (faster-whisper / pyannote) at once, risking garbled output or a crash inside the native code. Inference is now serialized per task type by an `asyncio.Lock`, while distinct tasks still run in parallel (`model-service/src/infrastructure/adapters/inbound/fastapi/routes/transcribe.py`, `diarize.py`, `inference_locks.py`).
+- The video downloader's SSRF allow-list resolved the host and required a public IP but then fetched by hostname, so DNS could be rebound between the check and the connect (a TOCTOU). The connection is now pinned to the address vetted during preflight while still presenting the hostname for TLS, so a rebind cannot redirect it to a private or internal host (`model-service/src/infrastructure/adapters/outbound/video/downloader.py`).
+
 ## [0.5.10] - 2026-07-01
 
 The 0.5.10 patch is the second of three releases remediating the second swarm audit — the frontend slice — fixing auto-save data-loss and stale-cache defects in the annotation UI ([#196](https://github.com/parafovea/fovea/pull/196)). Several were gaps in the first audit's own frontend fixes, which closed one instance of a defect class without closing every instance. Nothing is breaking.

model-service/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "fovea-model-service"
-version = "0.5.10"
+version = "0.5.11"
 description = "Model service for fovea video annotation tool"
 requires-python = ">=3.12"
 dependencies = [

model-service/src/application/services/audio_processing.py

@@ -257,7 +257,7 @@ async def extract_audio_segment(
                 stderr=asyncio.subprocess.PIPE,
             )
 
-            _stdout, stderr = await asyncio.wait_for(process.communicate(), timeout=60)
+            _stdout, stderr = await _communicate_with_timeout(process, 60)
 
             if process.returncode != 0:
                 error_msg = stderr.decode() if stderr else "Unknown error"
@@ -273,8 +273,8 @@ async def extract_audio_segment(
 
             return output_path
 
-        except TimeoutError as e:
-            raise AudioProcessingError("Segment extraction timed out after 60s") from e
+        except AudioProcessingError:
+            raise
         except Exception as e:
             raise AudioProcessingError(f"Segment extraction failed: {e}") from e
 
@@ -547,7 +547,7 @@ async def extract_audio_track(
                 stderr=asyncio.subprocess.PIPE,
             )
 
-            _stdout, stderr = await asyncio.wait_for(process.communicate(), timeout=300)
+            _stdout, stderr = await _communicate_with_timeout(process, 300)
 
             if process.returncode != 0:
                 error_msg = stderr.decode() if stderr else "Unknown error"
@@ -562,8 +562,8 @@ async def extract_audio_track(
 
             return output_path
 
-        except TimeoutError as e:
-            raise AudioProcessingError("Audio extraction timed out after 300s") from e
+        except AudioProcessingError:
+            raise
         except Exception as e:
             raise AudioProcessingError(f"Audio extraction failed: {e}") from e
 

model-service/src/infrastructure/adapters/inbound/fastapi/routes/diarize.py

@@ -31,6 +31,7 @@
 from pydantic import BaseModel, Field
 
 from src.infrastructure.adapters.inbound.fastapi.dependencies import ModelManagerDep  # noqa: TC001
+from src.infrastructure.adapters.inbound.fastapi.routes.inference_locks import inference_lock
 from src.infrastructure.config.settings import get_settings
 
 if TYPE_CHECKING:
@@ -146,8 +147,11 @@ async def diarize(
     start = time.time()
     try:
         # Diarization is a blocking CPU/GPU call; offload to a worker
-        # thread so it does not stall the event loop.
-        result: DiarizationResult = await asyncio.to_thread(model.diarize, audio_path_real)
+        # thread so it does not stall the event loop. Serialize inference on
+        # the shared cached pyannote pipeline: two concurrent diarizations
+        # would otherwise call the same non-thread-safe object at once.
+        async with inference_lock("speaker_diarization"):
+            result: DiarizationResult = await asyncio.to_thread(model.diarize, audio_path_real)
     except Exception as exc:
         logger.exception("Diarization failed")
         raise HTTPException(status_code=500, detail=f"Diarization failed: {exc}") from exc

model-service/src/infrastructure/adapters/inbound/fastapi/routes/inference_locks.py

@@ -0,0 +1,28 @@
+"""Per-task inference serialization locks.
+
+The transcribe and diarize routes fetch the single model instance cached in the
+`ModelManager` and run its native inference (faster-whisper / pyannote / torch)
+inside ``asyncio.to_thread``. Offloading to a worker thread removed the implicit
+serialization that running synchronously on the event loop provided, so two
+concurrent requests for the same task would now call the SAME model object's
+inference method from two threads at once — which those native objects are not
+safe for (garbled/interleaved output, or a crash inside CTranslate2/torch).
+
+These locks serialize inference PER TASK TYPE: only one inference runs at a time
+on a given shared model, while different tasks (transcription vs diarization,
+which hold distinct model instances) still run in parallel. The service runs on
+a single event loop, so a plain per-key :class:`asyncio.Lock` is sufficient; the
+locks are created lazily on first use within a running loop.
+"""
+
+from __future__ import annotations
+
+import asyncio
+from collections import defaultdict
+
+_inference_locks: defaultdict[str, asyncio.Lock] = defaultdict(asyncio.Lock)
+
+
+def inference_lock(task_type: str) -> asyncio.Lock:
+    """Return the process-wide inference lock for ``task_type``."""
+    return _inference_locks[task_type]

model-service/src/infrastructure/adapters/inbound/fastapi/routes/transcribe.py

@@ -23,6 +23,7 @@
 from pydantic import BaseModel, Field
 
 from src.infrastructure.adapters.inbound.fastapi.dependencies import ModelManagerDep  # noqa: TC001
+from src.infrastructure.adapters.inbound.fastapi.routes.inference_locks import inference_lock
 from src.infrastructure.adapters.outbound.models.audio.base import (
     AudioTranscriptionLoader,
     TranscriptionResult,
@@ -130,9 +131,13 @@ async def transcribe(
         # requests, /health, and OTLP export). Pass language=None when the
         # caller did not specify one; some loaders (faster-whisper) treat
         # an empty string as a hard lookup miss rather than "auto-detect".
-        result: TranscriptionResult = await asyncio.to_thread(
-            model.transcribe, audio_path_real, language=request.language or None
-        )
+        # Serialize inference on the shared cached model: two concurrent
+        # transcriptions would otherwise call the same non-thread-safe object
+        # from two worker threads at once.
+        async with inference_lock("audio_transcription"):
+            result: TranscriptionResult = await asyncio.to_thread(
+                model.transcribe, audio_path_real, language=request.language or None
+            )
     except Exception as exc:
         logger.exception("Transcription failed")
         raise HTTPException(status_code=500, detail=f"Transcription failed: {exc}") from exc

model-service/src/infrastructure/adapters/outbound/transcriber_whisper.py

@@ -7,10 +7,12 @@
 
 from __future__ import annotations
 
+import asyncio
 import logging
 import os
 import tempfile
 import time
+from typing import TYPE_CHECKING
 
 import torch
 
@@ -22,6 +24,9 @@
 from src.application.services.audio_processing import extract_audio_track, has_audio_stream
 from src.infrastructure.observability.telemetry import record_inference
 
+if TYPE_CHECKING:
+    from src.infrastructure.adapters.outbound.models.audio.loader import TranscriptionConfig
+
 logger = logging.getLogger(__name__)
 
 
@@ -40,11 +45,9 @@ async def transcribe_video(
         enable_diarization: bool = False,
     ) -> TranscriptionResultDTO:
         """Transcribe audio from a video file."""
-        from src.domain.entities.architectures import Whisper  # noqa: PLC0415
         from src.infrastructure.adapters.outbound.models.audio.loader import (  # noqa: PLC0415
             AudioFramework,
             TranscriptionConfig,
-            WhisperLoader,
         )
 
         start = time.time()
@@ -67,40 +70,75 @@ async def transcribe_video(
                 language=language,
                 device=device,
             )
-            loader = WhisperLoader(Whisper(), config)
-            loader.load()
-            try:
-                with record_inference(task="transcribe", model_id=self._model_id):
-                    result = loader.transcribe(audio_path)
-                segments = [
-                    TranscriptSegmentDTO(
-                        start=float(seg.start),
-                        end=float(seg.end),
-                        text=str(seg.text),
-                        confidence=float(getattr(seg, "confidence", 0.0) or 0.0),
-                    )
-                    for seg in result.segments
-                ]
-
-                speaker_count: int | None = None
-                if enable_diarization:
-                    speaker_count = _apply_diarization(audio_path, segments, device)
-
-                return TranscriptionResultDTO(
-                    text=str(result.text),
-                    segments=segments,
-                    language=getattr(result, "language", None),
-                    speaker_count=speaker_count,
-                    processing_time=time.time() - start,
-                )
-            finally:
-                loader.unload()
+            # Whisper load/transcribe, pyannote diarization, and unload are heavy
+            # blocking (CPU/GPU) calls that would run for tens of seconds to
+            # minutes. Offload the whole sequence to a worker thread so the event
+            # loop — /health probes, OTLP metric export, other concurrent
+            # requests — is not frozen for the duration.
+            text, segments, language_out, speaker_count = await asyncio.to_thread(
+                _run_transcription,
+                config,
+                audio_path,
+                self._model_id,
+                device,
+                enable_diarization,
+            )
+
+            return TranscriptionResultDTO(
+                text=text,
+                segments=segments,
+                language=language_out,
+                speaker_count=speaker_count,
+                processing_time=time.time() - start,
+            )
 
         finally:
             if os.path.exists(audio_path):
                 os.remove(audio_path)
 
 
+def _run_transcription(
+    config: TranscriptionConfig,
+    audio_path: str,
+    model_id: str,
+    device: str,
+    enable_diarization: bool,
+) -> tuple[str, list[TranscriptSegmentDTO], str | None, int | None]:
+    """Load Whisper, transcribe, optionally diarize, and unload — all blocking.
+
+    Runs on a worker thread (via ``asyncio.to_thread``) so the event loop is not
+    frozen for the duration of inference. Returns the transcript text, segments,
+    detected language, and speaker count.
+    """
+    from src.domain.entities.architectures import Whisper  # noqa: PLC0415
+    from src.infrastructure.adapters.outbound.models.audio.loader import (  # noqa: PLC0415
+        WhisperLoader,
+    )
+
+    loader = WhisperLoader(Whisper(), config)
+    loader.load()
+    try:
+        with record_inference(task="transcribe", model_id=model_id):
+            result = loader.transcribe(audio_path)
+        segments = [
+            TranscriptSegmentDTO(
+                start=float(seg.start),
+                end=float(seg.end),
+                text=str(seg.text),
+                confidence=float(getattr(seg, "confidence", 0.0) or 0.0),
+            )
+            for seg in result.segments
+        ]
+
+        speaker_count: int | None = None
+        if enable_diarization:
+            speaker_count = _apply_diarization(audio_path, segments, device)
+
+        return str(result.text), segments, getattr(result, "language", None), speaker_count
+    finally:
+        loader.unload()
+
+
 def _apply_diarization(
     audio_path: str, segments: list[TranscriptSegmentDTO], device: str
 ) -> int | None: