release.yml

name: Release
on:
  push:
    tags:
      - "v[0-9]+.[0-9]+.[0-9]+"
  # Just used for testing
  pull_request:
    branches:
      - main
    paths:
      - ".github/workflows/release.yml"
      - ".github/actions/setup/action.yml"
  workflow_dispatch:
    inputs:
      channel:
        description: The release channel
        default: beta
        required: true
        type: choice
        options:
          - alpha
          - beta
          - stable
      publish:
        description: Whether to publish a new release
        default: false
        required: true
        type: boolean
  schedule:
    # Release alpha every day at 20:00 UTC (4:00 AM UTC+8)
    - cron: "0 20 * * *"

defaults:
  run:
    shell: bash

permissions:
  contents: read

jobs:
  meta:
    name: Meta
    runs-on: ubuntu-latest
    outputs:
      version: ${{ steps.version.outputs.version }}
      tag: ${{ steps.version.outputs.tag }}
      commit: ${{ steps.version.outputs.commit }}
      channel: ${{ steps.version.outputs.channel }}
      prerelease: ${{ steps.version.outputs.channel != 'stable' }}
      publish: ${{ steps.version.outputs.publish }}
      skip: ${{ steps.version.outputs.skip }}
    steps:
      - name: Checkout
        uses: actions/checkout@v4
      - name: Checkout Version Branch
        uses: actions/checkout@v4
        with:
          ref: version
          path: version
      - name: Get Version
        id: version
        run: |
          bash .github/scripts/parse_version.sh

  release-note:
    name: Generate Release Notes
    if: ${{ !fromJson(needs.meta.outputs.skip) }}
    runs-on: ubuntu-latest
    needs: [meta]
    outputs:
      content: ${{ steps.git_cliff.outputs.content }}
    steps:
      - name: Checkout
        uses: actions/checkout@v4
        with:
          fetch-depth: 0
      - name: Generate Release Notes
        id: git_cliff
        uses: orhun/git-cliff-action@v2
        with:
          config: cliff.toml
          # If the release is a prerelease, use unreleased commits
          # otherwise use commits belonging to the last release
          args: -vv ${{ fromJson(needs.meta.outputs.prerelease) && '-u' || '-l' }}
      - name: Preview Release Notes
        if: ${{ !fromJson(needs.meta.outputs.publish) }}
        run: |
          {
            echo '```markdown'
            cat ${{ steps.git_cliff.outputs.changelog }}
            echo '```'
          } >> "$GITHUB_STEP_SUMMARY"

  build:
    name: Build
    needs: meta
    if: ${{ !fromJson(needs.meta.outputs.skip) }}
    runs-on: ${{ matrix.os }}
    strategy:
      fail-fast: false
      matrix:
        os:
          - ubuntu-latest
          - macos-latest
          - windows-latest
        arch:
          - x86_64
          - aarch64
        exclude:
          # Failed to cross compile ring on Windows
          - os: windows-latest
            arch: aarch64
    steps:
      - name: Checkout
        uses: actions/checkout@v4
      - name: Setup Rust
        uses: ./.github/actions/setup
        with:
          os: ${{ matrix.os }}
          arch: ${{ matrix.arch }}
      - name: Patch Version
        run: |
          MAA_VERSION="${{ needs.meta.outputs.version }}"
          if [ $(uname) == "Darwin" ]; then
            SED="sed -i '' -E" # BSD sed should use '' as backup extension
          else
            SED="sed -i -E"
          fi
          S="[[:space:]]" # BSD sed doesn't support \s
          $SED "1,6 s/(version${S}*=${S}*)\"[^\"]+\"/\1\"$MAA_VERSION\"/" maa-cli/Cargo.toml
          NL=$(grep -n -E "name${S}*=${S}*\"maa-cli\"" Cargo.lock | cut -d: -f1)
          NS=$((NL - 1))
          NE=$((NL + 3))
          $SED "$NS,$NE s/(version${S}*=${S}*)\"[^\"]+\"/\1\"$MAA_VERSION\"/" Cargo.lock
          {
            echo "Patch Version (${{ matrix.os }}, ${{ matrix.arch }})"
            echo '```diff'
            git diff
            echo '```'
          } >> "$GITHUB_STEP_SUMMARY"
      - name: Build
        env:
          CARGO_PROFILE_RELEASE_CODEGEN_UNITS: 1
          CARGO_PROFILE_RELEASE_LTO: true
          CARGO_PROFILE_RELEASE_STRIP: true
        run: |
          cargo build --release --package maa-cli --locked --features vendored-openssl
      - name: Tar Artifact
        run: |
          tar -cvf "$CARGO_BUILD_TARGET.tar" -C "target/$CARGO_BUILD_TARGET/release" maa
      - name: Upload Artifact
        uses: actions/upload-artifact@v4
        with:
          name: maa_cli-${{ env.CARGO_BUILD_TARGET }}
          path: ${{ env.CARGO_BUILD_TARGET }}.tar
          retention-days: 1
          if-no-files-found: error

  build-universal:
    name: Build Universal Binary
    if: ${{ !fromJson(needs.meta.outputs.skip) }}
    runs-on: macos-latest
    needs: [meta, build]
    steps:
      # download all artifacts, even if not all are used,
      # because this action don't support wildcards
      - name: Download Artifacts
        uses: actions/download-artifact@v4
      - name: Create universal binaries
        run: |
          for arch in x86_64 aarch64; do
            target="$arch-apple-darwin"
            dir="maa_cli-$target"
            tar -xvf "$dir/$target.tar" -C "$dir"
          done
          lipo -create -output maa maa_cli-x86_64-apple-darwin/maa maa_cli-aarch64-apple-darwin/maa
          tar -cvf "universal-apple-darwin.tar" maa
      - name: Upload Artifact
        uses: actions/upload-artifact@v4
        with:
          name: maa_cli-universal-apple-darwin
          path: universal-apple-darwin.tar
          retention-days: 1
          if-no-files-found: error

  release:
    name: Release
    if: ${{ !fromJson(needs.meta.outputs.skip) }}
    runs-on: ubuntu-latest
    needs: [meta, build, build-universal, release-note]
    permissions:
      contents: write
    env:
      GH_REPO: ${{ github.repository }}
      GH_TOKEN: ${{ secrets.GITHUB_TOKEN }}
      CHANNEL: ${{ needs.meta.outputs.channel }}
      VERSION: ${{ needs.meta.outputs.version }}
      TAG: ${{ needs.meta.outputs.tag }}
      COMMIT: ${{ needs.meta.outputs.commit }}
    steps:
      - name: Download Artifacts
        uses: actions/download-artifact@v4
      - name: Checkout version branch
        uses: actions/checkout@v4
        with:
          ref: version
          path: version
      - name: Extract files, Generate checksums and Update version.json
        run: |
          # When release channel is stable, update all channel version info
          # When release channel is beta, update beta version info only
          # (don't update alpha version info, because alpha version is nightly,
          # once a beta version is installed, alpha version will be considered
          # as outdated)
          # When release channel is alpha, update alpha version info only
          version_files=()
          [ "$CHANNEL" != "beta" ] && version_files+=(version/alpha.json)
          [ "$CHANNEL" != "alpha" ] && version_files+=(version/beta.json)
          [ "$CHANNEL" == "stable" ] && version_files+=(version/stable.json)

          # target independent version info
          for version_file in "${version_files[@]}"; do
            yq -i -oj ".version = \"$VERSION\"" "$version_file"
            yq -i -oj ".details.tag = \"$TAG\"" "$version_file"
            yq -i -oj ".details.commit = \"$COMMIT\"" "$version_file"
          done

          targets=(
            x86_64-unknown-linux-gnu
            aarch64-unknown-linux-gnu
            universal-apple-darwin
            x86_64-apple-darwin
            aarch64-apple-darwin
            x86_64-pc-windows-msvc
          )

          for target in "${targets[@]}"; do
            dir="maa_cli-$target"
            tar -xvf "$dir/$target.tar" -C "$dir"
            # use tar on linux and zip on other platforms
            if [[ "$target" == *"linux"* ]]; then
              archive_name="maa_cli-v$VERSION-$target.tar.gz"
              tar -czvf "$archive_name" "$dir/maa"
            else
              archive_name="maa_cli-v$VERSION-$target.zip"
              zip -r "$archive_name" "$dir/maa"
            fi
            checksum=$(sha256sum "$archive_name")
            checksum_hash=${checksum:0:64}
            size=$(stat -c%s "$archive_name")
            echo "$checksum" > "$archive_name.sha256"

            # old version info (deprecated)
            # only update when a stable release is published
            if [ "$CHANNEL" == "stable" ]; then
              version_file="version/version.json"
              yq -i -oj ".maa-cli.$target.version = \"$VERSION\"" "$version_file"
              yq -i -oj ".maa-cli.$target.tag = \"$TAG\"" "$version_file"
              yq -i -oj ".maa-cli.$target.name = \"$archive_name\"" "$version_file"
              yq -i -oj ".maa-cli.$target.size = $size" $version_file
              yq -i -oj ".maa-cli.$target.sha256sum = \"$checksum_hash\"" "$version_file"
            fi

            # target dependent version info
            for version_file in "${version_files[@]}"; do
              yq -i -oj ".details.assets.$target.name = \"$archive_name\"" "$version_file"
              yq -i -oj ".details.assets.$target.size = $size" "$version_file"
              yq -i -oj ".details.assets.$target.sha256sum = \"$checksum_hash\"" "$version_file"
            done
          done
      - name: Check existing release
        if: ${{ fromJson(needs.meta.outputs.publish) }}
        run: |
          if gh release view "$TAG" &> /dev/null; then
            if [ "$TAG" == "nightly" ]; then
              echo "Release as nightly, clear existing release and tag"
              gh release delete "$TAG" --yes  --cleanup-tag
            else
              echo "Release $TAG already exists, abort"
              exit 1
            fi
          fi
          sleep 5 # wait to avoid the release becames draft
      - name: Create Release
        uses: softprops/action-gh-release@v1
        if: ${{ fromJson(needs.meta.outputs.publish) }}
        with:
          name: v${{ needs.meta.outputs.version }}
          tag_name: ${{ needs.meta.outputs.tag }}
          prerelease: ${{ fromJson(needs.meta.outputs.prerelease) }}
          body: ${{ needs.release-note.outputs.content }}
          fail_on_unmatched_files: true
          files: |
            maa_cli-v${{ needs.meta.outputs.version }}-*-unknown-linux-gnu.tar.gz*
            maa_cli-v${{ needs.meta.outputs.version }}-*-apple-darwin.zip*
            maa_cli-v${{ needs.meta.outputs.version }}-*-pc-windows-msvc.zip*
      - name: Commit version.json and Push
        working-directory: version
        run: |
          git config --local user.name "github-actions[bot]"
          git config --local user.email "41898282+github-actions[bot]@users.noreply.github.com"
          {
            echo "Commit changes to version.json"
            echo '```diff'
            git diff ./*.json
            echo '```'
          } >> "$GITHUB_STEP_SUMMARY"
          git commit ./*.json -m "chore: bump version to v${{ needs.meta.outputs.version }}"
          git push --verbose ${{ !fromJson(needs.meta.outputs.publish) && '--dry-run' || ''}}

  publish-homebrew:
    needs: [meta, release]
    if: ${{ fromJson(needs.meta.outputs.publish) && !fromJson(needs.meta.outputs.prerelease) }}
    name: Publish Homebrew
    uses: ./.github/workflows/publish-homebrew.yml
    with:
      version: ${{ needs.meta.outputs.version }}
      dryrun: false
    secrets:
      MAA_HOMEBREW_BUMP_PR: ${{ secrets.MAA_HOMEBREW_BUMP_PR }}

  publish-aur:
    needs: [meta, release]
    if: ${{ fromJson(needs.meta.outputs.publish) && !fromJson(needs.meta.outputs.prerelease) }}
    name: Publish AUR Package
    uses: ./.github/workflows/publish-aur.yml
    with:
      pkgver: ${{ needs.meta.outputs.version }}
      dryrun: false
    secrets:
      AUR_SSH_PRIVATE_KEY: ${{ secrets.AUR_SSH_PRIVATE_KEY }}