microhx/build-static.sh

#!/bin/bash
# MicroHX Static Build Script
#
# This script builds a fully static binary for Linux using musl or zig.
#
# Usage:
#   ./build-static.sh              # Build with musl
#   ./build-static.sh --zig        # Build with zig (better glibc compatibility)
#   ./build-static.sh --help       # Show help

set -e

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

# Colors for output
RED='\033[0;31m'
GREEN='\033[0;32m'
YELLOW='\033[1;33m'
NC='\033[0m' # No Color

log_info() {
    echo -e "${GREEN}[INFO]${NC} $1"
}

log_warn() {
    echo -e "${YELLOW}[WARN]${NC} $1"
}

log_error() {
    echo -e "${RED}[ERROR]${NC} $1"
}

show_help() {
    cat << EOF
MicroHX Static Build Script

Usage:
  $0 [OPTIONS]

Options:
  --zig           Use zig for building (better glibc compatibility)
  --target ARCH   Target architecture (default: x86_64)
  --release       Build in release mode (default)
  --debug         Build in debug mode
  --help          Show this help message

Examples:
  $0                          # Build release with musl
  $0 --zig                    # Build release with zig
  $0 --target aarch64 --zig   # Build for ARM64 with zig
  $0 --debug                  # Build debug version

EOF
}

# Default values
USE_ZIG=false
TARGET_ARCH="x86_64"
BUILD_MODE="release"
FEATURES="cli"

# Parse arguments
while [[ $# -gt 0 ]]; do
    case $1 in
        --zig)
            USE_ZIG=true
            shift
            ;;
        --target)
            TARGET_ARCH="$2"
            shift 2
            ;;
        --release)
            BUILD_MODE="release"
            shift
            ;;
        --debug)
            BUILD_MODE="debug"
            shift
            ;;
        --help)
            show_help
            exit 0
            ;;
        *)
            log_error "Unknown option: $1"
            show_help
            exit 1
            ;;
    esac
done

# Determine target triple
case $TARGET_ARCH in
    x86_64)
        TARGET="x86_64-unknown-linux-musl"
        ;;
    aarch64|arm64)
        TARGET="aarch64-unknown-linux-musl"
        ;;
    i686|x86)
        TARGET="i686-unknown-linux-musl"
        ;;
    *)
        log_error "Unsupported architecture: $TARGET_ARCH"
        exit 1
        ;;
esac

log_info "Building MicroHX static binary"
log_info "Target: $TARGET"
log_info "Mode: $BUILD_MODE"

if [ "$USE_ZIG" = true ]; then
    log_info "Using zig for building"
    
    # Check if cargo-zigbuild is installed
    if ! command -v cargo-zigbuild &> /dev/null; then
        log_warn "cargo-zigbuild not found, installing..."
        cargo install cargo-zigbuild
    fi
    
    # Determine zig target for glibc 2.17 compatibility
    case $TARGET_ARCH in
        x86_64)
            ZIG_TARGET="x86_64-linux-gnu.2.17"
            ;;
        aarch64)
            ZIG_TARGET="aarch64-linux-gnu.2.17"
            ;;
        *)
            ZIG_TARGET="$TARGET_ARCH-linux-gnu.2.17"
            ;;
    esac
    
    log_info "Zig target: $ZIG_TARGET"
    
    if [ "$BUILD_MODE" = "release" ]; then
        cargo zigbuild --release --target "$TARGET" --features "$FEATURES"
        BINARY_PATH="target/$TARGET/release/microhx"
    else
        cargo zigbuild --target "$TARGET" --features "$FEATURES"
        BINARY_PATH="target/$TARGET/debug/microhx"
    fi
else
    # Using musl
    log_info "Using musl for building"
    
    # Check if musl target is installed
    if ! rustup target list --installed | grep -q "$TARGET"; then
        log_warn "Target $TARGET not installed, installing..."
        rustup target add "$TARGET"
    fi
    
    if [ "$BUILD_MODE" = "release" ]; then
        cargo build --release --target "$TARGET" --features "$FEATURES"
        BINARY_PATH="target/$TARGET/release/microhx"
    else
        cargo build --target "$TARGET" --features "$FEATURES"
        BINARY_PATH="target/$TARGET/debug/microhx"
    fi
fi

# Verify the binary
if [ -f "$BINARY_PATH" ]; then
    log_info "Build successful!"
    log_info "Binary: $BINARY_PATH"
    
    # Show binary info
    if command -v file &> /dev/null; then
        log_info "Binary info:"
        file "$BINARY_PATH"
    fi
    
    if command -v ldd &> /dev/null; then
        log_info "Dynamic dependencies (should be 'not a dynamic executable' or minimal):"
        ldd "$BINARY_PATH" 2>&1 || true
    fi
    
    log_info "To run: $BINARY_PATH"
else
    log_error "Build failed - binary not found at $BINARY_PATH"
    exit 1
fi