build.sh

#!/usr/bin/env bash
#
# Usage:
#   ./build.sh                                # build everything, Release/ReleaseFast
#   ./build.sh --no-zig                       # skip bootstrap + injector build
#   ./build.sh --no-dotnet                    # skip Payload build
#   ./build.sh --zig-targets "x86_64-linux-gnu x86_64-windows-gnu"
#   CONFIG=Debug OPTIMIZE=Debug INJECTOR_OPTIMIZE=Debug ./build.sh

set -euo pipefail

cd "$(dirname "$(readlink -f "$0")")"

BIN_DIR="$PWD/bin"
PAYLOAD_CSPROJ="$PWD/Hauyne.Payload/Hauyne.Payload.csproj"

CONFIG="${CONFIG:-Release}"
OPTIMIZE="${OPTIMIZE:-ReleaseFast}"
INJECTOR_OPTIMIZE="${INJECTOR_OPTIMIZE:-ReleaseSmall}"

DEFAULT_ZIG_TARGETS=(
    x86_64-linux-gnu
    x86_64-linux-musl
    x86_64-windows-gnu
    aarch64-linux-gnu
    aarch64-linux-musl
)
ZIG_TARGETS=("${DEFAULT_ZIG_TARGETS[@]}")

DO_ZIG=1
DO_DOTNET=1

while [[ $# -gt 0 ]]; do
    case "$1" in
        --no-zig)      DO_ZIG=0; shift ;;
        --no-dotnet)   DO_DOTNET=0; shift ;;
        --zig-targets) read -ra ZIG_TARGETS <<<"$2"; shift 2 ;;
        -h|--help)     sed -n '2,9p' "$0"; exit 0 ;;
        *)             echo "unknown arg: $1" >&2; exit 2 ;;
    esac
done

check_tool() {
    local name="$1" cmd="$2" version_cmd="$3"
    if ! command -v "$cmd" >/dev/null 2>&1; then
        echo "missing: $name ($cmd not in PATH)" >&2
        return 1
    fi
    printf '  %-8s %s\n' "$name" "$($version_cmd 2>&1 | head -n1)"
}

missing=0
(( DO_ZIG ))    && { check_tool zig    zig    "zig version"      || missing=1; }
(( DO_DOTNET )) && { check_tool dotnet dotnet "dotnet --version" || missing=1; }
(( missing )) && exit 1

echo "  CONFIG=$CONFIG   OPTIMIZE=$OPTIMIZE   INJECTOR_OPTIMIZE=$INJECTOR_OPTIMIZE"
(( DO_ZIG )) && echo "  ZIG_TARGETS=${ZIG_TARGETS[*]}"

bootstrap_artifact_for() {
    case "$1" in
        *windows*) echo "Hauyne.Bootstrap.dll" ;;
        *)         echo "libHauyne.Bootstrap.so" ;;
    esac
}

injector_artifact_for() {
    case "$1" in
        *windows*) echo "Hauyne.Injector.exe" ;;
        *)         echo "Hauyne.Injector" ;;
    esac
}

build_zig() {
    for target in "${ZIG_TARGETS[@]}"; do
        echo "==> zig $target (bootstrap=$OPTIMIZE, injector=$INJECTOR_OPTIMIZE)"
        zig build \
            -Dtarget="$target" \
            -Doptimize="$OPTIMIZE" \
            -Dinjector-optimize="$INJECTOR_OPTIMIZE" \
            --prefix "$BIN_DIR/$target"
    done

    link_canonical() {
        local target="$1"
        [[ " ${ZIG_TARGETS[*]} " == *" $target "* ]] || return 0

        local bs_artifact inj_artifact
        bs_artifact="$(bootstrap_artifact_for "$target")"
        inj_artifact="$(injector_artifact_for "$target")"

        ln -sfn "$target/$bs_artifact"  "$BIN_DIR/$bs_artifact"
        ln -sfn "$target/$inj_artifact" "$BIN_DIR/$inj_artifact"
    }
    link_canonical x86_64-linux-gnu
    link_canonical x86_64-windows-gnu
    link_canonical aarch64-linux-gnu
}

build_dotnet() {
    echo "==> dotnet build Hauyne.Payload ($CONFIG)"
    dotnet build "$PAYLOAD_CSPROJ" -c "$CONFIG" --nologo
}

payload() {
    (( DO_ZIG )) || return 0
    local payload=""
    for tfm in net10.0 net9.0; do
        if [[ -f "$BIN_DIR/$tfm/Hauyne.Payload.dll" ]]; then
            payload="$tfm/Hauyne.Payload.dll"
            break
        fi
    done
    [[ -n "$payload" ]] || return 0
    for target in "${ZIG_TARGETS[@]}"; do
        local dest="$BIN_DIR/$target"
        [[ -d "$dest" ]] || continue
        ln -sfn "../$payload" "$dest/Hauyne.Payload.dll"
    done
}

(( DO_ZIG ))    && build_zig
(( DO_DOTNET )) && build_dotnet
payload

find "$BIN_DIR" -maxdepth 2 -type f \
    \( -name '*.dll' -o -name '*.so' -o -name 'Hauyne.Injector' -o -name '*.exe' \) \
    -printf '  %p\n' 2>/dev/null | sort
find "$BIN_DIR" -maxdepth 1 -type l -printf '  %p -> %l\n' 2>/dev/null | sort