release.yml

name: Release

# Builds release artifacts for Windows, macOS, and Linux and attaches them to
# a GitHub Release whenever a version tag (v*) is pushed.
#
#   git tag v3.0.0 && git push origin v3.0.0
#
# Two product lines are published side by side on the same release:
#
#   * `bootanimix` (CLI) and `bootanimix-tui` (TUI) — plain Rust binaries
#     packaged as tar.gz / zip with SHA-256 checksums.
#   * `BootAnimix Studio` — the Tauri 2 desktop app, built as native
#     installers (NSIS/MSI on Windows, .app/.dmg on macOS, .deb/.rpm/AppImage
#     on Linux).
#
# The Tauri app lives in its own Cargo workspace (`apps/gui/src-tauri`) so the
# webview runtime toolchains never leak into the CLI/TUI builds. It cannot be
# cross-compiled, so each OS builds on its own runner.

on:
  push:
    tags: ["v*"]
  workflow_dispatch:

permissions:
  contents: write

concurrency:
  group: release-${{ github.ref }}
  cancel-in-progress: false

jobs:
  test:
    name: Test gate (Linux)
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@v4
      - uses: dtolnay/rust-toolchain@stable
      - name: Run unit, integration, and property tests
        run: cargo test --workspace

  build:
    name: Build ${{ matrix.target }}
    needs: test
    runs-on: ${{ matrix.os }}
    strategy:
      fail-fast: false
      matrix:
        include:
          - os: ubuntu-latest
            target: x86_64-unknown-linux-gnu
            archive_ext: tar.gz
          - os: windows-latest
            target: x86_64-pc-windows-msvc
            archive_ext: zip
          - os: macos-latest
            target: aarch64-apple-darwin
            archive_ext: tar.gz
          - os: macos-15-intel
            target: x86_64-apple-darwin
            archive_ext: tar.gz
    steps:
      - uses: actions/checkout@v4
      - uses: dtolnay/rust-toolchain@stable
        with:
          targets: ${{ matrix.target }}
      - name: Build CLI and TUI (release mode)
        run: cargo build --release -p bootanimix-cli -p bootanimix-tui --target ${{ matrix.target }}
      - name: Smoke-test binaries
        shell: bash
        run: |
          set -euo pipefail
          ext=""
          if [ "${{ runner.os }}" = "Windows" ]; then ext=".exe"; fi
          bin_dir="target/${{ matrix.target }}/release"
          "./${bin_dir}/bootanimix${ext}" --version
          "./${bin_dir}/bootanimix-tui${ext}" --help
          "./${bin_dir}/bootanimix${ext}" doctor
      - name: Stage release directory
        shell: bash
        run: |
          set -euo pipefail
          ext=""
          if [ "${{ runner.os }}" = "Windows" ]; then ext=".exe"; fi
          stage="bootanimix-${GITHUB_REF_NAME}-${{ matrix.target }}"
          mkdir -p "${stage}"
          cp "target/${{ matrix.target }}/release/bootanimix${ext}" "${stage}/"
          cp "target/${{ matrix.target }}/release/bootanimix-tui${ext}" "${stage}/"
          cp README.md LICENSE CHANGELOG.md "${stage}/"
      - name: Package archive (Unix)
        if: runner.os != 'Windows'
        shell: bash
        run: |
          set -euo pipefail
          stage="bootanimix-${GITHUB_REF_NAME}-${{ matrix.target }}"
          tar -czf "${stage}.${{ matrix.archive_ext }}" "${stage}"
          if command -v sha256sum >/dev/null 2>&1; then
            sha256sum "${stage}.${{ matrix.archive_ext }}" > "${stage}.${{ matrix.archive_ext }}.sha256"
          else
            shasum -a 256 "${stage}.${{ matrix.archive_ext }}" > "${stage}.${{ matrix.archive_ext }}.sha256"
          fi
      - name: Package archive (Windows)
        if: runner.os == 'Windows'
        shell: bash
        run: |
          set -euo pipefail
          stage="bootanimix-${GITHUB_REF_NAME}-${{ matrix.target }}"
          7z a "${stage}.${{ matrix.archive_ext }}" "${stage}"
          if command -v sha256sum >/dev/null 2>&1; then
            sha256sum "${stage}.${{ matrix.archive_ext }}" > "${stage}.${{ matrix.archive_ext }}.sha256"
          else
            shasum -a 256 "${stage}.${{ matrix.archive_ext }}" > "${stage}.${{ matrix.archive_ext }}.sha256"
          fi
      - name: Upload build artifact
        uses: actions/upload-artifact@v4
        with:
          name: bootanimix-${{ matrix.target }}
          path: |
            bootanimix-${{ github.ref_name }}-${{ matrix.target }}.${{ matrix.archive_ext }}
            bootanimix-${{ github.ref_name }}-${{ matrix.target }}.${{ matrix.archive_ext }}.sha256
          if-no-files-found: error

  build-gui:
    name: Build Studio ${{ matrix.target }}
    needs: test
    runs-on: ${{ matrix.os }}
    strategy:
      fail-fast: false
      matrix:
        include:
          - os: windows-latest
            target: x86_64-pc-windows-msvc
            bundles: nsis,msi
          - os: macos-latest
            target: aarch64-apple-darwin
            bundles: app,dmg
          - os: macos-15-intel
            target: x86_64-apple-darwin
            bundles: app,dmg
          - os: ubuntu-latest
            target: x86_64-unknown-linux-gnu
            bundles: deb,rpm,appimage
    steps:
      - uses: actions/checkout@v4

      - name: Install Linux webview dependencies
        if: runner.os == 'Linux'
        run: |
          sudo apt-get update
          sudo apt-get install -y \
            libwebkit2gtk-4.1-dev \
            libappindicator3-dev \
            librsvg2-dev \
            patchelf \
            libfuse2 \
            file

      - name: Set up Node.js
        uses: actions/setup-node@v4
        with:
          node-version: 22
          cache: npm
          cache-dependency-path: apps/gui/package-lock.json

      - name: Set up Rust
        uses: dtolnay/rust-toolchain@stable
        with:
          targets: ${{ matrix.target }}

      - name: Cache Rust build artifacts
        uses: swatinem/rust-cache@v2
        with:
          workspaces: apps/gui/src-tauri -> target
          key: ${{ matrix.target }}

      - name: Install frontend dependencies
        run: npm ci
        working-directory: apps/gui

      - name: Build the desktop app
        working-directory: apps/gui
        run: npx tauri build --target ${{ matrix.target }} --bundles ${{ matrix.bundles }}

      - name: Collect installers
        shell: bash
        run: |
          set -euo pipefail
          stage="bootanimix-studio-${{ matrix.target }}"
          mkdir -p "${stage}"
          bundle_dir="apps/gui/src-tauri/target/${{ matrix.target }}/release/bundle"
          if [ ! -d "${bundle_dir}" ]; then
            bundle_dir="apps/gui/src-tauri/target/release/bundle"
          fi
          echo "Bundles produced in ${bundle_dir}:"
          find "${bundle_dir}" -mindepth 1 -maxdepth 1 -type d -print
          # Copy every installer file; .app bundles are directories, so pack
          # them into a tar.gz instead.
          find "${bundle_dir}" -mindepth 2 -maxdepth 3 -type f \
            \( -name '*.exe' -o -name '*.msi' -o -name '*.dmg' -o -name '*.deb' \
               -o -name '*.rpm' -o -name '*.AppImage' \) \
            -exec cp {} "${stage}/" \;
          # The .app bundle is named "BootAnimix Studio.app" on every macOS
          # target, so the tarball has to carry the target triple or the
          # arm64 and x86_64 archives would collide when the release job
          # merges the artifacts.
          for app in "${bundle_dir}"/macos/*.app; do
            [ -d "${app}" ] || continue
            tar -czf "${stage}/BootAnimix-Studio-${{ matrix.target }}.app.tar.gz" \
              -C "$(dirname "${app}")" "$(basename "${app}")"
          done
          ls -l "${stage}"
          test -n "$(ls -A "${stage}")"

      - name: Upload Studio installers
        uses: actions/upload-artifact@v4
        with:
          name: bootanimix-studio-${{ matrix.target }}
          path: bootanimix-studio-${{ matrix.target }}/
          if-no-files-found: error

  release:
    name: Publish GitHub Release
    needs: [build, build-gui]
    # The CLI/TUI binaries are the primary artifacts: publish them even if a
    # desktop bundle failed to build on one platform. Any Studio installers
    # that did build are still attached.
    if: always() && needs.build.result == 'success' && startsWith(github.ref, 'refs/tags/v')
    runs-on: ubuntu-latest
    steps:
      - name: Download all build artifacts
        uses: actions/download-artifact@v4
        with:
          path: dist
          # Keep the per-artifact subdirectories so that a filename collision
          # between two targets is detected below, rather than one artifact
          # silently overwriting the other.
          merge-multiple: false

      - name: Flatten artifacts and check for duplicate names
        shell: bash
        run: |
          set -euo pipefail
          find dist -type f -printf '%f\n' | sort | uniq -d > duplicate_names.txt || true
          if [ -s duplicate_names.txt ]; then
            echo "::error::Two build artifacts produced the same asset name:"
            cat duplicate_names.txt
            exit 1
          fi
          mkdir -p flat
          find dist -type f -exec cp {} flat/ \;
          ls -l flat

      - name: Show published files
        run: ls -lR flat

      - name: Create GitHub Release with binaries
        uses: softprops/action-gh-release@v2
        with:
          generate_release_notes: true
          files: flat/**