release.yml

name: Release

on:
  push:
    tags:
      - "*"
  workflow_dispatch:
    inputs:
      tag:
        description: "Release tag (e.g. 0.3.1)"
        required: true
        type: string
      release_name:
        description: "Release title (leave blank to use tag as title)"
        required: false
        type: string
        default: ""

jobs:
  build:
    name: Build (${{ matrix.name }})
    runs-on: ${{ matrix.runner }}
    continue-on-error: ${{ matrix.experimental == true }}

    strategy:
      fail-fast: false
      matrix:
        include:
          - name: windows-x86_64
            runner: windows-latest
            target: x86_64-pc-windows-msvc
            artifact_name: blockwork-windows-x86_64.exe
            cef_windows_dir: cef_windows_x86_64
            installer_arch: x64compatible
            experimental: false

          - name: windows-arm64
            runner: windows-11-arm
            target: aarch64-pc-windows-msvc
            artifact_name: blockwork-windows-arm64.exe
            cef_windows_dir: cef_windows_aarch64
            installer_arch: arm64
            experimental: true

          - name: macos-arm64
            runner: macos-latest
            target: aarch64-apple-darwin
            artifact_name: blockwork-macos-arm64
            experimental: true

    steps:
      - name: Checkout
        uses: actions/checkout@v4

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

      - name: Cache Rust build artifacts
        uses: Swatinem/rust-cache@v2
        with:
          key: ${{ matrix.target }}

      - name: Install pnpm
        uses: pnpm/action-setup@v4
        with:
          package_json_file: ui/package.json

      - name: Install Node.js
        uses: actions/setup-node@v4
        with:
          node-version: 22
          cache: pnpm
          cache-dependency-path: ui/pnpm-lock.yaml

      - name: Build (release, Windows)
        if: runner.os == 'Windows'
        run: cargo build --release --target ${{ matrix.target }} --workspace --exclude blockwork-linux-bridge

      - name: Stage CEF runtime files (Windows)
        if: runner.os == 'Windows'
        shell: pwsh
        run: |
          $releaseDir = "target/${{ matrix.target }}/release"
          $cefBuildDir = Get-ChildItem "$releaseDir/build" -Directory -Filter "cef-dll-sys-*" |
            Sort-Object LastWriteTime -Descending | Select-Object -First 1
          $cefRuntimeDir = Get-ChildItem (Join-Path $cefBuildDir.FullName "out") -Recurse -Directory -Filter "${{ matrix.cef_windows_dir }}" |
            Select-Object -First 1
          Get-ChildItem $cefRuntimeDir.FullName -File | Copy-Item -Destination $releaseDir -Force
          Copy-Item (Join-Path $cefRuntimeDir.FullName "locales") $releaseDir -Recurse -Force

      - name: Rename binary (Windows)
        if: runner.os == 'Windows'
        shell: pwsh
        run: Copy-Item target/${{ matrix.target }}/release/blockwork.exe ${{ matrix.artifact_name }}

      - name: Upload artifact
        if: runner.os == 'Windows'
        uses: actions/upload-artifact@v4
        with:
          name: ${{ matrix.artifact_name }}
          path: ${{ matrix.artifact_name }}
          if-no-files-found: error
          retention-days: 90

      - name: Build macOS app bundle
        if: runner.os == 'macOS'
        run: ./scripts/build-macos-bundle.sh ${{ matrix.target }}

      - name: Zip macOS app bundle
        if: runner.os == 'macOS'
        run: ditto -c -k --sequesterRsrc --keepParent dist/Blockwork.app ${{ matrix.artifact_name }}.app.zip

      - name: Upload macOS app bundle
        if: runner.os == 'macOS'
        uses: actions/upload-artifact@v4
        with:
          name: ${{ matrix.artifact_name }}.app.zip
          path: ${{ matrix.artifact_name }}.app.zip
          if-no-files-found: error
          retention-days: 90

      - name: Locate or install Inno Setup
        if: runner.os == 'Windows'
        shell: pwsh
        run: |
          $iscc = "C:\Program Files (x86)\Inno Setup 6\ISCC.exe"
          if (-not (Test-Path $iscc)) {
            choco install innosetup -y
          }

      - name: Determine installer version
        if: runner.os == 'Windows'
        id: installer_version
        shell: pwsh
        run: |
          $tag = "${{ github.event_name == 'workflow_dispatch' && inputs.tag || github.ref_name }}"
          $version = $tag -replace '^v', ''
          echo "value=$version" >> $env:GITHUB_OUTPUT

      - name: Build installer (Inno Setup)
        if: runner.os == 'Windows'
        shell: pwsh
        run: |
          $iscc = "C:\Program Files (x86)\Inno Setup 6\ISCC.exe"
          & $iscc "/DMyAppVersion=${{ steps.installer_version.outputs.value }}" "/DTargetTriple=${{ matrix.target }}" "/DInstallerArch=${{ matrix.installer_arch }}" "/DOutputBaseFilename=blockwork-${{ matrix.name }}-setup" installer\blockwork.iss

      - name: Upload installer artifact
        if: runner.os == 'Windows'
        uses: actions/upload-artifact@v4
        with:
          name: blockwork-${{ matrix.name }}-setup.exe
          path: dist/blockwork-${{ matrix.name }}-setup.exe
          if-no-files-found: error
          retention-days: 90

      - name: Build MSIX (Microsoft Store)
        if: matrix.name == 'windows-x86_64'
        shell: pwsh
        run: ./scripts/build-msix.ps1 -Version "${{ steps.installer_version.outputs.value }}" -Target ${{ matrix.target }} -Arch x64

      - name: Upload MSIX artifact
        if: matrix.name == 'windows-x86_64'
        uses: actions/upload-artifact@v4
        with:
          name: blockwork-windows-x86_64.msix
          path: dist/blockwork-windows-x86_64.msix
          if-no-files-found: error
          retention-days: 90

  linux-appimage:
    name: AppImage (${{ matrix.name }})
    runs-on: ${{ matrix.runner }}

    strategy:
      fail-fast: false
      matrix:
        include:
          - name: linux-x86_64
            runner: ubuntu-latest
            target: x86_64-unknown-linux-gnu
            artifact_name: blockwork-linux-x86_64
            linux_arch: x86_64

          - name: linux-arm64
            runner: ubuntu-24.04-arm
            target: aarch64-unknown-linux-gnu
            artifact_name: blockwork-linux-arm64
            linux_arch: aarch64

    steps:
      - name: Checkout
        uses: actions/checkout@v4

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

      - name: Cache Rust build artifacts
        uses: Swatinem/rust-cache@v2
        with:
          key: ${{ matrix.target }}

      - name: Install Linux system dependencies
        run: |
          sudo apt-get update -qq
          sudo apt-get install -y --no-install-recommends \
            pkg-config \
            build-essential \
            curl \
            wget \
            file \
            libssl-dev \
            libxdo-dev \
            libayatana-appindicator3-dev \
            librsvg2-dev \
            libwebkit2gtk-4.1-dev \
            libdbus-1-dev \
            libxkbcommon-dev \
            libxkbcommon-x11-0 \
            libx11-dev \
            libx11-xcb-dev \
            libxtst-dev \
            libwayland-dev \
            wayland-protocols \
            libclang-dev

      - name: Install pnpm
        uses: pnpm/action-setup@v4
        with:
          package_json_file: ui/package.json

      - name: Install Node.js
        uses: actions/setup-node@v4
        with:
          node-version: 22
          cache: pnpm
          cache-dependency-path: ui/pnpm-lock.yaml

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

      - name: Stage CEF runtime files
        run: |
          releaseDir="target/${{ matrix.target }}/release"
          cefBuildDir=$(ls -dt "$releaseDir"/build/cef-dll-sys-*/ | head -1)
          cefRuntimeDir=$(find "${cefBuildDir}out" -maxdepth 2 -type d -name "cef_linux_${{ matrix.linux_arch }}" | head -1)
          find "$cefRuntimeDir" -maxdepth 1 -type f -exec cp -f {} "$releaseDir/" \;
          cp -r "$cefRuntimeDir/locales" "$releaseDir/"

      - name: Rename binary
        run: cp target/${{ matrix.target }}/release/blockwork ${{ matrix.artifact_name }}

      - name: Build AppImage
        run: |
          export APPIMAGE_EXTRACT_AND_RUN=1
          wget -q -O linuxdeploy.AppImage "https://github.com/linuxdeploy/linuxdeploy/releases/download/continuous/linuxdeploy-${{ matrix.linux_arch }}.AppImage"
          wget -q -O linuxdeploy-plugin-appimage.AppImage "https://github.com/linuxdeploy/linuxdeploy-plugin-appimage/releases/download/continuous/linuxdeploy-plugin-appimage-${{ matrix.linux_arch }}.AppImage"
          chmod +x linuxdeploy.AppImage linuxdeploy-plugin-appimage.AppImage
          mkdir -p appimage-staging
          # Exec entry wants a binary named blockwork.
          cp ${{ matrix.artifact_name }} appimage-staging/blockwork

          # CEF runtime sits next to the binary in target/<triple>/release.
          # linuxdeploy only finds libcef.so via ldd, so copy the rest by hand.
          CEF_DIR="target/${{ matrix.target }}/release"
          cp "$CEF_DIR/libcef.so" appimage-staging/
          # Daemon ships next to blockwork in usr/bin.
          cp "$CEF_DIR/blockwork-daemon" appimage-staging/

          export LINUXDEPLOY_EXCLUDED_LIBRARIES="libnspr4.so;libplc4.so;libplds4.so;libnss3.so;libnssutil3.so;libsmime3.so"

          ./linuxdeploy.AppImage \
            --appdir AppDir \
            --executable ./appimage-staging/blockwork \
            --executable ./appimage-staging/blockwork-daemon \
            --desktop-file res/blockwork.desktop \
            --icon-file res/icons/blockwork.png

          cp "$CEF_DIR"/libEGL.so "$CEF_DIR"/libGLESv2.so "$CEF_DIR"/libvk_swiftshader.so \
             "$CEF_DIR"/libvulkan.so.1 "$CEF_DIR"/vk_swiftshader_icd.json "$CEF_DIR"/chrome-sandbox \
             "$CEF_DIR"/icudtl.dat "$CEF_DIR"/v8_context_snapshot.bin "$CEF_DIR"/chrome_100_percent.pak \
             "$CEF_DIR"/chrome_200_percent.pak "$CEF_DIR"/resources.pak \
             AppDir/usr/lib/
          cp -r "$CEF_DIR/locales" AppDir/usr/lib/

          ./linuxdeploy.AppImage --appdir AppDir --output appimage
          mv Blockwork*.AppImage ${{ matrix.artifact_name }}.AppImage

      - name: Upload AppImage artifact
        uses: actions/upload-artifact@v4
        with:
          name: ${{ matrix.artifact_name }}.AppImage
          path: ${{ matrix.artifact_name }}.AppImage
          if-no-files-found: error
          retention-days: 90

  linux-flatpak:
    name: Flatpak (${{ matrix.name }})
    runs-on: ${{ matrix.runner }}

    strategy:
      fail-fast: false
      matrix:
        include:
          - name: linux-x86_64
            runner: ubuntu-latest
            artifact_name: blockwork-linux-x86_64

          - name: linux-arm64
            runner: ubuntu-24.04-arm
            artifact_name: blockwork-linux-arm64

    steps:
      - name: Checkout
        uses: actions/checkout@v4
        with:
          submodules: recursive

      - name: Install Flatpak tooling
        run: |
          sudo apt-get update -qq
          sudo apt-get install -y --no-install-recommends flatpak flatpak-builder elfutils
          flatpak remote-add --if-not-exists --user flathub https://flathub.org/repo/flathub.flatpakrepo
          flatpak install --user --noninteractive flathub \
            org.gnome.Platform//50 org.gnome.Sdk//50 \
            org.freedesktop.Sdk.Extension.rust-stable//25.08 org.freedesktop.Sdk.Extension.node24//25.08

      - name: Build Flatpak
        # Offline sandbox build, no host cargo build needed.
        run: |
          manifest=packaging/flatpak/com.blockworked.Blockwork
          awk '
            /# BEGIN app-source/ {
              print
              print "      - type: dir"
              print "        path: ../.."
              print "        skip: [target, .git, .flatpak-builder, flatpak-build, flatpak-repo, node_modules, ui/node_modules, ui/dist, packaging/flatpak]"
              skip = 1
              next
            }
            /# END app-source/ { skip = 0 }
            !skip
          ' "$manifest.yml" > "$manifest.local.yml"
          flatpak-builder --force-clean --user --default-branch=stable --repo=flatpak-repo flatpak-build "$manifest.local.yml"
          flatpak build-bundle flatpak-repo ${{ matrix.artifact_name }}.flatpak com.blockworked.Blockwork stable

      - name: Upload Flatpak artifact
        uses: actions/upload-artifact@v4
        with:
          name: ${{ matrix.artifact_name }}.flatpak
          path: ${{ matrix.artifact_name }}.flatpak
          if-no-files-found: error
          retention-days: 90

  release:
    name: Create GitHub Release
    runs-on: ubuntu-latest
    needs: [build, linux-appimage, linux-flatpak]
    if: always()
    permissions:
      contents: write

    steps:
      - name: Checkout
        uses: actions/checkout@v4

      - name: Determine release tag
        id: tag
        run: |
          if [ "${{ github.event_name }}" = "workflow_dispatch" ]; then
            echo "value=${{ inputs.tag }}" >> "$GITHUB_OUTPUT"
          else
            echo "value=${{ github.ref_name }}" >> "$GITHUB_OUTPUT"
          fi

      - name: Determine release name
        id: release_name
        run: |
          NAME="${{ inputs.release_name }}"
          if [ -z "$NAME" ]; then
            NAME="${{ steps.tag.outputs.value }}"
          fi
          echo "value=$NAME" >> "$GITHUB_OUTPUT"

      - name: Build release notes from CHANGELOG.md
        env:
          TAG: ${{ steps.tag.outputs.value }}
        run: |
          VERSION="${TAG#v}"
          awk -v ver="$VERSION" 'index($0, "## [" ver "]") == 1 {flag=1; print; next} flag && /^## \[/ {exit} flag' CHANGELOG.md > /tmp/changelog_section.md
          if [ ! -s /tmp/changelog_section.md ]; then
            echo "## $TAG" > /tmp/changelog_section.md
            echo "" >> /tmp/changelog_section.md
            echo "See commit history since the previous tag for details." >> /tmp/changelog_section.md
          fi
          {
            cat /tmp/changelog_section.md
            echo ""
            echo "## Downloads"
            echo ""
            echo "| Platform | File |"
            echo "|---|---|"
            echo "| Windows x86_64 (installer) | \`blockwork-windows-x86_64-setup.exe\` |"
            echo "| Windows x86_64 (portable exe) | \`blockwork-windows-x86_64.exe\` |"
            echo "| Windows x86_64 (MSIX, for the Microsoft Store) | \`blockwork-windows-x86_64.msix\` |"
            echo "| Windows arm64 (installer) | \`blockwork-windows-arm64-setup.exe\` |"
            echo "| Windows arm64 (portable exe) | \`blockwork-windows-arm64.exe\` |"
            echo "| Linux x86_64 (AppImage) | \`blockwork-linux-x86_64.AppImage\` |"
            echo "| Linux x86_64 (Flatpak) | \`blockwork-linux-x86_64.flatpak\` |"
            echo "| Linux arm64 (AppImage) | \`blockwork-linux-arm64.AppImage\` |"
            echo "| Linux arm64 (Flatpak) | \`blockwork-linux-arm64.flatpak\` |"
            echo "| macOS arm64 (app bundle, unsigned) | \`blockwork-macos-arm64.app.zip\` |"
          } > RELEASE_BODY.md
          cat RELEASE_BODY.md

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

      - name: List release artifacts
        run: ls -lh ./release-artifacts/

      - name: Create GitHub Release
        uses: softprops/action-gh-release@v2
        with:
          tag_name: ${{ steps.tag.outputs.value }}
          name: ${{ steps.release_name.outputs.value }}
          draft: false
          prerelease: false
          fail_on_unmatched_files: false
          files: ./release-artifacts/*
          body_path: RELEASE_BODY.md

  chocolatey:
    name: Chocolatey
    needs: [release]
    uses: ./.github/workflows/chocolatey.yml
    with:
      tag: ${{ github.event_name == 'workflow_dispatch' && inputs.tag || github.ref_name }}
    secrets: inherit

  homebrew:
    name: Homebrew
    needs: [release]
    uses: ./.github/workflows/homebrew.yml
    with:
      tag: ${{ github.event_name == 'workflow_dispatch' && inputs.tag || github.ref_name }}
    secrets: inherit

  winget:
    name: Publish to winget
    runs-on: windows-latest
    needs: [release]
    env:
      WINGET_TOKEN: ${{ secrets.WINGET_TOKEN }}

    steps:
      # Updates an existing package; the first version is submitted by hand
      - name: Open winget-pkgs PR
        if: env.WINGET_TOKEN != ''
        uses: vedantmgoyal9/winget-releaser@main
        with:
          identifier: Blockworked.Blockwork
          release-tag: ${{ github.event_name == 'workflow_dispatch' && inputs.tag || github.ref_name }}
          installers-regex: '-setup\.exe$'
          token: ${{ secrets.WINGET_TOKEN }}