Welle 2 · Docker-Dienste unter Arcane einzeln: Stacks, Zustand, Gesundheit, Update-Stand; neue Stacks unter „Neu entdeckt“

Statt „Arcane (Docker) · 11 Images“ zeigt das Homelab-Cockpit je Stack jeden Container mit Zustand, Healthcheck und
Update-Stand („Update verfügbar“, „lokal gebaut“ für NerdQuiz und Rippy, „aktuell“). Der Wächter meldet gelb, wenn
ein Container ungesund ist oder ständig neu startet; beendete Container sind kein Befund. Neue Stacks erscheinen unter
„Neu entdeckt“ (eigenes Register, nur „Übernehmen“), Lucy meldet sie einmal.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>

backend/services/homelab/entdecken.py

@@ -8,6 +8,8 @@ den es noch nicht gibt (oder dessen Nummer jetzt einen anderen Namen trägt), wi
                              Snapshots anlegen und Updates einspielen. Hat er schon community-script, genügt Übernehmen.
   • „Nur beobachten“         kein Etikett; er steht in der Liste, Updates gibt es für ihn nicht.
   • „Nicht anfassen“         setzt watcher-aus: auch ein Community-Script bleibt dann unberührt.
+Neue Docker-Stacks unter Arcane (Compose-Projekte, docker.py) kommen genauso dazu, mit eigenem Register
+(docker-bekannt.json) und nur „Übernehmen“ — Etiketten gibt es dort nicht.
 Beim allerersten Bericht (noch kein Register) gilt alles als bekannt — sonst stünden alle Geräte auf einmal da.
 Verschwindet ein Gast, fällt er aus dem Register; kommt unter derselben Nummer ein neuer, ist er wieder „neu“.
 Der eigene Container (Etikett mc2) erscheint nie.
@@ -33,20 +35,23 @@ ZEITLIMIT_S = 60
 _lock = threading.Lock()
 
 
-def _pfad() -> Path:
-    return einstellungen().daten_dir / "geraete-bekannt.json"
+def _pfad(name: str = "geraete-bekannt.json") -> Path:
+    return einstellungen().daten_dir / name
 
 
-def _lesen() -> dict | None:
+DOCKER = "docker-bekannt.json"
+
+
+def _lesen(name: str = "geraete-bekannt.json") -> dict | None:
     try:
-        daten = json.loads(_pfad().read_text(encoding="utf-8"))
+        daten = json.loads(_pfad(name).read_text(encoding="utf-8"))
     except (OSError, ValueError):
         return None
     return daten if isinstance(daten, dict) else None
 
 
-def _schreiben(daten: dict) -> None:
-    pfad = _pfad()
+def _schreiben(daten: dict, name: str = "geraete-bekannt.json") -> None:
+    pfad = _pfad(name)
     pfad.parent.mkdir(parents=True, exist_ok=True)
     tmp = pfad.with_suffix(".tmp")
     tmp.write_text(json.dumps(daten, ensure_ascii=False, indent=1), encoding="utf-8")
@@ -127,18 +132,74 @@ def neue() -> list[dict]:
     return liste
 
 
-def _markieren(zid: str) -> None:
+def _markieren(zid: str, name: str = "geraete-bekannt.json") -> None:
     with _lock:
-        register = _lesen() or {}
+        register = _lesen(name) or {}
         if zid in register:
             register[zid]["zustand"] = "bekannt"
-            _schreiben(register)
+            _schreiben(register, name)
+
+
+# --- Docker-Stacks (seit 25.09.2026) ----------------------------------------------------------------------------------
+
+def docker_gesehen(stacks: list[dict], jetzt: float | None = None, melden=None) -> list[str]:
+    """Die Stacks aus docker.lage() mit dem Register abgleichen. Rückgabe: die IDs („docker:<stack>“), die neu sind."""
+    jetzt = time.time() if jetzt is None else jetzt
+    melden = melden or _melden
+    aktuell = {f"docker:{s['name']}": s for s in stacks if s.get("name")}
+    if not aktuell:
+        return []
+    with _lock:
+        register = _lesen(DOCKER)
+        if register is None:
+            _schreiben({sid: {"erstmals": jetzt, "zustand": "bekannt"} for sid in aktuell}, DOCKER)
+            return []
+        neu = [sid for sid in aktuell if sid not in register]
+        for sid in neu:
+            register[sid] = {"erstmals": jetzt, "zustand": "neu"}
+        for sid in [s for s in register if s not in aktuell]:
+            register.pop(sid)
+        _schreiben(register, DOCKER)
+    for sid in neu:
+        namen = ", ".join(c["name"] for c in aktuell[sid].get("container") or [])
+        melden(f"Neu unter Arcane: der Docker-Stack „{aktuell[sid]['name']}“ ({namen}). Im Homelab-Cockpit unter „Neu "
+               "entdeckt“ übernehmen.")
+    return neu
+
+
+def docker_abgleichen() -> None:
+    """Nach jedem Bericht im eigenen Faden: Arcane fragen (gemerkt) und neue Stacks eintragen."""
+    from services.homelab import docker
+    try:
+        lage = docker.lage()
+        if lage["verfuegbar"]:
+            docker_gesehen(lage["stacks"])
+    except Exception:
+        log.warning("entdecken: Docker-Abgleich gescheitert", exc_info=True)
+
+
+def neue_docker() -> list[dict]:
+    """Neue Docker-Stacks für GET /api/homelab/neu."""
+    from services.homelab import docker
+    register = _lesen(DOCKER) or {}
+    offen = {sid: e for sid, e in register.items() if e.get("zustand") == "neu"}
+    if not offen:
+        return []
+    lage = docker.lage()
+    return [{"id": f"docker:{s['name']}", "name": s["name"], "erstmals": offen[f"docker:{s['name']}"].get("erstmals"),
+             "container": [c["name"] for c in s["container"]]}
+            for s in lage["stacks"] if f"docker:{s['name']}" in offen]
 
 
 def uebernehmen(zid: str, wahl: str) -> dict:
     """POST /api/homelab/neu/{zid}: „freigeben“, „beobachten“ oder „ausschliessen“."""
     if wahl not in WAHL:
         return {"ok": False, "detail": "Unbekannte Wahl."}
+    if zid.startswith("docker:"):
+        if wahl != "beobachten" or zid not in {s["id"] for s in neue_docker()}:
+            return {"ok": False, "detail": "Dieser Docker-Stack steht nicht (mehr) unter „Neu entdeckt“."}
+        _markieren(zid, DOCKER)
+        return {"ok": True, "text": f"Der Stack {zid.split(':', 1)[1]} ist übernommen."}
     geraet = next((g for g in neue() if g["id"] == zid), None)
     if not geraet:
         return {"ok": False, "detail": "Dieses Gerät steht nicht (mehr) unter „Neu entdeckt“."}