omarchy-pkgs/bin/build

#!/bin/bash

# Abort if anything fails
set -e

# Source common functions
BUILD_ROOT=$(realpath "${BASH_SOURCE[0]%/*}/..")
source "$BUILD_ROOT/lib/message-helpers.sh"

ARCH=${ARCH:-x86_64}

ARCH_DIR="$BUILD_ROOT/output/$ARCH"
SRC_DIR="$BUILD_ROOT/src"
BUILD_DIR="$BUILD_ROOT/build"

# Create directories if they don't exist
mkdir -p "$ARCH_DIR" "$SRC_DIR"

# Check for Docker
if ! command -v docker &>/dev/null; then
  print_error "Docker is not installed"
  exit 1
fi

# Check if Docker daemon is running
if ! docker info &>/dev/null; then
  print_error "Docker daemon is not running"
  print_warning "Start Docker with: sudo systemctl start docker"
  exit 1
fi

print_header "Omarchy AUR Package Builder"

# Parse command line arguments
while [[ $# -gt 0 ]]; do
  case $1 in
  --arch)
    ARCH="$2"
    shift 2
    ;;
  --skip-signing)
    SKIP_SIGNING=true
    shift
    ;;
  --package)
    SINGLE_PACKAGE="$2"
    shift 2
    ;;
  -h | --help)
    echo "Usage: $0 [OPTIONS]"
    echo ""
    echo "Options:"
    echo "  --arch <arch>        Target architecture (x86_64 or aarch64, default: x86_64)"
    echo "  --skip-signing       Build packages without GPG signing"
    echo "  --package <name>     Build only the specified package (with optional options)"
    echo "  -h, --help           Show this help message"
    echo ""
    echo "This script builds AUR packages from:"
    echo "  build/packages/omarchy-aur.packages"
    echo ""
    echo "Or build a single package with --package:"
    echo "  Package can be: AUR package, GitHub repo (owner/repo), or local PKGBUILD"
    echo "  Options can be appended after package name (skip-pgp, install, always-build, etc.)"
    echo ""
    echo "Examples:"
    echo "  $0 --skip-signing"
    echo "  $0 --arch aarch64"
    echo "  $0 --package yay"
    echo "  $0 --package \"elephant install\""
    echo "  $0 --package \"owner/repo skip-pgp\""
    echo ""
    exit 0
    ;;
  *)
    print_error "Unknown option: $1"
    exit 1
    ;;
  esac
done

# Show target architecture after parsing args
print_info "Target architecture: $ARCH"
print_info "Output directory: $ARCH_DIR"

# Check if AUR package list exists (only required if not building single package)
if [[ -z "$SINGLE_PACKAGE" ]]; then
  if [[ ! -f "$BUILD_DIR/packages/omarchy-aur.packages" ]]; then
    print_error "omarchy-aur.packages not found at $BUILD_DIR/packages/"
    exit 1
  fi
else
  print_info "Building single package: $SINGLE_PACKAGE"
fi

# Handle GPG signing setup
if [[ "$SKIP_SIGNING" == true ]]; then
  print_warning "Skipping GPG signing (--skip-signing flag set)"
  export SKIP_SIGNING=true
else
  # Get GPG key from 1Password or environment for signing
  if [[ -z "$GPG_PRIVATE_KEY" ]]; then
    print_info "Fetching GPG signing key from 1Password..."
    GPG_PRIVATE_KEY=$(op document get "Omarchy GPG Private Key" --account=omarchy.1password.com) || {
      print_error "Failed to fetch GPG key from 1Password or environment"
      exit 1
    }
  else
    print_info "Using existing GPG signing key from environment"
  fi
  export GPG_PRIVATE_KEY="$GPG_PRIVATE_KEY"

  # Get passphrase from 1Password or environment
  if [[ -z "$GPG_PASSPHRASE" ]]; then
    print_info "Fetching GPG key passphrase from 1Password..."
    GPG_PASSPHRASE=$(op item get "Omarchy GPG Private Key" --account=omarchy.1password.com --fields password --reveal) || {
      print_error "Failed to fetch GPG passphrase from 1Password or environment"
      exit 1
    }
  else
    print_info "Using existing GPG passphrase from environment"
  fi
  export GPG_PASSPHRASE
  print_success "GPG signing key and passphrase loaded"
fi

# Build/update the Docker image
print_info "Building Docker image..."
docker build -t omarchy-aur-builder:latest -f "$BUILD_DIR/Dockerfile" "$BUILD_DIR"

print_info "Running AUR package build..."

# Ensure output directory is writable by container user
# The container runs as 'builder' user, so we need to make output writable
if [ "$(id -u)" -eq 0 ]; then
  chmod -R 777 "$ARCH_DIR"
else
  sudo chown -R $(id -u):$(id -g) "$ARCH_DIR" 2>/dev/null || chmod -R 777 "$ARCH_DIR"
fi

# Build Docker arguments
DOCKER_ARGS=(
  --rm
  -e ARCH="$ARCH"
  -e SKIP_SIGNING
  -e GPG_PRIVATE_KEY
  -e GPG_PASSPHRASE
  -e SINGLE_PACKAGE="$SINGLE_PACKAGE"
  -v "$BUILD_ROOT/output:/output"
  -v "$BUILD_DIR:/build:ro"
  -v "$BUILD_ROOT/pkgbuilds:/pkgbuilds:ro"
)

# Use local pacman cache if you already have one on host to speed up repeat runs
if [ -d "/var/cache/pacman/pkg" ]; then
  DOCKER_ARGS+=(-v "/var/cache/pacman/pkg:/var/cache/pacman/pkg")
fi

# Run the builder with assembled args
docker run "${DOCKER_ARGS[@]}" omarchy-aur-builder:latest /build/build.sh

# Clear the GPG key and passphrase from environment
unset GPG_PRIVATE_KEY
unset GPG_PASSPHRASE

BUILD_RESULT=$?

# Summary
echo ""
if [[ $BUILD_RESULT -eq 0 ]]; then
  print_success "AUR build completed successfully!"
  echo ""
  print_info "Next steps:"
  echo "  1. Run ./bin/update-repo to update the repository"
  echo "  2. Commit and push changes"
else
  print_warning "Some AUR packages failed (see details above)"
  exit $BUILD_RESULT
fi