local bytes="${1:-0}"

if [[ ! "$bytes" =~ ^[0-9]+$ ]]; then

printf '%s\n' "$bytes"

return 0

fi

local units=("B" "KB" "MB" "GB" "TB")

local value="$bytes"

local unit_index=0

while (( value >= 1024 && unit_index < ${#units[@]} - 1 )); do

value=$((value / 1024))

((unit_index += 1))

done

printf '%s%s\n' "$value" "${units[$unit_index]}"

local path="$1"

local available_kb=""

available_kb=$(df -Pk "$path" 2>/dev/null | awk 'NR==2 {print $4}')

if [[ ! "$available_kb" =~ ^[0-9]+$ ]]; then

return 1

fi

printf '%s\n' $((available_kb * 1024))

local path="$1"

local filesystem=""

filesystem=$(df -Pk "$path" 2>/dev/null | awk 'NR==2 {print $1}')

if [[ -z "$filesystem" ]]; then

return 1

fi

printf '%s\n' "$filesystem"

local temp_path="${1:-/tmp}"

local install_path="${2:-$INSTALL_DIR}"

local temp_fs=""

local install_fs=""

local temp_free_bytes=""

local install_free_bytes=""

local combined_required_bytes=$((UPDATE_MIN_TEMP_FREE_BYTES + UPDATE_MIN_INSTALL_FREE_BYTES))

temp_fs=$(get_filesystem_device_for_path "$temp_path" 2>/dev/null || true)

install_fs=$(get_filesystem_device_for_path "$install_path" 2>/dev/null || true)

temp_free_bytes=$(get_available_bytes_for_path "$temp_path" 2>/dev/null || true)

install_free_bytes=$(get_available_bytes_for_path "$install_path" 2>/dev/null || true)

if [[ -z "$temp_free_bytes" || -z "$install_free_bytes" ]]; then

print_warn "Could not determine available disk space for the update preflight; continuing anyway"

return 0

fi

if [[ -n "$temp_fs" && "$temp_fs" == "$install_fs" ]]; then

if (( temp_free_bytes < combined_required_bytes )); then

print_error "Not enough free disk space to stage the Pulse update"

print_info "The same filesystem backs $temp_path and $install_path"

print_info "Available: $(bytes_to_human "$temp_free_bytes"), required: $(bytes_to_human "$combined_required_bytes")"

print_info "Free disk space and retry the update"

return 1

fi

return 0

fi

if (( temp_free_bytes < UPDATE_MIN_TEMP_FREE_BYTES )); then

print_error "Not enough free disk space in $temp_path to stage the Pulse update"

print_info "Available: $(bytes_to_human "$temp_free_bytes"), required: $(bytes_to_human "$UPDATE_MIN_TEMP_FREE_BYTES")"

print_info "Free disk space under $temp_path and retry the update"

return 1

fi

if (( install_free_bytes < UPDATE_MIN_INSTALL_FREE_BYTES )); then

print_error "Not enough free disk space in $install_path to apply the Pulse update"

print_info "Available: $(bytes_to_human "$install_free_bytes"), required: $(bytes_to_human "$UPDATE_MIN_INSTALL_FREE_BYTES")"

print_info "Free disk space under $install_path and retry the update"

return 1

fi

return 0

# Follow the GitHub "latest" redirect and extract the tag in a way that

# tolerates intermediate redirects that omit /tag/ (issue #698).

local target_url="${1:-}"

local effective_url=""

if [[ -z "$target_url" ]]; then

return 1

fi

local curl_cmd=(curl -fsSL --connect-timeout 5 --max-time 10 -o /dev/null -w '%{url_effective}' "$target_url")

if command -v timeout >/dev/null 2>&1; then

effective_url=$(timeout 10 "${curl_cmd[@]}" 2>/dev/null || true)

else

effective_url=$("${curl_cmd[@]}" 2>/dev/null || true)

fi

# Strip stray carriage returns so string comparisons behave under set -u

effective_url="${effective_url//$'\r'/}"

if [[ -z "$effective_url" ]]; then

return 1

fi

local tag=""

if [[ "$effective_url" =~ /tag/([^/?#]+) ]]; then

tag="${BASH_REMATCH[1]}"

elif [[ "$effective_url" =~ /download/([^/?#]+)/ ]]; then

tag="${BASH_REMATCH[1]}"

fi

if [[ -z "$tag" ]]; then

return 1

fi

printf '%s\n' "$tag"

return 0

local latest_version=""

local releases_json=""

local feed_xml=""

local api_url="https://api.github.com/repos/$GITHUB_REPO/releases"

local feed_url="https://github.com/$GITHUB_REPO/releases.atom"

if command -v timeout >/dev/null 2>&1; then

releases_json=$(timeout 10 curl -fsSL --connect-timeout 5 --max-time 10 "$api_url" 2>/dev/null || true)

else

releases_json=$(curl -fsSL --connect-timeout 5 --max-time 10 "$api_url" 2>/dev/null || true)

fi

if [[ -n "$releases_json" ]]; then

latest_version=$(printf '%s' "$releases_json" | grep -oE '"tag_name":[[:space:]]*"v5\.1\.[0-9]+"' | head -1 | sed -E 's/.*"([^"]+)"/\1/' || true)

fi

if [[ -z "$latest_version" ]]; then

if command -v timeout >/dev/null 2>&1; then

feed_xml=$(timeout 10 curl -fsSL --connect-timeout 5 --max-time 10 "$feed_url" 2>/dev/null || true)

else

feed_xml=$(curl -fsSL --connect-timeout 5 --max-time 10 "$feed_url" 2>/dev/null || true)

fi

if [[ -n "$feed_xml" ]]; then

latest_version=$(printf '%s' "$feed_xml" | grep -oE '<title>Pulse v5\.1\.[0-9]+</title>' | head -1 | sed -E 's#<title>Pulse (v[^<]+)</title>#\1#' || true)

fi

fi

printf '%s\n' "$latest_version"

local requested_version="${1:-}"

if [[ "$BUILD_FROM_SOURCE" == "true" ]]; then

maintenance_raw_url "install.sh"

return

fi

if [[ -n "$requested_version" ]]; then

if [[ "$requested_version" != v* ]]; then

requested_version="v${requested_version}"

fi

printf 'https://github.com/%s/releases/download/%s/install.sh\n' "$GITHUB_REPO" "$requested_version"

return

fi

maintenance_raw_url "install.sh"

local ctid=""

if [[ -r /proc/1/cgroup ]]; then

ctid=$(sed 's/\\x2d/-/g' /proc/1/cgroup 2>/dev/null | grep -Eo '(lxc|machine-lxc)-[0-9]+' | tail -n1 | grep -Eo '[0-9]+' | tail -n1)

if [[ -n "$ctid" ]]; then

echo "$ctid"

return

fi

fi

if command -v hostname >/dev/null 2>&1; then

ctid=$(hostname 2>/dev/null || true)

if [[ "$ctid" =~ ^[0-9]+$ ]]; then

echo "$ctid"

return

fi

fi

if command -v hostnamectl >/dev/null 2>&1; then

ctid=$(hostnamectl hostname 2>/dev/null || true)

if [[ "$ctid" =~ ^[0-9]+$ ]]; then

echo "$ctid"

return

fi

fi

if command -v findmnt >/dev/null 2>&1; then

local mount_src

mount_src=$(findmnt -no SOURCE / 2>/dev/null || true)

if [[ "$mount_src" =~ -([0-9]+)-disk ]]; then

echo "${BASH_REMATCH[1]}"

return

fi

fi

if command -v df >/dev/null 2>&1; then

local root_src

root_src=$(df -P / 2>/dev/null | awk 'NR==2 {print $1}')

if [[ "$root_src" =~ -([0-9]+)-disk ]]; then

echo "${BASH_REMATCH[1]}"

return

fi

fi

if [[ "$IN_CONTAINER" == "true" ]]; then

if [[ -z "$DETECTED_CTID" ]]; then

DETECTED_CTID=$(detect_lxc_ctid 2>/dev/null || true)

fi

return

fi

local virt_type=""

if command -v systemd-detect-virt >/dev/null 2>&1; then

virt_type=$(systemd-detect-virt --container 2>/dev/null || true)

if [[ -n "$virt_type" && "$virt_type" != "none" ]]; then

IN_CONTAINER=true

if [[ "$virt_type" == "docker" ]]; then

IN_DOCKER=true

fi

fi

fi

if [[ "$IN_CONTAINER" != "true" ]]; then

if [[ -f /.dockerenv ]] || grep -qa docker /proc/1/cgroup 2>/dev/null || grep -qa docker /proc/self/cgroup 2>/dev/null; then

IN_CONTAINER=true

IN_DOCKER=true

elif grep -qaE '(lxc|machine-lxc)' /proc/1/cgroup 2>/dev/null; then

IN_CONTAINER=true

elif [[ -r /proc/1/environ ]] && grep -qa 'container=lxc' /proc/1/environ 2>/dev/null; then

IN_CONTAINER=true

fi

fi

if [[ "$IN_CONTAINER" == "true" ]]; then

if [[ -z "$DETECTED_CTID" ]]; then

DETECTED_CTID=$(detect_lxc_ctid 2>/dev/null || true)

fi

fi

echo ""

print_error "Installation cancelled"

if [[ -n "$CURRENT_INSTALL_CTID" ]] && [[ "$CONTAINER_CREATED_FOR_CLEANUP" == "true" ]]; then

print_info "Cleaning up container $CURRENT_INSTALL_CTID..."

pct stop "$CURRENT_INSTALL_CTID" 2>/dev/null || true

sleep 2

pct destroy "$CURRENT_INSTALL_CTID" 2>/dev/null || true

fi

exit 1

local action="$1"

shift

timeout 5 systemctl "$action" "$@" 2>/dev/null || {

if [[ "$action" == "daemon-reload" ]]; then

# daemon-reload hanging is common in unprivileged containers, silent fail is OK

return 0

elif [[ "$action" == "start" || "$action" == "enable" ]]; then

print_info "Note: systemctl $action failed (may be in unprivileged container)"

return 1

else

return 1

fi

}

local service_name="${1:-$(detect_service_name)}"

if ! command -v systemctl >/dev/null 2>&1; then

return 1

fi

if timeout 5 systemctl is-active --quiet "$service_name" 2>/dev/null; then

STOPPED_PULSE_SERVICE="$service_name"

print_info "Stopping existing Pulse service ($service_name)..."

safe_systemctl stop "$service_name" || true

sleep 2

return 0

fi

return 1

local exit_code=$?

if [[ "$exit_code" -ne 0 ]] && [[ -n "$STOPPED_PULSE_SERVICE" ]] && command -v systemctl >/dev/null 2>&1; then

print_info "Restarting Pulse service ($STOPPED_PULSE_SERVICE) after failed update"

safe_systemctl start "$STOPPED_PULSE_SERVICE" || true

fi

if ! command -v systemctl >/dev/null 2>&1; then

echo "pulse"

return

fi

if systemctl list-unit-files --no-legend | grep -q "^pulse-backend.service"; then

echo "pulse-backend"

elif systemctl list-unit-files --no-legend | grep -q "^pulse.service"; then

echo "pulse"

else

echo "pulse" # Default for new installations

fi

echo -e "${BLUE}=================================================${NC}"

echo -e "${BLUE} Pulse Installation Script${NC}"

echo -e "${BLUE}=================================================${NC}"

echo

local prompt="$1"

local var_name="$2"

shift 2

local read_args="$@" # Allow passing additional args like -n 1

# When script is piped (curl | bash), stdin is the pipe, not the terminal

# We need to read from /dev/tty for user input

if [[ -t 0 ]]; then

# stdin is a terminal, read normally

echo -n "$prompt"

IFS= read -r $read_args "$var_name"

return 0

else

# stdin is not a terminal (piped), try /dev/tty if available

if { exec 3< /dev/tty; } 2>/dev/null; then

# /dev/tty is available and usable

echo -n "$prompt"

IFS= read -r $read_args "$var_name" <&3

exec 3<&-

return 0

else

# No TTY available at all - truly non-interactive

# Don't try to read from piped stdin as it will hang

return 1

fi

fi

local prompt="$1"

local var_name="$2"

local default_value="$3"

shift 3

local read_args="$@"

# Temporarily disable errexit

set +e

safe_read "$prompt" "$var_name" $read_args

local read_result=$?

set -e

if [[ $read_result -ne 0 ]]; then

# Failed to read - use default

eval "$var_name='$default_value'"

# Only print default message in truly non-interactive mode

if [[ ! -t 0 ]] && [[ -n "$default_value" ]]; then

print_info "Using default: $default_value"

fi

return 0 # Return success since we handled it with a default

fi

# Check if empty and use default

local current_value

eval "current_value=\$$var_name"

if [[ -z "$current_value" ]]; then

eval "$var_name='$default_value'"

fi

return 0

local pulse_url="$1"

local retries="${2:-60}"

local delay="${3:-1}"

if [[ -z "$pulse_url" ]] || ! command -v curl >/dev/null 2>&1; then

return 0

fi

local api_endpoint="${pulse_url%/}/api/health"

print_info "Waiting for Pulse API at ${api_endpoint}..."

for attempt in $(seq 1 "$retries"); do

if curl -fsS --max-time 2 "$api_endpoint" >/dev/null 2>&1; then

print_info "Pulse API is reachable"

return 0

fi

sleep "$delay"

done

print_warn "Pulse API did not respond after ${retries}s; continuing anyway"

return 1

if [[ -n "$DEBIAN_TEMPLATE" ]]; then

return

fi

local candidate=""

if command -v pveam >/dev/null 2>&1; then

local available_output=""

available_output=$(pveam available --section system 2>/dev/null || true)

candidate=$(echo "$available_output" | awk '$2 ~ /^debian-12-standard_[0-9]+\.[0-9]+-[0-9]+_amd64\.tar\.zst$/ {print $2}' | sort -V | tail -1)

if [[ -z "$candidate" ]]; then

available_output=$(pveam available 2>/dev/null || true)

candidate=$(echo "$available_output" | awk '$2 ~ /^debian-12-standard_[0-9]+\.[0-9]+-[0-9]+_amd64\.tar\.zst$/ {print $2}' | sort -V | tail -1)

fi

fi

if [[ -z "$candidate" ]]; then

candidate="$DEBIAN_TEMPLATE_FALLBACK"

print_info "Using fallback Debian template version: $candidate"

else

print_info "Detected latest Debian template version: $candidate"

fi

DEBIAN_TEMPLATE="$candidate"

if [[ $EUID -ne 0 ]]; then

print_error "This script must be run as root"

exit 1

fi

if [[ "$0" == "bash" ]] || [[ ! -f "$0" ]]; then

printf 'install.sh\n'

return 0

fi

basename "$0"

if [[ -f /etc/os-release ]]; then

. /etc/os-release

OS=$ID

VER=$VERSION_ID

else

print_error "Cannot detect OS"

exit 1

fi

# Check if SELinux is available and enforcing

if ! command -v getenforce >/dev/null 2>&1; then

return 0 # SELinux not installed

fi

if [[ "$(getenforce 2>/dev/null)" != "Enforcing" ]]; then

return 0 # SELinux not enforcing

fi

# restorecon is the proper way to fix SELinux contexts

if command -v restorecon >/dev/null 2>&1; then

print_info "Restoring SELinux contexts for installed binaries..."

restorecon -Rv "$INSTALL_DIR/bin/" >/dev/null 2>&1 || true

restorecon -v /usr/local/bin/pulse* >/dev/null 2>&1 || true

print_success "SELinux contexts restored"

else

# Fallback to chcon if restorecon isn't available

if command -v chcon >/dev/null 2>&1; then

print_info "Setting SELinux contexts for installed binaries..."

find "$INSTALL_DIR/bin/" -type f -executable -exec chcon -t bin_t {} \; 2>/dev/null || true

find /usr/local/bin/ -name 'pulse*' -exec chcon -h -t bin_t {} \; 2>/dev/null || true

fi

fi

# Check if this is a Proxmox VE host

if command -v pvesh &> /dev/null && [[ -d /etc/pve ]]; then

return 0

fi

return 1

# Remove stale pulse-sensor-proxy mount entries from LXC container configs.

# In v4, the installer added mount entries for /run/pulse-sensor-proxy to the

# container config. In v5, the sensor proxy was removed, and after a host reboot

# /run (tmpfs) is wiped so the mount source no longer exists, preventing the

# container from starting with: Failed to mount "/run/pulse-sensor-proxy"

if ! command -v pct >/dev/null 2>&1; then

return 0

fi

local ctids

ctids=$(pct list 2>/dev/null | tail -n +2 | awk '{print $1}') || return 0

[[ -z "$ctids" ]] && return 0

local cleaned=0

while IFS= read -r ctid; do

[[ -z "$ctid" ]] && continue

local conf="/etc/pve/lxc/${ctid}.conf"

[[ -f "$conf" ]] || continue

# Skip containers without sensor-proxy references

if ! grep -q 'pulse-sensor-proxy' "$conf" 2>/dev/null; then

continue

fi

print_info "Found stale sensor-proxy mount in container $ctid, cleaning up..."

local status

status=$(pct status "$ctid" 2>/dev/null | awk '{print $2}') || true

local was_running=false

[[ "$status" == "running" ]] && was_running=true

# Stop running containers before modifying mount config

if [[ "$was_running" == "true" ]]; then

print_info "Stopping container $ctid to remove stale mount..."

timeout 30 pct stop "$ctid" 2>/dev/null || true

sleep 2

fi

# Determine the main-section boundary (before any [snapshot] sections)

local snapshot_line

snapshot_line=$(grep -n '^\[' "$conf" 2>/dev/null | head -1 | cut -d: -f1) || true

# Remove mp<N> entries (e.g., mp0: /run/pulse-sensor-proxy,mp=/mnt/pulse-proxy)

# Only match entries in the main section, not inside snapshot blocks

local mp_keys

if [[ -n "$snapshot_line" ]] && [[ "$snapshot_line" -gt 1 ]]; then

mp_keys=$(head -n "$((snapshot_line - 1))" "$conf" 2>/dev/null | grep -E '^mp[0-9]+:.*pulse-sensor-proxy' | sed 's/:.*//') || true

else

mp_keys=$(grep -E '^mp[0-9]+:.*pulse-sensor-proxy' "$conf" 2>/dev/null | sed 's/:.*//') || true

fi

if [[ -n "$mp_keys" ]]; then

while IFS= read -r mp_key; do

[[ -z "$mp_key" ]] && continue

if timeout 15 pct set "$ctid" -delete "$mp_key" 2>/dev/null; then

print_success "Removed $mp_key from container $ctid"

else

# Fallback: direct config edit (main section only)

if [[ -n "$snapshot_line" ]] && [[ "$snapshot_line" -gt 1 ]]; then

timeout 10 sed -i "1,$((snapshot_line - 1)){/^${mp_key}:.*pulse-sensor-proxy/d}" "$conf" 2>/dev/null || true

else

timeout 10 sed -i "/^${mp_key}:.*pulse-sensor-proxy/d" "$conf" 2>/dev/null || true

fi

print_success "Removed $mp_key from container $ctid (direct edit)"

fi

cleaned=$((cleaned + 1))

done <<< "$mp_keys"

fi

# Remove lxc.mount.entry lines referencing pulse-sensor-proxy

# Only modify lines in the main section (before any [snapshot] sections)

if grep -q 'lxc\.mount\.entry:.*pulse-sensor-proxy' "$conf" 2>/dev/null; then

if [[ -n "$snapshot_line" ]] && [[ "$snapshot_line" -gt 1 ]]; then

# Only delete matching lines before the first snapshot section

timeout 10 sed -i "1,$((snapshot_line - 1)){/lxc\.mount\.entry:.*pulse-sensor-proxy/d}" "$conf" 2>/dev/null || true

else

# No snapshot sections, safe to delete all matching lines

timeout 10 sed -i '/lxc\.mount\.entry:.*pulse-sensor-proxy/d' "$conf" 2>/dev/null || true

fi

cleaned=$((cleaned + 1))

print_success "Removed lxc.mount.entry for sensor-proxy from container $ctid"

fi

# Restart container if it was running before cleanup

if [[ "$was_running" == "true" ]]; then

print_info "Restarting container $ctid..."

timeout 30 pct start "$ctid" 2>/dev/null || {

print_warn "Could not restart container $ctid — start it manually: pct start $ctid"

}

fi

done <<< "$ctids"

if [[ "$cleaned" -gt 0 ]]; then

print_success "Cleaned up stale sensor-proxy mount entries from container config(s)"

fi

# Detect if we're running inside Docker (multiple detection methods)

if [[ -f /.dockerenv ]] || \

grep -q docker /proc/1/cgroup 2>/dev/null || \

grep -q docker /proc/self/cgroup 2>/dev/null || \

[[ -f /run/.containerenv ]] || \

[[ "${container:-}" == "docker" ]]; then

print_error "Docker environment detected"

echo "Please use the Docker image directly: docker run -d -p 7655:7655 rcourtman/pulse:latest"

echo "See: https://github.com/rcourtman/Pulse/blob/main/docs/DOCKER.md"

exit 1

fi

local preferred=()

local fallback=()

local ip_output=""

ip_output=$(ip -o link show type bridge 2>/dev/null || true)

if [[ -n "$ip_output" ]]; then

while IFS= read -r line; do

[[ -z "$line" ]] && continue

local iface=${line#*: }

iface=${iface%%:*}

iface=${iface%%@*}

case "$iface" in

docker*|br-*|virbr*|cni*|cilium*|flannel*|kube-*|veth*|tap*|ovs-system)

continue

;;

vmbr*|vnet*|ovs*)

preferred+=("$iface")

;;

*)

fallback+=("$iface")

;;

esac

done <<< "$ip_output"

fi

if command -v ovs-vsctl >/dev/null 2>&1; then

local ovs_output=""

ovs_output=$(ovs-vsctl list-br 2>/dev/null || true)

if [[ -n "$ovs_output" ]]; then

while IFS= read -r iface; do

[[ -z "$iface" ]] && continue

case "$iface" in

docker*|br-*|virbr*|cni*|cilium*|flannel*|kube-*|veth*|tap*|ovs-system)

continue

;;

vmbr*|vnet*|ovs*)

preferred+=("$iface")

;;

*)

fallback+=("$iface")

;;

esac

done <<< "$ovs_output"

fi

fi

local combined=()

if [[ ${#preferred[@]} -gt 0 ]]; then

combined=("${preferred[@]}")

fi

if [[ ${#fallback[@]} -gt 0 ]]; then

combined+=("${fallback[@]}")

fi

if [[ ${#combined[@]} -gt 0 ]]; then

printf '%s\n' "${combined[@]}" | awk '!seen[$0]++' | paste -sd' ' -

fi

local iface="$1"

[[ -z "$iface" ]] && return 1

local bridge_info=""

bridge_info=$(ip -o link show "$iface" type bridge 2>/dev/null || true)

if [[ -n "$bridge_info" ]]; then

return 0

fi

if command -v ovs-vsctl >/dev/null 2>&1 && ovs-vsctl br-exists "$iface" &>/dev/null; then

return 0

fi

return 1

CURRENT_INSTALL_CTID=""

CONTAINER_CREATED_FOR_CLEANUP=false

trap handle_install_interrupt INT TERM

print_header

echo "Proxmox VE detected. Installing Pulse in a container."

echo

# Clean up stale sensor-proxy mount entries from v4 that prevent containers

# from starting after a host reboot (see GitHub Discussion #1280)

cleanup_stale_sensor_proxy_mounts

# Check if we can interact with the user

# Try to read from /dev/tty to test if we have terminal access

if test -e /dev/tty && (echo -n "" > /dev/tty) 2>/dev/null; then

# We have terminal access, show menu

echo "Installation mode:"

echo " 1) Quick (recommended)"

echo " 2) Advanced"

echo " 3) Cancel"

safe_read_with_default "Select [1-3]: " mode "1"

else

# No terminal access - truly non-interactive

echo "Non-interactive mode detected. Using Quick installation."

mode="1"

fi

case $mode in

3)

print_info "Installation cancelled"

exit 0

;;

2)

ADVANCED_MODE=true

;;

*)

ADVANCED_MODE=false

;;

esac

# Get next available container ID from Proxmox

local CTID=$(pvesh get /cluster/nextid 2>/dev/null || echo "100")

# If pvesh failed, fallback to manual search

if [[ "$CTID" == "100" ]]; then

while pct status $CTID &>/dev/null 2>&1 || qm status $CTID &>/dev/null 2>&1; do

((CTID++))

done

fi

if [[ "$ADVANCED_MODE" == "true" ]]; then

echo

# Ask for port configuration

safe_read_with_default "Frontend port [7655]: " frontend_port "7655"

if [[ ! "$frontend_port" =~ ^[0-9]+$ ]] || [[ "$frontend_port" -lt 1 ]] || [[ "$frontend_port" -gt 65535 ]]; then

print_error "Invalid port number. Using default port 7655."

frontend_port=7655

fi

auto_updates_flag=""

if [[ "$BUILD_FROM_SOURCE" == "true" ]]; then

echo

print_info "Skipping auto-update configuration: source builds don't support automatic release updates."

else

echo

# Ask about auto-updates

echo "Enable automatic updates?"

echo "Pulse can automatically install stable updates daily (between 2-6 AM)"

safe_read_with_default "Enable auto-updates? [y/N]: " enable_updates "n"

if [[ "$enable_updates" =~ ^[Yy]$ ]]; then

auto_updates_flag="--enable-auto-updates"

ENABLE_AUTO_UPDATES=true # Set the global variable for host installations

fi

fi

echo

# Try to get cluster-wide IDs, fall back to local

# Disable error exit for this section as commands may fail on fresh PVE installs without VMs

set +e

local USED_IDS=""

if command -v pvesh &>/dev/null; then

# Parse JSON output using grep and sed (works without jq)

USED_IDS=$(pvesh get /cluster/resources --type vm --output-format json 2>/dev/null | \

fi

if [[ -z "$USED_IDS" ]]; then

# Fallback: get local containers and VMs

local LOCAL_CTS=$(pct list 2>/dev/null | tail -n +2 | awk '{print $1}' | sort -n)

local LOCAL_VMS=$(qm list 2>/dev/null | tail -n +2 | awk '{print $1}' | sort -n)

USED_IDS=$(echo -e "$LOCAL_CTS\n$LOCAL_VMS" | grep -v '^$' | sort -n | paste -sd',' -)

fi

# Re-enable error exit

set -e

echo "Container/VM IDs in use: ${USED_IDS:-none}"

safe_read_with_default "Container ID [$CTID]: " custom_ctid "$CTID"

if [[ "$custom_ctid" != "$CTID" ]] && [[ "$custom_ctid" =~ ^[0-9]+$ ]]; then

# Check if ID is in use

if pct status $custom_ctid &>/dev/null 2>&1 || qm status $custom_ctid &>/dev/null 2>&1; then

print_error "Container/VM ID $custom_ctid is already in use"

exit 1

fi

# Also check cluster if possible

if command -v pvesh &>/dev/null; then

if pvesh get /cluster/resources --type vm 2>/dev/null | jq -e ".[] | select(.vmid == $custom_ctid)" &>/dev/null; then

print_error "Container/VM ID $custom_ctid is already in use in the cluster"

exit 1

fi

fi

CTID=$custom_ctid

fi

fi

print_info "Using container ID: $CTID"

CURRENT_INSTALL_CTID="$CTID"

if [[ "$ADVANCED_MODE" == "true" ]]; then

echo

echo -e "${BLUE}Advanced Mode - Customize all settings${NC}"

echo -e "${YELLOW}Defaults shown are suitable for monitoring 10-20 nodes${NC}"

echo

# Container settings

safe_read_with_default "Container hostname [pulse]: " hostname "pulse"

safe_read_with_default "Memory (MB) [1024]: " memory "1024"

safe_read_with_default "Disk size (GB) [4]: " disk "4"

safe_read_with_default "CPU cores [2]: " cores "2"

safe_read_with_default "CPU limit (0=unlimited) [2]: " cpulimit "2"

safe_read_with_default "Swap (MB) [256]: " swap "256"

safe_read_with_default "Start on boot? [Y/n]: " onboot "Y" -n 1 -r

echo

if [[ "$onboot" =~ ^[Nn]$ ]]; then

onboot=0

else

onboot=1

fi

safe_read_with_default "Enable firewall? [Y/n]: " firewall "Y" -n 1 -r

echo

if [[ "$firewall" =~ ^[Nn]$ ]]; then

firewall=0

else

firewall=1

fi

safe_read_with_default "Unprivileged container? [Y/n]: " unprivileged "Y" -n 1 -r

echo

if [[ "$unprivileged" =~ ^[Nn]$ ]]; then

unprivileged=0

else

unprivileged=1

fi

else

# Quick mode - just use defaults silently

# Use optimized defaults

hostname="pulse"

memory=1024

disk=4

cores=2

cpulimit=2

swap=256

onboot=1

firewall=1

unprivileged=1

# Ask for port even in quick mode

echo

safe_read_with_default "Port [7655]: " frontend_port "7655"

if [[ ! "$frontend_port" =~ ^[0-9]+$ ]] || [[ "$frontend_port" -lt 1 ]] || [[ "$frontend_port" -gt 65535 ]]; then

print_info "Using default: 7655"

frontend_port=7655

fi

auto_updates_flag=""

if [[ "$BUILD_FROM_SOURCE" == "true" ]]; then

echo

print_info "Skipping auto-update configuration: source builds don't support automatic release updates."

else

# Quick mode should ask about auto-updates too

echo

echo "Enable automatic updates?"

echo "Pulse can automatically install stable updates daily (between 2-6 AM)"

safe_read_with_default "Enable auto-updates? [y/N]: " enable_updates "n"

if [[ "$enable_updates" =~ ^[Yy]$ ]]; then

auto_updates_flag="--enable-auto-updates"

ENABLE_AUTO_UPDATES=true # Set the global variable for host installations

fi

fi

# Optional VLAN configuration - defaults to empty (no VLAN) for regular users

echo

safe_read_with_default "VLAN ID (press Enter for no VLAN): " vlan_id ""

if [[ -n "$vlan_id" ]]; then

# Validate VLAN ID (1-4094)

if [[ ! "$vlan_id" =~ ^[0-9]+$ ]] || [[ "$vlan_id" -lt 1 ]] || [[ "$vlan_id" -gt 4094 ]]; then

print_error "Invalid VLAN ID. Must be between 1 and 4094"

print_info "Proceeding without VLAN"

vlan_id=""

fi

fi

fi

# Get available network bridges

echo

print_info "Detecting available resources..."