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 (falls Tauri spaeter mehr reinpackt)
          cp "$APPDIR/AppRun" "$APPDIR/AppRun.original"

          # Custom AppRun: NixOS-Detection + WebKit-Workarounds
          cat > "$APPDIR/AppRun" << 'APPRUN_EOF'
          #!/bin/bash
          HERE="$(dirname "$(readlink -f "${0}")")"

          # NixOS: 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.
          # 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

          # Standard-AppImage-Runtime (analog zu linuxdeploy-Default)
          export PATH="${HERE}/usr/bin:${PATH}"
          export LD_LIBRARY_PATH="${HERE}/usr/lib:${LD_LIBRARY_PATH}"
          export XDG_DATA_DIRS="${HERE}/usr/share:${XDG_DATA_DIRS:-/usr/local/share:/usr/share}"
          export GSETTINGS_SCHEMA_DIR="${HERE}/usr/share/glib-2.0/schemas:${GSETTINGS_SCHEMA_DIR}"
          export GDK_PIXBUF_MODULE_FILE="${HERE}/usr/lib/gdk-pixbuf-2.0/2.10.0/loaders.cache"

          # Tauri-Binary aufrufen
          BIN=$(find "${HERE}/usr/bin" -maxdepth 1 -type f -executable | head -1)
          exec "$BIN" "$@"
          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 löschen falls vorhanden (404 ist OK)
          curl -sS -X DELETE \
            --user "data:${{ secrets.REGISTRY_TOKEN }}" \
            "${BASE}/latest/${FILENAME}" || 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}"