Serverseitig: Uploads landen in der Navidrome-Bibliothek

Auf Wunsch: was vom Handy hochgeladen wird, soll auch in Navidrome
auftauchen. Die Subsonic-API kennt keinen Upload — also erledigt es die
Melo-Cloud selbst.

Server (/home/dustin/scripts/melo_cloud.py, nicht versioniert — Backup als
melo_cloud.py.bak-20260821-084506):
- verknuepfe_navidrome(): Hardlink der Registry-Datei nach
  /home/dustin/navidrome/music (Bind-Mount des Containers). Gleiche
  Partition -> kein zusaetzlicher Speicher. Fallback: Kopie.
- rescan_navidrome(): Subsonic startScan.view ueber Navidromes
  AuthProxyHeader (TrustedSources 127.0.0.1) — kein Passwort im Code.
  Nur zur Beschleunigung, der Watcher findet neue Dateien ohnehin.
- upload() verknuepft neue UND bereits bekannte Titel (heilt Bestand).
- handle_delete() entfernt die Datei aus Registry + Navidrome, sobald kein
  Konto sie mehr aktiv hat. Der Registry-EINTRAG bleibt stehen: handle_list
  haengt die Grabsteine daran (JOIN registry) — ohne ihn erfuehren die
  anderen Geraete nie von der Loeschung (Zombie-Song).
- registry_pfad(): gemeinsame Dateisuche ueber alle Audio-Endungen, mit
  Rueckfall auf den Navidrome-Ordner.

Nebenbei repariert:
- Alle 325 Cloud-Dateien lagen nur noch im Navidrome-Ordner, REG war leer:
  jeder Download antwortete "File missing". Per Hardlink zurueckverknuepft
  (scripts/melo_cloud_migriere_registry.py).
- upload() legte jede Datei als ".mp3" ab, auch m4a/flac. Jetzt echte
  Endung; _download liefert passenden Content-Type und einen Dateinamen
  ohne doppelte Endung.

App:
- MeloCloudService.herunterladen() gibt die geschriebene Datei zurueck und
  leitet die Endung aus dem Content-Type ab (endungFuer) — sonst landet
  eine M4A als .mp3 auf dem Handy und Android ordnet sie falsch ein.
- loeschBremseGreift(): der Abgleich reicht keine Loeschwelle mehr zum
  Server durch (>10 Titel UND >1/3 des Serverbestands). Ohne die Bremse
  haette eine nicht eingehaengte Speicherkarte die Sammlung auf allen
  Geraeten geloescht.

276 Tests gruen (1 uebersprungen), flutter analyze ohne Befund, plus ein
Durchlauf gegen den echten Server (scripts/test_melo_cloud_navidrome.py):
Upload -> Registry + Navidrome (ein Hardlink) -> Navidrome liest ein ->
Loeschen entfernt beides, Grabstein bleibt.

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

test/services/melo_cloud_service_test.dart

@@ -101,6 +101,24 @@ void main() {
     });
   });
 
+  group('endungFuer', () {
+    test('erkennt die gängigen Formate der Bibliothek', () {
+      expect(MeloCloudService.endungFuer('audio/mpeg'), '.mp3');
+      expect(MeloCloudService.endungFuer('audio/mp4'), '.m4a');
+      expect(MeloCloudService.endungFuer('audio/flac'), '.flac');
+      expect(MeloCloudService.endungFuer('audio/ogg'), '.ogg');
+    });
+
+    test('ignoriert angehängte Parameter und Groß-/Kleinschreibung', () {
+      expect(MeloCloudService.endungFuer('Audio/MP4; charset=binary'), '.m4a');
+    });
+
+    test('fällt ohne bekannte Zuordnung auf .mp3 zurück', () {
+      expect(MeloCloudService.endungFuer(null), '.mp3');
+      expect(MeloCloudService.endungFuer('application/octet-stream'), '.mp3');
+    });
+  });
+
   group('CloudVerlauf', () {
     test('meldet die Zeit als ISO-Zeit ohne Bruchteile', () {
       final eintrag = CloudVerlauf(

test/services/sync_plan_test.dart

@@ -133,6 +133,28 @@ void main() {
     });
   });
 
+  group('loeschBremseGreift', () {
+    test('einzelne Löschungen laufen durch', () {
+      expect(loeschBremseGreift(zuLoeschen: 1, bestand: 300), isFalse);
+      expect(loeschBremseGreift(zuLoeschen: 10, bestand: 12), isFalse);
+    });
+
+    test('eine Löschwelle wird gestoppt', () {
+      // Typischer Unfall: Speicherkarte nicht eingehängt, der Scan meldet
+      // die halbe Sammlung als verschwunden.
+      expect(loeschBremseGreift(zuLoeschen: 300, bestand: 320), isTrue);
+      expect(loeschBremseGreift(zuLoeschen: 11, bestand: 30), isTrue);
+    });
+
+    test('viele Löschungen aus einem großen Bestand sind erlaubt', () {
+      expect(loeschBremseGreift(zuLoeschen: 20, bestand: 1000), isFalse);
+    });
+
+    test('ohne Löschungen greift nichts', () {
+      expect(loeschBremseGreift(zuLoeschen: 0, bestand: 0), isFalse);
+    });
+  });
+
   group('sollAutoSync', () {
     final jetzt = DateTime(2026, 8, 21, 12);
 

test/services/sync_service_test.dart

@@ -1,6 +1,7 @@
 import 'dart:convert';
 import 'dart:io';
 
+import 'package:drift/drift.dart' show Value;
 import 'package:drift/native.dart';
 import 'package:flutter_test/flutter_test.dart';
 import 'package:http/http.dart' as http;
@@ -75,7 +76,8 @@ void main() {
         );
       }
       if (pfad.contains('/download/')) {
-        return http.Response.bytes([1, 2, 3, 4], 200);
+        return http.Response.bytes([1, 2, 3, 4], 200,
+            headers: {'content-type': 'audio/mp4'});
       }
       return http.Response(jsonEncode({'status': 'ok'}), 200);
     });
@@ -90,6 +92,8 @@ void main() {
     expect(songs.single.cloudId, 'c1');
     expect(songs.single.durationMs, 200000);
     expect(await File(songs.single.path).readAsBytes(), [1, 2, 3, 4]);
+    // Endung kommt vom echten Dateityp des Servers, nicht pauschal .mp3.
+    expect(songs.single.path, endsWith('.m4a'));
   });
 
   test('eine eigene Datei geht zum Server und bekommt die Server-ID', () async {
@@ -197,6 +201,85 @@ void main() {
     expect(gemeldet, ['c5']);
   });
 
+  test('eine Löschwelle wird nicht zum Server durchgereicht', () async {
+    // 12 lokal verschwundene Titel bei 12 am Server: sieht nach einem
+    // Speicherkarten-Unfall aus, nicht nach 12 Einzel-Löschungen.
+    final amServer = <Map<String, dynamic>>[];
+    for (var i = 0; i < 12; i++) {
+      await db.upsertSongs([
+        SongsCompanion.insert(
+          id: 'lokal-$i',
+          path: '${tempDir.path}/weg$i.mp3',
+          title: 'Titel $i',
+          dateAddedMs: 0,
+          updatedAtMs: 0,
+          deleted: const Value(true),
+        ),
+      ]);
+      await db.setCloudId('lokal-$i', 'c$i');
+      amServer.add({'id': 'c$i', 'title': 'Titel $i'});
+    }
+
+    var geloescht = 0;
+    final sync = await baue((anfrage) async {
+      final pfad = anfrage.url.path;
+      if (pfad.endsWith('/list')) {
+        return http.Response(jsonEncode({'songs': amServer}), 200);
+      }
+      if (pfad.endsWith('/delete')) geloescht++;
+      return http.Response(jsonEncode({'status': 'ok'}), 200);
+    });
+
+    await sync.synchronisiere();
+
+    expect(geloescht, 0);
+    expect(sync.fehler, contains('Sicherheitsbremse'));
+  });
+
+  test('einzelne Löschungen laufen weiterhin durch', () async {
+    await db.upsertSongs([
+      SongsCompanion.insert(
+        id: 'lokal-1',
+        path: '${tempDir.path}/weg.mp3',
+        title: 'Weg',
+        dateAddedMs: 0,
+        updatedAtMs: 0,
+        deleted: const Value(true),
+      ),
+    ]);
+    await db.setCloudId('lokal-1', 'c1');
+
+    final gemeldet = <String>[];
+    final sync = await baue((anfrage) async {
+      final pfad = anfrage.url.path;
+      if (pfad.endsWith('/list')) {
+        return http.Response(
+          jsonEncode({
+            'songs': [
+              {'id': 'c1', 'title': 'Weg'},
+              {'id': 'c2', 'title': 'Bleibt'},
+            ]
+          }),
+          200,
+        );
+      }
+      if (pfad.endsWith('/delete')) {
+        gemeldet.add(
+            (jsonDecode(anfrage.body) as Map<String, dynamic>)['song_id'] as String);
+      }
+      if (pfad.contains('/download/')) {
+        return http.Response.bytes([1], 200,
+            headers: {'content-type': 'audio/mpeg'});
+      }
+      return http.Response(jsonEncode({'status': 'ok'}), 200);
+    });
+
+    await sync.synchronisiere();
+
+    expect(gemeldet, ['c1']);
+    expect(sync.fehler, isNull);
+  });
+
   test('ohne Anmeldung passiert nichts und der Grund steht da', () async {
     final sync = SyncService(
       db: db,