# 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:-https://github.com/$GITHUB_REPO/releases/latest}"

local effective_url=""

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 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

}

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 [[ -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

# 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

# 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..."

# Get available bridges

local BRIDGES=$(detect_network_bridges)

# First try to find the default network interface (could be bridge or regular interface)

local DEFAULT_INTERFACE=$(ip route | grep default | head -1 | grep -oP 'dev \K\S+')

# Check if the default interface is a bridge

local DEFAULT_BRIDGE=""

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

if is_bridge_interface "$DEFAULT_INTERFACE"; then

# Default interface is a bridge, use it

DEFAULT_BRIDGE="$DEFAULT_INTERFACE"

fi

fi

# If no default bridge found, try to use the first available bridge

if [[ -z "$DEFAULT_BRIDGE" && -n "$BRIDGES" ]]; then

DEFAULT_BRIDGE=$(echo "$BRIDGES" | cut -d' ' -f1)

fi

# If still no bridge found, we'll need to ask the user

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

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

# We have a default interface but it's not a bridge

print_info "Default network interface is $DEFAULT_INTERFACE (not a bridge)"

fi

DEFAULT_BRIDGE="vmbr0" # Fallback suggestion only

fi

# Get available storage with usage info

local STORAGE_INFO=$(pvesm status -content rootdir 2>/dev/null | tail -n +2)

local DEFAULT_STORAGE=$(echo "$STORAGE_INFO" | awk '{print $1}' | head -1)

DEFAULT_STORAGE=${DEFAULT_STORAGE:-local-lvm}

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

# Show available bridges

echo

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

echo "Available network bridges:"

local bridge_array=($BRIDGES)

local default_idx=0

for i in "${!bridge_array[@]}"; do

local idx=$((i+1))

echo " $idx) ${bridge_array[$i]}"

if [[ "${bridge_array[$i]}" == "$DEFAULT_BRIDGE" ]]; then

default_idx=$idx

fi

done

set +e

safe_read "Select network bridge [${default_idx}]: " bridge_choice

local read_result=$?

set -e

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

bridge_choice=${bridge_choice:-$default_idx}

if [[ "$bridge_choice" =~ ^[0-9]+$ ]] && [[ "$bridge_choice" -ge 1 ]] && [[ "$bridge_choice" -le ${#bridge_array[@]} ]]; then

bridge="${bridge_array[$((bridge_choice-1))]}"

elif [[ -n "$bridge_choice" ]]; then

# User typed a bridge name directly

bridge="$bridge_choice"

else

bridge="$DEFAULT_BRIDGE"

fi

else

# Non-interactive, use default

bridge="$DEFAULT_BRIDGE"

fi

else

echo "No network bridges detected"

echo "You may need to create a Linux bridge or Open vSwitch bridge first (e.g., vmbr0)"

set +e

safe_read "Enter network bridge name: " bridge

set -e

fi

# Show available storage with usage details

echo

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

echo "Available storage pools:"

local storage_names=()

local default_idx=0

local idx=1

while IFS= read -r line; do

local storage_name storage_type avail_gb total_gb used_pct parsed_line

parsed_line=$(LC_NUMERIC=C awk '{printf "%s,%s,%.1f,%.1f,%s", $1, $2, $6/1048576, $4/1048576, $7}' <<< "$line")

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

IFS=',' read -r storage_name storage_type avail_gb total_gb used_pct <<< "$parsed_line" || continue

storage_names+=("$storage_name")

LC_ALL=C printf " %d) %-15s %-8s %6.1f GB free of %6.1f GB (%s used)\n" \

"$idx" "$storage_name" "$storage_type" "$avail_gb" "$total_gb" "$used_pct"

if [[ "$storage_name" == "$DEFAULT_STORAGE" ]]; then

default_idx=$idx

fi

((idx++))

done <<< "$STORAGE_INFO"

set +e

safe_read "Select storage pool [${default_idx}]: " storage_choice

local read_result=$?

set -e

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

storage_choice=${storage_choice:-$default_idx}

if [[ "$storage_choice" =~ ^[0-9]+$ ]] && [[ "$storage_choice" -ge 1 ]] && [[ "$storage_choice" -le ${#storage_names[@]} ]]; then

storage="${storage_names[$((storage_choice-1))]}"

elif [[ -n "$storage_choice" ]]; then

# User typed a storage name directly

storage="$storage_choice"

else

storage="$DEFAULT_STORAGE"

fi

else

# Non-interactive, use default

storage="$DEFAULT_STORAGE"

fi

else

echo " No storage pools found"

set +e

safe_read "Enter storage pool name [$DEFAULT_STORAGE]: " storage

set -e

storage=${storage:-$DEFAULT_STORAGE}

fi

safe_read_with_default "Static IP with CIDR (e.g. 192.168.1.100/24, leave empty for DHCP): " static_ip ""

# If static IP is provided, we need gateway

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

# Validate IP format

if [[ ! "$static_ip" =~ ^[0-9]{1,3}\.[0-9]{1,3}\.[0-9]{1,3}\.[0-9]{1,3}/[0-9]{1,2}$ ]]; then

print_error "Invalid IP format. Please use CIDR notation (e.g., 192.168.1.100/24)"

print_info "Using DHCP instead"

static_ip=""

else

safe_read_with_default "Gateway IP address: " gateway_ip ""

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

# Try to guess gateway from the IP (use .1 of the subnet)

local ip_base="${static_ip%.*}"

gateway_ip="${ip_base}.1"

print_info "No gateway specified, using $gateway_ip"

elif [[ ! "$gateway_ip" =~ ^[0-9]{1,3}\.[0-9]{1,3}\.[0-9]{1,3}\.[0-9]{1,3}$ ]]; then

print_error "Invalid gateway format. Using DHCP instead"

static_ip=""

gateway_ip=""

fi

fi

fi

safe_read_with_default "DNS servers (space-separated, empty for host settings): " nameserver ""

# VLAN configuration

safe_read_with_default "VLAN ID (leave empty 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

safe_read_with_default "Startup order [99]: " startup "99"

else

# Quick mode - but still need to verify critical settings

# Network bridge selection

echo

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

echo "Available network bridges:"

local bridge_array=($BRIDGES)

local default_idx=0

for i in "${!bridge_array[@]}"; do

local idx=$((i+1))

echo " $idx) ${bridge_array[$i]}"

if [[ "${bridge_array[$i]}" == "$DEFAULT_BRIDGE" ]]; then

default_idx=$idx

fi

done

if [[ ${#bridge_array[@]} -eq 1 ]]; then

# Only one bridge available, use it

bridge="${bridge_array[0]}"

print_info "Using network bridge: $bridge"

else

set +e

safe_read "Select network bridge [${default_idx}]: " bridge_choice

local read_result=$?

set -e

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

bridge_choice=${bridge_choice:-$default_idx}

if [[ "$bridge_choice" =~ ^[0-9]+$ ]] && [[ "$bridge_choice" -ge 1 ]] && [[ "$bridge_choice" -le ${#bridge_array[@]} ]]; then

bridge="${bridge_array[$((bridge_choice-1))]}"

else

bridge="$DEFAULT_BRIDGE"

print_info "Invalid selection, using default: $bridge"

fi

else

# Non-interactive, use default

bridge="$DEFAULT_BRIDGE"

fi

fi

else

print_error "No network bridges detected on this system"

print_info "You may need to create a Linux bridge or Open vSwitch bridge first (e.g., vmbr0)"

set +e

safe_read "Enter network bridge name to use: " bridge

set -e

fi

# Storage selection

echo

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

echo "Available storage pools:"

# Create arrays for storage info

local storage_names=()

local storage_info_lines=()

local default_idx=0

local idx=1

while IFS= read -r line; do

local storage_name storage_type avail_gb total_gb used_pct parsed_line

parsed_line=$(LC_NUMERIC=C awk '{printf "%s,%s,%.1f,%.1f,%s", $1, $2, $6/1048576, $4/1048576, $7}' <<< "$line")

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

IFS=',' read -r storage_name storage_type avail_gb total_gb used_pct <<< "$parsed_line" || continue

storage_names+=("$storage_name")

LC_ALL=C printf " %d) %-15s %-8s %6.1f GB free of %6.1f GB (%s used)\n" \

"$idx" "$storage_name" "$storage_type" "$avail_gb" "$total_gb" "$used_pct"

if [[ "$storage_name" == "$DEFAULT_STORAGE" ]]; then

default_idx=$idx

fi

((idx++))

done <<< "$STORAGE_INFO"

if [[ ${#storage_names[@]} -eq 1 ]]; then

# Only one storage available, use it

storage="${storage_names[0]}"

print_info "Using storage pool: $storage"

else

set +e

safe_read "Select storage pool [${default_idx}]: " storage_choice

local read_result=$?

set -e

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

storage_choice=${storage_choice:-$default_idx}

if [[ "$storage_choice" =~ ^[0-9]+$ ]] && [[ "$storage_choice" -ge 1 ]] && [[ "$storage_choice" -le ${#storage_names[@]} ]]; then

storage="${storage_names[$((storage_choice-1))]}"

else

storage="$DEFAULT_STORAGE"

print_info "Invalid selection, using default: $storage"

fi

else

# Non-interactive, use default

storage="$DEFAULT_STORAGE"

fi

fi

else

print_error "No storage pools detected"

set +e

safe_read "Enter storage pool name to use: " storage

set -e

fi

static_ip=""

gateway_ip=""

nameserver=""

startup=99

fi

# Handle OS template selection

echo

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

# Get ALL storages that can contain templates

local TEMPLATE_STORAGES=$(pvesm status -content vztmpl 2>/dev/null | tail -n +2 | awk '{print $1}' | paste -sd' ' -)

# Collect templates from ALL template-capable storages

local ALL_TEMPLATES=""

for tmpl_storage in $TEMPLATE_STORAGES; do

# pveam list output already includes the storage prefix in the path

local STORAGE_TEMPLATES=$(pveam list "$tmpl_storage" 2>/dev/null | tail -n +2 | awk '{print $1}' || true)

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

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

ALL_TEMPLATES="${ALL_TEMPLATES}\n${STORAGE_TEMPLATES}"

else

ALL_TEMPLATES="$STORAGE_TEMPLATES"

fi

fi

done