Merge pull request 'Merge dev in testing: Anpassung Fallback auf dokcer-compose und Fehlerbehanldung bei sudo-Ausführung verbessert' (#8) from dev into testing

Reviewed-on: #8

.gitea/workflows/main.yaml

@@ -0,0 +1,155 @@
+name: Main Release & Publish
+
+on:
+  push:
+    branches:
+      - main
+
+jobs:
+  release-and-publish:
+    name: Build, Publish Packages (Stable) & Create Release
+    runs-on: ubuntu-latest
+    steps:
+      - name: Checkout Repository
+        uses: actions/checkout@v7
+
+      - name: Install Rust Toolchain
+        uses: actions-rust-lang/setup-rust-toolchain@v1
+        with:
+          toolchain: stable
+          cache: false
+
+      - name: Install Packaging Tools (Prebuilt Binaries)
+        run: |
+          mkdir -p ~/.cargo/bin
+          curl -fsSL https://github.com/cargo-bins/cargo-binstall/releases/latest/download/cargo-binstall-x86_64-unknown-linux-musl.tgz | tar -xz -C ~/.cargo/bin
+          echo "$HOME/.cargo/bin" >> $GITHUB_PATH
+          ~/.cargo/bin/cargo-binstall -y --no-symlinks cargo-deb cargo-generate-rpm
+
+      - name: Run Tests
+        run: |
+          cargo test
+
+      - name: Build Release Binary
+        run: |
+          cargo build --release
+
+      - name: Build Debian Package (.deb)
+        run: |
+          cargo deb
+
+      - name: Build Fedora / RPM Package (.rpm)
+        run: |
+          cargo generate-rpm
+
+      - name: Build Arch Linux Package (.pkg.tar.zst)
+        run: |
+          chmod +x packaging/arch/build-package.sh
+          ./packaging/arch/build-package.sh
+
+      - name: Publish Packages to Gitea Package Registry
+        env:
+          GITEA_URL: ${{ gitea.server_url || github.server_url }}
+          REPO_OWNER: ${{ gitea.repository_owner || github.repository_owner }}
+          TOKEN: ${{ secrets.PACKAGE_TOKEN || secrets.RELEASE_TOKEN || secrets.PUBLISH_TOKEN || secrets.API_TOKEN || secrets.PAT_TOKEN || secrets.CUSTOM_TOKEN || secrets.GITEA_TOKEN || secrets.GITHUB_TOKEN || github.token }}
+        run: |
+          echo "Veröffentliche Debian-Paket (Distribution: stable, Component: main)..."
+          for deb in target/debian/*.deb; do
+            [ -f "$deb" ] || continue
+            curl -f -s -S -X PUT \
+              -H "Authorization: token ${TOKEN}" \
+              --upload-file "$deb" \
+              "${GITEA_URL}/api/packages/${REPO_OWNER}/debian/pool/stable/main/upload"
+          done
+
+          echo "Veröffentliche Fedora/RPM-Paket (Gruppe: stable)..."
+          for rpm in target/generate-rpm/*.rpm; do
+            [ -f "$rpm" ] || continue
+            curl -f -s -S -X PUT \
+              -H "Authorization: token ${TOKEN}" \
+              --upload-file "$rpm" \
+              "${GITEA_URL}/api/packages/${REPO_OWNER}/rpm/stable/upload"
+          done
+
+          echo "Veröffentliche Arch Linux-Paket (Repository: stable)..."
+          for pkg in target/arch/*.pkg.tar.zst; do
+            [ -f "$pkg" ] || continue
+            curl -f -s -S -X PUT \
+              -H "Authorization: token ${TOKEN}" \
+              --upload-file "$pkg" \
+              "${GITEA_URL}/api/packages/${REPO_OWNER}/arch/stable/upload"
+          done
+
+      - name: Create Gitea Release and Upload Assets
+        env:
+          GITEA_URL: ${{ gitea.server_url || github.server_url }}
+          REPO: ${{ gitea.repository || github.repository }}
+          TOKEN: ${{ secrets.PACKAGE_TOKEN || secrets.RELEASE_TOKEN || secrets.PUBLISH_TOKEN || secrets.API_TOKEN || secrets.PAT_TOKEN || secrets.CUSTOM_TOKEN || secrets.GITEA_TOKEN || secrets.GITHUB_TOKEN || github.token }}
+        run: |
+          VERSION="$(sed -n 's/^version = "\(.*\)"/\1/p' Cargo.toml | head -n1)"
+          TAG_NAME="v${VERSION}"
+          RELEASE_TITLE="Release ${TAG_NAME}"
+          RELEASE_NOTES="Automatisches Release für docker-update ${VERSION}."
+
+          echo "Erstelle oder hole Release für Tag ${TAG_NAME} in ${REPO}..."
+
+          GET_RESP=$(curl -s -w "\n%{http_code}" \
+            -H "Authorization: token ${TOKEN}" \
+            "${GITEA_URL}/api/v1/repos/${REPO}/releases/tags/${TAG_NAME}")
+          HTTP_CODE=$(echo "$GET_RESP" | tail -n1)
+          BODY=$(echo "$GET_RESP" | sed '$d')
+
+          RELEASE_ID=""
+          if [ "$HTTP_CODE" -eq 200 ]; then
+            RELEASE_ID=$(echo "$BODY" | jq -r '.id // empty' 2>/dev/null || echo "$BODY" | grep -o '"id":[0-9]*' | head -n1 | cut -d: -f2)
+            echo "Bestehendes Release gefunden (ID: ${RELEASE_ID})."
+          else
+            echo "Erstelle neues Release ${TAG_NAME}..."
+            CREATE_PAYLOAD=$(cat <<EOF
+          {
+            "tag_name": "${TAG_NAME}",
+            "target_commitish": "main",
+            "name": "${RELEASE_TITLE}",
+            "body": "${RELEASE_NOTES}",
+            "draft": false,
+            "prerelease": false
+          }
+          EOF
+          )
+            CREATE_RESP=$(curl -f -s -S -X POST \
+              -H "Authorization: token ${TOKEN}" \
+              -H "Content-Type: application/json" \
+              -d "$CREATE_PAYLOAD" \
+              "${GITEA_URL}/api/v1/repos/${REPO}/releases")
+            RELEASE_ID=$(echo "$CREATE_RESP" | jq -r '.id // empty' 2>/dev/null || echo "$CREATE_RESP" | grep -o '"id":[0-9]*' | head -n1 | cut -d: -f2)
+            echo "Neues Release erstellt (ID: ${RELEASE_ID})."
+          fi
+
+          if [ -z "$RELEASE_ID" ]; then
+            echo "Fehler: Release-ID konnte nicht ermittelt werden!"
+            exit 1
+          fi
+
+          EXISTING_ASSETS_JSON=$(curl -s \
+            -H "Authorization: token ${TOKEN}" \
+            "${GITEA_URL}/api/v1/repos/${REPO}/releases/${RELEASE_ID}/assets" || echo "[]")
+
+          for file in target/debian/*.deb target/generate-rpm/*.rpm target/arch/*.pkg.tar.zst; do
+            [ -f "$file" ] || continue
+            filename="$(basename "$file")"
+            echo "Lade Release-Asset hoch: $filename"
+
+            ASSET_ID=$(echo "$EXISTING_ASSETS_JSON" | jq -r --arg name "$filename" '.[]? | select(.name == $name) | .id' 2>/dev/null | head -n1 || true)
+            if [ -n "$ASSET_ID" ] && [ "$ASSET_ID" != "null" ]; then
+              echo "Lösche altes Asset mit ID ${ASSET_ID}..."
+              curl -s -X DELETE \
+                -H "Authorization: token ${TOKEN}" \
+                "${GITEA_URL}/api/v1/repos/${REPO}/releases/${RELEASE_ID}/assets/${ASSET_ID}" || true
+            fi
+
+            curl -f -s -S -X POST \
+              -H "Authorization: token ${TOKEN}" \
+              -F "attachment=@${file}" \
+              "${GITEA_URL}/api/v1/repos/${REPO}/releases/${RELEASE_ID}/assets?name=${filename}"
+            echo "Asset ${filename} erfolgreich hochgeladen."
+          done

.gitea/workflows/testing.yaml

@@ -0,0 +1,155 @@
+name: Testing Build, Publish & Preview Release
+
+on:
+  push:
+    branches:
+      - testing
+
+jobs:
+  build-and-publish:
+    name: Build, Publish Packages (Testing) & Create Preview Release
+    runs-on: ubuntu-latest
+    steps:
+      - name: Checkout Repository
+        uses: actions/checkout@v7
+
+      - name: Install Rust Toolchain
+        uses: actions-rust-lang/setup-rust-toolchain@v1
+        with:
+          toolchain: stable
+          cache: false
+
+      - name: Install Packaging Tools (Prebuilt Binaries)
+        run: |
+          mkdir -p ~/.cargo/bin
+          curl -fsSL https://github.com/cargo-bins/cargo-binstall/releases/latest/download/cargo-binstall-x86_64-unknown-linux-musl.tgz | tar -xz -C ~/.cargo/bin
+          echo "$HOME/.cargo/bin" >> $GITHUB_PATH
+          ~/.cargo/bin/cargo-binstall -y --no-symlinks cargo-deb cargo-generate-rpm
+
+      - name: Run Tests
+        run: |
+          cargo test
+
+      - name: Build Release Binary
+        run: |
+          cargo build --release
+
+      - name: Build Debian Package (.deb)
+        run: |
+          cargo deb
+
+      - name: Build Fedora / RPM Package (.rpm)
+        run: |
+          cargo generate-rpm
+
+      - name: Build Arch Linux Package (.pkg.tar.zst)
+        run: |
+          chmod +x packaging/arch/build-package.sh
+          ./packaging/arch/build-package.sh
+
+      - name: Publish Packages to Gitea Package Registry
+        env:
+          GITEA_URL: ${{ gitea.server_url || github.server_url }}
+          REPO_OWNER: ${{ gitea.repository_owner || github.repository_owner }}
+          TOKEN: ${{ secrets.PACKAGE_TOKEN || secrets.RELEASE_TOKEN || secrets.PUBLISH_TOKEN || secrets.API_TOKEN || secrets.PAT_TOKEN || secrets.CUSTOM_TOKEN || secrets.GITEA_TOKEN || secrets.GITHUB_TOKEN || github.token }}
+        run: |
+          echo "Veröffentliche Debian-Paket (Distribution: testing, Component: main)..."
+          for deb in target/debian/*.deb; do
+            [ -f "$deb" ] || continue
+            curl -f -s -S -X PUT \
+              -H "Authorization: token ${TOKEN}" \
+              --upload-file "$deb" \
+              "${GITEA_URL}/api/packages/${REPO_OWNER}/debian/pool/testing/main/upload"
+          done
+
+          echo "Veröffentliche Fedora/RPM-Paket (Gruppe: testing)..."
+          for rpm in target/generate-rpm/*.rpm; do
+            [ -f "$rpm" ] || continue
+            curl -f -s -S -X PUT \
+              -H "Authorization: token ${TOKEN}" \
+              --upload-file "$rpm" \
+              "${GITEA_URL}/api/packages/${REPO_OWNER}/rpm/testing/upload"
+          done
+
+          echo "Veröffentliche Arch Linux-Paket (Repository: testing)..."
+          for pkg in target/arch/*.pkg.tar.zst; do
+            [ -f "$pkg" ] || continue
+            curl -f -s -S -X PUT \
+              -H "Authorization: token ${TOKEN}" \
+              --upload-file "$pkg" \
+              "${GITEA_URL}/api/packages/${REPO_OWNER}/arch/testing/upload"
+          done
+
+      - name: Create Gitea Pre-Release and Upload Assets
+        env:
+          GITEA_URL: ${{ gitea.server_url || github.server_url }}
+          REPO: ${{ gitea.repository || github.repository }}
+          TOKEN: ${{ secrets.PACKAGE_TOKEN || secrets.RELEASE_TOKEN || secrets.PUBLISH_TOKEN || secrets.API_TOKEN || secrets.PAT_TOKEN || secrets.CUSTOM_TOKEN || secrets.GITEA_TOKEN || secrets.GITHUB_TOKEN || github.token }}
+        run: |
+          VERSION="$(sed -n 's/^version = "\(.*\)"/\1/p' Cargo.toml | head -n1)"
+          TAG_NAME="v${VERSION}-preview"
+          RELEASE_TITLE="Preview Release ${TAG_NAME}"
+          RELEASE_NOTES="Automatisches Preview-Release für docker-update ${VERSION} (Branch: Testing)."
+
+          echo "Erstelle oder hole Preview-Release für Tag ${TAG_NAME} in ${REPO}..."
+
+          GET_RESP=$(curl -s -w "\n%{http_code}" \
+            -H "Authorization: token ${TOKEN}" \
+            "${GITEA_URL}/api/v1/repos/${REPO}/releases/tags/${TAG_NAME}")
+          HTTP_CODE=$(echo "$GET_RESP" | tail -n1)
+          BODY=$(echo "$GET_RESP" | sed '$d')
+
+          RELEASE_ID=""
+          if [ "$HTTP_CODE" -eq 200 ]; then
+            RELEASE_ID=$(echo "$BODY" | jq -r '.id // empty' 2>/dev/null || echo "$BODY" | grep -o '"id":[0-9]*' | head -n1 | cut -d: -f2)
+            echo "Bestehendes Release gefunden (ID: ${RELEASE_ID})."
+          else
+            echo "Erstelle neues Preview-Release ${TAG_NAME}..."
+            CREATE_PAYLOAD=$(cat <<EOF
+          {
+            "tag_name": "${TAG_NAME}",
+            "target_commitish": "testing",
+            "name": "${RELEASE_TITLE}",
+            "body": "${RELEASE_NOTES}",
+            "draft": false,
+            "prerelease": true
+          }
+          EOF
+          )
+            CREATE_RESP=$(curl -f -s -S -X POST \
+              -H "Authorization: token ${TOKEN}" \
+              -H "Content-Type: application/json" \
+              -d "$CREATE_PAYLOAD" \
+              "${GITEA_URL}/api/v1/repos/${REPO}/releases")
+            RELEASE_ID=$(echo "$CREATE_RESP" | jq -r '.id // empty' 2>/dev/null || echo "$CREATE_RESP" | grep -o '"id":[0-9]*' | head -n1 | cut -d: -f2)
+            echo "Neues Preview-Release erstellt (ID: ${RELEASE_ID})."
+          fi
+
+          if [ -z "$RELEASE_ID" ]; then
+            echo "Fehler: Release-ID konnte nicht ermittelt werden!"
+            exit 1
+          fi
+
+          EXISTING_ASSETS_JSON=$(curl -s \
+            -H "Authorization: token ${TOKEN}" \
+            "${GITEA_URL}/api/v1/repos/${REPO}/releases/${RELEASE_ID}/assets" || echo "[]")
+
+          for file in target/debian/*.deb target/generate-rpm/*.rpm target/arch/*.pkg.tar.zst; do
+            [ -f "$file" ] || continue
+            filename="$(basename "$file")"
+            echo "Lade Release-Asset hoch: $filename"
+
+            ASSET_ID=$(echo "$EXISTING_ASSETS_JSON" | jq -r --arg name "$filename" '.[]? | select(.name == $name) | .id' 2>/dev/null | head -n1 || true)
+            if [ -n "$ASSET_ID" ] && [ "$ASSET_ID" != "null" ]; then
+              echo "Lösche altes Asset mit ID ${ASSET_ID}..."
+              curl -s -X DELETE \
+                -H "Authorization: token ${TOKEN}" \
+                "${GITEA_URL}/api/v1/repos/${REPO}/releases/${RELEASE_ID}/assets/${ASSET_ID}" || true
+            fi
+
+            curl -f -s -S -X POST \
+              -H "Authorization: token ${TOKEN}" \
+              -F "attachment=@${file}" \
+              "${GITEA_URL}/api/v1/repos/${REPO}/releases/${RELEASE_ID}/assets?name=${filename}"
+            echo "Asset ${filename} erfolgreich hochgeladen."
+          done

.idea/jsonSchemas.xml

@@ -0,0 +1,28 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<project version="4">
+  <component name="JsonSchemaMappingsProjectConfiguration">
+    <state>
+      <map>
+        <entry key="GitHub Workflow">
+          <value>
+            <SchemaInfo>
+              <option name="name" value="GitHub Workflow" />
+              <option name="relativePathToSchema" value="https://www.schemastore.org/github-workflow.json" />
+              <option name="applicationDefined" value="true" />
+              <option name="patterns">
+                <list>
+                  <Item>
+                    <option name="path" value=".gitea/workflows/testing.yaml" />
+                  </Item>
+                  <Item>
+                    <option name="path" value=".gitea/workflows/main.yaml" />
+                  </Item>
+                </list>
+              </option>
+            </SchemaInfo>
+          </value>
+        </entry>
+      </map>
+    </state>
+  </component>
+</project>

AGENTS.md

@@ -27,6 +27,10 @@ lädt diese herunter, startet betroffene Services neu und bereinigt ungenutzte Z
 
 ```text
 DockerUpdate/
+├── .gitea/
+│   └── workflows/
+│       ├── testing.yaml # CI/CD für testing-Branch (Tests, Testing-Packages & Preview-Release)
+│       └── main.yaml    # CI/CD für main-Branch (Tests, Stable-Packages & Release)
 ├── Cargo.toml          # Rust-Manifest, Abhängigkeiten und Metadaten für cargo-deb / generate-rpm
 ├── Cargo.lock
 ├── LICENSE             # GPL-3.0 Lizenztext
@@ -34,7 +38,8 @@ DockerUpdate/
 ├── AGENTS.md           # Richtlinien und Dokumentation für Agenten
 ├── packaging/
 │   ├── arch/
-│   │   └── PKGBUILD    # Arch Linux PKGBUILD
+│   │   ├── PKGBUILD            # Arch Linux PKGBUILD
+│   │   └── build-package.sh    # Hilfsskript zur Erstellung des .pkg.tar.zst-Pakets
 │   └── fedora/
 │       └── docker-update.spec  # RPM-Spec für Fedora / RHEL / CentOS
 └── src/
@@ -70,6 +75,18 @@ DockerUpdate/
 - **`src/sudo.rs`**:
     - `is_run_as_root()`: Nutzt `libc::geteuid() == 0`.
     - `run_as_root()`: Führt `sudo <args>` per `exec` aus.
+- **`.gitea/workflows/`**:
+    - `testing.yaml`: Führt bei Push auf `testing` Tests und Builds durch, veröffentlicht Pakete in der Gitea Package
+      Registry
+      (`distribution: testing`, `component: main` bzw. Gruppe/Repo `testing`) und erstellt ein Gitea Preview-Release mit
+      den Paketen als Assets.
+    - `main.yaml`: Führt bei Push auf `main` Tests und Builds durch, veröffentlicht Pakete in der Gitea Package Registry
+      (`distribution: stable`, `component: main` bzw. Gruppe/Repo `stable`) und erstellt ein Gitea Release mit den
+      Paketen als Assets.
+- **`packaging/`**:
+    - `arch/PKGBUILD`: Quellpaketdefinition für Arch Linux (AUR / Makepkg).
+    - `arch/build-package.sh`: Hilfsskript zum Bauen des standardkonformen `.pkg.tar.zst`-Pakets aus dem Cargo-Build.
+    - `fedora/docker-update.spec`: RPM-Spec-Datei für Fedora, RHEL und CentOS.
 
 ---
 
@@ -88,6 +105,19 @@ cargo test
 cargo build --release
 ```
 
+### Optionale Paketierungsbefehle (lokale Validierung)
+
+```bash
+# Debian-Paket (.deb) erstellen (benötigt cargo-deb)
+cargo deb
+
+# Fedora / RPM-Paket (.rpm) erstellen (benötigt cargo-generate-rpm)
+cargo generate-rpm
+
+# Arch Linux-Paket (.pkg.tar.zst) erstellen
+./packaging/arch/build-package.sh
+```
+
 ---
 
 ## 4. Richtlinien für Änderungen
@@ -95,10 +125,13 @@ cargo build --release
 1. **Abwärtskompatibilität & Pfade**:
    Der Standard-Apps-Pfad `/var/apps` und die Konfigurationspfade dürfen nicht ohne triftigen Grund geändert werden.
 2. **Paketierungsdefinitionen synchron halten**:
-   Werden Abhängigkeiten oder Assets geändert, müssen `Cargo.toml` (`[package.metadata.deb]`,
+   Werden Abhängigkeiten, Metadaten oder Assets geändert, müssen `Cargo.toml` (`[package.metadata.deb]`,
-   `[package.metadata.generate-rpm]`), `packaging/arch/PKGBUILD` und `packaging/fedora/docker-update.spec` entsprechend
+   `[package.metadata.generate-rpm]`), `packaging/arch/PKGBUILD`, `packaging/arch/build-package.sh` und
-   aktualisiert werden.
+   `packaging/fedora/docker-update.spec` entsprechend aktualisiert werden.
 3. **Automatisierung**:
    Die empfohlene Automatisierungsmethode ist **Cron** (`/etc/cron.d/docker-update` oder `crontab -e`).
 4. **Keine Mocking-Bypässe**:
    Tests dürfen nicht gelöscht, ignoriert oder durch leere Dummy-Assertions ersetzt werden.
+5. **CI/CD & Release-Konsistenz**:
+   Workflows in `.gitea/workflows/` müssen bei strukturellen Paket- oder Release-Anpassungen konsistent zu `Cargo.toml`
+   gehalten werden.

README.md

@@ -38,6 +38,126 @@ auf neuere Versionen prüft, aktualisiert und neu startet.
 
 ---
 
+## Installation aus der Gitea-Paket-Registry
+
+Über die CI/CD-Pipelines werden bei jedem Push auf den `main`-Branch (Release / Stable) und `testing`-Branch (Preview /
+Testing) automatisch Pakete für **Debian/Ubuntu**, **Fedora/RHEL** und **Arch Linux** in der Gitea-Paket-Registry
+bereitgestellt.
+
+### 1. Debian / Ubuntu (`apt`)
+
+#### Stable (Produktiv)
+
+Füge das Repository zu deinen APT-Quellen hinzu:
+
+```bash
+# Keyring installieren
+sudo curl https://gitea.creative-dragonslayer.de/api/packages/Linuxapps/debian/repository.key -o /etc/apt/keyrings/gitea-Linuxapps.asc
+# Repository-Eintrag anlegen
+echo "deb [signed-by=/etc/apt/keyrings/gitea-Linuxapps.asc] https://gitea.creative-dragonslayer.de/api/packages/Linuxapps/debian stable main" | sudo tee -a /etc/apt/sources.list.d/gitea.list
+
+# Paketliste aktualisieren und installieren
+sudo apt update
+sudo apt install docker-update
+```
+
+#### Testing (Vorschau / Testing)
+
+```bash
+# Keyring installieren
+sudo curl https://gitea.creative-dragonslayer.de/api/packages/Linuxapps/debian/repository.key -o /etc/apt/keyrings/gitea-Linuxapps.asc
+# Testing-Repository-Eintrag anlegen
+echo "deb [signed-by=/etc/apt/keyrings/gitea-Linuxapps.asc] https://gitea.creative-dragonslayer.de/api/packages/Linuxapps/debian testing main" | sudo tee -a /etc/apt/sources.list.d/gitea.list
+
+# Paketliste aktualisieren und installieren
+sudo apt update
+sudo apt install docker-update
+```
+
+---
+
+### 2. Fedora / RHEL / CentOS (`dnf` / `yum`)
+
+#### Stable (Produktiv)
+
+Erstelle die Repository-Datei `/etc/yum.repos.d/docker-update.repo`:
+
+```bash
+sudo tee /etc/yum.repos.d/docker-update-stable.repo << 'EOF'
+[docker-update-stable]
+name=DockerUpdate Stable
+baseurl=https://gitea.creative-dragonslayer.de/api/packages/Linuxapps/rpm/stable
+enabled=1
+gpgcheck=0
+EOF
+
+# Installation via DNF
+sudo dnf install docker-update
+```
+
+#### Testing (Vorschau / Testing)
+
+```bash
+sudo tee /etc/yum.repos.d/docker-update-testing.repo << 'EOF'
+[docker-update-testing]
+name=DockerUpdate Testing
+baseurl=https://gitea.creative-dragonslayer.de/api/packages/Linuxapps/rpm/testing
+enabled=1
+gpgcheck=0
+EOF
+
+# Installation via DNF
+sudo dnf install docker-update
+```
+
+---
+
+### 3. Arch Linux (`pacman`)
+
+#### Stable (Produktiv)
+
+Füge das Repository in `/etc/pacman.conf` ein:
+
+```ini
+[docker-update-stable]
+SigLevel = Optional TrustAll
+Server = https://gitea.creative-dragonslayer.de/api/packages/Linuxapps/arch/stable/$arch
+```
+
+Installiere das Paket anschließend:
+
+```bash
+sudo pacman -Sy docker-update
+```
+
+#### Testing (Vorschau / Testing)
+
+Füge das Testing-Repository in `/etc/pacman.conf` ein:
+
+```ini
+[docker-update-testing]
+SigLevel = Optional TrustAll
+Server = https://gitea.creative-dragonslayer.de/api/packages/Linuxapps/arch/testing/$arch
+```
+
+Installiere das Paket:
+
+```bash
+sudo pacman -Sy docker-update
+```
+
+---
+
+### Download vorgefertigter Pakete (Releases)
+
+Alternativ können vorkompilierte Pakete (`.deb`, `.rpm`, `.pkg.tar.zst`) auch direkt aus den Releases heruntergeladen
+und manuell installiert werden:
+
+- **Stable-Releases**: [Gitea Releases](https://gitea.creative-dragonslayer.de/Linuxapps/DockerUpdate/releases)
+- **Preview-Releases (Testing)**: Markiert als Vorabveröffentlichung (*Pre-release*) mit dem Tag `v<VERSION>-preview`.
+
+---
+
 ## Manuelle Installation (Build from Source)
 
 ```bash

packaging/arch/build-package.sh

@@ -0,0 +1,54 @@
+#!/usr/bin/env bash
+set -euo pipefail
+
+SCRIPT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
+PROJECT_ROOT="$(cd "$SCRIPT_DIR/../.." && pwd)"
+
+cd "$PROJECT_ROOT"
+
+if [ ! -f "target/release/docker-update" ]; then
+    cargo build --release
+fi
+
+VERSION="$(sed -n 's/^version = "\(.*\)"/\1/p' Cargo.toml | head -n1)"
+PKGVER="${VERSION}"
+PKGREL="1"
+ARCH="x86_64"
+
+BUILD_DIR="$(mktemp -d)"
+trap 'rm -rf "$BUILD_DIR"' EXIT
+
+mkdir -p "$BUILD_DIR/usr/bin"
+mkdir -p "$BUILD_DIR/usr/share/licenses/docker-update"
+mkdir -p "$BUILD_DIR/usr/share/doc/docker-update"
+
+install -m 755 "target/release/docker-update" "$BUILD_DIR/usr/bin/docker-update"
+install -m 644 "LICENSE" "$BUILD_DIR/usr/share/licenses/docker-update/LICENSE"
+install -m 644 "README.md" "$BUILD_DIR/usr/share/doc/docker-update/README.md"
+
+INSTALLED_SIZE="$(du -sb "$BUILD_DIR" | awk '{print $1}')"
+
+cat <<EOF > "$BUILD_DIR/.PKGINFO"
+pkgname = docker-update
+pkgbase = docker-update
+pkgver = ${PKGVER}-${PKGREL}
+pkgdesc = Automatisches Aktualisieren von Docker-Compose-Anwendungen in /var/apps mit :latest-Images
+url = https://gitea.creative-dragonslayer.de/Linuxapps/DockerUpdate
+builddate = $(date +%s)
+packager = DragonSlayer_14
+size = ${INSTALLED_SIZE}
+arch = ${ARCH}
+license = GPL-3.0-or-later
+depend = gcc-libs
+depend = glibc
+depend = sudo
+depend = docker
+optdepend = docker-compose: Unterstützung für Docker Compose v1
+makepkgopt = strip
+EOF
+
+mkdir -p "target/arch"
+OUTPUT_FILE="$PROJECT_ROOT/target/arch/docker-update-${PKGVER}-${PKGREL}-${ARCH}.pkg.tar.zst"
+(cd "$BUILD_DIR" && tar --zstd -cf "$OUTPUT_FILE" .PKGINFO usr)
+
+echo "Arch-Paket erfolgreich erstellt: $OUTPUT_FILE"

src/log.rs

@@ -1,10 +1,10 @@
 //! Einfaches, threadsicheres Logging-Modul.
 //!
 //! Merkmale:
-//! - Ausgabe in Terminal (stdout/stderr) und zusätzlich in eine Logdatei im temporären Verzeichnis.
+//! - Ausgabe auf Standard-Streams (stdout/stderr) und zusätzlich in eine Logdatei im temporären Verzeichnis.
 //! - Nachrichtenvorlage: `[DD.MM.YYYY HH:MM:SS.mmm][LEVEL][TAG]: <Text>` mit Präfix ([!]/[?]/[i]/[d]).
 //! - Der aktuell verwendete Schweregradfilter ist statisch (`LOG_LEVEL`) und wird zur Laufzeit nicht geändert.
-//! - Terminal-Erkennung und Dateihandle werden lazily initialisiert und zwischengespeichert (`OnceLock`).
+//! - Dateihandle wird lazily initialisiert und zwischengespeichert (`OnceLock`).
 //!
 //! Hinweise:
 //! - Bei einem leeren `tag` wird ein leerer Tag-Abschnitt erzeugt.
@@ -22,13 +22,13 @@
 
 use std::env;
 use std::fmt::{Display, Formatter};
-use std::fs::{create_dir_all, File, OpenOptions};
+use std::fs::{File, OpenOptions, create_dir_all};
-use std::io::{stdout, IsTerminal, Write};
+use std::io::Write;
 use std::sync::{Mutex, OnceLock};
 
 use crate::config;
 use crate::program;
-use time::{macros::format_description, OffsetDateTime};
+use time::{OffsetDateTime, macros::format_description};
 
 /// Schweregrade für Logeinträge in aufsteigender Detailtiefe.
 ///
@@ -71,14 +71,11 @@ impl TryFrom<String> for LogLevel {
             "warn" => Ok(LogLevel::Warn),
             "info" => Ok(LogLevel::Info),
             "debug" => Ok(LogLevel::Debug),
-            _ => Err(LogLevel::Info)
+            _ => Err(LogLevel::Info),
         }
     }
 }
 
-/// Zwischenspeicher für die einmalig ermittelte Terminal-Fähigkeit von `stdout`.
-static IS_TERMINAL: OnceLock<bool> = OnceLock::new();
-
 /// Globaler Schweregradfilter für Ausgabe.
 static LOG_LEVEL: OnceLock<LogLevel> = OnceLock::new();
 
@@ -89,7 +86,7 @@ static LOG_FILE: OnceLock<Mutex<Option<File>>> = OnceLock::new();
 ///
 /// Verhalten:
 /// - Wenn `log_level` größer als der globale Filter ist, wird nichts ausgegeben.
-/// - Bei Terminalausgabe gehen `Error`-Meldungen nach `stderr`, alle anderen nach `stdout`.
+/// - `Error`-Meldungen gehen nach `stderr`, alle anderen nach `stdout`.
 /// - Zusätzlich wird in eine tägliche Logdatei im Temp-Verzeichnis geschrieben (wenn erfolgreich geöffnet).
 ///
 /// Parameter:
@@ -109,12 +106,10 @@ pub fn log(tag: &str, message: &str, log_level: LogLevel) {
     if log_level <= get_log_level() {
         let message: String = format_message(tag, message, &log_level);
 
-        if is_terminal() {
         if log_level == LogLevel::Error {
-                eprintln!("{}", message)
+            eprintln!("{}", message);
         } else {
-                println!("{}", message)
+            println!("{}", message);
-            }
         }
 
         let file_lock = get_or_init_log_file();
@@ -138,17 +133,7 @@ fn get_log_level() -> LogLevel {
     *LOG_LEVEL.get_or_init(|| {
         let log_level = &config::get_config().general.log_level;
         LogLevel::try_from(log_level.to_string()).unwrap_or(LogLevel::Info)
-    }
+    })
-    )
-}
-
-/// Ermittelt einmalig, ob `stdout` ein Terminal ist, und cached das Ergebnis.
-///
-/// Rückgabe:
-/// - `true`, wenn `stdout` ein TTY/Terminal ist.
-/// - `false` andernfalls.
-fn is_terminal() -> bool {
-    *IS_TERMINAL.get_or_init(|| stdout().is_terminal())
 }
 
 /// Formatiert eine Lognachricht mit Zeitstempel, Level, Tag und Präfix.
@@ -234,10 +219,7 @@ fn open_log_file() -> std::io::Result<File> {
     let file_name = format!("log-{}.log", date_str);
     dir.push(file_name);
 
-    OpenOptions::new()
+    OpenOptions::new().create(true).append(true).open(dir)
-        .create(true)
-        .append(true)
-        .open(dir)
 }
 
 #[cfg(test)]

src/sudo.rs

@@ -1,6 +1,7 @@
+use crate::log::{LogLevel, log};
 use std::env;
 use std::os::unix::process::CommandExt;
-use std::process::Command;
+use std::process::{Command, exit};
 
 /// Prüft, ob das Programm mit Root-/Administrator-Rechten ausgeführt wird.
 ///
@@ -11,10 +12,17 @@ use std::process::Command;
 pub fn is_run_as_root() -> bool {
     unsafe { libc::geteuid() == 0 }
 }
+
 /// Startet das Programm mit Root-Rechten über `sudo` neu.
 ///
 /// Diese Funktion versucht das Programm mit erhöhten Rechten neu zu starten.
 pub fn run_as_root() {
     let commandline_args: Vec<String> = env::args().collect();
-    let _output = Command::new("sudo").args(&commandline_args).exec(); // Bye bye never returns
+    let err = Command::new("sudo").args(&commandline_args).exec();
+    log(
+        "auth",
+        &format!("Fehler beim Ausführen von 'sudo': {}", err),
+        LogLevel::Error,
+    );
+    exit(1);
 }

src/updater.rs

@@ -1,10 +1,10 @@
+use crate::config;
+use crate::log::{LogLevel, log};
+use serde::Deserialize;
+use std::collections::HashMap;
 use std::fs;
 use std::path::{Path, PathBuf};
 use std::process::{Command, Output};
-use serde::Deserialize;
-use std::collections::HashMap;
-use crate::log::{log, LogLevel};
-use crate::config;
 
 const COMPOSE_FILENAMES: &[&str] = &[
     "docker-compose.yaml",
@@ -58,11 +58,21 @@ pub fn find_compose_file(dir: &Path) -> Option<PathBuf> {
 
 /// Liest eine Compose-Datei ein und liefert eine Liste von (Service-Name, Image-Name).
 pub fn parse_compose_services(compose_path: &Path) -> Result<Vec<(String, String)>, String> {
-    let content = fs::read_to_string(compose_path)
+    let content = fs::read_to_string(compose_path).map_err(|e| {
-        .map_err(|e| format!("Fehler beim Lesen der Datei '{}': {}", compose_path.display(), e))?;
+        format!(
+            "Fehler beim Lesen der Datei '{}': {}",
+            compose_path.display(),
+            e
+        )
+    })?;
 
-    let compose: ComposeFile = serde_yaml::from_str(&content)
+    let compose: ComposeFile = serde_yaml::from_str(&content).map_err(|e| {
-        .map_err(|e| format!("Fehler beim Parsen der YAML-Datei '{}': {}", compose_path.display(), e))?;
+        format!(
+            "Fehler beim Parsen der YAML-Datei '{}': {}",
+            compose_path.display(),
+            e
+        )
+    })?;
 
     let mut services = Vec::new();
     for (service_name, config) in compose.services {
@@ -83,7 +93,7 @@ fn run_docker_command(args: &[&str]) -> std::io::Result<Output> {
 }
 
 /// Führt einen Docker-Compose-Befehl im angegebenen Verzeichnis aus.
-/// Versucht zuerst `docker compose` und fällt bei Bedarf auf `docker-compose` zurück.
+/// Versucht zuerst `docker compose` und fällt bei Nichtverfügbarkeit auf `docker-compose` zurück.
 pub fn run_compose_command(dir: &Path, args: &[&str]) -> std::io::Result<Output> {
     let mut compose_args = vec!["compose"];
     compose_args.extend_from_slice(args);
@@ -94,14 +104,32 @@ pub fn run_compose_command(dir: &Path, args: &[&str]) -> std::io::Result<Output>
         .output();
 
     match output {
-        Ok(out) if out.status.success() || out.status.code() != Some(127) => Ok(out),
+        Ok(out) => {
-        _ => {
+            let stderr = String::from_utf8_lossy(&out.stderr);
-            // Fallback auf docker-compose (v1)
+            let is_unavailable = !out.status.success()
+                && (stderr.contains("is not a docker command")
+                    || stderr.contains("unknown command \"compose\"")
+                    || stderr.contains("unknown command: compose"));
+
+            if is_unavailable {
+                if let Ok(fallback_out) = Command::new("docker-compose")
+                    .current_dir(dir)
+                    .args(args)
+                    .output()
+                {
+                    return Ok(fallback_out);
+                }
+            }
+            Ok(out)
+        }
+        Err(err) if err.kind() == std::io::ErrorKind::NotFound => {
+            // docker-Binary nicht gefunden, versuche docker-compose
             Command::new("docker-compose")
                 .current_dir(dir)
                 .args(args)
                 .output()
         }
+        Err(err) => Err(err),
     }
 }
 
@@ -126,7 +154,10 @@ pub fn pull_image(image: &str) -> Result<bool, String> {
 
     if !output.status.success() {
         let stderr = String::from_utf8_lossy(&output.stderr).trim().to_string();
-        return Err(format!("'docker pull {}' fehlgeschlagen: {}", image, stderr));
+        return Err(format!(
+            "'docker pull {}' fehlgeschlagen: {}",
+            image, stderr
+        ));
     }
 
     let stdout_str = String::from_utf8_lossy(&output.stdout);
@@ -159,22 +190,53 @@ pub fn restart_compose_service(dir: &Path, service_name: Option<&str>) -> Result
     Ok(())
 }
 
+/// Bereinigt ungenutzte Zwischen-Images via `docker image prune -f`.
+pub fn prune_images() -> Result<(), String> {
+    let output = run_docker_command(&["image", "prune", "-f"])
+        .map_err(|e| format!("Fehler beim Ausführen von 'docker image prune -f': {}", e))?;
+
+    if !output.status.success() {
+        let stderr = String::from_utf8_lossy(&output.stderr).trim().to_string();
+        return Err(format!(
+            "'docker image prune -f' fehlgeschlagen: {}",
+            stderr
+        ));
+    }
+
+    Ok(())
+}
+
 /// Prüft alle Unterverzeichnisse im konfigurierten Apps-Verzeichnis auf Aktualisierungen.
 pub fn run_updates() {
     let config = config::get_config();
     let apps_dir_path = Path::new(&config.general.apps_dir);
 
-    log("scanner", &format!("Überprüfe Anwendungsverzeichnis: {}", apps_dir_path.display()), LogLevel::Info);
+    log(
+        "scanner",
+        &format!(
+            "Überprüfe Anwendungsverzeichnis: {}",
+            apps_dir_path.display()
+        ),
+        LogLevel::Info,
+    );
 
     if !apps_dir_path.exists() {
-        log("scanner", &format!("Verzeichnis '{}' existiert nicht.", apps_dir_path.display()), LogLevel::Warn);
+        log(
+            "scanner",
+            &format!("Verzeichnis '{}' existiert nicht.", apps_dir_path.display()),
+            LogLevel::Warn,
+        );
         return;
     }
 
     let entries = match fs::read_dir(apps_dir_path) {
         Ok(e) => e,
         Err(e) => {
-            log("scanner", &format!("Fehler beim Lesen von '{}': {}", apps_dir_path.display(), e), LogLevel::Error);
+            log(
+                "scanner",
+                &format!("Fehler beim Lesen von '{}': {}", apps_dir_path.display(), e),
+                LogLevel::Error,
+            );
             return;
         }
     };
@@ -187,28 +249,58 @@ pub fn run_updates() {
     app_dirs.sort();
 
     if app_dirs.is_empty() {
-        log("scanner", &format!("Keine Unterverzeichnisse in '{}' gefunden.", apps_dir_path.display()), LogLevel::Info);
+        log(
+            "scanner",
+            &format!(
+                "Keine Unterverzeichnisse in '{}' gefunden.",
+                apps_dir_path.display()
+            ),
+            LogLevel::Info,
+        );
         return;
     }
 
     for app_dir in app_dirs {
         let app_name = app_dir.file_name().unwrap_or_default().to_string_lossy();
-        log("scanner", &format!("Untersuche Anwendung '{}'...", app_name), LogLevel::Info);
+        log(
+            "scanner",
+            &format!("Untersuche Anwendung '{}'...", app_name),
+            LogLevel::Info,
+        );
 
         let compose_file = match find_compose_file(&app_dir) {
             Some(f) => f,
             None => {
-                log("scanner", &format!("Keine Docker-Compose-Datei in '{}' gefunden. Überspringe.", app_dir.display()), LogLevel::Debug);
+                log(
+                    "scanner",
+                    &format!(
+                        "Keine Docker-Compose-Datei in '{}' gefunden. Überspringe.",
+                        app_dir.display()
+                    ),
+                    LogLevel::Debug,
+                );
                 continue;
             }
         };
 
-        log("compose", &format!("Gefundene Compose-Datei: {}", compose_file.display()), LogLevel::Debug);
+        log(
+            "compose",
+            &format!("Gefundene Compose-Datei: {}", compose_file.display()),
+            LogLevel::Debug,
+        );
 
         let services = match parse_compose_services(&compose_file) {
             Ok(s) => s,
             Err(e) => {
-                log("compose", &format!("Fehler beim Analysieren von '{}': {}", compose_file.display(), e), LogLevel::Warn);
+                log(
+                    "compose",
+                    &format!(
+                        "Fehler beim Analysieren von '{}': {}",
+                        compose_file.display(),
+                        e
+                    ),
+                    LogLevel::Warn,
+                );
                 continue;
             }
         };
@@ -217,40 +309,107 @@ pub fn run_updates() {
 
         for (service_name, image) in services {
             if !is_latest_image(&image) {
-                log("updater", &format!("Service '{}' verwendet kein :latest-Image ('{}'). Überspringe.", service_name, image), LogLevel::Debug);
+                log(
+                    "updater",
+                    &format!(
+                        "Service '{}' verwendet kein :latest-Image ('{}'). Überspringe.",
+                        service_name, image
+                    ),
+                    LogLevel::Debug,
+                );
                 continue;
             }
 
-            log("updater", &format!("Prüfe auf neues Image für Service '{}' ('{}')...", service_name, image), LogLevel::Info);
+            log(
+                "updater",
+                &format!(
+                    "Prüfe auf neues Image für Service '{}' ('{}')...",
+                    service_name, image
+                ),
+                LogLevel::Info,
+            );
 
             match pull_image(&image) {
                 Ok(true) => {
-                    log("updater", &format!("Neueres Image für Service '{}' ('{}') gefunden und heruntergeladen.", service_name, image), LogLevel::Info);
+                    log(
+                        "updater",
+                        &format!(
+                            "Neueres Image für Service '{}' ('{}') gefunden und heruntergeladen.",
+                            service_name, image
+                        ),
+                        LogLevel::Info,
+                    );
                     updated_any = true;
                 }
                 Ok(false) => {
-                    log("updater", &format!("Image für Service '{}' ('{}') ist bereits aktuell.", service_name, image), LogLevel::Info);
+                    log(
+                        "updater",
+                        &format!(
+                            "Image für Service '{}' ('{}') ist bereits aktuell.",
+                            service_name, image
+                        ),
+                        LogLevel::Info,
+                    );
                 }
                 Err(e) => {
-                    log("updater", &format!("Fehler beim Aktualisieren von Image '{}': {}", image, e), LogLevel::Error);
+                    log(
+                        "updater",
+                        &format!("Fehler beim Aktualisieren von Image '{}': {}", image, e),
+                        LogLevel::Error,
+                    );
                 }
             }
         }
 
         if updated_any {
-            log("updater", &format!("Starte Anwendung '{}' neu mit aktualisierten Images...", app_name), LogLevel::Info);
+            log(
+                "updater",
+                &format!(
+                    "Starte Anwendung '{}' neu mit aktualisierten Images...",
+                    app_name
+                ),
+                LogLevel::Info,
+            );
             match restart_compose_service(&app_dir, None) {
                 Ok(_) => {
-                    log("updater", &format!("Anwendung '{}' erfolgreich aktualisiert und neu gestartet.", app_name), LogLevel::Info);
+                    log(
+                        "updater",
+                        &format!(
+                            "Anwendung '{}' erfolgreich aktualisiert und neu gestartet.",
+                            app_name
+                        ),
+                        LogLevel::Info,
+                    );
                 }
                 Err(e) => {
-                    log("updater", &format!("Fehler beim Neustarten der Anwendung '{}': {}", app_name, e), LogLevel::Error);
+                    log(
+                        "updater",
+                        &format!("Fehler beim Neustarten der Anwendung '{}': {}", app_name, e),
+                        LogLevel::Error,
+                    );
                 }
             }
+
+            log(
+                "updater",
+                "Bereinige ungenutzte Docker-Images...",
+                LogLevel::Info,
+            );
+            if let Err(e) = prune_images() {
+                log(
+                    "updater",
+                    &format!("Fehler beim Bereinigen ungenutzter Docker-Images: {}", e),
+                    LogLevel::Warn,
+                );
+            }
         }
     }
 
-    log("scanner", "Aktualisierungsvorgang abgeschlossen.", LogLevel::Info);
+    log(
+        "scanner",
+        "Aktualisierungsvorgang abgeschlossen.",
+        LogLevel::Info,
+    );
 }
 
 #[cfg(test)]