tauri-apps/tauri

# Copyright 2019-2024 Tauri Programme within The Commons Conservancy
# SPDX-License-Identifier: Apache-2.0
# SPDX-License-Identifier: MIT

name: Audit

on:
  workflow_dispatch:
  schedule:
    - cron: '0 0 * * *'
  pull_request:
    paths:
      - '.github/workflows/audit.yml'
      - '**/Cargo.lock'
      - '**/Cargo.toml'
      - '**/package.json'
      - '**/pnpm-lock.yaml'
  push:
    branches:
      - dev
    paths:
      - '.github/workflows/audit.yml'
      - '**/Cargo.lock'
      - '**/Cargo.toml'
      - '**/package.json'
      - '**/pnpm-lock.yaml'

concurrency:
  group: ${{ github.workflow }}-${{ github.ref }}
  cancel-in-progress: true

jobs:
  audit-rust:
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@v4
      - name: rust audit
        uses: rustsec/audit-check@v2
        with:
          token: ${{ secrets.GITHUB_TOKEN }}

  audit-js:
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@v4
      - run: npm i -g --force corepack
      - uses: actions/setup-node@v4
        with:
          node-version: 'lts/*'
      - run: pnpm audit

# Copyright 2019-2024 Tauri Programme within The Commons Conservancy
# SPDX-License-Identifier: Apache-2.0
# SPDX-License-Identifier: MIT

name: bench

on:
  push:
    branches:
      - dev
  workflow_dispatch:
  pull_request:
    paths:
      - '.github/workflows/bench.yml'
      - 'bench/**'

env:
  RUST_BACKTRACE: 1
  CARGO_PROFILE_DEV_DEBUG: 0 # This would add unnecessary bloat to the target folder, decreasing cache efficiency.
  LC_ALL: en_US.UTF-8 # This prevents strace from changing its number format to use commas.

concurrency:
  group: ${{ github.workflow }}-${{ github.ref }}
  cancel-in-progress: true

jobs:
  bench:
    strategy:
      fail-fast: false
      matrix:
        rust: [nightly]
        platform:
          - { target: x86_64-unknown-linux-gnu, os: ubuntu-latest }

    runs-on: ${{ matrix.platform.os }}

    steps:
      - uses: actions/checkout@v4

      - name: install Rust ${{ matrix.rust }}
        uses: dtolnay/rust-toolchain@master
        with:
          toolchain: ${{ matrix.rust }}
          components: rust-src
          targets: ${{ matrix.platform.target }}

      - name: setup python
        uses: actions/setup-python@v5
        with:
          python-version: '3.10'
          architecture: x64

      - name: install dependencies
        run: |
          python -m pip install --upgrade pip
          sudo apt-get update
          sudo apt-get install -y --no-install-recommends \
            webkit2gtk-4.1 libayatana-appindicator3-dev \
            xvfb \
            at-spi2-core
          wget https://github.com/sharkdp/hyperfine/releases/download/v1.18.0/hyperfine_1.18.0_amd64.deb
          sudo dpkg -i hyperfine_1.18.0_amd64.deb
          pip install memory_profiler

      - uses: Swatinem/rust-cache@v2

      - name: run benchmarks
        run: |
          cargo build --manifest-path bench/tests/cpu_intensive/src-tauri/Cargo.toml --release -Z build-std=std,panic_abort -Z build-std-features=panic_immediate_abort --target ${{ matrix.platform.target }}
          cargo build --manifest-path bench/tests/files_transfer/src-tauri/Cargo.toml --release -Z build-std=std,panic_abort -Z build-std-features=panic_immediate_abort --target ${{ matrix.platform.target }}
          cargo build --manifest-path bench/tests/helloworld/src-tauri/Cargo.toml --release -Z build-std=std,panic_abort -Z build-std-features=panic_immediate_abort --target ${{ matrix.platform.target }}
          xvfb-run --auto-servernum cargo run --manifest-path bench/Cargo.toml --bin run_benchmark

      - name: clone benchmarks_results
        if: github.repository == 'tauri-apps/tauri' && github.ref == 'refs/heads/dev'
        uses: actions/checkout@v4
        with:
          token: ${{ secrets.BENCH_PAT }}
          path: gh-pages
          repository: tauri-apps/benchmark_results

      - name: push new benchmarks
        if: github.repository == 'tauri-apps/tauri' && github.ref == 'refs/heads/dev'
        run: |
          cargo run --manifest-path bench/Cargo.toml --bin build_benchmark_jsons
          cd gh-pages
          git pull
          git config user.name "tauri-bench"
          git config user.email "gh.tauribot@gmail.com"
          git add .
          git commit --message "Update Tauri benchmarks"
          git push origin gh-pages

      - name: Print worker info
        run: |
          cat /proc/cpuinfo
          cat /proc/meminfo

# Copyright 2019-2024 Tauri Programme within The Commons Conservancy
# SPDX-License-Identifier: Apache-2.0
# SPDX-License-Identifier: MIT

name: check change tags

on:
  pull_request:
    paths:
      - '.changes/*.md'

concurrency:
  group: ${{ github.workflow }}-${{ github.ref }}
  cancel-in-progress: true

jobs:
  check:
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@v4

      - name: check change files end with .md
        run: |
          for file in .changes/*
          do
            if [[ ! "$file" =~ \.(md|json)$ ]]; then
              echo ".changes directory should only contain files that end with .md"
              echo "found an invalid file in .changes directory:"
              echo "$file"
              exit 1
            fi
          done

      - uses: dorny/paths-filter@v3
        id: filter
        with:
          list-files: shell
          filters: |
            changes:
              - added|modified: '.changes/*.md'

      - name: check
        run: node ./.scripts/ci/check-change-tags.js ${{ steps.filter.outputs.changes_files }}
        if: ${{ steps.filter.outputs.changes == 'true' }}

# Copyright 2019-2024 Tauri Programme within The Commons Conservancy
# SPDX-License-Identifier: Apache-2.0
# SPDX-License-Identifier: MIT

name: check generated files

on:
  pull_request:
    paths:
      - '.github/workflows/check-generated-files.yml'
      - 'pnpm-lock.yaml'
      - 'packages/api/src/**'
      - 'crates/tauri/scripts/bundle.global.js'
      - 'crates/tauri-utils/src/config.rs'
      - 'crates/tauri-cli/config.schema.json'
      - 'crates/tauri-schema-generator/schemas/*.json'

concurrency:
  group: ${{ github.workflow }}-${{ github.ref }}
  cancel-in-progress: true

jobs:
  changes:
    runs-on: ubuntu-latest
    outputs:
      api: ${{ steps.filter.outputs.api }}
      schema: ${{ steps.filter.outputs.schema }}
    steps:
      - uses: actions/checkout@v4
      - uses: dorny/paths-filter@v3
        id: filter
        with:
          filters: |
            api:
              - 'pnpm-lock.yaml'
              - 'packages/api/src/**'
              - 'crates/tauri/scripts/bundle.global.js'
            schema:
              - 'crates/tauri-utils/src/config.rs'
              - 'crates/tauri-cli/config.schema.json'
              - 'crates/tauri-schema-generator/schemas/*.json'

  api:
    runs-on: ubuntu-latest
    needs: changes
    if: needs.changes.outputs.api == 'true'
    steps:
      - uses: actions/checkout@v4
      - run: npm i -g --force corepack
      - uses: actions/setup-node@v4
        with:
          node-version: 'lts/*'
          cache: 'pnpm'

      - name: install deps
        run: pnpm i --frozen-lockfile
      - name: build api
        run: pnpm build
        working-directory: packages/api
      - name: check api
        run: ./.scripts/ci/has-diff.sh

  schema:
    runs-on: ubuntu-latest
    needs: changes
    if: needs.changes.outputs.schema == 'true'
    steps:
      - uses: actions/checkout@v4

      - name: install stable
        uses: dtolnay/rust-toolchain@stable

      - name: install Linux dependencies
        run: |
          sudo apt-get update
          sudo apt-get install -y libgtk-3-dev

      - uses: Swatinem/rust-cache@v2

      - name: generate schemas
        run: cargo build --manifest-path ./crates/tauri-schema-generator/Cargo.toml

      - name: check schemas
        run: ./.scripts/ci/has-diff.sh

# Copyright 2019-2024 Tauri Programme within The Commons Conservancy
# SPDX-License-Identifier: Apache-2.0
# SPDX-License-Identifier: MIT

name: check license headers

on:
  pull_request:

concurrency:
  group: ${{ github.workflow }}-${{ github.ref }}
  cancel-in-progress: true

jobs:
  check:
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@v4
      - uses: dorny/paths-filter@v3
        id: filter
        with:
          list-files: shell
          filters: |
            added:
              - added: '**'
      - name: check header license on new files
        if: ${{ steps.filter.outputs.added == 'true' }}
        run: node ./.scripts/ci/check-license-header.js ${{ steps.filter.outputs.added_files }}

# Copyright 2019-2024 Tauri Programme within The Commons Conservancy
# SPDX-License-Identifier: Apache-2.0
# SPDX-License-Identifier: MIT

name: covector comment
on:
  workflow_run:
    workflows: [covector status] # the `name` of the workflow run on `pull_request` running `status` with `comment: true`
    types:
      - completed

# note all other permissions are set to none if not specified
#  and these set the permissions for `secrets.GITHUB_TOKEN`
permissions:
  # to read the action artifacts on `covector status` workflows
  actions: read
  # to write the comment
  pull-requests: write

jobs:
  comment:
    runs-on: ubuntu-latest
    if: github.event.workflow_run.conclusion == 'success' &&
      (github.event.workflow_run.head_repository.full_name != github.repository || github.actor == 'dependabot[bot]')
    steps:
      - name: covector status
        uses: jbolda/covector/packages/action@covector-v0
        with:
          token: ${{ secrets.GITHUB_TOKEN }}
          command: 'status'

# Copyright 2019-2024 Tauri Programme within The Commons Conservancy
# SPDX-License-Identifier: Apache-2.0
# SPDX-License-Identifier: MIT

name: covector status
on: [pull_request]

jobs:
  covector:
    runs-on: ubuntu-latest

    steps:
      - uses: actions/checkout@v4
        with:
          fetch-depth: 0
      - name: covector status
        uses: jbolda/covector/packages/action@covector-v0
        id: covector
        with:
          command: 'status'
          token: ${{ secrets.GITHUB_TOKEN }}
          comment: true

# Copyright 2019-2024 Tauri Programme within The Commons Conservancy
# SPDX-License-Identifier: Apache-2.0
# SPDX-License-Identifier: MIT

name: covector version or publish

on:
  push:
    branches:
      - dev

jobs:
  run-integration-tests:
    runs-on: ${{ matrix.platform }}

    strategy:
      fail-fast: false
      matrix:
        platform: [ubuntu-latest, macos-latest, windows-latest]

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

      - run: npm i -g --force corepack
      - uses: actions/setup-node@v4
        with:
          node-version: 20
          cache: 'pnpm'

      - name: install stable
        uses: dtolnay/rust-toolchain@stable

      - name: install Linux dependencies
        if: matrix.platform == 'ubuntu-latest'
        run: |
          sudo apt-get update
          sudo apt-get install -y webkit2gtk-4.1 libayatana-appindicator3-dev libfuse2 librsvg2-dev

      - uses: Swatinem/rust-cache@v2

      - name: build CLI
        run: cargo build --manifest-path ./crates/tauri-cli/Cargo.toml

      - name: run integration tests
        run: cargo test --test '*' -- --ignored

      - name: run CLI tests
        timeout-minutes: 30
        run: |
          cd ./packages/cli
          pnpm i --frozen-lockfile
          pnpm build
          pnpm test

  version-or-publish:
    runs-on: ubuntu-latest
    timeout-minutes: 65
    permissions:
      actions: write # required for workflow_dispatch
      contents: write # required to create new releases
      pull-requests: write # required to open version update pr
      id-token: write # pnpm provenance / oidc token
    outputs:
      change: ${{ steps.covector.outputs.change }}
      commandRan: ${{ steps.covector.outputs.commandRan }}
      successfulPublish: ${{ steps.covector.outputs.successfulPublish }}
    needs:
      - run-integration-tests

    steps:
      - uses: actions/checkout@v4
        with:
          fetch-depth: 0
      - run: npm i -g --force corepack
      - uses: actions/setup-node@v6
        with:
          node-version: 24

      - name: cargo login
        run: cargo login ${{ secrets.ORG_CRATES_IO_TOKEN }}
      - name: git config
        run: |
          git config --global user.name "${{ github.event.pusher.name }}"
          git config --global user.email "${{ github.event.pusher.email }}"

      - name: install Linux dependencies
        run: |
          sudo apt-get update
          sudo apt-get install -y webkit2gtk-4.1 libayatana-appindicator3-dev librsvg2-dev

      - name: covector version or publish (publish when no change files present)
        uses: jbolda/covector/packages/action@covector-v0
        id: covector
        env:
          CARGO_AUDIT_OPTIONS: ${{ secrets.CARGO_AUDIT_OPTIONS }}
          NPM_CONFIG_PROVENANCE: true
        with:
          command: 'version-or-publish'
          token: ${{ secrets.GITHUB_TOKEN }}
          createRelease: true
          recognizeContributors: true

      - name: Sync Cargo.lock
        if: steps.covector.outputs.commandRan == 'version'
        run: cargo tree --depth 0

      - name: Create Pull Request With Versions Bumped
        if: steps.covector.outputs.commandRan == 'version'
        uses: peter-evans/create-pull-request@67ccf781d68cd99b580ae25a5c18a1cc84ffff1f # 7.0.6
        with:
          token: ${{ secrets.GITHUB_TOKEN }}
          branch: release/version-updates
          title: Apply Version Updates From Current Changes
          commit-message: 'apply version updates'
          labels: 'version updates'
          body: ${{ steps.covector.outputs.change }}
          sign-commits: true

      - name: Trigger doc update
        if: |
          steps.covector.outputs.successfulPublish == 'true' &&
          steps.covector.outputs.packagesPublished != ''
        uses: peter-evans/repository-dispatch@ff45666b9427631e3450c54a1bcbee4d9ff4d7c0 # 3.0.0
        with:
          token: ${{ secrets.ORG_TAURI_BOT_PAT }}
          repository: tauri-apps/tauri-docs
          event-type: update-docs

      - name: Trigger `@tauri-apps/cli` publishing workflow
        if: |
          steps.covector.outputs.successfulPublish == 'true' &&
          contains(steps.covector.outputs.packagesPublished, '@tauri-apps/cli')
        run: gh workflow run 31554138 -r dev -f releaseId=${{ steps.covector.outputs['-tauri-apps-cli-releaseId'] }}
        env:
          GH_TOKEN: ${{ secrets.GITHUB_TOKEN }}

      - name: Trigger `tauri-cli` publishing workflow
        if: |
          steps.covector.outputs.successfulPublish == 'true' &&
          contains(steps.covector.outputs.packagesPublished, 'tauri-cli')
        run: gh workflow run 31554139 -r dev
        env:
          GH_TOKEN: ${{ secrets.GITHUB_TOKEN }}

# Copyright 2019-2024 Tauri Programme within The Commons Conservancy
# SPDX-License-Identifier: Apache-2.0
# SPDX-License-Identifier: MIT

name: deploy schema worker

on:
  push:
    branches:
      - dev
    paths:
      - '.github/workflows/deploy-schema-worker.yml'
      - 'crates/tauri-schema-worker/**'

jobs:
  deploy:
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@v4
      - uses: cloudflare/wrangler-action@v3
        with:
          command: deploy
          workingDirectory: 'crates/tauri-schema-worker'
          apiToken: ${{ secrets.SCHEMA_WORKER_CLOUDFLARE_API_TOKEN }}
          accountId: ${{ secrets.SCHEMA_WORKER_CLOUDFLARE_ACCOUNT_ID  }}

# Copyright 2019-2024 Tauri Programme within The Commons Conservancy
# SPDX-License-Identifier: Apache-2.0
# SPDX-License-Identifier: MIT

name: docker

on:
  workflow_dispatch:
  #pull_request:
  #  paths:
  #    - '.docker/**'
  #    - '.github/workflows/docker.yml'

jobs:
  setup:
    runs-on: ubuntu-latest

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

      - name: install stable
        uses: dtolnay/rust-toolchain@stable

      - name: install Linux dependencies
        run: |
          sudo apt-get update
          sudo apt-get install -y libgtk-3-dev

      - name: install cross
        run: cargo install cross --git https://github.com/cross-rs/cross

      - name: Upload cross
        uses: actions/upload-artifact@v4
        with:
          name: cross
          path: '~/.cargo/bin/cross'
          if-no-files-found: error

      - name: build CLI
        run: cargo build --manifest-path ./crates/tauri-cli/Cargo.toml

      - name: Upload CLI
        uses: actions/upload-artifact@v4
        with:
          name: cargo-tauri
          path: crates/tauri-cli/target/debug/cargo-tauri
          if-no-files-found: error

  docker:
    needs: setup
    runs-on: ubuntu-latest

    strategy:
      fail-fast: false
      matrix:
        target:
          - { name: 'aarch64-unknown-linux-gnu', filename: 'aarch64' }

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

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

      - run: npm i -g --force corepack
      - name: Setup node
        uses: actions/setup-node@v4
        with:
          node-version: 'lts/*'

      - name: Download cross
        uses: actions/download-artifact@v4.1.7
        with:
          name: cross
          path: '~/.cargo/bin'

      - name: Download CLI
        uses: actions/download-artifact@v4.1.7
        with:
          name: cargo-tauri
          path: 'examples/api'

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

      - name: Set up Docker Buildx
        uses: docker/setup-buildx-action@v2

      - name: Login to GitHub Container Registry
        uses: docker/login-action@v2
        with:
          registry: ghcr.io
          username: ${{ github.repository_owner }}
          password: ${{ secrets.GITHUB_TOKEN }}

      - name: Build and export to Docker
        uses: docker/build-push-action@v3
        with:
          context: .docker/cross
          file: .docker/cross/${{ matrix.target.filename }}.Dockerfile
          load: true
          tags: ${{ matrix.target.name }}:latest

      - name: install dependencies
        run: |
          sudo apt-get update
          sudo apt-get install -y webkit2gtk-4.1 libayatana-appindicator3-dev

      - name: Test
        run: |
          cd packages/api
          pnpm i --frozen-lockfile && pnpm build
          cd ../../examples/api
          pnpm i --frozen-lockfile
          . .setup-cross.sh
          chmod +x cargo-tauri
          chmod +x $HOME/.cargo/bin/cross
          ./cargo-tauri build --runner cross --bundles deb --target ${{ matrix.target.name }} --verbose

      - name: Build and push
        uses: docker/build-push-action@v3
        with:
          context: .docker/cross
          file: .docker/cross/${{ matrix.target.filename }}.Dockerfile
          push: true
          tags: ghcr.io/${{ github.repository }}/${{ matrix.target.name }}:latest

# Copyright 2019-2024 Tauri Programme within The Commons Conservancy
# SPDX-License-Identifier: Apache-2.0
# SPDX-License-Identifier: MIT

name: check formatting

on:
  pull_request:

jobs:
  rustfmt:
    runs-on: ubuntu-latest

    steps:
      - uses: actions/checkout@v4

      - name: install Rust stable and rustfmt
        uses: dtolnay/rust-toolchain@stable
        with:
          components: rustfmt

      - name: run cargo fmt
        run: cargo fmt --all -- --check

  prettier:
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@v4
      - run: npm i -g --force corepack
      - uses: actions/setup-node@v4
        with:
          node-version: 'lts/*'
          cache: 'pnpm'
      - run: pnpm i --frozen-lockfile
      - run: pnpm format:check

  taplo:
    name: taplo (.toml files)
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@v4

      - name: install Rust stable
        uses: dtolnay/rust-toolchain@stable

      - name: install taplo-cli
        uses: taiki-e/install-action@v2
        with:
          tool: taplo-cli

      - run: taplo fmt --check --diff

# Copyright 2019-2024 Tauri Programme within The Commons Conservancy
# SPDX-License-Identifier: Apache-2.0
# SPDX-License-Identifier: MIT

name: lint js

on:
  pull_request:
    paths:
      - '.github/workflows/lint-js.yml'
      - 'packages/**'

concurrency:
  group: ${{ github.workflow }}-${{ github.ref }}
  cancel-in-progress: true

jobs:
  eslint:
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@v4
      - run: npm i -g --force corepack
      - uses: actions/setup-node@v4
        with:
          node-version: 'lts/*'
          cache: 'pnpm'
      - run: pnpm i --frozen-lockfile
      - run: pnpm eslint:check

  typescript:
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@v4
      - run: npm i -g --force corepack
      - uses: actions/setup-node@v4
        with:
          node-version: 'lts/*'
          cache: 'pnpm'
      - run: pnpm i --frozen-lockfile
      - run: pnpm ts:check

# Copyright 2019-2024 Tauri Programme within The Commons Conservancy
# SPDX-License-Identifier: Apache-2.0
# SPDX-License-Identifier: MIT

name: lint rust

on:
  push:
    branches:
      - dev
  pull_request:
    paths:
      - '.github/workflows/lint-rust.yml'
      - 'crates/**'

env:
  RUST_BACKTRACE: 1
  CARGO_PROFILE_DEV_DEBUG: 0 # This would add unnecessary bloat to the target folder, decreasing cache efficiency.

concurrency:
  group: ${{ github.workflow }}-${{ github.ref }}
  cancel-in-progress: true

jobs:
  clippy:
    runs-on: ubuntu-latest

    steps:
      - uses: actions/checkout@v4

      - name: install rust stable and clippy
        uses: dtolnay/rust-toolchain@stable
        with:
          components: clippy

      - name: install dependencies
        run: |
          sudo apt-get update
          sudo apt-get install -y libgtk-3-dev webkit2gtk-4.1 libayatana-appindicator3-dev

      - uses: Swatinem/rust-cache@v2

      - run: cargo clippy --all-targets --all-features -- -D warnings

# Copyright 2019-2024 Tauri Programme within The Commons Conservancy
# SPDX-License-Identifier: Apache-2.0
# SPDX-License-Identifier: MIT

name: publish `@tauri-apps/cli`
env:
  DEBUG: napi:*
  APP_NAME: cli
  MACOSX_DEPLOYMENT_TARGET: '10.13'
on:
  workflow_dispatch:
    inputs:
      releaseId:
        description: 'ID of the `@tauri-apps/cli` release'
        required: true
  repository_dispatch:
    types: [publish-js-cli]

defaults:
  run:
    working-directory: packages/cli/

permissions:
  contents: write # update release
  id-token: write # oidc token

jobs:
  build:
    strategy:
      fail-fast: false
      matrix:
        settings:
          - host: macos-latest
            target: x86_64-apple-darwin
            architecture: x64
            build: |
              pnpm build --target=x86_64-apple-darwin
              strip -x *.node
          - host: windows-latest
            build: pnpm build
            target: x86_64-pc-windows-msvc
            architecture: x64
          - host: windows-latest
            build: pnpm build --target i686-pc-windows-msvc
            target: i686-pc-windows-msvc
            architecture: x64
          - host: windows-latest
            architecture: x64
            target: aarch64-pc-windows-msvc
            build: pnpm build --target aarch64-pc-windows-msvc
          - host: ubuntu-22.04
            target: x86_64-unknown-linux-gnu
            docker: ghcr.io/napi-rs/napi-rs/nodejs-rust:lts-debian
            build: |
              npm i -g --force corepack
              cd packages/cli
              pnpm build --target x86_64-unknown-linux-gnu
              strip *.node
          - host: ubuntu-22.04
            target: x86_64-unknown-linux-musl
            docker: ghcr.io/napi-rs/napi-rs/nodejs-rust:lts-alpine
            build: |
              cd packages/cli
              pnpm build
              strip *.node
          - host: macos-latest
            target: aarch64-apple-darwin
            build: |
              pnpm build --features native-tls-vendored --target=aarch64-apple-darwin
              strip -x *.node
          - host: ubuntu-22.04
            target: aarch64-unknown-linux-gnu
            docker: ghcr.io/napi-rs/napi-rs/nodejs-rust:lts-debian-aarch64
            build: |
              npm i -g --force corepack
              cd packages/cli
              pnpm build --target aarch64-unknown-linux-gnu
              aarch64-unknown-linux-gnu-strip *.node
          - host: ubuntu-22.04
            architecture: x64
            target: armv7-unknown-linux-gnueabihf
            setup: |
              sudo apt-get update
              sudo apt-get install gcc-arm-linux-gnueabihf g++-arm-linux-gnueabihf -y
            build: |
              pnpm build --target=armv7-unknown-linux-gnueabihf
              arm-linux-gnueabihf-strip *.node
          - host: ubuntu-22.04
            architecture: x64
            target: aarch64-unknown-linux-musl
            docker: ghcr.io/napi-rs/napi-rs/nodejs-rust:lts-alpine
            build: |
              cd packages/cli
              rustup target add aarch64-unknown-linux-musl
              pnpm build --target aarch64-unknown-linux-musl
              /aarch64-linux-musl-cross/bin/aarch64-linux-musl-strip *.node
          - host: ubuntu-22.04
            architecture: x64
            target: riscv64gc-unknown-linux-gnu
            setup: |
              sudo apt-get update
              sudo apt-get install gcc-riscv64-linux-gnu g++-riscv64-linux-gnu -y
            build: |
              pnpm build --target=riscv64gc-unknown-linux-gnu
              riscv64-linux-gnu-strip *.node
    name: stable - ${{ matrix.settings.target }} - node@20
    runs-on: ${{ matrix.settings.host }}
    steps:
      - uses: actions/checkout@v4
      - run: npm i -g --force corepack
      - name: Setup node
        uses: actions/setup-node@v4
        if: ${{ !matrix.settings.docker }}
        with:
          node-version: 20
          cache: 'pnpm'
          architecture: ${{ matrix.settings.architecture }}
      - name: Install Rust
        uses: dtolnay/rust-toolchain@stable
        if: ${{ !matrix.settings.docker }}
        with:
          targets: ${{ matrix.settings.target }}
      - uses: Swatinem/rust-cache@v2
        with:
          key: ${{ matrix.settings.target }}
        if: ${{ matrix.settings.docker }}
      - name: Setup toolchain
        run: ${{ matrix.settings.setup }}
        if: ${{ matrix.settings.setup }}
        shell: bash
      - name: Install dependencies
        run: pnpm i --frozen-lockfile --ignore-scripts

      - name: Build in docker
        uses: addnab/docker-run-action@v3
        if: ${{ matrix.settings.docker }}
        with:
          image: ${{ matrix.settings.docker }}
          options: --user 0:0 -v ${{ github.workspace }}/.cargo-cache/git/db:/root/.cargo/git/db -v ${{ github.workspace }}/.cargo/registry/cache:/root/.cargo/registry/cache -v ${{ github.workspace }}/.cargo/registry/index:/root/.cargo/registry/index -v ${{ github.workspace }}:/build -w /build
          run: ${{ matrix.settings.build }}

      - name: Build
        run: ${{ matrix.settings.build }}
        if: ${{ !matrix.settings.docker }}
        shell: bash

      - name: Upload artifact
        uses: actions/upload-artifact@v4
        with:
          name: bindings-${{ matrix.settings.target }}
          path: packages/cli/${{ env.APP_NAME }}.*.node
          if-no-files-found: error
  #  build-freebsd:
  #    runs-on: macos-10.15
  #    name: Build FreeBSD
  #    steps:
  #      - uses: actions/checkout@v4
  #      - name: Build
  #        id: build
  #        uses: vmactions/freebsd-vm@v0.1.6
  #        env:
  #          DEBUG: napi:*
  #          RUSTUP_HOME: /usr/local/rustup
  #          CARGO_HOME: /usr/local/cargo
  #          RUSTUP_IO_THREADS: 1
  #        with:
  #          envs: DEBUG RUSTUP_HOME CARGO_HOME RUSTUP_IO_THREADS
  #          usesh: true
  #          mem: 3000
  #          prepare: |
  #            pkg install -y curl node14 python2
  #            curl -qL https://www.npmjs.com/install.sh | sh
  #            npm install -g pnpm
  #            curl https://sh.rustup.rs -sSf --output rustup.sh
  #            sh rustup.sh -y --profile minimal --default-toolchain stable
  #            export PATH="/usr/local/cargo/bin:$PATH"
  #            echo "~~~~ rustc --version ~~~~"
  #            rustc --version
  #            echo "~~~~ node -v ~~~~"
  #            node -v
  #            echo "~~~~ pnpm --version ~~~~"
  #            pnpm --version
  #          run: |
  #            export PATH="/usr/local/cargo/bin:$PATH"
  #            pwd
  #            ls -lah
  #            whoami
  #            env
  #            freebsd-version
  #            cd ./packages/cli/
  #            pnpm i --frozen-lockfile --ignore-scripts
  #            pnpm build
  #            strip -x *.node
  #            rm -rf node_modules
  #            rm -rf ../../target
  #      - name: Upload artifact
  #        uses: actions/upload-artifact@v4
  #        with:
  #          name: bindings-freebsd
  #          path: packages/cli/${{ env.APP_NAME }}.*.node
  #          if-no-files-found: error
  test-macOS-windows-binding:
    name: Test bindings on ${{ matrix.settings.target }} - node@${{ matrix.node }}
    needs:
      - build
    strategy:
      fail-fast: false
      matrix:
        settings:
          - host: macos-latest
            target: aarch64-apple-darwin
          - host: windows-latest
            target: x86_64-pc-windows-msvc
        node:
          - '18'
          - '20'
    runs-on: ${{ matrix.settings.host }}
    steps:
      - uses: actions/checkout@v4
      - run: npm i -g --force corepack
      - name: Setup node
        uses: actions/setup-node@v4
        with:
          node-version: ${{ matrix.node }}
          cache: 'pnpm'
      - name: Install dependencies
        run: pnpm i --frozen-lockfile --ignore-scripts
      - name: Download artifacts
        uses: actions/download-artifact@v4.1.7
        with:
          name: bindings-${{ matrix.settings.target }}
          path: 'packages/cli/'
      - name: List packages
        run: ls -R .
        shell: bash
      - name: Test bindings
        run: pnpm test
  test-linux-x64-gnu-binding:
    name: Test bindings on Linux-x64-gnu - node@${{ matrix.node }}
    needs:
      - build
    strategy:
      fail-fast: false
      matrix:
        node:
          - '18'
          - '20'
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@v4
      - run: npm i -g --force corepack
      - name: Setup node
        uses: actions/setup-node@v4
        with:
          node-version: ${{ matrix.node }}
          cache: 'pnpm'
      - name: Install dependencies
        run: pnpm i --frozen-lockfile --ignore-scripts
      - name: Download artifacts
        uses: actions/download-artifact@v4.1.7
        with:
          name: bindings-x86_64-unknown-linux-gnu
          path: 'packages/cli'
      - name: List packages
        run: ls -R .
        shell: bash
      - name: install system dependencies
        run: |
          sudo apt-get update
          sudo apt-get install -y webkit2gtk-4.1 libayatana-appindicator3-dev librsvg2-dev
      - name: Test bindings
        run: pnpm test
  test-linux-x64-musl-binding:
    name: Test bindings on x86_64-unknown-linux-musl - node@${{ matrix.node }}
    needs:
      - build
    strategy:
      fail-fast: false
      matrix:
        node:
          - '18'
          - '20'
    runs-on: ubuntu-latest
    container:
      image: ghcr.io/napi-rs/napi-rs/nodejs-rust:lts-alpine
    steps:
      - uses: actions/checkout@v4
      - run: npm i -g --force corepack
      - name: Setup node
        uses: actions/setup-node@v4
        with:
          node-version: ${{ matrix.node }}
          cache: 'pnpm'
      - name: Install dependencies
        run: pnpm i --frozen-lockfile --ignore-scripts
      - name: Download artifacts
        uses: actions/download-artifact@v4.1.7
        with:
          name: bindings-x86_64-unknown-linux-musl
          path: 'packages/cli/'
      - name: List packages
        run: ls -R .
        shell: bash
      - name: Setup and run tests
        run: |
          pnpm tauri --help
          ls -la
      #- name: Setup and run tests
      #  run: |
      #    rustup install stable
      #    rustup default stable
      #    pnpm test
      #    ls -la
  test-linux-arm-bindings:
    name: Test bindings on ${{ matrix.image }} - node@${{ matrix.node }}
    needs:
      - build
    strategy:
      fail-fast: false
      matrix:
        node:
          - '18'
          - '20'
        image:
          - ghcr.io/napi-rs/napi-rs/nodejs:aarch64-16
    runs-on: ubuntu-latest
    steps:
      - run: docker run --rm --privileged multiarch/qemu-user-static:register --reset
        working-directory: ${{ github.workspace }}
      - uses: actions/checkout@v4
      - name: List packages
        run: ls -R .
        shell: bash
      - name: Download aarch64-gnu artifacts
        uses: actions/download-artifact@v4.1.7
        with:
          name: bindings-aarch64-unknown-linux-gnu
          path: 'packages/cli'
      - name: Download armv7-gnueabihf artifacts
        uses: actions/download-artifact@v4.1.7
        with:
          name: bindings-armv7-unknown-linux-gnueabihf
          path: 'packages/cli/'
      # TODO: actually run test, blocked by https://github.com/rust-lang/cargo/issues/8719
      - uses: addnab/docker-run-action@v3
        with:
          image: ${{ matrix.image }}
          options: '-v ${{ github.workspace }}:/build -w /build -e RUSTUP_HOME=/usr/local/rustup -e CARGO_HOME=/usr/local/cargo'
          shell: bash
          run: |
            set -e
            export PATH=/usr/local/cargo/bin/:/usr/local/fnm:$PATH
            apt-get update
            DEBIAN_FRONTEND=noninteractive TZ=Etc/UTC apt-get install --no-install-recommends -y unzip libayatana-appindicator3-dev
            bash
            curl https://sh.rustup.rs -sSf | bash -s -- -y
            curl -fsSL https://fnm.vercel.app/install | bash -s -- --install-dir "/usr/local/fnm" --skip-shell
            eval "$(fnm env --use-on-cd)"
            fnm install ${{ matrix.node }}
            fnm use ${{ matrix.node }}
            cd packages/cli
            node tauri.js --help
            ls -la
  publish:
    name: Publish
    runs-on: ubuntu-latest
    needs:
      #- build-freebsd
      - test-macOS-windows-binding
      - test-linux-x64-gnu-binding
      - test-linux-x64-musl-binding
      #- test-linux-arm-bindings
    steps:
      - uses: actions/checkout@v4
      - run: npm i -g --force corepack
      - name: Setup node
        uses: actions/setup-node@v6
        with:
          node-version: 24
          cache: 'pnpm'
      - name: Install dependencies
        run: pnpm i --frozen-lockfile --ignore-scripts
      - name: Download all artifacts
        uses: actions/download-artifact@v4.1.7
        with:
          path: packages/cli/artifacts
      - name: Move artifacts
        run: pnpm artifacts
      - name: List packages
        run: ls -R ./npm
        shell: bash
      - name: Publish
        run: |
          npm publish
        env:
          GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
          NODE_AUTH_TOKEN: ''
          RELEASE_ID: ${{ github.event.client_payload.releaseId || inputs.releaseId }}

# Copyright 2019-2024 Tauri Programme within The Commons Conservancy
# SPDX-License-Identifier: Apache-2.0
# SPDX-License-Identifier: MIT

name: publish `tauri-cli`
env:
  MACOSX_DEPLOYMENT_TARGET: '10.13'
on:
  workflow_dispatch:
  repository_dispatch:
    types: [publish-clirs]

jobs:
  build:
    runs-on: ${{ matrix.config.os }}

    strategy:
      fail-fast: false
      matrix:
        config:
          - os: ubuntu-22.04
            rust_target: x86_64-unknown-linux-gnu
            ext: ''
            args: ''
          - os: macos-latest
            rust_target: x86_64-apple-darwin
            ext: ''
            args: ''
          - os: macos-latest
            rust_target: aarch64-apple-darwin
            ext: ''
            args: ''
          - os: windows-latest
            rust_target: x86_64-pc-windows-msvc
            ext: '.exe'
            args: ''
          - os: windows-latest
            rust_target: aarch64-pc-windows-msvc
            ext: '.exe'
            args: ''
          - os: ubuntu-22.04
            rust_target: riscv64gc-unknown-linux-gnu
            ext: ''
            args: ''
            cross: true

    steps:
      - uses: actions/checkout@v4

      - name: 'Setup Rust'
        if: ${{ !matrix.config.cross }}
        uses: dtolnay/rust-toolchain@stable
        with:
          targets: ${{ matrix.config.rust_target }}

      - uses: Swatinem/rust-cache@v2
        if: ${{ !matrix.config.cross }}
        with:
          key: ${{ matrix.config.rust_target }}

      - name: install Linux dependencies
        if: ${{ !matrix.config.cross && startsWith(matrix.config.os, 'ubuntu') }}
        run: |
          sudo apt-get update
          sudo apt-get install -y libgtk-3-dev

      - name: Install cross
        if: ${{ matrix.config.cross }}
        uses: taiki-e/install-action@v2
        with:
          tool: cross@0.2.5

      - name: Build CLI
        if: ${{ !matrix.config.cross }}
        run: cargo build --manifest-path ./crates/tauri-cli/Cargo.toml --profile release-size-optimized ${{ matrix.config.args }}

      - name: Build CLI (cross)
        if: ${{ matrix.config.cross }}
        run: cross build --manifest-path ./crates/tauri-cli/Cargo.toml --target ${{ matrix.config.rust_target }} --profile release-size-optimized ${{ matrix.config.args }}

      - name: Upload CLI
        if: ${{ !matrix.config.cross }}
        uses: actions/upload-artifact@v4
        with:
          name: cargo-tauri-${{ matrix.config.rust_target }}${{ matrix.config.ext }}
          path: target/release-size-optimized/cargo-tauri${{ matrix.config.ext }}
          if-no-files-found: error

      - name: Upload CLI (cross)
        if: ${{ matrix.config.cross }}
        uses: actions/upload-artifact@v4
        with:
          name: cargo-tauri-${{ matrix.config.rust_target }}${{ matrix.config.ext }}
          path: target/${{ matrix.config.rust_target }}/release-size-optimized/cargo-tauri${{ matrix.config.ext }}
          if-no-files-found: error

  upload:
    needs: build
    runs-on: ubuntu-latest

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

      - name: Download built CLIs
        uses: actions/download-artifact@v4.1.7
        with:
          path: outputs

      - name: Pack archives
        run: ./.scripts/ci/pack-cli.sh

      - name: Get CLI version
        run: echo "CLI_VERSION=$(cat crates/tauri-cli/metadata-v2.json | jq '."cli.js".version' -r)" >> $GITHUB_ENV

      - name: Publish release
        uses: softprops/action-gh-release@50195ba7f6f93d1ac97ba8332a178e008ad176aa
        with:
          tag_name: tauri-cli-v${{ env.CLI_VERSION }}
          files: |
            outputs/cargo-tauri-*.zip
            outputs/cargo-tauri-*.tgz

# Copyright 2019-2024 Tauri Programme within The Commons Conservancy
# SPDX-License-Identifier: Apache-2.0
# SPDX-License-Identifier: MIT

name: supply chain health status
on:
  workflow_dispatch:
  schedule:
    - cron: '0 0 * * *'
  push:
    branches:
      - dev
    paths:
      - '.github/workflows/supply-chain.yml'
      - '**/Cargo.lock'
      - '**/Cargo.toml'
jobs:
  cargo-vet:
    name: check rust dependencies with cargo vet
    runs-on: ubuntu-latest
    env:
      CARGO_VET_VERSION: 0.9.1
    steps:
      - uses: actions/checkout@master
      - name: Install Rust
        run: rustup update stable && rustup default stable

      - uses: actions/cache@v4
        with:
          path: ${{ runner.tool_cache }}/cargo-vet
          key: cargo-vet-bin-${{ env.CARGO_VET_VERSION }}

      - name: Add the tool cache directory to the search path
        run: echo "${{ runner.tool_cache }}/cargo-vet/bin" >> $GITHUB_PATH

      - name: Ensure that the tool cache is populated with the cargo-vet binary
        run: cargo install --root ${{ runner.tool_cache }}/cargo-vet --version ${{ env.CARGO_VET_VERSION }} cargo-vet

      # Enable this again to break the workflow once we have a reasonable amount of suggestions to get to a clean base line
      #      - name: Invoke cargo-vet
      #        run: cargo vet --locked

      - name: Provide audit suggestions
        run: cargo vet suggest

# Copyright 2019-2024 Tauri Programme within The Commons Conservancy
# SPDX-License-Identifier: Apache-2.0
# SPDX-License-Identifier: MIT

name: test android

on:
  pull_request:
    paths:
      - '.github/workflows/test-android.yml'
      - 'crates/tauri-cli/templates/mobile/android/**'
      - 'crates/tauri-cli/src/mobile/**'
      - '!crates/tauri-cli/src/mobile/ios.rs'
      - '!crates/tauri-cli/src/mobile/ios/**'
      - 'crates/tauri-build/src/mobile.rs'
      - 'crates/tauri/mobile/android/**'
      - 'crates/tauri/mobile/android-codegen/**'
  workflow_dispatch:

concurrency:
  group: ${{ github.workflow }}-${{ github.ref }}
  cancel-in-progress: true

jobs:
  test:
    runs-on: ${{ matrix.platform }}

    strategy:
      fail-fast: false
      matrix:
        platform: [ubuntu-latest, macos-latest, windows-latest]

    steps:
      - uses: actions/checkout@v4

      - name: install Rust 1.77.2
        uses: dtolnay/rust-toolchain@1.77.2

      - name: install Linux dependencies
        if: matrix.platform == 'ubuntu-latest'
        run: |
          sudo apt-get update
          sudo apt-get install -y libgtk-3-dev webkit2gtk-4.1

      - run: npm i -g --force corepack
      - name: setup node
        uses: actions/setup-node@v4
        with:
          node-version: lts/*
          cache: 'pnpm'

      - uses: actions/setup-java@v3
        with:
          distribution: temurin
          java-version: 17
          cache: 'gradle'

      - name: Setup NDK
        uses: nttld/setup-ndk@v1
        id: setup-ndk
        with:
          ndk-version: r25b
          local-cache: true

      # TODO check after https://github.com/nttld/setup-ndk/issues/518 is fixed
      - name: Restore Android Symlinks
        if: matrix.platform == 'ubuntu-latest' || matrix.platform == 'macos-latest'
        run: |
          directory="${{ steps.setup-ndk.outputs.ndk-path }}/toolchains/llvm/prebuilt/linux-x86_64/bin"
          find "$directory" -type l | while read link; do
              current_target=$(readlink "$link")
              new_target="$directory/$(basename "$current_target")"
              ln -sf "$new_target" "$link"
              echo "Changed $(basename "$link") from $current_target to $new_target"
          done

      - uses: Swatinem/rust-cache@v2

      - name: build CLI
        run: cargo build --manifest-path ./crates/tauri-cli/Cargo.toml

      - name: move CLI to cargo bin dir
        if: matrix.platform != 'windows-latest'
        run: mv ./target/debug/cargo-tauri $HOME/.cargo/bin

      - name: move CLI to cargo bin dir
        if: matrix.platform == 'windows-latest'
        run: mv ./target/debug/cargo-tauri.exe $HOME/.cargo/bin

      - run: pnpm i --frozen-lockfile

      - name: build Tauri API
        working-directory: ./packages/api
        run: pnpm build

      - name: init Android Studio project
        working-directory: ./examples/api
        run: cargo tauri android init
        env:
          NDK_HOME: ${{ steps.setup-ndk.outputs.ndk-path }}

      - name: build APK
        working-directory: ./examples/api
        run: cargo tauri android build
        env:
          NDK_HOME: ${{ steps.setup-ndk.outputs.ndk-path }}

# Copyright 2019-2024 Tauri Programme within The Commons Conservancy
# SPDX-License-Identifier: Apache-2.0
# SPDX-License-Identifier: MIT

name: test `@tauri-apps/cli`

on:
  push:
    branches:
      - dev
  pull_request:
    paths:
      - '.github/workflows/test-cli-js.yml'
      - 'packages/cli/**'
      # currently` @tauri-apps/cli` only tests the template
      - 'crates/tauri-cli/templates/app/**'

env:
  RUST_BACKTRACE: 1
  CARGO_PROFILE_DEV_DEBUG: 0 # This would add unnecessary bloat to the target folder, decreasing cache efficiency.

concurrency:
  group: ${{ github.workflow }}-${{ github.ref }}
  cancel-in-progress: true

jobs:
  test:
    runs-on: ${{ matrix.platform }}

    strategy:
      fail-fast: false
      matrix:
        platform: [ubuntu-latest, macos-latest, windows-latest]

    steps:
      - uses: actions/checkout@v4

      - name: install Rust stable
        uses: dtolnay/rust-toolchain@stable

      - run: npm i -g --force corepack
      - name: setup node
        uses: actions/setup-node@v4
        with:
          node-version: 'lts/*'
          cache: 'pnpm'

      - name: install Linux dependencies
        if: matrix.platform == 'ubuntu-latest'
        run: |
          sudo apt-get update
          sudo apt-get install -y webkit2gtk-4.1 libayatana-appindicator3-dev librsvg2-dev

      - uses: Swatinem/rust-cache@v2

      - name: test
        timeout-minutes: 30
        run: |
          cd ./packages/cli
          pnpm i --frozen-lockfile
          pnpm build
          pnpm test

# Copyright 2019-2024 Tauri Programme within The Commons Conservancy
# SPDX-License-Identifier: Apache-2.0
# SPDX-License-Identifier: MIT

name: test `tauri-cli`

on:
  push:
    branches:
      - dev
  pull_request:
    paths:
      - '.github/workflows/test-cli-rs.yml'
      - 'crates/tauri-utils/**'
      - 'crates/tauri-bundler/**'
      - 'crates/tauri-cli/**'

env:
  RUST_BACKTRACE: 1
  CARGO_PROFILE_DEV_DEBUG: 0 # This would add unnecessary bloat to the target folder, decreasing cache efficiency.

concurrency:
  group: ${{ github.workflow }}-${{ github.ref }}
  cancel-in-progress: true

jobs:
  test:
    runs-on: ${{ matrix.platform.os }}

    strategy:
      fail-fast: false
      matrix:
        platform:
          - { target: x86_64-pc-windows-msvc, os: windows-latest }
          - {
              target: aarch64-pc-windows-msvc,
              os: windows-latest,
              args: --no-default-features --features native-tls-vendored
            }
          - { target: x86_64-unknown-linux-gnu, os: ubuntu-latest }
          - { target: x86_64-apple-darwin, os: macos-latest }

    steps:
      - uses: actions/checkout@v4

      - name: 'Setup Rust'
        uses: dtolnay/rust-toolchain@1.77.2
        with:
          targets: ${{ matrix.platform.target }}

      - name: install Linux dependencies
        if: matrix.platform.os == 'ubuntu-latest'
        run: |
          sudo apt-get update
          sudo apt-get install -y libgtk-3-dev webkit2gtk-4.1 libayatana-appindicator3-dev librsvg2-dev

      - uses: Swatinem/rust-cache@v2

      - name: test CLI
        run: cargo test --manifest-path ./crates/tauri-cli/Cargo.toml ${{ matrix.platform.args }}

# Copyright 2019-2024 Tauri Programme within The Commons Conservancy
# SPDX-License-Identifier: Apache-2.0
# SPDX-License-Identifier: MIT

name: test core

on:
  push:
    branches:
      - dev
  pull_request:
    paths:
      - '.github/workflows/test-core.yml'
      - 'crates/**'
      - '!crates/tauri/scripts/**'
      - '!crates/tauri-cli/**'
      - '!crates/tauri-bundler/**'
      - '!crates/tauri-macos-sign/**'
      - '!crates/tauri-schema-generator/**'

env:
  RUST_BACKTRACE: 1
  CARGO_PROFILE_DEV_DEBUG: 0 # This would add unnecessary bloat to the target folder, decreasing cache efficiency.

concurrency:
  group: ${{ github.workflow }}-${{ github.ref }}
  cancel-in-progress: true

jobs:
  test:
    runs-on: ${{ matrix.platform.os }}

    strategy:
      fail-fast: false
      matrix:
        platform:
          - {
              target: x86_64-pc-windows-msvc,
              os: windows-latest,
              toolchain: '1.77.2',
              cross: false,
              command: 'test'
            }
          - {
              target: x86_64-unknown-linux-gnu,
              os: ubuntu-latest,
              toolchain: '1.77.2',
              cross: false,
              command: 'test'
            }
          - {
              target: aarch64-apple-darwin,
              os: macos-14,
              toolchain: '1.77.2',
              cross: false,
              command: 'test'
            }
          - {
              target: aarch64-apple-ios,
              os: macos-latest,
              toolchain: '1.77.2',
              cross: false,
              command: 'build'
            }
          - {
              target: aarch64-linux-android,
              os: ubuntu-latest,
              toolchain: '1.77.2',
              cross: true,
              command: 'build'
            }
        features:
          - { args: --no-default-features, key: no-default }
          - { args: --all-features, key: all }

    steps:
      - uses: actions/checkout@v4

      - name: install Rust
        uses: dtolnay/rust-toolchain@master
        with:
          toolchain: ${{ matrix.platform.toolchain }}
          targets: ${{ matrix.platform.target }}

      - name: install Linux dependencies
        if: contains(matrix.platform.target, 'unknown-linux')
        run: |
          sudo apt-get update
          sudo apt-get install -y webkit2gtk-4.1 libxdo-dev libayatana-appindicator3-dev

      - uses: Swatinem/rust-cache@v2
        with:
          key: ${{ matrix.platform.target }}
          save-if: ${{ matrix.features.key == 'all' }}

      - name: test tauri-utils
        if: ${{ !matrix.platform.cross }}
        # Using --lib --bins --tests to skip doc tests
        run: cargo ${{ matrix.platform.command }} --target ${{ matrix.platform.target }} ${{ matrix.features.args }} --lib --bins --tests --manifest-path crates/tauri-utils/Cargo.toml

      - name: test tauri-utils (using cross)
        if: ${{ matrix.platform.cross }}
        # Using --lib --bins --tests to skip doc tests
        run: |
          cargo install cross --git https://github.com/cross-rs/cross --rev 51f46f296253d8122c927c5bb933e3c4f27cc317 --locked
          cross ${{ matrix.platform.command }} --target ${{ matrix.platform.target }} ${{ matrix.features.args }} --lib --bins --tests --manifest-path crates/tauri-utils/Cargo.toml

      - name: test tauri
        if: ${{ !matrix.platform.cross }}
        run: cargo ${{ matrix.features.key == 'no-default' && 'check' || matrix.platform.command }} --target ${{ matrix.platform.target }} ${{ matrix.features.args }} --manifest-path crates/tauri/Cargo.toml

      - name: test tauri (using cross)
        if: ${{ matrix.platform.cross }}
        run: |
          cargo install cross --git https://github.com/cross-rs/cross --rev 51f46f296253d8122c927c5bb933e3c4f27cc317 --locked
          cross ${{ matrix.features.key == 'no-default' && 'check' || matrix.platform.command }} --target ${{ matrix.platform.target }} ${{ matrix.features.args }} --manifest-path crates/tauri/Cargo.toml

# Copyright 2019-2024 Tauri Programme within The Commons Conservancy
# SPDX-License-Identifier: Apache-2.0
# SPDX-License-Identifier: MIT

name: Udeps

on:
  push:
    branches:
      - dev

env:
  RUST_BACKTRACE: 1
  CARGO_PROFILE_DEV_DEBUG: 0 # This would add unnecessary bloat to the target folder, decreasing cache efficiency.

concurrency:
  group: ${{ github.workflow }}-${{ github.ref }}
  cancel-in-progress: true

jobs:
  changes:
    runs-on: ubuntu-latest
    outputs:
      tauri: ${{ steps.filter.outputs.tauri }}
      build: ${{ steps.filter.outputs.build }}
      codegen: ${{ steps.filter.outputs.codegen }}
      macros: ${{ steps.filter.outputs.macros }}
      runtime: ${{ steps.filter.outputs.runtime }}
      wry: ${{ steps.filter.outputs.wry }}
      utils: ${{ steps.filter.outputs.utils }}
      bundler: ${{ steps.filter.outputs.bundler }}
      cli: ${{ steps.filter.outputs.cli }}
    steps:
      - uses: actions/checkout@v4
      - uses: dorny/paths-filter@v3
        id: filter
        with:
          filters: |
            tauri:
              - 'crates/tauri/**'
              - '!crates/tauri/scripts/**'
            build:
              - 'crates/tauri-build/**'
            codegen:
              - 'crates/tauri-codegen/**'
            macros:
              - 'crates/tauri-macros/**'
            runtime:
              - 'crates/tauri-runtime/**'
            wry:
              - 'crates/tauri-runtime-wry/**'
            utils:
              - 'crates/tauri-utils/**'
            bundler:
              - 'crates/tauri-bundler/**'
            cli:
              - 'crates/tauri-cli/**'
            macossign:
              - 'crates/tauri-macos-sign/**'

  setup:
    runs-on: ubuntu-latest
    needs: changes
    if: |
      needs.changes.outputs.tauri == 'true' ||
      needs.changes.outputs.build == 'true' ||
      needs.changes.outputs.codegen == 'true' ||
      needs.changes.outputs.macros == 'true' ||
      needs.changes.outputs.runtime == 'true' ||
      needs.changes.outputs.wry == 'true' ||
      needs.changes.outputs.utils == 'true' ||
      needs.changes.outputs.bundler == 'true' ||
      needs.changes.outputs.cli == 'true' ||
      needs.changes.outputs.macossign == 'true'

    steps:
      - uses: actions/checkout@v4

      - name: Install Rust nightly
        uses: dtolnay/rust-toolchain@nightly

      - name: Install udeps
        run: cargo install cargo-udeps --locked --force

      - name: Upload udeps
        uses: actions/upload-artifact@v4
        with:
          name: udeps
          path: '~/.cargo/bin/cargo-udeps'
          if-no-files-found: error

      - name: Create udeps matrix
        id: create-matrix
        env:
          TAURI: ${{ needs.changes.outputs.tauri == 'true' }}
          BUILD: ${{ needs.changes.outputs.build == 'true' }}
          CODEGEN: ${{ needs.changes.outputs.codegen == 'true' }}
          MACROS: ${{ needs.changes.outputs.macros == 'true' }}
          RUNTIME: ${{ needs.changes.outputs.runtime == 'true' }}
          WRY: ${{ needs.changes.outputs.wry == 'true' }}
          UTILS: ${{ needs.changes.outputs.utils == 'true' }}
          BUNDLER: ${{ needs.changes.outputs.bundler == 'true' }}
          CLI: ${{ needs.changes.outputs.cli == 'true' }}
          MACOSSIGN: ${{ needs.changes.outputs.macossign == 'true' }}
        run: |
          crates=()
          if [ "${TAURI}" == "true" ]; then crates[${#crates[@]}]="\"./crates/tauri\""; fi
          if [ "${BUILD}" == "true" ]; then crates[${#crates[@]}]="\"./crates/tauri-build\""; fi
          if [ "${CODEGEN}" == "true" ]; then crates[${#crates[@]}]="\"./crates/tauri-codegen\""; fi
          if [ "${MACROS}" == "true" ]; then crates[${#crates[@]}]="\"./crates/tauri-macros\""; fi
          if [ "${RUNTIME}" == "true" ]; then crates[${#crates[@]}]="\"./crates/tauri-runtime\""; fi
          if [ "${WRY}" == "true" ]; then crates[${#crates[@]}]="\"./crates/tauri-runtime-wry\""; fi
          if [ "${UTILS}" == "true" ]; then crates[${#crates[@]}]="\"./crates/tauri-utils\""; fi
          if [ "${BUNDLER}" == "true" ]; then crates[${#crates[@]}]="\"./crates/tauri-bundler\""; fi
          if [ "${CLI}" == "true" ]; then crates[${#crates[@]}]="\"./crates/tauri-cli\""; fi
          if [ "${MACOSSIGN}" == "true" ]; then crates[${#crates[@]}]="\"./crates/tauri-macos-sign\""; fi
          echo "matrix=[$crates]" >> "$GITHUB_OUTPUT"
    outputs:
      matrix: ${{ steps.create-matrix.outputs.matrix }}

  udeps:
    runs-on: ubuntu-latest
    needs: setup
    strategy:
      matrix:
        path: ${{ fromJson(needs.setup.outputs.matrix) }}
    steps:
      - uses: actions/checkout@v4

      - name: Install Rust nightly
        uses: dtolnay/rust-toolchain@nightly

      - name: install dependencies
        run: |
          sudo apt-get update
          sudo apt-get install -y libgtk-3-dev

      - uses: Swatinem/rust-cache@v2

      - name: Download udeps
        uses: actions/download-artifact@v4.1.7
        with:
          name: udeps
          path: '~/.cargo/bin'

      - run: chmod +x $HOME/.cargo/bin/cargo-udeps

      - name: Install required packages
        run: |
          sudo apt-get update
          sudo apt-get install -y webkit2gtk-4.1 libayatana-appindicator3-dev

      - name: Run udeps
        run: cargo udeps --manifest-path ${{ matrix.path }}/Cargo.toml --all-targets --all-features