wowlet/.gitea/workflows/build-macos.yml

name: macos build (gitea self-hosted)

# Runs ONLY on the Gitea mac runner (GitHub ignores .gitea/workflows).
# Dispatch-only: the mac runner has capacity 1 and also serves the Hash Bags
# iOS lane, so macOS wowlet builds are an explicit button, not a push hook.
# All build state lands under the runner's work dir, which lives on
# /Volumes/DataSSD (never backed up: the fleet backup pulls an allowlist of
# gitea data only).
#
# Signing/notarization uses the SAME seven secrets as the smirk-monorepo
# desktop lane, set by ~/keys/suchsoftware/set-gitea-desktop-secrets.sh:
#   APPLE_CERTIFICATE (b64 Developer ID Application .p12),
#   APPLE_CERTIFICATE_PASSWORD, APPLE_SIGNING_IDENTITY, APPLE_TEAM_ID,
#   APPLE_API_ISSUER, APPLE_API_KEY, APPLE_API_KEY_P8_BASE64 (notarytool).
# If APPLE_CERTIFICATE is unset the build ships unsigned instead of failing.

on: [workflow_dispatch]

jobs:
  build-macos:
    name: "macOS (brew, native)"
    runs-on: macos-latest
    env:
      APPLE_CERTIFICATE: ${{ secrets.APPLE_CERTIFICATE }}
      APPLE_CERTIFICATE_PASSWORD: ${{ secrets.APPLE_CERTIFICATE_PASSWORD }}
      APPLE_SIGNING_IDENTITY: ${{ secrets.APPLE_SIGNING_IDENTITY }}
      APPLE_API_ISSUER: ${{ secrets.APPLE_API_ISSUER }}
      APPLE_API_KEY: ${{ secrets.APPLE_API_KEY }}
      APPLE_API_KEY_P8_BASE64: ${{ secrets.APPLE_API_KEY_P8_BASE64 }}
    steps:
      - uses: actions/checkout@v4
        with:
          submodules: recursive

      - name: install dependencies (brew)
        run: |
          export PATH="/opt/homebrew/bin:$PATH"
          set +o pipefail   # yes(1) takes SIGPIPE when brew has nothing to ask
          export NONINTERACTIVE=1 HOMEBREW_NO_ENV_HINTS=1 HOMEBREW_NO_INSTALL_UPGRADE=1
          yes | brew install --quiet qt libsodium libzip qrencode unbound cmake boost hidapi openssl expat protobuf pkgconfig zxing-cpp

      - name: fetch wownerod to embed
        run: |
          set -e
          ARCH=$(uname -m)
          case "$ARCH" in
            arm64) WOWTAR=wownero-aarch64-apple-darwin11-v0.11.4.0.tar.bz2 ;;
            *)     WOWTAR=wownero-x86_64-apple-darwin11-v0.11.4.0.tar.bz2 ;;
          esac
          mkdir -p /tmp/wownerod-embed /tmp/wow-extract
          curl -L -o /tmp/wownero.tar.bz2 \
            "https://github.com/wownero/wownero-codeberg-mirror/releases/download/v0.11.4.0/$WOWTAR"
          # /tmp is a symlink on macOS — find(1) won't descend it as a bare argument
          tar xjf /tmp/wownero.tar.bz2 -C /tmp/wow-extract
          find /tmp/wow-extract -name wownerod -type f -exec cp {} /tmp/wownerod-embed/ \;
          chmod +x /tmp/wownerod-embed/wownerod
          ls -la /tmp/wownerod-embed

      - name: fetch tor to embed
        run: |
          set -e
          ARCH=$(uname -m)
          case "$ARCH" in
            arm64) TORTAR=tor-expert-bundle-macos-aarch64-15.0.tar.gz ;;
            *)     TORTAR=tor-expert-bundle-macos-x86_64-15.0.tar.gz ;;
          esac
          mkdir -p /tmp/teb /tmp/tor-embed
          curl -L -o /tmp/teb.tgz "https://archive.torproject.org/tor-package-archive/torbrowser/15.0/$TORTAR"
          tar xzf /tmp/teb.tgz -C /tmp/teb
          cp /tmp/teb/tor/tor /tmp/teb/tor/libevent-*.dylib /tmp/tor-embed/
          # tor ships UNSIGNED; arm64 macOS SIGKILLs unsigned binaries. Ad-hoc sign
          # BEFORE embedding — the signature travels inside the file, so the copy
          # the app unpacks at runtime on user machines is runnable too.
          codesign -s - -f /tmp/tor-embed/tor /tmp/tor-embed/libevent-*.dylib
          chmod +x /tmp/tor-embed/tor
          # expert-bundle RELEASE number (15.0) is NOT the tor version — derive it
          TORVER=$(/tmp/tor-embed/tor --version | grep -oE '[0-9]+(\.[0-9]+){3}' | head -1)
          echo "TOR_VERSION=$TORVER" >> "$GITHUB_ENV"
          echo "embedded tor version: $TORVER"

      - name: build
        run: |
          export PATH="/opt/homebrew/bin:$PATH"
          # clang does not search /opt/homebrew/include by default; the feather
          # target pulls monero headers that include boost, and modern Boost's
          # CMake config leaves Boost_INCLUDE_DIRS empty. CPATH/LIBRARY_PATH make
          # every linked brew header/lib findable without per-dep flag surgery.
          export CPATH="$(brew --prefix)/include"
          export LIBRARY_PATH="$(brew --prefix)/lib"
          mkdir -p build && cd build
          cmake -DWITH_SCANNER=OFF -DUSE_DEVICE_TREZOR=OFF -DWOWNEROD_DIR=/tmp/wownerod-embed -DTOR_DIR=/tmp/tor-embed -DTOR_VERSION="$TOR_VERSION" -DCMAKE_PREFIX_PATH="$(brew --prefix qt)" ..
          cmake --build . -j "$(sysctl -n hw.ncpu)"

      - name: package app bundle
        run: |
          set -e
          cd build
          APP=$(find . -maxdepth 3 -name "*.app" -type d | head -1)
          [ -n "$APP" ] || { echo "no .app bundle produced"; ls -la bin/; exit 1; }
          mkdir -p dist
          cp -R "$APP" dist/Wowlet.app
          # cmake never places the icon in the bundle (upstream only copies it
          # for the dormant `installed/` layout)
          mkdir -p dist/Wowlet.app/Contents/Resources
          cp ../src/assets/images/appicons/appicon.icns dist/Wowlet.app/Contents/Resources/
          # bundle Qt frameworks/plugins so the app runs off-machine
          /opt/homebrew/opt/qt/bin/macdeployqt dist/Wowlet.app
          ls -la dist/

      - name: sign and notarize (skipped when secrets absent)
        run: |
          set -e
          cd build
          if [ -z "$APPLE_CERTIFICATE" ]; then
            echo "APPLE_CERTIFICATE not set — shipping UNSIGNED build"
            exit 0
          fi
          KC=/tmp/wowlet-ci.keychain-db
          KCPW=$(/usr/bin/uuidgen)
          echo "$KCPW" > /tmp/wowlet-ci-kcpw   # for the cleanup step only
          security create-keychain -p "$KCPW" "$KC"
          security set-keychain-settings -lut 3600 "$KC"
          security unlock-keychain -p "$KCPW" "$KC"
          printf '%s' "$APPLE_CERTIFICATE" | base64 -d > /tmp/dev_id.p12
          security import /tmp/dev_id.p12 -k "$KC" -P "$APPLE_CERTIFICATE_PASSWORD" \
            -T /usr/bin/codesign
          security set-key-partition-list -S apple-tool:,apple: -s -k "$KCPW" "$KC" >/dev/null
          security list-keychains -d user -s "$KC" login.keychain-db

          # sign nested Mach-O executables first (embedded wownerod etc.),
          # then frameworks, then the bundle — all hardened-runtime + timestamp
          SIGN() { codesign --force --options runtime --timestamp --keychain "$KC" \
                     --sign "$APPLE_SIGNING_IDENTITY" "$@"; }
          find dist/Wowlet.app -type f -perm +111 ! -path "*/Frameworks/*" \
            | while read -r f; do file "$f" | grep -q Mach-O && SIGN "$f" || true; done
          find dist/Wowlet.app/Contents/Frameworks -maxdepth 1 \( -name "*.framework" -o -name "*.dylib" \) 2>/dev/null \
            | while read -r fw; do SIGN "$fw"; done
          SIGN dist/Wowlet.app
          codesign --verify --deep --strict dist/Wowlet.app

          printf '%s' "$APPLE_API_KEY_P8_BASE64" | base64 -d > /tmp/notary.p8
          ditto -c -k --keepParent dist/Wowlet.app /tmp/wowlet-notarize.zip
          xcrun notarytool submit /tmp/wowlet-notarize.zip \
            --key /tmp/notary.p8 --key-id "$APPLE_API_KEY" --issuer "$APPLE_API_ISSUER" \
            --wait --timeout 30m
          xcrun stapler staple dist/Wowlet.app
          echo "signed + notarized + stapled"

      - name: zip artifact
        run: |
          set -e
          cd build/dist
          ditto -c -k --keepParent Wowlet.app ../wowlet-macos-$(uname -m).zip
          ls -la ../wowlet-macos-*.zip

      - name: cleanup signing material
        if: always()
        run: |
          if [ -f /tmp/wowlet-ci-kcpw ]; then
            security delete-keychain /tmp/wowlet-ci.keychain-db || true
          fi
          rm -f /tmp/dev_id.p12 /tmp/notary.p8 /tmp/wowlet-ci-kcpw /tmp/wowlet-notarize.zip

      - name: upload artifact
        uses: actions/upload-artifact@v3
        with:
          name: wowlet-macos
          path: build/wowlet-macos-*.zip
          retention-days: 14