steamify-cachyos/.github/workflows/bundle.yml

# Builds the single-file wizard (.github/tools/bundle.sh) and publishes it as a
# release per version: tag v$VERSION (VERSION in steamify.sh),
# with that version's CHANGELOG.md section as notes. A released version is
# never overwritten; the newest one is marked latest, and the "latest" tag and
# release are moved to it, so both of these always get the newest version:
#   curl -fsSL https://github.com/theupriser/steamify-cachyos/releases/latest/download/steamify.sh | bash
#   curl -fsSL https://github.com/theupriser/steamify-cachyos/releases/download/latest/steamify.sh | bash
# Each release also has the app: steamify-app.tar.gz (ui/, steamify.sh,
# lib/, patches/, services/, the icon) and its launcher, run with:
#   curl -fsSL https://github.com/theupriser/steamify-cachyos/releases/latest/download/steamify-app.sh | bash
# Pushes to release/** build and check it like pull requests; only main publishes.
# Pull requests only build and check it, and warn when VERSION is already released.
name: Single-file build

on:
  push:
    branches: [main, 'release/**']
  pull_request:
  workflow_dispatch:

permissions:
  contents: write

jobs:
  bundle:
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@v4
        with:
          fetch-depth: 0 # for the version in the bundle's header

      - name: Build
        run: |
          .github/tools/bundle.sh dist/steamify.sh
          # The app: sources, not the single-file build (its backend mode runs
          # steamify.sh from its own folder).
          tar -czf dist/steamify-app.tar.gz steamify.sh lib patches services ui assets/steam-gaming-settings.svg LICENSE.md
          cp ui/steamify-app.sh dist/steamify-app.sh

      - name: Check
        run: |
          bash -n dist/steamify.sh
          python3 -c 'import ast, sys; [ast.parse(open(f).read(), f) for f in sys.argv[1:]]' ui/steamify-ui patches/*.py

      # shellcheck through an action that brings its own binary: GitHub's runner has it installed,
      # Gitea's act_runner image doesn't. One file per run, as before (the exceptions are the bundle's).
      - name: shellcheck the bundle
        uses: ludeeus/action-shellcheck@2.0.0
        env:
          # SC2034/SC2154: variables used across the inlined modules.
          SHELLCHECK_OPTS: -e SC2034 -e SC2154
        with:
          severity: warning
          scandir: dist
          ignore_names: steamify-app.sh
      - name: shellcheck the app launcher
        uses: ludeeus/action-shellcheck@2.0.0
        with:
          severity: warning
          scandir: dist
          ignore_names: steamify.sh

      # The build as an artifact on GitHub and on the mirror (Gitea); releases stay GitHub's.
      # Gitea's artifact server doesn't speak upload-artifact@v4's protocol, and GitHub fails a workflow
      # that merely mentions the deprecated @v3: Gitea gets christopherhx's fork of v4 for Gitea.
      - uses: actions/upload-artifact@v4
        if: github.server_url == 'https://github.com'
        with:
          name: steamify
          path: |
            dist/steamify.sh
            dist/steamify-app.tar.gz
            dist/steamify-app.sh
      - uses: christopherhx/gitea-upload-artifact@v4
        if: github.server_url != 'https://github.com'
        with:
          name: steamify
          path: |
            dist/steamify.sh
            dist/steamify-app.tar.gz
            dist/steamify-app.sh

      - name: Version
        id: version
        if: github.server_url == 'https://github.com'
        env:
          GH_TOKEN: ${{ github.token }}
        run: |
          version="$(grep -oP '^VERSION=\K.*' steamify.sh)"
          echo "version=$version" >> "$GITHUB_OUTPUT"
          if gh release view "v$version" >/dev/null 2>&1; then
            echo "released=true" >> "$GITHUB_OUTPUT"
            echo "::warning::v$version is already released and won't be overwritten. Bump VERSION in steamify.sh and add a CHANGELOG.md section to release this."
          else
            echo "released=false" >> "$GITHUB_OUTPUT"
          fi

      - name: Publish the v${{ steps.version.outputs.version }} release
        if: >-
          github.server_url == 'https://github.com' &&
          github.event_name != 'pull_request' && github.ref == 'refs/heads/main' &&
          steps.version.outputs.released == 'false'
        env:
          GH_TOKEN: ${{ github.token }}
          VERSION: ${{ steps.version.outputs.version }}
        run: |
          # This version's section of CHANGELOG.md, without its heading.
          changes="$(awk -v v="$VERSION" '
              $0 ~ "^## " { if (found) exit; if (index($0, "## " v " ") == 1) { found = 1; next } }
              found' CHANGELOG.md)"
          notes="Single-file build of v$VERSION ($(git describe --always), $(git log -1 --format=%cs)).
          Run the newest version with:

              curl -fsSL https://github.com/${{ github.repository }}/releases/latest/download/steamify.sh | bash

          Or the app (v2):

              curl -fsSL https://github.com/${{ github.repository }}/releases/latest/download/steamify-app.sh | bash

          ## Changes in v$VERSION
          $changes"
          gh release create "v$VERSION" dist/steamify.sh dist/steamify-app.sh dist/steamify-app.tar.gz assets/steam-gaming-settings.svg \
              --target "$GITHUB_SHA" --title "Steamify CachyOS v$VERSION" --notes "$notes" --latest

          # "latest" follows the newest version tag, for the older install URL
          # (.../releases/download/latest/...). Only moved when a new version
          # is released, never for a push without a VERSION bump.
          git tag -f latest "$GITHUB_SHA" && git push -f origin latest
          latest_notes="Always the newest version, currently v$VERSION (see its release for the changes)."
          if gh release view latest >/dev/null 2>&1; then
            gh release edit latest --title "Steamify CachyOS - latest (v$VERSION)" --notes "$latest_notes" --latest=false
          else
            gh release create latest --title "Steamify CachyOS - latest (v$VERSION)" --notes "$latest_notes" --latest=false
          fi
          gh release upload latest dist/steamify.sh dist/steamify-app.sh dist/steamify-app.tar.gz assets/steam-gaming-settings.svg --clobber

      # The mirror (Gitea) publishes its own release per version too, the same way: never overwrites one,
      # notes from the changelog. gh can't talk to Gitea: its API for the check, a Gitea release action to
      # publish. The token is the run's own (repository write); a secret RELEASE_TOKEN overrides it.
      - name: Version (mirror)
        id: mirror_version
        if: github.server_url != 'https://github.com'
        env:
          TOKEN: ${{ secrets.RELEASE_TOKEN || github.token }}
        run: |
          version="$(grep -oP '^VERSION=\K.*' steamify.sh)"
          echo "version=$version" >> "$GITHUB_OUTPUT"
          if curl -fsS -o /dev/null -H "Authorization: token $TOKEN" \
              "${{ github.server_url }}/api/v1/repos/${{ github.repository }}/releases/tags/v$version"; then
            echo "released=true" >> "$GITHUB_OUTPUT"
            echo "::warning::v$version is already released on this server and won't be overwritten."
          else
            echo "released=false" >> "$GITHUB_OUTPUT"
          fi

      - name: Release notes (mirror)
        if: >-
          github.server_url != 'https://github.com' &&
          github.event_name != 'pull_request' && github.ref == 'refs/heads/main' &&
          steps.mirror_version.outputs.released == 'false'
        env:
          VERSION: ${{ steps.mirror_version.outputs.version }}
        run: |
          changes="$(awk -v v="$VERSION" '
              $0 ~ "^## " { if (found) exit; if (index($0, "## " v " ") == 1) { found = 1; next } }
              found' CHANGELOG.md)"
          cat > dist/release-notes.md <<NOTES
          Single-file build of v$VERSION ($(git describe --always), $(git log -1 --format=%cs)).
          Run this version with:

              curl -fsSL ${{ github.server_url }}/${{ github.repository }}/releases/download/v$VERSION/steamify.sh | bash

          ## Changes in v$VERSION
          $changes
          NOTES

      - name: Publish the v${{ steps.mirror_version.outputs.version }} release (mirror)
        if: >-
          github.server_url != 'https://github.com' &&
          github.event_name != 'pull_request' && github.ref == 'refs/heads/main' &&
          steps.mirror_version.outputs.released == 'false'
        uses: akkuman/gitea-release-action@v1.3.7
        with:
          token: ${{ secrets.RELEASE_TOKEN || github.token }}
          tag_name: v${{ steps.mirror_version.outputs.version }}
          target_commitish: ${{ github.sha }}
          name: Steamify CachyOS v${{ steps.mirror_version.outputs.version }}
          body_path: dist/release-notes.md
          files: |
            dist/steamify.sh
            dist/steamify-app.sh
            dist/steamify-app.tar.gz
            assets/steam-gaming-settings.svg

      # A new version starts the Steamify ISO's release of the ISO repo: its iso-1-github-tag.yml (always run from
      # master) names the ISO after the newest Steamify release, tags it, and the Gitea mirror builds and attaches the ISO.
      # The branch here decides the kind of build (the workflow's input `kind`):
      #   main (publishes the release)            -> release: a real ISO (tag v<steamify>-<date>)
      #   release/** (a version not yet released) -> dev: a pre-release (tag v<steamify>-dev.<date>)
      # Needs a fine-grained token for that repo (Actions: read and write) as the secret ISO_DISPATCH_TOKEN;
      # without it, this is skipped.
      - name: Start the Steamify ISO's release
        if: >-
          github.server_url == 'https://github.com' &&
          github.event_name != 'pull_request' &&
          (github.ref == 'refs/heads/main' || startsWith(github.ref, 'refs/heads/release/')) &&
          steps.version.outputs.released == 'false'
        env:
          GH_TOKEN: ${{ secrets.ISO_DISPATCH_TOKEN }}
        run: |
          if [ -z "$GH_TOKEN" ]; then
            echo "::notice::No ISO_DISPATCH_TOKEN: the Steamify ISO isn't released with this version."; exit 0
          fi
          # A release branch builds the ISO with its own code (and VERSION): steamify_ref. main builds the release it just published.
          if [ "$GITHUB_REF" = refs/heads/main ]; then kind=release; sref=""; else kind=dev; sref="$GITHUB_REF_NAME"; fi
          gh workflow run iso-1-github-tag.yml -R theupriser/steamify-cachyos-live-iso --ref master -f kind="$kind" -f steamify_ref="$sref"
          echo "Started the Steamify ISO's release (theupriser/steamify-cachyos-live-iso, master, kind $kind, Steamify ${sref:-the newest release})"