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>

desktop/darktable-sync-only.desktop

@@ -2,6 +2,6 @@
 Type=Application
 Name=Darktable Sync
 Comment=Nur Synchronisation ausfuehren ohne Darktable zu starten
-Exec=/home/%u/.local/bin/darktable_sync.sh --with-notify-start-stop
+Exec=/home/%u/.local/bin/darktable_sync.sh --execute --with-notify-start-stop
 Terminal=false
 Categories=Graphics;Photography;

install.sh

@@ -37,8 +37,17 @@ CONFIG_ENV="$CONFIG_DIR/.env"
 
 if [[ -f "$ENV_FILE" ]]; then
     echo "Hinweis: .env im Projektverzeichnis gefunden."
-    echo "  Bitte nach $CONFIG_ENV verschieben:"
-    echo "  cp .env $CONFIG_ENV && chmod 600 $CONFIG_ENV"
+    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
@@ -49,6 +58,18 @@ if [[ -f "$CONFIG_ENV" ]]; then
     set +a
 fi
 
+### Lokales Foto-Verzeichnis interaktiv abfragen
+
+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
+
 ### Konfiguration anzeigen
 
 echo ""
@@ -84,11 +105,6 @@ if ! command -v zenity >/dev/null 2>&1 && ! command -v kdialog >/dev/null 2>&1;
     echo "  (Ohne Dialog-Tool wird ein Text-Fallback verwendet)"
 fi
 
-if ! command -v bats >/dev/null 2>&1; then
-    echo "Hinweis: 'bats' nicht gefunden (nur fuer Tests benoetigt)."
-    echo "  sudo apt install bats"
-fi
-
 ### Verzeichnisse pruefen
 
 if [ ! -d "$LOCAL_PHOTO_DIR" ]; then
@@ -166,8 +182,27 @@ if [ ! -f "$CONFIG_ENV" ]; then
     cp "$SCRIPT_DIR/.env.example" "$CONFIG_ENV"
     chmod 600 "$CONFIG_ENV"
     echo ""
-    echo "WICHTIG: Konfiguration anpassen:"
+    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

scripts/darktable_common.sh

@@ -77,7 +77,60 @@ check_dependency() {
 }
 
 log() {
-    echo "[$(date '+%Y-%m-%d %H:%M:%S')] $*"
+    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() {
@@ -85,6 +138,19 @@ ssh_server() {
         -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
 }
@@ -103,3 +169,57 @@ ask_user() {
         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
+}

scripts/darktable_sync.sh

@@ -5,16 +5,33 @@ SCRIPT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
 # shellcheck source=darktable_common.sh
 source "$SCRIPT_DIR/darktable_common.sh"
 
+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_file="$1" direction="$2" count=0
     case "$direction" in
@@ -25,140 +42,270 @@ count_synced_files() {
 }
 
 LOCKDIR="$CONFIG_DIR/sync.lock"
+LOCKPID="$LOCKDIR/pid"
 TMPFILES=()
 
-# Atomares Locking per mkdir (verhindert Race Condition und Symlink-Attacken)
+log "Lock anfordern: $LOCKDIR"
 if ! mkdir "$LOCKDIR" 2>/dev/null; then
-    echo "Script laeuft bereits oder Lockdir loeschen: $LOCKDIR"
-    exit 1
+    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
-trap 'rm -f "${TMPFILES[@]}"; rmdir "$LOCKDIR" 2>/dev/null || true' EXIT
+echo "$$" > "$LOCKPID"
+log "Lock erworben (PID $$)."
+trap 'rm -f "${TMPFILES[@]}" "$LOCKPID"; rmdir "$LOCKDIR" 2>/dev/null || true; log "Lock freigegeben."' EXIT
 
-SHOW_NOTIFY_START_STOP=false
-if [[ "${1:-}" == "--with-notify-start-stop" ]]; then
-    SHOW_NOTIFY_START_STOP=true
+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
-    notify-send "Darktable Sync" "Ausstehender Sync wird jetzt ausgefuehrt..." -t 3000
+    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 uebersprungen."
+    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 laueft moeglicherweise auf: $ACTIVE" -u normal -t 10000
+        "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)
+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 "WARNUNG: Darktable-Versionen unterschiedlich!"
-        log "  Lokal:  $LOCAL_VERSION"
-        log "  Server: $SERVER_VERSION"
-        log "  Bitte beide Rechner auf gleichen Stand bringen."
+        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 "Datenbank-Backup erstellen..."
-cp "$LOCAL_DARKTABLE_DB_DIR/library.db" "$LOCAL_DARKTABLE_DB_DIR/library.db.bak"
-cp "$LOCAL_DARKTABLE_DB_DIR/data.db"    "$LOCAL_DARKTABLE_DB_DIR/data.db.bak"
+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")
-
-log "Datenbank hochladen..."
 UPLOAD_LOG_DB=$(mktemp)
 TMPFILES+=("$UPLOAD_LOG_DB")
-if ! rsync -uavh --itemize-changes \
-    --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 "Fehler beim Hochladen der Datenbank."
-    touch "$CONFIG_DIR/sync_pending"
-    exit 1
-fi
-SENT_DB=$(count_synced_files "$UPLOAD_LOG_DB" "up")
-
-log "Fotos hochladen..."
 UPLOAD_LOG_PHOTOS=$(mktemp)
 TMPFILES+=("$UPLOAD_LOG_PHOTOS")
-if ! rsync -uavh --itemize-changes \
-    --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 "Fehler beim Hochladen der Fotos."
-    touch "$CONFIG_DIR/sync_pending"
-    exit 1
-fi
-SENT_PHOTOS=$(count_synced_files "$UPLOAD_LOG_PHOTOS" "up")
-
-log "Datenbank herunterladen..."
 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 "Fehler beim Herunterladen der Datenbank."
+    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."
 
-log "Fotos herunterladen..."
-DOWNLOAD_LOG_PHOTOS=$(mktemp)
-TMPFILES+=("$DOWNLOAD_LOG_PHOTOS")
+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 "Fehler beim Herunterladen der Fotos."
+    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."
 
-echo "$LOCAL_VERSION" > "$LOCAL_DARKTABLE_DB_DIR/darktable_version"
+if [ "$DRY_RUN" = false ]; then
+    NEW_TOKEN=$(server_db_mtime)
+    save_sync_token "$NEW_TOKEN"
+    log "Sync-Token gespeichert: $NEW_TOKEN"
 
-rm -f "$CONFIG_DIR/sync_pending"
+    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
 
 TOTAL_SENT=$((SENT_DB + SENT_PHOTOS))
 TOTAL_RECEIVED=$((RECEIVED_DB + RECEIVED_PHOTOS))
 
-if [ "$TOTAL_SENT" -gt 0 ] || [ "$TOTAL_RECEIVED" -gt 0 ]; then
-    log "Hochgeladen: $TOTAL_SENT Dateien"
-    log "Heruntergeladen: $TOTAL_RECEIVED Dateien"
-    notify-send "Darktable Sync" \
-        "↑ $TOTAL_SENT hochgeladen | ↓ $TOTAL_RECEIVED heruntergeladen" -t 10000
-else
-    log "Keine Aenderungen."
-fi
+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)
 
-if [ "$SHOW_NOTIFY_START_STOP" = true ]; then
-    notify-send "Darktable Sync" "Sync abgeschlossen." -t 3000
+    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
+    else
+        log "Keine Änderungen – alles aktuell."
+    fi
+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
+        notify-send "Darktable Sync" \
+            "↑ $TOTAL_SENT hochgeladen | ↓ $TOTAL_RECEIVED heruntergeladen" -t 10000
+    else
+        log "Keine Änderungen – alles aktuell."
+    fi
+
+    if [ "$SHOW_NOTIFY_START_STOP" = true ]; then
+        notify-send "Darktable Sync" "Sync abgeschlossen." -t 3000
+    fi
 fi

scripts/darktable_wrapper.sh

@@ -5,20 +5,27 @@ SCRIPT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
 # shellcheck source=darktable_common.sh
 source "$SCRIPT_DIR/darktable_common.sh"
 
+log_step "Darktable Wrapper gestartet (PID $$)"
+
 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 laeuft bereits. Bitte zuerst schliessen." -u critical
+        "Darktable läuft bereits. Bitte zuerst schließen." -u critical
     exit 1
 fi
+log "Darktable läuft nicht."
 
 ACTIVE_MARKER_SET=false
 
@@ -29,36 +36,47 @@ cleanup() {
 }
 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..."
+    log "Starte Darktable ohne Sync (Server offline)..."
 else
-    log "Pre-Sync..."
+    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 "Starte Darktable..."
+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 "Post-Sync..."
+    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"

systemd/darktable-sync.service

@@ -3,4 +3,4 @@ Description=Darktable Sync (manueller Trigger)
 
 [Service]
 Type=oneshot
-ExecStart=%h/.local/bin/darktable_sync.sh
+ExecStart=%h/.local/bin/darktable_sync.sh --execute

tests/darktable_sync.bats

@@ -9,31 +9,34 @@ setup() {
     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"
+    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"
+    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"
+    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"
+    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" ]
@@ -41,19 +44,68 @@ setup() {
 
 @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" bash "$SYNC_SCRIPT"
+        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" bash "$SYNC_SCRIPT"
+        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"
+    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"* ]]
+}

tests/helpers/setup.bash

@@ -23,6 +23,11 @@ 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" "$@"

tests/security.bats

@@ -80,7 +80,7 @@ EOF
     mkdir -p "$CONFIG_DIR/sync.lock"
     run_with_stubs env SSH_STUB_FAIL=0 bash "$SYNC_SCRIPT"
     [ "$status" -eq 1 ]
-    [[ "$output" == *"laeuft bereits"* ]]
+    [[ "$output" == *"läuft bereits"* ]]
     rmdir "$CONFIG_DIR/sync.lock"
 }
 

tests/stubs/rsync

@@ -1,7 +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