qbz/.github/workflows/release-flatpak.yml

name: release-flatpak

on:
  workflow_dispatch:
    inputs:
      tag:
        description: "Optional release tag to build (e.g. v0.1.0)"
        required: false
        type: string
  push:
    tags:
      - "v*"

jobs:
  build-flatpak:
    runs-on: ubuntu-latest
    permissions:
      contents: write
    steps:
      - name: Checkout
        uses: actions/checkout@v4

      - name: Resolve release version
        id: release
        run: |
          VERSION=""
          if [[ "${GITHUB_REF}" == refs/tags/v* ]]; then
            VERSION="${GITHUB_REF#refs/tags/v}"
          elif [[ -n "${{ inputs.tag }}" ]]; then
            VERSION="${{ inputs.tag }}"
            VERSION="${VERSION#v}"
          fi
          echo "version=$VERSION" >> "$GITHUB_OUTPUT"

      - name: Sync version to build metadata
        if: steps.release.outputs.version != ''
        env:
          QBZ_VERSION: ${{ steps.release.outputs.version }}
        run: |
          python - <<'PY'
          import json
          import os
          import pathlib
          import re

          version = os.environ["QBZ_VERSION"]

          def update_json(path, updater):
              p = pathlib.Path(path)
              data = json.loads(p.read_text(encoding="utf-8"))
              updater(data)
              p.write_text(json.dumps(data, indent=2) + "\n", encoding="utf-8")

          update_json("package.json", lambda d: d.__setitem__("version", version))

          def update_lock(d):
              d["version"] = version
              packages = d.get("packages")
              if isinstance(packages, dict) and "" in packages:
                  packages[""]["version"] = version
          update_json("package-lock.json", update_lock)

          update_json("src-tauri/tauri.conf.json", lambda d: d.__setitem__("version", version))

          cargo_path = pathlib.Path("src-tauri/Cargo.toml")
          cargo_text = cargo_path.read_text(encoding="utf-8")
          cargo_text = re.sub(r'(?m)^version = \"[^\"]+\"', f'version = \"{version}\"', cargo_text, count=1)
          cargo_path.write_text(cargo_text, encoding="utf-8")
          PY

      - name: Install flatpak tooling
        run: |
          sudo apt-get update
          sudo apt-get install -y flatpak flatpak-builder
          flatpak remote-add --user --if-not-exists flathub https://flathub.org/repo/flathub.flatpakrepo

      - name: Install runtimes
        run: |
          # Install GNOME runtime and SDK first
          flatpak install --user -y --noninteractive flathub \
            org.gnome.Platform//49 \
            org.gnome.Sdk//49
          # Install SDK extensions - flatpak-builder will auto-resolve the correct version based on the SDK
          flatpak install --user -y --noninteractive flathub \
            org.freedesktop.Sdk.Extension.node20//25.08 \
            org.freedesktop.Sdk.Extension.rust-stable//25.08

      - name: Inject API secrets into Flatpak manifest
        env:
          SPOTIFY_API_CLIENT_ID: ${{ secrets.SPOTIFY_API_CLIENT_ID }}
          SPOTIFY_API_CLIENT_SECRET: ${{ secrets.SPOTIFY_API_CLIENT_SECRET }}
          TIDAL_API_CLIENT_ID: ${{ secrets.TIDAL_API_CLIENT_ID }}
          TIDAL_API_CLIENT_SECRET: ${{ secrets.TIDAL_API_CLIENT_SECRET }}
          DISCOGS_API_CLIENT_KEY: ${{ secrets.DISCOGS_API_CLIENT_KEY }}
          DISCOGS_API_CLIENT_SECRET: ${{ secrets.DISCOGS_API_CLIENT_SECRET }}
          LAST_FM_API_KEY: ${{ secrets.LAST_FM_API_KEY }}
          LAST_FM_API_SHARED_SECRET: ${{ secrets.LAST_FM_API_SHARED_SECRET }}
        run: |
          # Inject env vars into the qbz module's build-options.env in the manifest
          python3 << 'PY'
          import yaml
          import os

          with open('packaging/flatpak/com.blitzkriegfc.qbz.yml', 'r') as f:
              manifest = yaml.safe_load(f)

          # Find the qbz module and add env vars
          for module in manifest.get('modules', []):
              if module.get('name') == 'qbz':
                  if 'build-options' not in module:
                      module['build-options'] = {}
                  if 'env' not in module['build-options']:
                      module['build-options']['env'] = {}

                  env_vars = [
                      'SPOTIFY_API_CLIENT_ID', 'SPOTIFY_API_CLIENT_SECRET',
                      'TIDAL_API_CLIENT_ID', 'TIDAL_API_CLIENT_SECRET',
                      'DISCOGS_API_CLIENT_KEY', 'DISCOGS_API_CLIENT_SECRET',
                      'LAST_FM_API_KEY', 'LAST_FM_API_SHARED_SECRET'
                  ]
                  for var in env_vars:
                      val = os.environ.get(var, '')
                      if val:
                          module['build-options']['env'][var] = val
                  break

          with open('packaging/flatpak/com.blitzkriegfc.qbz.yml', 'w') as f:
              yaml.dump(manifest, f, default_flow_style=False, sort_keys=False)
          PY

      - name: Build Flatpak
        run: |
          mkdir -p flatpak-build flatpak-repo dist
          flatpak-builder --user --force-clean --repo=flatpak-repo \
            flatpak-build packaging/flatpak/com.blitzkriegfc.qbz.yml
          flatpak build-bundle flatpak-repo dist/QBZ.flatpak com.blitzkriegfc.qbz

      - name: Upload Flatpak bundle
        uses: actions/upload-artifact@v4
        with:
          name: qbz-flatpak
          path: dist/QBZ.flatpak

      - name: Publish GitHub Release Asset
        if: startsWith(github.ref, 'refs/tags/')
        uses: softprops/action-gh-release@v2
        with:
          files: dist/QBZ.flatpak