release.yml

name: Release

on:
  push:
    tags:
      - "v*"

permissions:
  contents: write

jobs:
  build:
    strategy:
      matrix:
        include:
          - goos: linux
            goarch: amd64
            runner: ubuntu-latest
          - goos: linux
            goarch: arm64
            runner: ubuntu-latest
          - goos: darwin
            goarch: amd64
            runner: macos-latest
          - goos: darwin
            goarch: arm64
            runner: macos-latest
          - goos: windows
            goarch: amd64
            runner: windows-latest
    runs-on: ${{ matrix.runner }}
    steps:
      - name: Checkout
        uses: actions/checkout@v6

      - name: Set up Go
        uses: actions/setup-go@v6
        with:
          go-version-file: go.mod

      - name: Install deps (Linux amd64)
        if: matrix.goos == 'linux' && matrix.goarch == 'amd64'
        run: |
          sudo apt-get update
          sudo apt-get install -y libasound2-dev libflac-dev libvorbis-dev libogg-dev

      - name: Install deps (Linux arm64 cross)
        if: matrix.goos == 'linux' && matrix.goarch == 'arm64'
        run: |
          sudo dpkg --add-architecture arm64
          # Pin existing DEB822 sources to amd64 only (noble+ uses this format)
          if [ -f /etc/apt/sources.list.d/ubuntu.sources ]; then
            sudo sed -i '/^Types:/a Architectures: amd64' /etc/apt/sources.list.d/ubuntu.sources
          fi
          # Pin traditional sources.list entries to amd64 (if any)
          sudo sed -i 's/^deb \(http\)/deb [arch=amd64] \1/' /etc/apt/sources.list || true
          # Add arm64 sources via ports.ubuntu.com
          CODENAME=$(lsb_release -cs)
          sudo tee /etc/apt/sources.list.d/arm64-ports.list > /dev/null <<EOF
          deb [arch=arm64] http://ports.ubuntu.com/ ${CODENAME} main restricted universe multiverse
          deb [arch=arm64] http://ports.ubuntu.com/ ${CODENAME}-updates main restricted universe multiverse
          deb [arch=arm64] http://ports.ubuntu.com/ ${CODENAME}-security main restricted universe multiverse
          EOF
          sudo apt-get update
          sudo apt-get install -y gcc-aarch64-linux-gnu libasound2-dev:arm64 libflac-dev:arm64 libvorbis-dev:arm64 libogg-dev:arm64

      - name: Install deps (macOS arm64)
        if: matrix.goos == 'darwin' && matrix.goarch == 'arm64'
        run: brew install flac libvorbis libogg pkg-config

      - name: Install deps (macOS amd64 cross)
        if: matrix.goos == 'darwin' && matrix.goarch == 'amd64'
        run: |
          # Install x86_64 Homebrew under /usr/local via Rosetta 2
          NONINTERACTIVE=1 arch -x86_64 /bin/bash -c \
            "$(curl -fsSL https://raw.githubusercontent.com/Homebrew/install/HEAD/install.sh)"
          arch -x86_64 /usr/local/bin/brew install flac libvorbis libogg pkg-config

      - name: Force static linking of codec libs (Linux)
        if: matrix.goos == 'linux'
        env:
          GOARCH: ${{ matrix.goarch }}
        run: |
          # Remove .so symlinks so the linker falls back to static .a archives.
          # This avoids soname mismatches (e.g. libFLAC.so.12 vs .so.14) when
          # the pre-built binary runs on distros with newer codec libraries.
          if [ "$GOARCH" = "arm64" ]; then
            LIB_DIR=/usr/lib/aarch64-linux-gnu
          else
            LIB_DIR=/usr/lib/x86_64-linux-gnu
          fi
          sudo rm -f ${LIB_DIR}/libFLAC.so
          sudo rm -f ${LIB_DIR}/libvorbis.so
          sudo rm -f ${LIB_DIR}/libvorbisenc.so
          sudo rm -f ${LIB_DIR}/libogg.so

      - name: Build (Linux)
        if: matrix.goos == 'linux'
        env:
          GOOS: ${{ matrix.goos }}
          GOARCH: ${{ matrix.goarch }}
          CGO_ENABLED: "1"
        run: |
          if [ "$GOARCH" = "arm64" ]; then
            export CC=aarch64-linux-gnu-gcc
            export PKG_CONFIG_PATH=/usr/lib/aarch64-linux-gnu/pkgconfig
          fi
          BINARY="cliamp-${GOOS}-${GOARCH}"
          VERSION="${GITHUB_REF#refs/tags/}"
          go build -trimpath \
            -ldflags="-s -w -X main.version=${VERSION} -extldflags '-lvorbisenc -lvorbis -lFLAC -logg -lm'" \
            -o "$BINARY" .

      - name: Build (Windows)
        if: matrix.goos == 'windows'
        env:
          GOOS: windows
          GOARCH: ${{ matrix.goarch }}
          CGO_ENABLED: "0"
        shell: bash
        run: |
          BINARY="cliamp-windows-${GOARCH}.exe"
          VERSION="${GITHUB_REF#refs/tags/}"
          go build -trimpath -ldflags="-s -w -X main.version=${VERSION}" -o "$BINARY" .

      - name: Build (macOS)
        if: matrix.goos == 'darwin'
        env:
          CGO_ENABLED: "1"
          GOARCH: ${{ matrix.goarch }}
        run: |
          if [ "$GOARCH" = "amd64" ]; then
            # Cross-compile for x86_64 using Rosetta 2 installed libs
            export CC="clang -arch x86_64"
            export PKG_CONFIG_PATH="/usr/local/lib/pkgconfig"
            export CGO_CFLAGS="-I/usr/local/include"
            export CGO_LDFLAGS="-L/usr/local/lib"
          fi
          BINARY="cliamp-darwin-${GOARCH}"
          VERSION="${GITHUB_REF#refs/tags/}"
          go build -trimpath -ldflags="-s -w -X main.version=${VERSION}" -o "$BINARY" .

      - name: Upload artifact
        uses: actions/upload-artifact@v7
        with:
          name: cliamp-${{ matrix.goos }}-${{ matrix.goarch }}
          path: cliamp-*

  release:
    needs: build
    runs-on: ubuntu-latest
    steps:
      - name: Checkout
        uses: actions/checkout@v6
        with:
          fetch-depth: 0

      - name: Download all artifacts
        uses: actions/download-artifact@v8
        with:
          path: artifacts
          merge-multiple: true

      - name: Generate checksums
        run: |
          cd artifacts
          sha256sum cliamp-* > checksums.txt
          cat checksums.txt

      - name: Generate changelog
        env:
          REPO: ${{ github.repository }}
          GH_TOKEN: ${{ github.token }}
        run: |
          TAG="${GITHUB_REF#refs/tags/}"

          PREV_TAG=$(git describe --tags --abbrev=0 "${TAG}^" 2>/dev/null || echo "")

          CHANGELOG=""

          if [ -z "$PREV_TAG" ]; then
            RANGE="$TAG"
          else
            RANGE="${PREV_TAG}..${TAG}"
          fi

          while IFS='|' read -r hash title author || [ -n "$hash" ]; do
            short_hash="${hash:0:7}"
            username=$(gh api "repos/${REPO}/commits/$hash" --jq '.author.login' 2>/dev/null || echo "")

            if [ -n "$username" ]; then
              author_info="$author ([@$username](https://github.com/$username))"
            else
              author_info="$author"
            fi

            CHANGELOG="${CHANGELOG}- $title by $author_info ([\`$short_hash\`](https://github.com/${REPO}/commit/$hash))"$'\n'
          done < <(git log "$RANGE" --pretty=format:"%H|%s|%an")

          {
            echo "## What's Changed"
            echo ""
            echo "$CHANGELOG"
            echo ""
            echo "## Checksums (SHA256)"
            echo ""
            echo '```'
            cat artifacts/checksums.txt
            echo '```'
            echo ""
            if [ -n "$PREV_TAG" ]; then
              echo "**Full Changelog**: https://github.com/${REPO}/compare/${PREV_TAG}...${TAG}"
            fi
          } > release_notes.md

      - name: Create release
        uses: softprops/action-gh-release@v2
        with:
          body_path: release_notes.md
          files: |
            artifacts/cliamp-*
            artifacts/checksums.txt

      - name: Upload checksums artifact
        uses: actions/upload-artifact@v7
        with:
          name: checksums
          path: artifacts/checksums.txt

  update-homebrew:
    needs: release
    runs-on: ubuntu-latest
    steps:
      - name: Download checksums
        uses: actions/download-artifact@v8
        with:
          name: checksums

      - name: Set env vars
        env:
          REPO: ${{ github.repository }}
        run: |
          TAG="${GITHUB_REF#refs/tags/}"
          VERSION="${TAG#v}"
          cat checksums.txt

          curl -fsSL "https://raw.githubusercontent.com/${REPO}/${TAG}/Cliamp.png" -o Cliamp.png
          curl -fsSL "https://raw.githubusercontent.com/${REPO}/${TAG}/cliamp.desktop" -o cliamp.desktop
          SHA_ICON=$(sha256sum Cliamp.png | awk '{print $1}')
          SHA_DESKTOP=$(sha256sum cliamp.desktop | awk '{print $1}')

          echo "VERSION=${VERSION}" >> $GITHUB_ENV
          echo "TAG=${TAG}" >> $GITHUB_ENV
          echo "SHA_DARWIN_ARM64=$(grep 'darwin-arm64' checksums.txt | awk '{print $1}')" >> $GITHUB_ENV
          echo "SHA_DARWIN_AMD64=$(grep 'darwin-amd64' checksums.txt | awk '{print $1}')" >> $GITHUB_ENV
          echo "SHA_LINUX_ARM64=$(grep 'linux-arm64' checksums.txt | awk '{print $1}')" >> $GITHUB_ENV
          echo "SHA_LINUX_AMD64=$(grep 'linux-amd64' checksums.txt | awk '{print $1}')" >> $GITHUB_ENV
          echo "SHA_ICON=${SHA_ICON}" >> $GITHUB_ENV
          echo "SHA_DESKTOP=${SHA_DESKTOP}" >> $GITHUB_ENV

      - name: Generate and push formula
        env:
          GH_TOKEN: ${{ secrets.HOMEBREW_TAP_TOKEN }}
        run: |
          git clone "https://x-access-token:${GH_TOKEN}@github.com/bjarneo/homebrew-cliamp.git"
          cd homebrew-cliamp
          mkdir -p Formula

          cat > Formula/cliamp.rb << 'FORMULA'
          class Cliamp < Formula
            desc "A retro terminal music player inspired by Winamp 2.x"
            homepage "https://github.com/bjarneo/cliamp"

            head "https://github.com/bjarneo/cliamp.git", branch: "main"

            depends_on "flac"
            depends_on "libvorbis"
            depends_on "libogg"
            depends_on "ffmpeg" => :recommended
            depends_on "yt-dlp" => :recommended
            depends_on "go" => :build
          FORMULA

          cat >> Formula/cliamp.rb << EOF
            version "${VERSION}"

            on_macos do
              on_arm do
                url "https://github.com/bjarneo/cliamp/releases/download/${TAG}/cliamp-darwin-arm64"
                sha256 "${SHA_DARWIN_ARM64}"
              end
              on_intel do
                url "https://github.com/bjarneo/cliamp/releases/download/${TAG}/cliamp-darwin-amd64"
                sha256 "${SHA_DARWIN_AMD64}"
              end
            end

            on_linux do
              on_arm do
                url "https://github.com/bjarneo/cliamp/releases/download/${TAG}/cliamp-linux-arm64"
                sha256 "${SHA_LINUX_ARM64}"
              end
              on_intel do
                url "https://github.com/bjarneo/cliamp/releases/download/${TAG}/cliamp-linux-amd64"
                sha256 "${SHA_LINUX_AMD64}"
              end
            end

            resource "icon" do
              url "https://raw.githubusercontent.com/bjarneo/cliamp/${TAG}/Cliamp.png"
              sha256 "${SHA_ICON}"
            end

            resource "desktop" do
              url "https://raw.githubusercontent.com/bjarneo/cliamp/${TAG}/cliamp.desktop"
              sha256 "${SHA_DESKTOP}"
            end

            def install
              if build.head?
                # Build from source for HEAD
                system "go", "build", "-ldflags", "-s -w", "-o", bin/"cliamp", "."
              else
                # Use pre-built binary for stable releases
                binary = Dir["cliamp-*"].first
                bin.install binary => "cliamp"
              end

              # Ship icon under pkgshare so it's always available; expose as
              # XDG icon + desktop entry on Linux for app-launcher integration.
              resource("icon").stage { pkgshare.install "Cliamp.png" => "cliamp.png" }

              on_linux do
                (share/"icons/hicolor/512x512/apps").install_symlink pkgshare/"cliamp.png"
                (share/"pixmaps").install_symlink pkgshare/"cliamp.png"
                resource("desktop").stage { (share/"applications").install "cliamp.desktop" }
              end
            end

            test do
              assert_match version.to_s, shell_output("#{bin}/cliamp --version")
            end
          end
          EOF

          sed -i 's/^          //' Formula/cliamp.rb

          git config user.name "github-actions[bot]"
          git config user.email "github-actions[bot]@users.noreply.github.com"
          git add Formula/cliamp.rb
          git commit -m "Update cliamp to ${VERSION}"
          git push