# 🛠️ Kapitel 13 – Clipper (Tutorial)

---

## Einleitung  

Clips sind der beste Weg, lange Streams in kurze, teilbare Highlights zu verwandeln. Unser Ziel in diesem Kapitel: Wir bauen ein System, das neue Videos automatisch erkennt, sinnvolle Stellen analysiert, passende Highlights schneidet und die Ergebnisse in Nextcloud ablegt – inklusive Titeln und Hashtags für jede Plattform. Der Clipper selbst übernimmt dabei die technische Verarbeitung, während **n8n** für Steuerung, Analyse und Benachrichtigungen sorgt. Das System bleibt dadurch flexibel, ressourcenschonend und jederzeit erweiterbar.

---

## Voraussetzungen  

- **Proxmox LXC** mit Debian 12 (Bookworm)  
- **Nextcloud** (Pflicht, Zielort für Clips & Metadaten)  
- **n8n-Instanz** (Automatisierung, Steuerung Clipper, Analyse, Metadaten-Erzeugung)  
- **Twitch-Entwickler-Account** inkl. API-Key (für VOD- und Clip-Zugriff)  
- **Optional**: RTMP-Server, falls VODs lokal aufgezeichnet werden  
- **Ressourcen für den LXC**: 1 vCPU, 1–2 GB RAM, 10 GB Speicher reichen aus  
- **Grundwissen**: SSH-Verbindung, Nano-Editor, Basiskenntnisse in n8n  

---

## Vorbereitung  

Wir beginnen mit einem frischen Debian‑12‑LXC in Proxmox, benennen ihn `clipper` und vergeben die im Abschnitt oben genannten Ressourcen. Danach bringen wir das System auf Stand und installieren die Grundwerkzeuge:
```bash
apt update && apt upgrade -y
apt install -y curl unzip ffmpeg inotify-tools
```

Eine korrekte Systemzeit ist entscheidend, da Schnittmarken später auf exakten Sekunden basieren. Prüfe die Zeit mit:
```bash
timedatectl status
```
Wenn hier UTC steht und du lieber „Europe/Berlin“ nutzen willst:
```bash
timedatectl list-timezones | grep Europe
timedatectl set-timezone Europe/Berlin
timedatectl status
```
Die Zeit wird sofort angepasst, Logs und Schnittzeiten passen damit zur lokalen Umgebung.

Zum Schluss legen wir die Arbeitsordner an:
```bash
mkdir -p /srv/clipper/{watch,out,temp,logs}
```
- `watch` – Eingangsordner für neue Videos (egal ob von Twitch oder RTMP)
- `out` – fertige Clips und Metadaten
- `temp` – Zwischenspeicher für Analyse
- `logs` – Protokolle aller Abläufe

Damit ist das Fundament gelegt.

---

## Abschnitt 2 – Clipper‑LXC einrichten (Benutzer, Verzeichnisse, Pakete, Skripte)

In diesem Abschnitt richten wir den **Clipper‑Container** so ein, dass **SSH‑Schlüssel**, **Downloads** und **n8n‑Aufrufe** ohne Berechtigungsfehler funktionieren. Wir arbeiten jetzt **im Terminal deines Clipper‑LXC als root**.

> **Entscheidung & Begründung – Benutzer mit Home & Bash**  
> Der Benutzer **clipper** bekommt ein **Homeverzeichnis** (`/home/clipper`) und eine **Login‑Shell**. So können SSH‑Schlüssel sauber in `~clipper/.ssh` landen und n8n später per SSH Befehle ausführen. Varianten ohne Home (System‑User) führen bei `ssh-copy-id` zu Fehlern.

### 2.1 Benutzer und Verzeichnisse anlegen (Terminal, als root)

```bash
adduser --home /home/clipper --shell /bin/bash clipper
```
Vergib ein Passwort und bestätige die Abfragen. Danach legst du die Arbeitsordner an und überträgst den Besitz an `clipper`:
```bash
mkdir -p /srv/clipper/{inbox,watch,out,temp,logs,bin}
chown -R clipper:clipper /srv/clipper
chmod 750 /srv/clipper
```
(optional, aber hilfreich für `ssh-copy-id` später):
```bash
install -d -m 700 -o clipper -g clipper /home/clipper/.ssh
```

> **Falls du den Benutzer bereits ohne Home angelegt hast:**  
> Richte ihn so nach:  
> `mkdir -p /home/clipper/.ssh && chown -R clipper:clipper /home/clipper && chmod 700 /home/clipper/.ssh`

### 2.2 Pakete installieren (Terminal, als root)

```bash
apt update && apt install -y yt-dlp jq python3 python3-venv curl unzip inotify-tools sudo
```
- **ffmpeg**: Analyse & Schnitt  
- **yt-dlp**: Twitch‑VOD/Clip‑Downloads (HLS)  
- **jq**: JSON‑Handling  
- **python3/venv**: spätere Analyse‑Tools  
- **inotify-tools**: Dateisystem‑Events (optional)  
- **sudo**: für gezielte Rechteerhöhungen falls nötig

### 2.3 Zentrale Konfiguration (Terminal, als root)

Bevor wir die Umgebungsdatei anlegen, brauchen wir ein eigenes Konfigurationsverzeichnis. Das existiert standardmäßig nicht, daher legen wir es einmalig an:

```bash
mkdir -p /etc/clipper
chown root:clipper /etc/clipper
chmod 750 /etc/clipper
```

> **Entscheidung & Begründung – eigenes /etc/clipper**  
> Konfiguration gehört nach `/etc`. Mit einem eigenen Ordner `/etc/clipper` bleibt alles übersichtlich getrennt.  
> Besitzer ist `root`, die Gruppe `clipper`. So kann der Clipper-User die Datei lesen, aber nicht verändern – genau die Balance zwischen Sicherheit und Funktion.



Entscheidung & Begründung – eigenes /etc/clipper
Konfiguration gehört nach /etc. Mit einem eigenen Ordner /etc/clipper bleibt alles übersichtlich getrennt.
Besitzer ist root, die Gruppe clipper. So kann der Clipper-User die Datei lesen, aber nicht verändern – genau die Balance zwischen Sicherheit und Funktion.

Lege eine Umgebungsdatei an, die beide Skripte laden:
```bash
nano /etc/clipper/clipper.env
```
Inhalt:
```
CLIPPER_INBOX=/srv/clipper/inbox
CLIPPER_IN=/srv/clipper/watch
CLIPPER_OUT=/srv/clipper/out
CLIPPER_TMP=/srv/clipper/temp
CLIPPER_LOG=/srv/clipper/logs/clipper.log
```
Dateirechte setzen, damit `clipper` sie lesen darf:
```bash
chown root:clipper /etc/clipper/clipper.env
chmod 640 /etc/clipper/clipper.env
```

### 2.4 Python‑Umgebung vorbereiten (Wechsel zu Benutzer *clipper*)

Wechsle jetzt **zum Benutzer clipper**:
```bash
su - clipper
```
Erzeuge und fülle eine virtuelle Umgebung für die spätere Analyse:
```bash
python3 -m venv /srv/clipper/.venv
source /srv/clipper/.venv/bin/activate
pip install --upgrade pip
pip install numpy opencv-python-headless
deactivate
```
Wechsle für die nächsten Schritte **im Benutzer clipper** weiter.

### 2.5 Einstiegsskripte erstellen (im Benutzer *clipper*)

**Analyse‑Stub** – prüft Eingaben, schreibt Logs, erzeugt leere Kandidatenliste:
```bash
nano /srv/clipper/bin/clipper-analyze
```
Inhalt:
```bash
#!/usr/bin/env bash
set -euo pipefail
ENV_FILE="/etc/clipper/clipper.env"; [ -r "$ENV_FILE" ] || { echo "ENV nicht lesbar: $ENV_FILE" >&2; exit 1; }; source "$ENV_FILE"
IN="$1"       # absolute Datei
JOBID="${2:-manual}"
mkdir -p "$CLIPPER_TMP/$JOBID"
echo "$(date '+%F %T') [ANALYZE] job=$JOBID file=$IN" | tee -a "$CLIPPER_LOG"
OUT_JSON="$CLIPPER_TMP/$JOBID/candidates.json"
echo '[]' > "$OUT_JSON"
echo "$OUT_JSON"
```

**Schneid‑Stub** – protokolliert Schnittaufrufe, echte Logik folgt in Abschnitt 5:
```bash
nano /srv/clipper/bin/clipper-cut
```
Inhalt:
```bash
#!/usr/bin/env bash
set -euo pipefail
ENV_FILE="/etc/clipper/clipper.env"; [ -r "$ENV_FILE" ] || { echo "ENV nicht lesbar: $ENV_FILE" >&2; exit 1; }; source "$ENV_FILE"
IN="$1"            # absolute Datei
RANGES_JSON="$2"   # Zeitbereiche (kommt später aus Abschnitt 4)
JOBID="${3:-manual}"
mkdir -p "$CLIPPER_OUT/$JOBID"
echo "$(date '+%F %T') [CUT] job=$JOBID file=$IN ranges=$RANGES_JSON" | tee -a "$CLIPPER_LOG"
exit 0
```

Rechte setzen und Eigentümer korrigieren:
```bash
chmod +x /srv/clipper/bin/clipper-*
chown -R clipper:clipper /srv/clipper/bin
```

### 2.6 Logrotation (zurück zu root)

Beende die Session (`exit`) und kehre zu **root** zurück. Richte Logrotation ein:
```bash
nano /etc/logrotate.d/clipper
```
Inhalt:
```
/srv/clipper/logs/*.log {
  rotate 14
  daily
  missingok
  notifempty
  compress
  delaycompress
  copytruncate
}
```

> **Schnelltest (optional):**  
> Zurück im **Benutzer clipper**:  
> `/srv/clipper/bin/clipper-analyze /srv/clipper/watch/demo.mp4 job-001`  
> `/srv/clipper/bin/clipper-cut /srv/clipper/watch/demo.mp4 /srv/clipper/temp/job-001/ranges.json job-001`  
> `tail -n 50 /srv/clipper/logs/clipper.log`

Mit dieser Einrichtung sind **SSH‑Schlüssel**, **Berechtigungen** und **Pfade** konsistent. `ssh-copy-id` aus Abschnitt 3 funktioniert dadurch ohne Fehlermeldungen – und n8n kann die Skripte stabil starten.

---

## Abschnitt 3 – n8n ↔ Twitch: VOD & Clips importieren, in Nextcloud ablegen, Clipper starten

In diesem Abschnitt verbinden wir n8n mit Twitch, Nextcloud und dem Clipper. Das Ziel: n8n erkennt automatisch neue VODs auf Twitch, lädt sie zusammen mit Clips herunter, legt sie in Nextcloud ab und startet dann die Analyse auf dem Clipper. Wir gehen Schritt für Schritt vor – immer mit klaren Hinweisen, ob wir uns gerade in der **n8n‑Weboberfläche**, im **Terminal** oder in **Nextcloud** befinden.

> **Entscheidung & Begründung – Rollenverteilung**  
> **n8n** steuert (APIs, Logik, Benachrichtigungen). **Clipper** arbeitet (Download, Analyse, Schnitt). **Nextcloud** speichert (Archiv & Übergabe). So bleibt n8n schlank und ausfallsicher, während Clipper CPU/IO für Medienjobs bekommt.

---

### Schritt 1: Zugriff zwischen den Containern vorbereiten (Terminal)

<details>
<summary>Optional: SSH Known-Hosts zurücksetzen (falls Clipper schon einmal erstellt wurde)</summary>

Wenn du den Clipper-LXC bereits früher erstellt und neu aufgesetzt hast, kann es zu einem SSH-Fehler kommen:

```
@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@
@    WARNING: REMOTE HOST IDENTIFICATION HAS CHANGED!     @
@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@
```

Das bedeutet, dass sich der **Server-Hostkey** geändert hat. SSH blockiert dann aus Sicherheitsgründen.

#### Lösung Schritt für Schritt (im n8n-LXC als root)

1. **Fingerprint auf dem Clipper prüfen**
```bash
ssh-keygen -lf /etc/ssh/ssh_host_ed25519_key.pub
```
(SHA256-Wert merken und vergleichen)

2. **Alten Eintrag löschen**
```bash
ssh-keygen -R "<CLIPPER-IP>"
```

> **Entscheidung & Begründung – Sicherheitsprinzip**  
> SSH schützt vor Man-in-the-Middle-Angriffen, indem es Hostkeys prüft. Wenn ein Container neu erstellt wird, ist ein neuer Hostkey normal. Wir löschen den alten Eintrag bewusst, prüfen den neuen Fingerprint und akzeptieren ihn erst danach. So bleibt die Verbindung sicher **und** stabil.

</details>


Melde dich zuerst im **Terminal deines n8n‑LXC** an. Wir richten hier die Verbindung zum Clipper und zu Nextcloud ein.

**SSH‑Schlüssel für Clipper erzeugen:**
```bash
ssh-keygen -t ed25519 -f ~/.ssh/id_ed25519 -N ""
ssh-copy-id clipper@<CLIPPER-IP>
ssh clipper@<CLIPPER-IP> "echo OK"
```
Ersetze `<CLIPPER-IP>` durch die IP/den Hostnamen deines Clipper‑LXC (z. B. `10.0.0.42`). Wenn **OK** erscheint, kann n8n ohne Passwort auf den Clipper zugreifen.

### Zugangsdaten für Nextcloud‑WebDAV erstellen (Weboberfläche)

> **Ort in Nextcloud**: Avatar (oben rechts) → **Persönliche Einstellungen** → **Sicherheit** → **ganz nach unten** zum Bereich **App‑Passwörter**.

**Anleitung:**
1. Melde dich in der **Nextcloud‑Weboberfläche** an.
2. Gehe zu **Persönliche Einstellungen** → **Sicherheit**.
3. **Ganz nach unten scrollen** bis zum Abschnitt **App‑Passwörter** (unscheinbar platziert).
4. Trage bei **App‑Name** z. B. `n8n Clipper` ein und klicke auf **Neues App‑Passwort erstellen**.
5. Kopiere das **einmalig angezeigte App‑Passwort** sofort und notiere zusätzlich deinen **Benutzernamen**. (Das Passwort wird später **nicht** erneut angezeigt.)

**WebDAV‑URL für n8n/Uploads:**
```
https://<DEINE_NEXTCLOUD_DOMAIN>/remote.php/dav/files/<DEIN_NC_BENUTZER>/
```
*(Alternativ, je nach Setup: `https://<DEINE_NEXTCLOUD_DOMAIN>/remote.php/webdav/`)*

<details>
<summary>Schnelltest (optional, auf deinem n8n‑LXC)</summary>

```bash
curl -u "<BENUTZER>:<APP_PASSWORT>" \
  -X PROPFIND -H "Depth: 0" \
  -s -o /dev/null -w "%{http_code}\n" \
  "https://<DEINE_NEXTCLOUD_DOMAIN>/remote.php/dav/files/<DEIN_NC_BENUTZER>/"
# Erwartet: 207
```

Optional kannst du die ersten Zeilen der Antwort prüfen:

```bash
curl -u "<BENUTZER>:<APP_PASSWORT>" \
  -X PROPFIND -H "Depth: 0" -s \
  "https://<DEINE_NEXTCLOUD_DOMAIN>/remote.php/dav/files/<DEIN_NC_BENUTZER>/" \
  | head -n 5
# Erwartet: XML mit <d:multistatus ...>
```

**Fehler & Lösung (kurz):**
- **401/403** → Benutzername oder App‑Passwort falsch.
- **404** → Pfad prüfen (richtiger Benutzerordner?).
- **App‑Passwörter fehlen?** Admin muss sie in den Nextcloud‑Einstellungen aktivieren.
</details>


**Twitch‑API Zugang:**  

<details>
<summary>Twitch Developer Console – App anlegen</summary>


1. Gehe auf [Twitch Developer Console](https://dev.twitch.tv/console/apps) → **Applications** → **Register Your Application**.
2. Felder ausfüllen:
- **Name:** frei wählbar (muss einzigartig sein).
- **OAuth Redirect URL:** z. B. `https://localhost/` (Platzhalter; für Client-Credentials Flow nicht genutzt).
- **Category:** passend wählen (z. B. Chatbot/Website Integration).
3. App speichern → **Manage** öffnen.
4. **Client ID** notieren, **New Secret** klicken und **Client Secret** sichern.


</details>

- Grant Type: *Client Credentials*  
- Access Token URL: `https://id.twitch.tv/oauth2/token`  
- Client ID / Secret eintragen  
- Speichern und testen.

Referenz: [Twitch Auth‑Doku](https://dev.twitch.tv/docs/authentication)

> **Entscheidung & Begründung – Warum Client‑Credentials?**  
> Für **Get Users**, **Get Videos**, **Get Clips** reicht ein App‑Token. Der Flow ist stabil, ohne User‑Login/Refresh‑Token‑Pflege.

---

### Schritt 2: Twitch‑User‑ID herausfinden (n8n‑Weboberfläche)

Die Twitch‑API benötigt deine **numerische User‑ID**, nicht den Login‑Namen. Wir holen diese ID einmalig in n8n.

1. Gehe in der n8n‑Weboberfläche auf **Workflows** → **+ New Workflow**.  
2. Ziehe einen **HTTP Request Node** auf die Arbeitsfläche.  
3. Konfiguriere ihn so:
   - Methode: GET  
   - URL: `https://api.twitch.tv/helix/users?login=<DEIN_LOGIN>`  
   - Authentifizierung: OAuth2 Credential (aus Schritt 1)  
   - Header: `Client-Id: <DEINE_CLIENT_ID>`
4. Klicke auf **Execute Node**.  
5. Im Ergebnis findest du im Feld `data[0].id` deine **User‑ID** (z. B. `123456789`). Diese Zahl ist entscheidend und ersetzt ab jetzt `<DEINE_TWITCH_USER_ID>` in allen weiteren Schritten.

Referenz: [Get Users](https://dev.twitch.tv/docs/api/reference#get-users)

> **Entscheidung & Begründung – Login vs. User‑ID**  
> Der „Login“ ist nur ein Anzeigename. Die API filtert zuverlässig über die **numerische ID** – deshalb holen wir sie einmalig und verwenden sie konsequent.

---

### Schritt 3: Workflow bauen (n8n‑Weboberfläche)

Jetzt bauen wir den eigentlichen Workflow, der regelmäßig neue VODs prüft, herunterlädt und ablegt.

1. **Cron‑Trigger anlegen:**  
   - Ziehe einen **Cron Node** auf die Arbeitsfläche.  
   - Stelle ihn auf „Every 10 minutes“.  
   Damit prüft n8n alle 10 Minuten auf neue VODs.

2. **VOD‑Daten abrufen:**  
   - Ziehe einen weiteren **HTTP Request Node** an den Cron‑Node.  
   - URL:  
     ```
     https://api.twitch.tv/helix/videos?user_id=<DEINE_TWITCH_USER_ID>&type=archive&first=1
     ```
   - Auth: OAuth2 Credential  
   - Header: `Client-Id: <DEINE_CLIENT_ID>`  
   - Ergebnis: In `data[0]` stehen `id`, `title`, `url`, `created_at`, `published_at`.

   Referenz: [Get Videos](https://dev.twitch.tv/docs/api/reference#get-videos)

3. **Clips abrufen (optional):**  
   - Ziehe einen weiteren **HTTP Request Node** an.  
   - URL:  
     ```
     https://api.twitch.tv/helix/clips?broadcaster_id=<DEINE_TWITCH_USER_ID>&started_at=<created_at>&ended_at=<published_at>
     ```
   - Ergebnis: Liste mit Clips, die im Zeitraum des VOD erstellt wurden.

   Referenz: [Get Clips](https://dev.twitch.tv/docs/api/reference#get-clips)

4. **VOD herunterladen (Terminal im Clipper‑LXC):**  
   Jetzt wechselst du ins **Terminal des Clipper‑LXC**. Stelle sicher, dass `yt-dlp` installiert ist (`apt install -y yt-dlp`). n8n ruft per SSH folgenden Befehl auf:
   ```bash
   mkdir -p "/srv/clipper/inbox/{{ $json.data[0].id }}"
   yt-dlp -o "/srv/clipper/inbox/{{ $json.data[0].id }}/%(title)s.%(ext)s" {{ $json.data[0].url }}
   ```
   Damit entsteht ein Unterordner `/srv/clipper/inbox/<VOD-ID>/` mit dem Video.

   > **Entscheidung & Begründung – Warum lädt *Clipper* (und nicht *n8n*)?**  
   > VODs kommen als **HLS‑Streams** (m3u8, segmentiert, signiert). Ein robuster Download braucht **yt‑dlp/ffmpeg** mit Retry/Resume und I/O‑Puffer. Das ist CPU/IO‑lastig und gehört auf die **Werkbank** (Clipper), nicht in die **Steuerzentrale** (n8n). So bleibt n8n stabil und reagiert weiter auf Webhooks.

5. **Clips herunterladen (Terminal im Clipper‑LXC, optional):**  
   Für jeden Clip‑URL ruft n8n per SSH `yt-dlp` auf:
   ```bash
   yt-dlp -o "/srv/clipper/inbox/<CLIP_ID>/%(title)s.%(ext)s" https://clips.twitch.tv/<CLIP_ID>
   ```

6. **Upload nach Nextcloud (n8n‑Weboberfläche):**  
   - Ziehe einen **HTTP Request Node** auf die Arbeitsfläche.  
   - Methode: **PUT**  
   - Auth: **Basic Auth** (Benutzername + App‑Passwort aus Schritt 1)  
   - URL:  
     ```
     https://<DEINE_NEXTCLOUD_DOMAIN>/remote.php/dav/files/<DEIN_NC_BENUTZER>/Clips/{{ $json.data[0].id }}/<Dateiname>
     ```
   - Ergebnis: In Nextcloud liegt danach ein Ordner `Clips/<VOD-ID>/…`.

   > **Entscheidung & Begründung – Warum Nextcloud?**  
   > Zentrales, versionierbares Speicherziel mit Freigaben/Quotas/Backups. Clipper und andere Systeme können darauf zugreifen, ohne erneut von Twitch laden zu müssen.

7. **Analyse starten (Terminal im Clipper‑LXC):**  
   Zum Abschluss ruft n8n per SSH das Skript `clipper-analyze` auf:
   ```bash
   /srv/clipper/bin/clipper-analyze \
     "/srv/clipper/inbox/{{ $json.data[0].id }}/{{ $json.data[0].title }}.mp4" \
     "vod-{{ $json.data[0].id }}"
   ```
   Das Skript erzeugt im Clipper‑Temp‑Ordner eine `candidates.json`. Mit dieser arbeiten wir in Abschnitt 4 weiter.

---

### Alternative: Twitch‑Community‑Node (n8n‑Weboberfläche)

Wenn du statt HTTP Requests lieber einen fertigen Twitch‑Node nutzen willst, kannst du in self‑hosted n8n einen **Community‑Node** installieren. Die Anleitung: [n8n Community Nodes](https://docs.n8n.io/integrations/community-nodes/). Beachte: Community‑Nodes sind Drittanbieter‑Code und können bei Updates Probleme machen. Für einen stabilen Dauerbetrieb empfehlen wir den API‑Weg mit HTTP Request.

---

### Kontrolle

Nach einem erfolgreichen Durchlauf prüfst du im **Terminal des Clipper‑LXC**:
```bash
su - clipper
ls -lh /srv/clipper/inbox/<VOD-ID>

tail -n 50 /srv/clipper/logs/clipper.log
```
Und in der **Nextcloud‑Weboberfläche** solltest du den Ordner `Clips/<VOD-ID>` sehen. Damit ist die Pipeline geschlossen: Twitch liefert VODs, n8n steuert den Ablauf, Clipper verarbeitet, Nextcloud speichert. In Abschnitt 4 gehen wir in die Analyse‑Logik und die KI‑Auswertung.