nextcloud-talk-capture 0.1.0__tar.gz

nextcloud_talk_capture-0.1.0/PKG-INFO

@@ -0,0 +1,88 @@
+Metadata-Version: 2.4
+Name: nextcloud-talk-capture
+Version: 0.1.0
+Summary: Capture Nextcloud Talk calls: signalling client, per-speaker audio, call monitoring
+Author: Done
+License: MIT
+Project-URL: Homepage, https://github.com/devsoftmus/done-transcription-app
+Project-URL: Issues, https://github.com/devsoftmus/done-transcription-app/issues
+Keywords: nextcloud,nextcloud-talk,webrtc,transcription,audio-capture
+Classifier: Development Status :: 4 - Beta
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Topic :: Communications :: Conferencing
+Classifier: Topic :: Multimedia :: Sound/Audio :: Capture/Recording
+Requires-Python: >=3.11
+Description-Content-Type: text/markdown
+Requires-Dist: aiohttp>=3.9.0
+Requires-Dist: websockets>=12.0
+Requires-Dist: aiortc>=1.9.0
+Requires-Dist: pymysql>=1.1.0
+Requires-Dist: sshtunnel>=0.4.0
+Requires-Dist: paramiko<4.0,>=3.0
+
+# nextcloud-talk-capture
+
+Capture **Nextcloud Talk** calls: join as a signalling client, receive one audio
+stream per speaker, and hand over the finished call as plain data.
+
+Import name is `talk_capture`.
+
+```python
+from talk_capture import CaptureConfig
+from talk_capture.monitor import CallMonitor
+from talk_capture.spreed_client import SpreedClient
+```
+
+## What it does — and what it deliberately does not
+
+This is the capture half of a transcription pipeline: it gets the audio and
+tells you who was speaking. What happens afterwards — speech recognition,
+summaries, publishing, storage — is not its business, and it holds no dependency
+on any of it.
+
+That separation is the whole point. The same package runs inside a Nextcloud
+ExApp, inside a standalone capture service, or inside an application that does
+everything, without dragging a product's worth of code along.
+
+| Module | |
+|---|---|
+| `spreed_client` | signalling client: HPB + aiortc, per-speaker audio |
+| `monitor` | active-call detection (polls the Nextcloud DB, optionally over an SSH tunnel) |
+| `presence` | join/leave annotations (pure functions, no I/O) |
+| `chat_commands` | opt-out commands posted in the room chat, honoured mid-call |
+| `resolve` | assembles a `FinishedCall` when the call ends |
+| `transcriber_backend` | sends audio to an engine, in-process or over gRPC |
+| `contracts` | `FinishedCall`, `SpeakerStatInput` — the payload handed downstream |
+| `config` | `CaptureConfig` — what capture needs, nothing more |
+| `aioice_patch` | works around an aioice race; import it before aiortc |
+
+## Requirements
+
+- Nextcloud Talk with a **High Performance Backend**. Call media lives in the
+  signalling server, not in the PHP layer, so an HPB is required.
+- Python 3.11+
+
+## Configuration
+
+`CaptureConfig` carries what capture needs: Nextcloud credentials, the
+signalling server and its secret, call-detection database access, the room
+filter, and where to send the audio. Build it from the environment with
+`CaptureConfig.from_env()`, or pass any object exposing the same attributes —
+config is taken duck-typed, so a larger application config works unchanged.
+
+## Contributing
+
+Two rules keep the package shippable on its own, both enforced by tests in the
+consuming repository:
+
+- nothing here may import the downstream half (publishing, analysis, storage);
+- a config field must keep its name, type and default in sync with any larger
+  config that is passed in — a mismatch fails mid-call, not at import.
+
+## Licence
+
+MIT.

nextcloud_talk_capture-0.1.0/README.md

@@ -0,0 +1,62 @@
+# nextcloud-talk-capture
+
+Capture **Nextcloud Talk** calls: join as a signalling client, receive one audio
+stream per speaker, and hand over the finished call as plain data.
+
+Import name is `talk_capture`.
+
+```python
+from talk_capture import CaptureConfig
+from talk_capture.monitor import CallMonitor
+from talk_capture.spreed_client import SpreedClient
+```
+
+## What it does — and what it deliberately does not
+
+This is the capture half of a transcription pipeline: it gets the audio and
+tells you who was speaking. What happens afterwards — speech recognition,
+summaries, publishing, storage — is not its business, and it holds no dependency
+on any of it.
+
+That separation is the whole point. The same package runs inside a Nextcloud
+ExApp, inside a standalone capture service, or inside an application that does
+everything, without dragging a product's worth of code along.
+
+| Module | |
+|---|---|
+| `spreed_client` | signalling client: HPB + aiortc, per-speaker audio |
+| `monitor` | active-call detection (polls the Nextcloud DB, optionally over an SSH tunnel) |
+| `presence` | join/leave annotations (pure functions, no I/O) |
+| `chat_commands` | opt-out commands posted in the room chat, honoured mid-call |
+| `resolve` | assembles a `FinishedCall` when the call ends |
+| `transcriber_backend` | sends audio to an engine, in-process or over gRPC |
+| `contracts` | `FinishedCall`, `SpeakerStatInput` — the payload handed downstream |
+| `config` | `CaptureConfig` — what capture needs, nothing more |
+| `aioice_patch` | works around an aioice race; import it before aiortc |
+
+## Requirements
+
+- Nextcloud Talk with a **High Performance Backend**. Call media lives in the
+  signalling server, not in the PHP layer, so an HPB is required.
+- Python 3.11+
+
+## Configuration
+
+`CaptureConfig` carries what capture needs: Nextcloud credentials, the
+signalling server and its secret, call-detection database access, the room
+filter, and where to send the audio. Build it from the environment with
+`CaptureConfig.from_env()`, or pass any object exposing the same attributes —
+config is taken duck-typed, so a larger application config works unchanged.
+
+## Contributing
+
+Two rules keep the package shippable on its own, both enforced by tests in the
+consuming repository:
+
+- nothing here may import the downstream half (publishing, analysis, storage);
+- a config field must keep its name, type and default in sync with any larger
+  config that is passed in — a mismatch fails mid-call, not at import.
+
+## Licence
+
+MIT.

nextcloud_talk_capture-0.1.0/pyproject.toml

@@ -0,0 +1,43 @@
+[build-system]
+requires = ["setuptools>=68"]
+build-backend = "setuptools.build_meta"
+
+[project]
+# Distribution name is explicit about the domain (PyPI is a global namespace);
+# the import name stays `talk_capture`.
+name = "nextcloud-talk-capture"
+version = "0.1.0"
+description = "Capture Nextcloud Talk calls: signalling client, per-speaker audio, call monitoring"
+readme = "README.md"
+requires-python = ">=3.11"
+# MIT on purpose, not by default: this package is consumed both by an AGPL
+# Nextcloud app and by a proprietary backend. Copyleft here would reach through
+# into the latter; MIT is compatible in both directions.
+license = { text = "MIT" }
+authors = [{ name = "Done" }]
+keywords = ["nextcloud", "nextcloud-talk", "webrtc", "transcription", "audio-capture"]
+classifiers = [
+    "Development Status :: 4 - Beta",
+    "Intended Audience :: Developers",
+    "License :: OSI Approved :: MIT License",
+    "Programming Language :: Python :: 3",
+    "Programming Language :: Python :: 3.11",
+    "Programming Language :: Python :: 3.12",
+    "Topic :: Communications :: Conferencing",
+    "Topic :: Multimedia :: Sound/Audio :: Capture/Recording",
+]
+dependencies = [
+    "aiohttp>=3.9.0",
+    "websockets>=12.0",
+    "aiortc>=1.9.0",
+    "pymysql>=1.1.0",
+    "sshtunnel>=0.4.0",
+    "paramiko>=3.0,<4.0",
+]
+
+[project.urls]
+Homepage = "https://github.com/devsoftmus/done-transcription-app"
+Issues = "https://github.com/devsoftmus/done-transcription-app/issues"
+
+[tool.setuptools.packages.find]
+where = ["src"]

nextcloud_talk_capture-0.1.0/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+

nextcloud_talk_capture-0.1.0/src/nextcloud_talk_capture.egg-info/PKG-INFO

@@ -0,0 +1,88 @@
+Metadata-Version: 2.4
+Name: nextcloud-talk-capture
+Version: 0.1.0
+Summary: Capture Nextcloud Talk calls: signalling client, per-speaker audio, call monitoring
+Author: Done
+License: MIT
+Project-URL: Homepage, https://github.com/devsoftmus/done-transcription-app
+Project-URL: Issues, https://github.com/devsoftmus/done-transcription-app/issues
+Keywords: nextcloud,nextcloud-talk,webrtc,transcription,audio-capture
+Classifier: Development Status :: 4 - Beta
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Topic :: Communications :: Conferencing
+Classifier: Topic :: Multimedia :: Sound/Audio :: Capture/Recording
+Requires-Python: >=3.11
+Description-Content-Type: text/markdown
+Requires-Dist: aiohttp>=3.9.0
+Requires-Dist: websockets>=12.0
+Requires-Dist: aiortc>=1.9.0
+Requires-Dist: pymysql>=1.1.0
+Requires-Dist: sshtunnel>=0.4.0
+Requires-Dist: paramiko<4.0,>=3.0
+
+# nextcloud-talk-capture
+
+Capture **Nextcloud Talk** calls: join as a signalling client, receive one audio
+stream per speaker, and hand over the finished call as plain data.
+
+Import name is `talk_capture`.
+
+```python
+from talk_capture import CaptureConfig
+from talk_capture.monitor import CallMonitor
+from talk_capture.spreed_client import SpreedClient
+```
+
+## What it does — and what it deliberately does not
+
+This is the capture half of a transcription pipeline: it gets the audio and
+tells you who was speaking. What happens afterwards — speech recognition,
+summaries, publishing, storage — is not its business, and it holds no dependency
+on any of it.
+
+That separation is the whole point. The same package runs inside a Nextcloud
+ExApp, inside a standalone capture service, or inside an application that does
+everything, without dragging a product's worth of code along.
+
+| Module | |
+|---|---|
+| `spreed_client` | signalling client: HPB + aiortc, per-speaker audio |
+| `monitor` | active-call detection (polls the Nextcloud DB, optionally over an SSH tunnel) |
+| `presence` | join/leave annotations (pure functions, no I/O) |
+| `chat_commands` | opt-out commands posted in the room chat, honoured mid-call |
+| `resolve` | assembles a `FinishedCall` when the call ends |
+| `transcriber_backend` | sends audio to an engine, in-process or over gRPC |
+| `contracts` | `FinishedCall`, `SpeakerStatInput` — the payload handed downstream |
+| `config` | `CaptureConfig` — what capture needs, nothing more |
+| `aioice_patch` | works around an aioice race; import it before aiortc |
+
+## Requirements
+
+- Nextcloud Talk with a **High Performance Backend**. Call media lives in the
+  signalling server, not in the PHP layer, so an HPB is required.
+- Python 3.11+
+
+## Configuration
+
+`CaptureConfig` carries what capture needs: Nextcloud credentials, the
+signalling server and its secret, call-detection database access, the room
+filter, and where to send the audio. Build it from the environment with
+`CaptureConfig.from_env()`, or pass any object exposing the same attributes —
+config is taken duck-typed, so a larger application config works unchanged.
+
+## Contributing
+
+Two rules keep the package shippable on its own, both enforced by tests in the
+consuming repository:
+
+- nothing here may import the downstream half (publishing, analysis, storage);
+- a config field must keep its name, type and default in sync with any larger
+  config that is passed in — a mismatch fails mid-call, not at import.
+
+## Licence
+
+MIT.

nextcloud_talk_capture-0.1.0/src/nextcloud_talk_capture.egg-info/SOURCES.txt

@@ -0,0 +1,17 @@
+README.md
+pyproject.toml
+src/nextcloud_talk_capture.egg-info/PKG-INFO
+src/nextcloud_talk_capture.egg-info/SOURCES.txt
+src/nextcloud_talk_capture.egg-info/dependency_links.txt
+src/nextcloud_talk_capture.egg-info/requires.txt
+src/nextcloud_talk_capture.egg-info/top_level.txt
+src/talk_capture/__init__.py
+src/talk_capture/aioice_patch.py
+src/talk_capture/chat_commands.py
+src/talk_capture/config.py
+src/talk_capture/contracts.py
+src/talk_capture/monitor.py
+src/talk_capture/presence.py
+src/talk_capture/resolve.py
+src/talk_capture/spreed_client.py
+src/talk_capture/transcriber_backend.py

nextcloud_talk_capture-0.1.0/src/nextcloud_talk_capture.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

nextcloud_talk_capture-0.1.0/src/nextcloud_talk_capture.egg-info/requires.txt

@@ -0,0 +1,6 @@
+aiohttp>=3.9.0
+websockets>=12.0
+aiortc>=1.9.0
+pymysql>=1.1.0
+sshtunnel>=0.4.0
+paramiko<4.0,>=3.0

nextcloud_talk_capture-0.1.0/src/nextcloud_talk_capture.egg-info/top_level.txt

@@ -0,0 +1 @@
+talk_capture

nextcloud_talk_capture-0.1.0/src/talk_capture/__init__.py

@@ -0,0 +1,12 @@
+"""Nextcloud Talk call capture — signalling, monitoring, and the brain contract.
+
+Everything needed to join a call, receive per-speaker audio, and hand over a
+FinishedCall. Deliberately knows nothing about what happens next: publishing,
+analysis and storage belong to whatever consumes this package, and nothing
+here may import them.
+"""
+
+from .config import CaptureConfig
+from .contracts import FinishedCall, SpeakerStatInput
+
+__all__ = ["CaptureConfig", "FinishedCall", "SpeakerStatInput"]

nextcloud_talk_capture-0.1.0/src/talk_capture/aioice_patch.py

@@ -0,0 +1,39 @@
+"""Monkey-patch for aioice Transaction.__retry race condition.
+
+Bug: aioice/stun.py Transaction.__retry() calls
+  self.__future.set_exception(TransactionTimeout())
+without checking if the future is already done.
+
+If a response arrives at the same moment as the retry timeout,
+response_received() sets the future first (it HAS the done() check),
+then __retry() tries to set_exception on an already-done future
+→ asyncio.InvalidStateError → process crash.
+
+Fix: Add `if not self.__future.done()` guard, same as response_received().
+
+See: https://github.com/aiortc/aioice/blob/main/src/aioice/stun.py
+"""
+
+import asyncio
+from aioice import stun
+
+
+def _patched_retry(self):
+    if self._Transaction__tries >= self._Transaction__tries_max:
+        if not self._Transaction__future.done():
+            self._Transaction__future.set_exception(stun.TransactionTimeout())
+        return
+
+    self._Transaction__protocol.send_stun(
+        self._Transaction__request, self._Transaction__addr
+    )
+
+    loop = asyncio.get_event_loop()
+    self._Transaction__timeout_handle = loop.call_later(
+        self._Transaction__timeout_delay, self._Transaction__retry
+    )
+    self._Transaction__timeout_delay *= 2
+    self._Transaction__tries += 1
+
+
+stun.Transaction._Transaction__retry = _patched_retry

nextcloud_talk_capture-0.1.0/src/talk_capture/chat_commands.py

@@ -0,0 +1,170 @@
+"""Opt-out chat commands and the one-to-one join gate.
+
+Three behaviours that decide whether a call is recorded at all:
+
+  * the opt-out command posted before a call starts (checked once, at join),
+  * the same command posted mid-call, which pauses and resumes recording,
+  * one-to-one calls, where capture waits for the second participant so a
+    ringing call is never recorded.
+
+Consent lives here rather than in the signalling client on purpose: it must hold
+regardless of how the audio is obtained.
+"""
+from __future__ import annotations
+
+import asyncio
+import logging
+import time
+from typing import Awaitable, Callable
+
+import aiohttp
+
+logger = logging.getLogger(__name__)
+
+CMD_STOP = frozenset(("/без-записи", "/no-record", "/no-transcribe"))
+CMD_START = frozenset(("/запись", "/record", "/transcribe"))
+CHAT_POLL_INTERVAL = 5  # seconds between chat polls
+
+
+def _ocs_auth(config):
+    return aiohttp.BasicAuth(config.nc_user, config.nc_password)
+
+
+_OCS_HEADERS = {"OCS-APIRequest": "true", "Accept": "application/json"}
+
+
+async def check_no_transcribe(config, room_token: str) -> bool:
+    """True if someone posted /без-записи in the room in the last 5 minutes —
+    transcription should be skipped for this call."""
+    url = (
+        f"{config.nc_url}/ocs/v2.php/apps/spreed/api/v1"
+        f"/chat/{room_token}?lookIntoFuture=0&limit=10"
+    )
+    try:
+        async with aiohttp.ClientSession(
+            auth=_ocs_auth(config), headers=_OCS_HEADERS,
+        ) as session:
+            async with session.get(url) as resp:
+                if resp.status != 200:
+                    return False
+                data = await resp.json()
+                messages = data.get("ocs", {}).get("data", [])
+                now = time.time()
+                for msg in messages:
+                    text = (msg.get("message") or "").strip().lower()
+                    if now - msg.get("timestamp", 0) > 300:
+                        continue
+                    if text in CMD_STOP:
+                        logger.info(
+                            "Transcription disabled for %s by %s",
+                            room_token, msg.get("actorDisplayName", "?"),
+                        )
+                        return True
+    except Exception:
+        logger.exception("Failed to check no-transcribe for %s", room_token)
+    return False
+
+
+async def wait_for_second_participant(
+    monitor, room_token: str, is_active: Callable[[], bool],
+    *, max_wait: int = 60, poll: int = 3,
+) -> bool:
+    """Wait until 2+ participants are in a 1:1 call before connecting (the bot
+    must NOT join while ringing — internal clients auto-set inCall, which stops
+    the ring). Returns True once 2+ present, False on timeout / call-ended.
+    `is_active()` reports whether the call is still pending (e.g. token still in
+    the session map)."""
+    loop = asyncio.get_running_loop()
+    logger.info("1:1 call %s — waiting for second participant", room_token)
+    for _ in range(0, max_wait, poll):
+        if not is_active():
+            logger.info("1:1 call %s — ended while waiting", room_token)
+            return False
+        try:
+            count = await loop.run_in_executor(
+                None, monitor._count_incall_participants, room_token,
+            )
+            if count >= 2:
+                logger.info("1:1 call %s — %d in call, joining", room_token, count)
+                return True
+        except Exception:
+            logger.debug("1:1 participant poll error for %s", room_token,
+                         exc_info=True)
+        await asyncio.sleep(poll)
+    logger.info("1:1 call %s — second participant never joined", room_token)
+    return False
+
+
+class ChatCommandMonitor:
+    """Polls a room's chat for /без-записи (pause) and /запись (resume) and
+    flips `self.recording`. The capture session checks `recording` before
+    feeding frames. start() launches the loop; stop() cancels it."""
+
+    def __init__(self, config, room_token: str):
+        self._config = config
+        self._token = room_token
+        self.recording = True
+        self._last_id = 0
+        self._task: asyncio.Task | None = None
+
+    def start(self) -> None:
+        self._task = asyncio.create_task(self._loop())
+
+    async def stop(self) -> None:
+        if self._task:
+            self._task.cancel()
+            try:
+                await self._task
+            except asyncio.CancelledError:
+                pass
+
+    def apply(self, text: str, author: str = "?") -> None:
+        """Apply one chat message's command (pure; used by the loop + tests)."""
+        text = (text or "").strip().lower()
+        if text in CMD_STOP and self.recording:
+            self.recording = False
+            logger.info("Recording PAUSED for %s by %s", self._token, author)
+        elif text in CMD_START and not self.recording:
+            self.recording = True
+            logger.info("Recording RESUMED for %s by %s", self._token, author)
+
+    async def _loop(self) -> None:
+        base = (
+            f"{self._config.nc_url}/ocs/v2.php/apps/spreed/api/v1"
+            f"/chat/{self._token}"
+        )
+        try:
+            async with aiohttp.ClientSession(
+                auth=_ocs_auth(self._config), headers=_OCS_HEADERS,
+            ) as session:
+                async with session.get(f"{base}?lookIntoFuture=0&limit=1") as resp:
+                    if resp.status == 200:
+                        msgs = (await resp.json()).get("ocs", {}).get("data", [])
+                        if msgs:
+                            self._last_id = msgs[0].get("id", 0)
+                while True:
+                    await asyncio.sleep(CHAT_POLL_INTERVAL)
+                    try:
+                        async with session.get(
+                            f"{base}?lookIntoFuture=1"
+                            f"&lastKnownMessageId={self._last_id}"
+                            f"&limit=20&timeout=0"
+                        ) as resp:
+                            if resp.status != 200:
+                                continue
+                            for msg in (await resp.json()).get(
+                                    "ocs", {}).get("data", []):
+                                mid = msg.get("id", 0)
+                                if mid > self._last_id:
+                                    self._last_id = mid
+                                self.apply(msg.get("message", ""),
+                                           msg.get("actorDisplayName", "?"))
+                    except asyncio.CancelledError:
+                        raise
+                    except Exception:
+                        logger.debug("Chat poll error for %s", self._token,
+                                     exc_info=True)
+        except asyncio.CancelledError:
+            pass
+        except Exception:
+            logger.exception("Chat monitor failed for %s", self._token)

nextcloud_talk_capture-0.1.0/src/talk_capture/config.py

@@ -0,0 +1,124 @@
+"""Configuration the capture path needs — and nothing else.
+
+An application that also transcribes, analyses and stores calls has a much
+larger configuration; capture needs about thirty values out of it.
+
+CaptureConfig declares exactly those. Capture modules take config duck-typed, so
+a larger application config with the same field names works unchanged — and a
+capture-only deployment can build one from the environment instead.
+"""
+from __future__ import annotations
+
+import os
+from dataclasses import dataclass
+
+
+def _csv(name: str) -> tuple:
+    return tuple(t.strip() for t in os.environ.get(name, "").split(",") if t.strip())
+
+
+@dataclass
+class CaptureConfig:
+    """What it takes to detect a call, join it, and receive per-speaker audio."""
+
+    # ── Nextcloud (OCS API: room metadata, chat commands, participants) ──
+    nc_url: str = ""
+    nc_user: str = ""
+    nc_password: str = ""
+
+    # ── Signalling (HPB) — the media path ──
+    hpb_url: str = ""
+    hpb_secret: str = ""
+
+    # ── Call detection: Nextcloud MySQL, optionally over an SSH tunnel ──
+    db_host: str = "127.0.0.1"
+    db_port: int = 3306
+    db_user: str = ""
+    db_password: str = ""
+    db_name: str = "nextcloud"
+    ssh_host: str = ""  # empty = direct MySQL, no tunnel
+    ssh_port: int = 22
+    ssh_user: str = "root"
+    ssh_key_path: str = "/root/.ssh/id_rsa"
+    poll_interval: int = 5
+
+    # ── Which rooms to capture ──
+    # allowlist wins when set (pilot rollout / a single test room); the
+    # include/exclude pair is the older per-room filter.
+    room_allowlist: tuple = ()
+    included_rooms: tuple = ()
+    excluded_rooms: tuple = ()
+
+    # ── Where the audio goes ──
+    transcriber_backend: str = "in_process"  # in_process | grpc
+    transcriber_grpc_target: str = "transcriber:7100"
+    transcriber_api_token: str = ""
+
+    # ── Result delivery (capture-only services POST S2 to the brain) ──
+    # Where a capture-only deployment POSTs the finished call. No default: it
+    # is deployment-specific, and silently posting nowhere is worse than failing.
+    nc_capture_s2_url: str = ""
+    s2_intake_token: str = ""
+    nc_capture_outbox_db: str = "/var/nc_capture_outbox/outbox.db"
+    nc_capture_replay_interval: float = 60.0
+
+    # ── Transcript presentation (travels with the finished call) ──
+    transcript_language: str = "ru"
+    daily_report_timezone: str = "Europe/Moscow"
+
+    # ── Voice-sample collection (optional; off unless enabled) ──
+    enrollment_collection_enabled: bool = False
+    enrollment_store_path: str = "/var/enrollment_store"
+    enrollment_min_rms: float = 0.003
+    enrollment_chunk_seconds: int = 30
+    enrollment_max_chunks_per_call: int = 10
+
+    diagnostic_logging: bool = False
+
+    @classmethod
+    def from_env(cls) -> "CaptureConfig":
+        """Build from the environment — for services that capture only."""
+        return cls(
+            nc_url=os.environ.get("NEXTCLOUD_URL", "").rstrip("/"),
+            nc_user=os.environ.get("NC_USER", ""),
+            nc_password=os.environ.get("NC_PASSWORD", ""),
+            hpb_url=os.environ.get("HPB_URL", ""),
+            hpb_secret=os.environ.get("HPB_SECRET", ""),
+            db_host=os.environ.get("DB_HOST", "127.0.0.1"),
+            db_port=int(os.environ.get("DB_PORT", "3306")),
+            db_user=os.environ.get("DB_USER", ""),
+            db_password=os.environ.get("DB_PASSWORD", ""),
+            db_name=os.environ.get("DB_NAME", "nextcloud"),
+            ssh_host=os.environ.get("SSH_HOST", ""),
+            ssh_port=int(os.environ.get("SSH_PORT", "22")),
+            ssh_user=os.environ.get("SSH_USER", "root"),
+            ssh_key_path=os.environ.get("SSH_KEY_PATH", "/root/.ssh/id_rsa"),
+            poll_interval=int(os.environ.get("POLL_INTERVAL", "5")),
+            room_allowlist=_csv("ROOM_ALLOWLIST"),
+            included_rooms=_csv("INCLUDED_ROOMS"),
+            excluded_rooms=_csv("EXCLUDED_ROOMS"),
+            transcriber_backend=os.environ.get("TRANSCRIBER_BACKEND", "in_process"),
+            transcriber_grpc_target=os.environ.get(
+                "TRANSCRIBER_GRPC_TARGET", "transcriber:7100"),
+            transcriber_api_token=os.environ.get("TRANSCRIBER_API_TOKEN", ""),
+            nc_capture_s2_url=os.environ.get("NC_CAPTURE_S2_URL", ""),
+            s2_intake_token=os.environ.get("S2_INTAKE_TOKEN", ""),
+            nc_capture_outbox_db=os.environ.get(
+                "NC_CAPTURE_OUTBOX_DB", "/var/nc_capture_outbox/outbox.db"),
+            nc_capture_replay_interval=float(
+                os.environ.get("NC_CAPTURE_REPLAY_INTERVAL", "60")),
+            transcript_language=os.environ.get("TRANSCRIPT_LANGUAGE", "ru"),
+            daily_report_timezone=os.environ.get(
+                "DAILY_REPORT_TIMEZONE", "Europe/Moscow"),
+            enrollment_collection_enabled=os.environ.get(
+                "ENROLLMENT_COLLECTION_ENABLED", "false").lower() == "true",
+            enrollment_store_path=os.environ.get(
+                "ENROLLMENT_STORE_PATH", "/var/enrollment_store"),
+            enrollment_min_rms=float(os.environ.get("ENROLLMENT_MIN_RMS", "0.003")),
+            enrollment_chunk_seconds=int(
+                os.environ.get("ENROLLMENT_CHUNK_SECONDS", "30")),
+            enrollment_max_chunks_per_call=int(
+                os.environ.get("ENROLLMENT_MAX_CHUNKS_PER_CALL", "10")),
+            diagnostic_logging=os.environ.get(
+                "DIAGNOSTIC_LOGGING", "false").lower() == "true",
+        )