feat: Trockenlauf als Standard-Aufruf, --execute/-e für echten Sync

Ohne Flags führt darktable_sync.sh jetzt einen Trockenlauf durch: - Banner mit Hinweis und Bestätigungsabfrage vor dem Start - rsync läuft mit --dry-run (keine Dateiänderungen) - Keine destruktiven Operationen: kein Backup, kein Token-Schreiben, kein sync_pending entfernen - Zusammenfassung nach Richtung (Upload/Download) und Aktion (neu/aktualisiert/gelöscht) aufgeschlüsselt - Optionale Detailansicht: Dateien gruppiert nach Typ (Foto, XMP, Datenbank, Video, Sonstiges) Mit --execute oder -e wird der echte Sync wie bisher ausgeführt. Desktop-Entry und Systemd-Service auf --execute aktualisiert. Co-Authored-By: Claude Sonnet 4.6 <noreply@anthropic.com>
install.sh: interaktive Abfragen bei Installation verbessert
2026-04-20 16:24:31 +02:00 · 2026-04-20 12:47:10 +02:00 · 2026-04-19 21:05:41 +02:00 · 2026-04-19 21:05:14 +02:00 · 2026-04-19 20:36:58 +02:00 · 2026-04-19 20:35:56 +02:00
23 changed files with 1335 additions and 208 deletions
@@ -1,13 +1,22 @@
-# Server Connection Settings
-SERVER_USER="your_nas_user"
+# Konfiguration fuer darktable-sync
+# Vorlage nach ~/.config/darktable-sync/.env kopieren:
+#   cp .env.example ~/.config/darktable-sync/.env
+#   chmod 600 ~/.config/darktable-sync/.env
+
+# Server-Verbindung
+SERVER_USER="your_server_user"
 SERVER_SSH_PORT=22
 SERVER_IP="192.168.1.100"

-# Server Paths
-SERVER_DB_DIR="/path/on/nas/darktable_db"
-SERVER_PHOTO_DIR="/path/on/nas/photo_library"
+# Pfade auf dem Server
+SERVER_DB_DIR="/path/on/server/darktable_db"
+SERVER_PHOTO_DIR="/path/on/server/photo_library"

-# Local Paths
+# Lokale Pfade
 LOCAL_PHOTO_DIR="$HOME/Pictures/raw"
 LOCAL_DARKTABLE_DB_DIR="$HOME/.config/darktable"
 BIN_DIR="$HOME/.local/bin"
+
+# Aufrufpfade (normalerweise nicht aendern)
+DARKTABLE_BIN="darktable"
+SYNC_BIN="$HOME/.local/bin/darktable_sync.sh"
@@ -1,7 +1,7 @@
 [Desktop Entry]
 Type=Application
-Name=Darktable sync only
-Comment=Run Darktable sync without starting Darktable
-Exec=/home/%u/.local/bin/darktable_sync.sh --with-notify-start-stop
+Name=Darktable Sync
+Comment=Nur Synchronisation ausfuehren ohne Darktable zu starten
+Exec=/home/%u/.local/bin/darktable_sync.sh --execute --with-notify-start-stop
 Terminal=false
 Categories=Graphics;Photography;
@@ -1,7 +1,7 @@
 [Desktop Entry]
 Type=Application
 Name=Darktable (with sync)
-Comment=Start Darktable and run sync in background
+Comment=Darktable mit Synchronisation starten (vor und nach dem Start)
 Exec=/home/%u/.local/bin/darktable_wrapper.sh
 Terminal=false
 Categories=Graphics;Photography;
@@ -2,127 +2,221 @@

 set -e

-### Default Configuration (can be overridden by .env file)
-
-SERVER_USER="${SERVER_USER:-$USER}"                # Default: current user
-SERVER_SSH_PORT="${SERVER_SSH_PORT:-22}"           # Default: standard SSH port
-SERVER_IP="${SERVER_IP:-192.168.1.100}"            # Default: common local network
+### Standardkonfiguration (kann durch .env ueberschrieben werden)

+SERVER_USER="${SERVER_USER:-$USER}"
+SERVER_SSH_PORT="${SERVER_SSH_PORT:-22}"
+SERVER_IP="${SERVER_IP:-192.168.1.100}"
 SERVER_DB_DIR="${SERVER_DB_DIR:-/volume1/Darktable/darktable_db}"
 SERVER_PHOTO_DIR="${SERVER_PHOTO_DIR:-/volume1/Darktable/photo_library}"
-
-LOCAL_PHOTO_DIR="${PHOTO_DIR:-$HOME/Pictures/raw}"
-LOCAL_DARKTABLE_DB_DIR="${DARKTABLE_DB_DIR:-$HOME/.config/darktable}"
-
+LOCAL_PHOTO_DIR="${LOCAL_PHOTO_DIR:-$HOME/Pictures/raw}"
+LOCAL_DARKTABLE_DB_DIR="${LOCAL_DARKTABLE_DB_DIR:-$HOME/.config/darktable}"
 BIN_DIR="${BIN_DIR:-$HOME/.local/bin}"
+DARKTABLE_BIN="${DARKTABLE_BIN:-darktable}"
+SYNC_BIN="${SYNC_BIN:-$HOME/.local/bin/darktable_sync.sh}"
+
 APPLICATIONS_DIR="$HOME/.local/share/applications"
+CONFIG_DIR="$HOME/.config/darktable-sync"

 SYNC_SCRIPT="$BIN_DIR/darktable_sync.sh"
 WRAPPER_SCRIPT="$BIN_DIR/darktable_wrapper.sh"
+COMMON_SCRIPT="$BIN_DIR/darktable_common.sh"
 DESKTOP_SHORTCUT="$APPLICATIONS_DIR/darktable-with-sync.desktop"
 SYNC_ONLY_SHORTCUT="$APPLICATIONS_DIR/darktable-sync-only.desktop"

-### Prepare folders
+### Verzeichnisse anlegen

 mkdir -p "$BIN_DIR"
-mkdir -p "$HOME/.config/systemd/user"
 mkdir -p "$APPLICATIONS_DIR"
+mkdir -p "$CONFIG_DIR"

-### Load .env if present (overrides defaults)
+### .env laden falls vorhanden

 ENV_FILE=".env"
+CONFIG_ENV="$CONFIG_DIR/.env"

 if [[ -f "$ENV_FILE" ]]; then
-  echo "Loading configuration from .env file..."
+    echo "Hinweis: .env im Projektverzeichnis gefunden."
+    read -r -p "  Jetzt nach $CONFIG_ENV verschieben? [J/n]: " MOVE_ENV
+    if [[ "${MOVE_ENV,,}" != "n" ]]; then
+        mkdir -p "$CONFIG_DIR"
+        cp "$ENV_FILE" "$CONFIG_ENV"
+        chmod 600 "$CONFIG_ENV"
+        rm "$ENV_FILE"
+        echo "  Erledigt: .env wurde verschoben."
+    else
+        echo "  Nicht verschoben. Bitte manuell ausfuehren:"
+        echo "  cp .env $CONFIG_ENV && chmod 600 $CONFIG_ENV"
+    fi
+fi
+
+if [[ -f "$CONFIG_ENV" ]]; then
+    echo "Konfiguration laden aus $CONFIG_ENV..."
    set -a
    # shellcheck source=/dev/null
-  . "$ENV_FILE"
+    . "$CONFIG_ENV"
    set +a
 fi

-### Show effective configuration
+### Lokales Foto-Verzeichnis interaktiv abfragen

-echo "Using configuration:"
-echo "SERVER_USER: $SERVER_USER"
-echo "SERVER_IP: $SERVER_IP"
-echo "SERVER_SSH_PORT: $SERVER_SSH_PORT"
-echo "SERVER_DB_DIR: $SERVER_DB_DIR"
-echo "SERVER_PHOTO_DIR: $SERVER_PHOTO_DIR"
-echo "PHOTO_DIR: $LOCAL_PHOTO_DIR"
-echo "DARKTABLE_DB_DIR: $LOCAL_DARKTABLE_DB_DIR"
-echo "BIN_DIR: $BIN_DIR"
+echo ""
+if [[ -d "$LOCAL_PHOTO_DIR" ]]; then
+    read -r -p "Lokales Foto-Verzeichnis [${LOCAL_PHOTO_DIR}] (Verzeichnis existiert bereits): " INPUT_PHOTO_DIR
+else
+    read -r -p "Lokales Foto-Verzeichnis [${LOCAL_PHOTO_DIR}]: " INPUT_PHOTO_DIR
+fi
+if [[ -n "$INPUT_PHOTO_DIR" ]]; then
+    LOCAL_PHOTO_DIR="$INPUT_PHOTO_DIR"
+fi

-### Check dependencies
+### Konfiguration anzeigen

-echo "Checking requirements..."
+echo ""
+echo "Aktive Konfiguration:"
+echo "  SERVER_USER:            $SERVER_USER"
+echo "  SERVER_IP:              $SERVER_IP"
+echo "  SERVER_SSH_PORT:        $SERVER_SSH_PORT"
+echo "  SERVER_DB_DIR:          $SERVER_DB_DIR"
+echo "  SERVER_PHOTO_DIR:       $SERVER_PHOTO_DIR"
+echo "  LOCAL_PHOTO_DIR:        $LOCAL_PHOTO_DIR"
+echo "  LOCAL_DARKTABLE_DB_DIR: $LOCAL_DARKTABLE_DB_DIR"
+echo "  BIN_DIR:                $BIN_DIR"
+echo ""

-REQUIRED_CMDS=("rsync" "notify-send" "ping" "darktable" "systemctl" "xdg-user-dir")
+### Abhaengigkeiten pruefen

+echo "Abhaengigkeiten pruefen..."
+
+REQUIRED_CMDS=("rsync" "notify-send" "darktable" "systemctl" "ssh")
 for cmd in "${REQUIRED_CMDS[@]}"; do
    if ! command -v "$cmd" >/dev/null 2>&1; then
-    echo "Error: '$cmd' is not installed."
-    echo "Install it with: sudo apt install $cmd"
+        echo "Fehler: '$cmd' ist nicht installiert."
+        echo "  Installieren mit: sudo apt install $cmd"
        exit 1
    fi
 done

-# Check folder presence
+if ! command -v zenity >/dev/null 2>&1 && ! command -v kdialog >/dev/null 2>&1; then
+    echo "Warnung: Weder 'zenity' noch 'kdialog' gefunden."
+    echo "  Mindestens eines installieren fuer GUI-Dialoge:"
+    echo "  sudo apt install zenity    # GNOME"
+    echo "  sudo apt install kdialog   # KDE"
+    echo "  (Ohne Dialog-Tool wird ein Text-Fallback verwendet)"
+fi
+
+### Verzeichnisse pruefen

 if [ ! -d "$LOCAL_PHOTO_DIR" ]; then
-  echo "Local photo folder does not exist: $LOCAL_PHOTO_DIR"
-  echo "Create it using: mkdir -p \"$LOCAL_PHOTO_DIR\""
+    echo "Fehler: Lokales Foto-Verzeichnis existiert nicht: $LOCAL_PHOTO_DIR"
+    echo "  Anlegen mit: mkdir -p \"$LOCAL_PHOTO_DIR\""
    exit 1
 fi

 if [ ! -d "$LOCAL_DARKTABLE_DB_DIR" ]; then
-  echo "Darktable database path does not exist: $LOCAL_DARKTABLE_DB_DIR"
-  echo "Start Darktable once or create the directory manually."
+    echo "Fehler: Darktable-Datenbank-Verzeichnis existiert nicht: $LOCAL_DARKTABLE_DB_DIR"
+    echo "  Darktable einmal starten oder manuell anlegen."
    exit 1
 fi

-# Check if server is reachable and remote dirs exist
+### Server-Erreichbarkeit pruefen

-if ping -c 1 "$SERVER_IP" &>/dev/null; then
-  echo "Server is reachable: $SERVER_IP"
+if ssh -o ConnectTimeout=5 -o BatchMode=yes \
+    -p "$SERVER_SSH_PORT" "$SERVER_USER@$SERVER_IP" true 2>/dev/null; then
+    echo "Server erreichbar: $SERVER_IP"

-  if ! ssh -p "$SERVER_SSH_PORT" "$SERVER_USER@$SERVER_IP" "[ -d '$SERVER_DB_DIR' ]"; then
-    echo "Remote directory missing on server: $SERVER_DB_DIR"
-    echo "Create it or adjust the path."
+    if ! ssh -o ConnectTimeout=5 -o BatchMode=yes \
+        -p "$SERVER_SSH_PORT" "$SERVER_USER@$SERVER_IP" \
+        "[ -d '$SERVER_DB_DIR' ]"; then
+        echo "Fehler: Server-Verzeichnis fehlt: $SERVER_DB_DIR"
        exit 1
    fi

-  if ! ssh -p "$SERVER_SSH_PORT" "$SERVER_USER@$SERVER_IP" "[ -d '$SERVER_PHOTO_DIR' ]"; then
-    echo "Remote directory missing on server: $SERVER_PHOTO_DIR"
-    echo "Create it or adjust the path."
+    if ! ssh -o ConnectTimeout=5 -o BatchMode=yes \
+        -p "$SERVER_SSH_PORT" "$SERVER_USER@$SERVER_IP" \
+        "[ -d '$SERVER_PHOTO_DIR' ]"; then
+        echo "Fehler: Server-Verzeichnis fehlt: $SERVER_PHOTO_DIR"
        exit 1
    fi
 else
-  echo "Server not reachable: $SERVER_IP"
-  echo "Sync will fail until server is online."
+    echo "Warnung: Server nicht erreichbar ($SERVER_IP)."
+    echo "  Sync wird fehlschlagen bis der Server online ist."
 fi

-### Install sync and wrapper scripts
+### Alte Systemd-Dateien entfernen (Unterstrich-Varianten)
+
+SYSTEMD_USER_DIR="$HOME/.config/systemd/user"
+OLD_SERVICE="$SYSTEMD_USER_DIR/darktable_sync.service"
+OLD_TIMER="$SYSTEMD_USER_DIR/darktable_sync.timer"
+
+if systemctl --user is-active darktable_sync.timer &>/dev/null; then
+    echo "Alten Timer deaktivieren..."
+    systemctl --user disable --now darktable_sync.timer || true
+fi
+
+for old_file in "$OLD_SERVICE" "$OLD_TIMER"; do
+    if [ -f "$old_file" ]; then
+        echo "Alte Datei entfernen: $old_file"
+        rm -f "$old_file"
+    fi
+done
+
+### Scripts installieren

 SCRIPT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"

+cp "$SCRIPT_DIR/scripts/darktable_common.sh" "$COMMON_SCRIPT"
 cp "$SCRIPT_DIR/scripts/darktable_sync.sh"   "$SYNC_SCRIPT"
 cp "$SCRIPT_DIR/scripts/darktable_wrapper.sh" "$WRAPPER_SCRIPT"
-chmod +x "$SYNC_SCRIPT" "$WRAPPER_SCRIPT"
+chmod +x "$COMMON_SCRIPT" "$SYNC_SCRIPT" "$WRAPPER_SCRIPT"

-### Install systemd user service and timer
-
-cp "$SCRIPT_DIR/systemd/darktable-sync.service" "$HOME/.config/systemd/user/darktable-sync.service"
-cp "$SCRIPT_DIR/systemd/darktable-sync.timer" "$HOME/.config/systemd/user/darktable-sync.timer"
+### Systemd Service installieren (kein Timer mehr)

+mkdir -p "$SYSTEMD_USER_DIR"
+cp "$SCRIPT_DIR/systemd/darktable-sync.service" "$SYSTEMD_USER_DIR/darktable-sync.service"
 systemctl --user daemon-reload
-systemctl --user enable darktable-sync.timer
-systemctl --user start darktable-sync.timer

-### Install desktop shortcuts
+### .env anlegen falls noch nicht vorhanden
+
+if [ ! -f "$CONFIG_ENV" ]; then
+    cp "$SCRIPT_DIR/.env.example" "$CONFIG_ENV"
+    chmod 600 "$CONFIG_ENV"
+    echo ""
+    echo "=========================================================="
+    echo "WICHTIG: Konfiguration anpassen, bevor du Darktable startest"
+    echo "=========================================================="
+    echo ""
+    echo "Eine Vorlage wurde angelegt:"
+    echo "  $CONFIG_ENV"
+    echo ""
+    echo "Mindestens diese Felder musst du eintragen:"
+    echo "  SERVER_USER      - dein SSH-Benutzer auf dem Server"
+    echo "  SERVER_IP        - IP-Adresse oder Hostname des Servers"
+    echo "  SERVER_DB_DIR    - Pfad zur Darktable-Datenbank auf dem Server"
+    echo "  SERVER_PHOTO_DIR - Pfad zum Fotoverzeichnis auf dem Server"
+    echo ""
+    echo "LOCAL_PHOTO_DIR ist bereits auf '${LOCAL_PHOTO_DIR}' gesetzt."
+    echo ""
+    echo "Jetzt bearbeiten:"
+    echo "  nano $CONFIG_ENV"
+    echo ""
+    echo "Danach install.sh erneut ausfuehren, damit die Verbindung"
+    echo "zum Server geprueft wird."
+    echo "=========================================================="
+fi
+
+### Desktop-Shortcuts installieren

 cp "$SCRIPT_DIR/desktop/darktable-with-sync.desktop" "$DESKTOP_SHORTCUT"
 cp "$SCRIPT_DIR/desktop/darktable-sync-only.desktop"  "$SYNC_ONLY_SHORTCUT"

 update-desktop-database "$APPLICATIONS_DIR" 2>/dev/null || true

-echo "Installation finished."
+echo ""
+echo "Installation abgeschlossen."
+echo "  Konfiguration:     $CONFIG_ENV"
+echo "  Sync-Script:       $SYNC_SCRIPT"
+echo "  Wrapper-Script:    $WRAPPER_SCRIPT"
+echo ""
+echo "Darktable ueber den Desktop-Shortcut 'Darktable (mit Sync)' starten"
+echo "oder direkt: $WRAPPER_SCRIPT"
@@ -0,0 +1,225 @@
+#!/usr/bin/env bash
+# Gemeinsame Hilfsfunktionen fuer darktable-sync Scripts.
+# Dieses Script wird per `source` eingebunden, nicht direkt ausgefuehrt.
+
+CONFIG_DIR="$HOME/.config/darktable-sync"
+
+load_config() {
+    local env_file="$CONFIG_DIR/.env"
+    if [ ! -f "$env_file" ]; then
+        echo "Fehler: Konfiguration nicht gefunden: $env_file" >&2
+        echo "Vorlage kopieren mit: cp .env.example $env_file" >&2
+        exit 1
+    fi
+
+    # Berechtigungen pruefen: .env darf nicht world-readable sein
+    local perms
+    perms=$(stat -c '%a' "$env_file" 2>/dev/null || stat -f '%A' "$env_file" 2>/dev/null)
+    if [[ "${perms: -1}" != "0" ]]; then
+        echo "Warnung: $env_file ist world-readable. Empfehlung: chmod 600 $env_file" >&2
+    fi
+
+    # Zeilen mit Shell-Operatoren abweisen (Kommentare und Leerzeilen ignorieren)
+    if grep -vE '^\s*#|^\s*$' "$env_file" | grep -qE '[;|&`]'; then
+        echo "Fehler: $env_file enthaelt unerlaubte Zeichen (; | & \`). Bitte pruefen." >&2
+        exit 1
+    fi
+
+    # shellcheck source=/dev/null
+    . "$env_file"
+}
+
+require_var() {
+    local var_name="$1"
+    if [ -z "${!var_name:-}" ]; then
+        echo "Fehler: Variable '$var_name' ist nicht gesetzt in $CONFIG_DIR/.env" >&2
+        exit 1
+    fi
+}
+
+validate_path() {
+    local var_name="$1" value="${!1:-}"
+    # Pfade duerfen keine Shell-Sonderzeichen oder Path-Traversal enthalten
+    if echo "$value" | grep -qE "['\";|&\`\$()\\\\]" || [[ "$value" == *".."* ]]; then
+        echo "Fehler: '$var_name' enthaelt unerlaubte Zeichen: $value" >&2
+        exit 1
+    fi
+}
+
+validate_config() {
+    require_var SERVER_IP
+    require_var SERVER_USER
+    require_var SERVER_SSH_PORT
+    require_var SERVER_DB_DIR
+    require_var SERVER_PHOTO_DIR
+    require_var LOCAL_DARKTABLE_DB_DIR
+    require_var LOCAL_PHOTO_DIR
+    require_var SYNC_BIN
+    require_var DARKTABLE_BIN
+
+    validate_path SERVER_DB_DIR
+    validate_path SERVER_PHOTO_DIR
+
+    # DARKTABLE_BIN: basename muss 'darktable' sein
+    if [[ "$(basename "$DARKTABLE_BIN")" != "darktable" ]]; then
+        echo "Fehler: DARKTABLE_BIN muss auf 'darktable' zeigen, nicht auf '$(basename "$DARKTABLE_BIN")'." >&2
+        exit 1
+    fi
+}
+
+check_dependency() {
+    local cmd="$1" pkg="${2:-$1}"
+    if ! command -v "$cmd" &>/dev/null; then
+        echo "Fehler: '$cmd' ist nicht installiert." >&2
+        echo "Installieren mit: sudo apt install $pkg" >&2
+        exit 1
+    fi
+}
+
+log() {
+    echo "$*"
+}
+
+log_step() {
+    echo "=== $* ==="
+}
+
+log_error() {
+    echo "FEHLER: $*" >&2
+}
+
+classify_filetype() {
+    local file="$1"
+    local ext="${file##*.}"; ext="${ext,,}"
+    case "$ext" in
+        jpg|jpeg|png|tif|tiff|dng|cr2|cr3|nef|arw|orf|rw2|raf|raw) echo "Foto" ;;
+        xmp)                                                           echo "XMP" ;;
+        db|bak)                                                        echo "Datenbank" ;;
+        mp4|mov|avi|mkv|mts|m2ts)                                      echo "Video" ;;
+        *)                                                             echo "Sonstiges" ;;
+    esac
+}
+
+format_rsync_details() {
+    local log_file="$1" direction_label="$2" direction="$3"
+    [ -f "$log_file" ] || return 0
+    local prefix; [ "$direction" = "up" ] && prefix=">f" || prefix="<f"
+
+    local label pattern files
+    while IFS=: read -r label pattern; do
+        files=$(grep -E "$pattern" "$log_file" 2>/dev/null \
+            | sed 's/^[^ ]*  *//' | sort) || true
+        [ -n "$files" ] || continue
+
+        local typ typed
+        for typ in Foto XMP Datenbank Video Sonstiges; do
+            typed=$(echo "$files" | while IFS= read -r f; do
+                [ "$(classify_filetype "$f")" = "$typ" ] && echo "  $f"
+            done)
+            [ -n "$typed" ] || continue
+            log_step "$direction_label – $typ ($label)"
+            echo "$typed"
+        done
+    done <<EOF
+neu:^${prefix}[+]{9}
+aktualisiert:^${prefix}[^+]
+gelöscht:^\*deleting
+EOF
+}
+
+confirm_dry_run() {
+    [ "${DRY_RUN_SKIP_CONFIRM:-0}" = "1" ] && return 0
+    ask_user "Darktable Sync – Trockenlauf" \
+        "Trockenlauf starten?\n\nEs werden keine Dateien verändert oder übertragen."
+}
+
+ssh_server() {
+    ssh -o ConnectTimeout=5 -o BatchMode=yes \
+        -p "$SERVER_SSH_PORT" "$SERVER_USER@$SERVER_IP" "$@"
+}
+
+# Liefert den Unix-Timestamp (mtime) von library.db auf dem Server, oder "0" wenn nicht vorhanden.
+server_db_mtime() {
+    ssh_server "stat -c '%Y' '$SERVER_DB_DIR/library.db' 2>/dev/null || echo 0"
+}
+
+save_sync_token() {
+    echo "$1" > "$CONFIG_DIR/sync_token"
+}
+
+read_sync_token() {
+    cat "$CONFIG_DIR/sync_token" 2>/dev/null || echo ""
+}
+
+server_reachable() {
+    ssh_server true 2>/dev/null
+}
+
+ask_user() {
+    local title="$1" text="$2" ans
+    if command -v zenity &>/dev/null; then
+        zenity --question --title="$title" --text="$text" 2>/dev/null
+        return $?
+    elif command -v kdialog &>/dev/null; then
+        kdialog --title "$title" --yesno "$text" 2>/dev/null
+        return $?
+    else
+        read -r -p "$text [j/N] " ans || true
+        [[ "$ans" =~ ^[jJyY] ]]
+        return $?
+    fi
+}
+
+# Fragt den User wie mit einem Sync-Token-Konflikt umgegangen werden soll.
+# Gibt "download", "upload" oder "abort" aus.
+ask_conflict_resolution() {
+    local TITLE="Darktable Sync – Konflikt"
+    local EXPLAIN="Ein anderer Rechner hat die Datenbank seit deinem letzten Sync verändert.\nDeine lokalen Änderungen wurden noch NICHT auf den Server übertragen.\n\nWas soll passieren?"
+
+    if command -v zenity &>/dev/null; then
+        local choice
+        choice=$(zenity --list \
+            --title="$TITLE" \
+            --text="$EXPLAIN" \
+            --radiolist \
+            --column="" --column="Aktion" --column="Beschreibung" \
+            TRUE  "Herunterladen"        "Server-Stand übernehmen (empfohlen)" \
+            FALSE "Hochladen erzwingen"  "Lokale Version auf Server schreiben – Server-Änderungen gehen verloren!" \
+            FALSE "Abbrechen"            "Nichts tun – Sync wird übersprungen" \
+            --width=520 --height=260 2>/dev/null) || true
+        case "$choice" in
+            "Hochladen erzwingen") echo "upload"   ;;
+            "Abbrechen")           echo "abort"    ;;
+            *)                     echo "download" ;;
+        esac
+
+    elif command -v kdialog &>/dev/null; then
+        local btn
+        btn=$(kdialog --title "$TITLE" \
+            --menu "$EXPLAIN" \
+            download "Herunterladen (empfohlen)" \
+            upload   "Hochladen erzwingen (Server-Änderungen gehen verloren!)" \
+            abort    "Abbrechen" 2>/dev/null) || true
+        case "$btn" in
+            upload|abort) echo "$btn" ;;
+            *)            echo "download" ;;
+        esac
+
+    else
+        echo ""
+        echo "=== $TITLE ==="
+        echo "Ein anderer Rechner hat die Datenbank seit deinem letzten Sync verändert."
+        echo "Deine lokalen Änderungen wurden noch NICHT auf den Server übertragen."
+        echo ""
+        echo "  1) Herunterladen (empfohlen) – Server-Stand übernehmen"
+        echo "  2) Hochladen erzwingen       – lokale Version gewinnt, Server-Änderungen gehen verloren"
+        echo "  3) Abbrechen"
+        local ans
+        read -r -p "Auswahl [1/2/3, Standard: 1]: " ans || true
+        case "$ans" in
+            2) echo "upload" ;;
+            3) echo "abort"  ;;
+            *) echo "download" ;;
+        esac
+    fi
+}
@@ -1,109 +1,311 @@
-#!/bin/bash
-set -e
+#!/usr/bin/env bash
+set -euo pipefail

-# Default-Konfiguration (per ENV überschreibbar)
-SERVER_USER="${SERVER_USER}"
-SERVER_SSH_PORT="${SERVER_SSH_PORT}"
-SERVER_IP="${SERVER_IP}"
-SERVER_DB_DIR="${SERVER_DB_DIR}"
-SERVER_PHOTO_DIR="${SERVER_PHOTO_DIR}"
-LOCAL_PHOTO_DIR="${PHOTO_DIR}"
-LOCAL_DARKTABLE_DB_DIR="${DARKTABLE_DB_DIR}"
+SCRIPT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
+# shellcheck source=darktable_common.sh
+source "$SCRIPT_DIR/darktable_common.sh"

-log() {
-    echo "[$(date '+%Y-%m-%d %H:%M:%S')] $*"
-}
+log_step "Darktable Sync gestartet (PID $$, Argumente: ${*:-keine})"
+
+check_dependency rsync
+check_dependency ssh openssh-client
+check_dependency notify-send libnotify-bin
+check_dependency darktable
+log "Alle Abhängigkeiten vorhanden."
+
+load_config
+validate_config
+log "Konfiguration geladen: Server=$SERVER_USER@$SERVER_IP:$SERVER_SSH_PORT"
+log "  DB lokal:    $LOCAL_DARKTABLE_DB_DIR"
+log "  DB Server:   $SERVER_DB_DIR"
+log "  Fotos lokal: $LOCAL_PHOTO_DIR"
+log "  Fotos Server:$SERVER_PHOTO_DIR"
+
+export DISPLAY="${DISPLAY:-:0}"
+
+DRY_RUN=true
+SHOW_NOTIFY_START_STOP=false
+for arg in "$@"; do
+    case "$arg" in
+        --execute|-e)             DRY_RUN=false ;;
+        --with-notify-start-stop) SHOW_NOTIFY_START_STOP=true ;;
+    esac
+done

 count_synced_files() {
-    local LOG="$1"
-    local DIRECTION="$2"
-    local COUNT=0
-
-    case "$DIRECTION" in
-        up)
-            COUNT=$(grep -E '^>f|cd' "$LOG" | wc -l)
-            ;;
-        down)
-            COUNT=$(grep -E '^<f|cd' "$LOG" | wc -l)
-            ;;
+    local log_file="$1" direction="$2" count=0
+    case "$direction" in
+        up)   count=$(grep -cE '^>f|^cd' "$log_file" 2>/dev/null) || count=0 ;;
+        down) count=$(grep -cE '^<f|^cd' "$log_file" 2>/dev/null) || count=0 ;;
    esac
-    echo "$COUNT"
+    echo "$count"
 }

-SCRIPT_NAME=$(basename "$0")
-LOCKFILE="/tmp/${SCRIPT_NAME}.lock"
+LOCKDIR="$CONFIG_DIR/sync.lock"
+LOCKPID="$LOCKDIR/pid"
+TMPFILES=()

-if [ -e "$LOCKFILE" ]; then
-    echo "Script is already running or delete $LOCKFILE"
+log "Lock anfordern: $LOCKDIR"
+if ! mkdir "$LOCKDIR" 2>/dev/null; then
+    EXISTING_PID=$(cat "$LOCKPID" 2>/dev/null || true)
+    if [ -n "$EXISTING_PID" ] && ! kill -0 "$EXISTING_PID" 2>/dev/null; then
+        log "Verwaisten Lock gefunden (PID $EXISTING_PID läuft nicht mehr) – wird entfernt."
+        rm -f "$LOCKPID"
+        rmdir "$LOCKDIR" 2>/dev/null || true
+        mkdir "$LOCKDIR"
+    else
+        log_error "Sync läuft bereits (PID ${EXISTING_PID:-unbekannt}). Lock: $LOCKDIR"
+        echo "  rmdir $LOCKDIR" >&2
+        exit 1
+    fi
+fi
+echo "$$" > "$LOCKPID"
+log "Lock erworben (PID $$)."
+trap 'rm -f "${TMPFILES[@]}" "$LOCKPID"; rmdir "$LOCKDIR" 2>/dev/null || true; log "Lock freigegeben."' EXIT
+
+if [ "$DRY_RUN" = true ]; then
+    log_step "TROCKENLAUF – keine Änderungen werden vorgenommen"
+    log "Dieser Aufruf zeigt nur, was synchronisiert werden würde."
+    log "Für echten Sync: $(basename "$0") --execute  oder  -e"
+    log ""
+    if ! confirm_dry_run; then
+        log "Trockenlauf abgebrochen."
+        exit 0
+    fi
+fi
+
+log "Prüfen ob Darktable läuft..."
+if pgrep -x darktable > /dev/null 2>&1; then
+    log "Darktable läuft (PID: $(pgrep -x darktable | tr '\n' ' ')) – Sync übersprungen."
+    notify-send "Darktable Sync – Abbruch" \
+        "Darktable ist gerade geöffnet. Sync erst nach dem Beenden möglich." \
+        -u normal -t 8000
+    exit 0
+fi
+log "Darktable läuft nicht – Sync kann fortfahren."
+
+if [ -f "$CONFIG_DIR/sync_pending" ]; then
+    log "Ausstehender Sync aus vorherigem Lauf wird jetzt nachgeholt."
+    notify-send "Darktable Sync" "Ausstehender Sync wird jetzt ausgeführt..." -t 3000
+fi
+
+log "Serververbindung prüfen ($SERVER_USER@$SERVER_IP Port $SERVER_SSH_PORT)..."
+if ! server_reachable; then
+    log "Server nicht erreichbar – Sync übersprungen, sync_pending gesetzt."
+    touch "$CONFIG_DIR/sync_pending"
+    exit 0
+fi
+log "Server erreichbar."
+
+if [ "$SHOW_NOTIFY_START_STOP" = true ]; then
+    notify-send "Darktable Sync" "Sync gestartet..." -t 3000
+fi
+
+log "Active-Marker auf Server prüfen..."
+ACTIVE=$(ssh_server "cat '$SERVER_DB_DIR/darktable.active' 2>/dev/null || true")
+if [ -n "$ACTIVE" ]; then
+    log "WARNUNG: Active-Marker vorhanden: $ACTIVE"
+    notify-send "Darktable Sync – Warnung" \
+        "Darktable läuft möglicherweise auf: $ACTIVE" -u normal -t 10000
+else
+    log "Kein Active-Marker – kein anderer Client aktiv."
+fi
+
+log "Darktable-Versionen prüfen..."
+SERVER_VERSION=$(ssh_server "cat '$SERVER_DB_DIR/darktable_version' 2>/dev/null || true")
+LOCAL_VERSION=$(darktable --version 2>&1 | head -1 || true)
+log "  Lokal:  ${LOCAL_VERSION:-unbekannt}"
+log "  Server: ${SERVER_VERSION:-noch nicht gespeichert}"
+
+if [ -n "$SERVER_VERSION" ]; then
+    LOCAL_MM=$(echo "$LOCAL_VERSION" | grep -oP '\d+\.\d+' | head -1 || true)
+    SERVER_MM=$(echo "$SERVER_VERSION" | grep -oP '\d+\.\d+' | head -1 || true)
+    if [ -n "$SERVER_MM" ] && [ "$LOCAL_MM" != "$SERVER_MM" ]; then
+        log_error "Versionskonflikt: lokal=$LOCAL_MM, server=$SERVER_MM"
+        log_error "Bitte beide Rechner auf gleichen Stand bringen."
+        notify-send "Darktable Sync – Versionskonflikt" \
+            "Lokal: $LOCAL_MM  Server: $SERVER_MM\nBitte angleichen!" \
+            -u critical
+        touch "$CONFIG_DIR/sync_pending"
+        exit 1
+    fi
+    log "Versionen übereinstimmend ($LOCAL_MM)."
+fi
+
+log "Sync-Token prüfen..."
+SAVED_TOKEN=$(read_sync_token)
+SERVER_TOKEN=$(server_db_mtime)
+log "  Gespeicherter Token: ${SAVED_TOKEN:-keiner (erster Sync)}"
+log "  Aktueller Server-Token: $SERVER_TOKEN"
+
+UPLOAD_ALLOWED=true
+if [ -n "$SAVED_TOKEN" ] && [ "$SAVED_TOKEN" != "$SERVER_TOKEN" ]; then
+    log "WARNUNG: Token-Konflikt (gespeichert=$SAVED_TOKEN, server=$SERVER_TOKEN) – Benutzer wird gefragt."
+    RESOLUTION=$(ask_conflict_resolution)
+    log "Benutzerentscheidung: $RESOLUTION"
+    case "$RESOLUTION" in
+        upload)
+            log "Upload erzwungen – lokale Version überschreibt Server."
+            ;;
+        abort)
+            log "Sync abgebrochen durch Benutzer."
+            exit 0
+            ;;
+        *)
+            log "Nur Download – Server-Stand wird übernommen."
+            UPLOAD_ALLOWED=false
+            ;;
+    esac
+else
+    log "Token stimmt überein – Upload erlaubt."
+fi
+
+if [ "$DRY_RUN" = false ]; then
+    log_step "Datenbank-Backup"
+    log "  $LOCAL_DARKTABLE_DB_DIR/library.db → library.db.bak"
+    cp "$LOCAL_DARKTABLE_DB_DIR/library.db" "$LOCAL_DARKTABLE_DB_DIR/library.db.bak"
+    log "  $LOCAL_DARKTABLE_DB_DIR/data.db    → data.db.bak"
+    cp "$LOCAL_DARKTABLE_DB_DIR/data.db"    "$LOCAL_DARKTABLE_DB_DIR/data.db.bak"
+    log "Backup abgeschlossen."
+fi
+
+SYNC_LOG=$(mktemp)
+TMPFILES+=("$SYNC_LOG")
+UPLOAD_LOG_DB=$(mktemp)
+TMPFILES+=("$UPLOAD_LOG_DB")
+UPLOAD_LOG_PHOTOS=$(mktemp)
+TMPFILES+=("$UPLOAD_LOG_PHOTOS")
+DOWNLOAD_LOG_DB=$(mktemp)
+TMPFILES+=("$DOWNLOAD_LOG_DB")
+DOWNLOAD_LOG_PHOTOS=$(mktemp)
+TMPFILES+=("$DOWNLOAD_LOG_PHOTOS")
+
+RSYNC_DRY_FLAG=()
+[ "$DRY_RUN" = true ] && RSYNC_DRY_FLAG=(--dry-run)
+[ "$DRY_RUN" = true ] && DRY_SUFFIX=" (Trockenlauf)" || DRY_SUFFIX=""
+
+SENT_DB=0
+SENT_PHOTOS=0
+
+if [ "$UPLOAD_ALLOWED" = true ]; then
+    log_step "Upload: Datenbank${DRY_SUFFIX}"
+    log "  Quelle: $LOCAL_DARKTABLE_DB_DIR/"
+    log "  Ziel:   $SERVER_USER@$SERVER_IP:$SERVER_DB_DIR/"
+    if ! rsync -uavh --itemize-changes \
+        "${RSYNC_DRY_FLAG[@]}" \
+        --exclude '*.lock' \
+        --exclude 'darktable_version' \
+        -e "ssh -p $SERVER_SSH_PORT" \
+        "$LOCAL_DARKTABLE_DB_DIR/" "$SERVER_USER@$SERVER_IP:$SERVER_DB_DIR/" \
+        2>&1 | tee -a "$SYNC_LOG" "$UPLOAD_LOG_DB"; then
+        log_error "Upload Datenbank fehlgeschlagen (Quelle: $LOCAL_DARKTABLE_DB_DIR)"
+        touch "$CONFIG_DIR/sync_pending"
+        exit 1
+    fi
+    SENT_DB=$(count_synced_files "$UPLOAD_LOG_DB" "up")
+    log "Datenbank-Upload abgeschlossen: $SENT_DB Datei(en) übertragen."
+
+    log_step "Upload: Fotos${DRY_SUFFIX}"
+    log "  Quelle: $LOCAL_PHOTO_DIR/"
+    log "  Ziel:   $SERVER_USER@$SERVER_IP:$SERVER_PHOTO_DIR/"
+    if ! rsync -uavh --itemize-changes \
+        "${RSYNC_DRY_FLAG[@]}" \
+        --exclude '*.lock' \
+        -e "ssh -p $SERVER_SSH_PORT" \
+        "$LOCAL_PHOTO_DIR/" "$SERVER_USER@$SERVER_IP:$SERVER_PHOTO_DIR/" \
+        2>&1 | tee -a "$SYNC_LOG" "$UPLOAD_LOG_PHOTOS"; then
+        log_error "Upload Fotos fehlgeschlagen (Quelle: $LOCAL_PHOTO_DIR)"
+        touch "$CONFIG_DIR/sync_pending"
+        exit 1
+    fi
+    SENT_PHOTOS=$(count_synced_files "$UPLOAD_LOG_PHOTOS" "up")
+    log "Foto-Upload abgeschlossen: $SENT_PHOTOS Datei(en) übertragen."
+else
+    log "Upload übersprungen (Token-Konflikt)."
+fi
+
+log_step "Download: Datenbank${DRY_SUFFIX}"
+log "  Quelle: $SERVER_USER@$SERVER_IP:$SERVER_DB_DIR/"
+log "  Ziel:   $LOCAL_DARKTABLE_DB_DIR/"
+if ! rsync -uavh --itemize-changes \
+    "${RSYNC_DRY_FLAG[@]}" \
+    --exclude '*.lock' \
+    -e "ssh -p $SERVER_SSH_PORT" \
+    "$SERVER_USER@$SERVER_IP:$SERVER_DB_DIR/" "$LOCAL_DARKTABLE_DB_DIR/" \
+    2>&1 | tee -a "$SYNC_LOG" "$DOWNLOAD_LOG_DB"; then
+    log_error "Download Datenbank fehlgeschlagen (Ziel: $LOCAL_DARKTABLE_DB_DIR)"
+    touch "$CONFIG_DIR/sync_pending"
    exit 1
 fi
+RECEIVED_DB=$(count_synced_files "$DOWNLOAD_LOG_DB" "down")
+log "Datenbank-Download abgeschlossen: $RECEIVED_DB Datei(en) empfangen."

-touch "$LOCKFILE"
-trap "rm -f '$LOCKFILE'" EXIT
+log_step "Download: Fotos${DRY_SUFFIX}"
+log "  Quelle: $SERVER_USER@$SERVER_IP:$SERVER_PHOTO_DIR/"
+log "  Ziel:   $LOCAL_PHOTO_DIR/"
+if ! rsync -uavh --itemize-changes \
+    "${RSYNC_DRY_FLAG[@]}" \
+    --exclude '*.lock' \
+    -e "ssh -p $SERVER_SSH_PORT" \
+    "$SERVER_USER@$SERVER_IP:$SERVER_PHOTO_DIR/" "$LOCAL_PHOTO_DIR/" \
+    2>&1 | tee -a "$SYNC_LOG" "$DOWNLOAD_LOG_PHOTOS"; then
+    log_error "Download Fotos fehlgeschlagen (Ziel: $LOCAL_PHOTO_DIR)"
+    touch "$CONFIG_DIR/sync_pending"
+    exit 1
+fi
+RECEIVED_PHOTOS=$(count_synced_files "$DOWNLOAD_LOG_PHOTOS" "down")
+log "Foto-Download abgeschlossen: $RECEIVED_PHOTOS Datei(en) empfangen."

-SHOW_NOTIFY_START_STOP=false
-if [[ "$1" == "--with-notify-start-stop" ]]; then
-    SHOW_NOTIFY_START_STOP=true
+if [ "$DRY_RUN" = false ]; then
+    NEW_TOKEN=$(server_db_mtime)
+    save_sync_token "$NEW_TOKEN"
+    log "Sync-Token gespeichert: $NEW_TOKEN"
+
+    log "Versionsdatei aktualisieren: $LOCAL_DARKTABLE_DB_DIR/darktable_version"
+    echo "$LOCAL_VERSION" > "$LOCAL_DARKTABLE_DB_DIR/darktable_version"
+
+    rm -f "$CONFIG_DIR/sync_pending"
+    log "sync_pending entfernt."
 fi

-if ping -c 1 "$SERVER_IP" &>/dev/null; then
-    export DISPLAY=:0
-    SYNC_LOG=$(mktemp)
-    log "Server is reachable – starting sync..."
-    log "Log file: $SYNC_LOG"
+TOTAL_SENT=$((SENT_DB + SENT_PHOTOS))
+TOTAL_RECEIVED=$((RECEIVED_DB + RECEIVED_PHOTOS))

-    if [ "$SHOW_NOTIFY_START_STOP" = true ]; then
-        notify-send "Darktable Sync" "Sync started..." -t 3000
+if [ "$DRY_RUN" = true ]; then
+    UP_NEW=$(  cat "$UPLOAD_LOG_DB" "$UPLOAD_LOG_PHOTOS" 2>/dev/null | grep -cE '^>f[+]{9}' || echo 0)
+    UP_UPD=$(  cat "$UPLOAD_LOG_DB" "$UPLOAD_LOG_PHOTOS" 2>/dev/null | grep -E  '^>f'        | grep -cvE '^>f[+]{9}' || echo 0)
+    UP_DEL=$(  cat "$UPLOAD_LOG_DB" "$UPLOAD_LOG_PHOTOS" 2>/dev/null | grep -cE '^\*deleting' || echo 0)
+    DN_NEW=$(  cat "$DOWNLOAD_LOG_DB" "$DOWNLOAD_LOG_PHOTOS" 2>/dev/null | grep -cE '^<f[+]{9}' || echo 0)
+    DN_UPD=$(  cat "$DOWNLOAD_LOG_DB" "$DOWNLOAD_LOG_PHOTOS" 2>/dev/null | grep -E  '^<f'        | grep -cvE '^<f[+]{9}' || echo 0)
+    DN_DEL=$(  cat "$DOWNLOAD_LOG_DB" "$DOWNLOAD_LOG_PHOTOS" 2>/dev/null | grep -cE '^\*deleting' || echo 0)
+
+    log_step "Trockenlauf-Ergebnis"
+    log "  Upload:   $UP_NEW neu | $UP_UPD aktualisiert | $UP_DEL gelöscht"
+    log "  Download: $DN_NEW neu | $DN_UPD aktualisiert | $DN_DEL gelöscht"
+
+    if [ "$((TOTAL_SENT + TOTAL_RECEIVED))" -gt 0 ]; then
+        if ask_user "Details" "Details der zu übertragenden Dateien anzeigen?"; then
+            format_rsync_details "$UPLOAD_LOG_DB"       "Upload"   "up"
+            format_rsync_details "$UPLOAD_LOG_PHOTOS"   "Upload"   "up"
+            format_rsync_details "$DOWNLOAD_LOG_DB"     "Download" "down"
+            format_rsync_details "$DOWNLOAD_LOG_PHOTOS" "Download" "down"
        fi
-
-    log "Uploading Darktable DB to Server..."
-    UPLOAD_LOG1=$(mktemp)
-    rsync -uavh --itemize-changes -e "ssh -p $SERVER_SSH_PORT" \
-        "$LOCAL_DARKTABLE_DB_DIR/" "$SERVER_USER@$SERVER_IP:$SERVER_DB_DIR/" \
-        2>&1 | tee -a "$SYNC_LOG" "$UPLOAD_LOG1"
-    SENT1=$(count_synced_files "$UPLOAD_LOG1" "up")
-    rm "$UPLOAD_LOG1"
-
-    log "Uploading photos to Server..."
-    UPLOAD_LOG2=$(mktemp)
-    rsync -uavh --itemize-changes -e "ssh -p $SERVER_SSH_PORT" \
-        "$LOCAL_PHOTO_DIR/" "$SERVER_USER@$SERVER_IP:$SERVER_PHOTO_DIR/" \
-        2>&1 | tee -a "$SYNC_LOG" "$UPLOAD_LOG2"
-    SENT2=$(count_synced_files "$UPLOAD_LOG2" "up")
-    rm "$UPLOAD_LOG2"
-
-    log "Downloading DB back from Server..."
-    DOWNLOAD_LOG1=$(mktemp)
-    rsync -uavh --itemize-changes -e "ssh -p $SERVER_SSH_PORT" \
-        "$SERVER_USER@$SERVER_IP:$SERVER_DB_DIR/" "$LOCAL_DARKTABLE_DB_DIR/" \
-        2>&1 | tee -a "$SYNC_LOG" "$DOWNLOAD_LOG1"
-    RECEIVED1=$(count_synced_files "$DOWNLOAD_LOG1" "down")
-    rm "$DOWNLOAD_LOG1"
-
-    log "Downloading photos from Server..."
-    DOWNLOAD_LOG2=$(mktemp)
-    rsync -uavh --itemize-changes -e "ssh -p $SERVER_SSH_PORT" \
-        "$SERVER_USER@$SERVER_IP:$SERVER_PHOTO_DIR/" "$LOCAL_PHOTO_DIR/" \
-        2>&1 | tee -a "$SYNC_LOG" "$DOWNLOAD_LOG2"
-    RECEIVED2=$(count_synced_files "$DOWNLOAD_LOG2" "down")
-    rm "$DOWNLOAD_LOG2"
-
-    if [ "$SHOW_NOTIFY_START_STOP" = true ]; then
-        notify-send "Darktable Sync" "Sync finished." -t 3000
+    else
+        log "Keine Änderungen – alles aktuell."
    fi
-
-    TOTAL_SENT=$((SENT1 + SENT2))
-    TOTAL_RECEIVED=$((RECEIVED1 + RECEIVED2))
+else
+    log_step "Sync abgeschlossen"
+    log "  Hochgeladen:     $TOTAL_SENT ($SENT_DB DB + $SENT_PHOTOS Fotos)"
+    log "  Heruntergeladen: $TOTAL_RECEIVED ($RECEIVED_DB DB + $RECEIVED_PHOTOS Fotos)"

    if [ "$TOTAL_SENT" -gt 0 ] || [ "$TOTAL_RECEIVED" -gt 0 ]; then
-        log "Uploaded: $TOTAL_SENT files"
-        log "Downloaded: $TOTAL_RECEIVED files"
-        notify-send "Darktable Sync" "↑ $TOTAL_SENT uploaded | ↓ $TOTAL_RECEIVED downloaded" -t 10000
+        notify-send "Darktable Sync" \
+            "↑ $TOTAL_SENT hochgeladen | ↓ $TOTAL_RECEIVED heruntergeladen" -t 10000
    else
-        log "No changes detected."
+        log "Keine Änderungen – alles aktuell."
    fi

-    rm -f "$SYNC_LOG"
-else
-    log "Server not reachable – skipping sync."
+    if [ "$SHOW_NOTIFY_START_STOP" = true ]; then
+        notify-send "Darktable Sync" "Sync abgeschlossen." -t 3000
+    fi
 fi
@@ -1,12 +1,82 @@
-#!/bin/bash
-set -e
+#!/usr/bin/env bash
+set -euo pipefail

-# Konfiguration (per ENV überschreibbar)
-DARKTABLE_BIN="${DARKTABLE_BIN:-darktable}"
-SYNC_BIN="${SYNC_BIN:-darktable_sync.sh}"
+SCRIPT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
+# shellcheck source=darktable_common.sh
+source "$SCRIPT_DIR/darktable_common.sh"

-# Sync im Hintergrund starten
-"$SYNC_BIN" --with-notify-start-stop &
+log_step "Darktable Wrapper gestartet (PID $$)"

-# Darktable starten
-exec "$DARKTABLE_BIN" "$@"
+check_dependency darktable
+check_dependency ssh openssh-client
+check_dependency notify-send libnotify-bin
+log "Alle Abhängigkeiten vorhanden."
+
+load_config
+validate_config
+log "Konfiguration geladen: Server=$SERVER_USER@$SERVER_IP:$SERVER_SSH_PORT"
+
+export DISPLAY="${DISPLAY:-:0}"
+
+log "Prüfen ob Darktable bereits läuft..."
+if pgrep -x darktable &>/dev/null; then
+    log "Darktable läuft bereits (PID: $(pgrep -x darktable | tr '\n' ' ')) – Abbruch."
+    notify-send "Darktable" \
+        "Darktable läuft bereits. Bitte zuerst schließen." -u critical
+    exit 1
+fi
+log "Darktable läuft nicht."
+
+ACTIVE_MARKER_SET=false
+
+cleanup() {
+    if [ "$ACTIVE_MARKER_SET" = true ]; then
+        ssh_server "rm -f '$SERVER_DB_DIR/darktable.active'" 2>/dev/null || true
+    fi
+}
+trap cleanup EXIT INT TERM
+
+log "Serververbindung prüfen ($SERVER_USER@$SERVER_IP Port $SERVER_SSH_PORT)..."
+if ! server_reachable; then
+    log "Server nicht erreichbar."
+    if ! ask_user "Darktable Sync" \
+        "Server nicht erreichbar.\nDarktable ohne Synchronisation starten?"; then
+        log "Abbruch durch Benutzer – Server nicht erreichbar."
+        exit 0
+    fi
+    log "Starte Darktable ohne Sync (Server offline)..."
+else
+    log "Server erreichbar."
+    log_step "Pre-Sync"
+    "$SYNC_BIN"
+    log "Pre-Sync abgeschlossen."
+
+    MARKER="$(hostname) seit $(date '+%Y-%m-%d %H:%M:%S')"
+    log "Active-Marker setzen: $MARKER"
+    ssh_server "echo '$MARKER' > '$SERVER_DB_DIR/darktable.active'" || true
+    ACTIVE_MARKER_SET=true
+fi
+
+log_step "Darktable starten"
+"$DARKTABLE_BIN" "$@" || true
+log "Darktable beendet."
+
+if [ "$ACTIVE_MARKER_SET" = true ]; then
+    log "Active-Marker entfernen..."
+    ssh_server "rm -f '$SERVER_DB_DIR/darktable.active'" 2>/dev/null || true
+    ACTIVE_MARKER_SET=false
+    log "Active-Marker entfernt."
+fi
+
+log "Serververbindung für Post-Sync prüfen..."
+if server_reachable; then
+    log_step "Post-Sync"
+    "$SYNC_BIN"
+    log "Post-Sync abgeschlossen."
+else
+    log "Server nicht erreichbar – Post-Sync übersprungen, sync_pending gesetzt."
+    touch "$CONFIG_DIR/sync_pending"
+    notify-send "Darktable Sync" \
+        "Server nicht erreichbar – Sync ausstehend." -t 5000
+fi
+log_step "Darktable Wrapper beendet"
@@ -0,0 +1,6 @@
+[Unit]
+Description=Darktable Sync (manueller Trigger)
+
+[Service]
+Type=oneshot
+ExecStart=%h/.local/bin/darktable_sync.sh --execute
@@ -1,6 +0,0 @@
-[Unit]
-Description=Darktable sync service
-
-[Service]
-Type=oneshot
-ExecStart=%h/.local/bin/darktable_sync.sh
@@ -1,10 +0,0 @@
-[Unit]
-Description=Run Darktable sync periodically
-
-[Timer]
-OnCalendar=*-*-* *:00:00
-Persistent=true
-Unit=darktable-sync.service
-
-[Install]
-WantedBy=timers.target
@@ -0,0 +1,77 @@
+#!/usr/bin/env bats
+
+load helpers/setup
+
+COMMON_SCRIPT="$BATS_TEST_DIRNAME/../scripts/darktable_common.sh"
+
+@test "check_dependency schlaegt fehl wenn Tool fehlt" {
+    run bash -c "source '$COMMON_SCRIPT'; check_dependency nicht_existierendes_tool"
+    [ "$status" -eq 1 ]
+    [[ "$output" == *"nicht_existierendes_tool"* ]]
+    [[ "$output" == *"sudo apt install"* ]]
+}
+
+@test "check_dependency besteht wenn Tool vorhanden" {
+    run bash -c "source '$COMMON_SCRIPT'; check_dependency bash"
+    [ "$status" -eq 0 ]
+}
+
+@test "load_config schlaegt fehl wenn .env fehlt" {
+    rm -f "$CONFIG_DIR/.env"
+    run bash -c "source '$COMMON_SCRIPT'; load_config"
+    [ "$status" -eq 1 ]
+    [[ "$output" == *"nicht gefunden"* ]]
+}
+
+@test "load_config laedt .env erfolgreich" {
+    create_valid_env
+    run bash -c "source '$COMMON_SCRIPT'; load_config; echo \$SERVER_IP"
+    [ "$status" -eq 0 ]
+    [[ "$output" == *"192.168.1.100"* ]]
+}
+
+@test "validate_config schlaegt fehl wenn Variable leer" {
+    create_valid_env
+    echo "SERVER_IP=" >> "$CONFIG_DIR/.env"
+    run bash -c "source '$COMMON_SCRIPT'; load_config; validate_config"
+    [ "$status" -eq 1 ]
+    [[ "$output" == *"SERVER_IP"* ]]
+}
+
+@test "server_reachable gibt false zurueck wenn SSH fehlschlaegt" {
+    create_valid_env
+    run_with_stubs bash -c "
+        export SSH_STUB_FAIL=1
+        source '$COMMON_SCRIPT'
+        load_config
+        server_reachable
+    "
+    [ "$status" -eq 1 ]
+}
+
+@test "server_reachable gibt true zurueck wenn SSH erfolgreich" {
+    create_valid_env
+    run_with_stubs bash -c "
+        export SSH_STUB_FAIL=0
+        source '$COMMON_SCRIPT'
+        load_config
+        server_reachable
+    "
+    [ "$status" -eq 0 ]
+}
+
+@test "ask_user: j-Eingabe gibt Exit 0" {
+    TMP_SCRIPT=$(mktemp)
+    echo "source '$COMMON_SCRIPT'; ask_user 'Titel' 'Frage?'" > "$TMP_SCRIPT"
+    run bash -c "echo 'j' | env PATH='$STUBS_DIR:$PATH' bash '$TMP_SCRIPT'"
+    rm -f "$TMP_SCRIPT"
+    [ "$status" -eq 0 ]
+}
+
+@test "ask_user: n-Eingabe gibt Exit 1" {
+    TMP_SCRIPT=$(mktemp)
+    echo "source '$COMMON_SCRIPT'; ask_user 'Titel' 'Frage?'" > "$TMP_SCRIPT"
+    run bash -c "echo 'n' | env PATH='$STUBS_DIR:$PATH' bash '$TMP_SCRIPT'"
+    rm -f "$TMP_SCRIPT"
+    [ "$status" -eq 1 ]
+}
@@ -0,0 +1,111 @@
+#!/usr/bin/env bats
+
+load helpers/setup
+
+SYNC_SCRIPT="$BATS_TEST_DIRNAME/../scripts/darktable_sync.sh"
+
+setup() {
+    create_valid_env
+    mkdir -p "$HOME/.config/darktable"
+    touch "$HOME/.config/darktable/library.db"
+    touch "$HOME/.config/darktable/data.db"
+    rm -f "$HOME/.config/darktable/"*.bak
+    mkdir -p "$HOME/Pictures"
+    export DISPLAY=:99
+}
+
+# --- Bestehende Tests (echter Sync via --execute) ---
+
+@test "sync_pending wird gesetzt wenn Server nicht erreichbar" {
+    run_with_stubs env SSH_STUB_FAIL=1 bash "$SYNC_SCRIPT" --execute
+    [ "$status" -eq 0 ]
+    [ -f "$CONFIG_DIR/sync_pending" ]
+}
+
+@test "sync_pending wird entfernt bei erfolgreichem Sync" {
+    touch "$CONFIG_DIR/sync_pending"
+    run_with_stubs env SSH_STUB_FAIL=0 bash "$SYNC_SCRIPT" --execute
+    [ "$status" -eq 0 ]
+    [ ! -f "$CONFIG_DIR/sync_pending" ]
+}
+
+@test "sync_pending wird gesetzt wenn rsync fehlschlaegt" {
+    run_with_stubs env SSH_STUB_FAIL=0 RSYNC_STUB_FAIL=1 bash "$SYNC_SCRIPT" --execute
+    [ "$status" -eq 1 ]
+    [ -f "$CONFIG_DIR/sync_pending" ]
+}
+
+@test "DB-Backup wird vor Download erstellt" {
+    run_with_stubs env SSH_STUB_FAIL=0 bash "$SYNC_SCRIPT" --execute
+    [ "$status" -eq 0 ]
+    [ -f "$HOME/.config/darktable/library.db.bak" ]
+    [ -f "$HOME/.config/darktable/data.db.bak" ]
+}
+
+@test "Versionskonflikt: gleiche Major.Minor gibt kein Exit 1" {
+    run_with_stubs env SSH_STUB_FAIL=0 SSH_STUB_OUTPUT="this is darktable 5.0.1" \
+        DARKTABLE_STUB_VERSION="5.0.1" DRY_RUN_SKIP_CONFIRM=1 bash "$SYNC_SCRIPT"
+    [ "$status" -eq 0 ]
+}
+
+@test "Versionskonflikt: andere Major.Minor gibt Exit 1" {
+    run_with_stubs env SSH_STUB_FAIL=0 SSH_STUB_OUTPUT="this is darktable 4.8.0" \
+        DARKTABLE_STUB_VERSION="5.0.0" DRY_RUN_SKIP_CONFIRM=1 bash "$SYNC_SCRIPT"
+    [ "$status" -eq 1 ]
+    [ -f "$CONFIG_DIR/sync_pending" ]
+}
+
+@test "Lockdir wird nach Abschluss entfernt" {
+    run_with_stubs env SSH_STUB_FAIL=0 bash "$SYNC_SCRIPT" --execute
+    [ "$status" -eq 0 ]
+    [ ! -d "$CONFIG_DIR/sync.lock" ]
+}
+
+# --- Neue Tests: Dry-Run-Verhalten ---
+
+@test "Trockenlauf ist Standard ohne --execute" {
+    run_with_stubs env SSH_STUB_FAIL=0 DRY_RUN_SKIP_CONFIRM=1 bash "$SYNC_SCRIPT"
+    [ "$status" -eq 0 ]
+    [[ "$output" == *"TROCKENLAUF"* ]]
+}
+
+@test "Trockenlauf erstellt kein Backup" {
+    run_with_stubs env SSH_STUB_FAIL=0 DRY_RUN_SKIP_CONFIRM=1 bash "$SYNC_SCRIPT"
+    [ "$status" -eq 0 ]
+    [ ! -f "$HOME/.config/darktable/library.db.bak" ]
+    [ ! -f "$HOME/.config/darktable/data.db.bak" ]
+}
+
+@test "Trockenlauf loescht sync_pending nicht" {
+    touch "$CONFIG_DIR/sync_pending"
+    run_with_stubs env SSH_STUB_FAIL=0 DRY_RUN_SKIP_CONFIRM=1 bash "$SYNC_SCRIPT"
+    [ "$status" -eq 0 ]
+    [ -f "$CONFIG_DIR/sync_pending" ]
+}
+
+@test "--execute fuehrt echten Sync durch und erstellt Backup" {
+    run_with_stubs env SSH_STUB_FAIL=0 bash "$SYNC_SCRIPT" --execute
+    [ "$status" -eq 0 ]
+    [ -f "$HOME/.config/darktable/library.db.bak" ]
+}
+
+@test "-e ist Kurzform fuer --execute" {
+    run_with_stubs env SSH_STUB_FAIL=0 bash "$SYNC_SCRIPT" -e
+    [ "$status" -eq 0 ]
+    [ -f "$HOME/.config/darktable/library.db.bak" ]
+}
+
+@test "Trockenlauf zeigt Ergebnis-Zusammenfassung" {
+    run_with_stubs env SSH_STUB_FAIL=0 DRY_RUN_SKIP_CONFIRM=1 bash "$SYNC_SCRIPT"
+    [ "$status" -eq 0 ]
+    [[ "$output" == *"Trockenlauf-Ergebnis"* ]]
+    [[ "$output" == *"Upload:"* ]]
+    [[ "$output" == *"Download:"* ]]
+}
+
+@test "Trockenlauf zaehlt neue Dateien korrekt" {
+    run_with_stubs env SSH_STUB_FAIL=0 DRY_RUN_SKIP_CONFIRM=1 \
+        RSYNC_STUB_DRY_LINES=">f+++++++++ foto.jpg" bash "$SYNC_SCRIPT"
+    [ "$status" -eq 0 ]
+    [[ "$output" == *"neu"* ]]
+}
@@ -0,0 +1,78 @@
+#!/usr/bin/env bats
+
+load helpers/setup
+
+WRAPPER_SCRIPT="$BATS_TEST_DIRNAME/../scripts/darktable_wrapper.sh"
+
+setup() {
+    create_valid_env
+    mkdir -p "$HOME/.local/bin"
+
+    # Sync-Stub: tut nichts
+    cat > "$HOME/.local/bin/darktable_sync.sh" <<'EOF'
+#!/bin/bash
+exit 0
+EOF
+    chmod +x "$HOME/.local/bin/darktable_sync.sh"
+
+    # Lokale Stubs in einem eigenen Verzeichnis pro Test (kein Überschreiben der globalen Stubs)
+    LOCAL_STUBS="$BATS_TMPDIR/stubs"
+    mkdir -p "$LOCAL_STUBS"
+    export LOCAL_STUBS
+
+    # Alle Stubs kopieren (verhindert echte Dialoge und GUI-Aufrufe)
+    cp "$BATS_TEST_DIRNAME/stubs/ssh"         "$LOCAL_STUBS/ssh"
+    cp "$BATS_TEST_DIRNAME/stubs/notify-send" "$LOCAL_STUBS/notify-send"
+    cp "$BATS_TEST_DIRNAME/stubs/darktable"   "$LOCAL_STUBS/darktable"
+    cp "$BATS_TEST_DIRNAME/stubs/pgrep"       "$LOCAL_STUBS/pgrep"
+    cp "$BATS_TEST_DIRNAME/stubs/zenity"      "$LOCAL_STUBS/zenity"
+    cp "$BATS_TEST_DIRNAME/stubs/kdialog"     "$LOCAL_STUBS/kdialog"
+    chmod +x "$LOCAL_STUBS/"*
+
+    export DISPLAY=:99
+}
+
+@test "Server nicht erreichbar + Dialog abgelehnt: kein Darktable-Start, Exit 0" {
+    run env PATH="$LOCAL_STUBS:$PATH" SSH_STUB_FAIL=1 \
+        bash -c "echo 'n' | bash '$WRAPPER_SCRIPT'"
+    [ "$status" -eq 0 ]
+}
+
+@test "Server nicht erreichbar + Dialog bestaetigt: Darktable startet" {
+    STARTED_FILE="$BATS_TMPDIR/darktable_started"
+    cat > "$LOCAL_STUBS/darktable" <<EOF
+#!/bin/bash
+if [[ "\${1:-}" == "--version" ]]; then echo "this is darktable 5.0.1"; exit 0; fi
+touch "$STARTED_FILE"
+exit 0
+EOF
+    chmod +x "$LOCAL_STUBS/darktable"
+
+    run env PATH="$LOCAL_STUBS:$PATH" SSH_STUB_FAIL=1 \
+        bash -c "echo 'j' | bash '$WRAPPER_SCRIPT'"
+    [ -f "$STARTED_FILE" ]
+}
+
+@test "Post-Sync schlaegt fehl: sync_pending gesetzt" {
+    SSH_CALL_COUNT="$BATS_TMPDIR/ssh_call_count"
+    echo "0" > "$SSH_CALL_COUNT"
+
+    cat > "$LOCAL_STUBS/ssh" <<EOF
+#!/bin/bash
+count=\$(cat "$SSH_CALL_COUNT")
+count=\$((count + 1))
+echo "\$count" > "$SSH_CALL_COUNT"
+# Ab Aufruf 3 fehlschlagen (Post-Sync-Erreichbarkeitstest)
+if [ "\$count" -ge 3 ]; then exit 1; fi
+exit 0
+EOF
+    chmod +x "$LOCAL_STUBS/ssh"
+
+    run env PATH="$LOCAL_STUBS:$PATH" SSH_STUB_FAIL=0 bash "$WRAPPER_SCRIPT"
+    [ -f "$CONFIG_DIR/sync_pending" ]
+}
+
+@test "Darktable laeuft bereits: Abbruch mit Exit 1" {
+    run env PATH="$LOCAL_STUBS:$PATH" PGREP_STUB_FOUND=1 bash "$WRAPPER_SCRIPT"
+    [ "$status" -eq 1 ]
+}
@@ -0,0 +1,34 @@
+# Gemeinsames Test-Setup
+
+STUBS_DIR="$BATS_TEST_DIRNAME/stubs"
+
+# Temporaere HOME anlegen
+export HOME="$BATS_TMPDIR/home"
+mkdir -p "$HOME/.config/darktable-sync"
+mkdir -p "$HOME/.config/darktable"
+mkdir -p "$HOME/.local/bin"
+export CONFIG_DIR="$HOME/.config/darktable-sync"
+
+create_valid_env() {
+    cat > "$CONFIG_DIR/.env" <<EOF
+SERVER_USER=testuser
+SERVER_SSH_PORT=22
+SERVER_IP=192.168.1.100
+SERVER_DB_DIR=/remote/db
+SERVER_PHOTO_DIR=/remote/photos
+LOCAL_DARKTABLE_DB_DIR=$HOME/.config/darktable
+LOCAL_PHOTO_DIR=$HOME/Pictures
+DARKTABLE_BIN=darktable
+SYNC_BIN=$HOME/.local/bin/darktable_sync.sh
+EOF
+}
+
+# Raeumt nach jedem Test auf (verhindert Lock-Leakage zwischen Tests)
+teardown() {
+    rm -rf "$CONFIG_DIR/sync.lock"
+}
+
+# Fuehrt ein Script mit dem Stubs-Verzeichnis vorne im PATH aus
+run_with_stubs() {
+    run env PATH="$STUBS_DIR:$PATH" "$@"
+}
@@ -0,0 +1,147 @@
+#!/usr/bin/env bats
+# Security-Tests fuer darktable-sync
+
+load helpers/setup
+
+COMMON_SCRIPT="$BATS_TEST_DIRNAME/../scripts/darktable_common.sh"
+SYNC_SCRIPT="$BATS_TEST_DIRNAME/../scripts/darktable_sync.sh"
+WRAPPER_SCRIPT="$BATS_TEST_DIRNAME/../scripts/darktable_wrapper.sh"
+
+setup() {
+    create_valid_env
+    mkdir -p "$HOME/.config/darktable"
+    touch "$HOME/.config/darktable/library.db"
+    touch "$HOME/.config/darktable/data.db"
+    mkdir -p "$HOME/Pictures"
+    export DISPLAY=:99
+}
+
+# --- K1: .env Code-Injection wird geblockt ---
+
+@test "security: .env mit Semikolon wird abgelehnt" {
+    cat > "$CONFIG_DIR/.env" <<'EOF'
+SERVER_IP=192.168.1.100
+SERVER_USER=testuser
+SERVER_SSH_PORT=22
+SERVER_DB_DIR=/remote/db
+SERVER_PHOTO_DIR=/remote/photos
+LOCAL_DARKTABLE_DB_DIR=/tmp/dt_test
+LOCAL_PHOTO_DIR=/tmp/photos_test
+DARKTABLE_BIN=darktable
+SYNC_BIN=/usr/local/bin/darktable_sync.sh
+INJECTION_MARKER=injected; touch /tmp/dt_security_test_marker
+EOF
+    run bash -c "source '$COMMON_SCRIPT'; load_config; echo done"
+    rm -f /tmp/dt_security_test_marker
+    [ "$status" -eq 1 ]
+    [[ "$output" == *"unerlaubte Zeichen"* ]]
+}
+
+@test "security: .env mit Backtick wird abgelehnt" {
+    cat > "$CONFIG_DIR/.env" <<'EOF'
+SERVER_IP=192.168.1.100
+SERVER_USER=testuser
+SERVER_SSH_PORT=22
+SERVER_DB_DIR=/remote/db
+SERVER_PHOTO_DIR=/remote/photos
+LOCAL_DARKTABLE_DB_DIR=/tmp/dt_test
+LOCAL_PHOTO_DIR=/tmp/photos_test
+DARKTABLE_BIN=darktable
+SYNC_BIN=/usr/local/bin/darktable_sync.sh
+EVIL=`touch /tmp/evil`
+EOF
+    run bash -c "source '$COMMON_SCRIPT'; load_config; echo done"
+    [ "$status" -eq 1 ]
+    [[ "$output" == *"unerlaubte Zeichen"* ]]
+}
+
+# --- K2: validate_path blockt SSH-Injection ---
+
+@test "security: SERVER_DB_DIR mit Single-Quote wird geblockt" {
+    create_valid_env
+    # Wert in Double-Quotes damit bash ihn fehlerfrei laedt, validate_path muss dann blockieren
+    printf 'SERVER_DB_DIR="/remote/db'"'"'injection"\n' >> "$CONFIG_DIR/.env"
+    run bash -c "source '$COMMON_SCRIPT'; load_config; validate_config"
+    [ "$status" -eq 1 ]
+    [[ "$output" == *"SERVER_DB_DIR"* ]]
+}
+
+@test "security: SERVER_DB_DIR mit Path-Traversal wird geblockt" {
+    create_valid_env
+    echo 'SERVER_DB_DIR=/../../../etc' >> "$CONFIG_DIR/.env"
+    run bash -c "source '$COMMON_SCRIPT'; load_config; validate_config"
+    [ "$status" -eq 1 ]
+    [[ "$output" == *"SERVER_DB_DIR"* ]]
+}
+
+# --- H1: Atomares Locking mit mkdir ---
+
+@test "security: gleichzeitiger Sync wird durch Lockdir geblockt" {
+    mkdir -p "$CONFIG_DIR/sync.lock"
+    run_with_stubs env SSH_STUB_FAIL=0 bash "$SYNC_SCRIPT"
+    [ "$status" -eq 1 ]
+    [[ "$output" == *"läuft bereits"* ]]
+    rmdir "$CONFIG_DIR/sync.lock"
+}
+
+# --- H2: Lockdir nicht durch Symlink angreifbar ---
+
+@test "security: Lockdir ist kein Symlink-Angriffspunkt" {
+    # mkdir schlaegt bei existierendem Symlink fehl – kein Ziel wird geloescht
+    TARGET="$BATS_TMPDIR/symlink_target"
+    echo "wichtiger Inhalt" > "$TARGET"
+    ln -sf "$TARGET" "$CONFIG_DIR/sync.lock"
+
+    run_with_stubs env SSH_STUB_FAIL=0 bash "$SYNC_SCRIPT"
+    # Script muss fehlschlagen (Symlink statt echtes Verzeichnis = mkdir schlaegt fehl)
+    [ "$status" -eq 1 ]
+    # Zieldatei darf nicht geloescht worden sein
+    [ -f "$TARGET" ]
+    rm -f "$CONFIG_DIR/sync.lock" "$TARGET"
+}
+
+# --- H3: DARKTABLE_BIN muss 'darktable' sein ---
+
+@test "security: DARKTABLE_BIN mit anderem basename wird geblockt" {
+    create_valid_env
+    echo "DARKTABLE_BIN=/usr/bin/evil_binary" >> "$CONFIG_DIR/.env"
+    run bash -c "source '$COMMON_SCRIPT'; load_config; validate_config"
+    [ "$status" -eq 1 ]
+    [[ "$output" == *"DARKTABLE_BIN"* ]]
+}
+
+# --- M2: .env-Berechtigungen werden gewarnt ---
+
+@test "security: .env mit world-readable Berechtigungen loest Warnung aus" {
+    create_valid_env
+    chmod 644 "$CONFIG_DIR/.env"
+    run bash -c "source '$COMMON_SCRIPT'; load_config; echo \$SERVER_IP"
+    [ "$status" -eq 0 ]
+    [[ "$output" == *"world-readable"* ]]
+}
+
+# --- validate_config: fehlende Variablen ---
+
+@test "security: validate_config blockt leere SERVER_IP" {
+    create_valid_env
+    echo "SERVER_IP=" >> "$CONFIG_DIR/.env"
+    run bash -c "source '$COMMON_SCRIPT'; load_config; validate_config"
+    [ "$status" -eq 1 ]
+    [[ "$output" == *"SERVER_IP"* ]]
+}
+
+@test "security: validate_config blockt fehlende SERVER_DB_DIR" {
+    create_valid_env
+    sed -i '/^SERVER_DB_DIR/d' "$CONFIG_DIR/.env"
+    run bash -c "source '$COMMON_SCRIPT'; load_config; validate_config"
+    [ "$status" -eq 1 ]
+    [[ "$output" == *"SERVER_DB_DIR"* ]]
+}
+
+# --- Lockdir Cleanup ---
+
+@test "security: Lockdir wird bei normalem Exit entfernt" {
+    run_with_stubs env SSH_STUB_FAIL=0 bash "$SYNC_SCRIPT"
+    [ "$status" -eq 0 ]
+    [ ! -d "$CONFIG_DIR/sync.lock" ]
+}
@@ -0,0 +1,7 @@
+#!/bin/bash
+# DARKTABLE_STUB_VERSION=x.y.z → gibt diese Version aus
+if [[ "${1:-}" == "--version" ]]; then
+    echo "this is darktable ${DARKTABLE_STUB_VERSION:-5.0.1}"
+    exit 0
+fi
+exit 0
@@ -0,0 +1,4 @@
+#!/bin/bash
+# kdialog-Stub fuer Tests: liest j/n aus stdin
+read -r ans
+[[ "$ans" =~ ^[jJyY] ]]
@@ -0,0 +1,3 @@
+#!/bin/bash
+# notify-send-Stub: immer erfolgreich
+exit 0
@@ -0,0 +1,8 @@
+#!/bin/bash
+# pgrep-Stub: Verhalten per Umgebungsvariable steuerbar
+# PGREP_STUB_FOUND=1 → Prozess gefunden
+if [ "${PGREP_STUB_FOUND:-0}" = "1" ]; then
+    echo "12345"
+    exit 0
+fi
+exit 1
@@ -0,0 +1,14 @@
+#!/bin/bash
+# rsync-Stub: Verhalten per Umgebungsvariable steuerbar
+# RSYNC_STUB_FAIL=1 → schlaegt fehl
+# RSYNC_STUB_DRY_LINES → Ausgabe bei --dry-run (Zeilenumbrüche als \n)
+if [ "${RSYNC_STUB_FAIL:-0}" = "1" ]; then
+    exit 1
+fi
+for arg in "$@"; do
+    if [ "$arg" = "--dry-run" ] && [ -n "${RSYNC_STUB_DRY_LINES:-}" ]; then
+        echo -e "$RSYNC_STUB_DRY_LINES"
+        break
+    fi
+done
+exit 0
@@ -0,0 +1,7 @@
+#!/bin/bash
+# SSH_STUB_FAIL=1 → schlaegt fehl
+if [ "${SSH_STUB_FAIL:-0}" = "1" ]; then
+    exit 1
+fi
+echo "${SSH_STUB_OUTPUT:-}"
+exit 0
@@ -0,0 +1,4 @@
+#!/bin/bash
+# zenity-Stub fuer Tests: liest j/n aus stdin
+read -r ans
+[[ "$ans" =~ ^[jJyY] ]]
@@ -1,27 +1,70 @@
 #!/bin/bash

-# Load possible custom paths from install-time .env if exists
-if [[ -f ".env" ]]; then
-    export $(grep -v '^#' .env | xargs)
-fi
+set -e

+CONFIG_DIR="${CONFIG_DIR:-$HOME/.config/darktable-sync}"
 BIN_DIR="${BIN_DIR:-$HOME/.local/bin}"
 APPLICATIONS_DIR="${APPLICATIONS_DIR:-$HOME/.local/share/applications}"
 SYSTEMD_USER_DIR="${SYSTEMD_USER_DIR:-$HOME/.config/systemd/user}"

-# Stop and disable systemd service
-echo "🛑 Removing systemd services..."
-systemctl --user disable --now darktable-sync.timer >/dev/null 2>&1 || true
+if [[ -f "$CONFIG_DIR/.env" ]]; then
+    # shellcheck source=/dev/null
+    . "$CONFIG_DIR/.env"
+fi
+
+### Systemd deaktivieren
+
+echo "Systemd-Services entfernen..."
+systemctl --user disable --now darktable-sync.timer 2>/dev/null || true
+systemctl --user disable --now darktable_sync.timer 2>/dev/null || true
 systemctl --user daemon-reload

-# Remove files
-echo "🧹 Cleaning up installed files..."
+### Lockdir entfernen (atomares Lock)
+
+LOCKDIR="$CONFIG_DIR/sync.lock"
+if [ -d "$LOCKDIR" ]; then
+    echo "Lockdir entfernen: $LOCKDIR"
+    rmdir "$LOCKDIR" 2>/dev/null || true
+fi
+
+### Aktiven Marker auf Server entfernen (best-effort)
+
+if [[ -n "${SERVER_IP:-}" ]] && [[ -n "${SERVER_DB_DIR:-}" ]]; then
+    if ssh -o ConnectTimeout=5 -o BatchMode=yes \
+        -p "${SERVER_SSH_PORT:-22}" "${SERVER_USER:-$USER}@$SERVER_IP" true 2>/dev/null; then
+        echo "Active-Marker auf Server entfernen..."
+        ssh -o ConnectTimeout=5 -o BatchMode=yes \
+            -p "${SERVER_SSH_PORT:-22}" "${SERVER_USER:-$USER}@$SERVER_IP" \
+            "rm -f '$SERVER_DB_DIR/darktable.active'" 2>/dev/null || true
+    fi
+fi
+
+### Installierte Dateien entfernen
+
+echo "Installierte Dateien entfernen..."
 rm -fv \
+    "$BIN_DIR/darktable_common.sh" \
    "$BIN_DIR/darktable_sync.sh" \
    "$BIN_DIR/darktable_wrapper.sh" \
    "$APPLICATIONS_DIR/darktable-with-sync.desktop" \
    "$APPLICATIONS_DIR/darktable-sync-only.desktop" \
    "$SYSTEMD_USER_DIR/darktable-sync.service" \
-  "$SYSTEMD_USER_DIR/darktable-sync.timer"
+    "$SYSTEMD_USER_DIR/darktable-sync.timer" \
+    "$SYSTEMD_USER_DIR/darktable_sync.service" \
+    "$SYSTEMD_USER_DIR/darktable_sync.timer"

-echo "✅ Uninstall complete. Config files in ~/.config/darktable remain untouched."
+### Config-Verzeichnis aufraumen
+
+if [ -d "$CONFIG_DIR" ]; then
+    read -r -p "Konfigurationsverzeichnis $CONFIG_DIR loeschen? [j/N] " ans
+    if [[ "$ans" =~ ^[jJyY] ]]; then
+        rm -rfv "$CONFIG_DIR"
+        echo "Konfigurationsverzeichnis entfernt."
+    else
+        echo "Konfigurationsverzeichnis bleibt erhalten: $CONFIG_DIR"
+    fi
+fi
+
+echo ""
+echo "Deinstallation abgeschlossen."
+echo "Die Darktable-Datenbank (~/.config/darktable/) bleibt unveraendert."
Author	SHA1	Message	Date
martin	c05f323605	feat: Trockenlauf als Standard-Aufruf, --execute/-e für echten Sync Ohne Flags führt darktable_sync.sh jetzt einen Trockenlauf durch: - Banner mit Hinweis und Bestätigungsabfrage vor dem Start - rsync läuft mit --dry-run (keine Dateiänderungen) - Keine destruktiven Operationen: kein Backup, kein Token-Schreiben, kein sync_pending entfernen - Zusammenfassung nach Richtung (Upload/Download) und Aktion (neu/aktualisiert/gelöscht) aufgeschlüsselt - Optionale Detailansicht: Dateien gruppiert nach Typ (Foto, XMP, Datenbank, Video, Sonstiges) Mit --execute oder -e wird der echte Sync wie bisher ausgeführt. Desktop-Entry und Systemd-Service auf --execute aktualisiert. Co-Authored-By: Claude Sonnet 4.6 <noreply@anthropic.com>	2026-04-20 16:24:31 +02:00
martin	0c5774f695	install.sh: interaktive Abfragen bei Installation verbessert - .env-Verschiebung aus Projektverzeichnis wird angeboten und bei Bestätigung automatisch ausgeführt - Lokales Foto-Verzeichnis wird interaktiv abgefragt (mit Hinweis falls es bereits existiert) - Ausführlicher Hinweis nach Anlegen der Default-.env mit Pflichtfeldern und nächsten Schritten - bats-Hinweis entfernt (nur für Entwickler relevant) - Tests: Umlaut-Mismatch in security.bats behoben, teardown() für Lock-Isolation ergänzt Co-Authored-By: Claude Sonnet 4.6 <noreply@anthropic.com>	2026-04-20 12:47:10 +02:00
martin	bc63739399	Merge pull request 'Robustheit: Error-Handling, Validation und Strukturverbesserungen' (#3 ) from feat/improve-sync-robustness into main	2026-04-19 21:05:41 +02:00
martin	c4a9b4a33d	Robustheit: Error-Handling, Validation und Strukturverbesserungen - Neue darktable_common.sh mit gemeinsamen Funktionen (Logging, Validierung, Lock-Management) - Verbesserte Fehlerbehandlung und aussagekräftige Error-Messages - Explizite Validierung von SSH-Schlüssel, Pfaden und Konfiguration beim Start - Sperrmechanismus zur Verhinderung paralleler Sync-Instanzen - Bessere Strukturierung des Sync-Prozesses mit sauberer Fehlertoleranz Co-Authored-By: Claude Sonnet 4.6 <noreply@anthropic.com>	2026-04-19 21:05:14 +02:00
martin	e5d87bd1cb	Merge pull request 'Refaktorierung: Common-Library mit generischen Funktionen' (#2 ) from refactor/darktable-common-extraction into main	2026-04-19 20:36:58 +02:00
martin	6fd8a8c308	Refaktorierung: Common-Library mit generischen Funktionen - Neue `darktable_common.sh` mit wiederverwendbaren Shell-Funktionen (Locking, Logging, Validierung) - `darktable_sync.sh` nutzt jetzt Common-Library statt eingebettete Logik - `darktable_wrapper.sh` vereinfacht durch Nutzung von Common-Funktionen - Eliminiert Code-Duplikation zwischen Sync und Wrapper - Verbessert Wartbarkeit und Testbarkeit Co-Authored-By: Claude Sonnet 4.6 <noreply@anthropic.com>	2026-04-19 20:35:56 +02:00
martin	0cd9679767	Merge pull request 'Robuste Darktable-Synchronisation: sequenzieller Ablauf, Sicherheitshaertung' (#1 ) from feature/robust-sync into main Robuste Darktable-Synchronisation: sequenzieller Ablauf, Sicherheitshaertung	2026-04-19 20:00:32 +02:00
martin	92a5d50082	Sicherheitshaertung: Injection-Schutz, atomares Locking, Pfad-Validierung - load_config blockiert Shell-Operatoren (;\|&`) in .env-Werten - validate_path prueft Sonderzeichen und Path-Traversal in Pfad-Variablen - validate_config prüft DARKTABLE_BIN-basename und ruft validate_path auf - Lockdir-Trap erst nach erfolgreicher Lock-Akquisition registriert (verhindert dass externer Lockdir bei gescheitertem Lock entfernt wird) - uninstall.sh nutzt rmdir statt rm -rf fuer Lockdir - security.bats mit 10 Tests fuer alle Sicherheitsanforderungen Co-Authored-By: Claude Sonnet 4.6 <noreply@anthropic.com>	2026-04-19 19:57:39 +02:00
martin	46664ab3b6	Code-Vereinfachung: Redundanzen entfernen und Wiederverwendung verbessern - log() Funktion in darktable_common.sh ausgelagert (war doppelt vorhanden) - ssh_server() Hilfsfunktion für wiederholte SSH-Aufrufe mit konsistenten Optionen - ssh_server() nutzen statt inline SSH-Befehle in darktable_sync.sh und darktable_wrapper.sh - Reduzierung von SSH-Optionswiederbholungen (ConnectTimeout, BatchMode, Port) Co-Authored-By: Claude Sonnet 4.6 <noreply@anthropic.com>	2026-04-19 19:45:11 +02:00
martin	6a6ce52cf9	Robuste Darktable-Synchronisation: sequenzieller Ablauf, Versions- und Concurrent-Schutz - Race Condition behoben: Pre-Sync wird vollstaendig abgewartet bevor Darktable startet - Post-Sync nach Schliessen von Darktable eingefuehrt (bisher fehlend) - .env aus festem Pfad ~/.config/darktable-sync/.env geladen (nicht mehr relativ) - Server-Erreichbarkeit per SSH statt ping (Firewall-sicher) - Darktable-Versionscheck (Major.Minor) vor Download mit Abbruch bei Konflikt - DB-Backup vor jedem Download (library.db.bak, data.db.bak) - sync_pending-Marker bei Offline/Fehler, Hinweis beim naechsten Start - darktable.active-Marker auf Server fuer Concurrent-Erkennung - Lock-Dateien vom Sync ausgeschlossen - systemd-Timer entfernt, Service bleibt als manueller Trigger - Gemeinsame Hilfsfunktionen in darktable_common.sh extrahiert - 20 BATS-Tests mit vollstaendigem Stub-System ohne GUI-Dialoge Co-Authored-By: Claude Opus 4.6 <noreply@anthropic.com>	2026-04-19 19:41:26 +02:00