Switch to stripping using cargo and supporting a latest release tag

.github/workflows/lock.yml

@@ -0,0 +1,28 @@
+name: 'Lock Threads'
+
+on:
+  schedule:
+    - cron: '0 3 * * *'
+  workflow_dispatch:
+
+permissions:
+  issues: write
+  pull-requests: write
+
+concurrency:
+  group: lock
+
+jobs:
+  action:
+    runs-on: ubuntu-latest
+    steps:
+      - uses: dessant/lock-threads@v4
+        with:
+          issue-inactive-days: '30'
+          issue-comment: >
+            I'm going to lock this issue because it has been closed for _30 days_ ⏳.
+            This helps our maintainers find and focus on the active issues.
+            If you have found a problem that seems similar to this, please open a new
+            issue and complete the issue template so we can capture all the details
+            necessary to investigate further.
+          process-only: 'issues'

.github/workflows/release.yml

@@ -5,360 +5,212 @@ on:
     tags:
       - v[0-9]+.[0-9]+.[0-9]+
       - v[0-9]+.[0-9]+.[0-9]+-**
+      - latest
+
+# Targets:
+#
+# - x86_64-apple-darwin
+# - aarch64-apple-darwin
+#
+# - x86_64-pc-windows-msvc
+# - aarch64-pc-windows-msvc
+#
+# - x86_64-unknown-linux-gnu
+# - aarch64-unknown-linux-gnu
+# - aarch64-linux-android (fails due to termios)
+# - armv7-unknown-linux-gnueabihf
+#
+# - x86_64-unknown-linux-musl
+# - aarch64-unknown-linux-musl
+#
+# - x86_64-unknown-freebsd
+# - aarch64-unknown-freebsd (works manually, but cannot cross-compile)
+#
+# - x86_64-unknown-netbsd (???)
+# - aarch64-unknown-netbsd (???)
+#
+# - x86_64-unknown-openbsd (???)
+# - aarch64-unknown-openbsd (fails due to openssl-src)
+#
 
 jobs:
   macos:
-    name: "Build release on MacOS"
+    name: "Build release on MacOS (${{ matrix.target }})"
     runs-on: macos-11.0
-    if: startsWith(github.ref, 'refs/tags/')
+    strategy:
-    env:
+      matrix:
-      UPLOAD_NAME: macos
+        target:
-      X86_ARCH: x86_64-apple-darwin
+          - x86_64-apple-darwin
-      ARM_ARCH: aarch64-apple-darwin
+          - aarch64-apple-darwin
-      X86_DIR: target/x86_64-apple-darwin/release
-      ARM_DIR: target/aarch64-apple-darwin/release
-      BUILD_BIN: distant
-      UNIVERSAL_REL_BIN: distant-macos
     steps:
       - uses: actions/checkout@v3
-      - name: Install Rust (x86)
+      - name: Install Rust (${{ matrix.target }})
-        uses: actions-rs/toolchain@v1
-        with:
-          profile: minimal
-          toolchain: stable
-          target: ${{ env.X86_ARCH }}
-      - name: Install Rust (ARM)
         uses: actions-rs/toolchain@v1
         with:
           profile: minimal
           toolchain: stable
-          target: ${{ env.ARM_ARCH }}
+          target: ${{ matrix.target }}
+          override: true
       - uses: Swatinem/rust-cache@v2
-      - name: Build binary (x86_64)
+      - name: Build binary (${{ matrix.target }})
-        run: |
-          cargo build --release --all-features --target ${{ env.X86_ARCH }}
-          ls -l ./${{ env.X86_DIR }}
-          strip ./${{ env.X86_DIR }}/${{ env.BUILD_BIN }}
-      - name: Build binary (aarch64)
-        run: |
-          cargo build --release --all-features --target ${{ env.ARM_ARCH }}
-          ls -l ./${{ env.ARM_DIR }}
-          strip ./${{ env.ARM_DIR }}/${{ env.BUILD_BIN }}
-      - name: Unify binaries
         run: |
-          lipo -create -output ${{ env.UNIVERSAL_REL_BIN }} \
+          cargo build --release --all-features --target ${{ matrix.target }}
-              ./${{ env.X86_DIR }}/${{ env.BUILD_BIN }} \
+          mv ./target/${{ matrix.target }}/release/distant ./distant-${{ matrix.target }}
-              ./${{ env.ARM_DIR }}/${{ env.BUILD_BIN }}
+          chmod +x ./distant-${{ matrix.target }}
-          chmod +x ./${{ env.UNIVERSAL_REL_BIN }}
       - name: Upload 
         uses: actions/upload-artifact@v2
         with:
-          name: ${{ env.UPLOAD_NAME }}
+          name: ${{ matrix.target }}
-          path: |
+          path: ./distant-${{ matrix.target }}
-            ${{ env.UNIVERSAL_REL_BIN }}
 
   windows:
-    name: "Build release on Windows"
+    name: "Build release on Windows (${{ matrix.target }})"
     runs-on: windows-latest
-    if: startsWith(github.ref, 'refs/tags/')
+    strategy:
-    env:
+      matrix:
-      UPLOAD_NAME: win64
+        target:
-      X86_ARCH: x86_64-pc-windows-msvc
+          - x86_64-pc-windows-msvc
-      X86_DIR: target/x86_64-pc-windows-msvc/release
+          - aarch64-pc-windows-msvc
-      BUILD_BIN: distant.exe
-      X86_REL_BIN: distant-win64.exe
     steps:
       - uses: actions/checkout@v2
-      - name: Install Rust (MSVC)
+      - name: Install Rust (${{ matrix.target }})
         uses: actions-rs/toolchain@v1
         with:
           profile: minimal
           toolchain: stable
-          target: ${{ env.X86_ARCH }}
+          target: ${{ matrix.target }}
-      - uses: Swatinem/rust-cache@v2
+          override: true
-      - name: Build binary (x86_64)
-        run: |
-          cargo build --release --all-features --target ${{ env.X86_ARCH }}
-          ls -l ./${{ env.X86_DIR }}
-          strip ./${{ env.X86_DIR }}/${{ env.BUILD_BIN }}
-          mv ./${{ env.X86_DIR }}/${{ env.BUILD_BIN }} ./${{ env.X86_REL_BIN }}
-          chmod +x ./${{ env.X86_REL_BIN }}
-      - name: Upload 
-        uses: actions/upload-artifact@v2
-        with:
-          name: ${{ env.UPLOAD_NAME }}
-          path: |
-            ${{ env.X86_REL_BIN }}
-
-  linux_gnu_x86:
-    name: "Build release on Linux (GNU x86)"
-    runs-on: ubuntu-latest
-    if: startsWith(github.ref, 'refs/tags/')
-    env:
-      UPLOAD_NAME: linux64-gnu-x86
-      X86_GNU_ARCH: x86_64-unknown-linux-gnu
-      X86_GNU_DIR: target/x86_64-unknown-linux-gnu/release
-      BUILD_BIN: distant
-      X86_GNU_REL_BIN: distant-linux64-gnu-x86
-    steps:
-      - uses: actions/checkout@v2
-      - name: Install Rust (GNU x86)
-        uses: actions-rs/toolchain@v1
-        with:
-          profile: minimal
-          toolchain: stable
-          target: ${{ env.X86_GNU_ARCH }}
-      - uses: Swatinem/rust-cache@v2
-      - name: Build binary (GNU x86_64)
-        run: |
-          cargo build --release --all-features --target ${{ env.X86_GNU_ARCH }}
-          ls -l ./${{ env.X86_GNU_DIR }}
-          strip ./${{ env.X86_GNU_DIR }}/${{ env.BUILD_BIN }}
-          mv ./${{ env.X86_GNU_DIR }}/${{ env.BUILD_BIN }} ./${{ env.X86_GNU_REL_BIN }}
-          chmod +x ./${{ env.X86_GNU_REL_BIN }}
-      - name: Upload 
-        uses: actions/upload-artifact@v2
-        with:
-          name: ${{ env.UPLOAD_NAME }}
-          path: |
-            ${{ env.X86_GNU_REL_BIN }}
-
-  linux_gnu_aarch64:
-    name: "Build release on Linux (GNU aarch64)"
-    runs-on: ubuntu-latest
-    if: startsWith(github.ref, 'refs/tags/')
-    env:
-      UPLOAD_NAME: linux64-gnu-aarch64
-      AARCH64_GNU_ARCH: aarch64-unknown-linux-gnu
-      AARCH64_GNU_DIR: target/aarch64-unknown-linux-gnu/release
-      BUILD_BIN: distant
-      AARCH64_GNU_REL_BIN: distant-linux64-gnu-aarch64
-    steps:
-      - uses: actions/checkout@v2
-      - name: Install Rust (GNU aarch64)
-        uses: actions-rs/toolchain@v1
-        with:
-          profile: minimal
-          toolchain: stable
-          target: ${{ env.AARCH64_GNU_ARCH }}
-      - uses: Swatinem/rust-cache@v2
-      - name: Install linker & binutils (gcc-aarch64-linux-gnu)
-        run: |
-          sudo apt update
-          sudo apt install -y gcc-aarch64-linux-gnu binutils-aarch64-linux-gnu
-      - name: Build binary (GNU aarch64)
-        run: |
-          cargo build --release --all-features --target ${{ env.AARCH64_GNU_ARCH }}
-          ls -l ./${{ env.AARCH64_GNU_DIR }}
-          /usr/aarch64-linux-gnu/bin/strip ./${{ env.AARCH64_GNU_DIR }}/${{ env.BUILD_BIN }}
-          mv ./${{ env.AARCH64_GNU_DIR }}/${{ env.BUILD_BIN }} ./${{ env.AARCH64_GNU_REL_BIN }}
-          chmod +x ./${{ env.AARCH64_GNU_REL_BIN }}
-      - name: Upload 
-        uses: actions/upload-artifact@v2
-        with:
-          name: ${{ env.UPLOAD_NAME }}
-          path: |
-            ${{ env.AARCH64_GNU_REL_BIN }}
-
-  linux_gnu_arm_v7:
-    name: "Build release on Linux (GNU arm-v7)"
-    runs-on: ubuntu-latest
-    if: startsWith(github.ref, 'refs/tags/')
-    env:
-      UPLOAD_NAME: linux64-gnu-arm-v7
-      ARMV7_GNU_ARCH: armv7-unknown-linux-gnueabihf
-      ARMV7_GNU_DIR: target/armv7-unknown-linux-gnueabihf/release
-      BUILD_BIN: distant
-      ARMV7_GNU_REL_BIN: distant-linux64-gnu-arm-v7
-    steps:
-      - uses: actions/checkout@v2
-      - name: Install Rust (GNU arm-v7)
-        uses: actions-rs/toolchain@v1
-        with:
-          profile: minimal
-          toolchain: stable
-          target: ${{ env.ARMV7_GNU_ARCH }}
       - uses: Swatinem/rust-cache@v2
-      - name: Install linker & binutils (gcc-arm-linux-gnueabihf)
+      - name: Build binary (${{ matrix.target }})
         run: |
-          sudo apt update
+          cargo build --release --all-features --target ${{ matrix.target }}
-          sudo apt install -y gcc-arm-linux-gnueabihf binutils-arm-linux-gnueabihf
+          mv ./target/${{ matrix.target }}/release/distant.exe ./distant-${{ matrix.target }}.exe
-      - name: Build binary (GNU arm-v7)
+          chmod +x ./distant-${{ matrix.target }}.exe
-        run: |
-          cargo build --release --all-features --target ${{ env.ARMV7_GNU_ARCH }}
-          ls -l ./${{ env.ARMV7_GNU_DIR }}
-          /usr/arm-linux-gnueabihf/bin/strip ./${{ env.ARMV7_GNU_DIR }}/${{ env.BUILD_BIN }}
-          mv ./${{ env.ARMV7_GNU_DIR }}/${{ env.BUILD_BIN }} ./${{ env.ARMV7_GNU_REL_BIN }}
-          chmod +x ./${{ env.ARMV7_GNU_REL_BIN }}
       - name: Upload 
         uses: actions/upload-artifact@v2
         with:
-          name: ${{ env.UPLOAD_NAME }}
+          name: ${{ matrix.target }}
-          path: |
+          path: ./distant-${{ matrix.target }}.exe
-            ${{ env.ARMV7_GNU_REL_BIN }}
 
-  # NOTE: For musl, we only support ssh2 and not libssh for the time being due to some
+  linux:
-  #       build issue with libssh-rs-sys not finding the symbol ENGINE_cleanup in libcrypto
+    name: "Build release on Linux (${{ matrix.target }})"
-  linux_musl_x86:
-    name: "Build release on Linux (musl x86)"
     runs-on: ubuntu-latest
-    if: startsWith(github.ref, 'refs/tags/')
+    strategy:
-    env:
+      matrix:
-      UPLOAD_NAME: linux64-musl-x86
+        include:
-      X86_MUSL_ARCH: x86_64-unknown-linux-musl
+          - target: x86_64-unknown-linux-gnu
-      X86_MUSL_DIR: target/x86_64-unknown-linux-musl/release
+            build: --all-features
-      BUILD_BIN: distant
+          - target: aarch64-unknown-linux-gnu
-      X86_MUSL_REL_BIN: distant-linux64-musl-x86
+            build: --all-features
+            deps: gcc-aarch64-linux-gnu binutils-aarch64-linux-gnu
+          - target: armv7-unknown-linux-gnueabihf
+            build: --all-features
+            deps: gcc-arm-linux-gnueabihf binutils-arm-linux-gnueabihf
+          - target: x86_64-unknown-linux-musl
+            build: --no-default-features --features ssh2
+            deps: musl-tools
+          - target: aarch64-unknown-linux-musl
+            build: --no-default-features --features ssh2
+            deps: musl-tools gcc-aarch64-linux-gnu binutils-aarch64-linux-gnu
     steps:
       - uses: actions/checkout@v2
-      - name: Install Rust (MUSL x86)
+      - name: Install Rust (${{ matrix.target }})
         uses: actions-rs/toolchain@v1
         with:
           profile: minimal
           toolchain: stable
-          target: ${{ env.X86_MUSL_ARCH }}
+          target: ${{ matrix.target }}
           override: true
-      - name: Install musl tools
+      - uses: Swatinem/rust-cache@v2
+      - name: Install dependencies
+        if: ${{ matrix.deps }}
         run: |
           sudo apt update
-          sudo apt install -y musl-tools
+          sudo apt install -y ${{ matrix.deps }}
-      - uses: Swatinem/rust-cache@v2
+      - name: Build binary (${{ matrix.target }})
-      - name: Build binary (MUSL x86_64)
         run: |
-          cargo build --release --no-default-features --features ssh2 --target ${{ env.X86_MUSL_ARCH }}
+          cargo build --release ${{ matrix.build }} --target ${{ matrix.target }}
-          ls -l ./${{ env.X86_MUSL_DIR }}
+          mv ./target/${{ matrix.target }}/release/distant ./distant-${{ matrix.target }}
-          strip ./${{ env.X86_MUSL_DIR }}/${{ env.BUILD_BIN }}
+          chmod +x ./distant-${{ matrix.target }}
-          mv ./${{ env.X86_MUSL_DIR }}/${{ env.BUILD_BIN }} ./${{ env.X86_MUSL_REL_BIN }}
-          chmod +x ./${{ env.X86_MUSL_REL_BIN }}
       - name: Upload 
         uses: actions/upload-artifact@v2
         with:
-          name: ${{ env.UPLOAD_NAME }}
+          name: ${{ matrix.target }}
-          path: |
+          path: ./distant-${{ matrix.target }}
-            ${{ env.X86_MUSL_REL_BIN }}
 
-  # NOTE: For musl, we only support ssh2 and not libssh for the time being due to some
+  bsd:
-  #       build issue with libssh-rs-sys not finding the symbol ENGINE_cleanup in libcrypto
+    name: "Build release on BSD (${{ matrix.os.target }})"
-  linux_musl_aarch64:
+    runs-on: ${{ matrix.os.host }} 
-    name: "Build release on Linux (musl aarch64)"
+    strategy:
-    runs-on: ubuntu-latest
+      matrix:
-    if: startsWith(github.ref, 'refs/tags/')
+        os:
-    env:
+          - name: freebsd
-      UPLOAD_NAME: linux64-musl-aarch64
+            architecture: x86-64
-      AARCH64_MUSL_ARCH: aarch64-unknown-linux-musl
+            version: '13.2'
-      AARCH64_MUSL_DIR: target/aarch64-unknown-linux-musl/release
+            host: macos-12
-      BUILD_BIN: distant
+            target: x86_64-unknown-freebsd
-      AARCH64_MUSL_REL_BIN: distant-linux64-musl-aarch64
+            build: --all-features
+            prepare: pkg install -y openssl gmake lang/rust devel/llvm-devel
+          - name: openbsd
+            architecture: x86-64
+            version: '7.3'
+            host: macos-12
+            target: x86_64-unknown-openbsd
+            build: --all-features
+            prepare: pkg_add -I gmake rust llvm
     steps:
-      - uses: actions/checkout@v2
+      - uses: actions/checkout@v3
-      - name: Install Rust (MUSL aarch64)
-        uses: actions-rs/toolchain@v1
-        with:
-          profile: minimal
-          toolchain: stable
-          target: ${{ env.AARCH64_MUSL_ARCH }}
-          override: true
-      - name: Install musl tools
-        run: |
-          sudo apt update
-          sudo apt install -y musl-tools gcc-aarch64-linux-gnu binutils-aarch64-linux-gnu
-      - name: Install cross
-        env:
-          LINK: https://github.com/cross-rs/cross/releases/download
-          CROSS_VERSION: 0.2.4
-          CROSS_FILE: cross-x86_64-unknown-linux-musl
-        run: |
-          curl -L "$LINK/v$CROSS_VERSION/$CROSS_FILE.tar.gz" |
-          tar xz -C $HOME/.cargo/bin
       - uses: Swatinem/rust-cache@v2
-      - name: Build binary (MUSL aarch64)
+      - name: Build in FreeBSD
-        run: |
+        uses: cross-platform-actions/action@v0.15.0
-          cross build --release --no-default-features --features ssh2 --target ${{ env.AARCH64_MUSL_ARCH }}
+        with:
-          ls -l ./${{ env.AARCH64_MUSL_DIR }}
+          operating_system: ${{ matrix.os.name }}
-          aarch64-linux-gnu-strip ./${{ env.AARCH64_MUSL_DIR }}/${{ env.BUILD_BIN }}
+          architecture: ${{ matrix.os.architecture }}
-          mv ./${{ env.AARCH64_MUSL_DIR }}/${{ env.BUILD_BIN }} ./${{ env.AARCH64_MUSL_REL_BIN }}
+          version: ${{ matrix.os.version }}
-          chmod +x ./${{ env.AARCH64_MUSL_REL_BIN }}
+          shell: bash
+          run: |
+            ${{ matrix.os.prepare }}
+            cargo build --release ${{ matrix.os.build }} --target ${{ matrix.os.target }}
+            mv ./target/${{ matrix.os.target }}/release/distant ./distant-${{ matrix.os.target }}
+            chmod +x ./distant-${{ matrix.os.target }}
       - name: Upload 
         uses: actions/upload-artifact@v2
         with:
-          name: ${{ env.UPLOAD_NAME }}
+          name: ${{ matrix.os.target }}
-          path: |
+          path: ./distant-${{ matrix.os.target }}
-            ${{ env.AARCH64_MUSL_REL_BIN }}
 
   publish:
-    needs: [macos, windows, linux_gnu_x86, linux_gnu_aarch64, linux_gnu_arm_v7, linux_musl_x86, linux_musl_aarch64]
+    needs: [macos, windows, linux, bsd]
     runs-on: ubuntu-latest
-    if: startsWith(github.ref, 'refs/tags/')
     permissions:
       contents: write
-    env:
-      MACOS: macos
-      MACOS_UNIVERSAL_BIN: distant-macos
-      WIN64: win64
-      WIN64_BIN: distant-win64.exe
-      LINUX64_GNU_X86: linux64-gnu-x86
-      LINUX64_GNU_X86_BIN: distant-linux64-gnu-x86
-      LINUX64_GNU_AARCH64: linux64-gnu-aarch64
-      LINUX64_GNU_AARCH64_BIN: distant-linux64-gnu-aarch64
-      LINUX64_GNU_ARMV7: linux64-gnu-arm-v7
-      LINUX64_GNU_ARMV7_BIN: distant-linux64-gnu-arm-v7
-      LINUX64_MUSL_X86: linux64-musl-x86
-      LINUX64_MUSL_X86_BIN: distant-linux64-musl-x86
-      LINUX64_MUSL_AARCH64: linux64-musl-aarch64
-      LINUX64_MUSL_AARCH64_BIN: distant-linux64-musl-aarch64
     steps:
       - uses: actions/checkout@v2
       - uses: actions/download-artifact@v2
-      - name: Generate MacOS SHA256 checksums
+      - name: Generate SHA256 checksums
-        run: |
-          cd ${{ env.MACOS }}
-          sha256sum ${{ env.MACOS_UNIVERSAL_BIN }} > ${{ env.MACOS_UNIVERSAL_BIN }}.sha256sum
-          echo "SHA_MACOS_BIN=$(cat ${{ env.MACOS_UNIVERSAL_BIN }}.sha256sum)" >> $GITHUB_ENV
-      - name: Generate Win64 SHA256 checksums
-        run: |
-          cd ${{ env.WIN64 }}
-          sha256sum ${{ env.WIN64_BIN }} > ${{ env.WIN64_BIN }}.sha256sum
-          echo "SHA_WIN64_BIN=$(cat ${{ env.WIN64_BIN }}.sha256sum)" >> $GITHUB_ENV
-      - name: Generate Linux64 (gnu x86) SHA256 checksums
-        run: |
-          cd ${{ env.LINUX64_GNU_X86 }}
-          sha256sum ${{ env.LINUX64_GNU_X86_BIN }} > ${{ env.LINUX64_GNU_X86_BIN }}.sha256sum
-          echo "SHA_LINUX64_GNU_X86_BIN=$(cat ${{ env.LINUX64_GNU_X86_BIN }}.sha256sum)" >> $GITHUB_ENV
-      - name: Generate Linux64 (gnu aarch64) SHA256 checksums
         run: |
-          cd ${{ env.LINUX64_GNU_AARCH64 }}
+          for i in $(find . -name "distant-*" -type f); do
-          sha256sum ${{ env.LINUX64_GNU_AARCH64_BIN }} > ${{ env.LINUX64_GNU_AARCH64_BIN }}.sha256sum
+            echo "Generating checksum for ${i}"
-          echo "SHA_LINUX64_GNU_AARCH64_BIN=$(cat ${{ env.LINUX64_GNU_AARCH64_BIN }}.sha256sum)" >> $GITHUB_ENV
+            sha256sum "${i}" > "${i}.sha256sum"
-      - name: Generate Linux64 (gnu arm-v7) SHA256 checksums
+          done
-        run: |
-          cd ${{ env.LINUX64_GNU_ARMV7 }}
-          sha256sum ${{ env.LINUX64_GNU_ARMV7_BIN }} > ${{ env.LINUX64_GNU_ARMV7_BIN }}.sha256sum
-          echo "SHA_LINUX64_GNU_ARMV7_BIN=$(cat ${{ env.LINUX64_GNU_ARMV7_BIN }}.sha256sum)" >> $GITHUB_ENV
-      - name: Generate Linux64 (musl x86) SHA256 checksums
-        run: |
-          cd ${{ env.LINUX64_MUSL_X86 }}
-          sha256sum ${{ env.LINUX64_MUSL_X86_BIN }} > ${{ env.LINUX64_MUSL_X86_BIN }}.sha256sum
-          echo "SHA_LINUX64_MUSL_X86_BIN=$(cat ${{ env.LINUX64_MUSL_X86_BIN }}.sha256sum)" >> $GITHUB_ENV
-      - name: Generate Linux64 (musl aarch64) SHA256 checksums
-        run: |
-          cd ${{ env.LINUX64_MUSL_AARCH64 }}
-          sha256sum ${{ env.LINUX64_MUSL_AARCH64_BIN }} > ${{ env.LINUX64_MUSL_AARCH64_BIN }}.sha256sum
-          echo "SHA_LINUX64_MUSL_AARCH64_BIN=$(cat ${{ env.LINUX64_MUSL_AARCH64_BIN }}.sha256sum)" >> $GITHUB_ENV
       - name: Determine git tag
         if: github.event_name == 'push'
         run: |
           TAG_NAME=${{ github.ref }}
           echo "TAG_NAME=${TAG_NAME#refs/tags/}" >> $GITHUB_ENV
           echo "TAG_VERSION=${TAG_NAME#refs/tags/v}" >> $GITHUB_ENV
-      - name: Check git tag for pre-release
+      - name: Check git tag for pre-release or latest
         id: check-tag
         run: |
           if [[ ${{ github.ref }} =~ ^refs/tags/v[0-9]+\.[0-9]+\.[0-9]+-.*$ ]]; then
               echo ::set-output name=match::true
+          elif [[ ${{ github.ref }} =~ ^refs/tags/latest$ ]]; then
+              echo ::set-output name=latest::true
           fi
       - name: Print pre-release status
         run: |
           echo "Is ${{ github.ref }} a pre-release: ${{ steps.check-tag.outputs.match }}"
+          echo "Is ${{ github.ref }} latest: ${{ steps.check-tag.outputs.latest }}"
       - name: Get Changelog Entry
         id: changelog
         uses: mindsers/changelog-reader-action@v2
@@ -374,33 +226,10 @@ jobs:
           draft: false
           prerelease: ${{ steps.check-tag.outputs.match == 'true' }}
           files: |
-            ${{ env.MACOS }}/${{ env.MACOS_UNIVERSAL_BIN }}
+            **/distant-*
-            ${{ env.WIN64 }}/${{ env.WIN64_BIN }}
-            ${{ env.LINUX64_GNU_X86 }}/${{ env.LINUX64_GNU_X86_BIN }}
-            ${{ env.LINUX64_GNU_AARCH64 }}/${{ env.LINUX64_GNU_AARCH64_BIN }}
-            ${{ env.LINUX64_GNU_ARMV7 }}/${{ env.LINUX64_GNU_ARMV7_BIN }}
-            ${{ env.LINUX64_MUSL_X86 }}/${{ env.LINUX64_MUSL_X86_BIN }}
-            ${{ env.LINUX64_MUSL_AARCH64 }}/${{ env.LINUX64_MUSL_AARCH64_BIN }}
             **/*.sha256sum
           body: |
-            ## Release Notes
+            ## Latest
-            ${{ steps.changelog.outputs.changes }}
+
-            ## Binaries
+            This is the latest commit (${{ github.sha }}) built for testing.
-            Standalone binaries are built out for Windows (x86_64), MacOS (Intel & ARM), and Linux (x86_64, aarch64, armv7).
+            This is not guaranteed to pass all tests or even function properly.
-            - **linux64-gnu-x86** is the x86-64 release on Linux using libc
-            - **linux64-gnu-aarch64** is the aarch64 release on Linux using libc
-            - **linux64-gnu-arm-v7** is the arm-v7 release on Linux using libc (for Raspberry PI)
-            - **linux64-musl-x86** is the x86-64 release on Linux using musl (static binary, no libc dependency)
-            - **linux64-musl-aarch64** is the aarch64 release on Linux using musl (static binary, no libc dependency)
-            - **macos** is a universal binary for Mac OS that supports x86-64 and aarch64 (ARM) platforms
-            - **win64** is the x86-64 release on Windows using MSVC
-            ## SHA256 Checksums
-            ```
-            ${{ env.SHA_MACOS_BIN }}
-            ${{ env.SHA_WIN64_BIN }}
-            ${{ env.SHA_LINUX64_GNU_X86_BIN }}
-            ${{ env.SHA_LINUX64_GNU_AARCH64_BIN }}
-            ${{ env.SHA_LINUX64_GNU_ARMV7_BIN }}
-            ${{ env.SHA_LINUX64_MUSL_X86_BIN }}
-            ${{ env.SHA_LINUX64_MUSL_AARCH64_BIN }}
-            ```

Cargo.toml

@@ -25,6 +25,7 @@ members = [
 opt-level = 'z'
 lto = true
 codegen-units = 1
+strip = true
 
 [features]
 default = ["libssh", "ssh2"]