English · Deutsch
LX Family · Private Family OS für Kalender, Aufgaben, Essen, Einkauf, Chat, Cloud und Kinderabenteuer.
Läuft auf eurem Server. Gehört eurer Familie.
> **Neuer Name, sichere Updates:** Aus **LX Family Planner** wird **LX Family**
> mit dem Untertitel **Private Family OS**. Repository, Docker-Image und
> Android-Paketkennung bleiben absichtlich unverändert, damit bestehende
> Installationen ganz normal aktualisieren. Mehr dazu unter
> [Namensänderung](docs/RENAMING.md).
## Ausprobieren – ohne Installation
> [!TIP]
> **[Live-Demo öffnen](https://familie.laxxx-lab.de/)**
> Familie: `Demo` · Passwort: `demo`
> Wähle danach Doris für die Erwachsenenansicht oder Jeremy Pascal für die
> Kinderwelt. Die öffentliche Demo ist ein gemeinsamer, schreibgeschützter
> Schauraum – bitte keine persönlichen Daten eingeben.
## Warum LX Family?
| Alles an einem Ort | Kinder machen wirklich mit | Eure Daten bleiben eure |
| --- | --- | --- |
| Kalender, Aufgaben, Einkauf, Essen, Chat, Dateien und Erinnerungen greifen ineinander. | Eigene Welten, Missionen, Sterne, Routinen, Sparziele und ein Belohnungsshop statt Erwachsenen-UI in klein. | Self-hosted mit SQLite, Docker, sicheren Backups und optionaler Nextcloud – ohne Werbetracking. |
## Ein Blick in die App
| Profilauswahl für die ganze Familie | Eigene Kinderwelt |
| --- | --- |
|  |  |
### Jede Rolle bekommt ihren eigenen Raum
| Kinderreise mit Routinen, Schule und Abzeichen | Haustierprofil ohne unnötige Kontofunktionen |
| --- | --- |
|  |  |
### Familienalltag, Dateien und Verwaltung
| Gemeinsamer Kalender | Family Cloud direkt in LX |
| --- | --- |
|  |  |
| Aufgaben mit Freigabe und Sternen | Elternzentrale |
| --- | --- |
|  |  |
Noch mehr ansehen: Mobile Ansicht, Chat und weitere Themenwelten
| Mobiler Familienchat | Raketenwelt |
| --- | --- |
|  |  |
| Waldruhe | Backstage |
| --- | --- |
|  |  |
## In 5 Minuten startklar
```bash
git clone https://github.com/laxxx-lab/lx-family-planner.git
cd lx-family-planner
cp .env.example .env
sed -i "s/^APP_SECRET=.*/APP_SECRET=$(openssl rand -hex 32)/" .env
docker compose up -d --build
```
Danach `http://SERVER-IP:3001` öffnen, Familie anlegen und losplanen. Unter
Windows erledigt `Start-Familienplaner.cmd` dieselben Schritte bequem per
Doppelklick. Für Proxmox gibt es weiter unten einen eigenen LXC-Helper.
### App-Stores für Heimserver
Neben Docker und dem Proxmox-Helper liegen im Repository prüfbare Pakete für
Unraid, Umbrel, CasaOS und Cosmos. CasaOS und Cosmos verwenden nur den
schlanken LX-Family-Container; Nextcloud und weitere Dienste verbindet ihr bei
Bedarf später innerhalb der Elternzentrale. Details für Tests und
Store-Einreichungen stehen unter [Store-Veröffentlichungen](docs/STORE_SUBMISSIONS.md).
> **Eigener Server, eigene Adresse:** LX Family betreibt keinen Dienst für
> Familien. Jede Installation bleibt auf eurer IP oder eigenen Domain. Die
> vollständige Anleitung für Heimnetz, HTTPS-Domain, Android-App und CORS steht
> unter [Selbst hosten](docs/SELF_HOSTING.md).
### Private Anmeldung und neue Familien
LX zeigt Familiennamen vor der Anmeldung standardmäßig **nicht öffentlich an**.
Die Familie gibt ihren Namen und ihr Familienpasswort selbst ein. Auch die
Registrierung ist sicher voreingestellt: Mit `REGISTRATION_MODE=first-family`
darf sich nur die erste Familie selbst anlegen; anschließend schließt der Server
die Registrierung automatisch.
Wer auf einer Installation kontrolliert weitere Familien aufnehmen möchte,
verwendet einen langen persönlichen Einladungscode:
```env
REGISTRATION_MODE=invite
REGISTRATION_INVITE_CODE=hier-einen-langen-zufaelligen-code-eintragen
PUBLIC_FAMILY_DIRECTORY=false
```
`REGISTRATION_MODE=open` ist ausschließlich für bewusst öffentlich betriebene
Mehrfamilien-Portale gedacht. `PUBLIC_FAMILY_DIRECTORY=true` veröffentlicht
Familiennamen und Profilanzahlen bereits vor der Anmeldung und sollte im Internet
nicht verwendet werden.
## Das ist enthalten
- Familienkonten mit Profilen für Mama, Papa, Kind, Oma, Opa und weitere Rollen
- abgesicherte Ersteinrichtung: Mindestens ein angemeldetes Erwachsenenprofil
behält Verwaltungsrechte; ältere ausgesperrte Haushaltsprofile werden beim
Update automatisch repariert
- beliebig viele verwaltete Organisationsprofile ohne eigene Anmeldung, etwa
für Oma, Opa oder betreute Personen; mit Kalender und Aufgaben, aber ohne
Chat, Punkte oder Profilwechsel
- kinderleichte Bubble-Profilauswahl und optionaler Profil-PIN
- Kalender mit mehreren Erinnerungen pro Termin, Müllkalender, ICS-Dateiimport
und automatisch aktualisierte Kalender-Abos
- automatische Familiengeburtstage aus den Profilen mit Kalenderterminen und
Erinnerungen eine Woche vorher sowie am Geburtstag
- gemeinsamer Familienchat, geschützte Direktnachrichten, bewusst
eingeladene Chatgäste und Cloud-Anhänge für Fotos, Videos, Audio,
Dokumente, ZIP-Dateien und APKs bis 100 MB
- Einkaufslisten mit großem, alltagstauglichem Produktkatalog und Bring!-Anbindung
- Wochen-Speiseplan, Rezeptbuch, direkter Android-Teilen-Import, sicherer Web-,
Pinterest- und Facebook-Reel-Import mit Prüfansicht, Tandoor-Exportimport,
My-Recipe-Box-Import per Teilen oder `.rtk`-Backup, vollständiger
Rezepteditor und Kochmodus
- persönliche und gemeinsame Aufgaben, faire Sterne-Zuordnung und
Belohnungsshop
- Familienreise mit Morgen-/Abendroutinen, Wochenrückblick, Abzeichen,
Mutmachern und gemeinsamen Missionen
- geschütztes Taschengeldbuch mit Sparzielen und optionaler
Sterne-zu-Taschengeld-Umwandlung
- Schulbereich mit Stundenplan, Hausaufgaben, Klassenarbeiten und
Schulranzen-Checkliste
- Familien-Abstimmungen mit einer Stimme pro Profil
- faire Aufgabenrotation: wiederkehrende Pflichten wechseln automatisch
zwischen ausgewählten Familienmitgliedern
- Vier-Augen-Prinzip: Kinder melden eine Aufgabe als erledigt, der Ersteller
bestätigt sie und erst danach werden Sterne gutgeschrieben
- Pinnwand, detailliertes Familiennetz und Stammbaum zwischen angemeldeten
Familien
- privater Familienbriefkasten für längere Absprachen zwischen bestätigten
Familienverbindungen
- einzeln bestätigte Familienfreigaben für gemeinsame Termine, Aufgaben,
Sterne, Belohnungen und Taschengeld der Enkelkinder
- native Home-Assistant-Kacheln mit Live-Status, sicheren Aktionen,
Profilfreigaben und großer Tablet-Ansicht
- optionale Family Cloud mit Nextcloud, gemeinsamen und persönlichen
Profilordnern, Ordnerwahl vor Uploads, integrierter Dateiübersicht,
Drag-and-drop-Upload, Zwei-Wege-Kalenderabgleich und verschlüsselten
Sicherungen
- Elternzentrale für Profile, Aufgaben, Punktestände und Geräte sowie
freigegebene YouTube-/Spotify-Widgets mit echten Medien-Covern
- eigene Kinderoberfläche mit Raketen-, Einhorn-, Feen-, Dino-, Sonnen- und
Heldenwelt
- Erwachsenen-Themes von Waldruhe und Küstenruhe bis Backstage und Neon Nacht
- zusätzliche ruhige Themes ohne Motive sowie ein getrennt gespeichertes,
serverseitig geprüftes Custom-CSS-Theme für eigene Farben und Rundungen
- echte profilgebundene Android-App-Benachrichtigungen, Browser-Push und
optionale Gotify-Anbindung
- einstellbare Benachrichtigungsruhe und Medienzeiten für Kinderprofile
- schnell erreichbare Notfallkarte mit elterngeschützter Bearbeitung
- dauerhaftes, profilgetrenntes Meldungszentrum mit gelesen/ungelesen
- Familien-Posteingang mit persönlichem Tagesüberblick für Termine, Aufgaben,
Essen und Einkauf
- wiederkehrende Aufgaben für täglich, werktags, wöchentlich und monatlich
- frei anpassbare Dashboard-Kacheln pro Profil und Gerät mit eigener
Tablet-Anordnung, Sichtbarkeit, kompakter Ansicht und einer dynamischen
Müllabfuhr-Kachel kurz vor dem Abholtermin
- eigenständiger Tablet Mode mit acht Kacheln für das Querformat
- responsive Darstellung für PC, Tablet und Smartphone
- globaler „Problem melden“-Knopf mit lokaler Verwaltung in der Elternzentrale
- sichtbare Produktversion in den Familieneinstellungen und im Systemstatus
### Profile ohne eigenen Zugang
Erwachsene können in der Profilverwaltung bei einem neuen Profil **Nur von uns
verwaltet** auswählen. Das Profil bleibt anschließend aus der Anmeldung und dem
Profilwechsel ausgeblendet. Im Kalender, in der Aufgabenplanung und in der
Elternzentrale kann es trotzdem wie jede andere Person ausgewählt werden.
Diese Profile sind für reine Organisation gedacht. Sie erhalten keinen Chat,
keine eigenen Push-Geräte, keine Kinderpunkte und keinen eigenen Zugang zum
Familienplaner. Terminerinnerungen für ein verwaltetes Profil gehen automatisch
an die zuständigen Erwachsenen.
### Familienkonten sicher miteinander verbinden
Großeltern mit einem eigenen Familienkonto werden über **Euer Familiennetz**
eingeladen. Nach der gegenseitigen Bestätigung legt jede Familie selbst fest,
was die andere Seite darf:
- Einladungen zu gemeinsam sichtbaren Terminen
- Aufgaben für Kinder und Teenager
- Sternpunkte und eigene Belohnungen
- Taschengeldbuchungen
Private Kalendertermine, Direktnachrichten, Pinnwandbilder und Zugangsdaten
werden dabei nicht geteilt. Aufgaben eines verbundenen Großelternkontos müssen
weiterhin von einem Erwachsenen im Familienkonto des Kindes bestätigt werden.
Bestätigte Familien können sich außerdem unter **Familienpost** private Briefe
senden und beantworten. Ein Brief ist nur für die Erwachsenenprofile der
beiden beteiligten Familien sichtbar.
Für den Gruppenchat lässt sich ein einzelnes Erwachsenenprofil gezielt
einladen, zum Beispiel Oma oder Opa. Das Zielprofil muss die Einladung selbst
annehmen. Es sieht erst danach neue Gruppennachrichten der einladenden Familie;
frühere Verläufe und sämtliche Direktnachrichten bleiben verborgen. Die
einladende Familie kann den Zugang jederzeit wieder beenden.
### Home Assistant
Home Assistant wird in der **Elternzentrale** verbunden. Benötigt werden die
interne Adresse der Home-Assistant-Instanz und ein langlebiger Zugriffsschlüssel
aus dem Home-Assistant-Profil. Danach werden nur die ausdrücklich ausgewählten
Geräte und Sensoren als Dashboard-Kacheln angezeigt.
Eltern können pro Entität festlegen:
- nur anzeigen oder auch bedienen,
- welche Kinderprofile die Kachel sehen dürfen,
- ob die Integration vorübergehend aktiv ist.
Türschlösser und Alarmanlagen werden nicht freigegeben. Garagentore und
Einfahrten bleiben Erwachsenen vorbehalten und verlangen eine zusätzliche
Bestätigung. Der Zugriffsschlüssel wird verschlüsselt im Backend gespeichert
und niemals an den Browser ausgeliefert.
Bei Docker sollte als Adresse vorzugsweise die feste Heimnetz-IP verwendet
werden, zum Beispiel:
```text
http://192.168.178.50:8123
```
Eine `.local`-Adresse funktioniert abhängig vom Docker- und Netzwerksystem
nicht immer zuverlässig.
### Family Cloud mit Nextcloud
Nextcloud wird über den eigenen Hauptmenüpunkt **Family Cloud** verbunden.
Dieser Bereich ist ausschließlich für Erwachsenenprofile sichtbar. LX Family
bleibt dabei die führende Stelle für Profile, Kinderfreigaben, Aufgabenpunkte
und Belohnungen. Nextcloud übernimmt:
- einen frei wählbaren Kalender mit automatischem Abgleich in beide Richtungen,
- einen gemeinsamen Ordner für die Familie,
- tägliche und manuelle, verschlüsselte Familien-Backups.
Termine werden nicht nur kopiert. Änderungen und Löschungen werden dauerhaft
zugeordnet. Wenn derselbe Termin zwischen zwei Abgleichen in beiden Systemen
geändert wurde, gewinnt die lokale Fassung und LX legt zusätzlich eine klar
markierte Nextcloud-Konfliktkopie ab. Dadurch geht keine Fassung unbemerkt
verloren.
Aufgaben und Kinderpunkte bleiben bewusst in LX Family: Ein in Nextcloud
abgehakter Task darf das Vier-Augen-Prinzip für Kinder nicht umgehen.
#### Nextcloud zusammen mit Docker starten
Unter Windows genügt nach dem normalen LX-Start ein Doppelklick auf:
```text
Nextcloud-Aktivieren.cmd
```
Unter Linux:
```bash
./scripts/nextcloud-enable.sh
```
In einer Installation über den Proxmox-Helper:
```bash
lx-family nextcloud
```
Mit bereits eingerichteter Cloudflare- oder Reverse-Proxy-Adresse kann die
öffentliche Domain direkt mitgegeben werden:
```bash
lx-family nextcloud https://cloud.example.de
```
Das Hilfsskript:
1. aktiviert das optionale Docker-Profil `nextcloud`,
2. erzeugt getrennte, zufällige Kennwörter für Nextcloud, MariaDB und Redis,
3. ergänzt Servername und Heimnetz-IP als vertrauenswürdige Adressen,
4. startet Nextcloud samt Datenbank, Redis und Cron-Dienst,
5. wartet auf die vollständige Einrichtung und ergänzt nach Möglichkeit die
offizielle Nextcloud-Kalenderoberfläche.
Der erste Start kann zwei bis fünf Minuten dauern. Standardmäßig ist Nextcloud
anschließend unter `http://IP-DES-SERVERS:8080` erreichbar. Benutzer und
einmaliges Startpasswort zeigt das Hilfsskript an; beides steht zusätzlich in
der lokalen, von Git ausgeschlossenen `.env`.
Danach richtet LX alle bereits vorhandenen Familien automatisch ein. Neue
Familien erhalten ihren Cloud-Bereich direkt nach der Registrierung. Der
Knopf **Family Cloud automatisch einrichten** bleibt als manuelle Reparatur-
und Neueinrichtungsoption sichtbar. LX erstellt serverseitig:
- einen eigenen, getrennten Nextcloud-Benutzer für diese Familie,
- ein zufälliges Kennwort und ein widerrufbares App-Passwort,
- standardmäßig 10 GB Speicherplatz,
- einen Familienkalender sowie die Bereiche `Familie`, `Familie/Uploads`,
`Familie/Chat` und einen persönlichen Ordner unter `Profile` für jedes
echte Nutzerprofil,
- den ersten sicheren Zwei-Wege-Abgleich.
Die Trennung erfolgt absichtlich pro Familie und nicht pro Profil: Mama, Papa
und freigegebene Familienprofile arbeiten in LX mit demselben Familienarchiv.
Kinder oder verwaltete Organisationsprofile benötigen deshalb kein eigenes
Nextcloud-Passwort. Eine in LX ausdrücklich getrennte Cloud wird bei späteren
Neustarts nicht automatisch wieder verbunden.
Sobald die Verbindung steht, erscheint im selben Bereich das
**Familienarchiv**. Erwachsene können dort direkt in LX:
- Ordner öffnen und neu anlegen,
- Bilder, PDF- und Textdateien ansehen,
- mehrere Dateien auswählen oder vom PC in die Fläche ziehen; vor einem
Dashboard-Upload wird der Zielordner gewählt und kann direkt neu angelegt
werden,
- Dateien herunterladen oder nach einer zweiten Bestätigung löschen.
Uploads sind auf 100 MB pro Datei und 20 Dateien je Durchlauf begrenzt. Im
Stammverzeichnis legt LX bewusst keine losen Dateien ab. Neue Chat-Anhänge
landen automatisch unter `Familie/Chat/Jahr-Monat`; Bilder, Videos, Audio,
PDF-/Office-Dokumente, Archive und APKs bleiben dort als Originaldateien
erhalten, während der Chat nur den geschützten Verweis speichert. Der
Inhalt von Direktnachrichten wird zusätzlich vor dem Cloud-Upload
verschlüsselt und ist ausschließlich für die beiden Chatprofile über LX
lesbar. Der
Browser erhält kein Nextcloud-App-Passwort: Alle Dateizugriffe laufen durch die
angemeldete LX-Sitzung und das Backend. Belegter und verfügbarer Speicher
werden direkt im Familienarchiv angezeigt.
Das Administratorkonto wird nicht als Familienkonto verwendet. Auch mehrere
Familien auf demselben Portal erhalten dadurch getrennte Cloud-Bereiche. Das
zufällige Web-Kennwort und das App-Passwort liegen mit `APP_SECRET`
verschlüsselt in SQLite. Erwachsene können den Web-Zugang bei Bedarf unter
**Verbindung verwalten → Cloud-Zugang anzeigen** gezielt laden und kopieren;
die Antwort wird nicht im Browser-Cache gespeichert.
Für eine bereits vorhandene Nextcloud bleibt die manuelle Verbindung erhalten.
Im Nextcloud-Profil unter **Persönliche Einstellungen → Sicherheit** dafür ein
neues App-Passwort nur für `LX Family` erzeugen:
| Feld | Mitgelieferte Docker-Cloud | Vorhandene Nextcloud |
| --- | --- | --- |
| Adresse für LX Family | automatisch `http://nextcloud` | vom LX-Server erreichbare URL |
| Adresse für Browser | `http://SERVER-IP:8080` | öffentliche oder Heimnetz-URL |
| Benutzer | automatisch pro Familie | Nextcloud-Benutzer |
| App-Passwort | automatisch erzeugt | neu erzeugtes App-Passwort |
Die interne Adresse wird nur vom Backend verwendet. Zugangsdaten gelangen
nicht an den Browser und werden mit `APP_SECRET` verschlüsselt in SQLite
gespeichert.
Die Browser-Adresse wird bei öffentlichen Planer-Domains **nicht** durch
Anhängen von `:8080` erraten. `familie.example.de:8080` wäre nur dann gültig,
wenn genau dieser Port öffentlich weitergeleitet wurde. Maßgeblich ist
`NEXTCLOUD_PUBLIC_URL`:
```env
# nur im Heimnetz
NEXTCLOUD_PUBLIC_URL=http://192.168.178.50:8080
# nach Einrichtung einer eigenen HTTPS-Proxy-Route
NEXTCLOUD_PUBLIC_URL=https://cloud.example.de
```
Für öffentlichen Zugriff empfiehlt sich eine eigene Subdomain, die im
Reverse-Proxy oder Cloudflare Tunnel auf den internen Nextcloud-Dienst
`http://SERVER-IP:8080` zeigt. Erst nachdem diese Route wirklich antwortet,
wird `NEXTCLOUD_PUBLIC_URL` auf die HTTPS-Adresse umgestellt.
Für eine bereits laufende Docker-/PVE-Installation übernimmt das folgende
Kommando alle erforderlichen Nextcloud-Einstellungen:
```bash
cd /opt/docker/lx-family-planner
bash scripts/nextcloud-public-url.sh https://cloud.example.de
```
Es ergänzt die Domain dauerhaft in `.env` und Nextclouds `trusted_domains`,
setzt die öffentliche Link-Adresse sowie HTTPS und lädt LX Family mit der
neuen Browser-Adresse neu. Der Befehl ist wiederholbar und entfernt keine
bestehenden Vertrauensadressen.
#### Daten und Updates
Die Nextcloud-Daten liegen in den drei unabhängigen Docker-Volumes
`nextcloud-html`, `nextcloud-db` und `nextcloud-redis`. Normale LX-Updates
erstellen oder entfernen diese Volumes nicht. Auch `docker compose down`
behält sie. **Nicht** `docker compose down -v` verwenden, weil `-v` die
Nextcloud-Volumes ausdrücklich löscht.
Die `.env` und insbesondere `APP_SECRET` müssen zusammen mit den normalen
Serversicherungen aufbewahrt werden. Ohne denselben `APP_SECRET` können die
verschlüsselten LX-Family-Archive und Integrationstokens nach einer
Neuinstallation nicht entschlüsselt werden.
Eine bereits vorhandene Nextcloud muss nicht im LX-Docker-Stack laufen. Lokale
Heimnetz-Adressen sind für diese ausdrücklich eingerichtete Integration
erlaubt; Link-Local-, Multicast- und Geräte-Metadaten-Adressen bleiben
serverseitig gesperrt. Für Zugriff außerhalb des Heimnetzes werden HTTPS und
ein sauber konfigurierter Reverse Proxy empfohlen.
## Weg 1: Mit Docker starten (empfohlen)
### Einfach unter Windows
Voraussetzung ist eine laufende Installation von Docker Desktop. Danach genügt
ein Doppelklick auf:
```text
Start-Familienplaner.cmd
```
Das Startskript:
1. erzeugt beim ersten Start eine lokale `.env` mit sicherem Anwendungsschlüssel,
2. übernimmt einen vorhandenen Altbestand nach `data/`,
3. baut den Produktions-Container,
4. startet ihn auf Port `3001`.
Auf dem Server-PC ist die App anschließend unter
`http://localhost:3001` erreichbar. Andere Geräte im selben Heimnetz öffnen:
```text
http://IP-DES-SERVERS:3001
```
Beispiel:
```text
http://192.168.178.40:3001
```
Falls Windows Verbindungen aus dem Heimnetz blockiert, kann
`Heimnetz-Freigabe.cmd` einmal als Administrator ausgeführt werden. Das Skript
erlaubt Port `3001` nur in privaten Netzwerken. Eine Portfreigabe am Router ist
für den reinen Heimnetzbetrieb nicht nötig und wird nicht empfohlen.
Weitere Helfer:
- `Update-Familienplaner.cmd` lädt Updates, prüft sie auf einer Kopie der
Datenbank und spielt sie mit automatischer Rückfallmöglichkeit ein.
- `Stop-Familienplaner.cmd` beendet die App, ohne Daten zu löschen.
- `Backup-Familienplaner.cmd` erzeugt eine konsistente SQLite-Sicherung.
- Ein erneuter Start baut geänderten Programmcode automatisch neu.
### Docker manuell
```powershell
Copy-Item .env.example .env
```
Danach in `.env` mindestens `APP_SECRET` durch einen langen, zufälligen Wert
ersetzen und starten:
```powershell
docker compose up -d --build
```
Status und Protokoll:
```powershell
docker compose ps
docker compose logs -f family-planner
```
Stoppen:
```powershell
docker compose down
```
Die aktiven Daten liegen in `data/`, Sicherungen in `backups/`. Beide Ordner
werden absichtlich nicht in Git aufgenommen.
### Fertiges Docker-Image verwenden
Für Server, NAS-Systeme und App-Stores wird jede veröffentlichte Version
zusätzlich als fertiges Image für AMD64 und ARM64 bereitgestellt:
```text
ghcr.io/laxxx-lab/lx-family-planner:latest
```
Damit muss LX auf dem Zielserver nicht mehr aus dem Quellcode gebaut werden:
```bash
mkdir -p lx-family-planner && cd lx-family-planner
curl -fsSLo compose.yaml https://github.com/laxxx-lab/lx-family-planner/releases/latest/download/compose.yaml
curl -fsSLo .env https://github.com/laxxx-lab/lx-family-planner/releases/latest/download/env.example
sed -i "s/^APP_SECRET=.*/APP_SECRET=$(openssl rand -hex 32)/" .env
docker compose up -d
```
Die Daten bleiben in `data/`, Sicherungen in `backups/`. Eine bestimmte
Programmversion lässt sich mit `LX_FAMILY_VERSION=1.16.1` fest anheften.
## Proxmox VE Helper-Script
Für Proxmox VE gibt es einen eigenen One-Liner. Er wird in der
**Proxmox-Host-Shell als root** ausgeführt und erstellt einen neuen,
unprivilegierten Debian-LXC:
```bash
bash -c "$(curl -fsSL https://raw.githubusercontent.com/laxxx-lab/lx-family-planner/main/scripts/pve-helper.sh)"
```
Vor dem Ausführen kann das Skript vollständig angesehen werden:
```bash
curl -fsSL https://raw.githubusercontent.com/laxxx-lab/lx-family-planner/main/scripts/pve-helper.sh | less
```
Ein Trockenlauf prüft PVE, Speicher, Netzwerk und alle gewählten Werte, erstellt
aber noch keinen Container:
```bash
bash -c "$(curl -fsSL https://raw.githubusercontent.com/laxxx-lab/lx-family-planner/main/scripts/pve-helper.sh)" -- --dry-run
```
Die Standardinstallation verwendet:
- Proxmox VE 8.4 oder neuer
- Debian 13, mit automatischem Rückfall auf Debian 12
- unprivilegierten LXC mit `nesting` und `keyctl`
- 2 CPU-Kerne, 2 GB RAM, 512 MB Swap und 8 GB Speicher
- DHCP an `vmbr0` und Port `3001`
- Docker Engine aus dem offiziellen Docker-Repository
- zufällig erzeugtes App-Geheimnis und persistente Daten im LXC
Im erweiterten Modus lassen sich Container-ID, Speicher, Netzwerk, Ressourcen,
Port und öffentliche LX-Adresse anpassen. Eine bereits vergebene Container-ID
wird niemals überschrieben. Bei einem Installationsfehler bleibt der neue
Container zur Diagnose erhalten.
Nach der Installation:
```bash
pct enter CONTAINER_ID
lx-family status
lx-family update
lx-family backup
lx-family logs
lx-family restart
lx-family domain https://familie.example.de
lx-family doctor
```
Der Helper ist für eine **neue Installation** gedacht. Für den Umzug einer
bestehenden Familie zuerst ein Datenbank-Backup erstellen und dieses
anschließend bewusst in die neue Instanz übernehmen.
## Installation aus einem App-Store
LX Family ist für **Unraid Community Applications** und den
**Umbrel App Store** vorbereitet. Nach der Prüfung durch die jeweiligen
Store-Teams erscheint LX dort als normale App: Installieren anklicken,
Speicherort und Zugang festlegen, fertig.
### Unraid-Datenordner
Das Community-Applications-Template verwendet standardmäßig `PUID=99` und
`PGID=100` (`nobody:users`). Beim Start prüft LX die eingebundenen Ordner
`/app/data` und `/app/backups`, repariert ihre Schreibrechte und wechselt erst
danach auf diese eingeschränkte Benutzerkennung. Dadurch startet SQLite auch
bei einer frischen Unraid-Installation zuverlässig, ohne den Planer dauerhaft
als `root` laufen zu lassen.
Wer für Appdata eine andere Benutzerkennung verwendet, kann PUID und PGID in
der erweiterten Container-Konfiguration anpassen. Bereits vorhandene Dateien
und alle späteren Updates bleiben in den beiden Appdata-Ordnern erhalten.
Bis zur Freischaltung funktionieren Docker, das fertige GHCR-Image und der
Proxmox-Helper unverändert weiter. Die Store-Pakete und ihre Prüfschritte sind
unter [Store-Veröffentlichungen](docs/STORE_SUBMISSIONS.md) dokumentiert.
## Bequem und sicher aktualisieren
### Docker unter Windows
Ein Doppelklick genügt:
```text
Update-Familienplaner.cmd
```
Das Update läuft bewusst in dieser Reihenfolge:
1. Nur bei einem sauberen Programmordner wird die neue Git-Version geladen.
2. Das bisherige Docker-Abbild wird als Rückfallversion vorgemerkt.
3. Die neue Version wird gebaut, während der Planer noch erreichbar bleibt.
4. Danach wird die App kurz angehalten und eine konsistente SQLite-Sicherung
samt Prüfmanifest erstellt.
5. Alle Datenbankmigrationen laufen zuerst auf einer temporären Kopie dieser
Sicherung.
6. Erst nach erfolgreicher Simulation startet die neue Version.
7. Abschließend werden alle bereits vorhandenen Datensätze und gespeicherten
Einstellungen mit dem Stand vor dem Update verglichen.
Schlägt Start, Migration, Gesundheitscheck oder Datenvergleich fehl, stellt das
Skript automatisch die vorherige Docker-Version und die Sicherung wieder her.
Lokale Änderungen an Programmdateien werden nicht überschrieben. In diesem Fall
bricht das Update mit einer Erklärung ab. Absichtlich lokal bereitgestellter
Quellcode kann ohne Git-Abruf aktualisiert werden:
```powershell
powershell -File scripts/docker-update.ps1 -SkipPull
```
### Docker unter Linux
Im Projektordner:
```bash
bash scripts/docker-update.sh
```
Ohne Git-Abruf:
```bash
bash scripts/docker-update.sh --skip-pull
```
#### Stabile Releases automatisch einspielen
Auf einem Linux-Docker-Server kann LX einmalig für kontrollierte automatische
Updates eingerichtet werden:
```bash
sudo bash scripts/install-auto-update.sh
```
Der Server prüft täglich nachts das neueste **veröffentlichte stabile**
GitHub-Release. Einzelne Entwicklungs-Commits werden nicht installiert. Vor
jedem echten Update verwendet LX denselben geschützten Ablauf wie beim
manuellen Docker-Update:
- bisheriges Docker-Abbild als Rückfallversion vormerken
- konsistente Datenbanksicherung mit Prüfmanifest erstellen
- Migration zuerst auf einer Sicherungskopie simulieren
- neue Version starten und Gesundheitscheck ausführen
- Familieninhalte und Einstellungen mit dem vorherigen Stand vergleichen
- bei einem Fehler automatisch zur vorherigen Version zurückkehren
Nur prüfen, ohne etwas zu verändern:
```bash
bash scripts/docker-auto-update.sh --check
```
Zeitplan und letzter Lauf:
```bash
systemctl list-timers lx-family-planner-auto-update.timer
systemctl status lx-family-planner-auto-update.service
```
### Ohne Docker
Vor dem Austausch des Programmcodes:
```powershell
npm run backup
git pull --ff-only
npm ci
npm run check
```
Danach den laufenden Node-Prozess beziehungsweise den verwendeten Systemdienst
neu starten und prüfen:
```powershell
npm run audit
```
Die `.env` darf bei einem Update nicht ersetzt werden. Insbesondere
`APP_SECRET` muss gleich bleiben, weil damit Bring!, Gotify, Home Assistant,
private Kalenderlinks und Push-Schlüssel verschlüsselt werden.
### Was erhalten bleibt
Der Docker-Updater behält den Ordner `data/` als unabhängiges Volume. Das
Prüfmanifest kontrolliert unter anderem:
- Familienkonten, Profile, Rollen, PINs, Sterne und Profil-Themes
- Routinen, Taschengeldbuchungen, Sparziele, Schuleinträge und Abstimmungen
- Familien-Missionen, Mutmacher, Abzeichenfortschritt und Kinder-Begleiter
- Ruhezeiten, Medienzeitfenster und Notfallkontakte
- Kalendertermine, Aufgaben, Einkauf, Speisepläne und Mülltermine
- importierte Rezepte einschließlich Zutaten, Zubereitung und Bildern
- Pinnwandnotizen und Pinnwandbilder
- Chat, Familiennetz, Familienfreigaben, gemeinsame Termine, Medienlinks und
Dashboard-Inhalte
- Kalender-Abos, Bring!, Gotify, Home Assistant und deren verschlüsselte
Konfiguration
- lokal gespeicherte Problemmeldungen und ihr Bearbeitungsstatus
- Push-Geräte, Benachrichtigungseinstellungen und Familien-Posteingang
Gerätespezifische Komfortwerte wie das zuletzt aktive Profil, der ausgewählte
Haushalt, die Reihenfolge der Dashboard-Kacheln und ein zurückgestellter
Benachrichtigungshinweis liegen im Browser. Ein Update löscht diesen Speicher
nicht. Dafür müssen Adresse und Port der App gleich bleiben.
## Weg 2: Ohne Docker starten
Voraussetzungen:
- Node.js 22.13 oder neuer
- npm
Einmalig vorbereiten:
```powershell
Copy-Item .env.example .env
npm ci
npm run build
```
`APP_SECRET` in `.env` vor dem ersten produktiven Start durch einen langen,
zufälligen Wert ersetzen. Danach:
```powershell
npm start
```
Die App läuft unter `http://localhost:3001`.
Für die Entwicklung werden zwei Terminals verwendet:
```powershell
npm run server
```
```powershell
npm run dev
```
Vite läuft dann unter `http://localhost:3000` und leitet API-Anfragen an den
Server auf Port `3001` weiter.
## Externe Kalender verbinden
Eltern und Großeltern können im Familienkalender unter **Kalenderquellen**
veröffentlichte ICS-Links aus Google Kalender, Outlook, Nextcloud und anderen
Kalenderdiensten hinterlegen. Die Verbindung ist bewusst nur lesend:
- der geheime Kalenderlink wird verschlüsselt in SQLite gespeichert,
- Termine werden standardmäßig einmal pro Stunde aktualisiert,
- wiederkehrende Termine, Ausnahmen, Ganztagstermine und Zeitzonen werden
berücksichtigt,
- abonnierte Termine sind im Familienplaner als schreibgeschützt markiert,
- bei einem Verbindungsfehler bleiben die zuletzt erfolgreich gelesenen
Termine erhalten.
Kalender auf privaten Heimnetz-Adressen sind aus Sicherheitsgründen zunächst
gesperrt. Für einen lokalen Nextcloud- oder CalDAV-Server kann in `.env`
bewusst freigeschaltet werden:
```text
CALENDAR_ALLOW_PRIVATE_HOSTS=true
```
Link-Local- und Loopback-Adressen bleiben trotzdem gesperrt. Das
Aktualisierungsintervall lässt sich mit
`CALENDAR_SYNC_INTERVAL_MINUTES=60` anpassen.
## Terminerinnerungen
Beim Anlegen eines Termins lassen sich mehrere Erinnerungen kombinieren, zum
Beispiel **1 Tag**, **10 Stunden**, **1 Stunde** und **10 Minuten vorher**.
Eigene Termine können später über das Glockensymbol im Kalender angepasst
werden.
Die Prüfung läuft auf dem Server und nicht nur im geöffneten Browser:
- der Hinweis erscheint im Familien-Posteingang,
- Geräte mit aktiviertem Web-Push erhalten eine Systemmeldung,
- ein verbundener Gotify-Server kann die Erinnerung ebenfalls zustellen,
- bereits verschickte Erinnerungen werden in SQLite vermerkt und nicht doppelt
gesendet,
- nach einer kurzen Serverpause wird nur der sinnvollste noch offene Hinweis
nachgeholt.
Docker verwendet standardmäßig `Europe/Berlin`. Eine andere Zeitzone kann über
`TZ` in der `.env` gesetzt werden.
## Sprache der Oberfläche
Die App startet standardmäßig auf Deutsch. Über die Umgebungsvariable
`APP_LANGUAGE` in der `.env` kann die Standardsprache gewählt werden: `de`,
`en`, `fr`, `es`, `it`, `nl` oder `pl`. Zusätzlich gibt es vor der Anmeldung
und im Kopfbereich eine sichtbare Sprachwahl, die pro Gerät gespeichert wird.
Die Einstellung gilt für die Web-App, die Android-App und serverseitige
Benachrichtigungen. Details und Übersetzungs-Konventionen stehen in
[docs/i18n.de.md](docs/i18n.de.md).
## Rezepte aus dem Web importieren
Der Rezept-Finder liest öffentliche HTTPS-Seiten mit Schema.org- oder
h-recipe-Daten. Dadurch funktionieren neben Chefkoch, Lecker und vielen
weiteren Rezeptportalen auch Pinterest-Pins, die auf eine öffentliche
Original-Rezeptseite verweisen. Bei Pins mit direkt hinterlegten Zutaten wird
der lesbare Inhalt übernommen und gegebenenfalls mit einem Prüfhinweis
gekennzeichnet.
Öffentliche Facebook-Reels können als Link oder direkt über die Android-
Teilen-Funktion an LX übergeben werden. LX wertet den mitgesendeten
Beschreibungstext und einen verlinkten Original-Rezeptartikel aus. Ein aus
Social Media erkanntes Rezept wird niemals ungeprüft gespeichert: Zutaten und
Zubereitung öffnen sich zuerst als bearbeitbarer Entwurf. Private Reels und
Inhalte hinter einem Facebook-Login werden nicht umgangen.
Zum Schutz des Heimnetzes öffnet der Import keine privaten oder lokalen
Netzwerkadressen, keine Links mit eingebetteten Zugangsdaten und keine Seiten
hinter einem Login. Portale, die automatisierte Aufrufe vollständig blockieren,
müssen weiterhin manuell ins Kochbuch übertragen werden.
### Rezepte aus Tandoor Recipes übernehmen
LX liest das offizielle Tandoor-Standardexportformat direkt ein. In Tandoor
ein Rezept öffnen, über das Menü **Exportieren** wählen, bei Bedarf alle
Rezepte markieren und die erzeugte ZIP-Datei im LX-Rezept-Finder unter
**Aus Tandoor Recipes übernehmen** auswählen. Zutaten, Zubereitungsschritte,
Zeiten, Portionen und im Export vorhandene Bilder werden übernommen. Große
Sammlungen werden einzeln gespeichert, damit ein fehlerhaftes Rezept nicht die
gesamte Familienbibliothek unbrauchbar macht.
### Rezepte aus My Recipe Box übernehmen
Einzelne Rezepte lassen sich auf Android direkt aus **My Recipe Box** über
**Teilen → LX Familie** senden. Enthält die Freigabe einen Original-Link, liest
LX nach Möglichkeit die öffentliche Rezeptseite. Andernfalls werden der
geteilte Rezepttext, die Zutaten und die Zubereitung als bearbeitbarer Entwurf
geöffnet und erst nach der Prüfung gespeichert.
Für eine vollständige Sammlung in My Recipe Box unter **Synchronisieren /
Backup → Backup exportieren (RTK)** eine `.rtk`-Datei erstellen. In Android
anschließend **Teilen → LX Family** wählen; LX öffnet den Rezeptbereich
und startet den Import automatisch. Alternativ lässt sich die Datei weiterhin
im Rezept-Finder unter **Aus My Recipe Box übernehmen** auswählen. LX liest das
offene RTK-Format mit Rezepten, Bildern, Quellen, Kategorien und Stichwörtern.
Bereits übernommene Rezepte mit derselben My-Recipe-Box-ID werden übersprungen,
damit ein Backup nicht versehentlich doppelt importiert wird.
### Rezept direkt aus Chefkoch, Pinterest, Facebook oder My Recipe Box teilen
Sowohl die installierte LX-PWA als auch die Android-App registrieren sich auf
unterstützten Android-Geräten als Teilen-Ziel. Danach funktioniert der Ablauf
ohne Kopieren:
1. LX Family über die HTTPS-Adresse öffnen.
2. Im Browser **Zum Startbildschirm hinzufügen** beziehungsweise **App
installieren** wählen.
3. In Chefkoch, Pinterest, einem öffentlichen Facebook-Reel oder einer anderen
Rezept-App **Teilen** öffnen.
4. **LX Family** auswählen.
LX öffnet das Kochbuch, liest den geteilten Link und startet den sicheren
Rezeptimport. Die Funktion ist von der Web-Share-Target-Unterstützung des
Geräts abhängig; auf Android mit der LX-App oder einer installierten
Chromium-PWA ist sie am zuverlässigsten. Ohne Installation bleibt das Einfügen
eines Links im Rezept-Finder weiterhin möglich.
### Android-App herunterladen und bauen
Auf der öffentlichen Anmeldeseite zeigt LX automatisch die aktuelle
Android-App mit Versionsnummer, Dateigröße, Download-Knopf und QR-Code an. Der
QR-Code verweist immer auf die eigene Planer-Adresse, zum Beispiel
`https://familie.example.de/apk/latest.apk`.
Bei einem Aufruf über `localhost` wird bewusst kein QR-Code angezeigt, weil
`localhost` auf dem Handy das Handy selbst bezeichnet. Für lokale Tests die
Heimnetz-IP des Servers verwenden oder `PUBLIC_APP_URL` in `.env` auf die
öffentliche HTTPS-Adresse setzen.
Für einen neuen App-Build genügt unter Windows:
```powershell
npm run build:apk
```
Damit die APK echte Android-Benachrichtigungen empfangen kann, muss vorher
einmal Firebase Cloud Messaging eingerichtet werden:
1. In der [Firebase Console](https://console.firebase.google.com/) ein Projekt
anlegen.
2. Im Projekt eine Android-App mit dem Paketnamen
`com.lxfamily.planner` registrieren.
3. Die heruntergeladene `google-services.json` unter
`android/app/google-services.json` ablegen.
4. Unter **Projekteinstellungen → Dienstkonten** einen privaten
Dienstkontoschlüssel erzeugen und als
`data/firebase-service-account.json` auf dem LX-Server ablegen.
5. Den Server neu starten und danach `npm run build:apk` ausführen.
Beide Dateien müssen aus demselben Firebase-Projekt stammen. Das Build-Skript
bricht bewusst ab, wenn die Android-Datei fehlt oder den falschen Paketnamen
enthält; dadurch wird keine scheinbar fertige APK ohne funktionierenden
Android-Push verteilt.
`firebase-service-account.json` ist geheim und bleibt ausschließlich im
persistenten `data/`-Ordner. `google-services.json` enthält nur die
App-Projektzuordnung, bleibt in diesem Projekt aber ebenfalls lokal. Beide
Pfade stehen in `.gitignore`.
Das fertige Paket liegt anschließend als `LX-Family-Planner.apk` im
Projektordner. Beim ersten Durchlauf erzeugt das Skript automatisch einen
privaten Release-Schlüssel unter `data/android-signing/`. Danach verwendet
jeder Build denselben Schlüssel, damit Android spätere Versionen als Update
akzeptiert.
> **Wichtig:** `data/android-signing/` einmal sicher außerhalb des Servers
> sichern. Geht dieser Schlüssel verloren, können bestehende App-Installationen
> nicht mehr mit einer neu signierten APK aktualisiert werden.
Eine vorhandene professionelle Signatur kann stattdessen über diese lokalen
Variablen vorgegeben werden:
```text
LX_ANDROID_KEYSTORE
LX_ANDROID_STORE_PASSWORD
LX_ANDROID_KEY_ALIAS
LX_ANDROID_KEY_PASSWORD
```
Keystore und Passwörter werden nicht in Git aufgenommen. Die fertige,
signierte APK wird zusätzlich unter `public/apk/latest.apk` bereitgestellt und
ist damit Bestandteil des nächsten Docker- beziehungsweise Server-Updates. In
der App kann über das Server-Symbol eine andere HTTPS-Domain oder eine
Heimnetz-IP ausgewählt werden.
Der Build wird außerdem nach `data/apk/latest.apk` kopiert. Läuft der
Familienplaner aus demselben Projektordner beziehungsweise mit dem
Docker-Volume `data/`, weist eine ältere Android-App automatisch auf die neue
Version hin. Produktionsserver bieten ausschließlich signierte Release-Pakete
an.
## Benachrichtigungen
### Native Android-App-Benachrichtigungen
Die herunterladbare LX Android-App verwendet Firebase Cloud Messaging. Das ist
ein eigener nativer Kanal und kein Browser-Push in einer WebView. Meldungen
erscheinen deshalb im Android-Benachrichtigungsbereich, wenn die App im
Hintergrund liegt oder geschlossen ist.
Beim ersten Einschalten erklärt LX die Funktion und öffnet anschließend die
Android-Systemabfrage. Diese Abfrage erscheint pro App-Installation nur
einmal. Die eigentliche Auswahl wird getrennt pro Familienprofil und Gerät auf
dem LX-Server gespeichert und kann in den Profileinstellungen oder der
Elternzentrale jederzeit geändert werden.
Native Meldungen verwenden dieselben Regeln wie der Familien-Posteingang:
Chat, Direktnachrichten, Termine und Erinnerungen, Aufgaben,
Elternbestätigungen, Stimmungen und Hilfe-Anfragen, Problemmeldungen,
Belohnungen, Taschengeld, Schule, Abstimmungen, Missionen und Familiennetz.
Familienruhe und die private Sperrbildschirm-Vorschau gelten ebenfalls. Beim
Antippen öffnet die App direkt die passende Ansicht.
Für Docker ist keine zusätzliche Freigabe nötig: `./data` ist bereits als
persistentes Volume eingebunden. Nach dem Ablegen von
`data/firebase-service-account.json` genügt:
```bash
docker compose up -d --build family-planner
```
Ohne Docker wird derselbe Standardpfad verwendet. Alternativ kann
`FIREBASE_SERVICE_ACCOUNT_FILE` in `.env` auf einen anderen lokalen Pfad
zeigen. Der private Schlüssel wird nie an die Android-App oder einen Browser
ausgeliefert.
Voraussetzung auf dem Handy sind Google Play-Dienste. Wenn eine App in Android
manuell **Beenden erzwingen** gesetzt wird, stellt Android Benachrichtigungen
erst nach dem nächsten Öffnen wieder zu. Normales Wegwischen aus der
App-Übersicht ist kein Problem.
### Browser-Push
Browser-Benachrichtigungen werden pro Familienprofil und Gerät gespeichert. Ein
Gerät kann mehreren Profilen zugeordnet sein; in den Profileinstellungen lassen
sich einzelne Meldungsarten an- und ausschalten.
Unabhängig davon landen wichtige Ereignisse zusätzlich im profilgetrennten
Familien-Posteingang der App. Der Reiter **Heute** bündelt Termine, fällige
Aufgaben, Elternfreigaben, Speiseplan und Einkauf passend zum aktiven Profil.
Im Reiter **Meldungen** bleiben Aufgabenfreigaben, Termine und Chatnachrichten
nachvollziehbar, auch wenn ein Browser-Push nicht zugestellt wurde.
Gelesen/ungelesen wird zwischen den Geräten synchronisiert; alte Meldungen
werden nach 90 Tagen automatisch entfernt.
Echte Benachrichtigungen im Hintergrund benötigen eine vertrauenswürdige
HTTPS-Adresse. Eine reine Heimnetz-Adresse wie `http://192.168.x.x:3001` genügt
den Browsern dafür nicht. Empfohlen ist ein Reverse Proxy wie Caddy, Traefik
oder nginx vor Port `3001`. Die Adresse kann über internes DNS trotzdem auf das
Heimnetz beschränkt bleiben.
Als Alternative zur APK können Chrome und andere kompatible Browser Web Push
über den Service Worker empfangen. Dafür den Planer über die HTTPS-Adresse
öffnen, über **Zum Startbildschirm hinzufügen** installieren und anschließend
in der Elternzentrale das aktuelle Gerät für das gewünschte Profil anmelden.
Dieser Browserweg bleibt verfügbar, ist aber von Browser und
Energiespareinstellungen abhängiger als der native App-Kanal.
Auf iPhone und iPad muss die App zuerst zum Home-Bildschirm hinzugefügt und von
dort geöffnet werden.
### Gotify, Telegram und WhatsApp
- **Gotify:** bereits als unabhängiger Elternkanal integriert.
- **Telegram:** sinnvollster nächster Kanal. Geplant ist eine einmalige
Profilkopplung über QR-/Start-Link zu einem Familien-Bot, ohne dass Kinder
Tokens eingeben müssen.
- **WhatsApp:** technisch nur über die offizielle WhatsApp Business Platform
vorgesehen. Eine Kopplung eines privaten WhatsApp-Kontos über inoffizielle
Web-Sitzungen gehört bewusst nicht zum Produktionskonzept.
## Sicherheit und Daten
- Passwörter und Profil-PINs werden nicht im Klartext gespeichert.
- Sitzungen verwenden ein `HttpOnly`-Cookie.
- Familien und Direktnachrichten werden serverseitig voneinander isoliert.
- Bring!- und Nextcloud-Zugangsdaten, private Kalenderlinks und Push-Schlüssel
werden mit `APP_SECRET` verschlüsselt.
- Der Docker-Container läuft ohne Root-Rechte, mit schreibgeschütztem
Dateisystem, ohne Linux-Capabilities und mit `no-new-privileges`.
- Ohne `AGENT_API_KEY` bleibt die optionale Agent-Schnittstelle deaktiviert.
- SQLite läuft im WAL-Modus und kritische Punktebuchungen sind transaktional.
Wichtig: Wer `APP_SECRET` später ändert, muss verschlüsselte Integrationen wie
Bring! und Nextcloud erneut verbinden. Vorhandene `.lxbackup`-Archive benötigen
ebenfalls den ursprünglichen Schlüssel.
## Backups
Mit Docker:
```text
Backup-Familienplaner.cmd
```
Ohne Docker:
```powershell
npm run backup
```
Zu jeder neuen `.sqlite`-Sicherung wird eine Datei
`.sqlite.manifest.json` angelegt. Sie enthält keine Passwörter oder
Integrationstokens, sondern Prüfsummen, Datensatzkennungen und
Integritätsergebnisse. Damit kann nach einem Update erkannt werden, ob ein
bestehender Eintrag oder ein gespeichertes Einstellungsfeld fehlt oder verändert
wurde.
LX behält automatisch genau die **drei neuesten** vollständigen lokalen
Sicherungen samt Prüfmanifest. Während eines geschützten Updates bleibt bis zum
erfolgreichen Gesundheits- und Datencheck kurzzeitig eine vierte Sicherung als
Rückfallnetz erhalten.
Sicherungen sollten regelmäßig zusätzlich auf ein anderes Gerät oder Medium
kopiert werden. Ein Backup ist erst dann ein gutes Backup, wenn die
Wiederherstellung einmal getestet wurde.
Mit verbundener Family Cloud legt LX zusätzlich ein verschlüsseltes,
familiengetrenntes `.lxbackup` samt Prüfsummenmanifest unter
`LX Family/Backups` in Nextcloud ab. Dieses Archiv ersetzt nicht die lokale
Komplettsicherung des Servers, sorgt aber dafür, dass die Inhalte einer Familie
außerhalb des LX-Datenvolumes liegen.
## Konfiguration
Die Vorlage liegt in `.env.example`.
| Variable | Bedeutung |
| --- | --- |
| `APP_SECRET` | Pflicht in Produktion; verschlüsselt sensible lokale Daten |
| `PORT` | interner Server-Port, Standard `3001` |
| `HOST_PORT` | Port des Docker-Hosts, Standard `3001` |
| `PUBLIC_APP_URL` | öffentliche HTTPS-Adresse für App-Download und QR-Code |
| `DEMO_FAMILY_ID` | optional; schützt genau dieses Familienkonto als öffentliche Nur-Lese-Demo |
| `DATABASE_FILE` | abweichender Pfad zur SQLite-Datenbank |
| `LEGACY_DATABASE_FILE` | optionaler JSON-Altbestand für die erste Migration |
| `EVENT_REMINDER_INTERVAL_SECONDS` | Prüfintervall für fällige Terminerinnerungen |
| `FIREBASE_SERVICE_ACCOUNT_FILE` | optionaler Pfad zum privaten FCM-Dienstschlüssel; Standard `data/firebase-service-account.json` |
| `FIREBASE_PROJECT_ID` | optional; Firebase-Projektkennung, normalerweise aus dem Dienstschlüssel gelesen |
| `NEXTCLOUD_SYNC_INTERVAL_MINUTES` | regelmäßiger DAV-Abgleich, Standard `15` |
| `COMPOSE_PROFILES` | mit Wert `nextcloud` die mitgelieferte Family Cloud starten |
| `NEXTCLOUD_PORT` | Port der mitgelieferten Nextcloud, Standard `8080` |
| `NEXTCLOUD_PUBLIC_URL` | tatsächlich vom Familiengerät erreichbare Cloud-Adresse |
| `NEXTCLOUD_INTERNAL_URL` | interne Docker-Adresse; normalerweise `http://nextcloud` |
| `NEXTCLOUD_AUTO_PROVISION` | fehlende Familienkonten automatisch anlegen; Standard `true` |
| `NEXTCLOUD_FAMILY_QUOTA` | Speicherkontingent pro Familie; Standard `10GB` |
| `NEXTCLOUD_*_PASSWORD` | vom Aktivierungsskript zufällig erzeugte Cloud-, Datenbank- und Redis-Schlüssel |
| `NEXTCLOUD_TRUSTED_DOMAINS` | erlaubte Browsernamen und Heimnetz-Adressen für Nextcloud |
| `CORS_ALLOWED_ORIGINS` | zusätzliche, vertrauenswürdige Ursprünge nur für eine getrennt gehostete Weboberfläche; normale Browser- und Android-Installationen benötigen keinen Eintrag |
| `TRUST_PROXY` | nur hinter einem vertrauenswürdigen Reverse Proxy auf `1` setzen; bei direkt freigegebenem Docker-Port leer bzw. `false` lassen |
| `AGENT_API_KEY` | aktiviert optional die geschützte Agent-API |
| `VAPID_*` | optionale feste Web-Push-Schlüssel |
## Qualität prüfen
```powershell
npm run check
```
Der Befehl prüft die Serverdateien, führt den isolierten API-Smoke-Test aus und
erstellt einen vollständigen Produktions-Build.
Nur die aktive Datenbank kontrollieren:
```powershell
npm run audit
```
## Architektur
```text
Browser / PWA
│
├── React-Oberfläche und rollenabhängige Themes
├── Service Worker für Web Push
│
▼
Express API
├── Sitzungen und Berechtigungen
├── Familien-, Profil- und Integrationslogik
├── geschützter Echtzeit-Ereigniskanal
│
▼
SQLite
├── Familienisolierte Daten
├── verschlüsselte Integrationswerte
└── transaktionale Aufgaben- und Punktebuchungen
```
Wichtige Bereiche:
- `server/app.js` – HTTP-API, Sitzungen, Berechtigungen und Integrationen
- `server/database.js` – Schema, Migrationen und Transaktionen
- `src/context/FamilyContext.jsx` – zentraler Client-Datenzugriff
- `src/components/Auth` – Anmeldung und Familienkonto
- `src/components/Dashboard` – Erwachsenen-, Kinder- und Tablet-Dashboard
- `src/index.css` – Theme-System und responsive Produktoberfläche
## Projektstatus
Der Planer ist für den privaten, selbst gehosteten Familienbetrieb ausgelegt.
Vor Aktualisierungen sollte immer ein Backup erstellt werden. Zugang aus dem
öffentlichen Internet sollte nur über HTTPS, einen Reverse Proxy und eine
bewusst konfigurierte Zugriffsschicht erfolgen.
## Mitmachen
Ideen und Fehlermeldungen sind willkommen. GitHub bietet dafür vorbereitete
Formulare, die keine technischen Vorkenntnisse voraussetzen.
- [Änderungen und neue Funktionen](CHANGELOG.de.md)
- [Beitragen](CONTRIBUTING.de.md)
- [Sicherheitsproblem vertraulich melden](SECURITY.de.md)
Eine freiwillige einmalige oder monatliche Unterstützung über GitHub Sponsors
wird vorbereitet. Dadurch werden keine Funktionen freigeschaltet und es
entsteht keine bezahlte Vorzugsbehandlung: LX bleibt kostenlos und für jede
Familie dieselbe Anwendung.
Gebaut für echte Familien – nicht für Werbeprofile.