build.sh

#!/usr/bin/env bash
set -euo pipefail

# Build PC executable from Linux/macOS/Windows.
# - Provisions ONNX Runtime package (headers + libs)
# - Then builds src/main.cpp -> build/openwakeword(.exe)
#
# Usage:
#   ./build.sh [--onnxruntime 1.23.2]

SCRIPT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
cd "$SCRIPT_DIR"
PARENT_DIR="$(cd "$SCRIPT_DIR/.." && pwd)"

ORT_VERSION_DEFAULT="1.23.2"
ORT_VERSION="$ORT_VERSION_DEFAULT"

install_host_tool_if_missing() {
    local cmd="$1"
    local apt_pkg="$2"
    local dnf_pkg="$3"
    local yum_pkg="$4"
    local pacman_pkg="$5"
    local brew_pkg="$6"
    local winget_id="$7"
    local choco_pkg="$8"

    if command -v "$cmd" >/dev/null 2>&1; then
        return 0
    fi

    echo "[build] (setup) missing tool: $cmd"

    case "$(uname -s)" in
        Linux*)
            if command -v apt-get >/dev/null 2>&1; then
                if command -v sudo >/dev/null 2>&1; then
                    sudo apt-get update || true
                    sudo apt-get install -y "$apt_pkg" || true
                else
                    apt-get update || true
                    apt-get install -y "$apt_pkg" || true
                fi
            elif command -v dnf >/dev/null 2>&1; then
                if command -v sudo >/dev/null 2>&1; then
                    sudo dnf install -y "$dnf_pkg" || true
                else
                    dnf install -y "$dnf_pkg" || true
                fi
            elif command -v yum >/dev/null 2>&1; then
                if command -v sudo >/dev/null 2>&1; then
                    sudo yum install -y "$yum_pkg" || true
                else
                    yum install -y "$yum_pkg" || true
                fi
            elif command -v pacman >/dev/null 2>&1; then
                if command -v sudo >/dev/null 2>&1; then
                    sudo pacman -Sy --noconfirm "$pacman_pkg" || true
                else
                    pacman -Sy --noconfirm "$pacman_pkg" || true
                fi
            fi
            ;;
        Darwin*)
            if command -v brew >/dev/null 2>&1; then
                brew install "$brew_pkg" || true
            fi
            ;;
        MINGW*|MSYS*|CYGWIN*)
            if command -v winget >/dev/null 2>&1 && [[ -n "$winget_id" ]]; then
                winget install -e --id "$winget_id" --accept-package-agreements --accept-source-agreements || true
            elif command -v choco >/dev/null 2>&1 && [[ -n "$choco_pkg" ]]; then
                choco install -y "$choco_pkg" || true
            fi
            ;;
    esac

    if ! command -v "$cmd" >/dev/null 2>&1; then
        echo "[build] [ERROR] Required tool still missing after auto-install attempt: $cmd" >&2
        exit 2
    fi
}

usage() {
    cat <<EOF
Usage: $(basename "$0") [--onnxruntime <version>]

Examples:
  $(basename "$0")
  $(basename "$0") --onnxruntime 1.23.2
EOF
}

while [[ $# -gt 0 ]]; do
    case "$1" in
        -h|--help)
            usage
            exit 0
            ;;
        --onnxruntime)
            shift
            [[ $# -gt 0 ]] || { echo "[build] Missing value for --onnxruntime" >&2; exit 2; }
            ORT_VERSION="$1"
            shift
            ;;
        *)
            echo "[build] Unknown argument: $1" >&2
            usage
            exit 2
            ;;
    esac
done

OS_RAW="$(uname -s)"
ARCH_RAW="$(uname -m)"

OS=""
ORT_OS=""
ARCH=""
EXT=""

case "$OS_RAW" in
    Linux*)
        OS="linux"
        ORT_OS="linux"
        EXT="tgz"
        ;;
    Darwin*)
        OS="macos"
        ORT_OS="osx"
        EXT="tgz"
        ;;
    MINGW*|MSYS*|CYGWIN*)
        OS="windows"
        ORT_OS="win"
        EXT="zip"
        ;;
    *)
        echo "[build] [ERROR] Unsupported OS: $OS_RAW" >&2
        exit 2
        ;;
esac

case "$ARCH_RAW" in
    x86_64|amd64)
        ARCH="x64"
        ;;
    aarch64|arm64)
        ARCH="arm64"
        ;;
    *)
        echo "[build] [ERROR] Unsupported CPU architecture: $ARCH_RAW" >&2
        exit 2
        ;;
esac

install_host_tool_if_missing curl curl curl curl curl curl cURL curl
if [[ "$EXT" == "tgz" ]]; then
    install_host_tool_if_missing tar tar tar tar tar gnu-tar "" ""
else
    install_host_tool_if_missing unzip unzip unzip unzip unzip unzip "" unzip
fi

if [[ "$OS" != "windows" ]]; then
    install_host_tool_if_missing g++ g++ gcc-c++ gcc-c++ gcc gcc "" mingw
fi

ORT_PACKAGE="onnxruntime-${ORT_OS}-${ARCH}-${ORT_VERSION}"
ORT_URL="https://github.com/microsoft/onnxruntime/releases/download/v${ORT_VERSION}/${ORT_PACKAGE}.${EXT}"
TARGET_ID="${OS}-${ARCH}"

ORT_ROOT="$PARENT_DIR/onnxruntime-pc"
ORT_VER_DIR="$ORT_ROOT/$ORT_VERSION/$TARGET_ID"
ORT_INCLUDE_DIR="$ORT_VER_DIR/include"
ORT_LIB_DIR="$ORT_VER_DIR/lib"

CACHE_DIR="$PARENT_DIR/.cache/onnxruntime-pc/${ORT_VERSION}"
CACHED_ARCHIVE="$CACHE_DIR/${ORT_PACKAGE}.${EXT}"

mkdir -p "$CACHE_DIR" "$ORT_INCLUDE_DIR" "$ORT_LIB_DIR"

have_headers=0
[[ -f "$ORT_INCLUDE_DIR/onnxruntime_cxx_api.h" ]] && have_headers=1

have_libs=0
case "$OS" in
    linux)
        [[ -f "$ORT_LIB_DIR/libonnxruntime.so" ]] && have_libs=1
        ;;
    macos)
        [[ -f "$ORT_LIB_DIR/libonnxruntime.dylib" ]] && have_libs=1
        ;;
    windows)
        [[ -f "$ORT_LIB_DIR/onnxruntime.lib" && -f "$ORT_LIB_DIR/onnxruntime.dll" ]] && have_libs=1
        ;;
esac

if [[ "$have_headers" -ne 1 || "$have_libs" -ne 1 ]]; then
    echo "[build] Provisioning ONNX Runtime v${ORT_VERSION} for ${OS}/${ARCH}"

    if [[ ! -s "$CACHED_ARCHIVE" ]]; then
        echo "[build] Downloading: $ORT_URL"
        curl -fL --retry 3 --retry-delay 1 -o "$CACHED_ARCHIVE" "$ORT_URL"
    else
        echo "[build] Using cached archive: $CACHED_ARCHIVE"
    fi

    tmp_dir="$(mktemp -d)"
    cleanup_tmp() {
        rm -rf "$tmp_dir"
    }
    trap cleanup_tmp EXIT

    case "$EXT" in
        tgz)
            tar -xzf "$CACHED_ARCHIVE" -C "$tmp_dir"
            ;;
        zip)
            unzip -q "$CACHED_ARCHIVE" -d "$tmp_dir"
            ;;
    esac

    extracted_dir="$tmp_dir/$ORT_PACKAGE"
    if [[ ! -d "$extracted_dir" ]]; then
        echo "[build] [ERROR] Extracted package directory not found: $extracted_dir" >&2
        exit 2
    fi

    if [[ ! -d "$extracted_dir/include" || ! -d "$extracted_dir/lib" ]]; then
        echo "[build] [ERROR] ONNX Runtime package missing include/ or lib/." >&2
        exit 2
    fi

    rm -rf "$ORT_INCLUDE_DIR" "$ORT_LIB_DIR"
    mkdir -p "$ORT_INCLUDE_DIR" "$ORT_LIB_DIR"

    cp -a "$extracted_dir/include/." "$ORT_INCLUDE_DIR/"

    case "$OS" in
        linux)
            cp -a "$extracted_dir/lib/libonnxruntime.so"* "$ORT_LIB_DIR/"
            ;;
        macos)
            cp -a "$extracted_dir/lib/libonnxruntime"*.dylib "$ORT_LIB_DIR/"
            ;;
        windows)
            cp -a "$extracted_dir/lib/onnxruntime.lib" "$ORT_LIB_DIR/"
            cp -a "$extracted_dir/lib/onnxruntime.dll" "$ORT_LIB_DIR/"
            if [[ -f "$extracted_dir/lib/libonnxruntime.dll.a" ]]; then
                cp -a "$extracted_dir/lib/libonnxruntime.dll.a" "$ORT_LIB_DIR/"
            fi
            ;;
    esac

    trap - EXIT
    cleanup_tmp
else
    echo "[build] ONNX Runtime already present: $ORT_VER_DIR"
fi

rm -rf "$PARENT_DIR/.cache"

BUILD_DIR="$PARENT_DIR/build-pc/$TARGET_ID"
mkdir -p "$BUILD_DIR"
MARKER_FILE="$BUILD_DIR/onnxruntime-version"

SRC_FILE="$SCRIPT_DIR/src/main.cpp"
OUT_FILE="$BUILD_DIR/openwakeword"

if [[ "$OS" == "windows" ]]; then
    OUT_FILE="${OUT_FILE}.exe"
fi

if [[ "$OS" == "windows" ]]; then
    to_win_path() {
        local p="$1"
        if command -v cygpath >/dev/null 2>&1; then
            cygpath -w "$p"
        else
            printf '%s\n' "$p"
        fi
    }

    if command -v cl.exe >/dev/null 2>&1; then
        echo "[build] Building with cl.exe -> $OUT_FILE"

        SRC_WIN="$(to_win_path "$SRC_FILE")"
        INC_WIN="$(to_win_path "$ORT_INCLUDE_DIR")"
        LIB_WIN="$(to_win_path "$ORT_LIB_DIR")"
        OUT_WIN="$(to_win_path "$OUT_FILE")"

        cl.exe /nologo /std:c++20 /EHsc /O2 /W4 /I"$INC_WIN" "$SRC_WIN" /link /LIBPATH:"$LIB_WIN" onnxruntime.lib /OUT:"$OUT_WIN"
    elif command -v g++ >/dev/null 2>&1 && [[ -f "$ORT_LIB_DIR/libonnxruntime.dll.a" ]]; then
        echo "[build] Building with g++ -> $OUT_FILE"
        g++ -o "$OUT_FILE" \
            -I"$ORT_INCLUDE_DIR" \
            -L"$ORT_LIB_DIR" \
            -O2 -std=c++20 -Wall -Wextra \
            "$SRC_FILE" \
            -lpthread -lonnxruntime
    else
        echo "[build] [ERROR] On Windows, use Visual Studio Developer shell (cl.exe), or provide MinGW import lib libonnxruntime.dll.a." >&2
        exit 2
    fi

else
    CXX="${CXX:-g++}"
    if ! command -v "$CXX" >/dev/null 2>&1; then
        echo "[build] [ERROR] Compiler not found: $CXX" >&2
        exit 2
    fi

    RPATH_FLAG="-Wl,-rpath,$ORT_LIB_DIR"
    if [[ "$OS" == "macos" ]]; then
        RPATH_FLAG="-Wl,-rpath,$ORT_LIB_DIR"
    fi

    echo "[build] Building with $CXX -> $OUT_FILE"
    "$CXX" -o "$OUT_FILE" \
        -I"$ORT_INCLUDE_DIR" \
        -L"$ORT_LIB_DIR" \
        -O2 -std=c++20 -Wall -Wextra \
        "$RPATH_FLAG" \
        "$SRC_FILE" \
        -lpthread -lonnxruntime

fi

printf '%s\n' "$ORT_VERSION" > "$MARKER_FILE"

echo "[build] Done: $OUT_FILE"
echo "[build] Marker: $MARKER_FILE ($ORT_VERSION)"