release-app.yml

# # Run for macOS
# act -W .github/workflows/release-app.yml --container-architecture linux/amd64 -j publish-tauri -P macos-latest=-self-hosted

# # Run for Linux
# act -W .github/workflows/release-app.yml --container-architecture linux/amd64 -j publish-tauri -P ubuntu-22.04

name: Release App

on:
  push:
    tags:
      - "v*"
  workflow_dispatch:
    inputs:
      commit_hash:
        description: "Commit hash to build from (optional)"
        required: false
      version:
        description: "Version to set in Cargo.toml (required if commit_hash is provided)"
        required: false

jobs:
  generate_changelog:
    runs-on: ubuntu-latest

    permissions:
      contents: write

    steps:
      - uses: actions/checkout@v4
        with:
          fetch-depth: 0

      - name: Get version from Cargo.toml if not provided
        id: get_version
        run: |
          if [ -z "${{ github.event.inputs.version }}" ]; then
            VERSION=$(grep '^version = ' screenpipe-app-tauri/src-tauri/Cargo.toml | sed 's/version = "\(.*\)"/\1/')
            echo "VERSION=$VERSION" >> $GITHUB_ENV
          else
            echo "VERSION=${{ github.event.inputs.version }}" >> $GITHUB_ENV
          fi

      - name: Generate Changelog
        env:
          OPENAI_API_KEY: ${{ secrets.OPENAI_API_KEY }}
          CN_API_KEY: ${{ secrets.CN_API_KEY }}
        run: .github/scripts/generate_changelog_md.sh ${{ env.VERSION }} ${{ github.event.inputs.commit_hash }}

      - name: Commit and push changelog files
        if: env.CHANGELOG_GENERATED == 1
        run: |
          git config user.name "GitHub Actions Bot"
          git config user.email "github-actions[bot]@users.noreply.github.com"
          git remote set-url origin https://x-access-token:${GH_TOKEN}@github.com/${GITHUB_REPOSITORY}.git
          git add .
          git commit -m "docs: add changelog for ${{ env.VERSION }}"
          git pull origin main
          git push origin main

  draft:
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@v4
        with:
          ref: ${{ github.event.inputs.commit_hash || github.ref }}

      - name: Update version in Cargo.toml
        if: github.event.inputs.commit_hash && github.event.inputs.version
        run: |
          if [[ "$OSTYPE" == "darwin"* ]]; then
            sed -i '' 's/^version = ".*"/version = "${{ github.event.inputs.version }}"/' screenpipe-app-tauri/src-tauri/Cargo.toml
          else
            sed -i 's/^version = ".*"/version = "${{ github.event.inputs.version }}"/' screenpipe-app-tauri/src-tauri/Cargo.toml
          fi

      - name: create draft release
        uses: crabnebula-dev/cloud-release@v0.2
        with:
          command: release draft ${{ secrets.CN_APP_SLUG }} --framework tauri
          api-key: ${{ secrets.CN_API_KEY }}

  publish-tauri:
    permissions:
      contents: write
    strategy:
      fail-fast: false
      matrix:
        include:
          - platform: "macos-latest" # for Arm based macs (M1 and above).
            args: "--target aarch64-apple-darwin --features metal,beta"
            target: aarch64-apple-darwin
            tauri-args: "--target aarch64-apple-darwin"
          - platform: "macos-latest" # for Intel based macs.
            args: "--target x86_64-apple-darwin --features metal,beta"
            target: x86_64-apple-darwin
            tauri-args: "--target x86_64-apple-darwin"
          - platform: "ubuntu-22.04" # Ubuntu x86_64
            args: "--features mkl" # TODO CUDA
            tauri-args: ""
          - platform: [self-hosted, Windows, X64] # Windows x86_64
            args: "--target x86_64-pc-windows-msvc" # TODO CUDA --features mkl --features "openblas"
            pre-build-args: "" # --openblas
            tauri-args: "--target x86_64-pc-windows-msvc"

    runs-on: ${{ matrix.platform }}
    steps:
      - uses: actions/checkout@v4
        with:
          ref: ${{ github.event.inputs.commit_hash || github.ref }}

      - name: Update version in Cargo.toml
        if: github.event.inputs.commit_hash && github.event.inputs.version
        run: |
          if [[ "$OSTYPE" == "darwin"* ]]; then
            sed -i '' 's/^version = ".*"/version = "${{ github.event.inputs.version }}"/' screenpipe-app-tauri/src-tauri/Cargo.toml
          else
            sed -i 's/^version = ".*"/version = "${{ github.event.inputs.version }}"/' screenpipe-app-tauri/src-tauri/Cargo.toml
          fi

      - name: Setup Bun
        uses: oven-sh/setup-bun@v2

      - name: Setup Node
        uses: actions/setup-node@v4
        with:
          node-version: 20

      - name: Install Rust
        if: matrix.args == '--target x86_64-pc-windows-msvc' || matrix.platform == 'big-windows'
        run: |
          Invoke-WebRequest https://static.rust-lang.org/rustup/dist/x86_64-pc-windows-gnu/rustup-init.exe -OutFile rustup-init.exe
          .\rustup-init.exe -y

      - name: Set up Rust
        uses: actions-rust-lang/setup-rust-toolchain@v1
        with:
          toolchain: stable
          override: true
          target: ${{ matrix.target }}
          cache: true
          rustflags: ""

      - uses: actions/cache@v4
        with:
          path: |
            ~/.cargo/registry/index/
            ~/.cargo/registry/cache/
            ~/.cargo/git/db/
            target/${{ matrix.target }}/release/deps
            target/${{ matrix.target }}/release/build
          key: ${{ matrix.platform }}-${{ matrix.target }}-cargo-${{ hashFiles('**/Cargo.lock') }}-v1
          restore-keys: |
            ${{ runner.os }}-${{ matrix.target }}-cargo-v1-

      - name: Cache Homebrew packages
        if: matrix.platform == 'macos-latest'
        uses: actions/cache@v4
        with:
          path: |
            ~/Library/Caches/Homebrew
            /usr/local/Cellar/ffmpeg
            /usr/local/Cellar/pkg-config
          key: ${{ runner.os }}-brew-${{ hashFiles('.github/workflows/release-cli.yml') }}
          restore-keys: |
            ${{ runner.os }}-brew-

      - name: Cache Pre Build
        id: cache-pre-build
        uses: actions/cache@v4
        with:
          path: |
            screenpipe-app-tauri/src-tauri/openblas
            screenpipe-app-tauri/src-tauri/clblast
            screenpipe-app-tauri/src-tauri/ffmpeg
            screenpipe-app-tauri/src-tauri/tesseract-*
          key: ${{ matrix.platform }}-${{ matrix.target }}-pre-build

      - name: Install Linux dependencies
        if: matrix.platform == 'ubuntu-22.04' || matrix.platform == 'big-linux'
        run: |
          sudo apt update
          sudo apt install -y libappindicator3-1 libappindicator3-dev libwebkit2gtk-4.0-dev libwebkit2gtk-4.1-dev libappindicator3-dev librsvg2-dev patchelf wget

      - name: Install dependencies
        if: matrix.platform == 'macos-latest'
        run: |
          brew install ffmpeg pkg-config

      # - name: Install MKL
      #   if: matrix.args == '--target x86_64-pc-windows-msvc'
      #   run: |
      #     pip install mkl mkl-devel mkl-static

      - name: Install MKL in Linux
        if: matrix.platform == 'ubuntu-22.04'
        run: |
          pip install mkl mkl-devel mkl-static
          mkdir -p /opt/intel/mkl
          cp -rfv ~/.local/lib/* ~/.local/include/* /opt/intel/mkl/
          sudo cp -rfv ~/.local/lib/* /usr/lib/x86_64-linux-gnu/

      - name: Install frontend dependencies
        shell: bash
        working-directory: ./screenpipe-app-tauri
        run: |
          ls . 
          bun install

      # - name: Setup tmate session # HACK
      #   if: matrix.args == '--target x86_64-pc-windows-msvc'
      #   uses: mxschmitt/action-tmate@v3

      - name: Install vcpkg
        if: matrix.args == '--target x86_64-pc-windows-msvc' || matrix.platform == 'big-windows'
        uses: lukka/run-vcpkg@v11
        with:
          vcpkgGitCommitId: "7adc2e4d49e8d0efc07a369079faa6bc3dbb90f3"

      - name: Set up MSVC
        if: matrix.args == '--target x86_64-pc-windows-msvc' || matrix.platform == 'big-windows'
        uses: ilammy/msvc-dev-cmd@v1

      - name: Install LLVM and Clang
        if: matrix.args == '--target x86_64-pc-windows-msvc' || matrix.platform == 'big-windows'
        uses: KyleMayes/install-llvm-action@v2
        with:
          version: "10.0"

      - name: Run pre_build.js
        shell: bash
        env:
          SKIP_SCREENPIPE_SETUP: true
        run: |
          bun ./scripts/pre_build.js ${{ matrix.pre-build-args }}
        working-directory: ./screenpipe-app-tauri

      - name: Build CLI
        shell: bash
        env:
          # Windows specific optimizations (only applied when building for Windows)
          CARGO_PROFILE_RELEASE_STRIP: ${{ matrix.args == '--target x86_64-pc-windows-msvc' && 'symbols' || 'none' }}
          CARGO_PROFILE_RELEASE_PANIC: ${{ matrix.args == '--target x86_64-pc-windows-msvc' && 'abort' || 'unwind' }}
          CARGO_PROFILE_RELEASE_INCREMENTAL: ${{ matrix.args == '--target x86_64-pc-windows-msvc' && 'false' || 'true' }}
        run: |
          if [[ "${{ matrix.platform }}" == "macos-latest" ]]; then
            export PKG_CONFIG_PATH="/usr/local/opt/ffmpeg/lib/pkgconfig:$PKG_CONFIG_PATH"
            export PKG_CONFIG_ALLOW_CROSS=1
            export RUSTFLAGS="-C link-arg=-Wl,-rpath,@executable_path/../Frameworks -C link-arg=-Wl,-rpath,@loader_path/../Frameworks -C link-arg=-Wl,-install_name,@rpath/libscreenpipe.dylib"
          fi
          if [[ "${{ matrix.platform }}" == "ubuntu-22.04" ]]; then
            export PKG_CONFIG_PATH="~/.local/lib/pkgconfig:$PKG_CONFIG_PATH"
            export MKLROOT="/opt/intel/mkl"
          fi
          cargo build --release -p screenpipe-server ${{ matrix.args }}

      # Run pre build again to copy the CLI into app
      - name: Run pre_build.js
        shell: bash
        run: |
          bun ./scripts/pre_build.js ${{ matrix.pre-build-args }}
        working-directory: ./screenpipe-app-tauri

      - name: Free Disk Space (Ubuntu)
        if: matrix.platform == 'ubuntu-22.04'
        uses: jlumbroso/free-disk-space@main
        with:
          tool-cache: false
          android: true
          dotnet: true
          haskell: true
          large-packages: false
          docker-images: true
          swap-storage: true

      # - name: Free Disk Space (Windows)
      #   if: matrix.args == '--target x86_64-pc-windows-msvc'
      #   run: |
      #     # Remove unnecessary Windows components
      #     Get-ChildItem -Path "C:\Windows\SoftwareDistribution\Download\" -Force | Remove-Item -Force -Recurse
      #     Remove-Item -Path "C:\Windows\Temp\*" -Force -Recurse
      #     # Clean npm cache
      #     npm cache clean --force
      #     # Clean cargo cache
      #     cargo cache --autoclean
      #     # Remove unused Windows features
      #     dism.exe /online /cleanup-image /startcomponentcleanup /resetbase

      - name: Build
        uses: tauri-apps/tauri-action@v0
        env:
          # for updater
          TAURI_SIGNING_PRIVATE_KEY: ${{ secrets.TAURI_PRIVATE_KEY }}
          TAURI_SIGNING_PRIVATE_KEY_PASSWORD: ${{ secrets.TAURI_KEY_PASSWORD }}
          # for release
          GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
          # for macos signing
          APPLE_CERTIFICATE: ${{ secrets.APPLE_CERTIFICATE }}
          APPLE_CERTIFICATE_PASSWORD: ${{ secrets.APPLE_CERTIFICATE_PASSWORD }}
          APPLE_SIGNING_IDENTITY: ${{ secrets.APPLE_SIGNING_IDENTITY }}
          APPLE_ID: ${{ secrets.APPLE_ID }}
          APPLE_PASSWORD: ${{ secrets.APPLE_PASSWORD }}
          APPLE_TEAM_ID: ${{ secrets.APPLE_TEAM_ID }}
          # https://tauri.app/v1/guides/distribution/sign-macos
          CI: true
          # ubuntu mkl
          PKG_CONFIG_PATH: ${{ matrix.platform == 'ubuntu-22.04' && '~/.local/lib/pkgconfig:$PKG_CONFIG_PATH' || '' }}
          MKLROOT: ${{ matrix.platform == 'ubuntu-22.04' && '/opt/intel/mkl' || '' }}
          # Optimize for build speed on Windows
          CARGO_PROFILE_RELEASE_LTO: ${{ matrix.args == '--target x86_64-pc-windows-msvc' && 'thin' || matrix.platform == 'ubuntu-22.04' && 'true' || 'false' }}
          CARGO_PROFILE_RELEASE_OPT_LEVEL: ${{ matrix.args == '--target x86_64-pc-windows-msvc' && '2' || matrix.platform == 'ubuntu-22.04' && 'z' || '3' }}
          CARGO_PROFILE_RELEASE_CODEGEN_UNITS: ${{ matrix.args == '--target x86_64-pc-windows-msvc' && '16' || matrix.platform == 'ubuntu-22.04' && '1' || '16' }}
          # Enable incremental compilation for Windows
          CARGO_INCREMENTAL: ${{ matrix.args == '--target x86_64-pc-windows-msvc' && 'true' || 'false' }}
          # Windows specific optimizations (only applied when building for Windows)
          CARGO_PROFILE_RELEASE_STRIP: ${{ matrix.args == '--target x86_64-pc-windows-msvc' && 'symbols' || 'none' }}
          CARGO_PROFILE_RELEASE_PANIC: ${{ matrix.args == '--target x86_64-pc-windows-msvc' && 'abort' || 'unwind' }}
          CARGO_PROFILE_RELEASE_INCREMENTAL: ${{ matrix.args == '--target x86_64-pc-windows-msvc' && 'false' || 'true' }}
          RUSTFLAGS: ${{ matrix.args == '--target x86_64-pc-windows-msvc' && '-C target-feature=+crt-static -C link-arg=/LTCG' || '' }}
        with:
          args: ${{ matrix.tauri-args }}
          projectPath: "./screenpipe-app-tauri"
          tauriScript: bunx tauri -v

      - name: Upload Assets to CrabNebula Cloud
        uses: crabnebula-dev/cloud-release@v0.2
        with:
          command: release upload ${{ secrets.CN_APP_SLUG }} --framework tauri
          api-key: ${{ secrets.CN_API_KEY }}
          path: ./screenpipe-app-tauri/src-tauri