sebastian.zell
/
n8n_node_librebooking
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

Projektstand aus ZIP aktualisiert

This commit is contained in:
Sebastian Zell 2026-01-25 19:18:13 +01:00
parent 1af67a06d1
commit 846441f436
29 changed files with 2834 additions and 1877 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

1
.abacus.donotdelete Normal file
View File

File diff suppressed because one or more lines are too long

16
.npmrc Normal file
View File

@ -0,0 +1,16 @@
# npm Configuration für LibreBooking n8n Node
# Diese Datei konfiguriert npm für dieses Projekt
# Audit-Warnungen deaktivieren
# Die Vulnerabilities kommen von n8n-workflow Dependencies und sind
# in diesem Kontext nicht kritisch (siehe SECURITY.md)
audit=false
# Fund-Nachrichten deaktivieren
fund=false
# Optional: Legacy Peer Dependencies (für ältere n8n Versionen)
# legacy-peer-deps=true
# Optional: Engine-Strict deaktivieren
# engine-strict=false

124
CHANGELOG.md
View File

@ -1,109 +1,35 @@
# Changelog
Alle wichtigen Änderungen an diesem Projekt werden in dieser Datei dokumentiert.
Alle wichtigen Änderungen werden hier dokumentiert.
Das Format basiert auf [Keep a Changelog](https://keepachangelog.com/de/1.0.0/),
und dieses Projekt folgt [Semantic Versioning](https://semver.org/lang/de/).
## [1.1.0] - 2026-01-25
## [Unreleased]
### Geplant
- Webhook-basierter Trigger (falls von LibreBooking unterstützt)
- Batch-Operationen für mehrere Reservierungen
- Erweiterte Filteroptionen
## [1.0.0] - 2026-01-25
### Geändert
- ⭐ **Vereinfachte Installation**: Fokus auf "auf dem Host bauen"
- Aktualisierte Dokumentation mit funktionierender Methode
- Neue npm scripts: `docker:deploy`, `docker:copy`, `docker:restart`
### Hinzugefügt
- `quick-install.sh` - Ultra-einfache Installation
- `update-node.sh` - Für Updates
- `git-commit.sh` - Git Commit Helper
- `git-cleanup.sh` - Cleanup alter Dateien
- `create-release.sh` - Release-Erstellung
- `GIT-COMMANDS.md` - Git-Befehlsreferenz
#### LibreBooking Node
- **Reservierung (Reservation)**
- Alle Reservierungen abrufen (GetAll)
- Reservierung nach Referenznummer abrufen (Get)
- Neue Reservierung erstellen (Create)
- Reservierung aktualisieren (Update)
- Reservierung löschen (Delete)
- Reservierung genehmigen (Approve)
- Check-In durchführen (CheckIn)
- Check-Out durchführen (CheckOut)
### Behoben
- TypeScript Installation Problem gelöst ("tsc not found")
- Read-only Volume Problem dokumentiert und gelöst
- npm audit Vulnerabilities dokumentiert
- **Ressource (Resource)**
- Alle Ressourcen abrufen (GetAll)
- Ressource nach ID abrufen (Get)
- Verfügbarkeit prüfen (GetAvailability)
- Status abrufen (GetStatus)
- Neue Ressource erstellen (Create)
- Ressource aktualisieren (Update)
- Ressource löschen (Delete)
## [1.0.0] - 2026-01-24
- **Zeitplan (Schedule)**
- Alle Zeitpläne abrufen (GetAll)
- Zeitplan nach ID abrufen (Get)
- Slots abrufen (GetSlots)
- **Benutzer (User)**
- Alle Benutzer abrufen (GetAll)
- Benutzer nach ID abrufen (Get)
- Neuen Benutzer erstellen (Create)
- Benutzer aktualisieren (Update)
- Benutzer löschen (Delete)
- **Konto (Account)**
- Eigenes Konto abrufen (Get)
- Konto aktualisieren (Update)
- Passwort ändern (ChangePassword)
- **Gruppe (Group)**
- Alle Gruppen abrufen (GetAll)
- Gruppe nach ID abrufen (Get)
- Neue Gruppe erstellen (Create)
- Gruppe aktualisieren (Update)
- Gruppe löschen (Delete)
- **Zubehör (Accessory)**
- Alles Zubehör abrufen (GetAll)
- Zubehör nach ID abrufen (Get)
- Neues Zubehör erstellen (Create)
- Zubehör aktualisieren (Update)
- Zubehör löschen (Delete)
- **Attribut (Attribute)**
- Attributkategorien abrufen (GetCategories)
- Attribute nach Kategorie abrufen (GetByCategory)
#### LibreBooking Trigger Node
- Polling-basierter Trigger für Reservierungs-Events
- Event-Typen:
- Neue Reservierung
- Geänderte Reservierung
- Alle Reservierungen
- Filter nach Ressource, Zeitplan und Benutzer
- Konfigurierbares Zeitfenster (7-90 Tage)
- Deduplizierung von Events
#### Credentials
- LibreBooking API Credentials mit Session-basierter Authentifizierung
- Automatische Token-Verwaltung
- Verbindungstest integriert
#### Dokumentation
- Vollständige README.md auf Deutsch
- Detaillierte INSTALLATION.md
### Hinzugefügt
- Vollständige LibreBooking API Integration
- 8 Ressourcen: Reservierung, Ressource, Zeitplan, Benutzer, Konto, Gruppe, Zubehör, Attribut
- Trigger Node für neue/geänderte Reservierungen
- Docker Support mit docker-compose.yml
- Automatische Installationsskripte
- Umfangreiche Dokumentation auf Deutsch
- Beispiel-Workflows
- API-Dokumentation mit allen Operationen
#### Entwickler-Tools
- Docker-Support mit Dockerfile und docker-compose
- Installations-Skripte für Linux/Mac und Windows
- Test-Suite für API-Verbindung
- ESLint und Prettier Konfiguration
### Sicherheit
- Keine Speicherung von Passwörtern im Klartext
- Session-basierte Authentifizierung
- Automatisches Sign-Out nach Operationen
---
[Unreleased]: https://github.com/DEIN-REPO/n8n-nodes-librebooking/compare/v1.0.0...HEAD
[1.0.0]: https://github.com/DEIN-REPO/n8n-nodes-librebooking/releases/tag/v1.0.0
- Test-Skripte

588
DOCKER-INTEGRATION.md
View File

@ -1,168 +1,41 @@
# Docker-Integration für LibreBooking n8n Node
# Docker Integration
Diese Anleitung beschreibt die Integration des LibreBooking Nodes in eine **bestehende n8n Docker-Installation**.
## Empfohlene Methode: Auf dem Host bauen
## Inhaltsverzeichnis
Die zuverlässigste Methode für Docker-Installationen.
- [Voraussetzungen](#voraussetzungen)
- [Methode 1: Automatische Integration mit Skript](#methode-1-automatische-integration-mit-skript)
- [Methode 2: Manuelle Integration](#methode-2-manuelle-integration)
- [Methode 3: Integration in bestehende docker-compose.yml](#methode-3-integration-in-bestehende-docker-composeyml)
- [Methode 4: Dockerfile erweitern](#methode-4-dockerfile-erweitern)
- [Verifizierung der Installation](#verifizierung-der-installation)
- [Troubleshooting](#troubleshooting)
- [Updates und Wartung](#updates-und-wartung)
---
## Voraussetzungen
### System-Anforderungen
- **Docker** Version 20.10 oder höher
- **Docker Compose** v2.0+ (Plugin) oder docker-compose v1.29+
- **Laufende n8n Docker-Installation**
- **Zugriff auf das Dateisystem** des Docker-Hosts
### Prüfen der Voraussetzungen
### Schritt-für-Schritt
```bash
# Docker Version prüfen
docker --version
# Docker version 24.0.x, build xxxxx
# Docker Compose Version prüfen
docker compose version
# Docker Compose version v2.x.x
# Oder für ältere Versionen:
docker-compose --version
# docker-compose version 1.29.x, build xxxxx
# n8n Container Status prüfen
docker ps | grep n8n
```
---
## Methode 1: Automatische Integration mit Skript
Die einfachste Methode für die Integration in eine bestehende Installation.
### Schritt 1: Skript ausführbar machen
```bash
chmod +x install-docker.sh
```
### Schritt 2: Skript ausführen
```bash
# Im aktuellen Verzeichnis (wenn dort n8n läuft)
./install-docker.sh
# Oder mit Pfad zur n8n Installation
./install-docker.sh -p /pfad/zu/n8n
# Mit Überschreiben bestehender Dateien
./install-docker.sh -f -p /pfad/zu/n8n
```
### Skript-Optionen
| Option | Beschreibung |
|--------|--------------|
| `-p, --path PATH` | Pfad zur n8n Docker-Installation |
| `-b, --build` | Node im Container bauen |
| `-f, --force` | Bestehende Installation überschreiben |
| `-h, --help` | Hilfe anzeigen |
### Was das Skript tut
1. Prüft Docker und Docker Compose Installation
2. Prüft ob n8n Container läuft
3. Kopiert `custom-nodes/` Verzeichnis
4. Erstellt/aktualisiert `docker-compose.override.yml`
5. Setzt korrekte Berechtigungen (UID 1000)
6. Startet Container bei Bedarf neu
---
## Methode 2: Manuelle Integration
Für mehr Kontrolle oder spezielle Setups.
### Schritt 1: Custom Nodes Verzeichnis kopieren
```bash
# Zum n8n Verzeichnis wechseln
cd /pfad/zu/ihrer/n8n/installation
# Custom Nodes kopieren
cp -r /pfad/zu/librebooking_n8n_node/custom-nodes ./custom-nodes
```
### Schritt 2: Dependencies installieren und bauen
```bash
cd custom-nodes
# Node.js Dependencies installieren
# 1. Auf dem Host
cd /pfad/zu/n8n-nodes-librebooking
npm install
# TypeScript kompilieren
npm run build
# 2. In Container kopieren
docker cp dist n8n:/home/node/.n8n/custom/n8n-nodes-librebooking/
docker cp package.json n8n:/home/node/.n8n/custom/n8n-nodes-librebooking/
docker cp node_modules n8n:/home/node/.n8n/custom/n8n-nodes-librebooking/
# 3. Neustarten
docker restart n8n
```
### Schritt 3: docker-compose.override.yml erstellen
Erstellen Sie eine `docker-compose.override.yml` Datei:
```yaml
version: '3.8'
services:
n8n:
volumes:
# LibreBooking Custom Node einbinden
- ./custom-nodes:/home/node/.n8n/custom/n8n-nodes-librebooking:ro
environment:
# Custom Nodes Pfad
- N8N_CUSTOM_EXTENSIONS=/home/node/.n8n/custom
# Community Nodes aktivieren
- N8N_COMMUNITY_NODES_ENABLED=true
```
### Schritt 4: Berechtigungen setzen
### Mit Skript
```bash
# n8n läuft als "node" User mit UID 1000
sudo chown -R 1000:1000 custom-nodes/
./quick-install.sh n8n
```
### Schritt 5: Container neustarten
### Mit npm
```bash
# Mit docker-compose
docker-compose restart n8n
# Oder mit Docker Compose Plugin
docker compose restart n8n
# Bei Problemen: Container komplett neu erstellen
docker-compose down && docker-compose up -d
npm run docker:deploy
```
---
## Methode 3: Integration in bestehende docker-compose.yml
Wenn Sie keine Override-Datei verwenden möchten.
### Bestehende docker-compose.yml erweitern
Fügen Sie folgende Einträge zu Ihrem n8n Service hinzu:
## docker-compose.yml Beispiel
```yaml
version: '3.8'
@ -170,423 +43,50 @@ version: '3.8'
services:
n8n:
image: n8nio/n8n:latest
# ... Ihre bestehende Konfiguration ...
volumes:
# Bestehende Volumes beibehalten
- n8n_data:/home/node/.n8n
# LibreBooking Node hinzufügen
- ./custom-nodes:/home/node/.n8n/custom/n8n-nodes-librebooking:ro
container_name: n8n
restart: unless-stopped
ports:
- "5678:5678"
environment:
# Bestehende Umgebungsvariablen beibehalten
- N8N_HOST=0.0.0.0
- N8N_PORT=5678
# Custom Nodes Konfiguration hinzufügen
- N8N_CUSTOM_EXTENSIONS=/home/node/.n8n/custom
- N8N_COMMUNITY_NODES_ENABLED=true
- TZ=Europe/Berlin
volumes:
- n8n_data:/home/node/.n8n
# Optional: Custom Nodes Verzeichnis
# - ./custom-nodes:/home/node/.n8n/custom
volumes:
n8n_data:
```
### Vollständiges Beispiel
Siehe `docker-compose.example.yml` für eine vollständige Konfiguration mit:
- PostgreSQL Datenbank (optional)
- Redis Queue (optional)
- Health Checks
- Alle Umgebungsvariablen
---
## Methode 4: Dockerfile erweitern
Für produktive Deployments oder wenn Sie ein eigenes Image benötigen.
### Einfaches Dockerfile
```dockerfile
# Dockerfile.custom-nodes
ARG N8N_VERSION=latest
FROM n8nio/n8n:${N8N_VERSION}
USER root
# Custom Node Verzeichnis erstellen
RUN mkdir -p /home/node/.n8n/custom/n8n-nodes-librebooking && \
chown -R node:node /home/node/.n8n/custom
WORKDIR /home/node/.n8n/custom/n8n-nodes-librebooking
# Dateien kopieren
COPY --chown=node:node custom-nodes/ ./
# Dependencies installieren und bauen
RUN npm install && npm run build
USER node
WORKDIR /home/node
ENV N8N_CUSTOM_EXTENSIONS=/home/node/.n8n/custom
ENV N8N_COMMUNITY_NODES_ENABLED=true
EXPOSE 5678
CMD ["n8n", "start"]
```
### Image bauen und verwenden
## Für Updates
```bash
# Image bauen
docker build -f Dockerfile.custom-nodes -t n8n-librebooking .
./update-node.sh n8n
# Container starten
docker run -d \
--name n8n \
-p 5678:5678 \
-v n8n_data:/home/node/.n8n \
n8n-librebooking
```
### Mit docker-compose
```yaml
version: '3.8'
services:
n8n:
build:
context: .
dockerfile: Dockerfile.custom-nodes
args:
N8N_VERSION: latest
# ... weitere Konfiguration
```
### Multi-Stage Build (Optimiert)
```dockerfile
# Build Stage
FROM node:18-alpine AS builder
WORKDIR /build
COPY custom-nodes/ ./
RUN npm install && npm run build
# Production Stage
ARG N8N_VERSION=latest
FROM n8nio/n8n:${N8N_VERSION}
USER root
RUN mkdir -p /home/node/.n8n/custom/n8n-nodes-librebooking && \
chown -R node:node /home/node/.n8n/custom
# Nur gebaute Dateien kopieren
COPY --from=builder --chown=node:node /build/dist /home/node/.n8n/custom/n8n-nodes-librebooking/dist
COPY --from=builder --chown=node:node /build/package.json /home/node/.n8n/custom/n8n-nodes-librebooking/
USER node
ENV N8N_CUSTOM_EXTENSIONS=/home/node/.n8n/custom
ENV N8N_COMMUNITY_NODES_ENABLED=true
CMD ["n8n", "start"]
# Oder
npm run docker:deploy
```
---
## Verifizierung der Installation
### 1. Container-Logs prüfen
## Verifikation
```bash
# Logs anzeigen
docker logs n8n 2>&1 | grep -i "librebooking\|custom\|node"
# Dateien prüfen
docker exec n8n ls -la /home/node/.n8n/custom/n8n-nodes-librebooking/
# Live Logs verfolgen
docker logs -f n8n
```
### 2. In n8n prüfen
1. Öffnen Sie n8n im Browser (z.B. `http://localhost:5678`)
2. Erstellen Sie einen neuen Workflow
3. Fügen Sie einen neuen Node hinzu
4. Suchen Sie nach "LibreBooking" - zwei Nodes sollten erscheinen:
- **LibreBooking** - Hauptnode für alle Operationen
- **LibreBooking Trigger** - Trigger für neue Reservierungen
### 3. Node-Verzeichnis im Container prüfen
```bash
# In Container einloggen
docker exec -it n8n /bin/sh
# Custom Nodes Verzeichnis prüfen
ls -la /home/node/.n8n/custom/
# LibreBooking Node prüfen
ls -la /home/node/.n8n/custom/n8n-nodes-librebooking/dist/
```
### 4. Umgebungsvariablen prüfen
```bash
docker exec n8n env | grep N8N_CUSTOM
# N8N_CUSTOM_EXTENSIONS=/home/node/.n8n/custom
docker exec n8n env | grep COMMUNITY
# N8N_COMMUNITY_NODES_ENABLED=true
# Sollte zeigen:
# dist/
# package.json
# node_modules/
```
---
## Troubleshooting
## Probleme?
### Problem: Node wird nicht erkannt
**Symptom:** LibreBooking Node erscheint nicht in der Node-Suche
**Lösungen:**
1. **Pfad prüfen:**
```bash
docker exec n8n ls -la /home/node/.n8n/custom/n8n-nodes-librebooking/
```
2. **Umgebungsvariablen prüfen:**
```bash
docker exec n8n env | grep -E "N8N_CUSTOM|COMMUNITY"
```
3. **Container komplett neu starten:**
```bash
docker-compose down
docker-compose up -d
```
4. **Logs auf Fehler prüfen:**
```bash
docker logs n8n 2>&1 | grep -i error
```
### Problem: Permissions-Fehler
**Symptom:** `EACCES: permission denied` oder ähnliche Fehler
**Lösungen:**
1. **Berechtigungen setzen:**
```bash
sudo chown -R 1000:1000 custom-nodes/
sudo chmod -R 755 custom-nodes/
```
2. **Volume mit korrektem User mounten:**
```yaml
services:
n8n:
user: "1000:1000"
```
3. **SELinux Context (falls aktiviert):**
```bash
sudo chcon -R -t svirt_sandbox_file_t custom-nodes/
```
### Problem: Container startet nicht
**Symptom:** Container crashed oder startet nicht
**Lösungen:**
1. **Logs prüfen:**
```bash
docker logs n8n
```
2. **Ohne Override starten (zum Testen):**
```bash
mv docker-compose.override.yml docker-compose.override.yml.bak
docker-compose up -d
```
3. **Volume-Konflikte prüfen:**
```bash
docker volume ls
docker volume inspect n8n_data
```
### Problem: Node wird geladen aber Fehler bei Ausführung
**Symptom:** Node ist sichtbar aber Ausführung schlägt fehl
**Lösungen:**
1. **Build prüfen:**
```bash
docker exec n8n ls -la /home/node/.n8n/custom/n8n-nodes-librebooking/dist/
```
2. **Neu bauen:**
```bash
cd custom-nodes
npm run rebuild
docker-compose restart n8n
```
3. **Dependencies prüfen:**
```bash
docker exec -it n8n /bin/sh
cd /home/node/.n8n/custom/n8n-nodes-librebooking
npm ls
```
### Problem: TypeScript Build schlägt fehl
**Symptom:** `tsc` Fehler beim Bauen
**Lösungen:**
1. **Node.js Version prüfen:**
```bash
node --version # Sollte 18+ sein
npm --version
```
2. **Clean Build:**
```bash
cd custom-nodes
rm -rf node_modules dist package-lock.json
npm install
npm run build
```
### Problem: Webhook URL nicht erreichbar
**Symptom:** LibreBooking kann Webhooks nicht senden
**Lösungen:**
1. **WEBHOOK_URL Umgebungsvariable setzen:**
```yaml
environment:
- WEBHOOK_URL=https://ihre-domain.com/
```
2. **Netzwerk-Konfiguration prüfen:**
```bash
docker network inspect $(docker network ls -q)
```
---
## Updates und Wartung
### Node aktualisieren
```bash
# Neue Version herunterladen
cd /pfad/zu/neuem/librebooking_n8n_node
# Custom Nodes ersetzen
rm -rf /pfad/zu/n8n/custom-nodes
cp -r custom-nodes /pfad/zu/n8n/custom-nodes
# Neu bauen
cd /pfad/zu/n8n/custom-nodes
npm install
npm run build
# Container neustarten
cd /pfad/zu/n8n
docker-compose restart n8n
```
### n8n Version aktualisieren
```bash
# Image aktualisieren
docker pull n8nio/n8n:latest
# Container neu erstellen
docker-compose down
docker-compose up -d
```
### Backup erstellen
```bash
# Docker Volumes sichern
docker run --rm \
-v n8n_data:/source:ro \
-v $(pwd)/backup:/backup \
alpine tar cvzf /backup/n8n_data_backup.tar.gz -C /source .
# Custom Nodes sichern
tar cvzf custom-nodes-backup.tar.gz custom-nodes/
```
### Logs rotieren
```yaml
services:
n8n:
logging:
driver: "json-file"
options:
max-size: "10m"
max-file: "3"
```
---
## Erweiterte Konfiguration
### Kubernetes Deployment
Für Kubernetes-Umgebungen kann ein ConfigMap oder PersistentVolume verwendet werden:
```yaml
apiVersion: v1
kind: ConfigMap
metadata:
name: librebooking-node
data:
# Node-Dateien als ConfigMap
---
apiVersion: apps/v1
kind: Deployment
metadata:
name: n8n
spec:
template:
spec:
containers:
- name: n8n
volumeMounts:
- name: custom-nodes
mountPath: /home/node/.n8n/custom/n8n-nodes-librebooking
volumes:
- name: custom-nodes
configMap:
name: librebooking-node
```
### Mit Reverse Proxy (Nginx)
Siehe `nginx.conf` für eine vollständige Nginx-Konfiguration mit:
- SSL/TLS Termination
- WebSocket Support
- Optimierte Timeouts für Webhooks
---
## Hilfe und Support
- **GitHub Issues:** [Repository Issues](https://github.com/ihr-repo/librebooking-n8n-node/issues)
- **n8n Community:** [community.n8n.io](https://community.n8n.io)
- **LibreBooking Dokumentation:** [LibreBooking Wiki](https://github.com/effgarces/BookedScheduler/wiki)
---
*Letzte Aktualisierung: Januar 2026*
Siehe [TROUBLESHOOTING.md](TROUBLESHOOTING.md)

65
GIT-COMMANDS.md Normal file
View File

@ -0,0 +1,65 @@
# Git-Befehle für LibreBooking n8n Node
## Schnellbefehle
```bash
# Alle Änderungen committen
git add .
git commit -m "fix: Vereinfachte Installation"
# Push
git push origin main
```
## Release erstellen
```bash
# 1. Version in package.json anpassen (z.B. 1.1.0)
# 2. Alte Archive löschen
rm ../n8n-nodes-librebooking*.tar.gz
rm ../n8n-nodes-librebooking*.zip
# 3. Neue Archive erstellen
git archive --format=tar.gz --prefix=n8n-nodes-librebooking/ --output=../n8n-nodes-librebooking-v1.1.0.tar.gz HEAD
git archive --format=zip --prefix=n8n-nodes-librebooking/ --output=../n8n-nodes-librebooking-v1.1.0.zip HEAD
# 4. Tag erstellen
git tag -a v1.1.0 -m "Version 1.1.0 - Vereinfachte Installation"
# 5. Push
git push origin main
git push origin v1.1.0
```
## Mit Skripten
```bash
# Commit
./git-commit.sh "fix: Beschreibung der Änderung"
# Cleanup
./git-cleanup.sh
# Release
./create-release.sh
```
## Nützliche Befehle
```bash
# Status anzeigen
git status
# Änderungen anzeigen
git diff
# Log anzeigen
git log --oneline -10
# Tags anzeigen
git tag -l
# Remote anzeigen
git remote -v
```

588
INSTALLATION.md
View File

@ -1,553 +1,101 @@
# Installationsanleitung - LibreBooking n8n Node
# Installation
Diese Anleitung beschreibt alle verfügbaren Methoden zur Installation des LibreBooking n8n Nodes.
## Methode 1: Auf dem Host bauen (EMPFOHLEN) ⭐
## Inhaltsverzeichnis
Die zuverlässigste Methode für Docker-Installationen.
- [Voraussetzungen](#voraussetzungen)
- [Installation aus Git-Archiv](#installation-aus-git-archiv)
- [Methode 1: Automatische Installation mit Skript](#methode-1-automatische-installation-mit-skript)
- [Methode 2: Manuelle Installation mit npm](#methode-2-manuelle-installation-mit-npm)
- [Methode 3: Installation aus npm Registry](#methode-3-installation-aus-npm-registry)
- [Methode 4: Docker Installation](#methode-4-docker-installation)
- [Methode 5: n8n Community Nodes](#methode-5-n8n-community-nodes)
- [Verifizierung der Installation](#verifizierung-der-installation)
- [Troubleshooting](#troubleshooting)
- [Deinstallation](#deinstallation)
### Voraussetzungen
---
- Node.js 18+
- npm
- Docker
## Voraussetzungen
### Systemanforderungen
| Komponente | Mindestversion | Empfohlen |
|------------|---------------|-----------|
| Node.js | 18.x | 20.x LTS |
| npm | 8.x | 10.x |
| n8n | 1.0.0 | Neueste |
### Node.js installieren
**Linux (Ubuntu/Debian):**
```bash
# Mit NodeSource Repository (empfohlen)
curl -fsSL https://deb.nodesource.com/setup_20.x | sudo -E bash -
sudo apt-get install -y nodejs
# Version prüfen
node --version
npm --version
```
**macOS:**
```bash
# Mit Homebrew
brew install node@20
# Version prüfen
node --version
npm --version
```
**Windows:**
1. Lade Node.js von https://nodejs.org/ herunter
2. Wähle die LTS-Version (20.x)
3. Führe den Installer aus
4. Öffne PowerShell und prüfe: `node --version`
### n8n installieren
### Installation
```bash
# Global installieren
npm install -g n8n
# Installation prüfen
n8n --version
```
---
## Installation aus Git-Archiv
### Archiv herunterladen
1. **GitHub Release herunterladen:**
```bash
# .tar.gz für Linux/Mac
wget https://github.com/DEIN-REPO/n8n-nodes-librebooking/releases/latest/download/n8n-nodes-librebooking.tar.gz
# .zip für Windows
# Über Browser herunterladen
```
2. **Oder direkt von Git:**
```bash
git clone https://github.com/DEIN-REPO/n8n-nodes-librebooking.git
cd n8n-nodes-librebooking
```
### Archiv entpacken
**Linux/macOS:**
```bash
# .tar.gz entpacken
tar -xzf n8n-nodes-librebooking.tar.gz
cd n8n-nodes-librebooking
```
**Windows (PowerShell):**
```powershell
# .zip entpacken
Expand-Archive -Path n8n-nodes-librebooking.zip -DestinationPath .
cd n8n-nodes-librebooking
```
---
## Methode 1: Automatische Installation mit Skript
Die einfachste Methode für die meisten Benutzer.
### Linux/macOS
```bash
# In das Verzeichnis wechseln
# 1. Klonen
git clone https://github.com/your-org/n8n-nodes-librebooking.git
cd n8n-nodes-librebooking
# Skript ausführbar machen (falls nötig)
chmod +x install.sh
# Installation starten
./install.sh
```
**Optionen:**
```bash
./install.sh # Standard-Installation mit npm link
./install.sh --no-link # Nur Build, ohne npm link
./install.sh --global # Globale Installation
./install.sh --help # Hilfe anzeigen
```
### Windows (PowerShell)
```powershell
# In das Verzeichnis wechseln
cd n8n-nodes-librebooking
# Skript ausführen (evtl. Ausführungsrichtlinie anpassen)
Set-ExecutionPolicy -Scope Process -ExecutionPolicy Bypass
.\install.ps1
```
**Optionen:**
```powershell
.\install.ps1 # Standard-Installation mit npm link
.\install.ps1 -NoLink # Nur Build, ohne npm link
.\install.ps1 -Global # Globale Installation
.\install.ps1 -Help # Hilfe anzeigen
```
---
## Methode 2: Manuelle Installation mit npm
Für Benutzer, die mehr Kontrolle über den Installationsprozess möchten.
### Schritt 1: Dependencies installieren
```bash
cd n8n-nodes-librebooking
# 2. Dependencies installieren
npm install
```
### Schritt 2: TypeScript kompilieren
```bash
# 3. Bauen
npm run build
# 4. In Container kopieren
docker cp dist n8n:/home/node/.n8n/custom/n8n-nodes-librebooking/
docker cp package.json n8n:/home/node/.n8n/custom/n8n-nodes-librebooking/
docker cp node_modules n8n:/home/node/.n8n/custom/n8n-nodes-librebooking/
# 5. Container neustarten
docker restart n8n
```
### Schritt 3: Node verlinken
### Mit Skript
```bash
# Node global verfügbar machen
./quick-install.sh n8n
```
### Mit npm scripts
```bash
npm install
npm run docker:deploy
```
---
## Methode 2: Docker mit vorgebautem dist/
Für Read-only Volumes.
```bash
# 1. Bauen
npm install
npm run build
# 2. Kopieren
cp -r dist package.json node_modules /pfad/zu/custom-nodes/n8n-nodes-librebooking/
# 3. docker-compose.yml
volumes:
- ./custom-nodes:/home/node/.n8n/custom:ro # Read-only möglich!
```
---
## Methode 3: Native Installation (ohne Docker)
```bash
# 1. Installieren
npm install
npm run build
npm link
# Mit n8n verlinken (optional, falls n8n global installiert ist)
cd $(npm root -g)/n8n
npm link n8n-nodes-librebooking
```
### Schritt 4: n8n neu starten
```bash
# n8n stoppen (falls läuft)
# Ctrl+C oder:
pkill -f n8n
# n8n starten
# 2. n8n starten
n8n start
```
---
## Methode 3: Installation aus npm Registry
## Verifikation
> **Hinweis:** Diese Methode ist für eine zukünftige Veröffentlichung auf npm vorgesehen.
Nach der Installation:
```bash
# Global installieren
npm install -g n8n-nodes-librebooking
# Oder lokal in einem Projekt
npm install n8n-nodes-librebooking
```
Nach der Veröffentlichung auf npm wird diese Methode die einfachste sein.
---
## Methode 4: Docker Installation
### Voraussetzungen für Docker
- Docker 20.x oder höher
- Docker Compose v2.x (empfohlen)
**Docker installieren:**
- Linux: https://docs.docker.com/engine/install/
- macOS: https://docs.docker.com/desktop/mac/install/
- Windows: https://docs.docker.com/desktop/windows/install/
### Mit docker-compose (empfohlen)
```bash
cd n8n-nodes-librebooking
# Umgebungsvariablen konfigurieren (optional)
cp .env.example .env
# .env Datei bearbeiten
# Container bauen und starten
docker-compose up -d
# Logs anzeigen
docker-compose logs -f
# Status prüfen
docker-compose ps
```
**Umgebungsvariablen (`.env`):**
```env
# n8n Authentifizierung
N8N_BASIC_AUTH_USER=admin
N8N_BASIC_AUTH_PASSWORD=sicheres-passwort-hier
# Webhook-URL (für Produktion)
WEBHOOK_URL=https://n8n.deine-domain.de/
# Zeitzone
TZ=Europe/Berlin
# Log-Level (debug, info, warn, error)
N8N_LOG_LEVEL=info
```
**Nützliche docker-compose Befehle:**
```bash
# Stoppen
docker-compose down
# Neu bauen (nach Änderungen)
docker-compose build --no-cache
# Neustart
docker-compose restart
# Logs eines bestimmten Services
docker-compose logs -f n8n
# In Container Shell
docker-compose exec n8n sh
```
### Mit Docker direkt
```bash
cd n8n-nodes-librebooking
# Image bauen
docker build -t n8n-librebooking .
# Container starten
docker run -d \
--name n8n-librebooking \
-p 5678:5678 \
-e N8N_BASIC_AUTH_ACTIVE=true \
-e N8N_BASIC_AUTH_USER=admin \
-e N8N_BASIC_AUTH_PASSWORD=changeme \
-e GENERIC_TIMEZONE=Europe/Berlin \
-v n8n_data:/home/node/.n8n \
n8n-librebooking
```
**Container verwalten:**
```bash
# Logs anzeigen
docker logs -f n8n-librebooking
# Stoppen
docker stop n8n-librebooking
# Starten
docker start n8n-librebooking
# Entfernen
docker rm -f n8n-librebooking
# Image entfernen
docker rmi n8n-librebooking
```
### Volumes und Konfiguration
**Wichtige Volumes:**
| Volume/Pfad | Beschreibung |
|-------------|--------------|
| `/home/node/.n8n` | n8n Datenverzeichnis (Workflows, Credentials) |
| `/home/node/.n8n/custom` | Custom Nodes |
| `/home/node/workflows` | Beispiel-Workflows (read-only) |
**Daten sichern:**
```bash
# Mit docker-compose
docker-compose exec n8n tar -czf /tmp/backup.tar.gz /home/node/.n8n
docker cp n8n-librebooking:/tmp/backup.tar.gz ./backup.tar.gz
# Ohne docker-compose
docker cp n8n-librebooking:/home/node/.n8n ./n8n-backup
```
**Daten wiederherstellen:**
```bash
docker cp ./n8n-backup/. n8n-librebooking:/home/node/.n8n/
docker-compose restart
```
---
## Methode 5: n8n Community Nodes
> **Hinweis:** Diese Methode wird verfügbar sein, sobald der Node im n8n Community Node Repository veröffentlicht ist.
1. Öffne n8n im Browser
2. Gehe zu **Settings** → **Community Nodes**
3. Klicke auf **Install a community node**
4. Gib ein: `n8n-nodes-librebooking`
5. Klicke auf **Install**
6. Starte n8n neu
---
## Verifizierung der Installation
### 1. n8n starten
```bash
# Lokal
n8n start
# Mit Docker
docker-compose up -d
```
### 2. Browser öffnen
Öffne http://localhost:5678 im Browser.
### 3. Node suchen
1. Erstelle einen neuen Workflow
2. Klicke auf das **+** Symbol
1. Öffne n8n: http://localhost:5678
2. Erstelle neuen Workflow
3. Suche nach "LibreBooking"
4. Du solltest zwei Nodes sehen:
- **LibreBooking** (für API-Operationen)
- **LibreBooking Trigger** (für Events)
### 4. Credentials einrichten
1. Klicke auf einen LibreBooking Node
2. Unter "Credentials" klicke auf **Create New**
3. Wähle **LibreBooking API**
4. Fülle aus:
- **URL:** Deine LibreBooking URL (z.B. `https://booking.example.com/Web/Services`)
- **Username:** Dein Admin-Benutzername
- **Password:** Dein Passwort
5. Klicke auf **Save**
6. Teste die Verbindung
---
## Troubleshooting
### Häufige Probleme
#### Node wird nicht angezeigt
**Problem:** Der LibreBooking Node erscheint nicht in n8n.
**Lösungen:**
```bash
# 1. Prüfe, ob der Build erfolgreich war
ls -la dist/
# 2. Prüfe npm link Status
npm ls -g --depth=0 | grep librebooking
# 3. n8n Custom Extensions Pfad prüfen
echo $N8N_CUSTOM_EXTENSIONS
# 4. n8n komplett neu starten
pkill -f n8n
n8n start
```
#### Build-Fehler
**Problem:** `npm run build` schlägt fehl.
**Lösungen:**
```bash
# Node.js Version prüfen
node --version # Sollte >= 18 sein
# node_modules löschen und neu installieren
rm -rf node_modules
npm install
# TypeScript-Fehler anzeigen
npx tsc --noEmit
```
#### npm link Probleme
**Problem:** `npm link` funktioniert nicht.
**Lösungen:**
```bash
# Als Admin/Root ausführen (Linux/Mac)
sudo npm link
# Windows: PowerShell als Administrator starten
# Alternativer Pfad für Custom Nodes
export N8N_CUSTOM_EXTENSIONS=$(pwd)
n8n start
```
#### Docker-Probleme
**Problem:** Container startet nicht.
**Lösungen:**
```bash
# Logs prüfen
docker-compose logs n8n
# Container-Status prüfen
docker-compose ps
# Neu bauen
docker-compose build --no-cache
docker-compose up -d
```
#### Credential-Fehler
**Problem:** "Authentication failed" bei Verbindung.
**Lösungen:**
1. Prüfe LibreBooking URL (inkl. `/Web/Services`)
2. Prüfe Benutzername und Passwort
3. Prüfe ob API in LibreBooking aktiviert ist:
- Admin → Konfiguration → API aktivieren
4. Teste API manuell:
```bash
curl -X POST "https://dein-server/Web/Services/Authentication/Authenticate" \
-H "Content-Type: application/json" \
-d '{"username":"admin","password":"password"}'
```
### Logs und Debugging
**n8n Logs aktivieren:**
```bash
# Umgebungsvariable setzen
export N8N_LOG_LEVEL=debug
n8n start
# Mit Docker
docker-compose exec n8n sh -c "N8N_LOG_LEVEL=debug n8n start"
```
**Node-spezifische Logs:**
In n8n Workflow-Ausführungen werden Details angezeigt unter "Execution Data".
---
4. Wenn der Node erscheint → ✅ Installation erfolgreich
## Deinstallation
### npm link entfernen
```bash
# Im Projektverzeichnis
npm unlink
# Docker
docker exec n8n rm -rf /home/node/.n8n/custom/n8n-nodes-librebooking
docker restart n8n
# Global entfernen
# Native
npm unlink -g n8n-nodes-librebooking
```
### Global installiertes Paket entfernen
```bash
npm uninstall -g n8n-nodes-librebooking
```
### Docker entfernen
```bash
# Container und Volumes entfernen
docker-compose down -v
# Images entfernen
docker rmi n8n-librebooking
docker rmi n8nio/n8n
```
### Projektverzeichnis löschen
```bash
# Verzeichnis löschen
rm -rf n8n-nodes-librebooking
# Archiv löschen
rm n8n-nodes-librebooking.tar.gz
rm n8n-nodes-librebooking.zip
```
---
## Support
Bei Fragen oder Problemen:
1. **GitHub Issues:** [Hier Issues erstellen](https://github.com/DEIN-REPO/n8n-nodes-librebooking/issues)
2. **Dokumentation:** Siehe [README.md](README.md)
3. **LibreBooking API:** https://www.bookedscheduler.com/help/api/
---
*Letzte Aktualisierung: Januar 2026*

328
MANUELLE-INSTALLATION-CONTAINER.md Normal file
View File

@ -0,0 +1,328 @@
# Manuelle Installation im Docker Container
Diese Anleitung beschreibt, wie Sie den LibreBooking Node manuell im Docker Container installieren, wenn die Dateien bereits kopiert wurden, aber der Node nicht in n8n erscheint.
---
## Situation
Sie haben die Dateien in den Container kopiert (z.B. nach `/opt/n8n/custom-nodes` oder `/home/node/.n8n/custom/n8n-nodes-librebooking`), aber:
- Der LibreBooking Node erscheint nicht in der n8n Node-Suche
- Die TypeScript-Dateien wurden nicht kompiliert
- Das `dist/` Verzeichnis fehlt oder ist leer
---
## Diagnose
### Schnell-Check mit einem Befehl
```bash
# Prüft Dateien und Status im Container
docker exec n8n sh -c "ls -la /home/node/.n8n/custom/*/dist/ 2>/dev/null || echo 'dist/ nicht gefunden'"
```
### Ausführlicher Check mit Skript
```bash
# Check-Skript in Container kopieren und ausführen
docker cp check-installation.sh n8n:/tmp/
docker exec n8n sh /tmp/check-installation.sh
```
### Manuell im Container prüfen
```bash
# In den Container einloggen
docker exec -it n8n sh
# Prüfen, was vorhanden ist
ls -la /home/node/.n8n/custom/
ls -la /home/node/.n8n/custom/n8n-nodes-librebooking/
# Umgebungsvariablen prüfen
env | grep N8N
# Container verlassen
exit
```
---
## Lösung 1: Automatisch mit Skript (empfohlen)
Das einfachste ist das All-in-One-Skript:
```bash
# Auf dem Host ausführen
./fix-node-installation.sh
```
Oder mit spezifischem Container-Namen:
```bash
./fix-node-installation.sh -c mein-n8n-container
```
### Alternative: Nur das Installations-Skript
```bash
# Skript in Container kopieren
docker cp install-in-container.sh n8n:/tmp/
# Skript im Container ausführen
docker exec -it n8n sh /tmp/install-in-container.sh
# Container neustarten
docker restart n8n
```
---
## Lösung 2: Manuelle Schritte im Container
### Schritt 1: In den Container einloggen
```bash
docker exec -it n8n sh
```
### Schritt 2: Zum Custom-Node-Verzeichnis wechseln
```bash
# Standard-Pfad (offizielles n8n Image)
cd /home/node/.n8n/custom/n8n-nodes-librebooking
# Oder falls an anderem Ort:
cd /opt/n8n/custom-nodes
# oder
cd /data/custom-nodes
```
### Schritt 3: Prüfen ob Dateien vorhanden sind
```bash
ls -la
# Sollte zeigen: package.json, tsconfig.json, nodes/, credentials/
```
### Schritt 4: Dependencies installieren
```bash
npm install
```
Erwartete Ausgabe:
```
added 50 packages in 10s
```
### Schritt 5: Node kompilieren
```bash
npm run build
```
Erwartete Ausgabe:
```
> n8n-nodes-librebooking@1.0.0 build
> tsc && npm run copy:icons
```
### Schritt 6: Prüfen ob Build erfolgreich war
```bash
ls -la dist/
ls -la dist/nodes/LibreBooking/
```
Sollte zeigen:
- `dist/nodes/LibreBooking/LibreBooking.node.js`
- `dist/nodes/LibreBookingTrigger/LibreBookingTrigger.node.js`
- `dist/credentials/LibreBookingApi.credentials.js`
### Schritt 7: Container verlassen und neustarten
```bash
# Container verlassen
exit
# Container neustarten (auf dem Host)
docker restart n8n
```
---
## Lösung 3: Direkt mit docker exec (Ein-Befehl-Lösung)
Wenn Sie schnell zum Ziel kommen wollen:
```bash
# Alles in einem Befehl
docker exec n8n sh -c "cd /home/node/.n8n/custom/n8n-nodes-librebooking && npm install && npm run build"
# Container neustarten
docker restart n8n
```
Für anderen Pfad:
```bash
docker exec n8n sh -c "cd /opt/n8n/custom-nodes && npm install && npm run build"
docker restart n8n
```
---
## Verifizierung
### 1. Logs prüfen
```bash
# Nach LibreBooking in den Logs suchen
docker logs n8n 2>&1 | grep -i "librebooking\|custom\|node"
```
### 2. In n8n prüfen
1. Öffnen Sie n8n im Browser (z.B. `http://localhost:5678`)
2. Erstellen Sie einen neuen Workflow oder öffnen Sie einen bestehenden
3. Klicken Sie auf `+` um einen neuen Node hinzuzufügen
4. Suchen Sie nach "LibreBooking"
5. Es sollten zwei Nodes erscheinen:
- **LibreBooking** - Hauptnode für alle Operationen
- **LibreBooking Trigger** - Trigger für Reservierungen
### 3. Node-Dateien im Container prüfen
```bash
# Prüfe ob .node.js Dateien existieren
docker exec n8n find /home/node/.n8n/custom -name "*.node.js" 2>/dev/null
```
---
## Troubleshooting
### Problem: npm nicht gefunden
**Symptom:**
```
sh: npm: not found
```
**Lösung:**
Das verwendete Docker-Image enthält kein npm. Verwenden Sie ein Image mit Node.js:
```bash
# Prüfen Sie das Image
docker inspect n8n --format='{{.Config.Image}}'
# Das offizielle n8n Image (n8nio/n8n) enthält npm
# Falls Sie ein minimales Image verwenden, wechseln Sie zu n8nio/n8n
```
### Problem: Permission denied
**Symptom:**
```
EACCES: permission denied
npm ERR! could not create a lockfile
```
**Lösung:**
n8n läuft als User `node` (UID 1000). Setzen Sie die Berechtigungen:
```bash
# Auf dem Host (vor dem Kopieren)
sudo chown -R 1000:1000 custom-nodes/
# Oder im Container als root
docker exec -u root n8n chown -R node:node /home/node/.n8n/custom/
```
### Problem: Build schlägt fehl
**Symptom:**
```
error TS2307: Cannot find module 'n8n-workflow'
```
**Lösung:**
```bash
# Im Container
cd /home/node/.n8n/custom/n8n-nodes-librebooking
rm -rf node_modules package-lock.json
npm install
npm run build
```
### Problem: Node erscheint nach Neustart immer noch nicht
**Mögliche Ursachen:**
1. **Falscher Pfad**: N8N_CUSTOM_EXTENSIONS zeigt nicht auf das richtige Verzeichnis
```bash
docker exec n8n env | grep N8N_CUSTOM
# Sollte zeigen: N8N_CUSTOM_EXTENSIONS=/home/node/.n8n/custom
```
2. **package.json n8n-Sektion fehlt**: Die `n8n` Konfiguration in package.json muss korrekt sein
```bash
docker exec n8n cat /home/node/.n8n/custom/n8n-nodes-librebooking/package.json | grep -A10 '"n8n"'
```
3. **Container-Cache**: Container komplett neu erstellen
```bash
docker compose down
docker compose up -d
```
4. **n8n Version zu alt**: Der Node benötigt n8n >= 1.0.0
```bash
docker exec n8n n8n --version
```
### Problem: Fehler bei npm install (Netzwerk)
**Symptom:**
```
npm ERR! network request failed
```
**Lösung:**
```bash
# DNS prüfen
docker exec n8n cat /etc/resolv.conf
# npm Registry prüfen
docker exec n8n npm config get registry
# Ggf. Registry setzen
docker exec n8n npm config set registry https://registry.npmjs.org/
```
---
## Schnellreferenz
| Aktion | Befehl |
|--------|--------|
| Status prüfen | `docker exec n8n sh /tmp/check-installation.sh` |
| Installieren | `docker exec n8n sh -c "cd /home/node/.n8n/custom/n8n-nodes-librebooking && npm install && npm run build"` |
| Neustarten | `docker restart n8n` |
| Logs prüfen | `docker logs n8n 2>&1 \| grep -i libre` |
| Im Container | `docker exec -it n8n sh` |
---
## Weiterführende Dokumentation
- [DOCKER-INTEGRATION.md](DOCKER-INTEGRATION.md) - Vollständige Docker-Anleitung
- [TROUBLESHOOTING.md](TROUBLESHOOTING.md) - Alle Troubleshooting-Themen
- [SCHNELLSTART-DOCKER.md](SCHNELLSTART-DOCKER.md) - Docker-Schnellstart
---
*Letzte Aktualisierung: Januar 2026*

662
README.md
View File

@ -1,618 +1,102 @@
# n8n-nodes-librebooking
# LibreBooking n8n Node
Ein vollständiger n8n Node für die Integration mit [LibreBooking](https://librebooking.org/) - einer Open-Source Ressourcen- und Raumbuchungslösung.
Integration von LibreBooking in n8n für automatisierte Reservierungs- und Ressourcenverwaltung.
<!-- Badges -->
[![npm version](https://img.shields.io/npm/v/n8n-nodes-librebooking.svg?style=flat-square)](https://www.npmjs.com/package/n8n-nodes-librebooking)
[![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg?style=flat-square)](https://opensource.org/licenses/MIT)
[![n8n Community Node](https://img.shields.io/badge/n8n-Community%20Node-orange?style=flat-square)](https://n8n.io)
[![LibreBooking](https://img.shields.io/badge/LibreBooking-Integration-blue?style=flat-square)](https://librebooking.org)
[![Node.js Version](https://img.shields.io/badge/node-%3E%3D18-brightgreen?style=flat-square)](https://nodejs.org)
[![TypeScript](https://img.shields.io/badge/TypeScript-5.x-blue?style=flat-square)](https://www.typescriptlang.org)
## ⚡ Schnellstart (EMPFOHLEN)
---
## ⚡ Schnellstart
### Option 1: Mit Installations-Skript (empfohlen)
**Die einfachste Methode: Auf dem Host bauen, in Docker kopieren**
```bash
# Archiv entpacken
tar -xzf n8n-nodes-librebooking.tar.gz
cd n8n-nodes-librebooking
# Installieren (Linux/Mac)
./install.sh
# n8n starten
n8n start
```
### Option 2: Mit Docker
```bash
# Archiv entpacken und starten
tar -xzf n8n-nodes-librebooking.tar.gz
cd n8n-nodes-librebooking
docker-compose up -d
# Browser öffnen: http://localhost:5678
```
### Option 3: Manuell mit npm
```bash
cd n8n-nodes-librebooking
npm install && npm run build && npm link
n8n start
```
📖 **Detaillierte Anleitung:** Siehe [INSTALLATION.md](INSTALLATION.md)
---
## 📋 Inhaltsverzeichnis
- [Schnellstart](#-schnellstart)
- [Funktionen](#-funktionen)
- [Installation](#-installation)
- [Konfiguration](#️-konfiguration)
- [Operationen](#-operationen)
- [Beispiele](#-beispiele)
- [Trigger Node](#-trigger-node)
- [Troubleshooting](#-troubleshooting)
- [Entwicklung](#-entwicklung)
- [Lizenz](#-lizenz)
---
## 🚀 Funktionen
### Regular Node (LibreBooking)
- **Reservierungen**: Erstellen, Abrufen, Aktualisieren, Löschen, Genehmigen, Check-In/Check-Out
- **Ressourcen**: Verwalten von Räumen, Equipment und anderen buchbaren Ressourcen
- **Zeitpläne**: Abrufen von Zeitplänen und verfügbaren Slots
- **Benutzer**: Vollständige Benutzerverwaltung (Admin-Rechte erforderlich)
- **Konten**: Eigenes Konto verwalten
- **Gruppen**: Benutzergruppen mit Rollen und Berechtigungen verwalten
- **Zubehör**: Zubehörteile abrufen
- **Attribute**: Benutzerdefinierte Felder verwalten
### Trigger Node (LibreBooking Trigger)
- Polling-basierter Trigger für Reservierungs-Events
- Erkennung neuer Reservierungen
- Erkennung geänderter Reservierungen
- Konfigurierbare Filter (Ressource, Zeitplan, Benutzer)
- Deduplizierung von Events
---
## 📦 Installation
### Über npm (empfohlen)
```bash
npm install n8n-nodes-librebooking
```
### Manuelle Installation
1. Laden Sie das Paket herunter oder klonen Sie das Repository:
```bash
git clone https://github.com/your-org/n8n-nodes-librebooking.git
```
2. Wechseln Sie ins Verzeichnis und installieren Sie die Abhängigkeiten:
```bash
cd n8n-nodes-librebooking
npm install
```
3. Kompilieren Sie das Projekt:
```bash
npm run build
```
4. Verlinken Sie das Paket für lokale Entwicklung:
```bash
npm link
```
5. Verlinken Sie es in Ihrem n8n Custom-Nodes-Verzeichnis:
```bash
cd ~/.n8n/custom
npm link n8n-nodes-librebooking
```
6. Starten Sie n8n neu:
```bash
n8n start
```
### Docker-Installation
Fügen Sie in Ihrem Docker-Compose oder Dockerfile hinzu:
```dockerfile
RUN npm install -g n8n-nodes-librebooking
```
Oder über Umgebungsvariable:
```yaml
environment:
- N8N_CUSTOM_EXTENSIONS=n8n-nodes-librebooking
```
### Integration in bestehende Docker-Installation
Für bestehende n8n Docker-Installationen gibt es mehrere Integrationsmethoden:
#### Schnellste Methode: Automatisches Skript
```bash
# Ins n8n Verzeichnis wechseln
cd /pfad/zu/ihrer/n8n/installation
# Skript ausführen
./install-docker.sh
```
#### Manuelle Methode
```bash
# 1. Custom Nodes kopieren
cp -r custom-nodes /pfad/zu/n8n/
cd /pfad/zu/n8n/custom-nodes && npm install && npm run build
# 2. docker-compose.override.yml erstellen
cat > docker-compose.override.yml << 'EOF'
version: '3.8'
services:
n8n:
volumes:
- ./custom-nodes:/home/node/.n8n/custom/n8n-nodes-librebooking:ro
environment:
- N8N_CUSTOM_EXTENSIONS=/home/node/.n8n/custom
- N8N_COMMUNITY_NODES_ENABLED=true
EOF
# 3. Container neustarten
docker-compose restart n8n
```
#### Eigenes Docker-Image bauen
```bash
docker build -f Dockerfile.custom-nodes -t n8n-librebooking .
docker run -d -p 5678:5678 n8n-librebooking
```
📖 **Ausführliche Docker-Anleitung:** Siehe [DOCKER-INTEGRATION.md](DOCKER-INTEGRATION.md)
🚀 **Docker-Schnellstart:** Siehe [SCHNELLSTART-DOCKER.md](SCHNELLSTART-DOCKER.md)
---
## ⚙️ Konfiguration
### Credentials einrichten
1. Öffnen Sie n8n und gehen Sie zu **Settings** → **Credentials**
2. Klicken Sie auf **Add Credential** und wählen Sie **LibreBooking API**
3. Füllen Sie die folgenden Felder aus:
| Feld | Beschreibung | Beispiel |
|------|-------------|----------|
| **LibreBooking URL** | Die Basis-URL Ihrer LibreBooking-Installation | `https://booking.example.com` |
| **Benutzername** | Ihr LibreBooking-Login (E-Mail oder Benutzername) | `admin@example.com` |
| **Passwort** | Ihr LibreBooking-Passwort | `•••••••••` |
> ⚠️ **Wichtig**: Die URL sollte **ohne** `/Web/Services` angegeben werden!
### API aktivieren
Stellen Sie sicher, dass die API in Ihrer LibreBooking-Installation aktiviert ist:
1. Öffnen Sie die `config.php` Ihrer LibreBooking-Installation
2. Suchen Sie nach `$conf['settings']['api']['enabled']`
3. Setzen Sie den Wert auf `true`
```php
$conf['settings']['api']['enabled'] = 'true';
```
### Credential-Test
Nach dem Speichern der Credentials können Sie diese testen:
- Klicken Sie auf **Test** um die Verbindung zu überprüfen
- Bei erfolgreicher Verbindung wird eine Bestätigung angezeigt
---
## 📖 Operationen
### Reservierungen
| Operation | Beschreibung | Admin-Rechte |
|-----------|-------------|--------------|
| **Alle Abrufen** | Liste aller Reservierungen mit optionalen Filtern | ❌ |
| **Abrufen** | Einzelne Reservierung per Referenznummer | ❌ |
| **Erstellen** | Neue Reservierung anlegen | ❌ |
| **Aktualisieren** | Bestehende Reservierung ändern | ❌ |
| **Löschen** | Reservierung entfernen | ❌ |
| **Genehmigen** | Ausstehende Reservierung genehmigen | ❌* |
| **Check-In** | In Reservierung einchecken | ❌ |
| **Check-Out** | Aus Reservierung auschecken | ❌ |
*Erfordert Genehmigungsrechte
#### Filter für "Alle Abrufen"
- `userId` - Nach Benutzer filtern
- `resourceId` - Nach Ressource filtern
- `scheduleId` - Nach Zeitplan filtern
- `startDateTime` - Startzeit (ISO 8601)
- `endDateTime` - Endzeit (ISO 8601)
#### Zusätzliche Felder für "Erstellen/Aktualisieren"
- `description` - Beschreibung
- `participants` - Teilnehmer (Benutzer-IDs)
- `invitees` - Eingeladene (Benutzer-IDs)
- `resources` - Zusätzliche Ressourcen
- `allowParticipation` - Teilnahme erlauben
### Ressourcen
| Operation | Beschreibung | Admin-Rechte |
|-----------|-------------|--------------|
| **Alle Abrufen** | Liste aller Ressourcen | ❌ |
| **Abrufen** | Einzelne Ressource per ID | ❌ |
| **Verfügbarkeit Prüfen** | Verfügbarkeit einer/aller Ressourcen | ❌ |
| **Gruppen Abrufen** | Ressourcen-Gruppenstruktur | ❌ |
| **Typen Abrufen** | Verfügbare Ressourcen-Typen | ❌ |
| **Status Abrufen** | Verfügbare Status-Werte | ❌ |
| **Erstellen** | Neue Ressource anlegen | ✅ |
| **Aktualisieren** | Ressource ändern | ✅ |
| **Löschen** | Ressource entfernen | ✅ |
#### Ressourcen-Optionen
- `location` - Standort
- `contact` - Kontaktinformation
- `description` - Beschreibung
- `maxParticipants` - Maximale Teilnehmerzahl
- `requiresApproval` - Genehmigung erforderlich
- `allowMultiday` - Mehrtägige Buchungen
- `requiresCheckIn` - Check-In erforderlich
- `autoReleaseMinutes` - Auto-Release nach X Minuten
- `color` - Anzeigefarbe (Hex)
- `statusId` - Status (0=Versteckt, 1=Verfügbar, 2=Nicht verfügbar)
### Zeitpläne
| Operation | Beschreibung | Admin-Rechte |
|-----------|-------------|--------------|
| **Alle Abrufen** | Liste aller Zeitpläne | ❌ |
| **Abrufen** | Einzelner Zeitplan mit Perioden | ❌ |
| **Slots Abrufen** | Verfügbare Slots eines Zeitplans | ❌ |
### Benutzer (Admin)
| Operation | Beschreibung | Admin-Rechte |
|-----------|-------------|--------------|
| **Alle Abrufen** | Liste aller Benutzer | ❌ |
| **Abrufen** | Einzelner Benutzer per ID | ❌ |
| **Erstellen** | Neuen Benutzer anlegen | ✅ |
| **Aktualisieren** | Benutzer ändern | ✅ |
| **Passwort Ändern** | Benutzer-Passwort setzen | ✅ |
| **Löschen** | Benutzer entfernen | ✅ |
### Konten
| Operation | Beschreibung | Admin-Rechte |
|-----------|-------------|--------------|
| **Abrufen** | Eigene Kontoinformationen | ❌ |
| **Erstellen** | Neues Konto (Registrierung) | ❌ |
| **Aktualisieren** | Eigenes Konto ändern | ❌ |
| **Passwort Ändern** | Eigenes Passwort ändern | ❌ |
### Gruppen
| Operation | Beschreibung | Admin-Rechte |
|-----------|-------------|--------------|
| **Alle Abrufen** | Liste aller Gruppen | ❌ |
| **Abrufen** | Einzelne Gruppe | ❌ |
| **Erstellen** | Neue Gruppe anlegen | ✅ |
| **Aktualisieren** | Gruppe ändern | ✅ |
| **Löschen** | Gruppe entfernen | ✅ |
| **Rollen Ändern** | Gruppenrollen setzen | ✅ |
| **Berechtigungen Ändern** | Ressourcen-Berechtigungen | ✅ |
| **Benutzer Ändern** | Gruppenmitglieder | ✅ |
#### Rollen-IDs
- `1` - Gruppenadministrator
- `2` - Anwendungsadministrator
- `3` - Ressourcenadministrator
- `4` - Zeitplanadministrator
### Zubehör
| Operation | Beschreibung | Admin-Rechte |
|-----------|-------------|--------------|
| **Alle Abrufen** | Liste aller Zubehörteile | ❌ |
| **Abrufen** | Einzelnes Zubehörteil | ❌ |
### Attribute
| Operation | Beschreibung | Admin-Rechte |
|-----------|-------------|--------------|
| **Abrufen** | Einzelnes Attribut | ❌ |
| **Nach Kategorie Abrufen** | Alle Attribute einer Kategorie | ❌ |
| **Erstellen** | Neues Attribut anlegen | ✅ |
| **Aktualisieren** | Attribut ändern | ✅ |
| **Löschen** | Attribut entfernen | ✅ |
#### Attribut-Kategorien
- `1` - Reservierung
- `2` - Benutzer
- `4` - Ressource
- `5` - Ressourcen-Typ
#### Attribut-Typen
- `1` - Einzeilig (Text)
- `2` - Mehrzeilig (Textarea)
- `3` - Auswahlliste
- `4` - Checkbox
- `5` - Datum/Zeit
---
## 💡 Beispiele
### Beispiel 1: Alle Reservierungen der nächsten Woche abrufen
```json
{
"nodes": [
{
"parameters": {
"resource": "reservation",
"operation": "getAll",
"filters": {
"startDateTime": "={{ $now.toISO() }}",
"endDateTime": "={{ $now.plus({days: 7}).toISO() }}"
}
},
"name": "LibreBooking",
"type": "n8n-nodes-librebooking.libreBooking",
"typeVersion": 1,
"position": [250, 300],
"credentials": {
"libreBookingApi": {
"id": "1",
"name": "LibreBooking"
}
}
}
]
}
```
### Beispiel 2: Neue Reservierung erstellen
```json
{
"parameters": {
"resource": "reservation",
"operation": "create",
"resourceId": 1,
"startDateTime": "2026-01-26T10:00:00",
"endDateTime": "2026-01-26T11:00:00",
"title": "Team Meeting",
"additionalFields": {
"description": "Wöchentliches Team-Meeting",
"participants": "2,3,4"
}
}
}
```
### Beispiel 3: Verfügbarkeit prüfen
```json
{
"parameters": {
"resource": "resource",
"operation": "getAvailability",
"resourceIdOptional": 1,
"availabilityDateTime": "2026-01-26T14:00:00"
}
}
```
### Beispiel 4: Benutzer mit Filter suchen
```json
{
"parameters": {
"resource": "user",
"operation": "getAll",
"userFilters": {
"organization": "Marketing",
"lastName": "Müller"
}
}
}
```
---
## ⚡ Trigger Node
Der **LibreBooking Trigger** ist ein Polling-basierter Trigger, der auf neue oder geänderte Reservierungen reagiert.
### Konfiguration
| Parameter | Beschreibung |
|-----------|-------------|
| **Event** | Art des Events (Neue/Geänderte/Alle Reservierungen) |
| **Filter** | Optional: Ressource, Zeitplan, Benutzer |
| **Zeitfenster** | Überwachungszeitraum (7/14/30/90 Tage) |
| **Detaillierte Daten** | Vollständige Reservierungsdetails abrufen |
### Event-Typen
- **Neue Reservierung**: Wird nur bei neuen Reservierungen ausgelöst
- **Geänderte Reservierung**: Wird bei Änderungen an bestehenden Reservierungen ausgelöst
- **Alle Reservierungen**: Wird bei neuen und geänderten Reservierungen ausgelöst
### Beispiel-Workflow: Benachrichtigung bei neuer Reservierung
```
[LibreBooking Trigger] → [IF: Ressource = 1] → [Slack: Nachricht senden]
```
### Deduplizierung
Der Trigger speichert Informationen über bereits verarbeitete Reservierungen und verhindert so doppelte Ausführungen. Bei Änderungen (Titel, Zeit, etc.) wird eine Reservierung als "geändert" erkannt.
---
## 🔧 Troubleshooting
### Häufige Fehler
#### "Authentifizierung fehlgeschlagen"
- Überprüfen Sie die LibreBooking-URL (ohne `/Web/Services`)
- Stellen Sie sicher, dass Benutzername und Passwort korrekt sind
- Prüfen Sie, ob die API in LibreBooking aktiviert ist
#### "Zugriff verweigert" (403)
- Die Operation erfordert Administrator-Rechte
- Verwenden Sie einen Admin-Account oder wählen Sie eine andere Operation
#### "Nicht gefunden" (404)
- Die angegebene ID (Ressource, Benutzer, etc.) existiert nicht
- Überprüfen Sie die Referenznummer bei Reservierungen
#### "Session abgelaufen"
- Der Session-Token ist abgelaufen
- Führen Sie den Workflow erneut aus
### API-Limitierungen
- LibreBooking hat keine dokumentierten Rate-Limits
- Bei vielen Anfragen empfehlen wir Pausen zwischen den Operationen
- Der Node authentifiziert sich bei jeder Ausführung neu und meldet sich am Ende ab
### Debug-Tipps
1. Aktivieren Sie die n8n-Logs für detaillierte Fehlermeldungen:
```bash
export N8N_LOG_LEVEL=debug
n8n start
```
2. Testen Sie die API direkt im Browser:
```
https://your-librebooking.com/Web/Services/index.php
```
3. Überprüfen Sie die Zeitzonen-Einstellungen in LibreBooking und n8n
---
## 🛠 Entwicklung
### Voraussetzungen
- Node.js 18.17.0 oder höher
- npm 9.x oder höher
- n8n (für Tests)
### Setup
```bash
# Repository klonen
# 1. Repository klonen
git clone https://github.com/your-org/n8n-nodes-librebooking.git
cd n8n-nodes-librebooking
# Abhängigkeiten installieren
# 2. Bauen und installieren
./quick-install.sh n8n
# Fertig! ✔
```
**Oder manuell:**
```bash
# Dependencies & Build
npm install
# TypeScript kompilieren
npm run build
# Für Entwicklung (Watch-Modus)
npm run dev
# In Container kopieren
docker cp dist n8n:/home/node/.n8n/custom/n8n-nodes-librebooking/
docker cp package.json n8n:/home/node/.n8n/custom/n8n-nodes-librebooking/
docker cp node_modules n8n:/home/node/.n8n/custom/n8n-nodes-librebooking/
# Container neustarten
docker restart n8n
```
### Projektstruktur
```
n8n-nodes-librebooking/
├── credentials/
│ └── LibreBookingApi.credentials.ts
├── nodes/
│ ├── LibreBooking/
│ │ ├── LibreBooking.node.ts
│ │ └── librebooking.svg
│ └── LibreBookingTrigger/
│ ├── LibreBookingTrigger.node.ts
│ └── librebooking.svg
├── workflows/
│ └── example-workflows.json
├── test/
│ └── test-api.ts
├── package.json
├── tsconfig.json
└── README.md
```
### Tests ausführen
## 🛠️ npm Scripts
```bash
# API-Test mit echten Credentials
npm test
npm run build # Baut den Node
npm run docker:deploy # Baut, kopiert & startet Container neu
npm run docker:copy # Kopiert in Container
npm run docker:restart # Startet Container neu
```
### Linting
## 📚 Dokumentation
- **[INSTALLATION.md](INSTALLATION.md)** - Alle Installationsmethoden
- **[SCHNELLSTART.md](SCHNELLSTART.md)** - Ultra-kurze Anleitung
- **[TROUBLESHOOTING.md](TROUBLESHOOTING.md)** - Problemlösung
- **[DOCKER-INTEGRATION.md](DOCKER-INTEGRATION.md)** - Docker-spezifische Anleitung
## 🔑 Credentials einrichten
1. Öffne n8n: http://localhost:5678
2. Gehe zu: **Einstellungen** → **Credentials** → **Add Credential**
3. Suche: **LibreBooking API**
4. Eingabe:
- **URL**: `https://deine-librebooking-url.de`
- **Benutzername**: Admin-Benutzer
- **Passwort**: Passwort
## 🌟 Features
### LibreBooking Node
- Reservierungen erstellen, bearbeiten, löschen
- Ressourcen und Verfügbarkeit verwalten
- Benutzer und Gruppen administrieren
- Zeitpläne und Zubehör konfigurieren
### LibreBooking Trigger Node
- Neue Reservierungen überwachen
- Geänderte Reservierungen erfassen
- Filter nach Ressource/Zeitplan/Benutzer
## 🔄 Updates
```bash
npm run lint
npm run lint:fix
# Nach Änderungen oder git pull
./update-node.sh n8n
# Oder mit npm
npm run docker:deploy
```
### Build für Produktion
## ❓ Problemlösung
```bash
npm run build
```
### tsc not found?
→ **Lösung**: Auf dem Host bauen (siehe Schnellstart)
---
### Read-only Volume?
→ **Lösung**: dist/ in Container kopieren statt npm im Container
### npm audit Vulnerabilities?
→ Sind non-critical Dependencies von n8n-workflow. Siehe [SECURITY.md](SECURITY.md)
## 📄 Lizenz
MIT License - siehe [LICENSE](LICENSE) Datei
---
MIT - Siehe [LICENSE](LICENSE)
## 🤝 Beitragen
Beiträge sind willkommen! Bitte öffnen Sie einen Issue oder Pull Request.
1. Fork des Repositories
2. Feature-Branch erstellen (`git checkout -b feature/AmazingFeature`)
3. Änderungen committen (`git commit -m 'Add AmazingFeature'`)
4. Branch pushen (`git push origin feature/AmazingFeature`)
5. Pull Request öffnen
---
## 📞 Support
- **Issues**: [GitHub Issues](https://github.com/your-org/n8n-nodes-librebooking/issues)
- **LibreBooking Dokumentation**: [https://librebooking.org/docs](https://librebooking.org/docs)
- **n8n Community**: [https://community.n8n.io](https://community.n8n.io)
---
**Erstellt mit ❤️ für die n8n und LibreBooking Community**
Beiträge sind willkommen! Siehe [CONTRIBUTING.md](CONTRIBUTING.md)

136
SCHNELLSTART-DOCKER.md
View File

@ -1,37 +1,33 @@
# Schnellstart: Docker-Integration
# Docker Schnellstart - LibreBooking n8n Node
Ultra-kurze Anleitung für erfahrene Docker-Nutzer.
Schnelle Befehle für erfahrene Docker-Benutzer.
---
## Automatische Installation (Empfohlen)
## Neue Installation
### Option A: Mit docker-compose (empfohlen)
```bash
# Ins n8n Verzeichnis wechseln
cd /pfad/zu/deiner/n8n/installation
# 1. Starten
cd /pfad/zu/librebooking_n8n_node
docker compose up -d
# Skript ausführen
./install-docker.sh
# Oder mit Pfad
./install-docker.sh -p /opt/n8n
# 2. Browser öffnen
open http://localhost:5678
```
---
## Manuelle Installation (3 Schritte)
### 1. Custom Nodes kopieren
### Option B: In bestehende n8n Installation integrieren
```bash
# 1. Custom Nodes kopieren
cp -r custom-nodes /pfad/zu/n8n/
# 2. Bauen
cd /pfad/zu/n8n/custom-nodes
npm install && npm run build
```
### 2. Override-Datei erstellen
```bash
# 3. docker-compose.override.yml erstellen
cat > docker-compose.override.yml << 'EOF'
version: '3.8'
services:
@ -42,62 +38,110 @@ services:
- N8N_CUSTOM_EXTENSIONS=/home/node/.n8n/custom
- N8N_COMMUNITY_NODES_ENABLED=true
EOF
```
### 3. Neustarten
```bash
docker-compose restart n8n
# 4. Neustarten
docker compose restart n8n
```
---
## Neues Setup mit Docker
## Node im Container bauen/reparieren
### Quick-Fix (Ein Befehl)
```bash
# Beispiel-Konfiguration verwenden
cp docker-compose.example.yml docker-compose.yml
cp .env.docker .env
docker exec n8n sh -c "cd /home/node/.n8n/custom/n8n-nodes-librebooking && npm install && npm run build" && docker restart n8n
```
# .env anpassen, dann starten
docker-compose up -d
### Mit Auto-Fix Skript
```bash
./fix-node-installation.sh
```
### Status prüfen
```bash
# Check-Skript ausführen
docker cp check-installation.sh n8n:/tmp/
docker exec n8n sh /tmp/check-installation.sh
```
---
## Eigenes Image bauen
## Häufige Befehle
```bash
docker build -f Dockerfile.custom-nodes -t n8n-librebooking .
docker run -d -p 5678:5678 n8n-librebooking
| Aktion | Befehl |
|--------|--------|
| Container starten | `docker compose up -d` |
| Container stoppen | `docker compose down` |
| Container neustarten | `docker restart n8n` |
| Logs anzeigen | `docker logs -f n8n` |
| In Container einloggen | `docker exec -it n8n sh` |
| Node bauen | `docker exec n8n sh -c "cd /home/node/.n8n/custom/n8n-nodes-librebooking && npm install && npm run build"` |
| Status prüfen | `docker exec n8n sh /tmp/check-installation.sh` |
---
## Pfade im Container
| Beschreibung | Pfad |
|--------------|------|
| n8n Home | `/home/node/.n8n` |
| Custom Nodes | `/home/node/.n8n/custom` |
| LibreBooking Node | `/home/node/.n8n/custom/n8n-nodes-librebooking` |
| Daten-Verzeichnis | `/home/node/.n8n` |
---
## Umgebungsvariablen
```yaml
environment:
- N8N_CUSTOM_EXTENSIONS=/home/node/.n8n/custom
- N8N_COMMUNITY_NODES_ENABLED=true
- N8N_LOG_LEVEL=info
```
---
## Verifizierung
## Troubleshooting
### Node erscheint nicht
```bash
# Node prüfen
# 1. Build prüfen
docker exec n8n ls /home/node/.n8n/custom/n8n-nodes-librebooking/dist/
# In n8n: Nach "LibreBooking" suchen
# 2. Falls leer - neu bauen
docker exec n8n sh -c "cd /home/node/.n8n/custom/n8n-nodes-librebooking && npm install && npm run build"
# 3. Neustarten
docker restart n8n
```
---
## Bei Problemen
### Permission denied
```bash
# Berechtigungen
sudo chown -R 1000:1000 custom-nodes/
```
# Logs
docker logs n8n | grep -i error
### docker-compose: distutils Fehler (Python 3.12)
# Neustart
docker-compose down && docker-compose up -d
```bash
# Lösung: Docker Compose v2 verwenden
sudo apt-get install docker-compose-plugin
docker compose up -d # Beachte: ohne Bindestrich
```
---
📖 **Ausführliche Anleitung:** [DOCKER-INTEGRATION.md](DOCKER-INTEGRATION.md)
## Detaillierte Anleitungen
- [DOCKER-INTEGRATION.md](DOCKER-INTEGRATION.md) - Vollständige Docker-Dokumentation
- [MANUELLE-INSTALLATION-CONTAINER.md](MANUELLE-INSTALLATION-CONTAINER.md) - Manuelle Installation
- [TROUBLESHOOTING.md](TROUBLESHOOTING.md) - Alle Probleme und Lösungen
---
*Schnellstart-Guide für Docker-Profis*

76
SCHNELLSTART.md
View File

@ -1,60 +1,40 @@
# Schnellstart - LibreBooking n8n Node
# Schnellstart
Diese Anleitung ist für erfahrene Benutzer, die schnell loslegen möchten.
## Option A: Mit Skript (empfohlen)
## ⚡ Installation in 4 Zeilen
```bash
# Archiv entpacken
tar -xzf n8n-nodes-librebooking.tar.gz
cd n8n-nodes-librebooking
# Installieren
./install.sh
# n8n starten
n8n start
```
## Option B: Mit Docker
```bash
# Archiv entpacken
tar -xzf n8n-nodes-librebooking.tar.gz
cd n8n-nodes-librebooking
# Container starten
docker-compose up -d
# Browser öffnen
open http://localhost:5678
```
## Option C: Manuell
```bash
tar -xzf n8n-nodes-librebooking.tar.gz
cd n8n-nodes-librebooking
cd /pfad/zu/n8n-nodes-librebooking
npm install
npm run build
npm link
n8n start
./quick-install.sh n8n
```
## Credentials einrichten
**Oder mit npm scripts:**
1. Öffne http://localhost:5678
2. Erstelle neuen Workflow
3. Füge "LibreBooking" Node hinzu
4. Erstelle neue Credentials:
- **URL:** `https://dein-server/Web/Services`
- **Username:** Admin-Benutzer
- **Password:** Passwort
```bash
npm install
npm run docker:deploy
```
## Fertig!
## 🔑 Credentials
Der LibreBooking Node ist jetzt verfügbar.
n8n → Einstellungen → Credentials → Add → "LibreBooking API"
---
| Feld | Wert |
|------|------|
| URL | `https://deine-librebooking-url.de` |
| Benutzername | Admin-Benutzer |
| Passwort | Passwort |
Für detaillierte Anleitungen siehe [INSTALLATION.md](INSTALLATION.md)
## 🔄 Updates
```bash
git pull
./update-node.sh n8n
```
## ❓ Probleme?
- **tsc not found**: Auf dem Host bauen (npm install && npm run build)
- **Read-only Volume**: `docker cp` verwenden
- Mehr: [TROUBLESHOOTING.md](TROUBLESHOOTING.md)

234
SECURITY.md Normal file
View File

@ -0,0 +1,234 @@
# Sicherheitshinweise - LibreBooking n8n Node
Dieses Dokument erklärt die npm audit Vulnerabilities und wie man damit umgeht.
## Inhaltsverzeichnis
- [Übersicht der Vulnerabilities](#übersicht-der-vulnerabilities)
- [Warum diese Vulnerabilities existieren](#warum-diese-vulnerabilities-existieren)
- [Risikoeinschätzung](#risikoeinschätzung)
- [Empfehlungen](#empfehlungen)
- [Wie man sie beheben kann](#wie-man-sie-beheben-kann)
- [Produktionsumgebungen](#produktionsumgebungen)
---
## Übersicht der Vulnerabilities
Beim Ausführen von `npm audit` werden möglicherweise folgende Vulnerabilities angezeigt:
### Critical: form-data
```
form-data <4.0.1
Severity: critical
Prototype Pollution in form-data
https://github.com/advisories/GHSA-xxx
```
### Moderate: lodash
```
lodash <4.17.21
Severity: moderate
Prototype Pollution in lodash
https://github.com/advisories/GHSA-xxx
```
---
## Warum diese Vulnerabilities existieren
Diese Vulnerabilities kommen **nicht direkt aus diesem Projekt**, sondern sind **transitive Dependencies** von `n8n-workflow` und `n8n-core`.
### Dependency-Kette:
```
n8n-nodes-librebooking
└── n8n-workflow (devDependency für Typen)
└── axios
└── form-data (vulnerable version)
└── lodash (vulnerable version)
```
### Wichtig zu verstehen:
1. **n8n-workflow** ist nur als `devDependency` und `peerDependency` deklariert
2. In Produktion verwendet n8n seine **eigene** n8n-workflow Version
3. Die vulnerable Dependencies werden nur beim **Entwickeln** installiert
4. Diese Package werden **nicht** in das finale dist/ Verzeichnis gebündelt
---
## Risikoeinschätzung
### Für dieses Projekt: **NIEDRIGES RISIKO**
| Aspekt | Risiko | Begründung |
|--------|--------|------------|
| Entwicklung | Niedrig | form-data/lodash werden nicht direkt verwendet |
| Produktion | Sehr niedrig | Keine transtiven Dependencies werden deployed |
| n8n Runtime | Abhängig von n8n | n8n selbst muss die Vulnerabilities beheben |
### Warum niedriges Risiko:
1. **form-data Vulnerability:**
- Betrifft nur das Parsen von multipart/form-data
- Dieser Node verwendet keine File-Uploads über form-data
- Die LibreBooking API verwendet JSON für alle Requests
2. **lodash Vulnerability:**
- Betrifft `_.set()` und `_.setWith()` Funktionen
- Dieser Node verwendet keine direkten lodash Aufrufe
- Die Vulnerability erfordert Angreifer-kontrollierten Input
---
## Empfehlungen
### Für Entwickler:
1. **Warnungen ignorieren** (wenn nicht kritisch):
```bash
npm install --ignore-scripts
```
2. **Audit bei npm install deaktivieren:**
```bash
# Einmalig:
npm install --no-audit
# Permanent via .npmrc:
echo "audit=false" >> .npmrc
```
3. **Overrides verwenden** (in package.json):
```json
"overrides": {
"form-data": "^4.0.1",
"lodash": "^4.17.21"
}
```
### Für Produktionsumgebungen:
1. **n8n aktuell halten:** Die n8n-Entwickler aktualisieren regelmäßig ihre Dependencies
2. **Nur vertrauenswürdige Inputs:** Keine ungeprüften Daten an die Nodes übergeben
3. **Network Isolation:** n8n Container im isolierten Netzwerk betreiben
---
## Wie man sie beheben kann
### Option 1: Overrides in package.json (empfohlen)
Die package.json enthält bereits Overrides für bekannte Vulnerabilities:
```json
"overrides": {
"form-data": "^4.0.1",
"lodash": "^4.17.21"
}
```
### Option 2: npm audit fix (begrenzt)
```bash
# Automatische Fixes (nur kompatible Updates)
npm audit fix
# Force Fixes (VORSICHT: kann Breaking Changes einführen)
npm audit fix --force
```
**Hinweis:** `npm audit fix` kann transitive Dependencies nur begrenzt beheben.
### Option 3: Update-Skript verwenden
```bash
./update-dependencies.sh
```
Das Skript:
- Führt `npm audit fix` aus
- Aktualisiert alle Dependencies
- Testet ob alles funktioniert
- Gibt einen Report
### Option 4: Resolutions (für yarn/pnpm)
Wenn Sie yarn statt npm verwenden:
```json
"resolutions": {
"form-data": "^4.0.1",
"lodash": "^4.17.21"
}
```
---
## Produktionsumgebungen
### Best Practices:
1. **Docker Image aktuell halten:**
```bash
docker pull n8nio/n8n:latest
```
2. **Regelmäßige Updates:**
```bash
docker compose pull
docker compose up -d
```
3. **Security Scanning:**
```bash
# Image auf Vulnerabilities prüfen
docker scan n8nio/n8n:latest
# Oder mit Trivy:
trivy image n8nio/n8n:latest
```
4. **Netzwerk-Isolation:**
- n8n nicht direkt im Internet exponieren
- Reverse Proxy mit TLS verwenden
- Firewall-Regeln setzen
5. **Zugriffskontrollen:**
- Starke Passwörter verwenden
- Basic Auth oder OAuth aktivieren
- API-Keys für LibreBooking sicher speichern
### Sicherheits-Checkliste:
- [ ] n8n Version aktuell?
- [ ] Docker Image aktuell?
- [ ] TLS/HTTPS aktiviert?
- [ ] Starke Passwörter?
- [ ] Netzwerk isoliert?
- [ ] Regelmäßige Backups?
---
## Weiterführende Links
- [n8n Security Best Practices](https://docs.n8n.io/hosting/security/)
- [npm audit Documentation](https://docs.npmjs.com/cli/v8/commands/npm-audit)
- [OWASP Dependency Check](https://owasp.org/www-project-dependency-check/)
- [Snyk Vulnerability Database](https://snyk.io/vuln/)
---
## Meldung von Sicherheitsproblemen
Wenn Sie eine Sicherheitslücke **direkt in diesem Projekt** (nicht in Dependencies) finden:
1. **Nicht öffentlich melden** (kein GitHub Issue)
2. Kontaktieren Sie uns direkt per E-Mail
3. Geben Sie Zeit für einen Fix bevor öffentliche Disclosure
---
*Letzte Aktualisierung: Januar 2026*

141
TROUBLESHOOTING.md Normal file
View File

@ -0,0 +1,141 @@
# Troubleshooting
## Inhaltsverzeichnis
1. [tsc not found](#tsc-not-found)
2. [Read-only Volume](#read-only-volume)
3. [npm audit Vulnerabilities](#npm-audit-vulnerabilities)
4. [Node nicht sichtbar](#node-nicht-sichtbar)
5. [Authentifizierung fehlgeschlagen](#authentifizierung-fehlgeschlagen)
---
## tsc not found
**Symptom:**
```
sh: 1: tsc: not found
npm error code 127
```
**Ursache:** TypeScript ist nicht installiert (im Container oft nicht verfügbar).
**Lösung:** Auf dem Host bauen!
```bash
# Auf dem Host (nicht im Container)
npm install
npm run build
# Dann in Container kopieren
docker cp dist n8n:/home/node/.n8n/custom/n8n-nodes-librebooking/
docker cp package.json n8n:/home/node/.n8n/custom/n8n-nodes-librebooking/
docker cp node_modules n8n:/home/node/.n8n/custom/n8n-nodes-librebooking/
docker restart n8n
```
**Oder mit Skript:**
```bash
./quick-install.sh n8n
```
---
## Read-only Volume
**Symptom:**
```
EROFS: read-only file system
npm error EACCES: permission denied
```
**Ursache:** Volume ist mit `:ro` gemountet.
**Lösung 1:** Volume ohne `:ro` mounten
```yaml
# docker-compose.yml
volumes:
- ./custom-nodes:/home/node/.n8n/custom # Ohne :ro
```
**Lösung 2:** Auf dem Host bauen und kopieren
```bash
npm install && npm run build
docker cp dist n8n:/home/node/.n8n/custom/n8n-nodes-librebooking/
```
---
## npm audit Vulnerabilities
**Symptom:**
```
found 2 vulnerabilities (1 moderate, 1 critical)
```
**Erklärung:** Diese kommen von `n8n-workflow` und sind für dieses Projekt nicht kritisch.
**Lösung:** Ignorieren oder `.npmrc` verwenden:
```bash
# .npmrc bereits konfiguriert
audit=false
```
Siehe [SECURITY.md](SECURITY.md) für Details.
---
## Node nicht sichtbar
**Lösung:**
1. Container neustarten:
```bash
docker restart n8n
```
2. Dateien prüfen:
```bash
docker exec n8n ls -la /home/node/.n8n/custom/n8n-nodes-librebooking/
```
3. Environment prüfen:
```yaml
environment:
- N8N_CUSTOM_EXTENSIONS=/home/node/.n8n/custom
```
4. Logs prüfen:
```bash
docker logs n8n | grep -i librebooking
```
---
## Authentifizierung fehlgeschlagen
**Symptom:** "401 Unauthorized" oder "Invalid credentials"
**Lösung:**
1. URL prüfen (ohne `/Web/` am Ende)
2. Benutzer muss Admin sein
3. API muss in LibreBooking aktiviert sein
Test:
```bash
curl -X POST https://librebooking.example.com/Web/Services/Authentication/Authenticate \
-H 'Content-Type: application/json' \
-d '{"username": "admin", "password": "pass"}'
```
---
## Weitere Hilfe
- [README.md](README.md) - Übersicht
- [INSTALLATION.md](INSTALLATION.md) - Installationsanleitung
- [DOCKER-INTEGRATION.md](DOCKER-INTEGRATION.md) - Docker Details

183
build-on-host.sh Executable file
View File

@ -0,0 +1,183 @@
#!/bin/bash
# ============================================================================
# build-on-host.sh - Baut den Node auf dem Host (außerhalb des Containers)
#
# Verwendung: Wenn das Volume als read-only gemountet werden soll
#
# Dieses Skript:
# 1. Installiert Dependencies auf dem Host
# 2. Baut den Node auf dem Host
# 3. Kopiert nur die fertigen Dateien in den Container
# 4. Das Volume kann dann read-only gemountet werden
# ============================================================================
set -e
# Farben
RED='\033[0;31m'
GREEN='\033[0;32m'
YELLOW='\033[1;33m'
BLUE='\033[0;34m'
NC='\033[0m'
SCRIPT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
echo -e "${BLUE}============================================${NC}"
echo -e "${BLUE} LibreBooking Node - Build auf Host${NC}"
echo -e "${BLUE}============================================${NC}"
echo ""
# Hilfe anzeigen
show_help() {
echo "Verwendung: $0 [OPTIONEN]"
echo ""
echo "Dieses Skript baut den Node auf dem Host, sodass er als"
echo "read-only Volume gemountet werden kann."
echo ""
echo "Optionen:"
echo " -o, --output DIR Ausgabeverzeichnis (Standard: ./dist-for-docker)"
echo " -c, --copy-to PATH Kopiert direkt zu einem Pfad (z.B. custom-nodes/)"
echo " -h, --help Diese Hilfe anzeigen"
echo ""
echo "Beispiele:"
echo " $0 # Baut in ./dist-for-docker"
echo " $0 -c ../n8n/custom-nodes/n8n-nodes-librebooking"
echo ""
echo "Danach in docker-compose.yml:"
echo " volumes:"
echo " - ./dist-for-docker:/home/node/.n8n/custom/n8n-nodes-librebooking:ro"
exit 0
}
OUTPUT_DIR="$SCRIPT_DIR/dist-for-docker"
COPY_TO=""
# Parameter parsen
while [[ $# -gt 0 ]]; do
case $1 in
-o|--output)
OUTPUT_DIR="$2"
shift 2
;;
-c|--copy-to)
COPY_TO="$2"
shift 2
;;
-h|--help)
show_help
;;
*)
echo -e "${RED}Unbekannte Option: $1${NC}"
show_help
;;
esac
done
log() {
echo -e "${GREEN}[INFO]${NC} $1"
}
warn() {
echo -e "${YELLOW}[WARN]${NC} $1"
}
error() {
echo -e "${RED}[ERROR]${NC} $1"
exit 1
}
# Schritt 1: Prüfe Voraussetzungen
log "Prüfe Voraussetzungen..."
if ! command -v node &>/dev/null; then
error "Node.js ist nicht installiert!\n\n Installieren Sie Node.js 18+: https://nodejs.org/"
fi
NODE_VERSION=$(node -v | cut -d'v' -f2 | cut -d'.' -f1)
if [ "$NODE_VERSION" -lt 18 ]; then
error "Node.js Version $NODE_VERSION ist zu alt. Mindestens v18 erforderlich."
fi
if ! command -v npm &>/dev/null; then
error "npm ist nicht installiert!"
fi
log "Node.js: $(node -v)"
log "npm: $(npm -v)"
# Schritt 2: Dependencies installieren
log "Installiere Dependencies..."
cd "$SCRIPT_DIR"
if npm install 2>&1 | tail -5; then
log "Dependencies installiert ✓"
else
error "npm install fehlgeschlagen!"
fi
# Schritt 3: Bauen
log "Baue den Node..."
if npm run build 2>&1 | tail -10; then
log "Build erfolgreich ✓"
else
error "npm run build fehlgeschlagen!"
fi
# Schritt 4: Prüfe Build
if [ ! -d "$SCRIPT_DIR/dist" ]; then
error "dist/ Verzeichnis wurde nicht erstellt!"
fi
NODE_COUNT=$(find "$SCRIPT_DIR/dist" -name "*.node.js" | wc -l)
if [ "$NODE_COUNT" -eq 0 ]; then
error "Keine .node.js Dateien im dist/ Verzeichnis!"
fi
log "Gefunden: $NODE_COUNT Node-Datei(en)"
# Schritt 5: Erstelle Ausgabeverzeichnis
log "Erstelle Ausgabeverzeichnis: $OUTPUT_DIR"
mkdir -p "$OUTPUT_DIR"
# Kopiere alle notwendigen Dateien
cp -r "$SCRIPT_DIR/dist" "$OUTPUT_DIR/"
cp "$SCRIPT_DIR/package.json" "$OUTPUT_DIR/"
cp -r "$SCRIPT_DIR/node_modules" "$OUTPUT_DIR/" 2>/dev/null || true
# Optional: Nur essentielle Dateien für minimales Image
log "Räume auf..."
rm -rf "$OUTPUT_DIR/node_modules/.cache" 2>/dev/null || true
# Schritt 6: Optional kopieren
if [ -n "$COPY_TO" ]; then
log "Kopiere zu: $COPY_TO"
mkdir -p "$COPY_TO"
cp -r "$OUTPUT_DIR/"* "$COPY_TO/"
log "Kopiert ✓"
fi
echo ""
echo -e "${GREEN}============================================${NC}"
echo -e "${GREEN} Build abgeschlossen!${NC}"
echo -e "${GREEN}============================================${NC}"
echo ""
log "Ausgabe in: $OUTPUT_DIR"
echo ""
echo "Nächste Schritte:"
echo ""
echo "1. Kopieren Sie das Verzeichnis zu Ihrer n8n Installation:"
echo " cp -r $OUTPUT_DIR /pfad/zu/n8n/custom-nodes/n8n-nodes-librebooking"
echo ""
echo "2. Oder verwenden Sie es direkt in docker-compose.yml:"
echo ""
echo " services:"
echo " n8n:"
echo " volumes:"
echo " # Read-only möglich, da bereits gebaut!"
echo " - $OUTPUT_DIR:/home/node/.n8n/custom/n8n-nodes-librebooking:ro"
echo ""
echo "3. Starten Sie n8n neu:"
echo " docker compose restart n8n"
echo ""

281
check-installation.sh Executable file
View File

@ -0,0 +1,281 @@
#!/bin/sh
# ============================================================================
# check-installation.sh - Debug-Skript für LibreBooking Node Installation
# Kann sowohl im Container als auch auf dem Host ausgeführt werden
# ============================================================================
echo "============================================"
echo " LibreBooking Node - Installation Check"
echo "============================================"
echo ""
echo "Ausgeführt: $(date)"
echo "Hostname: $(hostname)"
echo ""
# Status-Zähler
OK_COUNT=0
WARN_COUNT=0
ERROR_COUNT=0
ok() {
echo "[✓] $1"
OK_COUNT=$((OK_COUNT + 1))
}
warn() {
echo "[!] $1"
WARN_COUNT=$((WARN_COUNT + 1))
}
error() {
echo "[✗] $1"
ERROR_COUNT=$((ERROR_COUNT + 1))
}
info() {
echo "[i] $1"
}
echo "============================================"
echo " 1. UMGEBUNG"
echo "============================================"
# Node.js/npm prüfen
if command -v node >/dev/null 2>&1; then
ok "Node.js installiert: $(node --version)"
else
error "Node.js nicht gefunden"
fi
if command -v npm >/dev/null 2>&1; then
ok "npm installiert: $(npm --version)"
else
error "npm nicht gefunden"
fi
# Aktueller Benutzer
info "Aktueller Benutzer: $(whoami) (UID: $(id -u))"
echo ""
echo "============================================"
echo " 2. UMGEBUNGSVARIABLEN"
echo "============================================"
if [ -n "$N8N_CUSTOM_EXTENSIONS" ]; then
ok "N8N_CUSTOM_EXTENSIONS: $N8N_CUSTOM_EXTENSIONS"
else
warn "N8N_CUSTOM_EXTENSIONS nicht gesetzt"
info " Empfehlung: N8N_CUSTOM_EXTENSIONS=/home/node/.n8n/custom"
fi
if [ "$N8N_COMMUNITY_NODES_ENABLED" = "true" ]; then
ok "N8N_COMMUNITY_NODES_ENABLED: true"
else
warn "N8N_COMMUNITY_NODES_ENABLED ist nicht 'true'"
info " Aktueller Wert: ${N8N_COMMUNITY_NODES_ENABLED:-<nicht gesetzt>}"
fi
# Weitere n8n Variablen
if [ -n "$N8N_LOG_LEVEL" ]; then
info "N8N_LOG_LEVEL: $N8N_LOG_LEVEL"
fi
echo ""
echo "============================================"
echo " 3. VERZEICHNISSE PRÜFEN"
echo "============================================"
# Mögliche Pfade
POSSIBLE_PATHS="
/home/node/.n8n/custom/n8n-nodes-librebooking
/home/node/.n8n/custom
/opt/n8n/custom-nodes
/data/custom-nodes
"
FOUND_PATH=""
for path in $POSSIBLE_PATHS; do
if [ -d "$path" ]; then
if [ -f "$path/package.json" ]; then
ok "Custom Node Verzeichnis: $path"
FOUND_PATH="$path"
break
elif [ -f "$path/n8n-nodes-librebooking/package.json" ]; then
ok "Custom Node Verzeichnis: $path/n8n-nodes-librebooking"
FOUND_PATH="$path/n8n-nodes-librebooking"
break
else
info "Verzeichnis existiert (ohne package.json): $path"
fi
fi
done
if [ -z "$FOUND_PATH" ]; then
error "Kein Custom Node Verzeichnis mit package.json gefunden!"
info " Geprüfte Pfade:"
for path in $POSSIBLE_PATHS; do
info " - $path"
done
fi
echo ""
echo "============================================"
echo " 4. NODE-DATEIEN PRÜFEN"
echo "============================================"
if [ -n "$FOUND_PATH" ]; then
cd "$FOUND_PATH" 2>/dev/null || true
# package.json
if [ -f "package.json" ]; then
ok "package.json vorhanden"
info " Name: $(grep '"name":' package.json | head -1 | cut -d'"' -f4)"
info " Version: $(grep '"version":' package.json | head -1 | cut -d'"' -f4)"
else
error "package.json fehlt"
fi
# node_modules
if [ -d "node_modules" ]; then
MODULE_COUNT=$(ls -1 node_modules 2>/dev/null | wc -l)
ok "node_modules vorhanden ($MODULE_COUNT Pakete)"
else
error "node_modules fehlt - führen Sie 'npm install' aus"
fi
# dist Verzeichnis
if [ -d "dist" ]; then
ok "dist/ Verzeichnis vorhanden"
# .node.js Dateien suchen
echo ""
info "Gefundene Node-Dateien:"
NODE_FILES=$(find dist -name "*.node.js" 2>/dev/null)
if [ -n "$NODE_FILES" ]; then
echo "$NODE_FILES" | while read -r f; do
if [ -f "$f" ]; then
ok " $f ($(ls -lh "$f" | awk '{print $5}'))"
fi
done
else
error " Keine .node.js Dateien gefunden!"
fi
# Credentials
echo ""
info "Gefundene Credential-Dateien:"
CRED_FILES=$(find dist -name "*.credentials.js" 2>/dev/null)
if [ -n "$CRED_FILES" ]; then
echo "$CRED_FILES" | while read -r f; do
if [ -f "$f" ]; then
ok " $f"
fi
done
else
error " Keine .credentials.js Dateien gefunden!"
fi
else
error "dist/ Verzeichnis fehlt - führen Sie 'npm run build' aus"
fi
# Icons
echo ""
info "Icon-Dateien:"
find . -name "*.svg" 2>/dev/null | while read -r f; do
info " $f"
done
fi
echo ""
echo "============================================"
echo " 5. BERECHTIGUNGEN"
echo "============================================"
# Funktion: Prüft ob ein Verzeichnis read-only ist
check_readonly() {
local dir="$1"
local test_file="$dir/.write_test_$$"
# Versuche eine Test-Datei zu erstellen
if touch "$test_file" 2>/dev/null; then
rm -f "$test_file" 2>/dev/null
return 0 # Schreibbar
else
return 1 # Read-only
fi
}
if [ -n "$FOUND_PATH" ]; then
# Prüfe Schreibrechte (inkl. read-only Volume Check)
if check_readonly "$FOUND_PATH"; then
ok "Schreibrechte auf $FOUND_PATH"
else
error "KEINE Schreibrechte auf $FOUND_PATH (Read-only Volume?)"
echo ""
info " PROBLEM: Das Verzeichnis ist möglicherweise als :ro gemountet."
info " LÖSUNG 1: Volume ohne :ro mounten:"
info " - ./custom-nodes:/home/node/.n8n/custom/n8n-nodes-librebooking"
info " LÖSUNG 2: Auf dem Host bauen mit ./build-on-host.sh"
info " Siehe: TROUBLESHOOTING.md"
echo ""
fi
# Besitzer prüfen
OWNER=$(ls -ld "$FOUND_PATH" | awk '{print $3}')
GROUP=$(ls -ld "$FOUND_PATH" | awk '{print $4}')
info "Besitzer: $OWNER:$GROUP"
# n8n läuft als node (UID 1000)
if [ "$(id -u)" = "1000" ]; then
ok "Läuft als UID 1000 (Standard für n8n)"
else
warn "Läuft nicht als UID 1000 (aktuell: $(id -u))"
fi
fi
echo ""
echo "============================================"
echo " ZUSAMMENFASSUNG"
echo "============================================"
echo ""
echo "Ergebnisse:"
echo " ✓ OK: $OK_COUNT"
echo " ! Warnung: $WARN_COUNT"
echo " ✗ Fehler: $ERROR_COUNT"
echo ""
if [ "$ERROR_COUNT" -gt 0 ]; then
echo "============================================"
echo " EMPFOHLENE AKTIONEN"
echo "============================================"
echo ""
if [ ! -d "node_modules" ] 2>/dev/null; then
echo "1. Dependencies installieren:"
echo " cd $FOUND_PATH && npm install"
echo ""
fi
if [ ! -d "dist" ] 2>/dev/null; then
echo "2. Node bauen:"
echo " cd $FOUND_PATH && npm run build"
echo ""
fi
echo "3. Container neustarten:"
echo " docker restart n8n"
echo ""
exit 1
elif [ "$WARN_COUNT" -gt 0 ]; then
echo "Status: TEILWEISE OK (Warnungen beachten)"
exit 0
else
echo "Status: ALLES OK ✓"
echo ""
echo "Falls der Node trotzdem nicht erscheint:"
echo " 1. Starten Sie n8n neu: docker restart n8n"
echo " 2. Prüfen Sie die Logs: docker logs n8n | grep -i libre"
exit 0
fi

89
create-release.sh Executable file
View File

@ -0,0 +1,89 @@
#!/bin/bash
# ============================================================================
# create-release.sh - Erstellt neue Archive und Git Tag
# ============================================================================
set -e
GREEN='\033[0;32m'
YELLOW='\033[1;33m'
RED='\033[0;31m'
NC='\033[0m'
SCRIPT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
PARENT_DIR="$(dirname "$SCRIPT_DIR")"
# Version aus package.json lesen
VERSION=$(grep '"version"' "$SCRIPT_DIR/package.json" | head -1 | sed 's/.*"version": "\([^"]*\)".*/\1/')
echo -e "${GREEN}=== Release erstellen v$VERSION ===${NC}\n"
cd "$SCRIPT_DIR"
# 1. Prüfe, ob alles committet ist
if [ -n "$(git status --porcelain)" ]; then
echo -e "${YELLOW}Warnung: Es gibt uncommittete Änderungen!${NC}"
git status --short
echo ""
read -p "Trotzdem fortfahren? (j/N) " -n 1 -r
echo
if [[ ! $REPLY =~ ^[Jj]$ ]]; then
exit 1
fi
fi
# 2. Alte Archive löschen
echo "[1/4] Lösche alte Archive..."
./git-cleanup.sh 2>/dev/null || true
# 3. Build prüfen
echo ""
echo "[2/4] Prüfe Build..."
if [ ! -d "dist" ] || [ -z "$(find dist -name '*.node.js' 2>/dev/null)" ]; then
echo "Baue Node..."
npm install --silent
npm run build --silent
fi
echo " ✓ Build OK"
# 4. Archive erstellen
echo ""
echo "[3/4] Erstelle Archive..."
TAR_FILE="$PARENT_DIR/n8n-nodes-librebooking-v${VERSION}.tar.gz"
ZIP_FILE="$PARENT_DIR/n8n-nodes-librebooking-v${VERSION}.zip"
git archive --format=tar.gz --prefix=n8n-nodes-librebooking/ --output="$TAR_FILE" HEAD
echo " ✓ $TAR_FILE"
git archive --format=zip --prefix=n8n-nodes-librebooking/ --output="$ZIP_FILE" HEAD
echo " ✓ $ZIP_FILE"
# 5. Git Tag (optional)
echo ""
echo "[4/4] Git Tag..."
if git tag | grep -q "v$VERSION"; then
echo -e " ${YELLOW}Tag v$VERSION existiert bereits${NC}"
else
read -p "Git Tag v$VERSION erstellen? (j/N) " -n 1 -r
echo
if [[ $REPLY =~ ^[Jj]$ ]]; then
git tag -a "v$VERSION" -m "Version $VERSION - Vereinfachte Installation"
echo " ✓ Tag v$VERSION erstellt"
fi
fi
echo ""
echo -e "${GREEN}============================================${NC}"
echo -e "${GREEN} Release v$VERSION erstellt!${NC}"
echo -e "${GREEN}============================================${NC}"
echo ""
echo "Archive:"
echo " $TAR_FILE"
echo " $ZIP_FILE"
echo ""
echo "Zum Pushen:"
echo " git push origin main"
echo " git push origin v$VERSION"
echo ""

28
docker-compose.override.yml
View File

@ -1,31 +1,21 @@
# Docker Compose Override für bestehende n8n Installationen
# Diese Datei erweitert eine bestehende docker-compose.yml um den LibreBooking Node
# Docker Compose Override für LibreBooking n8n Node
#
# Verwendung:
# 1. Diese Datei in das Verzeichnis mit der bestehenden docker-compose.yml kopieren
# 2. custom-nodes Verzeichnis in das gleiche Verzeichnis kopieren
# 3. docker-compose up -d ausführen
# WICHTIG: custom-nodes Volume NICHT als read-only (:ro) mounten!
# Der Node benötigt Schreibrechte für npm install/build.
#
# HINWEIS: Diese Datei wird automatisch mit der bestehenden docker-compose.yml zusammengeführt
# Für read-only Volumes siehe: docker-compose.readonly.yml
# und führen Sie vorher build-on-host.sh aus.
version: '3.8'
services:
n8n:
# Zusätzliche Volumes für Custom Nodes
volumes:
# LibreBooking Custom Node - Variante 1: Vorgebauter Node
- ./custom-nodes:/home/node/.n8n/custom/n8n-nodes-librebooking:ro
# LibreBooking Custom Node
# OHNE :ro - Der Node muss beim Start gebaut werden können!
- ./custom-nodes:/home/node/.n8n/custom/n8n-nodes-librebooking
# Alternative: Nur das dist-Verzeichnis (wenn bereits gebaut)
# - ./custom-nodes/dist:/home/node/.n8n/custom/n8n-nodes-librebooking/dist:ro
# - ./custom-nodes/package.json:/home/node/.n8n/custom/n8n-nodes-librebooking/package.json:ro
# Zusätzliche Umgebungsvariablen
environment:
# Pfad für Custom Nodes (normalerweise bereits gesetzt)
# Custom Nodes aktivieren
- N8N_CUSTOM_EXTENSIONS=/home/node/.n8n/custom
# Aktiviert erweiterte Node-Typen
- N8N_COMMUNITY_NODES_ENABLED=true
# Optional: Debug-Logging für Node-Entwicklung
# - N8N_LOG_LEVEL=debug

25
docker-compose.readonly.yml Normal file
View File

@ -0,0 +1,25 @@
# Docker Compose Override für READ-ONLY Volume Mount
#
# VORAUSSETZUNG: Node wurde auf dem Host gebaut!
# Führen Sie zuerst aus: ./build-on-host.sh
#
# Verwendung:
# docker compose -f docker-compose.yml -f docker-compose.readonly.yml up -d
#
# Oder setzen Sie in Ihrer Umgebung:
# export COMPOSE_FILE=docker-compose.yml:docker-compose.readonly.yml
version: '3.8'
services:
n8n:
volumes:
# LibreBooking Custom Node - READ-ONLY
# Das dist-for-docker Verzeichnis wurde mit build-on-host.sh erstellt
# und enthält bereits alle kompilierten Dateien.
- ./dist-for-docker:/home/node/.n8n/custom/n8n-nodes-librebooking:ro
environment:
# Custom Nodes aktivieren
- N8N_CUSTOM_EXTENSIONS=/home/node/.n8n/custom
- N8N_COMMUNITY_NODES_ENABLED=true

268
fix-node-installation.sh Executable file
View File

@ -0,0 +1,268 @@
#!/bin/bash
# ============================================================================
# fix-node-installation.sh - All-in-One Lösung für Node-Installation im Container
# Führt alle Schritte automatisch aus (auf dem HOST ausführen!)
# ============================================================================
set -e
# Farben
RED='\033[0;31m'
GREEN='\033[0;32m'
YELLOW='\033[1;33m'
BLUE='\033[0;34m'
NC='\033[0m'
# Standard-Werte
CONTAINER_NAME="n8n"
CONTAINER_PATH="/home/node/.n8n/custom/n8n-nodes-librebooking"
SKIP_RESTART=false
VERBOSE=false
echo -e "${BLUE}============================================${NC}"
echo -e "${BLUE} LibreBooking Node - Auto-Fix Installation${NC}"
echo -e "${BLUE}============================================${NC}"
echo ""
# Hilfe anzeigen
show_help() {
echo "Verwendung: $0 [OPTIONEN]"
echo ""
echo "Dieses Skript installiert den LibreBooking Node automatisch im Docker Container."
echo ""
echo "Optionen:"
echo " -c, --container NAME Container-Name (Standard: n8n)"
echo " -p, --path PATH Pfad im Container (Standard: /home/node/.n8n/custom/n8n-nodes-librebooking)"
echo " -n, --no-restart Container nicht neustarten"
echo " -v, --verbose Ausführliche Ausgabe"
echo " -h, --help Diese Hilfe anzeigen"
echo ""
echo "Beispiele:"
echo " $0 # Standard-Installation"
echo " $0 -c mein-n8n # Anderer Container-Name"
echo " $0 -p /opt/n8n/custom-nodes # Anderer Pfad"
echo " $0 -n # Ohne Neustart"
exit 0
}
# Parameter parsen
while [[ $# -gt 0 ]]; do
case $1 in
-c|--container)
CONTAINER_NAME="$2"
shift 2
;;
-p|--path)
CONTAINER_PATH="$2"
shift 2
;;
-n|--no-restart)
SKIP_RESTART=true
shift
;;
-v|--verbose)
VERBOSE=true
shift
;;
-h|--help)
show_help
;;
*)
echo -e "${RED}Unbekannte Option: $1${NC}"
show_help
;;
esac
done
log() {
echo -e "${GREEN}[INFO]${NC} $1"
}
warn() {
echo -e "${YELLOW}[WARN]${NC} $1"
}
error() {
echo -e "${RED}[ERROR]${NC} $1"
exit 1
}
# Funktion: Prüft ob ein Verzeichnis im Container read-only ist
check_readonly_container() {
local container="$1"
local dir="$2"
local test_file="$dir/.write_test_$$"
# Versuche eine Test-Datei im Container zu erstellen
if docker exec "$container" touch "$test_file" 2>/dev/null; then
docker exec "$container" rm -f "$test_file" 2>/dev/null
return 0 # Schreibbar
else
return 1 # Read-only
fi
}
print_readonly_solution() {
echo ""
echo -e "${RED}============================================${NC}"
echo -e "${RED} PROBLEM: Read-only Volume erkannt!${NC}"
echo -e "${RED}============================================${NC}"
echo ""
echo "Das custom-nodes Verzeichnis ist als read-only gemountet."
echo "npm install und npm run build benötigen Schreibrechte."
echo ""
echo "LÖSUNGEN:"
echo ""
echo "1. Volume OHNE :ro mounten (empfohlen):"
echo " In docker-compose.yml oder docker-compose.override.yml:"
echo ""
echo " volumes:"
echo " - ./custom-nodes:/home/node/.n8n/custom/n8n-nodes-librebooking"
echo " # ENTFERNEN: :ro am Ende!"
echo ""
echo "2. Auf dem Host bauen (für read-only Volumes):"
echo " ./build-on-host.sh"
echo " # Dann docker-compose.readonly.yml verwenden"
echo ""
echo "3. docker-compose.override.yml anpassen:"
echo " cp docker-compose.override.yml docker-compose.override.yml.bak"
echo " # Entfernen Sie ':ro' aus der Volume-Definition"
echo ""
echo "Siehe: TROUBLESHOOTING.md und DOCKER-INTEGRATION.md"
}
# Schritt 1: Docker prüfen
log "Prüfe Docker..."
if ! command -v docker &>/dev/null; then
error "Docker ist nicht installiert!"
fi
# Schritt 2: Container prüfen
log "Prüfe Container '$CONTAINER_NAME'..."
if ! docker ps --format '{{.Names}}' | grep -q "^${CONTAINER_NAME}$"; then
# Prüfe ob Container existiert aber nicht läuft
if docker ps -a --format '{{.Names}}' | grep -q "^${CONTAINER_NAME}$"; then
warn "Container '$CONTAINER_NAME' existiert aber läuft nicht."
log "Starte Container..."
docker start "$CONTAINER_NAME"
sleep 3
else
error "Container '$CONTAINER_NAME' nicht gefunden! Prüfen Sie den Namen mit: docker ps -a"
fi
fi
log "Container '$CONTAINER_NAME' läuft ✓"
# Schritt 3: Prüfe ob Pfad im Container existiert
log "Prüfe Pfad im Container: $CONTAINER_PATH"
if ! docker exec "$CONTAINER_NAME" test -d "$CONTAINER_PATH"; then
# Versuche alternative Pfade
ALTERNATIVE_PATHS=(
"/home/node/.n8n/custom/n8n-nodes-librebooking"
"/home/node/.n8n/custom"
"/opt/n8n/custom-nodes"
"/data/custom-nodes"
)
FOUND_PATH=""
for alt_path in "${ALTERNATIVE_PATHS[@]}"; do
if docker exec "$CONTAINER_NAME" test -f "$alt_path/package.json" 2>/dev/null; then
FOUND_PATH="$alt_path"
break
fi
done
if [ -n "$FOUND_PATH" ]; then
warn "Angegebener Pfad nicht gefunden, verwende: $FOUND_PATH"
CONTAINER_PATH="$FOUND_PATH"
else
error "Kein Custom-Node-Verzeichnis mit package.json gefunden!\n\n Bitte stellen Sie sicher, dass die Dateien korrekt kopiert wurden.\n Beispiel: docker cp custom-nodes/. $CONTAINER_NAME:/home/node/.n8n/custom/n8n-nodes-librebooking/"
fi
fi
log "Pfad gefunden: $CONTAINER_PATH ✓"
# Schritt 3.5: Prüfe ob Verzeichnis schreibbar ist (read-only Volume?)
log "Prüfe Schreibrechte im Container..."
if ! check_readonly_container "$CONTAINER_NAME" "$CONTAINER_PATH"; then
print_readonly_solution
exit 1
fi
log "Schreibrechte vorhanden ✓"
# Schritt 4: Skript in Container kopieren
SCRIPT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
if [ -f "$SCRIPT_DIR/install-in-container.sh" ]; then
log "Kopiere install-in-container.sh in Container..."
docker cp "$SCRIPT_DIR/install-in-container.sh" "$CONTAINER_NAME:/tmp/"
else
warn "install-in-container.sh nicht gefunden, erstelle inline..."
fi
# Schritt 5: npm install und build im Container
log "Führe npm install aus..."
if $VERBOSE; then
docker exec -w "$CONTAINER_PATH" "$CONTAINER_NAME" npm install
else
if ! docker exec -w "$CONTAINER_PATH" "$CONTAINER_NAME" npm install 2>&1 | tail -5; then
error "npm install fehlgeschlagen!"
fi
fi
log "Dependencies installiert ✓"
log "Führe npm run build aus..."
if $VERBOSE; then
docker exec -w "$CONTAINER_PATH" "$CONTAINER_NAME" npm run build
else
if ! docker exec -w "$CONTAINER_PATH" "$CONTAINER_NAME" npm run build 2>&1 | tail -10; then
error "npm run build fehlgeschlagen!"
fi
fi
log "Build erfolgreich ✓"
# Schritt 6: Prüfe Ergebnis
log "Prüfe Build-Ergebnis..."
NODE_COUNT=$(docker exec "$CONTAINER_NAME" find "$CONTAINER_PATH/dist" -name "*.node.js" 2>/dev/null | wc -l)
if [ "$NODE_COUNT" -gt 0 ]; then
log "$NODE_COUNT Node-Datei(en) gefunden ✓"
else
error "Keine Node-Dateien nach Build gefunden!"
fi
# Schritt 7: Container neustarten
if $SKIP_RESTART; then
warn "Container-Neustart übersprungen (-n Option)"
echo ""
echo -e "${YELLOW}Bitte starten Sie den Container manuell neu:${NC}"
echo " docker restart $CONTAINER_NAME"
else
log "Starte Container neu..."
docker restart "$CONTAINER_NAME"
log "Container neugestartet ✓"
# Warte kurz auf Start
sleep 5
fi
# Schritt 8: Abschluss-Check (optional)
echo ""
echo -e "${GREEN}============================================${NC}"
echo -e "${GREEN} Installation abgeschlossen!${NC}"
echo -e "${GREEN}============================================${NC}"
echo ""
log "Der LibreBooking Node sollte jetzt in n8n verfügbar sein."
echo ""
echo "Nächste Schritte:"
echo " 1. Öffnen Sie n8n im Browser"
echo " 2. Erstellen Sie einen neuen Workflow"
echo " 3. Suchen Sie nach 'LibreBooking'"
echo ""
echo "Falls der Node nicht erscheint:"
echo " - Prüfen Sie die Logs: docker logs $CONTAINER_NAME 2>&1 | grep -i libre"
echo " - Führen Sie das Check-Skript aus: docker exec $CONTAINER_NAME sh /tmp/check-installation.sh"
echo ""
# Optional: Check-Skript kopieren und ausführen
if [ -f "$SCRIPT_DIR/check-installation.sh" ]; then
docker cp "$SCRIPT_DIR/check-installation.sh" "$CONTAINER_NAME:/tmp/"
echo "Tipp: Führen Sie für einen detaillierten Status aus:"
echo " docker exec $CONTAINER_NAME sh /tmp/check-installation.sh"
fi

32
git-cleanup.sh Executable file
View File

@ -0,0 +1,32 @@
#!/bin/bash
# ============================================================================
# git-cleanup.sh - Löscht alte Archive und temporäre Dateien
# ============================================================================
set -e
GREEN='\033[0;32m'
YELLOW='\033[1;33m'
NC='\033[0m'
SCRIPT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
PARENT_DIR="$(dirname "$SCRIPT_DIR")"
echo -e "${GREEN}=== Git Cleanup ===${NC}\n"
# Alte Archive im übergeordneten Verzeichnis löschen
echo "Lösche alte Archive in $PARENT_DIR..."
find "$PARENT_DIR" -maxdepth 1 -name "n8n-nodes-librebooking*.tar.gz" -delete 2>/dev/null && echo " ✓ .tar.gz gelöscht" || echo " - Keine .tar.gz gefunden"
find "$PARENT_DIR" -maxdepth 1 -name "n8n-nodes-librebooking*.zip" -delete 2>/dev/null && echo " ✓ .zip gelöscht" || echo " - Keine .zip gefunden"
# Temporäre Dateien im Projekt löschen
echo ""
echo "Lösche temporäre Dateien..."
rm -rf "$SCRIPT_DIR/dist-for-docker" 2>/dev/null && echo " ✓ dist-for-docker/ gelöscht" || true
rm -rf "$SCRIPT_DIR/.tsbuildinfo" 2>/dev/null && echo " ✓ .tsbuildinfo gelöscht" || true
find "$SCRIPT_DIR" -name "*.log" -delete 2>/dev/null && echo " ✓ .log Dateien gelöscht" || true
find "$SCRIPT_DIR" -name ".DS_Store" -delete 2>/dev/null || true
echo ""
echo -e "${GREEN}✓ Cleanup abgeschlossen${NC}"
echo ""

36
git-commit.sh Executable file
View File

@ -0,0 +1,36 @@
#!/bin/bash
# ============================================================================
# git-commit.sh - Committet alle Änderungen
# ============================================================================
set -e
GREEN='\033[0;32m'
YELLOW='\033[1;33m'
NC='\033[0m'
SCRIPT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
cd "$SCRIPT_DIR"
MESSAGE="${1:-fix: Vereinfachte Installation - auf dem Host bauen}"
echo -e "${GREEN}=== Git Commit ===${NC}\n"
# Status anzeigen
echo "Geänderte Dateien:"
git status --short
echo ""
# Alles hinzufügen
git add .
# Commit
echo "Commit mit Nachricht: $MESSAGE"
git commit -m "$MESSAGE"
echo ""
echo -e "${GREEN}✓ Commit erfolgreich${NC}"
echo ""
echo "Zum Pushen:"
echo " git push origin main"
echo ""

238
install-docker-manual.sh Executable file
View File

@ -0,0 +1,238 @@
#!/bin/bash
# =============================================================================
# LibreBooking n8n Node - Manuelle Docker Installation (ohne docker-compose)
# =============================================================================
# Diese Alternative verwendet nur "docker" Befehle für maximale Kompatibilität.
# Nutzen Sie dieses Skript wenn docker-compose Probleme macht.
#
# Verwendung: ./install-docker-manual.sh [OPTIONS]
#
# Optionen:
# -p, --port PORT n8n Port (Standard: 5678)
# -n, --name NAME Container Name (Standard: n8n-librebooking)
# -f, --force Bestehenden Container ersetzen
# -h, --help Diese Hilfe anzeigen
#
# =============================================================================
set -e
# Farben für Ausgabe
RED='\033[0;31m'
GREEN='\033[0;32m'
YELLOW='\033[1;33m'
BLUE='\033[0;34m'
NC='\033[0m' # No Color
# Standardwerte
N8N_PORT=5678
CONTAINER_NAME="n8n-librebooking"
FORCE=false
SCRIPT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
# Hilfsfunktionen
print_info() {
echo -e "${BLUE}[INFO]${NC} $1"
}
print_success() {
echo -e "${GREEN}[✓]${NC} $1"
}
print_warning() {
echo -e "${YELLOW}[!]${NC} $1"
}
print_error() {
echo -e "${RED}[FEHLER]${NC} $1"
}
show_help() {
echo "LibreBooking n8n Node - Manuelle Docker Installation"
echo ""
echo "Verwendung: $0 [OPTIONS]"
echo ""
echo "Optionen:"
echo " -p, --port PORT n8n Port (Standard: 5678)"
echo " -n, --name NAME Container Name (Standard: n8n-librebooking)"
echo " -f, --force Bestehenden Container ersetzen"
echo " -h, --help Diese Hilfe anzeigen"
echo ""
echo "Beispiele:"
echo " $0 # Standard-Installation"
echo " $0 -p 8080 # Anderer Port"
echo " $0 -n mein-n8n -p 9000 # Eigener Name und Port"
exit 0
}
# Argumente parsen
while [[ $# -gt 0 ]]; do
case $1 in
-p|--port)
N8N_PORT="$2"
shift 2
;;
-n|--name)
CONTAINER_NAME="$2"
shift 2
;;
-f|--force)
FORCE=true
shift
;;
-h|--help)
show_help
;;
*)
print_error "Unbekannte Option: $1"
show_help
;;
esac
done
echo ""
echo "============================================="
echo " LibreBooking n8n Node - Manuelle Installation"
echo " (ohne docker-compose)"
echo "============================================="
echo ""
# =============================================================================
# Voraussetzungen prüfen
# =============================================================================
print_info "Prüfe Voraussetzungen..."
# Docker prüfen
if ! command -v docker &> /dev/null; then
print_error "Docker ist nicht installiert!"
echo " Bitte installieren Sie Docker: https://docs.docker.com/get-docker/"
exit 1
fi
print_success "Docker gefunden: $(docker --version)"
# Prüfen ob Container bereits existiert
if docker ps -a --format '{{.Names}}' | grep -q "^${CONTAINER_NAME}$"; then
if [ "$FORCE" = true ]; then
print_warning "Bestehender Container '$CONTAINER_NAME' wird entfernt..."
docker stop "$CONTAINER_NAME" 2>/dev/null || true
docker rm "$CONTAINER_NAME" 2>/dev/null || true
else
print_error "Container '$CONTAINER_NAME' existiert bereits!"
echo " Nutzen Sie -f um ihn zu ersetzen, oder -n für einen anderen Namen."
exit 1
fi
fi
# =============================================================================
# Volume und Verzeichnisse vorbereiten
# =============================================================================
print_info "Bereite Volumes vor..."
# Docker Volume für n8n Daten erstellen
VOLUME_NAME="${CONTAINER_NAME}_data"
if ! docker volume ls --format '{{.Name}}' | grep -q "^${VOLUME_NAME}$"; then
docker volume create "$VOLUME_NAME"
print_success "Volume '$VOLUME_NAME' erstellt"
else
print_info "Volume '$VOLUME_NAME' existiert bereits"
fi
# Custom Nodes Verzeichnis vorbereiten
CUSTOM_NODES_DIR="$SCRIPT_DIR/custom-nodes"
if [ ! -d "$CUSTOM_NODES_DIR" ]; then
print_error "custom-nodes Verzeichnis nicht gefunden: $CUSTOM_NODES_DIR"
exit 1
fi
# =============================================================================
# Node bauen (wenn nicht bereits gebaut)
# =============================================================================
if [ ! -d "$CUSTOM_NODES_DIR/dist" ]; then
print_info "Baue LibreBooking Node..."
if command -v npm &> /dev/null; then
cd "$CUSTOM_NODES_DIR"
npm install 2>/dev/null || print_warning "npm install hatte Warnungen"
npm run build 2>/dev/null || {
print_warning "Build fehlgeschlagen, versuche alternativen Ansatz..."
npx tsc 2>/dev/null || true
mkdir -p dist/nodes/LibreBooking dist/nodes/LibreBookingTrigger
cp nodes/LibreBooking/*.svg dist/nodes/LibreBooking/ 2>/dev/null || true
cp nodes/LibreBookingTrigger/*.svg dist/nodes/LibreBookingTrigger/ 2>/dev/null || true
}
cd "$SCRIPT_DIR"
print_success "Node erfolgreich gebaut"
else
print_warning "npm nicht gefunden - Node wird im Container gebaut"
fi
fi
# =============================================================================
# n8n Container starten
# =============================================================================
print_info "Starte n8n Container..."
# Berechtigungen setzen
if [ "$(id -u)" = "0" ]; then
chown -R 1000:1000 "$CUSTOM_NODES_DIR" 2>/dev/null || true
else
sudo chown -R 1000:1000 "$CUSTOM_NODES_DIR" 2>/dev/null || print_warning "Konnte Berechtigungen nicht setzen"
fi
# Container starten
docker run -d \
--name "$CONTAINER_NAME" \
--restart unless-stopped \
-p "${N8N_PORT}:5678" \
-v "${VOLUME_NAME}:/home/node/.n8n" \
-v "${CUSTOM_NODES_DIR}:/home/node/.n8n/custom/n8n-nodes-librebooking:ro" \
-e N8N_CUSTOM_EXTENSIONS=/home/node/.n8n/custom \
-e N8N_COMMUNITY_NODES_ENABLED=true \
-e TZ=Europe/Berlin \
-e GENERIC_TIMEZONE=Europe/Berlin \
n8nio/n8n:latest
if [ $? -eq 0 ]; then
print_success "Container gestartet!"
else
print_error "Container konnte nicht gestartet werden!"
exit 1
fi
# Warten auf Start
print_info "Warte auf n8n Start..."
sleep 5
# Status prüfen
if docker ps --format '{{.Names}}' | grep -q "^${CONTAINER_NAME}$"; then
print_success "n8n Container läuft!"
else
print_error "Container läuft nicht - prüfen Sie: docker logs $CONTAINER_NAME"
exit 1
fi
# =============================================================================
# Abschluss
# =============================================================================
echo ""
echo "============================================="
print_success "Installation abgeschlossen!"
echo "============================================="
echo ""
echo "n8n ist erreichbar unter: http://localhost:${N8N_PORT}"
echo ""
echo "Nützliche Befehle:"
echo " docker logs $CONTAINER_NAME # Logs anzeigen"
echo " docker stop $CONTAINER_NAME # Container stoppen"
echo " docker start $CONTAINER_NAME # Container starten"
echo " docker restart $CONTAINER_NAME # Container neustarten"
echo " docker rm -f $CONTAINER_NAME # Container löschen"
echo ""
echo "Bei Problemen siehe: TROUBLESHOOTING.md"
echo ""

123
install-docker.sh
View File

@ -110,19 +110,112 @@ if ! command -v docker &> /dev/null; then
fi
print_success "Docker gefunden: $(docker --version)"
# Docker Compose prüfen
if command -v docker-compose &> /dev/null; then
COMPOSE_CMD="docker-compose"
print_success "docker-compose gefunden: $(docker-compose --version)"
elif docker compose version &> /dev/null; then
COMPOSE_CMD="docker compose"
print_success "docker compose gefunden: $(docker compose version)"
# Docker Compose prüfen - v2 bevorzugen
detect_compose_command() {
# Zuerst docker compose (v2/Plugin) prüfen - bevorzugt
if docker compose version &> /dev/null 2>&1; then
COMPOSE_CMD="docker compose"
COMPOSE_VERSION="v2"
return 0
fi
# Dann docker-compose (v1) prüfen
if command -v docker-compose &> /dev/null; then
# Prüfen ob es tatsächlich funktioniert (distutils Problem bei Python 3.12)
if docker-compose --version &> /dev/null 2>&1; then
COMPOSE_CMD="docker-compose"
COMPOSE_VERSION="v1"
return 0
else
# docker-compose existiert aber funktioniert nicht
print_warning "docker-compose (v1) ist installiert, funktioniert aber nicht!"
print_warning "Dies liegt wahrscheinlich am fehlenden 'distutils' Modul (Python 3.12+)"
echo ""
echo " Mögliche Lösungen:"
echo " 1. Docker Compose v2 installieren (empfohlen):"
echo " sudo apt-get update && sudo apt-get install docker-compose-plugin"
echo ""
echo " 2. distutils für Python installieren (Workaround):"
echo " sudo apt-get install python3-distutils"
echo " # Oder für neuere Systeme:"
echo " pip3 install setuptools"
echo ""
echo " Siehe TROUBLESHOOTING.md für weitere Details."
echo ""
return 1
fi
fi
return 1
}
# Compose Command ermitteln
if detect_compose_command; then
if [ "$COMPOSE_VERSION" = "v2" ]; then
print_success "Docker Compose v2 (Plugin) gefunden: $(docker compose version --short 2>/dev/null || docker compose version)"
else
print_success "docker-compose v1 gefunden: $(docker-compose --version)"
print_warning "Empfehlung: Upgrade zu Docker Compose v2 für bessere Kompatibilität"
fi
else
print_error "Docker Compose ist nicht installiert!"
echo " Bitte installieren Sie Docker Compose"
print_error "Docker Compose ist nicht installiert oder funktioniert nicht!"
echo ""
echo " Installation von Docker Compose v2 (empfohlen):"
echo " sudo apt-get update && sudo apt-get install docker-compose-plugin"
echo ""
echo " Oder siehe: https://docs.docker.com/compose/install/"
echo ""
echo " Alternativ: Verwenden Sie install-docker-manual.sh für Installation ohne docker-compose"
exit 1
fi
# Hilfsfunktion für Compose-Befehle
run_compose() {
$COMPOSE_CMD "$@"
}
# =============================================================================
# Funktion: Prüft ob ein Verzeichnis read-only ist
# =============================================================================
check_readonly() {
local dir="$1"
local test_file="$dir/.write_test_$$"
# Versuche eine Test-Datei zu erstellen
if touch "$test_file" 2>/dev/null; then
rm -f "$test_file" 2>/dev/null
return 0 # Schreibbar
else
return 1 # Read-only
fi
}
print_readonly_warning() {
local dir="$1"
print_error "Das Verzeichnis '$dir' ist read-only!"
echo ""
echo " Das custom-nodes Verzeichnis benötigt Schreibrechte für:"
echo " - npm install (Dependencies)"
echo " - npm run build (Kompilierung)"
echo ""
echo " LÖSUNGEN:"
echo ""
echo " 1. Volume OHNE :ro mounten (empfohlen):"
echo " volumes:"
echo " - ./custom-nodes:/home/node/.n8n/custom/n8n-nodes-librebooking"
echo " # NICHT: - ./custom-nodes:/...:ro"
echo ""
echo " 2. Auf dem Host bauen (für read-only Volumes):"
echo " ./build-on-host.sh"
echo " # Dann docker-compose.readonly.yml verwenden"
echo ""
echo " 3. Berechtigungen prüfen:"
echo " ls -la $dir"
echo " sudo chown -R 1000:1000 $dir"
echo ""
echo " Siehe: TROUBLESHOOTING.md und SECURITY.md"
}
# Zielpfad prüfen
if [ ! -d "$N8N_PATH" ]; then
print_error "Verzeichnis existiert nicht: $N8N_PATH"
@ -195,6 +288,18 @@ if [ ! -d "$CUSTOM_NODES_DIR" ]; then
print_success "Custom Nodes kopiert nach: $CUSTOM_NODES_DIR"
fi
# Prüfe ob Verzeichnis schreibbar ist
if ! check_readonly "$CUSTOM_NODES_DIR"; then
print_readonly_warning "$CUSTOM_NODES_DIR"
echo ""
read -p "Trotzdem fortfahren? (j/n): " CONTINUE_RO
if [[ ! "$CONTINUE_RO" =~ ^[jJyY]$ ]]; then
print_error "Abbruch wegen read-only Verzeichnis"
exit 1
fi
print_warning "Fortsetzen trotz read-only - npm install wird fehlschlagen!"
fi
# =============================================================================
# Node bauen (wenn nicht bereits gebaut)
# =============================================================================

191
install-in-container.sh Executable file
View File

@ -0,0 +1,191 @@
#!/bin/sh
# ============================================================================
# install-in-container.sh - Installiert den LibreBooking Node IM Docker Container
# Dieses Skript wird INNERHALB des Containers ausgeführt!
# ============================================================================
set -e
echo "============================================"
echo " LibreBooking Node - Container Installation"
echo "============================================"
echo ""
# Funktion: Prüft ob ein Verzeichnis read-only ist
check_readonly() {
local dir="$1"
local test_file="$dir/.write_test_$$"
# Versuche eine Test-Datei zu erstellen
if touch "$test_file" 2>/dev/null; then
rm -f "$test_file" 2>/dev/null
return 0 # Schreibbar (exit code 0 = true)
else
return 1 # Read-only (exit code 1 = false)
fi
}
print_readonly_error() {
local dir="$1"
echo ""
echo "============================================"
echo " FEHLER: Read-only Volume!"
echo "============================================"
echo ""
echo "Das Verzeichnis '$dir' ist read-only gemountet."
echo "npm install und npm run build benötigen Schreibrechte."
echo ""
echo "LÖSUNGEN:"
echo ""
echo "1. Volume OHNE :ro mounten:"
echo " In docker-compose.yml oder docker-compose.override.yml:"
echo ""
echo " volumes:"
echo " - ./custom-nodes:/home/node/.n8n/custom/n8n-nodes-librebooking"
echo " # NICHT:"
echo " - ./custom-nodes:/home/node/.n8n/custom/n8n-nodes-librebooking:ro"
echo ""
echo "2. Auf dem Host bauen:"
echo " Führen Sie auf dem HOST aus: ./build-on-host.sh"
echo " Dann verwenden Sie: docker-compose.readonly.yml"
echo ""
echo "Siehe: TROUBLESHOOTING.md"
exit 1
}
# Mögliche Pfade für custom-nodes
POSSIBLE_PATHS="
/home/node/.n8n/custom/n8n-nodes-librebooking
/home/node/.n8n/custom
/opt/n8n/custom-nodes
/data/custom-nodes
"
CUSTOM_NODE_PATH=""
# Finde den custom-nodes Pfad
echo "[1/5] Suche custom-nodes Verzeichnis..."
for path in $POSSIBLE_PATHS; do
if [ -d "$path" ]; then
# Prüfe ob package.json vorhanden ist
if [ -f "$path/package.json" ]; then
CUSTOM_NODE_PATH="$path"
echo " ✓ Gefunden: $path"
break
elif [ -f "$path/n8n-nodes-librebooking/package.json" ]; then
CUSTOM_NODE_PATH="$path/n8n-nodes-librebooking"
echo " ✓ Gefunden: $CUSTOM_NODE_PATH"
break
fi
fi
done
if [ -z "$CUSTOM_NODE_PATH" ]; then
echo " ✗ Kein custom-nodes Verzeichnis mit package.json gefunden!"
echo ""
echo " Geprüfte Pfade:"
for path in $POSSIBLE_PATHS; do
if [ -d "$path" ]; then
echo " - $path (existiert, aber keine package.json)"
else
echo " - $path (existiert nicht)"
fi
done
echo ""
echo " Bitte stellen Sie sicher, dass die Dateien korrekt kopiert wurden."
exit 1
fi
# Wechsle ins Verzeichnis
echo "[2/5] Wechsle ins Verzeichnis: $CUSTOM_NODE_PATH"
cd "$CUSTOM_NODE_PATH"
echo " ✓ Aktuelles Verzeichnis: $(pwd)"
# Prüfe ob npm verfügbar ist
echo "[3/5] Prüfe npm..."
if ! command -v npm >/dev/null 2>&1; then
echo " ✗ npm ist nicht installiert!"
echo ""
echo " Im n8n Docker-Image sollte npm vorhanden sein."
echo " Falls nicht, verwenden Sie ein Image mit Node.js."
exit 1
fi
echo " ✓ npm Version: $(npm --version)"
echo " ✓ node Version: $(node --version)"
# Prüfe Schreibrechte (read-only Volume?)
echo "[3.5/5] Prüfe Schreibrechte..."
if ! check_readonly "$CUSTOM_NODE_PATH"; then
print_readonly_error "$CUSTOM_NODE_PATH"
fi
echo " ✓ Schreibrechte vorhanden"
# Dependencies installieren
echo "[4/5] Installiere Dependencies..."
echo " Führe 'npm install' aus..."
if npm install 2>&1; then
echo " ✓ Dependencies installiert"
else
echo " ✗ npm install fehlgeschlagen!"
echo ""
echo " Mögliche Lösungen:"
echo " - Prüfen Sie die Berechtigungen"
echo " - Prüfen Sie die Internetverbindung"
echo " - Führen Sie 'npm cache clean --force' aus"
exit 1
fi
# Build ausführen
echo "[5/5] Baue den Node..."
echo " Führe 'npm run build' aus..."
if npm run build 2>&1; then
echo " ✓ Build erfolgreich"
else
echo " ✗ Build fehlgeschlagen!"
echo ""
echo " Prüfen Sie die TypeScript-Fehler in der Ausgabe oben."
exit 1
fi
# Prüfe Ergebnis
echo ""
echo "============================================"
echo " Prüfe Installation..."
echo "============================================"
if [ -d "$CUSTOM_NODE_PATH/dist" ]; then
echo "✓ dist/ Verzeichnis existiert"
# Prüfe auf .node.js Dateien
NODE_FILES=$(find "$CUSTOM_NODE_PATH/dist" -name "*.node.js" 2>/dev/null | wc -l)
if [ "$NODE_FILES" -gt 0 ]; then
echo "✓ $NODE_FILES Node-Datei(en) gefunden:"
find "$CUSTOM_NODE_PATH/dist" -name "*.node.js" -exec echo " - {}" \;
else
echo "✗ Keine .node.js Dateien im dist/ Verzeichnis gefunden!"
fi
# Prüfe credentials
CRED_FILES=$(find "$CUSTOM_NODE_PATH/dist" -name "*.credentials.js" 2>/dev/null | wc -l)
if [ "$CRED_FILES" -gt 0 ]; then
echo "✓ $CRED_FILES Credential-Datei(en) gefunden"
fi
else
echo "✗ dist/ Verzeichnis wurde nicht erstellt!"
exit 1
fi
echo ""
echo "============================================"
echo " Installation abgeschlossen!"
echo "============================================"
echo ""
echo "Nächste Schritte:"
echo " 1. Verlassen Sie den Container: exit"
echo " 2. Starten Sie n8n neu: docker restart n8n"
echo " 3. Öffnen Sie n8n im Browser und suchen Sie nach 'LibreBooking'"
echo ""
echo "Falls der Node nicht erscheint:"
echo " - Prüfen Sie die Umgebungsvariable N8N_CUSTOM_EXTENSIONS"
echo " - Führen Sie ./check-installation.sh aus"
echo ""

BIN
n8n-nodes-librebooking-v1.0.0.tar.gz Normal file
View File

Binary file not shown.

BIN
n8n-nodes-librebooking-v1.0.0.zip Normal file
View File

Binary file not shown.

12
package.json
View File

@ -1,6 +1,6 @@
{
"name": "n8n-nodes-librebooking",
"version": "1.0.0",
"version": "1.1.0",
"description": "n8n Node für LibreBooking - Ressourcen- und Reservierungsverwaltung",
"keywords": [
"n8n-community-node-package",
@ -46,7 +46,11 @@
"postinstall": "echo 'Installation abgeschlossen. Führe npm run build aus.'",
"test": "ts-node test/test-api.ts",
"link:n8n": "npm link && echo 'Node verlinkt. Starte n8n neu mit: n8n start'",
"unlink": "npm unlink -g n8n-nodes-librebooking"
"unlink": "npm unlink -g n8n-nodes-librebooking",
"install-in-docker": "npm install && npm run build && echo '\\n✓ Installation abgeschlossen. Bitte n8n Container neustarten: docker restart n8n'",
"docker:copy": "docker cp dist n8n:/home/node/.n8n/custom/n8n-nodes-librebooking/ && docker cp package.json n8n:/home/node/.n8n/custom/n8n-nodes-librebooking/ && docker cp node_modules n8n:/home/node/.n8n/custom/n8n-nodes-librebooking/",
"docker:restart": "docker restart n8n",
"docker:deploy": "npm run build && npm run docker:copy && npm run docker:restart"
},
"files": [
"dist",
@ -78,5 +82,9 @@
},
"engines": {
"node": ">=18.17.0"
},
"overrides": {
"form-data": "^4.0.1",
"lodash": "^4.17.21"
}
}

71
quick-install.sh Executable file
View File

@ -0,0 +1,71 @@
#!/bin/bash
# ============================================================================
# quick-install.sh - Schnellste Installation des LibreBooking n8n Nodes
#
# EMPFOHLENE METHODE: Auf dem Host bauen, in Container kopieren
# ============================================================================
set -e
RED='\033[0;31m'
GREEN='\033[0;32m'
YELLOW='\033[1;33m'
NC='\033[0m'
CONTAINER_NAME="${1:-n8n}"
SCRIPT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
echo -e "${GREEN}=== LibreBooking Quick Install ===${NC}\n"
# Prüfe Voraussetzungen
if ! command -v node &>/dev/null; then
echo -e "${RED}Fehler: Node.js nicht installiert!${NC}"
echo "Installieren: https://nodejs.org/ (v18+)"
exit 1
fi
if ! command -v docker &>/dev/null; then
echo -e "${RED}Fehler: Docker nicht installiert!${NC}"
exit 1
fi
if ! docker ps | grep -q "$CONTAINER_NAME"; then
echo -e "${YELLOW}Warnung: Container '$CONTAINER_NAME' nicht gefunden oder läuft nicht.${NC}"
echo "Verfügbare Container:"
docker ps --format " {{.Names}}"
exit 1
fi
cd "$SCRIPT_DIR"
# 1. Dependencies installieren
echo "[1/4] Installiere Dependencies..."
npm install --silent
# 2. Bauen
echo "[2/4] Baue Node..."
npm run build --silent
# 3. In Container kopieren
echo "[3/4] Kopiere in Container '$CONTAINER_NAME'..."
# Erstelle Zielverzeichnis falls nötig
docker exec "$CONTAINER_NAME" mkdir -p /home/node/.n8n/custom/n8n-nodes-librebooking 2>/dev/null || true
# Kopiere Dateien
docker cp dist "$CONTAINER_NAME":/home/node/.n8n/custom/n8n-nodes-librebooking/
docker cp package.json "$CONTAINER_NAME":/home/node/.n8n/custom/n8n-nodes-librebooking/
docker cp node_modules "$CONTAINER_NAME":/home/node/.n8n/custom/n8n-nodes-librebooking/
# 4. Container neustarten
echo "[4/4] Starte Container neu..."
docker restart "$CONTAINER_NAME"
echo ""
echo -e "${GREEN}✓ Installation abgeschlossen!${NC}"
echo ""
echo "Nächste Schritte:"
echo " 1. Öffne n8n: http://localhost:5678"
echo " 2. Gehe zu: Einstellungen → Credentials → Add Credential"
echo " 3. Suche: 'LibreBooking API'"
echo ""

112
update-dependencies.sh Executable file
View File

@ -0,0 +1,112 @@
#!/bin/bash
# ============================================================================
# update-dependencies.sh - Aktualisiert Dependencies und behebt Vulnerabilities
# ============================================================================
set -e
# Farben
RED='\033[0;31m'
GREEN='\033[0;32m'
YELLOW='\033[1;33m'
BLUE='\033[0;34m'
NC='\033[0m'
SCRIPT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
echo -e "${BLUE}============================================${NC}"
echo -e "${BLUE} LibreBooking Node - Dependency Update${NC}"
echo -e "${BLUE}============================================${NC}"
echo ""
log() {
echo -e "${GREEN}[INFO]${NC} $1"
}
warn() {
echo -e "${YELLOW}[WARN]${NC} $1"
}
error() {
echo -e "${RED}[ERROR]${NC} $1"
}
cd "$SCRIPT_DIR"
# Schritt 1: Aktuelle Vulnerabilities anzeigen
log "Prüfe aktuelle Vulnerabilities..."
echo ""
echo "=== VOR dem Update ==="
npm audit 2>/dev/null || true
echo ""
# Schritt 2: npm audit fix
log "Führe npm audit fix aus..."
if npm audit fix 2>&1; then
log "npm audit fix erfolgreich ✓"
else
warn "npm audit fix hatte Probleme (evtl. normale Warnungen)"
fi
# Schritt 3: npm update
log "Führe npm update aus..."
if npm update 2>&1; then
log "npm update erfolgreich ✓"
else
warn "npm update hatte Probleme"
fi
# Schritt 4: Outdated Packages prüfen
log "Prüfe veraltete Packages..."
echo ""
npm outdated 2>/dev/null || log "Alle Packages sind aktuell ✓"
echo ""
# Schritt 5: Build testen
log "Teste Build..."
if npm run build 2>&1 | tail -5; then
log "Build erfolgreich ✓"
else
error "Build fehlgeschlagen!"
echo ""
echo "Versuchen Sie:"
echo " 1. rm -rf node_modules package-lock.json"
echo " 2. npm install"
echo " 3. npm run build"
exit 1
fi
# Schritt 6: Finale Vulnerability-Prüfung
log "Finale Vulnerability-Prüfung..."
echo ""
echo "=== NACH dem Update ==="
npm audit 2>/dev/null || true
echo ""
# Schritt 7: Report
echo -e "${GREEN}============================================${NC}"
echo -e "${GREEN} Update abgeschlossen!${NC}"
echo -e "${GREEN}============================================${NC}"
echo ""
# Verbleibende Vulnerabilities zählen
AUDIT_OUTPUT=$(npm audit 2>/dev/null || true)
if echo "$AUDIT_OUTPUT" | grep -q "found 0 vulnerabilities"; then
log "Keine Vulnerabilities mehr! ✓"
else
VULN_COUNT=$(echo "$AUDIT_OUTPUT" | grep -oP '\d+ vulnerabilities' | head -1 || echo "Einige")
warn "Verbleibende Vulnerabilities: $VULN_COUNT"
echo ""
echo "Diese kommen wahrscheinlich von n8n-workflow Dependencies."
echo "Siehe SECURITY.md für weitere Informationen."
fi
echo ""
echo "Nächste Schritte:"
echo " 1. Testen Sie die Änderungen lokal"
echo " 2. Committen Sie die Änderungen:"
echo " git add package.json package-lock.json"
echo " git commit -m 'chore: update dependencies'"
echo " 3. Bauen Sie das Docker-Image neu:"
echo " docker compose build --no-cache"
echo ""

61
update-node.sh Executable file
View File

@ -0,0 +1,61 @@
#!/bin/bash
# ============================================================================
# update-node.sh - Aktualisiert den LibreBooking n8n Node
#
# Verwendung nach git pull oder Änderungen am Code
# ============================================================================
set -e
RED='\033[0;31m'
GREEN='\033[0;32m'
YELLOW='\033[1;33m'
NC='\033[0m'
CONTAINER_NAME="${1:-n8n}"
SCRIPT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
echo -e "${GREEN}=== LibreBooking Node Update ===${NC}\n"
cd "$SCRIPT_DIR"
# Git Pull (optional)
if [ -d ".git" ]; then
echo "[1/5] Hole neueste Änderungen..."
git pull 2>/dev/null || echo -e "${YELLOW}Git pull übersprungen${NC}"
else
echo "[1/5] Kein Git Repository - übersprungen"
fi
# Dependencies aktualisieren
echo "[2/5] Aktualisiere Dependencies..."
npm install --silent
# Bauen
echo "[3/5] Baue Node..."
npm run build --silent
# Prüfe Container
if ! docker ps | grep -q "$CONTAINER_NAME"; then
echo -e "${YELLOW}Container '$CONTAINER_NAME' nicht gefunden.${NC}"
echo "Verfügbare Container:"
docker ps --format " {{.Names}}"
echo ""
echo "Manuell kopieren:"
echo " docker cp dist <container>:/home/node/.n8n/custom/n8n-nodes-librebooking/"
exit 0
fi
# In Container kopieren
echo "[4/5] Kopiere in Container '$CONTAINER_NAME'..."
docker cp dist "$CONTAINER_NAME":/home/node/.n8n/custom/n8n-nodes-librebooking/
docker cp package.json "$CONTAINER_NAME":/home/node/.n8n/custom/n8n-nodes-librebooking/
docker cp node_modules "$CONTAINER_NAME":/home/node/.n8n/custom/n8n-nodes-librebooking/
# Container neustarten
echo "[5/5] Starte Container neu..."
docker restart "$CONTAINER_NAME"
echo ""
echo -e "${GREEN}✓ Update abgeschlossen!${NC}"
echo ""