build.sh

#!/usr/bin/env bash
#
# MieruWebUI build script
#
# Usage:
#   ./build.sh            # build backend + frontend (release)
#   ./build.sh all        # same as default
#   ./build.sh prod       # production bundle → dist/prod/
#   ./build.sh backend    # Rust release build only
#   ./build.sh frontend   # Vue production build only
#   ./build.sh dev        # debug backend + frontend deps
#
# Requires bash (not plain sh):
#   ./build.sh prod
#   bash build.sh prod
#
if [ -z "${BASH_VERSION:-}" ]; then
  exec bash "$0" "$@"
fi

set -euo pipefail

ROOT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
BACKEND_DIR="${ROOT_DIR}/backend"
FRONTEND_DIR="${ROOT_DIR}/frontend"
OUT_DIR="${OUT_DIR:-${ROOT_DIR}/dist/prod}"

log()  { printf '\033[1;32m[build]\033[0m %s\n' "$*"; }
err()  { printf '\033[1;31m[build]\033[0m %s\n' "$*" >&2; }

usage() {
  cat <<EOF
Usage: ./build.sh [target]

Targets:
  all        Build frontend + backend (default, release, in-tree)
  prod       Production bundle: optimized build + package to dist/prod/
  docker     Build Docker image via docker compose
  backend    Build Rust backend only (cargo build --release)
  frontend   Build Vue frontend only (npm run build)
  dev        Debug backend build + install frontend deps

Environment:
  OUT_DIR    Output directory for prod bundle (default: dist/prod)

Examples:
  ./build.sh
  ./build.sh prod
  ./build.sh backend
  OUT_DIR=/opt/mieruwebui ./build.sh prod
EOF
}

need_cmd() {
  if ! command -v "$1" >/dev/null 2>&1; then
    err "Required command not found: $1"
    exit 1
  fi
}

load_rust_env() {
  if [[ -f "${HOME}/.cargo/env" ]]; then
    # shellcheck disable=SC1091
    source "${HOME}/.cargo/env"
  fi
}

build_frontend() {
  log "Building frontend (production)..."
  need_cmd npm
  cd "${FRONTEND_DIR}"

  if [[ -f package-lock.json ]]; then
    npm ci --no-audit --no-fund
  else
    npm install --no-audit --no-fund
  fi

  NODE_ENV=production npm run build
  log "Frontend ready: ${FRONTEND_DIR}/dist"
}

build_backend() {
  local profile="${1:-release}"

  log "Building backend (${profile})..."
  need_cmd cargo
  load_rust_env
  cd "${BACKEND_DIR}"

  if [[ "${profile}" == "release" ]]; then
    RUSTFLAGS="${RUSTFLAGS:--C strip=symbols}" cargo build --release
    log "Backend ready: ${BACKEND_DIR}/target/release/mieru-webui"
  else
    cargo build
    log "Backend ready: ${BACKEND_DIR}/target/debug/mieru-webui"
  fi
}

build_all() {
  build_frontend
  build_backend release
  log "Done. Run:"
  log "  cd backend && cargo run --release"
}

write_run_script() {
  local dest="$1"
  cat >"${dest}/run.sh" <<'EOF'
#!/usr/bin/env bash
set -euo pipefail
DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
cd "${DIR}/backend"
mkdir -p data
exec ./mieru-webui
EOF
  chmod +x "${dest}/run.sh"
}

write_prod_readme() {
  local dest="$1"
  cat >"${dest}/README.txt" <<EOF
MieruWebUI production bundle
Generated: $(date -u +"%Y-%m-%d %H:%M:%S UTC")

Layout:
  backend/mieru-webui   — server binary
  backend/data/         — SQLite database
  frontend/dist/        — web UI static files
  .env.example          — configuration template

Quick start:
  1. cp .env.example .env && nano .env
  2. ./run.sh

Or with systemd — see install.sh in source repository.
EOF
}

build_prod() {
  log "Production build → ${OUT_DIR}"

  build_frontend
  build_backend release

  log "Packaging..."
  rm -rf "${OUT_DIR}"
  mkdir -p "${OUT_DIR}/backend/data" "${OUT_DIR}/frontend/dist"

  cp "${BACKEND_DIR}/target/release/mieru-webui" "${OUT_DIR}/backend/mieru-webui"
  chmod +x "${OUT_DIR}/backend/mieru-webui"
  rsync -a "${FRONTEND_DIR}/dist/" "${OUT_DIR}/frontend/dist/"

  if [[ -f "${ROOT_DIR}/.env.example" ]]; then
    cp "${ROOT_DIR}/.env.example" "${OUT_DIR}/.env.example"
  fi

  write_run_script "${OUT_DIR}"
  write_prod_readme "${OUT_DIR}"

  # Record build info
  cat >"${OUT_DIR}/BUILD_INFO" <<EOF
built_at=$(date -u +"%Y-%m-%dT%H:%M:%SZ")
rustc=$(rustc --version 2>/dev/null || echo unknown)
node=$(node --version 2>/dev/null || echo unknown)
EOF

  log "Production bundle ready: ${OUT_DIR}"
  log "  Binary:  ${OUT_DIR}/backend/mieru-webui"
  log "  Static:  ${OUT_DIR}/frontend/dist"
  log "  Run:     cd ${OUT_DIR} && cp .env.example .env && ./run.sh"
}

build_dev() {
  need_cmd npm
  load_rust_env
  cd "${FRONTEND_DIR}"
  npm install --no-audit --no-fund
  cd "${BACKEND_DIR}"
  cargo build
  log "Dev build complete (debug backend + frontend deps)"
}

main() {
  local target="${1:-all}"

  case "${target}" in
    all)
      build_all
      ;;
    prod|production)
      build_prod
      ;;
    docker)
      need_cmd docker
      log "Building Docker image..."
      docker compose build
      log "Image ready. Run: docker compose up -d"
      ;;
    backend|back|rust)
      build_backend release
      ;;
    frontend|front|vue)
      build_frontend
      ;;
    dev)
      build_dev
      ;;
    -h|--help|help)
      usage
      ;;
    *)
      err "Unknown target: ${target}"
      echo
      usage
      exit 1
      ;;
  esac
}

main "$@"