fix(security): v3-Umbau P1 — Geheimnisse raus aus dem Browser, Frontend endlich getestet

Zweite Etappe. Kern: das Frontend traegt kein Geheimnis mehr, und es laeuft
nicht laenger als einziger Teil des Stacks ungeprueft durchs Gate.

## B-01 — Box-Sudo-Passwort: ersatzlos entfernt

Das Passwort lag im localStorage und reiste bei JEDEM mutierenden Request mit —
als Header `X-Sudo-Password` UND im JSON-Rumpf. Da /etc/sudoers den Dienst-Nutzer
mit `NOPASSWD: ALL` fuehrt, waere ein einziger XSS in der SPA Root auf der Box
gewesen.

AUF DER BOX GEMESSEN: `sudo -n true` laeuft durch. Das Passwort wurde also nie
gebraucht — es war reines Risiko ohne Gegenwert. Darum keine Umkonstruktion
(Sitzungs-Cookie o. AE.), sondern Loeschung, quer durch den ganzen Pfad:

  frontend/src/lib/api.ts             kein localStorage-Zugriff mehr
  frontend/.../SettingsTab.tsx        Eingabefeld weg, dafuer die Erklaerung warum
  backend/routers/maintenance.py      SudoReq entfaellt, 8 Endpunkte entschlackt
  backend/services/maintenance.py     _run() nutzt immer `sudo -n`
  backend/services/jobengine.py       keine stdin-Pipe mehr (DEVNULL)

`password_required` bleibt als ehrliches Signal: Verlangt sudo je doch ein
Passwort, ist das eine Konfigurations-Frage auf der Box — nichts, was man mit
einem im Browser geparkten Geheimnis uebertuencht.

## HuggingFace-Token: liegt jetzt auf der Box

Derselbe Fehler, kleinerer Radius. Neu: backend/services/geheimnisse.py — Datei
neben den anderen mc2-*.json, Rechte 0600, atomar geschrieben. Die Oberflaeche
erfaehrt nur, OB ein Token gesetzt ist, nie seinen Wert. Ein Schluessel-Allowlist
verhindert, dass ein fehlgeleiteter Request beliebige Felder hineinschreibt.
Prozess-Env (HF_TOKEN) hat Vorrang und wird als solche angezeigt.
Verifiziert gegen das lokale Backend: setzen/lesen/loeschen ok, unerlaubter
Schluessel wird mit Klartext-Grund abgewiesen, der Wert kommt nie zurueck.

## B-14 — Fehlermeldungen sagen jetzt, was los ist

api() warf `new Error("500 Internal Server Error")` und verwarf den Rumpf; der
eigentliche Grund aus FastAPIs `detail` erreichte die Oberflaeche nie. Neu:
ApiError mit status + detail, inklusive Validierungslisten und HTML-Fehlerseiten
(ein kaputter Rumpf darf die Meldung nicht in einen zweiten Fehler verwandeln).
Zwei Aufrufstellen zeigen den Grund jetzt statt "Fehler" (Discover, ModelBrowse).

## B-07 — Tests und Linter, ehrlich eingeordnet

Praezisierung gegenueber dem Audit: Die MC2-Ampel fuehrt bewusst GAR KEINE Tests
aus (dokumentiert: die Python-Dienste haengen an ML-Wheels, die echten Tests sind
Pruefstand + Box). Das ist fuer die Dienste richtig — fuer Frontend-Unit-Tests
nicht: die laufen in jsdom, brauchen weder Modell noch GPU, und sind in 1,3 s durch.

  Vitest + Testing Library, 17 Tests in 3 Dateien
  ESLint (flat config) + Prettier
  Beides jetzt Teil der Ampel

Die Tests sind kein Feigenblatt: acht davon sind der Zaun um B-01 — sie beweisen,
dass api() weder Kopfzeilen noch Rumpf aus dem localStorage anreichert. Dazu eine
ESLint-Regel, die localStorage-Zugriffe auf Schluessel mit password/token/secret
im Namen hart abweist (an einer Probe verifiziert; harmlose Schluessel wie
mc_sidebar_collapsed bleiben erlaubt).

ESLint meldet 0 Fehler / 93 Warnungen. Die 18 Treffer der neuen React-Compiler-
Regeln (setState im Effekt, Ref-Zugriff im Render) sind ECHT, aber quer durch
10 500 Zeilen zu beheben ist P5-Arbeit. Sie stehen als sichtbare Warn-Liste statt
abgeschaltet — ein ab Tag eins rotes Gate ist kein Gate mehr.

## Nebenbefund, im Browser reproduziert: veraltetes Buendel nach Deploy

Ein Deploy ersetzt dist und startet den Dienst neu; offene Tabs behalten aber ihr
altes Start-Buendel, dessen Nachlade-Chunks nun fehlen — der naechste
Ansichtswechsel wirft. Galt schon fuer die 10 lazy Views, traf durch P0 nun auch
die Startseite. lib/veralteteVersion.ts faengt Vites `vite:preloadError` ab und
laedt EINMAL neu (Sperre in sessionStorage gegen Endlosschleife).

## Nachgemessen

  Start-Chunk gzip 111 411 B · dist gesamt 1 480 097 B (beide im Ampel-Budget)
  tsc --noEmit sauber · 17/17 Tests gruen · ESLint 0 Fehler

Im echten Browser gegen das lokale Backend geprueft: Einstellungen holen den
Token-Zustand von der Box, kein Passwort-Feld mehr, Knoepfe korrekt gesperrt,
beide Cockpit-Diagramme rendern (Achsen + Zeitachse sichtbar).

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

backend/routers/maintenance.py

@@ -1,19 +1,28 @@
-"""Wartungs-Endpoints: Update-Badge, OS-/Engine-Update, Reboot, Restart, Logs."""
+"""Wartungs-Endpoints: Update-Badge, OS-/Engine-Update, Reboot, Restart, Logs.
 
-from fastapi import APIRouter, Header, HTTPException
+v3-Umbau P1 (28.08.2026): Das Sudo-Passwort ist hier ersatzlos entfallen. Auf der Box
+gemessen — `sudo -n true` läuft durch, weil `/etc/sudoers` den Dienst-Nutzer mit
+`NOPASSWD: ALL` führt. Das Passwort wurde also nie gebraucht, lag aber im
+`localStorage` des Browsers und reiste bei jedem mutierenden Request mit. Sollte die
+sudoers-Zeile je fallen, meldet `services.maintenance` sauber `password_required`
+statt still zu scheitern — das ist dann ein Konfigurations-Signal und nichts, was man
+mit einem im Browser geparkten Geheimnis übertüncht.
+"""
+
+from fastapi import APIRouter, HTTPException
 from pydantic import BaseModel
-from services import maintenance
+from services import geheimnisse, maintenance
 
 router = APIRouter(prefix="/api")
 
 
-class SudoReq(BaseModel):
-    sudo_password: str | None = None
-
-
 class RestartReq(BaseModel):
     service: str
-    sudo_password: str | None = None
+
+
+class GeheimnisReq(BaseModel):
+    schluessel: str
+    wert: str | None = None
 
 
 @router.get("/maintenance/updates")
@@ -28,32 +37,32 @@ def update_details(kind: str) -> dict:
     return maintenance.update_details(kind)
 
 @router.post("/maintenance/check-updates")
-def check_updates(body: SudoReq) -> dict:
-    res = maintenance.check_updates_job(body.sudo_password)
+def check_updates() -> dict:
+    res = maintenance.check_updates_job()
     if isinstance(res, dict) and not res.get("ok", True):
         return res
     return res
 
 
 @router.post("/maintenance/os-update")
-def os_update(body: SudoReq) -> dict:
-    res = maintenance.os_update_job(body.sudo_password)
+def os_update() -> dict:
+    res = maintenance.os_update_job()
     if isinstance(res, dict) and not res.get("ok", True):
         return res
     return res
 
 
 @router.post("/maintenance/engine-update")
-def engine_update(body: SudoReq) -> dict:
-    res = maintenance.engine_update_job(body.sudo_password)
+def engine_update() -> dict:
+    res = maintenance.engine_update_job()
     if not res:
         raise HTTPException(400, "Kein Engine-Update-Befehl gesetzt (MC_ENGINE_UPDATE_CMD).")
     return res
 
 
 @router.post("/maintenance/swap-update")
-def swap_update(body: SudoReq) -> dict:
-    res = maintenance.swap_update_job(body.sudo_password)
+def swap_update() -> dict:
+    res = maintenance.swap_update_job()
     if not res:
         raise HTTPException(400, "Kein Router-Update-Befehl gesetzt (MC_SWAP_UPDATE_CMD).")
     return res
@@ -65,20 +74,34 @@ def hermes_update() -> dict:
 
 
 @router.post("/maintenance/update-all")
-def update_all(body: SudoReq) -> dict:
-    return maintenance.update_all_job(body.sudo_password)
+def update_all() -> dict:
+    return maintenance.update_all_job()
 
 
 @router.post("/maintenance/reboot")
-def reboot(body: SudoReq) -> dict:
-    return maintenance.reboot(body.sudo_password)
+def reboot() -> dict:
+    return maintenance.reboot()
 
 
 @router.post("/maintenance/restart")
 def restart(body: RestartReq) -> dict:
-    return maintenance.restart_service(body.service, body.sudo_password)
+    return maintenance.restart_service(body.service)
 
 
 @router.get("/maintenance/logs")
-def logs(service: str, lines: int = 200, x_sudo_password: str | None = Header(None)) -> dict:
-    return maintenance.logs(service, lines, x_sudo_password)
+def logs(service: str, lines: int = 200) -> dict:
+    return maintenance.logs(service, lines)
+
+
+@router.get("/maintenance/geheimnisse")
+def geheimnisse_status() -> dict:
+    """Nur der Zustand — ob ein Token gesetzt ist, niemals sein Wert."""
+    return geheimnisse.status()
+
+
+@router.post("/maintenance/geheimnisse")
+def geheimnisse_setzen(body: GeheimnisReq) -> dict:
+    """Setzt (oder löscht bei leerem Wert) ein Geheimnis in der Box-Ablage."""
+    if not geheimnisse.setzen(body.schluessel, body.wert):
+        raise HTTPException(400, f"Geheimnis '{body.schluessel}' konnte nicht gespeichert werden.")
+    return {"ok": True, **geheimnisse.status()}

backend/routers/models.py

@@ -4,7 +4,7 @@ import psutil
 from config import HF_DOWNLOAD_ENV, MODELS_DIR
 from fastapi import APIRouter, HTTPException
 from pydantic import BaseModel
-from services import budget, discover, hf, jobengine, llamaswap
+from services import budget, discover, geheimnisse, hf, jobengine, llamaswap
 from services.fit import evaluate_fit, max_ctx_for
 
 router = APIRouter(prefix="/api")
@@ -77,7 +77,9 @@ class InstallReq(BaseModel):
     quant: str = "Q4_K_M"
     ctx: int | None = None
     jinja: bool = False
-    hf_token: str | None = None
+    # Kein hf_token mehr im Request (v3-Umbau P1): der Token lag frueher im localStorage
+    # des Browsers und reiste hier mit. Jetzt liegt er auf der Box (services.geheimnisse)
+    # und wird unten von dort gelesen — die Oberflaeche sieht ihn nie wieder.
 
 
 @router.get("/hf/search")
@@ -144,8 +146,8 @@ def install(req: InstallReq) -> dict:
         args.append(info["mmproj"])
     args += ["--local-dir", str(target)]
     env = dict(HF_DOWNLOAD_ENV)
-    if req.hf_token:
-        env["HF_TOKEN"] = req.hf_token
+    if token := geheimnisse.hf_token():
+        env["HF_TOKEN"] = token
     job_id = jobengine.start_job(args, f"download {req.repo}", env=env,
                                  on_done=_apply_role if role else None)
     jobengine.attach_download_progress(job_id, str(target), info["total_bytes"])

backend/services/geheimnisse.py

@@ -0,0 +1,100 @@
+"""Geheimnis-Ablage auf der Box (v3-Umbau P1).
+
+WARUM ES DAS GIBT: Bis zum 28.08.2026 lagen das Box-Sudo-Passwort und der
+HuggingFace-Token im `localStorage` des Browsers und reisten bei jedem mutierenden
+Request mit (Header `X-Sudo-Password` **und** im JSON-Rumpf). Da der Dienst-Nutzer
+laut `/etc/sudoers` mit `NOPASSWD: ALL` läuft, wäre ein einziger XSS in der SPA
+gleichbedeutend mit Root auf der Box gewesen.
+
+Das Sudo-Passwort ist ersatzlos entfallen — auf der Box gemessen: `sudo -n true`
+läuft durch, es wurde also nie gebraucht. Bleibt der HF-Token; der liegt jetzt hier:
+eine Datei neben den anderen `mc2-*.json` unter MODELS_DIR, Rechte 0600, und er wird
+**nie** an den Browser zurückgegeben. Die Oberfläche erfährt nur, OB einer gesetzt ist.
+
+Absichtlich kein Verschlüsseln: Der Schlüssel müsste auf derselben Maschine liegen und
+wäre damit Theater. Der Gewinn ist, dass das Geheimnis den Browser gar nicht erst
+erreicht — nicht, dass die Datei unlesbar wäre.
+"""
+
+import json
+import logging
+import os
+from pathlib import Path
+
+from config import MODELS_DIR
+
+log = logging.getLogger(__name__)
+
+PFAD = Path(os.environ.get("MC_GEHEIMNISSE_PFAD", str(MODELS_DIR / "mc2-geheimnisse.json")))
+
+# Was hier abgelegt werden darf. Neue Schlüssel bewusst eintragen — so kann ein
+# fehlgeleiteter Request keine beliebigen Felder in die Datei schreiben.
+ERLAUBT = frozenset({"hf_token"})
+
+
+def _lesen() -> dict[str, str]:
+    """Ganze Ablage. Fehlt die Datei (frische Box, Windows-Entwicklungsrechner ohne
+    /srv/models), ist das kein Fehler, sondern schlicht 'nichts gesetzt'."""
+    try:
+        daten = json.loads(PFAD.read_text(encoding="utf-8"))
+        return {k: v for k, v in daten.items() if k in ERLAUBT and isinstance(v, str)}
+    except (OSError, ValueError):
+        return {}
+
+
+def _schreiben(daten: dict[str, str]) -> bool:
+    """Atomar über eine Nachbardatei, damit ein Absturz mittendrin keine halbe Datei
+    hinterlässt. Rechte 0600 werden VOR dem Umbenennen gesetzt — sonst gäbe es ein
+    Zeitfenster, in dem das Geheimnis world-readable auf der Platte liegt."""
+    try:
+        PFAD.parent.mkdir(parents=True, exist_ok=True)
+        tmp = PFAD.with_suffix(".json.tmp")
+        tmp.write_text(json.dumps(daten, indent=2, ensure_ascii=False), encoding="utf-8")
+        try:
+            os.chmod(tmp, 0o600)
+        except OSError:
+            pass  # Windows kennt keine Unix-Rechte — lokal harmlos, auf der Box greift es
+        tmp.replace(PFAD)
+        return True
+    except OSError as exc:
+        log.warning("Geheimnis-Ablage nicht schreibbar (%s): %s", PFAD, exc)
+        return False
+
+
+def hf_token() -> str | None:
+    """Der HF-Token für Modell-Downloads. Reihenfolge: Prozess-Env schlägt Datei —
+    so kann die systemd-Unit ihn setzen, ohne dass jemand die Oberfläche anfassen muss."""
+    return os.environ.get("HF_TOKEN") or _lesen().get("hf_token") or None
+
+
+def setzen(schluessel: str, wert: str | None) -> bool:
+    """Setzt oder löscht (wert=None oder leer) ein Geheimnis."""
+    if schluessel not in ERLAUBT:
+        return False
+    daten = _lesen()
+    if wert:
+        daten[schluessel] = wert
+    else:
+        daten.pop(schluessel, None)
+    return _schreiben(daten)
+
+
+def status() -> dict[str, bool]:
+    """Was die Oberfläche erfahren darf: nur, OB etwas gesetzt ist — nie der Wert.
+    `aus_env` sagt dem Nutzer, warum ein Löschen in der Oberfläche wirkungslos bliebe."""
+    daten = _lesen()
+    return {
+        "hf_token_gesetzt": bool(daten.get("hf_token") or os.environ.get("HF_TOKEN")),
+        "hf_token_aus_env": bool(os.environ.get("HF_TOKEN")),
+        "schreibbar": _schreibbar(),
+    }
+
+
+def _schreibbar() -> bool:
+    """Ehrlich melden, wenn die Ablage nicht beschreibbar ist (z. B. lokal auf Windows
+    ohne /srv/models) — sonst speichert die Oberfläche scheinbar erfolgreich ins Leere."""
+    try:
+        PFAD.parent.mkdir(parents=True, exist_ok=True)
+        return os.access(PFAD.parent, os.W_OK)
+    except OSError:
+        return False

backend/services/jobengine.py

@@ -57,39 +57,29 @@ def _pump_output(job: dict, stream) -> None:
         commit()
 
 
-def _run_job(job_id: str, args: list[str], env: dict | None = None, sudo_password: str | None = None):
+def _run_job(job_id: str, args: list[str], env: dict | None = None):
+    """Job-Prozess starten und mitschreiben.
+
+    v3-Umbau P1 (28.08.2026): Hier wurde frueher ein Sudo-Passwort aus dem Browser an
+    stdin gefuettert (und dafuer `sudo -n` in den Argumenten zu `sudo -S` umgeschrieben).
+    Auf der Box laeuft sudo passwortlos (`NOPASSWD: ALL`), der Pfad war tot. Ohne ihn
+    braucht der Prozess auch keine stdin-Pipe mehr: DEVNULL sorgt dafuer, dass ein Job,
+    der wider Erwarten nach einem Passwort fragt, sofort scheitert statt still zu haengen."""
     job = JOBS[job_id]
     job["state"] = "running"
     try:
-        actual_args = list(args)
-        if sudo_password is not None:
-            for i, arg in enumerate(actual_args):
-                if isinstance(arg, str):
-                    actual_args[i] = arg.replace("sudo -n", "sudo -S").replace("sudo ", "sudo -S ")
-
         proc = subprocess.Popen(
-            actual_args, stdout=subprocess.PIPE, stderr=subprocess.STDOUT,
-            stdin=subprocess.PIPE if sudo_password is not None else None,
+            list(args), stdout=subprocess.PIPE, stderr=subprocess.STDOUT,
+            stdin=subprocess.DEVNULL,
             bufsize=0,
             env={**os.environ, **(env or {})},
         )
         _PROCS[job_id] = proc
 
-        if sudo_password is not None and proc.stdin:
-            proc.stdin.write((sudo_password + "\n").encode("utf-8"))
-            proc.stdin.flush()
-            proc.stdin.close()
-
         _pump_output(job, proc.stdout)
         proc.wait()
         job["returncode"] = proc.returncode
         job["state"] = "canceled" if job.get("canceled") else ("done" if proc.returncode == 0 else "failed")
-        
-        # Check if failed due to sudo authorization failure
-        if proc.returncode != 0 and job["log"]:
-            log_str = "\n".join(job["log"])
-            if "a password is required" in log_str or "password" in log_str.lower() or "sudo:" in log_str:
-                job["sudo_failed"] = True
     except Exception as exc:
         _append_log(job, f"[mc] Fehler: {exc}")
         job["state"] = "failed"
@@ -148,9 +138,8 @@ def attach_download_progress(job_id: str, local_dir: str, total_bytes: int) -> N
 
 
 def start_job(args: list[str], label: str, env: dict | None = None, on_done=None,
-              sudo_password: str | None = None, group: str | None = None) -> str:
+              group: str | None = None) -> str:
     job_id = uuid.uuid4().hex[:12]
-    # Mask password in log if present in args
     log_args = list(args)
     JOBS[job_id] = {
         "id": job_id, "label": label, "state": "queued", "group": group,
@@ -159,7 +148,7 @@ def start_job(args: list[str], label: str, env: dict | None = None, on_done=None
     }
     if on_done:
         JOBS[job_id]["_on_done"] = on_done
-    threading.Thread(target=_run_job, args=(job_id, args, env, sudo_password), daemon=True).start()
+    threading.Thread(target=_run_job, args=(job_id, args, env), daemon=True).start()
     return job_id