release.yml

name: Release

on:
  push:
    tags:
      - 'v*'

env:
  REGISTRY: ghcr.io
  IMAGE_BASE: ghcr.io/${{ github.repository }}

jobs:
  prepare:
    name: Prepare Release
    runs-on: blacksmith-4vcpu-ubuntu-2404
    permissions:
      contents: write
    outputs:
      packages: ${{ steps.detect.outputs.packages }}
      has_releases: ${{ steps.detect.outputs.has_releases }}
    steps:
      - name: Checkout Repo
        uses: actions/checkout@v4
        with:
          fetch-depth: 0
          token: ${{ secrets.GITHUB_TOKEN }}

      - name: Install pnpm
        uses: pnpm/action-setup@v4

      - uses: actions/setup-node@v4
        with:
          node-version: 22
          cache: 'pnpm'

      - name: Extract Version
        id: get_version
        run: echo "VERSION=${GITHUB_REF#refs/tags/v}" >> $GITHUB_ENV

      - name: Set Versions
        run: node scripts/set-version.js ${{ env.VERSION }}
      
      - name: Update Lockfile
        run: pnpm install --lockfile-only

      - name: Git Identity
        run: |
          git config --global user.name 'github-actions[bot]'
          git config --global user.email 'github-actions[bot]@users.noreply.github.com'

      - name: Commit and Sync
        run: |
          # Commit changes only if there are any
          if [ -n "$(git status --porcelain)" ]; then
            git add .
            git commit -m "chore: release v${{ env.VERSION }}"
          else
            echo "No changes to commit. Version might have been manually bumped."
          fi
          
          # Push to release branch
          git push origin HEAD:release
          
          # Sync to development
          git fetch origin release
          git checkout development
          git pull origin development
          git merge origin/release
          git push origin development

      - name: Find All Packages with Dockerfiles
        id: detect
        run: |
          PACKAGES="[]"
          
          # Find all package.json files in apps and packages directories
          PACKAGE_JSONS=$(find apps packages -maxdepth 2 -name "package.json" 2>/dev/null || true)
          
          for PKG_FILE in $PACKAGE_JSONS; do
            DIR=$(dirname "$PKG_FILE")
            
            # Only include packages that have a Dockerfile
            if [ -f "$DIR/Dockerfile" ]; then
              NAME=$(node -p "require('./$PKG_FILE').name" 2>/dev/null || echo "")
              VERSION=$(node -p "require('./$PKG_FILE').version" 2>/dev/null || echo "")
              
              if [ -n "$NAME" ] && [ -n "$VERSION" ]; then
                ITEM=$(jq -n \
                  --arg name "$NAME" \
                  --arg version "$VERSION" \
                  --arg dir "$DIR" \
                  '{name: $name, version: $version, dir: $dir}')
                
                PACKAGES=$(echo "$PACKAGES" | jq -c --argjson item "$ITEM" '. + [$item]')
                echo "Found: $NAME@$VERSION (dir: $DIR)"
              fi
            fi
          done
          
          # Use heredoc to safely output JSON
          echo "packages<<EOF" >> $GITHUB_OUTPUT
          echo "$PACKAGES" >> $GITHUB_OUTPUT
          echo "EOF" >> $GITHUB_OUTPUT
          
          if [ "$PACKAGES" != "[]" ]; then
            echo "has_releases=true" >> $GITHUB_OUTPUT
          else
            echo "has_releases=false" >> $GITHUB_OUTPUT
          fi
          
          echo "Packages for Docker build:"
          echo "$PACKAGES" | jq .

  publish-docker:
    name: Publish Docker Images
    needs: prepare
    if: needs.prepare.outputs.has_releases == 'true'
    runs-on: blacksmith-8vcpu-ubuntu-2404
    permissions:
      contents: read
      packages: write
    strategy:
      fail-fast: false
      matrix:
        package: ${{ fromJson(needs.prepare.outputs.packages) }}
    steps:
      - name: Checkout
        uses: actions/checkout@v4
        with:
          ref: release
          
      - name: Prepare Docker Metadata
        id: prep
        run: |
          PACKAGE_NAME="${{ matrix.package.name }}"
          # Remove scope if present (e.g. @uptimekit/dash -> dash)
          APP_NAME=${PACKAGE_NAME#@*/}
          APP_NAME=${APP_NAME#*/}
          
          # Construct image name
          IMAGE_NAME=${{ env.REGISTRY }}/${{ github.repository_owner }}/${APP_NAME}
          # Lowercase just in case
          IMAGE_NAME=$(echo "$IMAGE_NAME" | tr '[:upper:]' '[:lower:]')
          
          echo "image_name=$IMAGE_NAME" >> $GITHUB_OUTPUT
          echo "app_name_clean=$APP_NAME" >> $GITHUB_OUTPUT
          echo "app_dir=${{ matrix.package.dir }}" >> $GITHUB_OUTPUT

      - name: Docker meta
        id: meta
        uses: docker/metadata-action@v5
        with:
          images: |
            ${{ steps.prep.outputs.image_name }}
            uptimekit/${{ steps.prep.outputs.app_name_clean }}
          tags: |
            type=semver,pattern={{version}},value=${{ matrix.package.version }}
            type=semver,pattern={{major}}.{{minor}},value=${{ matrix.package.version }}
            type=semver,pattern={{major}},value=${{ matrix.package.version }}
            type=raw,value=latest

      - name: Set up QEMU
        uses: docker/setup-qemu-action@v3

      - name: Setup Blacksmith Builder
        uses: useblacksmith/setup-docker-builder@v1

      - name: Docker Login to GHCR
        uses: docker/login-action@v3
        with:
          registry: ${{ env.REGISTRY }}
          username: ${{ github.actor }}
          password: ${{ secrets.GITHUB_TOKEN }}

      - name: Docker Login to Docker Hub
        uses: docker/login-action@v3
        with:
          username: ${{ secrets.DOCKER_USERNAME }}
          password: ${{ secrets.DOCKER_TOKEN }}

      - name: Docker Image Publish
        uses: useblacksmith/build-push-action@v2
        with:
          context: .
          file: ${{ steps.prep.outputs.app_dir }}/Dockerfile
          push: true
          tags: ${{ steps.meta.outputs.tags }}
          labels: ${{ steps.meta.outputs.labels }}