Onglet Radio sur le serveur, bouton de synchronisation sur le mobile (2.5.0)

Le serveur gagne un onglet Radio : les stations de l'annuaire, écoutables en
direct dans le navigateur ou enregistrables — jusqu'à l'arrêt ou pour une durée
choisie —, puis réécoutables depuis l'interface. Quatre enregistrements en
parallèle au plus ; si le flux tombe, il est rouvert et le fichier continue.
Les enregistrements rejoignent la bibliothèque : le mobile les reçoit.

Un redémarrage du service clôt proprement les captures en cours, et celles
restées « en cours » après un plantage sont récupérées au démarrage suivant.
La copie de flux sans blocs ICY, propre au guet, est extraite pour être
partagée.

Côté mobile, la synchronisation manuelle n'était qu'un petit lien dans l'onglet
Connexion : elle a maintenant un vrai bouton dans l'onglet Synchronisation.
Deux passages ne se chevauchent plus, et une erreur inattendue s'affiche au lieu
de fermer l'application.

Le code Kotlin n'a pas été compilé sur cette machine (pas de JDK) : il a été
relu, mais reste à construire.

Co-Authored-By: Claude Sonnet 5 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01N6pmSE168yjyf8vgV8mZx6

server/noxely_server/api.py

@@ -28,6 +28,7 @@ from fastapi.responses import FileResponse, HTMLResponse, PlainTextResponse, Res
 
 from . import config as config_module
 from . import rotation
+from .recorder import AlreadyRecording, Recorder, TooMany
 from .sources import catalogs, radio
 from .storage import Storage
 from .workers import Downloader, Watcher, safe_name
@@ -43,6 +44,7 @@ config = config_module.load()
 storage = Storage(config.db_path)
 downloader = Downloader(config, storage)
 watcher = Watcher(config, storage)
+recorder = Recorder(config, storage)
 
 
 def authorised(x_noxely_token: str = Header(default="")) -> None:
@@ -62,11 +64,15 @@ def authorised(x_noxely_token: str = Header(default="")) -> None:
 
 @asynccontextmanager
 async def lifespan(app: FastAPI):
+    recorder.recover()
     tasks = [
         asyncio.create_task(downloader.run_forever()),
         asyncio.create_task(watcher.run_forever()),
     ]
     yield
+    # Les enregistrements en cours sont clos avant de couper : sans cela, redémarrer le
+    # service laisserait chaque fichier « en cours » à jamais.
+    await recorder.stop_all()
     for task in tasks:
         task.cancel()
 
@@ -103,7 +109,8 @@ def media_file(media_id: str):
 
 
 @app.delete("/api/media/{media_id}", dependencies=[Depends(authorised)])
-def delete_media(media_id: str) -> dict:
+async def delete_media(media_id: str) -> dict:
+    recorder.stop(media_id)  # supprimer un enregistrement en cours l'arrête d'abord
     item = storage.delete_media(media_id)
     if item:
         (config.media_dir / item.filename).unlink(missing_ok=True)
@@ -168,6 +175,44 @@ async def radio_stations(genre: str | None = None, name: str | None = None) -> d
     return {"stations": await radio.stations(genre, name)}
 
 
+@app.post("/api/radio/record", dependencies=[Depends(authorised)])
+async def radio_record(payload: dict = Body(...)) -> dict:
+    """Enregistre une station jusqu'à l'arrêt, ou jusqu'à `minutes` si elles sont données."""
+    url = str(payload.get("url") or "").strip()
+    if not url.startswith(("http://", "https://")):
+        raise HTTPException(status_code=400, detail="Adresse de flux invalide")
+    try:
+        minutes = int(payload["minutes"]) if payload.get("minutes") else None
+    except (TypeError, ValueError):
+        raise HTTPException(status_code=400, detail="Durée invalide")
+    station = {
+        "name": str(payload.get("name") or "Station").strip()[:80] or "Station",
+        "url": url,
+        "codec": str(payload.get("codec") or ""),
+    }
+    try:
+        return {"media_id": recorder.start(station, minutes)}
+    except AlreadyRecording:
+        raise HTTPException(status_code=409, detail="Cette station est déjà en cours d'enregistrement")
+    except TooMany as error:
+        raise HTTPException(status_code=409, detail=f"{error} enregistrements simultanés au plus")
+
+
+@app.post("/api/radio/record/{media_id}/stop", dependencies=[Depends(authorised)])
+async def radio_stop(media_id: str) -> dict:
+    return {"stopped": recorder.stop(media_id)}
+
+
+@app.get("/api/radio/recordings", dependencies=[Depends(authorised)])
+async def radio_recordings() -> dict:
+    """Ce qui s'enregistre en ce moment, et ce qui l'a été — guets compris."""
+    return {
+        "active": recorder.active(),
+        "items": [m.public() for m in storage.radio_media()],
+        "max_minutes": config.record_max_minutes,
+    }
+
+
 @app.get("/api/watches", dependencies=[Depends(authorised)])
 def watches() -> dict:
     return {

server/noxely_server/config.py

@@ -60,6 +60,9 @@ class Config:
     listen_interval: int
     #: Ancienneté maximale de l'historique, en jours. Au-delà, les lignes sont purgées.
     history_days: int
+    #: Durée maximale d'un enregistrement de station, en minutes : garde-fou contre un
+    #: enregistrement oublié, qui remplirait le disque à raison d'environ 57 Mo par heure.
+    record_max_minutes: int
 
     @property
     def media_dir(self) -> Path:
@@ -84,4 +87,5 @@ def load() -> Config:
         history=os.environ.get("NOXELY_HISTORY", "1").strip().lower() not in ("0", "false", "non", "no"),
         listen_interval=int(os.environ.get("NOXELY_LISTEN_INTERVAL", "60")),
         history_days=int(os.environ.get("NOXELY_HISTORY_DAYS", "90")),
+        record_max_minutes=int(os.environ.get("NOXELY_RECORD_MAX_MINUTES", "180")),
     )

server/noxely_server/recorder.py

@@ -0,0 +1,194 @@
+# Noxely — collecte côté serveur, écoute hors connexion côté mobile.
+# Copyright © 2026 Johnny (tuxgyver)
+#
+# Ce programme est un logiciel libre : vous pouvez le redistribuer et le modifier
+# selon les termes de la GNU General Public License, version 3 ou ultérieure,
+# telle que publiée par la Free Software Foundation.
+#
+# Il est distribué dans l'espoir d'être utile, mais SANS AUCUNE GARANTIE.
+# Voir le fichier LICENSE à la racine du dépôt pour le texte complet.
+
+"""Enregistrement d'une station à la demande, jusqu'à l'arrêt ou l'expiration de la durée.
+
+À la différence du guet, qui s'arrête quand la station annonce un autre morceau, on capte ici
+le flux tel quel. Le fichier rejoint la bibliothèque comme n'importe quel média : le mobile le
+récupère à sa prochaine synchronisation, et l'interface web peut le réécouter.
+"""
+from __future__ import annotations
+
+import asyncio
+import time
+import uuid
+from dataclasses import dataclass, field
+from datetime import datetime
+
+import httpx
+
+from .config import Config
+from .sources import radio
+from .storage import Storage
+from .workers import UA, safe_name
+
+#: Enregistrements simultanés au plus : chacun tient un flux ouvert en permanence.
+MAX_PARALLEL = 4
+#: Nouvelles tentatives d'affilée avant d'abandonner un flux qui ne revient pas.
+MAX_RECONNECTS = 5
+#: En deçà, un enregistrement interrompu ne vaut pas d'être conservé.
+MIN_KEPT_BYTES = 64 * 1024
+
+
+class AlreadyRecording(Exception):
+    """La station est déjà en cours d'enregistrement."""
+
+
+class TooMany(Exception):
+    """Trop d'enregistrements simultanés."""
+
+
+@dataclass
+class Active:
+    media_id: str
+    station: str
+    url: str
+    started_at: int
+    limit_minutes: int
+    written: int = 0
+    stop: asyncio.Event = field(default_factory=asyncio.Event)
+    task: asyncio.Task | None = None
+
+    def public(self) -> dict:
+        return {
+            "media_id": self.media_id, "station": self.station, "started_at": self.started_at,
+            "written": self.written, "limit_minutes": self.limit_minutes,
+        }
+
+
+class Recorder:
+    def __init__(self, config: Config, storage: Storage) -> None:
+        self.config = config
+        self.storage = storage
+        self._active: dict[str, Active] = {}
+
+    # --- Pilotage -------------------------------------------------------
+
+    def start(self, station: dict, minutes: int | None = None) -> str:
+        """Lance l'enregistrement d'une station ; à appeler depuis la boucle d'événements."""
+        if any(a.url == station["url"] for a in self._active.values()):
+            raise AlreadyRecording(station["name"])
+        if len(self._active) >= MAX_PARALLEL:
+            raise TooMany(str(MAX_PARALLEL))
+
+        cap = self.config.record_max_minutes
+        limit = min(minutes, cap) if minutes and minutes > 0 else cap
+        codec = (station.get("codec") or "").upper()
+        extension, mime = (
+            ("aac", "audio/aac") if codec.startswith("AAC")
+            else ("ogg", "audio/ogg") if codec.startswith("OGG")
+            else ("mp3", "audio/mpeg")
+        )
+        stamp = datetime.now()
+        title = f"{station['name']} — {stamp:%d/%m/%Y %H:%M}"
+        # Le suffixe aléatoire évite qu'un second enregistrement de la même station, lancé dans
+        # la même minute, écrase le fichier du premier.
+        filename = safe_name(f"{station['name']}_{stamp:%Y-%m-%d_%H%M}_{uuid.uuid4().hex[:6]}", extension)
+        media_id = self.storage.add_media(
+            title=title, artist=station["name"], source="radio", origin=station["name"],
+            filename=filename, remote_url=None, mime=mime, state="downloading",
+        )
+        entry = Active(media_id, station["name"], station["url"], _now(), limit)
+        entry.task = asyncio.create_task(self._run(entry, filename))
+        self._active[media_id] = entry
+        return media_id
+
+    def stop(self, media_id: str) -> bool:
+        entry = self._active.get(media_id)
+        if not entry:
+            return False
+        entry.stop.set()
+        return True
+
+    async def stop_all(self, timeout: float = 8.0) -> None:
+        """À l'arrêt du serveur : clôt proprement les fichiers plutôt que de les laisser en cours."""
+        tasks = [a.task for a in self._active.values() if a.task]
+        for media_id in list(self._active):
+            self.stop(media_id)
+        if tasks:
+            await asyncio.wait(tasks, timeout=timeout)
+
+    def active(self) -> list[dict]:
+        return [a.public() for a in self._active.values()]
+
+    def recover(self) -> None:
+        """Au démarrage : ce qui était « en cours » ne l'est plus, l'ancien processus est mort.
+
+        Un fichier qui contient de l'audio reste lisible : on le déclare prêt plutôt que de
+        perdre une écoute entière sur un simple redémarrage du service.
+        """
+        for item in self.storage.stuck_recordings():
+            path = self.config.media_dir / item.filename
+            size = path.stat().st_size if path.exists() else 0
+            if size >= MIN_KEPT_BYTES:
+                self.storage.update_media(item.id, state="ready", size=size,
+                                          error="interrompu par un arrêt du serveur")
+            else:
+                path.unlink(missing_ok=True)
+                self.storage.update_media(item.id, state="failed", error="interrompu, rien de capté")
+
+    # --- Capture --------------------------------------------------------
+
+    async def _run(self, entry: Active, filename: str) -> None:
+        target = self.config.media_dir / filename
+        began = time.monotonic()
+        deadline = began + entry.limit_minutes * 60
+        failures = 0
+        problem = ""
+
+        def keep_going(total: int, _title: str | None) -> bool:
+            entry.written = base + total
+            return not entry.stop.is_set() and time.monotonic() < deadline
+
+        try:
+            while not entry.stop.is_set() and time.monotonic() < deadline:
+                base = entry.written
+                try:
+                    async with httpx.AsyncClient(
+                        headers={**UA, "Icy-MetaData": "1"}, follow_redirects=True,
+                        timeout=httpx.Timeout(30.0, read=60.0),
+                    ) as client:
+                        async with client.stream("GET", entry.url) as response:
+                            response.raise_for_status()
+                            interval = int(response.headers.get("icy-metaint") or 0)
+                            with target.open("ab") as handle:
+                                await radio.copy_stream(response, handle, interval, keep_going)
+                except Exception as error:
+                    problem = str(error)[:150] or type(error).__name__
+                # Une connexion qui a livré de l'audio remet le compteur à zéro : seules les
+                # tentatives infructueuses d'affilée comptent, pas une coupure après une heure.
+                failures = 0 if entry.written > base else failures + 1
+                if entry.stop.is_set() or time.monotonic() >= deadline:
+                    break
+                if failures > MAX_RECONNECTS:
+                    break
+                await asyncio.sleep(3)
+        finally:
+            self._finish(entry, target, time.monotonic() - began, problem)
+            self._active.pop(entry.media_id, None)
+
+    def _finish(self, entry: Active, target, elapsed: float, problem: str) -> None:
+        size = target.stat().st_size if target.exists() else 0
+        completed = entry.stop.is_set() or elapsed >= entry.limit_minutes * 60
+        if size >= MIN_KEPT_BYTES or (size > 0 and completed):
+            self.storage.update_media(
+                entry.media_id, state="ready", size=size, duration_ms=int(elapsed * 1000),
+                error=None if completed else (f"interrompu : {problem}" if problem else "interrompu"),
+            )
+        else:
+            target.unlink(missing_ok=True)
+            self.storage.update_media(
+                entry.media_id, state="failed",
+                error=problem or "aucune donnée reçue de la station",
+            )
+
+
+def _now() -> int:
+    return int(time.time() * 1000)

server/noxely_server/sources/radio.py

@@ -100,3 +100,41 @@ async def _read_title(response, interval: int) -> str | None:
         found = STREAM_TITLE.search(meta)
         return found.group(1).strip() or None if found else None
     return None
+
+
+async def copy_stream(response, handle, interval: int, keep_going) -> int:
+    """Copie l'audio d'un flux dans `handle`, sans les blocs de métadonnées ICY.
+
+    Laissés dans le fichier, ces blocs le rendraient illisible. `keep_going(total, title)` est
+    interrogée après chaque bloc écrit : `total` est le nombre d'octets audio copiés, `title` le
+    titre qui vient d'être annoncé (ou None). Elle décide seule quand s'arrêter — fin d'un
+    morceau pour le guet, demande de l'utilisateur ou durée écoulée pour un enregistrement.
+    """
+    if interval <= 0:
+        total = 0
+        async for chunk in response.aiter_bytes(32768):
+            handle.write(chunk)
+            total += len(chunk)
+            if not keep_going(total, None):
+                break
+        return total
+
+    buffer = bytearray()
+    total = 0
+    async for chunk in response.aiter_bytes(32768):
+        buffer.extend(chunk)
+        while len(buffer) >= interval + 1:
+            length = buffer[interval] * 16
+            if len(buffer) < interval + 1 + length:
+                break
+            handle.write(bytes(buffer[:interval]))
+            total += interval
+            meta = bytes(buffer[interval + 1:interval + 1 + length]).decode("utf-8", "replace")
+            del buffer[:interval + 1 + length]
+            announced = STREAM_TITLE.search(meta)
+            title = announced.group(1).strip() if announced else None
+            if not keep_going(total, title or None):
+                return total
+        if not keep_going(total, None):
+            return total
+    return total

server/noxely_server/storage.py

@@ -169,6 +169,25 @@ class Storage:
             )
         ]
 
+    def radio_media(self, limit: int = 100) -> list[Media]:
+        """Les enregistrements de radio, les plus récents d'abord — guets compris."""
+        return [
+            Media(**dict(r))
+            for r in self._db.execute(
+                "SELECT * FROM media WHERE source = 'radio' ORDER BY created_at DESC LIMIT ?",
+                (limit,),
+            )
+        ]
+
+    def stuck_recordings(self) -> list[Media]:
+        """Enregistrements restés « en cours » : le serveur s'est arrêté avant de les clore."""
+        return [
+            Media(**dict(r))
+            for r in self._db.execute(
+                "SELECT * FROM media WHERE source = 'radio' AND state = 'downloading'"
+            )
+        ]
+
     def delete_media(self, media_id: str) -> Media | None:
         item = self.media(media_id)
         if item:

server/noxely_server/web/about.js

@@ -34,8 +34,10 @@ const ABOUT = {
      'On nomme un titre sans désigner de station : les plus écoutées sont balayées en continu, ' +
      'et l\'enregistrement part dès que l\'une le diffuse.'],
     ['Enregistrer un direct',
-     'La capture prend le nom du morceau annoncé par la station, et s\'arrête quand il cède la ' +
-     'place au suivant.'],
+     'Le guet capte le morceau annoncé et s\'arrête quand il cède la place au suivant.'],
+    ['Écouter et enregistrer une station',
+     'L\'onglet Radio liste les stations : on les écoute en direct, ou on les enregistre — jusqu\'à ' +
+     'l\'arrêt ou pour une durée choisie — puis on réécoute depuis le navigateur ou le mobile.'],
     ['Garder l\'historique et repérer la rotation',
      'Chaque titre annoncé par les stations est noté ; l\'onglet Écoutes montre ce qui a été ' +
      'entendu et ce qui tourne le plus sur les dernières remontées, titres comme artistes.'],

server/noxely_server/web/index.html

@@ -66,6 +66,9 @@
   .tech { width:100%; border-collapse:collapse; }
   .tech td { padding:9px 4px; border-bottom:1px solid var(--line); vertical-align:top; }
   .tech td:first-child { color:var(--muted); width:38%; }
+  [hidden] { display:none !important; }
+  .card button { flex:none; }
+  #audio { flex:2; min-width:220px; max-width:100%; }
   h3.section { font-size:15px; margin:20px 0 10px; }
   .log h4 { margin:0 0 4px; font-size:15px; }
 </style>
@@ -81,6 +84,7 @@
   <div class="tabs">
     <button onclick="show('search')"  aria-selected="true"  id="t-search">🔎 Rechercher</button>
     <button onclick="show('watch')"   aria-selected="false" id="t-watch">📡 Guets</button>
+    <button onclick="show('radio')"   aria-selected="false" id="t-radio">📻 Radio</button>
     <button onclick="show('heard')"   aria-selected="false" id="t-heard">📈 Écoutes</button>
     <button onclick="show('queue')"   aria-selected="false" id="t-queue">⏳ File</button>
     <button onclick="show('library')" aria-selected="false" id="t-library">📚 Bibliothèque</button>
@@ -108,6 +112,33 @@
     <div id="watches"></div>
   </section>
 
+  <section id="p-radio" hidden>
+    <div class="row">
+      <select id="radioGenre" onchange="loadStations()"><option value="">Tous les genres</option></select>
+      <input type="text" id="radioName" placeholder="Nom de la station"
+             onkeydown="if(event.key==='Enter')loadStations()">
+      <button class="go" onclick="loadStations()">Chercher</button>
+      <select id="radioMinutes" title="Durée d'un enregistrement">
+        <option value="">Enregistrer jusqu'à l'arrêt</option>
+        <option value="15">Enregistrer 15 min</option>
+        <option value="30">Enregistrer 30 min</option>
+        <option value="60">Enregistrer 1 h</option>
+        <option value="120">Enregistrer 2 h</option>
+      </select>
+    </div>
+    <div class="card" id="radioPlayer" hidden>
+      <div class="grow"><b id="playerTitle"></b><small id="playerNote"></small></div>
+      <audio id="audio" controls></audio>
+      <button class="ghost" onclick="stopPlayer()" title="Fermer le lecteur">×</button>
+    </div>
+    <h3 class="section">⏺ En cours d'enregistrement</h3>
+    <div id="radioActive"></div>
+    <h3 class="section">🎙️ Enregistrements</h3>
+    <div id="radioRecordings"></div>
+    <h3 class="section">📻 Stations</h3>
+    <div id="radioStations"></div>
+  </section>
+
   <section id="p-heard" hidden>
     <div class="row">
       <select id="rotationWindow" onchange="loadHeard()">
@@ -182,13 +213,14 @@ async function api(path, options = {}) {
 }
 
 function show(name) {
-  for (const tab of ['search', 'watch', 'heard', 'queue', 'library', 'devices', 'settings', 'about']) {
+  for (const tab of ['search', 'watch', 'radio', 'heard', 'queue', 'library', 'devices', 'settings', 'about']) {
     $('p-' + tab).hidden = tab !== name;
     $('t-' + tab).setAttribute('aria-selected', String(tab === name));
   }
   if (name === 'queue') loadQueue();
   if (name === 'library') loadLibrary();
   if (name === 'watch') loadWatches();
+  if (name === 'radio') loadRadio();
   if (name === 'heard') loadHeard();
   if (name === 'devices') loadDevices();
   if (name === 'settings') loadServerInfo();
@@ -206,9 +238,11 @@ async function refreshAll() {
     $('status').className = 'pill warn';
   }
   try {
-    const { catalogs } = await api('/catalogs');
+    const { catalogs, genres } = await api('/catalogs');
     $('catalog').innerHTML = Object.entries(catalogs)
       .map(([id, label]) => `<option value="${id}">${label}</option>`).join('');
+    $('radioGenre').innerHTML = '<option value="">Tous les genres</option>' +
+      genres.map((g) => `<option value="${esc(g)}">${esc(g)}</option>`).join('');
   } catch {}
 }
 
@@ -366,6 +400,132 @@ async function loadHeard() {
   }
 }
 
+// --- Radio : stations, écoute, enregistrement ---------------------------
+
+let radioStations = [];
+let radioItems = [];
+let radioTimer = null;
+let playerUrl = null;
+
+const fmtSize = (n) => n >= 1e6 ? (n / 1e6).toFixed(1) + ' Mo' : Math.round(n / 1e3) + ' Ko';
+const fmtDuration = (ms) => {
+  if (ms < 60000) return `${Math.max(1, Math.round(ms / 1000))} s`;
+  const min = Math.round(ms / 60000);
+  return min >= 60 ? `${Math.floor(min / 60)} h ${String(min % 60).padStart(2, '0')}` : `${min} min`;
+};
+
+function loadRadio() {
+  loadRecordings();
+  if (!radioStations.length) loadStations();
+}
+
+async function loadStations() {
+  $('radioStations').innerHTML = '<div class="empty">Chargement des stations…</div>';
+  const params = new URLSearchParams();
+  if ($('radioGenre').value) params.set('genre', $('radioGenre').value);
+  if ($('radioName').value.trim()) params.set('name', $('radioName').value.trim());
+  try {
+    radioStations = (await api('/radio/stations?' + params)).stations;
+    $('radioStations').innerHTML = radioStations.length ? radioStations.map((s, i) => `
+      <div class="card"><div class="grow"><b>${esc(s.name)}</b>
+        <small>${esc([s.country, s.codec, s.bitrate ? s.bitrate + ' kb/s' : ''].filter(Boolean).join(' · '))}</small></div>
+        <button class="ghost" onclick="listenLive(${i})">▶ Écouter</button>
+        <button class="go" onclick="recordStation(${i})">⏺ Enregistrer</button></div>`).join('')
+      : '<div class="empty">Aucune station</div>';
+  } catch (e) {
+    $('radioStations').innerHTML = `<div class="empty">Annuaire indisponible : ${esc(e.message || e)}</div>`;
+  }
+}
+
+function play(title, note, src, isBlob) {
+  if (playerUrl) URL.revokeObjectURL(playerUrl);
+  playerUrl = isBlob ? src : null;
+  $('radioPlayer').hidden = false;
+  $('playerTitle').textContent = title;
+  $('playerNote').textContent = note;
+  const audio = $('audio');
+  audio.onerror = () => { $('playerNote').textContent = 'Lecture impossible dans ce navigateur'; };
+  audio.src = src;
+  audio.play().catch(() => {});
+}
+
+function stopPlayer() {
+  const audio = $('audio');
+  audio.pause();
+  audio.removeAttribute('src');
+  audio.load();
+  if (playerUrl) URL.revokeObjectURL(playerUrl);
+  playerUrl = null;
+  $('radioPlayer').hidden = true;
+}
+
+const listenLive = (i) => play(radioStations[i].name, 'En direct', radioStations[i].url, false);
+
+async function playRecording(i) {
+  const item = radioItems[i];
+  $('radioPlayer').hidden = false;
+  $('playerTitle').textContent = item.title;
+  $('playerNote').textContent = 'Chargement du fichier…';
+  try {
+    const response = await fetch('/api/media/' + item.id + '/file', { headers: { 'X-Noxely-Token': token } });
+    if (!response.ok) throw new Error(response.status);
+    play(item.title, 'Enregistrement', URL.createObjectURL(await response.blob()), true);
+  } catch (e) { $('playerNote').textContent = 'Lecture impossible : ' + (e.message || e); }
+}
+
+async function recordStation(i) {
+  const s = radioStations[i];
+  const minutes = $('radioMinutes').value;
+  try {
+    await api('/radio/record', { method: 'POST', body: JSON.stringify({
+      name: s.name, url: s.url, codec: s.codec, minutes: minutes ? Number(minutes) : null }) });
+    loadRecordings();
+  } catch (e) { alert(e.message || e); }
+}
+
+async function stopRecording(id) {
+  await api('/radio/record/' + id + '/stop', { method: 'POST' });
+  setTimeout(loadRecordings, 1500);
+}
+
+async function deleteRecording(i) {
+  if (!confirm('Supprimer définitivement « ' + radioItems[i].title + ' » du serveur ?')) return;
+  await api('/media/' + radioItems[i].id, { method: 'DELETE' });
+  loadRecordings();
+}
+
+async function loadRecordings() {
+  clearTimeout(radioTimer);
+  try {
+    const { active, items, max_minutes: max } = await api('/radio/recordings');
+    radioItems = items;
+    const running = new Set(active.map((a) => a.media_id));
+    $('radioActive').innerHTML = active.length ? active.map((a) => `
+      <div class="card"><div class="grow"><b>${esc(a.station)}</b>
+        <small>depuis ${clock(a.started_at)} · ${fmtSize(a.written)} · s'arrête seul après ${a.limit_minutes} min (max ${max})</small></div>
+        <span class="pill warn">● en cours</span>
+        <button class="go" onclick="stopRecording('${a.media_id}')">■ Arrêter</button></div>`).join('')
+      : '<div class="empty" style="padding:10px">Aucun enregistrement en cours</div>';
+
+    const shown = items.map((m, i) => [m, i]).filter(([m]) => !running.has(m.id));
+    $('radioRecordings').innerHTML = shown.length ? shown.map(([m, i]) => `
+      <div class="card"><div class="grow"><b>${esc(m.title)}</b>
+        <small>${clock(m.created_at)}${m.size ? ' · ' + fmtSize(m.size) : ''}${
+          m.duration_ms ? ' · ' + fmtDuration(m.duration_ms) : ''}${m.error ? ' · ' + esc(m.error) : ''}</small></div>
+        ${m.state === 'ready' ? `<button class="ghost" onclick="playRecording(${i})">▶ Écouter</button>`
+          : `<span class="pill ${m.state === 'failed' ? 'warn' : ''}">${m.state === 'failed' ? 'échec' : 'en cours'}</span>`}
+        <button class="ghost" onclick="deleteRecording(${i})" title="Supprimer">×</button></div>`).join('')
+      : '<div class="empty" style="padding:10px">Aucun enregistrement — choisis une station ci-dessous</div>';
+
+    // Tant que quelque chose s'enregistre, la taille et l'état se rafraîchissent d'eux-mêmes.
+    if (!$('p-radio').hidden && (active.length || items.some((m) => m.state === 'downloading'))) {
+      radioTimer = setTimeout(loadRecordings, 4000);
+    }
+  } catch (e) {
+    $('radioActive').innerHTML = `<div class="empty">${esc(e.message || e)}</div>`;
+  }
+}
+
 async function loadServerInfo() {
   try {
     const health = await fetch('/api/health').then((r) => r.json());

server/noxely_server/workers.py

@@ -195,44 +195,21 @@ class Watcher:
                 async with client.stream("GET", station["url"]) as response:
                     response.raise_for_status()
                     interval = int(response.headers.get("icy-metaint") or 0)
+                    # Fin du morceau : la station en annonce un autre. Les gardes-fous bornent
+                    # le fichier quand aucune annonce ne vient (40 Mo sans ICY, 60 Mo avec).
+                    limit = 40_000_000 if interval <= 0 else 60_000_000
+
+                    def keep_going(total: int, announced: str | None) -> bool:
+                        return not (announced and announced != title) and total <= limit
+
                     with target.open("wb") as handle:
-                        written = await self._copy(response, handle, interval, title)
+                        written = await radio.copy_stream(response, handle, interval, keep_going)
             self.storage.update_media(media_id, state="ready", size=written)
         except Exception as error:
             self.storage.update_media(media_id, state="failed", error=str(error)[:200])
         finally:
             self.recording = None
 
-    async def _copy(self, response, handle, interval: int, wanted: str) -> int:
-        """Retire les blocs ICY du flux : laissés dedans, ils rendraient le fichier illisible."""
-        if interval <= 0:
-            total = 0
-            async for chunk in response.aiter_bytes(32768):
-                handle.write(chunk)
-                total += len(chunk)
-                if total > 40_000_000:  # garde-fou : 40 Mo sans annonce de fin
-                    break
-            return total
-
-        buffer = bytearray()
-        total = 0
-        async for chunk in response.aiter_bytes(32768):
-            buffer.extend(chunk)
-            while len(buffer) >= interval + 1:
-                length = buffer[interval] * 16
-                if len(buffer) < interval + 1 + length:
-                    break
-                handle.write(bytes(buffer[:interval]))
-                total += interval
-                meta = bytes(buffer[interval + 1:interval + 1 + length]).decode("utf-8", "replace")
-                del buffer[:interval + 1 + length]
-                announced = radio.STREAM_TITLE.search(meta)
-                if announced and announced.group(1).strip() and announced.group(1).strip() != wanted:
-                    return total  # le morceau est terminé
-            if total > 60_000_000:
-                return total
-        return total
-
 
 def _now() -> int:
     return int(time.time() * 1000)