sbox-build

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

LOCAL_IMAGE="sbox-win-docker"
REMOTE_IMAGE="ghcr.io/vincetheprogrammer/sbox-win-docker:main"
REPO_URL="https://github.com/vinceTheProgrammer/sbox-win-docker"
INSTALL_DOCS_URL="https://docs.docker.com/engine/install/"

DEFAULT_SRC_DIR="$HOME/.local/share/sbox-win-docker"

NO_PROMPT=0
FORCE_PULL=0
FORCE_REBUILD=0
DO_UPDATE=0
SRC_DIR="$DEFAULT_SRC_DIR"
DROP_SHELL=0
REPO_ROOT_NAME_OVERRIDE=""

usage() {
  cat <<EOF
Usage: sbox-build [options]

Wrapper Options:
  --pull                Force pull the prebuilt image (even if local image exists)
  --rebuild             Force rebuild the image locally (uses local repo clone)
  --update              When rebuilding, git pull before building
  --src-dir <dir>       Override local repo directory (default: $DEFAULT_SRC_DIR)
  --repo-root-name <n>  Override detected repo root name (bypasses 'sbox-public' check)
  --no-prompt           Never prompt; fail if user interaction would be required
  --shell               Drop into an interactive bash shell inside the container           
  -h, --help            Show this help message

Build Options:
  --enable-codegen-patch  Make future builds faster. Patches CodeGen.Targets before builds. Creates .sboxbuild_codegen_patch (experimental)
  --enable-hash-cache     Make change based building not rely on git commits. Creates .sboxbuild_cache (recommended)
  --full                  Force full build
  --no-auto-full          Disable auto full-build detection for fresh clones
  --test                  Run tests after build
  --format                Format the project

Examples:
  sbox-build
  sbox-build --pull
  sbox-build --rebuild
  sbox-build --enable-codegen-patch --enable-hash-cache
  sbox-build --full --test --format
EOF
}

DOCKER_ARGS=()

# -----------------------------
# Parse args
# -----------------------------

while [[ $# -gt 0 ]]; do
  case "$1" in
    --pull)
      FORCE_PULL=1
      shift
      ;;
    --rebuild)
      FORCE_REBUILD=1
      shift
      ;;
    --update)
      DO_UPDATE=1
      shift
      ;;
    --src-dir)
      shift
      if [[ $# -eq 0 ]]; then
        echo "ERROR: --src-dir requires a path"
        exit 1
      fi
      SRC_DIR="${1/#\~/$HOME}"
      shift
      ;;
    --repo-root-name=*)
      REPO_ROOT_NAME_OVERRIDE="${1#--repo-root-name=}"
      shift
      ;;
    --repo-root-name)
      shift
      if [[ $# -eq 0 ]]; then
        echo "ERROR: --repo-root-name requires a value"
        exit 1
      fi
      REPO_ROOT_NAME_OVERRIDE="$1"
      shift
      ;;
    --no-prompt)
      NO_PROMPT=1
      shift
      ;;
    --shell)
      DROP_SHELL=1
      shift
      ;;
    -h|--help)
      usage
      exit 0
      ;;
    --)
      shift
      DOCKER_ARGS+=("$@")
      break
      ;;
    *)
      DOCKER_ARGS+=("$1")
      shift
      ;;
  esac
done

if [[ "$FORCE_PULL" -eq 1 && "$FORCE_REBUILD" -eq 1 ]]; then
  echo "ERROR: Cannot use --pull and --rebuild at the same time."
  exit 1
fi

# -----------------------------
# Prompt helpers
# -----------------------------

prompt_yes_no() {
  local prompt="$1"
  local default="${2:-Y}"

  if [[ "$NO_PROMPT" -eq 1 ]]; then
    echo "ERROR: --no-prompt set, but script needs input: $prompt"
    exit 1
  fi

  local answer=""
  read -rp "$prompt" answer
  answer="${answer:-$default}"

  if [[ "$answer" == "y" || "$answer" == "Y" ]]; then
    return 0
  fi

  return 1
}

choose_src_dir_prompt() {
  if [[ "$NO_PROMPT" -eq 1 ]]; then
    return 0
  fi

  read -e -p "Repo location: " -i "$DEFAULT_SRC_DIR" SRC_DIR
  SRC_DIR="${SRC_DIR/#\~/$HOME}"
}

# -----------------------------
# Docker sanity checks / setup
# -----------------------------

if ! command -v docker >/dev/null 2>&1; then
  echo "ERROR: Docker is not installed."
  echo "Install Docker here:"
  echo "$INSTALL_DOCS_URL"
  exit 1
fi

# Ensure docker group exists
if ! getent group docker >/dev/null 2>&1; then
  echo "Docker group does not exist."

  if ! prompt_yes_no "Create the docker group now? (Y/n): " "Y"; then
    echo "ERROR: Docker group is required to continue."
    exit 1
  fi

  sudo groupadd docker
fi

# Ensure user is in docker group
if ! id -nG "$USER" | tr ' ' '\n' | grep -qx docker; then
  echo "User '$USER' is not in the docker group."

  if ! prompt_yes_no "Add '$USER' to the docker group now? (Y/n): " "Y"; then
    echo "ERROR: You must be in the docker group to continue."
    exit 1
  fi

  sudo usermod -aG docker "$USER"

  echo
  echo "SUCCESS: Added '$USER' to docker group."
  echo "You must log out and log back in (or reboot) for this to take effect."
  echo "Then re-run: sbox-build"
  exit 0
fi

# Now that permissions should be correct, check if docker daemon is running
if ! docker info >/dev/null 2>&1; then
  echo "Docker is installed, but the Docker daemon doesn't seem to be running."

  if ! prompt_yes_no "Start Docker now? (Y/n): " "Y"; then
    echo "ERROR: Docker must be running to continue."
    exit 1
  fi

  if command -v systemctl >/dev/null 2>&1; then
    sudo systemctl start docker
  elif command -v service >/dev/null 2>&1; then
    sudo service docker start
  else
    echo "ERROR: Couldn't detect systemctl or service manager to start Docker."
    echo "Please start Docker manually, then re-run this script."
    exit 1
  fi

  docker info >/dev/null 2>&1 || {
    echo "ERROR: Docker still isn't running after attempting to start it."
    exit 1
  }
fi

# -----------------------------
# Image handling
# -----------------------------

pull_image() {
  echo "Pulling: $REMOTE_IMAGE"
  docker pull "$REMOTE_IMAGE"

  echo "Tagging as: $LOCAL_IMAGE"
  docker tag "$REMOTE_IMAGE" "$LOCAL_IMAGE"
}

is_valid_sbox_win_docker_repo() {
  if [[ ! -d "$SRC_DIR/.git" ]]; then
    return 1
  fi

  # Must contain expected project files
  if [[ ! -f "$SRC_DIR/Dockerfile" || ! -f "$SRC_DIR/sbox-build" ]]; then
    return 1
  fi

  # Must have correct origin remote
  local origin_url=""
  origin_url="$(git -C "$SRC_DIR" remote get-url origin 2>/dev/null || true)"

  if [[ "$origin_url" != *"vinceTheProgrammer/sbox-win-docker"* ]]; then
    return 1
  fi

  return 0
}

ensure_repo_exists() {
  if [[ -d "$SRC_DIR" ]]; then
    if is_valid_sbox_win_docker_repo; then
      return 0
    fi

    echo "ERROR: '$SRC_DIR' exists but does not appear to be the sbox-win-docker repo."
    echo "Refusing to use it (prevents accidentally building unrelated Dockerfiles)."
    echo
    echo "Expected:"
    echo "  - Dockerfile"
    echo "  - sbox-build"
    echo "  - origin remote containing: vinceTheProgrammer/sbox-win-docker"
    echo
    echo "Fix options:"
    echo "  - choose another directory with --src-dir"
    echo "  - delete '$SRC_DIR' and re-run"
    exit 1
  fi

  echo "Local build repo not found at: $SRC_DIR"

  if [[ "$NO_PROMPT" -eq 1 ]]; then
    echo "ERROR: --no-prompt set, cannot clone automatically."
    echo "Clone manually with:"
    echo "  git clone $REPO_URL $SRC_DIR"
    exit 1
  fi

  if ! prompt_yes_no "Clone sbox-win-docker repo into '$SRC_DIR'? (Y/n): " "Y"; then
    echo "ERROR: Cannot rebuild without a local repo."
    exit 1
  fi

  mkdir -p "$(dirname "$SRC_DIR")"
  git clone "$REPO_URL" "$SRC_DIR"
}

build_image() {
  if ! command -v git >/dev/null 2>&1; then
    echo "ERROR: git is required to build locally but is not installed."
    exit 1
  fi

  ensure_repo_exists

  (
    cd "$SRC_DIR"

    if [[ "$DO_UPDATE" -eq 1 ]]; then
      echo "Updating repo (git pull)..."
      git pull
    fi

    echo "Building docker image '$LOCAL_IMAGE' from: $SRC_DIR"
    docker build -t "$LOCAL_IMAGE" .
  )
}

IMAGE_EXISTS=0
if docker image inspect "$LOCAL_IMAGE" >/dev/null 2>&1; then
  IMAGE_EXISTS=1
fi

# If rebuilding and user didn't specify --src-dir explicitly, allow changing location
if [[ "$FORCE_REBUILD" -eq 1 && "$SRC_DIR" == "$DEFAULT_SRC_DIR" ]]; then
  choose_src_dir_prompt
fi

if [[ "$FORCE_PULL" -eq 1 ]]; then
  pull_image

elif [[ "$FORCE_REBUILD" -eq 1 ]]; then
  build_image

elif [[ "$IMAGE_EXISTS" -eq 0 ]]; then
  echo "Docker image '$LOCAL_IMAGE' is not present."
  echo
  echo "Recommended: Pull the prebuilt image (fastest)."
  echo "Alternative: Build locally (for dev / customization)."
  echo

  if prompt_yes_no "Pull prebuilt image from Docker Hub? (Y/n): " "Y"; then
    pull_image
  else
    choose_src_dir_prompt
    build_image
  fi
fi

# ----------------------------------------
# Strict check: must be inside sbox-public (or override)
# ----------------------------------------

REPO_ROOT="$(git rev-parse --show-toplevel 2>/dev/null || true)"

if [[ -z "$REPO_ROOT" ]]; then
  echo "ERROR: You must run this script from inside a git repository."
  echo "Current dir: $(pwd)"
  exit 1
fi

# Use override name if provided, otherwise use actual basename
if [[ -n "$REPO_ROOT_NAME_OVERRIDE" ]]; then
  REPO_ROOT_NAME="$REPO_ROOT_NAME_OVERRIDE"
else
  REPO_ROOT_NAME="$(basename "$REPO_ROOT")"
fi

# Only validate against 'sbox-public' if no override was provided
if [[ -z "$REPO_ROOT_NAME_OVERRIDE" && "$REPO_ROOT_NAME" != "sbox-public" ]]; then
  echo "ERROR: Refusing to run: git repo top-level folder is not named 'sbox-public'."
  echo "Found repo root: $REPO_ROOT (detected name: $REPO_ROOT_NAME)"
  echo "Current dir: $(pwd)"
  exit 1
fi

if [[ "$PWD" != "$REPO_ROOT"* ]]; then
  echo "ERROR: Current directory is not inside the detected repo root."
  exit 1
fi

echo "Starting s&box build in repo: $REPO_ROOT (name override: ${REPO_ROOT_NAME_OVERRIDE:-none})"

if [[ "$DROP_SHELL" -eq 1 ]]; then
  echo "Launching interactive bash shell inside container..."
  docker run --rm -it \
    -v "$PWD:/root/sbox:z" \
    -v "$HOME/.cache/sbox-nuget":/root/.wine64/drive_c/users/root/.nuget:z \
    -e HOST_UID="$(id -u)" \
    -e HOST_GID="$(id -g)" \
    --entrypoint bash \
    "$LOCAL_IMAGE"
else
  docker run --rm -it \
    -v "$PWD:/root/sbox:z" \
    -v "$HOME/.cache/sbox-nuget":/root/.wine64/drive_c/users/root/.nuget:z \
    -e HOST_UID="$(id -u)" \
    -e HOST_GID="$(id -g)" \
    -e NO_PROMPT="$NO_PROMPT" \
    "$LOCAL_IMAGE" "${DOCKER_ARGS[@]}"
fi