Merge pull request 'Merge Feature/gitea-actions in dev' (#1) from feature/gitea-actions into dev

Reviewed-on: #1

.gitea/workflows/dev.yml

@@ -0,0 +1,151 @@
+name: Dev Build, Publish & Preview Release
+
+on:
+  push:
+    branches:
+      - dev
+
+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
+
+      - name: Install Packaging Tools
+        run: |
+          cargo install cargo-deb cargo-generate-rpm --locked
+
+      - 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.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.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: dev)."
+
+          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": "dev",
+            "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

.gitea/workflows/main.yml

@@ -0,0 +1,151 @@
+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@v4
+
+      - name: Install Rust Toolchain
+        uses: actions-rust-lang/setup-rust-toolchain@v1
+        with:
+          toolchain: stable
+
+      - name: Install Packaging Tools
+        run: |
+          cargo install cargo-deb cargo-generate-rpm --locked
+
+      - 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.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.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

.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/dev.yml" />
+                  </Item>
+                  <Item>
+                    <option name="path" value=".gitea/workflows/main.yml" />
+                  </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/
+│       ├── dev.yml     # CI/CD für dev-Branch (Tests, Testing-Packages & Preview-Release)
+│       └── main.yml    # 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,9 +38,10 @@ 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
+│       └── docker-update.spec  # RPM-Spec für Fedora / RHEL / CentOS
 └── src/
     ├── main.rs         # Einstiegspunkt, Root-Prüfung, Ausführung
     ├── program.rs      # Hilfsfunktion zur Programmnamensermittlung
@@ -70,6 +75,17 @@ DockerUpdate/
 - **`src/sudo.rs`**:
     - `is_run_as_root()`: Nutzt `libc::geteuid() == 0`.
     - `run_as_root()`: Führt `sudo <args>` per `exec` aus.
+- **`.gitea/workflows/`**:
+    - `dev.yml`: Führt bei Push auf `dev` 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.yml`: 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 +104,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 +124,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]`,
-   `[package.metadata.generate-rpm]`), `packaging/arch/PKGBUILD` und `packaging/fedora/docker-update.spec` entsprechend
-   aktualisiert werden.
+   Werden Abhängigkeiten, Metadaten oder Assets geändert, müssen `Cargo.toml` (`[package.metadata.deb]`,
+   `[package.metadata.generate-rpm]`), `packaging/arch/PKGBUILD`, `packaging/arch/build-package.sh` und
+   `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 `dev`-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 / Dev)
+
+```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 / Dev)
+
+```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 / Dev)
+
+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/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)
-        .map_err(|e| format!("Fehler beim Lesen der Datei '{}': {}", compose_path.display(), e))?;
+    let content = fs::read_to_string(compose_path).map_err(|e| {
+        format!(
+            "Fehler beim Lesen der Datei '{}': {}",
+            compose_path.display(),
+            e
+        )
+    })?;
 
-    let compose: ComposeFile = serde_yaml::from_str(&content)
-        .map_err(|e| format!("Fehler beim Parsen der YAML-Datei '{}': {}", compose_path.display(), e))?;
+    let compose: ComposeFile = serde_yaml::from_str(&content).map_err(|e| {
+        format!(
+            "Fehler beim Parsen der YAML-Datei '{}': {}",
+            compose_path.display(),
+            e
+        )
+    })?;
 
     let mut services = Vec::new();
     for (service_name, config) in compose.services {
@@ -126,7 +136,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 +172,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 +231,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 +291,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)]