release.yml

name: Release

on:
  push:
    tags:
      - "v*"

permissions:
  contents: write

jobs:
  build:
    name: Build (${{ matrix.archive_name }}.${{ matrix.archive_ext }})
    runs-on: ${{ matrix.os }}
    strategy:
      fail-fast: false
      matrix:
        include:
          # Linux x86_64 — native
          - os: ubuntu-latest
            target: x86_64-unknown-linux-gnu
            archive_name: starforge-linux-x86_64
            archive_ext: tar.gz
            binary_name: starforge

          # macOS ARM64 — native on macos-latest (M1 runner)
          - os: macos-latest
            target: aarch64-apple-darwin
            archive_name: starforge-macos-aarch64
            archive_ext: tar.gz
            binary_name: starforge

          # Windows x86_64 — native
          - os: windows-latest
            target: x86_64-pc-windows-msvc
            archive_name: starforge-windows-x86_64
            archive_ext: zip
            binary_name: starforge.exe

          # Linux ARM64 — cross-compiled using `cross`
          - os: ubuntu-latest
            target: aarch64-unknown-linux-gnu
            archive_name: starforge-linux-aarch64
            archive_ext: tar.gz
            binary_name: starforge

    steps:
      - uses: actions/checkout@v4

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

      # Only runs for the aarch64-unknown-linux-gnu matrix entry
      - name: Install aarch64 Linux cross-linker
        if: matrix.target == 'aarch64-unknown-linux-gnu'
        run: sudo apt-get install -y gcc-aarch64-linux-gnu

      # Tells cargo which linker to use when targeting aarch64 Linux
      - name: Configure cargo linker for aarch64 Linux
        if: matrix.target == 'aarch64-unknown-linux-gnu'
        run: |
          mkdir -p ~/.cargo
          cat >> ~/.cargo/config.toml << 'EOF'
          [target.aarch64-unknown-linux-gnu]
          linker = "aarch64-linux-gnu-gcc"
          EOF

      - name: Build
        run: cargo build --release --locked --target ${{ matrix.target }}

      # Linux and macOS produce .tar.gz
      - name: Package binary (Linux / macOS)
        if: runner.os != 'Windows'
        run: |
          mkdir -p dist
          if [ "${{ matrix.target }}" = "aarch64-unknown-linux-gnu" ]; then
            cp target/${{ matrix.target }}/release/${{ matrix.binary_name }} dist/starforge
          else
            cp target/${{ matrix.target }}/release/${{ matrix.binary_name }} dist/starforge
          fi
          tar -czf "dist/${{ matrix.archive_name }}.tar.gz" -C dist starforge
          rm dist/starforge

      # Windows produces .zip
      - name: Package binary (Windows)
        if: runner.os == 'Windows'
        shell: bash
        run: |
          mkdir -p dist
          cp target/${{ matrix.target }}/release/${{ matrix.binary_name }} dist/
          cd dist
          7z a "${{ matrix.archive_name }}.zip" "${{ matrix.binary_name }}"
          rm "${{ matrix.binary_name }}"

      # Generate checksums for all archives
      - name: Generate checksums
        shell: bash
        run: |
          cd dist
          if [ "${{ runner.os }}" = "Windows" ]; then
            certutil -hashfile "${{ matrix.archive_name }}.zip" SHA256 | grep -v "SHA256 hash" | grep -v "^$" > checksums.txt
          else
            sha256sum "${{ matrix.archive_name }}.tar.gz" >> checksums.txt
          fi

      - name: Upload build artifact
        uses: actions/upload-artifact@v4
        with:
          name: ${{ matrix.archive_name }}
          path: |
            dist/${{ matrix.archive_name }}.*
            dist/checksums.txt

  release:
    name: Publish GitHub Release
    needs: build
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@v4

      - name: Download all artifacts
        uses: actions/download-artifact@v4
        with:
          path: release-artifacts

      - name: Prepare release files
        run: |
          mkdir -p release-files
          find release-artifacts -type f \( -name "*.tar.gz" -o -name "*.zip" \) -exec cp {} release-files/ \;
          find release-artifacts -type f -name "checksums.txt" -exec cat {} >> release-files/SHA256SUMS.txt \;

      - name: Publish GitHub release
        uses: softprops/action-gh-release@v2
        with:
          files: |
            release-files/*

  homebrew:
    name: Update Homebrew Formula
    needs: release
    runs-on: ubuntu-latest
    if: github.event_name == 'push' && startsWith(github.ref, 'refs/tags/')
    steps:
      - uses: actions/checkout@v4

      - name: Extract version from tag
        id: version
        run: |
          VERSION=${GITHUB_REF#refs/tags/v}
          echo "version=$VERSION" >> $GITHUB_OUTPUT

      - name: Download Linux binary
        uses: actions/download-artifact@v4
        with:
          name: starforge-linux-x86_64
          path: homebrew-build

      - name: Generate Homebrew formula
        run: |
          VERSION="${{ steps.version.outputs.version }}"
          TARBALL="https://github.com/${{ github.repository }}/releases/download/v${VERSION}/starforge-linux-x86_64.tar.gz"
          SHA256=$(cd homebrew-build && sha256sum starforge-linux-x86_64.tar.gz | cut -d' ' -f1)

          cat > homebrew-formula.rb << EOF
          class Starforge < Formula
            desc "Deploy Soroban smart contracts with enhanced CLI"
            homepage "https://github.com/${{ github.repository }}"
            url "${TARBALL}"
            sha256 "${SHA256}"
            version "${VERSION}"

            def install
              bin.install "starforge"
            end

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

          cat homebrew-formula.rb

      - name: Create PR to homebrew-core (optional)
        run: |
          echo "Homebrew formula generated. Manual PR creation or automation can be set up."