wasmcloud.yml

name: wasmCloud

on:
  pull_request:
  merge_group:
  workflow_dispatch:
  push:
    branches:
      - main
    tags:
      - 'actor-v[0-9].[0-9]+.[0-9]+'
      - 'actor-v[0-9].[0-9]+.[0-9]+-*'
      - 'control-interface-v[0-9].[0-9]+.[0-9]+'
      - 'control-interface-v[0-9].[0-9]+.[0-9]+-*'
      - 'core-v[0-9].[0-9]+.[0-9]+'
      - 'core-v[0-9].[0-9]+.[0-9]+-*'
      - 'host-sys-v[0-9].[0-9]+.[0-9]+'
      - 'host-sys-v[0-9].[0-9]+.[0-9]+-*'
      - 'host-v[0-9].[0-9]+.[0-9]+'
      - 'host-v[0-9].[0-9]+.[0-9]+-*'
      - 'opentelemetry-nats-v[0-9].[0-9]+.[0-9]+'
      - 'opentelemetry-nats-v[0-9].[0-9]+.[0-9]+-*'
      - 'provider-archive-v[0-9].[0-9]+.[0-9]+'
      - 'provider-archive-v[0-9].[0-9]+.[0-9]+-*'
      - 'provider-sdk-v[0-9].[0-9]+.[0-9]+'
      - 'provider-sdk-v[0-9].[0-9]+.[0-9]+-*'
      - 'provider-wit-bindgen-v[0-9].[0-9]+.[0-9]+'
      - 'provider-wit-bindgen-v[0-9].[0-9]+.[0-9]+-*'
      - 'runtime-v[0-9].[0-9]+.[0-9]+'
      - 'runtime-v[0-9].[0-9]+.[0-9]+-*'
      - 'tracing-v[0-9].[0-9]+.[0-9]+'
      - 'tracing-v[0-9].[0-9]+.[0-9]+-*'
      - 'v[0-9].[0-9]+.[0-9]+'
      - 'v[0-9].[0-9]+.[0-9]+-*'
      - 'wascap-v[0-9].[0-9]+.[0-9]+'
      - 'wascap-v[0-9].[0-9]+.[0-9]+-*'
      - 'wash-cli-v[0-9].[0-9]+.[0-9]+'
      - 'wash-cli-v[0-9].[0-9]+.[0-9]+-*'
      - 'wash-lib-v[0-9].[0-9]+.[0-9]+'
      - 'wash-lib-v[0-9].[0-9]+.[0-9]+-*'

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

jobs:
  build-bin:
    strategy:
      matrix:
        config:
          - target: aarch64-unknown-linux-musl
            test-bin: |
              nix profile install --inputs-from . 'nixpkgs#qemu'
              qemu-aarch64 ./result/bin/wash --version
              qemu-aarch64 ./result/bin/wasmcloud --version
            test-oci: docker load < ./result
            # TODO: Run aarch64 binary within OCI

          - target: aarch64-apple-darwin
            test-bin: |
              file ./result/bin/wash
              file ./result/bin/wasmcloud
            test-oci: docker load < ./result

          - target: aarch64-linux-android
            test-bin: |
              file ./result/bin/wash
              file ./result/bin/wasmcloud
            test-oci: docker load < ./result

          - target: riscv64gc-unknown-linux-gnu-fhs
            test-bin: |
              nix build -L '.#wasmcloud-riscv64gc-unknown-linux-gnu'
              nix shell --inputs-from . 'nixpkgs#qemu' -c qemu-riscv64 ./result/bin/wasmcloud --version

          - target: x86_64-apple-darwin
            test-bin: |
              file ./result/bin/wash
              file ./result/bin/wasmcloud
            test-oci: docker load < ./result

          # TODO: Build for GNU once https://github.com/rust-lang/rust/issues/92212 is resolved
          #- target: x86_64-pc-windows-gnu
          #  test-bin: |
          #    nix profile install --inputs-from . 'nixpkgs#wine64'
          #    wine64 ./result/bin/wash.exe --version
          #    wine64 ./result/bin/wasmcloud.exe --version
          #  test-oci: docker load < ./result
          #  # TODO: Run win64 binary within OCI

          - target: x86_64-unknown-linux-musl
            test-bin: |
              ./result/bin/wash --version
              ./result/bin/wasmcloud --version
            test-oci: |
              docker load < ./result
              docker run --rm wasmcloud:$(nix eval --raw .#wasmcloud-x86_64-unknown-linux-musl-oci.imageTag) wash --version
              docker run --rm wasmcloud:$(nix eval --raw .#wasmcloud-x86_64-unknown-linux-musl-oci.imageTag) wasmcloud --version

    name: wasmcloud-${{ matrix.config.target }}
    runs-on: ubuntu-22.04-16-cores
    steps:
      - uses: actions/checkout@v4.1.1
      - uses: ./.github/actions/install-nix
        # need to run condition inside job steps so that job will pass if all steps are skipped
        # https://docs.github.com/en/actions/using-workflows/workflow-syntax-for-github-actions#onpull_requestpull_request_targetbranchesbranches-ignore
        with:
          cachixAuthToken: '${{ secrets.CACHIX_AUTH_TOKEN }}'
      - uses: ./.github/actions/build-nix
        with:
          package: wasmcloud-${{ matrix.config.target }}
      - run: ${{ matrix.config.test-bin }}
      - uses: ./.github/actions/build-nix
        if: ${{ !endsWith(matrix.config.target, 'fhs') }}
        with:
          package: wasmcloud-${{ matrix.config.target }}-oci
      - run: ${{ matrix.config.test-oci }}
        if: ${{ !endsWith(matrix.config.target, 'fhs') }}

  build-windows:
    name: wasmcloud-x86_64-pc-windows-msvc
    runs-on: windows-latest-8-cores
    steps:
      - uses: actions/checkout@v4.1.1
      - run: cargo build --release -p wash-cli -p wasmcloud
      - run: mkdir "artifact/bin"
      - run: move "target/release/wasmcloud.exe" "artifact/bin/wasmcloud.exe"
      - run: move "target/release/wash.exe" "artifact/bin/wash.exe"
      - uses: actions/upload-artifact@v4
        with:
          name: wasmcloud-x86_64-pc-windows-msvc
          path: artifact

  build-lipo:
    name: wasmcloud-universal-darwin
    needs: build-bin
    runs-on: macos-12
    steps:
      - uses: actions/download-artifact@v4
        with:
          name: wasmcloud-aarch64-apple-darwin
          path: aarch64
      - uses: actions/download-artifact@v4
        with:
          name: wasmcloud-x86_64-apple-darwin
          path: x86_64

      - run: chmod +x ./x86_64/bin/*
      - run: ./x86_64/bin/wash --version
      - run: ./x86_64/bin/wasmcloud --version

      - run: mkdir -p ./artifact/bin
      - run: lipo -create ./aarch64/bin/wash ./x86_64/bin/wash -output ./artifact/bin/wash
      - run: lipo -create ./aarch64/bin/wasmcloud ./x86_64/bin/wasmcloud -output ./artifact/bin/wasmcloud

      - run: chmod +x ./artifact/bin/wash
      - run: ./artifact/bin/wash --version
      - run: chmod +x ./artifact/bin/wasmcloud
      - run: ./artifact/bin/wasmcloud --version

      - uses: actions/upload-artifact@v4
        with:
          name: wasmcloud-universal-darwin
          path: artifact

  test-linux:
    runs-on: ubuntu-22.04-16-cores
    needs: build-bin
    steps:
      - uses: actions/download-artifact@v4
        with:
          name: wasmcloud-x86_64-unknown-linux-musl
      - run: chmod +x ./bin/wash
      - run: chmod +x ./bin/wasmcloud
      - run: ./bin/wash --version
      - run: ./bin/wasmcloud --version

  test-windows:
    runs-on: windows-latest-8-cores
    needs: build-windows
    steps:
      - uses: actions/download-artifact@v4
        with:
          name: wasmcloud-x86_64-pc-windows-msvc
      - run: .\bin\wash.exe --version
      - run: .\bin\wasmcloud.exe --version

  cargo:
    strategy:
      matrix:
        check:
          - audit
          - fmt
          - clippy
          - nextest

    name: cargo ${{ matrix.check }}
    runs-on: ubuntu-22.04-16-cores
    steps:
      - uses: actions/checkout@v4.1.1
      - uses: ./.github/actions/install-nix
        # need to run condition inside job steps so that job will pass if all steps are skipped
        # https://docs.github.com/en/actions/using-workflows/workflow-syntax-for-github-actions#onpull_requestpull_request_targetbranchesbranches-ignore
        with:
          cachixAuthToken: '${{ secrets.CACHIX_AUTH_TOKEN }}'
      - run: nix build -L .#checks.x86_64-linux.${{ matrix.check }}

  build-doc:
    runs-on: ubuntu-22.04-16-cores
    steps:
      - uses: actions/checkout@v4.1.1
      - uses: ./.github/actions/install-nix
        with:
          cachixAuthToken: '${{ secrets.CACHIX_AUTH_TOKEN }}'
      - run: nix build -L .#checks.x86_64-linux.doc
      - run: cp --no-preserve=mode -R ./result/share/doc ./doc
      - run: rm -f doc/.lock
      - name: Create `.nojekyll`
        run: touch doc/.nojekyll
      - name: Write `index.html`
        run: |
          cat <<EOF > doc/index.html
            <!DOCTYPE html>
            <meta charset="utf-8">
            <title>Redirecting to wasmcloud_host/index.html</title>
            <meta http-equiv="refresh" content="0; URL=wasmcloud_host/index.html">
            <link rel="canonical" href="https://${{ github.repository_owner }}.github.io/wasmCloud/wasmcloud_host/index.html">
          EOF
      - uses: actions/upload-pages-artifact@v3.0.1
        with:
          path: doc

  deploy-doc:
    runs-on: ubuntu-22.04-16-cores
    needs: build-doc
    permissions:
      pages: write
      id-token: write
    environment:
      name: github-pages
      url: ${{ steps.deployment.outputs.page_url }}
    if: github.ref == 'refs/heads/main'
    steps:
      - uses: actions/deploy-pages@v4.0.4
        id: deployment

  oci:
    strategy:
      matrix:
        include:
          - bin: wasmcloud

          - bin: wash
            prefix: wash-cli-

    runs-on: ubuntu-22.04-16-cores
    permissions:
      packages: write
    needs:
      - build-bin
      - test-linux
    steps:
      - uses: actions/checkout@v4.1.1
      - uses: ./.github/actions/install-nix
        with:
          cachixAuthToken: '${{ secrets.CACHIX_AUTH_TOKEN }}'

      - name: Extract tag context
        id: ctx
        run: |
          echo "owner=${GITHUB_REPOSITORY_OWNER,,}" >> "$GITHUB_OUTPUT"
          echo "sha_short=$(git rev-parse --short HEAD)" >> "$GITHUB_OUTPUT"

          version=${GITHUB_REF_NAME#${{ matrix.prefix }}v}
          echo "version=${version}" >> "$GITHUB_OUTPUT"
          echo "version is ${version}"
          if [[ $version == *"-"* ]]; then
            echo "version ${version} is a pre-release"
            echo "prerelease=true" >> "$GITHUB_OUTPUT"
          fi

      - name: Login to AzureCR
        if: startswith(github.ref, format('refs/tags/{0}v', matrix.prefix)) || github.ref == 'refs/heads/main'
        continue-on-error: ${{ github.repository_owner != 'wasmCloud' }}
        uses: azure/docker-login@v1
        with:
          login-server: ${{ secrets.AZURECR_PUSH_URL }}
          username: ${{ secrets.AZURECR_PUSH_USER }}
          password: ${{ secrets.AZURECR_PUSH_PASSWORD }}

      - name: Login to GitHub Container Registry
        if: startswith(github.ref, format('refs/tags/{0}v', matrix.prefix)) || github.ref == 'refs/heads/main'
        uses: docker/login-action@v3
        with:
          registry: ghcr.io
          username: ${{ github.repository_owner }}
          password: ${{ secrets.GITHUB_TOKEN }}

      - name: Login to DockerHub
        if: startswith(github.ref, format('refs/tags/{0}v', matrix.prefix)) || github.ref == 'refs/heads/main'
        continue-on-error: ${{ github.repository_owner != 'wasmCloud' }}
        uses: docker/login-action@v3
        with:
          username: ${{ secrets.DOCKERHUB_PUSH_USER }}
          password: ${{ secrets.DOCKERHUB_PUSH_PASSWORD }}

      - name: Install `buildah`
        run: nix profile install --inputs-from . 'nixpkgs#buildah'

      - name: Build `${{ matrix.bin }}` image
        run: nix run -L .#build-${{ matrix.bin }}-oci-debian ${{ matrix.bin }}

      - name: Test `${{ matrix.bin }}` image
        run: |
          buildah push ${{ matrix.bin }}:amd64 docker-daemon:${{ matrix.bin }}:test
          docker run --rm ${{ matrix.bin }}:test ${{ matrix.bin }} --version

      - name: Push `${{ matrix.bin }}` commit rev tag
        if: startswith(github.ref, format('refs/tags/{0}v', matrix.prefix)) || github.ref == 'refs/heads/main'
        run: |
          buildah manifest push --all --format 'v2s2' ${{ matrix.bin }} docker://ghcr.io/${{ steps.ctx.outputs.owner }}/${{ matrix.bin }}:${{ github.sha }}
          buildah manifest push --all --format 'v2s2' ${{ matrix.bin }} docker://ghcr.io/${{ steps.ctx.outputs.owner }}/${{ matrix.bin }}:${{ steps.ctx.outputs.sha_short }}

          docker run --rm ghcr.io/${{ steps.ctx.outputs.owner }}/${{ matrix.bin }}:${{ github.sha }} ${{ matrix.bin }} --version
          docker run --rm ghcr.io/${{ steps.ctx.outputs.owner }}/${{ matrix.bin }}:${{ steps.ctx.outputs.sha_short }} ${{ matrix.bin }} --version

      - name: Push `${{ matrix.bin }}` `canary` tag
        if: github.ref == 'refs/heads/main'
        continue-on-error: ${{ github.repository_owner != 'wasmCloud' }}
        run: |
          buildah manifest push --all --format 'v2s2' ${{ matrix.bin }} docker://${{ steps.ctx.outputs.owner }}/${{ matrix.bin }}:canary
          buildah manifest push --all --format 'v2s2' ${{ matrix.bin }} docker://ghcr.io/${{ steps.ctx.outputs.owner }}/${{ matrix.bin }}:canary
          buildah manifest push --all --format 'v2s2' ${{ matrix.bin }} docker://wasmcloud.azurecr.io/${{ steps.ctx.outputs.owner }}/${{ matrix.bin }}:canary

          docker run --rm ${{ steps.ctx.outputs.owner }}/${{ matrix.bin }}:canary ${{ matrix.bin }} --version
          docker run --rm ghcr.io/${{ steps.ctx.outputs.owner }}/${{ matrix.bin }}:canary ${{ matrix.bin }} --version
          docker run --rm wasmcloud.azurecr.io/${{ steps.ctx.outputs.owner }}/${{ matrix.bin }}:canary ${{ matrix.bin }} --version

      - name: Push `${{ matrix.bin }}` version tag
        if: startswith(github.ref, format('refs/tags/{0}v', matrix.prefix))
        continue-on-error: ${{ github.repository_owner != 'wasmCloud' }}
        run: |
          buildah manifest push --all --format 'v2s2' ${{ matrix.bin }} docker://${{ steps.ctx.outputs.owner }}/${{ matrix.bin }}:${{ steps.ctx.outputs.version }}
          buildah manifest push --all --format 'v2s2' ${{ matrix.bin }} docker://ghcr.io/${{ steps.ctx.outputs.owner }}/${{ matrix.bin }}:${{ steps.ctx.outputs.version }}
          buildah manifest push --all --format 'v2s2' ${{ matrix.bin }} docker://wasmcloud.azurecr.io/${{ steps.ctx.outputs.owner }}/${{ matrix.bin }}:${{ steps.ctx.outputs.version }}

          docker run --rm ${{ steps.ctx.outputs.owner }}/${{ matrix.bin }}:${{ steps.ctx.outputs.version }} ${{ matrix.bin }} --version
          docker run --rm ghcr.io/${{ steps.ctx.outputs.owner }}/${{ matrix.bin }}:${{ steps.ctx.outputs.version }} ${{ matrix.bin }} --version
          docker run --rm wasmcloud.azurecr.io/${{ steps.ctx.outputs.owner }}/${{ matrix.bin }}:${{ steps.ctx.outputs.version }} ${{ matrix.bin }} --version

      - name: Push `${{ matrix.bin }}` `latest` tag
        if: startswith(github.ref, format('refs/tags/{0}v', matrix.prefix)) && !steps.ctx.outputs.prerelease
        continue-on-error: ${{ github.repository_owner != 'wasmCloud' }}
        run: |
          buildah manifest push --all --format 'v2s2' ${{ matrix.bin }} docker://${{ steps.ctx.outputs.owner }}/${{ matrix.bin }}:latest
          buildah manifest push --all --format 'v2s2' ${{ matrix.bin }} docker://ghcr.io/${{ steps.ctx.outputs.owner }}/${{ matrix.bin }}:latest
          buildah manifest push --all --format 'v2s2' ${{ matrix.bin }} docker://wasmcloud.azurecr.io/${{ steps.ctx.outputs.owner }}/${{ matrix.bin }}:latest

          docker run --rm ${{ steps.ctx.outputs.owner }}/${{ matrix.bin }}:latest ${{ matrix.bin }} --version
          docker run --rm ghcr.io/${{ steps.ctx.outputs.owner }}/${{ matrix.bin }}:latest ${{ matrix.bin }} --version
          docker run --rm wasmcloud.azurecr.io/${{ steps.ctx.outputs.owner }}/${{ matrix.bin }}:latest ${{ matrix.bin }} --version

  release:
    if: startsWith(github.ref, 'refs/tags/v') || startsWith(github.ref, 'refs/tags/wash-cli-v')
    needs:
      - build-bin
      - build-doc
      - build-lipo
      - cargo
      - oci
      - test-linux
      - test-windows
    runs-on: ubuntu-22.04-16-cores
    permissions:
      contents: write
    steps:
      - uses: actions/checkout@v4.1.1
      - uses: actions/download-artifact@v4
        with:
          path: artifacts
      - run: |
          for dir in ./artifacts/wasmcloud-*; do
            target=${dir#./artifacts/wasmcloud-}
            for bin_path in $(find ${dir}/bin -type f); do
              chmod +x ${bin_path}
              bin=$(basename ${bin_path})
              case "$bin" in
                *.exe)
                  bin="${bin%.exe}"
                  mkdir -p ./${bin}
                  mv ${bin_path} ./${bin}/${bin}-${target}.exe
                ;;
                *)
                  mkdir -p ./${bin}
                  mv ${bin_path} ./${bin}/${bin}-${target%-fhs}
                ;;
              esac
            done
          done

      - uses: softprops/action-gh-release@v2
        if: startsWith(github.ref, 'refs/tags/v')
        with:
          draft: true
          prerelease: true
          generate_release_notes: true
          files: ./wasmcloud/*

      - uses: softprops/action-gh-release@v2
        if: startsWith(github.ref, 'refs/tags/wash-cli-v')
        with:
          draft: true
          prerelease: true
          generate_release_notes: true
          files: ./wash/*

  snapcraft:
    if: startsWith(github.ref, 'refs/tags/wash-cli-v')
    needs: cargo
    runs-on: ubuntu-22.04-16-cores
    steps:
      - uses: actions/checkout@v4.1.1

      - uses: snapcore/action-build@v1
        id: build
        with:
          path: ./crates/wash-cli
      - uses: snapcore/action-publish@v1
        continue-on-error: ${{ github.repository_owner != 'wasmCloud' }}
        env:
          SNAPCRAFT_STORE_CREDENTIALS: ${{ secrets.SNAP_STORE_LOGIN }}
        with:
          snap: ${{ steps.build.outputs.snap }}
          release: edge

  nfpm:
    if: startsWith(github.ref, 'refs/tags/wash-cli-v')
    env:
      REF: ${{ github.ref }}
      PACKAGECLOUD_TOKEN: ${{ secrets.PACKAGECLOUD_API_TOKEN }}
    needs:
      - cargo
      - build-bin
      - test-linux
    runs-on: ubuntu-22.04-16-cores
    steps:
      - uses: actions/checkout@v4.1.1

      - uses: ./.github/actions/install-nix
        with:
          cachixAuthToken: '${{ secrets.CACHIX_AUTH_TOKEN }}'
      - name: Install NFPM
        run: nix profile install -L --inputs-from . 'nixpkgs#nfpm'

      - uses: actions/download-artifact@v4
        with:
          name: wasmcloud-aarch64-unknown-linux-musl
          path: ./crates/wash-cli/aarch64
      - uses: actions/download-artifact@v4
        with:
          name: wasmcloud-x86_64-unknown-linux-musl
          path: ./crates/wash-cli/x86_64
      - name: Make wash executable
        working-directory: ./crates/wash-cli
        run: |
          chmod +x ./aarch64/bin/wash
          chmod +x ./x86_64/bin/wash

      - name: Build `deb` and `rpm`
        working-directory: ./crates/wash-cli
        run: |
          export VERSION=$(echo $REF| cut -d- -f3 | tr -d "v")
          nfpm pkg --packager deb -f build/nfpm.amd64.yaml
          nfpm pkg --packager deb -f build/nfpm.arm64.yaml
          nfpm pkg --packager rpm -f build/nfpm.amd64.yaml
          nfpm pkg --packager rpm -f build/nfpm.arm64.yaml
      - name: Push `deb`
        working-directory: ./crates/wash-cli
        run: |
          debs=(35 203 206 207 210 215 219 220 221 233 235 237 261 266)
          for distro_version in "${debs[@]}"; do
            curl -F "package[distro_version_id]=${distro_version}" -F "package[package_file]=@$(ls wash_*_amd64.deb)" https://$PACKAGECLOUD_TOKEN:@packagecloud.io/api/v1/repos/wasmcloud/core/packages.json;
            curl -F "package[distro_version_id]=${distro_version}" -F "package[package_file]=@$(ls wash_*_arm64.deb)" https://$PACKAGECLOUD_TOKEN:@packagecloud.io/api/v1/repos/wasmcloud/core/packages.json;
          done
      - name: Push `rpm`
        working-directory: ./crates/wash-cli
        run: |
          rpms=(194 204 209 216 226 231 236 239 240 244 260 273)
          for distro_version in "${rpms[@]}"; do
            curl -F "package[distro_version_id]=${distro_version}" -F "package[package_file]=@$(ls wash-*.aarch64.rpm)" https://$PACKAGECLOUD_TOKEN:@packagecloud.io/api/v1/repos/wasmcloud/core/packages.json;
            curl -F "package[distro_version_id]=${distro_version}" -F "package[package_file]=@$(ls wash-*.x86_64.rpm)" https://$PACKAGECLOUD_TOKEN:@packagecloud.io/api/v1/repos/wasmcloud/core/packages.json;
          done

  crates:
    strategy:
      matrix:
        include:
          - crate: actor
            workspace-dependencies: true

          - crate: control-interface

          - crate: core
            workspace-dependencies: true

          - crate: host
            workspace-dependencies: true

          - crate: host-sys
            workspace-dependencies: true

          - crate: opentelemetry-nats

          - crate: provider-archive
            workspace-dependencies: true

          - crate: provider-sdk
            workspace-dependencies: true

          - crate: provider-wit-bindgen
            workspace-dependencies: true

          - crate: runtime
            workspace-dependencies: true

          - crate: tracing
            workspace-dependencies: true

          - crate: wascap

          - crate: wash-cli
            workspace-dependencies: true

          - crate: wash-lib
            workspace-dependencies: true

    name: publish ${{ matrix.crate }} to crates.io
    needs: cargo
    runs-on: ubuntu-22.04-16-cores
    steps:
      - uses: actions/checkout@v4.1.1

      - name: Extract tag context
        id: ctx
        run: |
          version=${GITHUB_REF_NAME#${{ matrix.crate }}-v}
          echo "version is ${version}"
          if [[ $version == *"-"* ]]; then
            echo "version ${version} is a pre-release"
            echo "prerelease=true" >> "$GITHUB_OUTPUT"
          fi

      - name: dry-run publish ${{ matrix.crate }} to crates.io
        if: ${{ !startsWith(github.ref, 'refs/tags/') }}
        continue-on-error: ${{ matrix.workspace-dependencies }} # publish may fail due to workspace crates not being published yet
        run: cargo publish --dry-run
        working-directory: ./crates/${{ matrix.crate }}

      - name: publish ${{ matrix.crate }} to crates.io
        if: startsWith(github.ref, format('refs/tags/{0}-v', matrix.crate)) && !steps.ctx.outputs.prerelease
        continue-on-error: ${{ github.repository_owner != 'wasmCloud' }}
        run: cargo publish --token ${{ secrets.CRATES_PUBLISH_TOKEN }}
        working-directory: ./crates/${{ matrix.crate }}