CI: Fuegt automatisiertes Nightly-Release und Testing-Registry-Publish hinzu, behebt Zeitzone bei geplanten Workflows

- Neuer Workflow "nightly-pr.yaml": Erstellt und merged taeglich automatisch
  einen Pull Request von dev nach nightly (09:00 Uhr Europe/Berlin); legt den
  nightly-Branch bei Bedarf initial von dev an.
- Neuer Workflow "nightly.yaml": Testet, paketiert und veroeffentlicht bei
  Aenderungen auf nightly eine Pre-Release-Version (-nightly.<Zeitstempel>)
  in die Gitea Cargo Registry; erstellt bewusst kein Gitea-Release.
- testing.yaml veroeffentlicht nun zusaetzlich eine Pre-Release-Version
  (-testing.<Zeitstempel>) in die Gitea Cargo Registry, zusaetzlich zum
  bisherigen Preview-Release mit Crate-Anhang.
- Beide Versions-Suffixe sind SemVer-Pre-Releases, wodurch Renovates
  Standardverhalten (ignoreUnstable) sie automatisch ignoriert.
- CRON_TZ=Europe/Berlin in security-scan.yaml und trufflehog-scan.yaml
  ergaenzt: Gitea Actions interpretiert schedule-Cron sonst in der lokalen
  Zeitzone des Gitea-Servers statt in der beabsichtigten Zeitzone.

Co-Authored-By: Claude Sonnet 5 <noreply@anthropic.com>

.gitea/workflows/code-quality.yaml

@@ -24,16 +24,14 @@ jobs:
           components: clippy, rustfmt
           cache: false
 
+      # Ein rohes 'actions/cache' auf target/ liefert zwar einen technischen Cache-Hit (Dateien
+      # werden wiederhergestellt), Cargo kompiliert die Abhängigkeiten aber oft trotzdem neu:
+      # Der tar-basierte Restore-Vorgang setzt bei allen wiederhergestellten Dateien dieselbe
+      # Mtime, wodurch Cargos Fingerprinting nicht mehr zuverlässig erkennen kann, was
+      # älter/neuer als was ist, und sicherheitshalber alles neu baut. Swatinem/rust-cache ist
+      # genau dafür gebaut (u. a. gezielte Mtime-Korrektur nach dem Restore).
       - name: Cache Cargo-Abhängigkeiten & Build-Artefakte
-        uses: actions/cache@v6
+        uses: Swatinem/rust-cache@v2
-        with:
-          path: |
-            ~/.cargo/registry
-            ~/.cargo/git
-            target
-          key: cargo-${{ runner.os }}-${{ hashFiles('Cargo.lock') }}
-          restore-keys: |
-            cargo-${{ runner.os }}-
 
       - name: Formatierung automatisch beheben
         run: cargo fmt

.gitea/workflows/main.yaml

@@ -54,16 +54,14 @@ jobs:
           toolchain: stable
           cache: false
 
+      # Ein rohes 'actions/cache' auf target/ liefert zwar einen technischen Cache-Hit (Dateien
+      # werden wiederhergestellt), Cargo kompiliert die Abhängigkeiten aber oft trotzdem neu:
+      # Der tar-basierte Restore-Vorgang setzt bei allen wiederhergestellten Dateien dieselbe
+      # Mtime, wodurch Cargos Fingerprinting nicht mehr zuverlässig erkennen kann, was
+      # älter/neuer als was ist, und sicherheitshalber alles neu baut. Swatinem/rust-cache ist
+      # genau dafür gebaut (u. a. gezielte Mtime-Korrektur nach dem Restore).
       - name: Cache Cargo-Abhängigkeiten & Build-Artefakte
-        uses: actions/cache@v6
+        uses: Swatinem/rust-cache@v2
-        with:
-          path: |
-            ~/.cargo/registry
-            ~/.cargo/git
-            target
-          key: cargo-${{ runner.os }}-${{ hashFiles('Cargo.lock') }}
-          restore-keys: |
-            cargo-${{ runner.os }}-
 
       - name: Run Tests
         run: |

.gitea/workflows/nightly-pr.yaml

@@ -0,0 +1,91 @@
+name: Nightly Auto-Merge (Dev → Nightly)
+
+on:
+  schedule:
+    # Gitea Actions interpretiert 'schedule'-Cron standardmaessig in der lokalen
+    # Zeitzone des Gitea-Servers (anders als GitHub Actions, das immer UTC nutzt).
+    # Das CRON_TZ-Praefix ist eine Gitea-Erweiterung und legt die Zeitzone explizit
+    # und DST-sicher fest, unabhaengig von der Server-Konfiguration.
+    - cron: "CRON_TZ=Europe/Berlin 0 9 * * *"
+  workflow_dispatch:
+
+jobs:
+  merge-dev-into-nightly:
+    name: Erstelle & merge automatisch PR von dev nach nightly
+    runs-on: ubuntu-latest
+    steps:
+      - name: Checkout Repository
+        uses: actions/checkout@v7
+        with:
+          fetch-depth: 0
+          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 }}
+
+      - name: Stelle sicher, dass der nightly-Branch existiert
+        run: |
+          git fetch origin dev
+          if git ls-remote --exit-code --heads origin nightly > /dev/null 2>&1; then
+            echo "nightly-Branch existiert bereits."
+          else
+            echo "nightly-Branch existiert noch nicht, erstelle ihn initial von dev..."
+            git push origin origin/dev:refs/heads/nightly
+          fi
+
+      - name: Prüfe auf Unterschiede zwischen dev und nightly
+        id: diff
+        run: |
+          git fetch origin nightly
+          if git diff --quiet origin/nightly origin/dev; then
+            echo "Keine Unterschiede zwischen dev und nightly, überspringe."
+            echo "has_changes=false" >> "$GITHUB_OUTPUT"
+          else
+            echo "has_changes=true" >> "$GITHUB_OUTPUT"
+          fi
+
+      - name: Prüfe auf bereits offenen PR nach nightly
+        id: check_pr
+        if: steps.diff.outputs.has_changes == 'true'
+        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: |
+          OPEN_PRS=$(curl -s -H "Authorization: token ${TOKEN}" "${GITEA_URL}/api/v1/repos/${REPO}/pulls?state=open&limit=50")
+          PR_NUMBER=$(echo "$OPEN_PRS" | jq -r '[.[] | select(.base.ref == "nightly" and .head.ref == "dev")][0].number // empty')
+          echo "Bereits offener dev→nightly PR: ${PR_NUMBER:-keiner}"
+          echo "pr_number=${PR_NUMBER}" >> "$GITHUB_OUTPUT"
+
+      - name: Erstelle PR (dev -> nightly)
+        id: create_pr
+        if: steps.diff.outputs.has_changes == 'true' && steps.check_pr.outputs.pr_number == ''
+        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: |
+          DATE="$(date -u +%Y-%m-%d)"
+          PAYLOAD=$(jq -n --arg title "Nightly-Build: Merge dev in nightly (${DATE})" --arg head "dev" --arg base "nightly" \
+            '{title: $title, head: $head, base: $base}')
+          RESP=$(curl -f -s -S -X POST \
+            -H "Authorization: token ${TOKEN}" \
+            -H "Content-Type: application/json" \
+            -d "$PAYLOAD" \
+            "${GITEA_URL}/api/v1/repos/${REPO}/pulls")
+          PR_NUMBER=$(echo "$RESP" | jq -r '.number')
+          echo "PR #${PR_NUMBER} erstellt."
+          echo "pr_number=${PR_NUMBER}" >> "$GITHUB_OUTPUT"
+
+      - name: Merge PR automatisch
+        if: steps.diff.outputs.has_changes == 'true'
+        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 }}
+          PR_NUMBER: ${{ steps.create_pr.outputs.pr_number || steps.check_pr.outputs.pr_number }}
+        run: |
+          echo "Merge PR #${PR_NUMBER} automatisch (dev -> nightly)..."
+          curl -f -s -S -X POST \
+            -H "Authorization: token ${TOKEN}" \
+            -H "Content-Type: application/json" \
+            -d '{"Do": "merge"}' \
+            "${GITEA_URL}/api/v1/repos/${REPO}/pulls/${PR_NUMBER}/merge"
+          echo "PR #${PR_NUMBER} erfolgreich gemerged."

.gitea/workflows/nightly.yaml

@@ -0,0 +1,97 @@
+name: Nightly Build & Publish
+
+on:
+  push:
+    branches:
+      - nightly
+
+jobs:
+  detect-changes:
+    name: Erkenne relevante Code-Änderungen
+    runs-on: ubuntu-latest
+    outputs:
+      code_changed: ${{ steps.filter.outputs.code }}
+    steps:
+      - name: Checkout Repository
+        uses: actions/checkout@v7
+
+      - name: Prüfe auf Änderungen am Programmcode
+        uses: dorny/paths-filter@v4
+        id: filter
+        with:
+          filters: |
+            code:
+              - 'src/**'
+              - 'Cargo.toml'
+              - 'Cargo.lock'
+              - 'scripts/**'
+              - '.cargo/**'
+              - '.gitea/workflows/nightly.yaml'
+
+  build-and-publish:
+    name: Build & Publish Nightly-Crate zur Gitea Registry
+    needs: detect-changes
+    if: needs.detect-changes.outputs.code_changed == 'true'
+    runs-on: ubuntu-latest
+    steps:
+      - name: Checkout Repository
+        uses: actions/checkout@v7
+
+      - name: Install Rust Toolchain
+        uses: actions-rust-lang/setup-rust-toolchain@v2
+        with:
+          toolchain: stable
+          cache: false
+
+      - name: Cache Cargo-Abhängigkeiten & Build-Artefakte
+        uses: Swatinem/rust-cache@v2
+
+      - name: Run Tests
+        run: |
+          cargo test
+
+      - name: Compiler Check
+        run: |
+          cargo check --all-targets
+
+      # Nightly-Builds duerfen nie als regulaeres Update erscheinen: Ein SemVer-Pre-Release-
+      # Suffix (-nightly.<Zeitstempel>) sorgt dafuer, dass Renovates Standardverhalten
+      # (ignoreUnstable: true) diese Version automatisch ignoriert, solange die Basis-Version
+      # in Cargo.toml selbst kein Pre-Release ist. Die Aenderung ist rein fuer den Build-
+      # Workspace bestimmt und wird nie zurueck in den Branch committet.
+      - name: Ermittle & setze Nightly-Version (temporär, wird nicht committet)
+        id: nightly_version
+        run: |
+          BASE_VERSION="$(sed -n 's/^version = "\(.*\)"/\1/p' Cargo.toml | head -n1)"
+          TIMESTAMP="$(date -u +%Y%m%d%H%M)"
+          NIGHTLY_VERSION="${BASE_VERSION}-nightly.${TIMESTAMP}"
+          echo "Basis-Version: ${BASE_VERSION} -> Nightly-Version: ${NIGHTLY_VERSION}"
+          sed -i "0,/^version = \"${BASE_VERSION}\"/s//version = \"${NIGHTLY_VERSION}\"/" Cargo.toml
+          echo "version=${NIGHTLY_VERSION}" >> "$GITHUB_OUTPUT"
+
+      - name: Package Crate
+        run: |
+          cargo package --allow-dirty
+
+      - name: Publish Nightly-Crate zur 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: |
+          mkdir -p ~/.cargo
+          cat <<EOF > ~/.cargo/config.toml
+          [registries.gitea]
+          index = "sparse+${GITEA_URL}/api/packages/${REPO_OWNER}/cargo/"
+          EOF
+
+          cat <<EOF > ~/.cargo/credentials.toml
+          [registries.gitea]
+          token = "Bearer ${TOKEN}"
+          EOF
+
+          export CARGO_REGISTRIES_GITEA_INDEX="sparse+${GITEA_URL}/api/packages/${REPO_OWNER}/cargo/"
+          export CARGO_REGISTRIES_GITEA_TOKEN="Bearer ${TOKEN}"
+
+          echo "Veröffentliche Nightly-Crate ${{ steps.nightly_version.outputs.version }} in Gitea Cargo Package Registry..."
+          cargo publish --registry gitea --allow-dirty

.gitea/workflows/renovate.yaml

@@ -9,7 +9,7 @@ jobs:
   renovate:
     name: Dependency-Updates prüfen & Pull Requests erstellen
     runs-on: ubuntu-latest
-    container: ghcr.io/renovatebot/renovate:44.82.0
+    container: ghcr.io/renovatebot/renovate:44.103.6
     steps:
       - name: Renovate ausführen
         run: renovate

.gitea/workflows/security-scan.yaml

@@ -8,7 +8,7 @@ on:
       - dev
   pull_request:
   schedule:
-    - cron: "0 5 * * 1"
+    - cron: "CRON_TZ=Europe/Berlin 0 5 * * 1"
   workflow_dispatch:
 
 jobs:
@@ -17,7 +17,7 @@ jobs:
     runs-on: ubuntu-latest
     env:
       TRIVY_VERSION: "0.74.0"
-      OSV_SCANNER_VERSION: "2.5.1"
+      OSV_SCANNER_VERSION: "2.6.0"
     steps:
       - name: Checkout Repository
         uses: actions/checkout@v7

.gitea/workflows/testing-to-main-pr.yaml

@@ -0,0 +1,111 @@
+name: Auto-PR (Testing → Main)
+
+on:
+  push:
+    branches:
+      - testing
+
+jobs:
+  create-pr:
+    name: Erstelle automatisch PR von testing nach main
+    runs-on: ubuntu-latest
+    steps:
+      - name: Checkout Repository
+        uses: actions/checkout@v7
+        with:
+          fetch-depth: 0
+
+      - name: Prüfe auf bereits offenen PR nach main
+        id: check_pr
+        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: |
+          OPEN_PRS=$(curl -s -H "Authorization: token ${TOKEN}" "${GITEA_URL}/api/v1/repos/${REPO}/pulls?state=open&limit=50")
+          EXISTS=$(echo "$OPEN_PRS" | jq -r '[.[] | select(.base.ref == "main" and .head.ref == "testing")] | length')
+          echo "Bereits offene testing→main PRs: ${EXISTS}"
+          echo "exists=${EXISTS}" >> "$GITHUB_OUTPUT"
+
+      - name: Ermittle Versionen auf main & testing
+        id: versions
+        if: steps.check_pr.outputs.exists == '0'
+        run: |
+          git fetch origin main
+          MAIN_VERSION="$(git show origin/main:Cargo.toml | sed -n 's/^version = "\(.*\)"/\1/p' | head -n1)"
+          TESTING_VERSION="$(sed -n 's/^version = "\(.*\)"/\1/p' Cargo.toml | head -n1)"
+          echo "Version auf main: ${MAIN_VERSION} / Version auf testing: ${TESTING_VERSION}"
+          echo "main_version=${MAIN_VERSION}" >> "$GITHUB_OUTPUT"
+          echo "testing_version=${TESTING_VERSION}" >> "$GITHUB_OUTPUT"
+
+      - name: Ermittle geänderte Kategorien (main...testing)
+        id: categories
+        if: steps.check_pr.outputs.exists == '0' && steps.versions.outputs.main_version == steps.versions.outputs.testing_version
+        run: |
+          CHANGED_FILES="$(git diff --name-only origin/main...HEAD)"
+          echo "Geänderte Dateien main...testing:"
+          echo "$CHANGED_FILES"
+
+          WORKFLOWS="false"
+          CONFIG="false"
+          DOCS="false"
+
+          if echo "$CHANGED_FILES" | grep -q '^\.gitea/workflows/'; then
+            WORKFLOWS="true"
+          fi
+          if echo "$CHANGED_FILES" | grep -qE '^(renovate\.json|qodana\.yaml|Cargo\.toml|Cargo\.lock|\.cargo/)'; then
+            CONFIG="true"
+          fi
+          if echo "$CHANGED_FILES" | grep -qE '(^|/)[^/]+\.md$|^LICENSE$'; then
+            DOCS="true"
+          fi
+
+          echo "workflows=${WORKFLOWS}" >> "$GITHUB_OUTPUT"
+          echo "config=${CONFIG}" >> "$GITHUB_OUTPUT"
+          echo "docs=${DOCS}" >> "$GITHUB_OUTPUT"
+
+      - name: Bestimme PR-Titel
+        id: title
+        if: steps.check_pr.outputs.exists == '0'
+        run: |
+          if [ "${{ steps.versions.outputs.main_version }}" != "${{ steps.versions.outputs.testing_version }}" ]; then
+            TITLE="Merge testing in main: Release ${{ steps.versions.outputs.testing_version }}"
+          else
+            PARTS=()
+            [ "${{ steps.categories.outputs.workflows }}" = "true" ] && PARTS+=("Workflows")
+            [ "${{ steps.categories.outputs.config }}" = "true" ] && PARTS+=("Konfigurationen")
+            [ "${{ steps.categories.outputs.docs }}" = "true" ] && PARTS+=("Dokumentation")
+
+            if [ ${#PARTS[@]} -eq 0 ]; then
+              TITLE="Merge testing in main"
+            else
+              JOINED=""
+              for PART in "${PARTS[@]}"; do
+                if [ -z "$JOINED" ]; then
+                  JOINED="$PART"
+                else
+                  JOINED="${JOINED} & ${PART}"
+                fi
+              done
+              TITLE="Merge testing in main: ${JOINED} aktualisiert"
+            fi
+          fi
+          echo "Ermittelter PR-Titel: ${TITLE}"
+          echo "title=${TITLE}" >> "$GITHUB_OUTPUT"
+
+      - name: Erstelle PR (testing -> main)
+        if: steps.check_pr.outputs.exists == '0'
+        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 }}
+          TITLE: ${{ steps.title.outputs.title }}
+        run: |
+          PAYLOAD=$(jq -n --arg title "$TITLE" --arg head "testing" --arg base "main" \
+            '{title: $title, head: $head, base: $base}')
+          curl -f -s -S -X POST \
+            -H "Authorization: token ${TOKEN}" \
+            -H "Content-Type: application/json" \
+            -d "$PAYLOAD" \
+            "${GITEA_URL}/api/v1/repos/${REPO}/pulls"
+          echo "PR erstellt: ${TITLE}"

.gitea/workflows/testing.yaml

@@ -43,16 +43,14 @@ jobs:
           toolchain: stable
           cache: false
 
+      # Ein rohes 'actions/cache' auf target/ liefert zwar einen technischen Cache-Hit (Dateien
+      # werden wiederhergestellt), Cargo kompiliert die Abhängigkeiten aber oft trotzdem neu:
+      # Der tar-basierte Restore-Vorgang setzt bei allen wiederhergestellten Dateien dieselbe
+      # Mtime, wodurch Cargos Fingerprinting nicht mehr zuverlässig erkennen kann, was
+      # älter/neuer als was ist, und sicherheitshalber alles neu baut. Swatinem/rust-cache ist
+      # genau dafür gebaut (u. a. gezielte Mtime-Korrektur nach dem Restore).
       - name: Cache Cargo-Abhängigkeiten & Build-Artefakte
-        uses: actions/cache@v6
+        uses: Swatinem/rust-cache@v2
-        with:
-          path: |
-            ~/.cargo/registry
-            ~/.cargo/git
-            target
-          key: cargo-${{ runner.os }}-${{ hashFiles('Cargo.lock') }}
-          restore-keys: |
-            cargo-${{ runner.os }}-
 
       - name: Run Tests
         run: |
@@ -62,9 +60,54 @@ jobs:
         run: |
           cargo check --all-targets
 
+      - name: Ermittle Basis-Version (für Release-Tag)
+        id: base_version
+        run: |
+          BASE_VERSION="$(sed -n 's/^version = "\(.*\)"/\1/p' Cargo.toml | head -n1)"
+          echo "version=${BASE_VERSION}" >> "$GITHUB_OUTPUT"
+
+      # Testing-Builds duerfen nie als regulaeres Update erscheinen: Ein SemVer-Pre-Release-
+      # Suffix (-testing.<Zeitstempel>) sorgt dafuer, dass Renovates Standardverhalten
+      # (ignoreUnstable: true) diese Version automatisch ignoriert, solange die Basis-Version
+      # in Cargo.toml selbst kein Pre-Release ist. Die Aenderung ist rein fuer den Build-
+      # Workspace bestimmt und wird nie zurueck in den Branch committet; der Release-Tag
+      # weiter unten nutzt bewusst die zuvor ermittelte Basis-Version, damit er stabil bleibt.
+      - name: Ermittle & setze Testing-Version (temporär, wird nicht committet)
+        id: testing_version
+        run: |
+          BASE_VERSION="${{ steps.base_version.outputs.version }}"
+          TIMESTAMP="$(date -u +%Y%m%d%H%M)"
+          TESTING_VERSION="${BASE_VERSION}-testing.${TIMESTAMP}"
+          echo "Basis-Version: ${BASE_VERSION} -> Testing-Version: ${TESTING_VERSION}"
+          sed -i "0,/^version = \"${BASE_VERSION}\"/s//version = \"${TESTING_VERSION}\"/" Cargo.toml
+          echo "version=${TESTING_VERSION}" >> "$GITHUB_OUTPUT"
+
       - name: Package Crate
         run: |
-          cargo package
+          cargo package --allow-dirty
+
+      - name: Publish Testing-Crate zur 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: |
+          mkdir -p ~/.cargo
+          cat <<EOF > ~/.cargo/config.toml
+          [registries.gitea]
+          index = "sparse+${GITEA_URL}/api/packages/${REPO_OWNER}/cargo/"
+          EOF
+
+          cat <<EOF > ~/.cargo/credentials.toml
+          [registries.gitea]
+          token = "Bearer ${TOKEN}"
+          EOF
+
+          export CARGO_REGISTRIES_GITEA_INDEX="sparse+${GITEA_URL}/api/packages/${REPO_OWNER}/cargo/"
+          export CARGO_REGISTRIES_GITEA_TOKEN="Bearer ${TOKEN}"
+
+          echo "Veröffentliche Testing-Crate ${{ steps.testing_version.outputs.version }} in Gitea Cargo Package Registry..."
+          cargo publish --registry gitea --allow-dirty
 
       - name: Create Gitea Pre-Release and Upload Assets
         env:
@@ -73,7 +116,7 @@ jobs:
           REPO_NAME: ${{ gitea.repository_name || github.event.repository.name }}
           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)"
+          VERSION="${{ steps.base_version.outputs.version }}"
           TAG_NAME="v${VERSION}-preview"
           RELEASE_TITLE="Preview Release ${TAG_NAME}"
           RELEASE_NOTES="Automatisches Preview-Release für ${REPO_NAME} Crate ${VERSION} (Branch: Testing)."

.gitea/workflows/trufflehog-scan.yaml

@@ -4,7 +4,7 @@ on:
   push:
   pull_request:
   schedule:
-    - cron: "0 6 * * 1"
+    - cron: "CRON_TZ=Europe/Berlin 0 6 * * 1"
   workflow_dispatch:
 
 jobs:
@@ -12,7 +12,7 @@ jobs:
     name: TruffleHog
     runs-on: ubuntu-latest
     env:
-      TRUFFLEHOG_VERSION: "3.97.4"
+      TRUFFLEHOG_VERSION: "3.97.5"
     steps:
       - name: Checkout Repository
         uses: actions/checkout@v7

.gitea/workflows/unit-tests.yaml

@@ -8,6 +8,7 @@ on:
       - reopened
     branches:
       - testing
+      - dev
 
 jobs:
   test:
@@ -23,16 +24,14 @@ jobs:
           toolchain: stable
           cache: false
 
+      # Ein rohes 'actions/cache' auf target/ liefert zwar einen technischen Cache-Hit (Dateien
+      # werden wiederhergestellt), Cargo kompiliert die Abhängigkeiten aber oft trotzdem neu:
+      # Der tar-basierte Restore-Vorgang setzt bei allen wiederhergestellten Dateien dieselbe
+      # Mtime, wodurch Cargos Fingerprinting nicht mehr zuverlässig erkennen kann, was
+      # älter/neuer als was ist, und sicherheitshalber alles neu baut. Swatinem/rust-cache ist
+      # genau dafür gebaut (u. a. gezielte Mtime-Korrektur nach dem Restore).
       - name: Cache Cargo-Abhängigkeiten & Build-Artefakte
-        uses: actions/cache@v6
+        uses: Swatinem/rust-cache@v2
-        with:
-          path: |
-            ~/.cargo/registry
-            ~/.cargo/git
-            target
-          key: cargo-${{ runner.os }}-${{ hashFiles('Cargo.lock') }}
-          restore-keys: |
-            cargo-${{ runner.os }}-
 
       - name: Run Tests
         run: cargo test

Cargo.lock

@@ -10,7 +10,7 @@ checksum = "9330f8b2ff13f34540b44e946ef35111825727b38d33286ef986142615121801"
 
 [[package]]
 name = "config-ctdra"
-version = "1.0.5"
+version = "1.0.6"
 dependencies = [
  "confy",
  "program-ctdra",

Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "config-ctdra"
-version = "1.0.5"
+version = "1.0.6"
 edition = "2024"
 authors = ['DragonSlayer_14']
 readme = "README.md"

renovate.json

@@ -1,29 +1,59 @@
 {
   "$schema": "https://docs.renovatebot.com/renovate-schema.json",
-  "extends": ["config:recommended"],
+  "extends": [
+    "config:recommended"
+  ],
   "timezone": "Europe/Berlin",
-  "schedule": ["before 6am on monday"],
+  "schedule": [
+    "before 6am"
+  ],
   "baseBranchPatterns": [
     "dev"
   ],
   "packageRules": [
     {
-      "matchFileNames": [".gitea/workflows/**"],
+      "matchFileNames": [
+        ".gitea/workflows/**"
+      ],
       "groupName": "Gitea Actions",
       "separateMajorMinor": false,
       "separateMinorPatch": false
     },
     {
-      "matchManagers": ["cargo"],
+      "matchManagers": [
+        "cargo"
+      ],
       "groupName": "Cargo Dependencies",
       "separateMajorMinor": false,
       "separateMinorPatch": false
     },
     {
-      "matchManagers": ["dockerfile", "docker-compose"],
+      "matchManagers": [
+        "dockerfile",
+        "docker-compose"
+      ],
       "groupName": "Docker-Images",
       "separateMajorMinor": false,
       "separateMinorPatch": false
+    },
+    {
+      "description": "Patch-/Minor-/Digest-Updates automatisch mergen, sobald alle CI-Checks (inkl. Unit-Tests) erfolgreich sind - Major-Updates sind unten explizit ausgenommen (siehe nächste Regel).",
+      "matchUpdateTypes": [
+        "patch",
+        "minor",
+        "digest",
+        "lockFileMaintenance"
+      ],
+      "automerge": true,
+      "automergeType": "pr",
+      "platformAutomerge": true
+    },
+    {
+      "description": "Major-Updates immer manuell prüfen, da potenziell brechende Änderungen.",
+      "matchUpdateTypes": [
+        "major"
+      ],
+      "automerge": false
     }
   ],
   "customManagers": [