# Close Lid, Uptime, Auth

# Setup-Guide: Hyprlock, Authelia & Uptime Kuma

---

# TEIL 1: HYPRLOCK AUTO-LOCK BEI LID CLOSE

## Hyprland Lid-Event Handler

### Methode 1: Mit Hyprland Event (empfohlen!)

Hyprland hat ein eingebautes Event-System!

**Config erweitern:**

```bash
nano ~/.config/hypr/hyprland.conf
```

**Füge hinzu:**

```conf
# Lid close event
bindl = , switch:on:Lid Switch, exec, hyprlock
```

Das war's! 

**Test:**
- Laptop-Deckel zuklappen
- Sollte sofort sperren

---

### Methode 2: Mit systemd-logind (Alternative)

Falls Methode 1 nicht funktioniert:

**Script erstellen:**

```bash
sudo nano /usr/local/bin/lock-on-lid.sh
```

**Inhalt:**
```bash
#!/bin/bash

# User und Display finden
USER=$(who | grep tty | awk '{print $1}' | head -1)
DISPLAY_NUM=$(who | grep "($USER)" | awk '{print $5}' | sed 's/[()]//g' | head -1)

if [ -z "$DISPLAY_NUM" ]; then
    DISPLAY_NUM=":0"
fi

# Als User ausführen
export DISPLAY="$DISPLAY_NUM"
sudo -u $USER WAYLAND_DISPLAY=wayland-1 hyprlock
```

**Ausführbar machen:**
```bash
sudo chmod +x /usr/local/bin/lock-on-lid.sh
```

**Systemd-Service:**
```bash
sudo nano /etc/systemd/system/lock-on-lid@.service
```

**Inhalt:**
```ini
[Unit]
Description=Lock screen on lid close
Before=sleep.target

[Service]
Type=oneshot
User=%i
ExecStart=/usr/local/bin/lock-on-lid.sh

[Install]
WantedBy=sleep.target
```

**Aktivieren:**
```bash
sudo systemctl enable lock-on-lid@denode.service
```

**logind.conf anpassen:**
```bash
sudo nano /etc/systemd/logind.conf
```

Ändere:
```ini
HandleLidSwitch=lock
HandleLidSwitchExternalPower=lock
HandleLidSwitchDocked=ignore
```

**logind neu starten:**
```bash
sudo systemctl restart systemd-logind
```

---

# TEIL 2: AUTHELIA SSO INSTALLATION

## Was ist Authelia?

**Authelia** ersetzt Basic Auth durch moderne Login-Seite mit:
- Schöne Login-UI
- 2FA (TOTP, U2F)
- SSO für alle Services
- Session-Management
- Passwort-Reset

**Aussehen:** Wie Google/GitHub Login - professionell!

---

## Schritt 1: Verzeichnis erstellen

**WICHTIG: Wir nutzen die HDD um Speicherplatz zu sparen!**

```bash
# Auf dem Homeserver - auf der HDD!
sudo mkdir -p /mnt/hdd/authelia/{config,data,data/redis}
sudo chown -R denode:denode /mnt/hdd/authelia
cd /mnt/hdd/authelia
```

---

## Schritt 2: Docker-Compose erstellen

```bash
nano docker-compose.yml
```

**Inhalt:**

```yaml
version: '3.8'

services:
  authelia:
    image: authelia/authelia:latest
    container_name: authelia
    restart: unless-stopped
    environment:
      - TZ=Europe/Berlin
    volumes:
      - ./config:/config
      - ./data:/data
    ports:
      - "9091:9091"
    networks:
      - authelia

  redis:
    image: redis:7-alpine
    container_name: authelia-redis
    restart: unless-stopped
    volumes:
      - ./data/redis:/data
    networks:
      - authelia

networks:
  authelia:
    driver: bridge
```

---

## Schritt 3: Authelia Config

```bash
nano config/configuration.yml
```

**Komplette Config:**

```yaml
---
theme: dark
jwt_secret: CHANGE_THIS_TO_RANDOM_STRING_123456789012345678901234567890

default_redirection_url: https://denode.eu

server:
  host: 0.0.0.0
  port: 9091

log:
  level: info

totp:
  issuer: denode.eu
  period: 30
  skew: 1

authentication_backend:
  file:
    path: /config/users_database.yml
    password:
      algorithm: argon2id
      iterations: 1
      salt_length: 16
      parallelism: 8
      memory: 64

access_control:
  default_policy: deny
  rules:
    - domain: "*.denode.eu"
      policy: one_factor

session:
  name: authelia_session
  domain: denode.eu
  expiration: 1h
  inactivity: 5m
  remember_me_duration: 1M

  redis:
    host: redis
    port: 6379

regulation:
  max_retries: 3
  find_time: 2m
  ban_time: 5m

storage:
  local:
    path: /data/db.sqlite3

notifier:
  disable_startup_check: true
  filesystem:
    filename: /data/notification.txt
```

**WICHTIG:** Ändere `jwt_secret` zu einem zufälligen String!

```bash
# Generiere Random String
openssl rand -hex 32
# Kopiere Output und ersetze jwt_secret
```

---

## Schritt 4: Users erstellen

```bash
nano config/users_database.yml
```

**Inhalt:**

```yaml
---
users:
  denode:
    displayname: "Denode"
    password: "$argon2id$v=19$m=65536,t=3,p=4$HASH_HIER"
    email: admin@denode.local
    groups:
      - admins
      - dev
```

**Passwort hashen:**

```bash
docker run --rm authelia/authelia:latest authelia crypto hash generate argon2 --password 'DeinPasswort'
```

Kopiere den Hash (komplette Zeile mit `$argon2id$...`) und ersetze in `users_database.yml`!

---

## Schritt 5: Authelia starten

```bash
cd /mnt/hdd/authelia

docker compose up -d

# Logs ansehen
docker compose logs -f
```

**Warte bis:** "Authelia is now listening"

**Test:**
```bash
curl http://localhost:9091/api/health
# Sollte {"status":"UP"} zurückgeben
```

---

## Schritt 6: Caddy auf Homeserver anpassen

```bash
sudo nano /etc/caddy/Caddyfile
```

**Füge nach dem `homeserver.mora-stairs.ts.net` Block hinzu:**

```
# Authelia
auth.denode.eu {
    reverse_proxy localhost:9091
}

http://:80 {
    @from_tunnel remote_ip 10.100.0.1
    
    # Authelia API
    @authelia host auth.denode.eu
    handle @authelia {
        handle @from_tunnel {
            reverse_proxy localhost:9091
        }
        handle {
            respond "Access denied" 403
        }
    }
    
    # ... rest bleibt gleich
}
```

**Caddy neuladen:**
```bash
sudo systemctl reload caddy
```

---

## Schritt 7: DNS-Record setzen

Bei spaceship.com:
```
Type: A
Name: auth
Value: 46.224.8.110
TTL: 3600
```

---

## Schritt 8: Caddy auf Hetzner mit Authelia

```bash
ssh hetzner
nano /etc/caddy/Caddyfile
```

**Ändere z.B. den notes.denode.eu Block:**

```
notes.denode.eu {
    # Forward Auth zu Authelia
    forward_auth auth.denode.eu {
        uri /api/verify?rd=https://auth.denode.eu
        copy_headers Remote-User Remote-Groups Remote-Name Remote-Email
    }
    
    encode gzip
    reverse_proxy 10.100.0.2:4567 {
        header_up Host {host}
        header_up X-Real-IP {remote_host}
        header_up X-Forwarded-For {remote_host}
        header_up X-Forwarded-Proto {scheme}
    }
}
```

**Gleich für alle Services (denode.eu, overleaf.denode.eu, etc.):**

```
denode.eu {
    forward_auth auth.denode.eu {
        uri /api/verify?rd=https://auth.denode.eu
        copy_headers Remote-User Remote-Groups Remote-Name Remote-Email
    }
    
    root * /var/www/denode
    file_server
    encode gzip
}

overleaf.denode.eu {
    forward_auth auth.denode.eu {
        uri /api/verify?rd=https://auth.denode.eu
        copy_headers Remote-User Remote-Groups Remote-Name Remote-Email
    }
    
    encode gzip
    reverse_proxy 10.100.0.2:4568 {
        header_up Host {host}
        header_up X-Real-IP {remote_host}
        header_up X-Forwarded-For {remote_host}
        header_up X-Forwarded-Proto {scheme}
    }
}
```

**Caddy neuladen:**
```bash
systemctl reload caddy
```

---

## Schritt 9: Authelia testen!

1. **Öffne:** `https://notes.denode.eu`
2. **Du wirst weitergeleitet zu:** `https://auth.denode.eu`
3. **Login-Seite erscheint!** 
4. **Einloggen:**
   - Username: `denode`
   - Passwort: DeinPasswort
5. **Nach Login:** Zurück zu BookStack!

**2FA einrichten (optional):**
1. Nach Login: Klick auf dein Profil
2. **Two-Factor Authentication**
3. QR-Code mit Authenticator-App scannen (z.B. Authy, Google Authenticator)

---

## Authelia Features

**Session-Management:**
- Nach Login: 1 Stunde gültig
- "Remember Me": 1 Monat
- Auto-Logout bei Inaktivität: 5 Minuten

**Sicherheit:**
- 3 Fehlversuche → 5 Minuten Ban
- Passwort-Hashing mit Argon2id
- Optional: 2FA mit TOTP

**Aussehen:**
- Dark Mode (in Config: `theme: dark`)
- Responsive Design
- Moderne UI

---

## Troubleshooting Authelia

**Logs ansehen:**
```bash
cd /mnt/hdd/authelia
docker compose logs authelia -f
```

**Container neu starten:**
```bash
docker compose restart authelia
```

**Config testen:**
```bash
docker exec authelia authelia validate-config /config/configuration.yml
```

**Passwort zurücksetzen:**
```bash
# Neuen Hash generieren
docker run --rm authelia/authelia:latest authelia crypto hash generate argon2 --password 'NeuesPasswort'

# In users_database.yml eintragen
nano config/users_database.yml

# Authelia neu starten
docker compose restart authelia
```

---

# TEIL 3: UPTIME KUMA INSTALLATION

## Was ist Uptime Kuma?

**Uptime Kuma** ist ein modernes Monitoring-Dashboard.

**Features:**
- Schöne Status-Seite
- Monitort HTTP, TCP, Ping, Docker, etc.
- Benachrichtigungen (Telegram!)
- Öffentliche Status-Page möglich
- Response-Time Graphen
- Uptime-Statistiken

**Sieht aus wie:** Professionelles Monitoring-Dashboard!

---

## Schritt 1: Installation

**WICHTIG: Auf HDD installieren!**

```bash
# Auf dem Homeserver - auf der HDD!
sudo mkdir -p /mnt/hdd/uptime-kuma/data
sudo chown -R denode:denode /mnt/hdd/uptime-kuma
cd /mnt/hdd/uptime-kuma

nano docker-compose.yml
```

**Inhalt:**

```yaml
version: '3.8'

services:
  uptime-kuma:
    image: louislam/uptime-kuma:latest
    container_name: uptime-kuma
    restart: unless-stopped
    volumes:
      - ./data:/app/data
    ports:
      - "3001:3001"
```

**Starten:**
```bash
docker compose up -d

# Logs
docker compose logs -f
```

---

## Schritt 2: Caddy konfigurieren

**Auf Homeserver:**
```bash
sudo nano /etc/caddy/Caddyfile
```

**Füge in `http://:80` Block hinzu:**

```
@uptime host uptime.denode.eu
handle @uptime {
    handle @from_tunnel {
        reverse_proxy localhost:3001 {
            header_up X-Real-IP {remote_host}
            header_up X-Forwarded-For {remote_host}
            header_up X-Forwarded-Proto {scheme}
        }
    }
    handle {
        respond "Access denied" 403
    }
}
```

**Auf Hetzner:**
```bash
ssh hetzner
nano /etc/caddy/Caddyfile
```

**Hinzufügen:**

```
uptime.denode.eu {
    # Optional: Mit Authelia schützen
    forward_auth auth.denode.eu {
        uri /api/verify?rd=https://auth.denode.eu
        copy_headers Remote-User Remote-Groups Remote-Name Remote-Email
    }
    
    encode gzip
    reverse_proxy 10.100.0.2:3001 {
        header_up Host {host}
        header_up X-Real-IP {remote_host}
        header_up X-Forwarded-For {remote_host}
        header_up X-Forwarded-Proto {scheme}
    }
}
```

**Beide Caddy neu laden:**
```bash
# Homeserver
sudo systemctl reload caddy

# Hetzner
ssh hetzner "systemctl reload caddy"
```

---

## Schritt 3: DNS-Record

Bei spaceship.com:
```
Type: A
Name: uptime
Value: 46.224.8.110
TTL: 3600
```

---

## Schritt 4: Uptime Kuma Setup

1. **Öffne:** `https://uptime.denode.eu`
2. **Erster Login:** Account erstellen
   - Username: admin
   - Passwort: DeinSicheresPasswort
3. **Dashboard öffnet sich!**

---

## Schritt 5: Monitors erstellen

### Nextcloud Monitor

1. Klick **"Add New Monitor"**
2. **Monitor Type:** HTTP(s)
3. **Friendly Name:** Nextcloud
4. **URL:** `https://nextcloud.denode.eu`
5. **Heartbeat Interval:** 60 seconds
6. **Retries:** 3
7. **Method:** GET
8. **Accepted Status Codes:** 200-299, 302
9. **Save**

### BookStack Monitor

- **Name:** BookStack
- **URL:** `https://notes.denode.eu`
- Rest gleich

### Overleaf Monitor

- **Name:** Overleaf
- **URL:** `https://overleaf.denode.eu`

### Landing-Page Monitor

- **Name:** Landing Page
- **URL:** `https://denode.eu`

### Wireguard-Tunnel Monitor

1. **Monitor Type:** Ping
2. **Name:** Wireguard Tunnel
3. **Hostname:** `10.100.0.1` (Hetzner) oder `10.100.0.2` (Homeserver)
4. **Save**

---

## Schritt 6: Telegram-Benachrichtigungen

1. **Settings** → **Notifications**
2. **Setup Notification** → **Telegram**
3. **Bot Token:** `8446514684:AAEthBJXkEVMw9kOVfrjdtpDuE5S3P9Heas`
4. **Chat ID:** `1916692273`
5. **Test** → sollte Nachricht in Telegram kommen!
6. **Save**

**Für jeden Monitor aktivieren:**
- Monitor öffnen → **Notifications** Tab
- Telegram aktivieren

---

## Schritt 7: Status-Page erstellen (Optional)

**Öffentliche Status-Seite für Freunde/Familie:**

1. **Status Pages** (links im Menü)
2. **Add New Status Page**
3. **Title:** Denode Services
4. **Slug:** `public` (wird zu: uptime.denode.eu/status/public)
5. **Description:** "Status meiner Self-Hosted Services"
6. **Theme:** Dark
7. **Add a Group:**
   - Name: "Services"
   - Wähle alle Monitore
8. **Save**

Jetzt können andere `https://uptime.denode.eu/status/public` aufrufen und sehen den Status!

---

## Uptime Kuma Features

**Dashboard:**
- Live-Status aller Services (🟢🔴)
- Durchschnittliche Response-Time
- Uptime Prozent (24h, 7d, 30d)
- Incident-History

**Benachrichtigungen:**
- Telegram
- Discord
- Email
- Slack
- Webhook
- ... und viele mehr!

**Monitoring-Typen:**
- HTTP(s)
- TCP Port
- Ping/ICMP
- DNS
- Docker Container
- Keyword (prüft ob Text auf Seite)

---

## Troubleshooting Uptime Kuma

**Container neu starten:**
```bash
cd /mnt/hdd/uptime-kuma
docker compose restart
```

**Logs:**
```bash
docker compose logs -f
```

**Daten zurücksetzen:**
```bash
docker compose down
rm -rf data/
docker compose up -d
```

---

# ZUSAMMENFASSUNG

## Was du jetzt hast:

**1. Hyprlock Auto-Lock** ✅
- Laptop sperrt automatisch beim Zuklappen
- Hyprland Event-Handler

**2. Authelia SSO** ✅
- Moderne Login-Seite für alle Services
- Kein nerviges Basic-Auth mehr!
- Optional: 2FA
- Session-Management
- Sieht professionell aus!

**3. Uptime Kuma** ✅
- Monitoring aller Services
- Schönes Dashboard
- Telegram-Benachrichtigungen
- Status-Page für andere

---

## URLs:

- **Authelia:** https://auth.denode.eu
- **Uptime Kuma:** https://uptime.denode.eu
- **Status-Page:** https://uptime.denode.eu/status/public

---

## Wichtige Befehle:

**Authelia:**
```bash
cd /mnt/hdd/authelia
docker compose ps
docker compose logs -f
docker compose restart
```

**Uptime Kuma:**
```bash
cd /mnt/hdd/uptime-kuma
docker compose ps
docker compose logs -f
```

**Hyprlock testen:**
```bash
hyprlock
```

---

## Ports:

- Authelia: 9091
- Uptime Kuma: 3001

---

## Backup:

**In Backup-Script einfügen:**

```bash
# Authelia Backup (liegt auf HDD!)
tar -czf "$BACKUP_DIR/authelia/authelia_${DATE}.tar.gz" -C /mnt/hdd authelia/

# Uptime Kuma Backup (liegt auf HDD!)
tar -czf "$BACKUP_DIR/uptime-kuma/uptime-kuma_${DATE}.tar.gz" -C /mnt/hdd uptime-kuma/
```

**Backup-Verzeichnisse erstellen:**
```bash
mkdir -p /mnt/hdd/backups/authelia
mkdir -p /mnt/hdd/backups/uptime-kuma
```

---

## Landing-Page erweitern:

Füge neue Service-Cards hinzu:

```html
<div class="service-card">
    <div class="service-icon">🔐</div>
    <h3>Login</h3>
    <p>Single Sign-On für alle Services.</p>
    <a href="https://auth.denode.eu" class="service-link">Öffnen →</a>
</div>

<div class="service-card">
    <div class="service-icon">📊</div>
    <h3>Status</h3>
    <p>Monitoring & Uptime aller Services.</p>
    <a href="https://uptime.denode.eu" class="service-link">Öffnen →</a>
</div>
```

---

- ✅ Automatisches Laptop-Lock
- ✅ Moderne Login-Seite
- ✅ Professionelles Monitoring