claude-desktop/.forgejo/workflows/build-appimage.yml

# Claude Desktop — AppImage Build Pipeline
# Triggert bei [appimage] im Commit oder bei Release-Tags (v*)
# Runner: data-it/forgejo-runner mit Rust + GTK vorinstalliert

name: Build AppImage

on:
  push:
    tags:
      - 'v*'
    branches:
      - main

jobs:
  build:
    # Laeuft auf dem Debian-Runner (16-Forgejo-Runner-AppImage) - glibc fuer linuxdeploy
    runs-on: appimage
    if: contains(github.event.head_commit.message, '[appimage]') || startsWith(github.ref, 'refs/tags/v')

    steps:
      - name: Checkout
        run: |
          git clone --depth 1 --branch "${GITHUB_REF_NAME}" \
            "https://oauth2:${{ secrets.REGISTRY_TOKEN }}@git.data-it-solution.de/${GITHUB_REPOSITORY}.git" .          

      - name: Show Rust Version
        run: |
          rustc --version
          cargo --version          

      - name: Install npm packages
        run: npm ci

      - name: Build Tauri App
        run: |
          npm run tauri build -- --bundles appimage
          ls -la src-tauri/target/release/bundle/appimage/          

      - name: Patch AppRun fuer NixOS-Support + Re-Bundle
        run: |
          set -e
          BUNDLE_DIR=src-tauri/target/release/bundle/appimage
          APPDIR=$(ls -d "$BUNDLE_DIR"/*.AppDir | head -1)
          OLD_APPIMAGE=$(ls "$BUNDLE_DIR"/*.AppImage | head -1)
          OLD_NAME=$(basename "$OLD_APPIMAGE")

          echo "AppDir: $APPDIR"
          echo "Original AppImage: $OLD_NAME"

          # Original AppRun sichern + ueberhaupt: das linuxdeploy-Original
          # ist sehr klein, laedt einen Hook (linuxdeploy-plugin-gtk.sh) der
          # ALLE ENV-Vars korrekt setzt (LD_LIBRARY_PATH, WEBKIT_EXEC_PATH,
          # GDK_PIXBUF etc.), dann ruft es AppRun.wrapped auf.
          # Wir ergaenzen davor nur unsere NixOS+WebKit-Workarounds.
          cp "$APPDIR/AppRun" "$APPDIR/AppRun.original"

          cat > "$APPDIR/AppRun" << 'APPRUN_EOF'
          #!/bin/bash
          HERE="$(readlink -f "$(dirname "$0")")"

          # --- NixOS-Detection ---
          # Host-Mesa unter /run/opengl-driver bevorzugen,
          # weil bundled Mesa gegen NixOS-Treiber kollidiert
          if [ -d /run/opengl-driver/lib ]; then
            export LD_LIBRARY_PATH="/run/opengl-driver/lib:${LD_LIBRARY_PATH}"
          fi

          # --- WebKit-Workarounds ---
          # fuer problematische GPU/Compositor-Stacks (Wayland-Bugs, NVIDIA, etc.)
          # Nur setzen wenn User nichts vorgegeben hat (override moeglich).
          : "${WEBKIT_DISABLE_DMABUF_RENDERER:=1}"
          : "${WEBKIT_DISABLE_COMPOSITING_MODE:=1}"
          export WEBKIT_DISABLE_DMABUF_RENDERER WEBKIT_DISABLE_COMPOSITING_MODE

          # --- Original linuxdeploy-Logik (1:1 wie AppRun.original) ---
          set -e
          source "$HERE"/apprun-hooks/linuxdeploy-plugin-gtk.sh
          exec "$HERE"/AppRun.wrapped "$@"
          APPRUN_EOF
          chmod +x "$APPDIR/AppRun"

          echo "--- neuer AppRun ---"
          cat "$APPDIR/AppRun"

          # Altes AppImage weg, neu packen mit appimagetool
          rm "$OLD_APPIMAGE"
          appimagetool --no-appstream "$APPDIR" "$BUNDLE_DIR/$OLD_NAME"

          ls -la "$BUNDLE_DIR/"          

      - name: Get Version
        id: version
        run: |
          VERSION=$(grep '^version' src-tauri/Cargo.toml | head -1 | sed 's/.*"\(.*\)"/\1/')
          echo "version=${VERSION}" >> $GITHUB_OUTPUT
          echo "Version: ${VERSION}"          

      - name: Upload to Package Registry
        run: |
          set -e
          ORIG=$(ls src-tauri/target/release/bundle/appimage/*.AppImage | head -1)
          # Tauri benennt mit "Claude Desktop_..." (Leerzeichen) -> URL-unsicher.
          # Umbenennen zu "Claude-Desktop_..." vor dem Upload.
          SAFE_NAME=$(basename "$ORIG" | tr ' ' '-')
          APPIMAGE="$(dirname "$ORIG")/$SAFE_NAME"
          mv "$ORIG" "$APPIMAGE"
          FILENAME="$SAFE_NAME"
          VERSION=$(grep '^version' src-tauri/Cargo.toml | head -1 | sed 's/.*"\(.*\)"/\1/')

          echo "Lade $FILENAME (v${VERSION}) in Package Registry..."

          BASE="https://git.data-it-solution.de/api/packages/data/generic/claude-desktop"

          # Latest + versionierte Datei loeschen falls vorhanden
          # (Forgejo Package Registry weist PUT auf existierenden Pfad mit 409 ab)
          curl -sS -X DELETE \
            --user "data:${{ secrets.REGISTRY_TOKEN }}" \
            "${BASE}/latest/${FILENAME}" >/dev/null 2>&1 || true
          curl -sS -X DELETE \
            --user "data:${{ secrets.REGISTRY_TOKEN }}" \
            "${BASE}/${VERSION}/${FILENAME}" >/dev/null 2>&1 || true

          # Versioniert hochladen
          curl --fail -sS -X PUT \
            --user "data:${{ secrets.REGISTRY_TOKEN }}" \
            --upload-file "$APPIMAGE" \
            "${BASE}/${VERSION}/${FILENAME}"

          # Latest hochladen
          curl --fail -sS -X PUT \
            --user "data:${{ secrets.REGISTRY_TOKEN }}" \
            --upload-file "$APPIMAGE" \
            "${BASE}/latest/${FILENAME}"

          echo "Upload abgeschlossen: ${FILENAME} (v${VERSION})"          

      - name: Upload to Release
        if: startsWith(github.ref, 'refs/tags/v')
        run: |
          set -e
          # AppImage wurde im vorherigen Step schon umbenannt (Leerzeichen -> -)
          APPIMAGE=$(ls src-tauri/target/release/bundle/appimage/*.AppImage | head -1)
          FILENAME=$(basename "$APPIMAGE")
          TAG="${GITHUB_REF#refs/tags/}"

          echo "Lade $FILENAME zu Release $TAG hoch..."

          # Release erstellen falls nicht vorhanden
          curl -s -X POST \
            -H "Authorization: token ${{ secrets.REGISTRY_TOKEN }}" \
            -H "Content-Type: application/json" \
            "https://git.data-it-solution.de/api/v1/repos/${GITHUB_REPOSITORY}/releases" \
            -d "{\"tag_name\":\"${TAG}\",\"name\":\"${TAG}\",\"body\":\"Release ${TAG}\"}" || true

          # Release-ID holen
          RELEASE_ID=$(curl -s \
            -H "Authorization: token ${{ secrets.REGISTRY_TOKEN }}" \
            "https://git.data-it-solution.de/api/v1/repos/${GITHUB_REPOSITORY}/releases/tags/${TAG}" \
            | grep -o '"id":[0-9]*' | head -1 | sed 's/"id"://')

          echo "Release-ID: $RELEASE_ID"

          # AppImage hochladen
          curl -s -X POST \
            -H "Authorization: token ${{ secrets.REGISTRY_TOKEN }}" \
            -H "Content-Type: application/octet-stream" \
            "https://git.data-it-solution.de/api/v1/repos/${GITHUB_REPOSITORY}/releases/${RELEASE_ID}/assets?name=${FILENAME}" \
            --data-binary "@${APPIMAGE}"

          echo "Upload abgeschlossen: ${FILENAME}"