#!/bin/sh

export PATH="/bin:/sbin:/usr/bin:/usr/sbin:${PATH:-}"

CONFIG="owrtremote"
SECTION="main"
XRAY_RELEASE_BASE_URL="${XRAY_RELEASE_BASE_URL:-https://github.com/XTLS/Xray-core/releases/latest/download}"

log() {
	# procd already captures stderr. Use only logger for managed processes.
	[ "${OWRT_REMOTE_SERVICE_LOG:-0}" = 1 ] || printf '%s\n' "$*" >&2
	logger -t owrt-remote "$*" 2>/dev/null || true
}

die() {
	log "ОШИБКА: $*"
	exit 1
}

usage() {
	cat <<'EOF'
Использование:
  owrt-remote status
  owrt-remote doctor
  owrt-remote install-xray-tmp
  owrt-remote prepare-xray
  owrt-remote stop-xray
  owrt-remote render-client [--stdout]
  owrt-remote run
  owrt-remote heartbeat
  owrt-remote heartbeat-loop
  owrt-remote heartbeat-diagnostics
  owrt-remote logs-sync
  owrt-remote network-diagnostics

Настройки лежат в /etc/config/owrtremote.
EOF
}

uci_get() {
	local key default value
	key="$1"
	default="$2"
	value="$(uci -q get "$CONFIG.$SECTION.$key" 2>/dev/null || true)"
	[ -n "$value" ] && {
		printf '%s' "$value"
		return
	}
	printf '%s' "$default"
}

truthy() {
	case "$1" in
		1|yes|true|on|enabled) return 0 ;;
		*) return 1 ;;
	esac
}

json_escape() {
	# The final sentinel retains trailing newlines through awk's record split.
	printf '%s.' "$1" | LC_ALL=C awk '
		BEGIN { for (i = 1; i < 32; i++) escape[sprintf("%c", i)] = sprintf("\\u%04x", i) }
		{ if (NR > 1) value = value "\n"; value = value $0 }
		END {
			value = substr(value, 1, length(value) - 1)
			for (i = 1; i <= length(value); i++) {
				char = substr(value, i, 1)
				if (char == "\\") printf "\\\\"
				else if (char == "\"") printf "\\\""
				else if (char in escape) printf "%s", escape[char]
				else printf "%s", char
			}
		}'
}

json_string() {
	printf '"%s"' "$(json_escape "$1")"
}

safe_num() {
	case "$1" in
		''|*[!0-9]*) printf '%s' "$2" ;;
		*) printf '%s' "$1" ;;
	esac
}

safe_id() {
	printf '%s' "$1" | tr -cs 'A-Za-z0-9._-' '-'
}

normalize_url_base() {
	local value
	value="${1%/}"
	printf '%s' "$value"
}

json_unescape_basic() {
	printf '%s' "$1" | sed 's/\\"/"/g; s/\\\\/\\/g'
}

json_extract_object_string() {
	local file object key compact value
	file="$1"
	object="$2"
	key="$3"
	compact="$(tr -d '\r\n' <"$file" 2>/dev/null || true)"
	[ -n "$compact" ] || return 0
	value="$(printf '%s' "$compact" | sed -n "s/.*\"$object\"[[:space:]]*:[[:space:]]*{[^}]*\"$key\"[[:space:]]*:[[:space:]]*\"\\([^\"]*\\)\".*/\\1/p" | head -n 1)"
	json_unescape_basic "$value"
}

uci_set_if_changed() {
	local key next current
	key="$1"
	next="$2"
	[ -n "$next" ] || return 1
	current="$(uci_get "$key" '')"
	[ "$current" = "$next" ] && return 1
	uci -q set "$CONFIG.$SECTION.$key=$next" >/dev/null 2>&1 || return 1
	return 0
}

# Existing installations also default to manual: only an explicit opt-in may
# let a heartbeat replace the administrator's tunnel endpoint.
vps_host_mode() {
	case "$(uci_get vps_host_mode manual)" in
		auto) printf auto ;;
		*) printf manual ;;
	esac
}

WAN_HELPER="${OWRT_REMOTE_WAN_HELPER:-/usr/lib/owrt-remote/wan.sh}"
if [ -r "$WAN_HELPER" ]; then
	. "$WAN_HELPER"
fi

host_model() {
	if [ -r /tmp/sysinfo/model ]; then
		cat /tmp/sysinfo/model
		return
	fi
	if [ -r /proc/device-tree/model ]; then
		tr -d '\000' </proc/device-tree/model
		return
	fi
	printf 'OpenWrt router'
}

board_name() {
	if [ -r /tmp/sysinfo/board_name ]; then
		cat /tmp/sysinfo/board_name
		return
	fi
	printf 'unknown'
}

release_text() {
	if [ -r /etc/openwrt_release ]; then
		(
			. /etc/openwrt_release 2>/dev/null
			printf '%s %s' "${DISTRIB_ID:-OpenWrt}" "${DISTRIB_RELEASE:-unknown}"
		)
		return
	fi
	printf 'OpenWrt unknown'
}

uptime_seconds() {
	if [ -r /proc/uptime ]; then
		cut -d. -f1 /proc/uptime
		return
	fi
	printf '0'
}

load_text() {
	if [ -r /proc/loadavg ]; then
		awk '{print $1" "$2" "$3}' /proc/loadavg
		return
	fi
	printf '0 0 0'
}

memory_text() {
	if [ -r /proc/meminfo ]; then
		awk '
			/^MemTotal:/ { total=$2 }
			/^MemAvailable:/ { avail=$2 }
			/^MemFree:/ && avail=="" { avail=$2 }
			END {
				if (total == "") total = 0
				if (avail == "") avail = 0
				printf "%s/%s kB", avail, total
			}
		' /proc/meminfo
		return
	fi
	printf '0/0 kB'
}

flash_text() {
	local mount text
	text="$(
		df -kP 2>/dev/null | awk '
			function mb(k) {
				if (k == "" || k == 0) return "0 MB"
				return sprintf("%.1f MB", k / 1024)
			}
			NR == 1 { next }
			{
				mount = $NF
				total = $(NF-4)
				avail = $(NF-2)
				pct = $(NF-1)
				gsub(/%/, "", pct)
				if (total !~ /^[0-9]+$/ || avail !~ /^[0-9]+$/ || pct !~ /^[0-9]+$/) next

				score = 0
				if (mount == "/overlay" || mount == "/rom/overlay") score = 400
				else if (mount == "/") score = 300
				else if ($1 == "overlayfs:/overlay") score = 250
				else if (mount ~ /^\/overlay(\/|$)/) score = 200
				if (score <= best_score) next

				best_score = score
				best_total = total
				best_avail = avail
				best_pct = pct
			}
			END {
				if (best_score > 0) {
					printf "%s free / %s (%s%% used)", mb(best_avail), mb(best_total), best_pct
				}
			}
		'
	)"
	if [ -n "$text" ]; then
		printf '%s' "$text"
		return
	fi
	for mount in /overlay /rom/overlay /; do
		text="$(
			df -kP "$mount" 2>/dev/null | awk '
				function mb(k) {
					if (k == "" || k == 0) return "0 MB"
					return sprintf("%.1f MB", k / 1024)
				}
				NR == 1 { next }
				NF >= 5 {
					total = $(NF-4)
					avail = $(NF-2)
					pct = $(NF-1)
					gsub(/%/, "", pct)
					if (total ~ /^[0-9]+$/ && avail ~ /^[0-9]+$/ && pct ~ /^[0-9]+$/) {
						printf "%s free / %s (%s%% used)", mb(avail), mb(total), pct
						exit
					}
				}
			'
		)"
		if [ -n "$text" ]; then
			printf '%s' "$text"
			return
		fi
	done
	printf 'unknown'
}

temperature_text() {
	local file raw max
	max=""
	for file in /sys/class/thermal/thermal_zone*/temp /sys/devices/virtual/thermal/thermal_zone*/temp /sys/class/hwmon/hwmon*/temp*_input; do
		[ -r "$file" ] || continue
		raw="$(cat "$file" 2>/dev/null | tr -cd '0-9-')"
		[ -n "$raw" ] || continue
		case "$raw" in
			-*|'') continue ;;
		esac
		[ -z "$max" ] && max="$raw"
		[ "$raw" -gt "$max" ] && max="$raw"
	done
	if [ -n "$max" ]; then
		awk -v t="$max" 'BEGIN { if (t > 1000) printf "%.1f C", t / 1000; else printf "%s C", t }'
		return
	fi
	printf 'unknown'
}

ps_all() {
	ps w 2>/dev/null || ps 2>/dev/null || true
}

xray_pids() {
	local config cmdline cmd pid
	config="$(uci_get xray_config /etc/xray/owrt-remote-client.json)"
	[ -n "$config" ] || return 0
	for cmdline in /proc/[0-9]*/cmdline; do
		[ -r "$cmdline" ] || continue
		cmd="$(tr '\000' ' ' <"$cmdline" 2>/dev/null || true)"
		case "$cmd" in
			*xray*"$config"*|*xray-core*"$config"*)
				pid="${cmdline%/cmdline}"
				pid="${pid##*/}"
				printf '%s\n' "$pid"
				;;
		esac
	done
}

xray_running() {
	[ -n "$(xray_pids)" ]
}

stop_xray() {
	local pids pid alive
	pids="$(xray_pids)"
	if [ -z "$pids" ]; then
		printf '%s\n' "OK: Xray уже остановлен"
		return 0
	fi
	for pid in $pids; do
		kill "$pid" >/dev/null 2>&1 || true
	done
	sleep 1
	alive=""
	for pid in $pids; do
		if kill -0 "$pid" >/dev/null 2>&1; then
			kill -9 "$pid" >/dev/null 2>&1 || true
			alive="$alive $pid"
		fi
	done
	if [ -n "$alive" ]; then
		printf 'OK: Xray остановлен принудительно:%s\n' "$alive"
	else
		printf '%s\n' "OK: Xray остановлен"
	fi
}

ssh_running() {
	ps_all | grep '[d]ropbear' >/dev/null 2>&1
}

active_ssh_session() {
	local port hex file
	port="$(safe_num "$(uci_get ssh_port 22)" 22)"
	hex="$(printf '%04X' "$port" 2>/dev/null || printf '0016')"
	for file in /proc/net/tcp /proc/net/tcp6; do
		[ -r "$file" ] || continue
		awk -v port="$hex" '
			NR > 1 {
				split($2, local_addr, ":")
				if (local_addr[2] == port && $4 == "01") {
					found = 1
				}
			}
			END { exit found ? 0 : 1 }
		' "$file" 2>/dev/null && return 0
	done
	return 1
}

xray_bin_path() {
	local configured candidate
	configured="$(uci_get xray_bin /usr/bin/xray)"
	if [ -x "$configured" ]; then
		printf '%s' "$configured"
		return
	fi
	for candidate in /usr/bin/xray /usr/bin/xray-core /usr/local/bin/xray /opt/bin/xray /tmp/owrt-xray/xray /tmp/owrt-xray/xray_softfloat /tmp/xray /tmp/xray_softfloat; do
		if [ -x "$candidate" ]; then
			printf '%s' "$candidate"
			return
		fi
	done
	candidate="$(command -v xray 2>/dev/null || command -v xray-core 2>/dev/null || true)"
	if [ -n "$candidate" ] && [ -x "$candidate" ]; then
		printf '%s' "$candidate"
		return
	fi
	printf '%s' "$configured"
}

fetch_file() {
	local url dst
	url="$1"
	dst="$2"
	if command -v wget >/dev/null 2>&1; then
		wget -q -O "$dst" "$url"
		return
	fi
	if command -v curl >/dev/null 2>&1; then
		curl -fsSL "$url" -o "$dst"
		return
	fi
	die "для скачивания нужен wget или curl"
}

xray_arch() {
	local arch
	arch="$(uname -m 2>/dev/null || true)"

	case "$arch" in
		mips|mips64|mips64el|mips64le|mipsel|mipsle|'') ;;
		*)
			printf '%s\n' "$arch"
			return
			;;
	esac

	if command -v opkg >/dev/null 2>&1; then
		arch="$(
			opkg print-architecture 2>/dev/null | awk '
				$1 == "arch" && $2 != "all" && $2 != "noarch" {
					priority = $3 + 0
					if (priority >= best_priority) {
						best = $2
						best_priority = priority
					}
				}
				END {
					if (best != "") {
						print best
					}
				}
			'
		)"
		[ -n "$arch" ] && {
			printf '%s\n' "$arch"
			return
		}
	fi

	if command -v apk >/dev/null 2>&1; then
		arch="$(apk --print-arch 2>/dev/null || true)"
		[ -n "$arch" ] && {
			printf '%s\n' "$arch"
			return
		}
	fi

	printf '%s\n' "$arch"
}

xray_release_asset() {
	case "$(xray_arch)" in
		aarch64|arm64) printf '%s\n' "Xray-linux-arm64-v8a.zip" ;;
		armv7l|armv7*) printf '%s\n' "Xray-linux-arm32-v7a.zip" ;;
		armv6l|armv6*) printf '%s\n' "Xray-linux-arm32-v6.zip" ;;
		armv5l|armv5*) printf '%s\n' "Xray-linux-arm32-v5.zip" ;;
		x86_64|amd64) printf '%s\n' "Xray-linux-64.zip" ;;
		i386|i686) printf '%s\n' "Xray-linux-32.zip" ;;
		mips64el|mips64le|mips64el_*|mips64le_*) printf '%s\n' "Xray-linux-mips64le.zip" ;;
		mips64|mips64_*) printf '%s\n' "Xray-linux-mips64.zip" ;;
		mipsel*|mipsle*) printf '%s\n' "Xray-linux-mips32le.zip" ;;
		mips*) printf '%s\n' "Xray-linux-mips32.zip" ;;
		*) return 1 ;;
	esac
}

install_package() {
	local pkg
	pkg="$1"
	if command -v opkg >/dev/null 2>&1; then
		opkg update || die "не смог обновить opkg для установки $pkg"
		opkg install "$pkg" || die "не смог поставить $pkg через opkg"
		return
	fi
	if command -v apk >/dev/null 2>&1; then
		apk -U add "$pkg" ca-certificates || die "не смог поставить $pkg через apk"
		return
	fi
	die "не найден пакетный менеджер opkg или apk для установки $pkg"
}

install_xray_tmp() {
	local dir zip asset url version
	dir="/tmp/owrt-xray"
	zip="$dir/xray.zip"
	asset="$(xray_release_asset)" || die "не знаю готовый Xray asset для $(uname -m 2>/dev/null)"
	url="$XRAY_RELEASE_BASE_URL/$asset"

	mkdir -p /var/lock /var/run "$dir"
	if ! command -v unzip >/dev/null 2>&1; then
		install_package unzip
	fi

	printf 'Скачиваю Xray: %s\n' "$asset"
	fetch_file "$url" "$zip"
	( cd "$dir" && unzip -o "$zip" xray >/dev/null ) || die "не смог распаковать Xray"
	chmod +x "$dir/xray"
	version="$("$dir/xray" version 2>&1)" || die "скачанный Xray не запускается"
	version="$(printf '%s\n' "$version" | sed -n '1p')"

	uci set "$CONFIG.$SECTION.xray_bin=$dir/xray"
	uci commit "$CONFIG"
	printf 'OK: Xray поставлен в %s\n' "$dir/xray"
	printf 'OK: %s\n' "$version"
	printf 'OK: xray_bin сохранен в /etc/config/owrtremote\n'
}

ensure_xray_available() {
	local configured candidate found
	configured="$(uci_get xray_bin /usr/bin/xray)"
	[ -x "$configured" ] && return 0

	for candidate in /usr/bin/xray /usr/bin/xray-core /usr/local/bin/xray /opt/bin/xray /tmp/owrt-xray/xray /tmp/xray; do
		if [ -x "$candidate" ]; then
			found="$candidate"
			break
		fi
	done

	if [ -z "$found" ]; then
		found="$(command -v xray 2>/dev/null || command -v xray-core 2>/dev/null || true)"
	fi

	if [ -n "$found" ] && [ -x "$found" ]; then
		[ "$found" = "$configured" ] || {
			uci set "$CONFIG.$SECTION.xray_bin=$found"
			uci commit "$CONFIG"
			log "Xray найден: $found"
		}
		return 0
	fi

	log "Xray не найден ($configured), ставлю временный Xray в /tmp..."
	install_xray_tmp
}

service_enabled() {
	/etc/init.d/owrt-remote enabled >/dev/null 2>&1
}

xray_apply_trace() {
	[ -z "${OWRT_REMOTE_APPLY_TRACE:-}" ] || printf '%s\n' "$1" >>"$OWRT_REMOTE_APPLY_TRACE"
	return 0
}

xray_valid_uuid() {
	[ "${#1}" = 36 ] || return 1
	printf '%s\n' "$1" | LC_ALL=C grep -Eq '^[0-9a-fA-F]{8}-[0-9a-fA-F]{4}-[0-9a-fA-F]{4}-[0-9a-fA-F]{4}-[0-9a-fA-F]{12}$'
}

xray_port() {
	LC_ALL=C awk -v value="$2" -v field="$1" 'BEGIN {
		if (value !~ /^[0-9]+$/ || value + 0 < 1 || value + 0 > 65535) {
			printf "ОШИБКА: %s должен быть целым числом от 1 до 65535\n", field > "/dev/stderr"
			exit 1
		}
		printf "%d", value + 0
	}'
}

xray_valid_tag() {
	[ -n "$2" ] || { log "ОШИБКА: $1 пустой"; return 1; }
	# OpenWrt's BusyBox tr normally has character classes disabled. Use
	# explicit ASCII bytes; [:space:][:cntrl:] would delete ordinary letters.
	if [ "$(printf '%s' "$2" | LC_ALL=C tr -d '\001-\040\177')" != "$2" ]; then
		log "ОШИБКА: $1 содержит пробел или управляющий символ; метка должна сохраняться из OpenWrt config без изменений"
		return 1
	fi
	case "$2" in router-admin|router-ssh|vps-interconn|vps-ssh-interconn)
		log "ОШИБКА: $1 совпадает с внутренней меткой клиента"; return 1 ;;
	esac
}

validate_xray_config() {
	local file binary rc
	file="$1"
	binary="$(xray_bin_path)"
	[ -s "$file" ] || { log "ОШИБКА: конфигурация Xray отсутствует или пуста: $file"; return 1; }
	[ -x "$binary" ] || { log "ОШИБКА: Xray не найден или не исполняемый: $binary"; return 1; }
	printf 'Проверка Xray: %s -test -config %s\n' "$binary" "$file" >&2
	if "$binary" -test -config "$file" >&2; then
		return 0
	else
		rc=$?
		printf 'Проверка Xray не пройдена (rc=%s). Рабочий JSON не заменён.\n' "$rc" >&2
		return "$rc"
	fi
}

render_client_config() (
	local temp_dir rc xray_host out stdout router_id vps_host vps_port uuid ssh_uuid encryption flow reverse_tag ssh_reverse_tag admin_host admin_port ssh_host ssh_port xray_config xray_config_dir
	temp_dir=""
	out=""
	trap 'rm -f "$out"; [ -z "$temp_dir" ] || rmdir "$temp_dir" 2>/dev/null || true' EXIT
	trap 'exit 1' INT TERM
	umask 077
	stdout="0"
	if [ "${1:-}" = "--stdout" ]; then
		stdout="1"
	fi

	router_id="$(safe_id "$(uci_get router_id main)")"
	vps_host="$(uci_get vps_host '')"
	local wan_sockopt wan_xray_device
	wan_sockopt=''
	if truthy "$(uci_get wan_direct 0)"; then
		command -v wan_prepare >/dev/null 2>&1 || die "WAN helper missing: $WAN_HELPER"
		wan_prepare || die "не удалось подготовить прямое соединение через WAN"
		vps_host="$(wan_resolve_host "$vps_host")" || die "VPS host не разрешается через WAN DNS"
		wan_xray_device="$(wan_device)" || die "выбранный WAN интерфейс отключился"
		wan_sockopt=", \"sockopt\": {\"mark\": $((PODKOP_BYPASS_MARK)), \"interface\": \"$(json_escape "$wan_xray_device")\"}"
	fi
	vps_port="$(xray_port vps_port "$(uci_get vps_port 8443)")" || return 1
	uuid="$(uci_get vless_uuid '')"
	ssh_uuid="$(uci_get ssh_vless_uuid '')"
	encryption="$(uci_get vless_encryption none)"
	flow="$(uci_get vless_flow '')"
	reverse_tag="$(uci_get reverse_tag reverse-in)"
	ssh_reverse_tag="$(uci_get ssh_reverse_tag "${reverse_tag}-ssh")"
	admin_host="$(uci_get admin_host 127.0.0.1)"
	admin_port="$(xray_port admin_port "$(uci_get admin_port 80)")" || return 1
	ssh_host="$(uci_get ssh_host 127.0.0.1)"
	ssh_port="$(xray_port ssh_port "$(uci_get ssh_port 22)")" || return 1
	xray_config="$(uci_get xray_config /etc/xray/owrt-remote-client.json)"

	[ -n "$vps_host" ] || die "vps_host пустой"
	[ -n "$uuid" ] || die "vless_uuid пустой"
	[ -n "$ssh_uuid" ] || ssh_uuid="$uuid"
	xray_valid_uuid "$uuid" || die "vless_uuid: ожидается UUID в формате 8-4-4-4-12; значение не исправляется автоматически"
	xray_valid_uuid "$ssh_uuid" || die "ssh_vless_uuid: ожидается UUID в формате 8-4-4-4-12; значение не исправляется автоматически"
	[ -z "$(uci_get ssh_vless_uuid '')" ] || [ "$uuid" != "$ssh_uuid" ] || die "vless_uuid и ssh_vless_uuid должны различаться для двух reverse-туннелей"
	xray_valid_tag reverse_tag "$reverse_tag" || return 1
	xray_valid_tag ssh_reverse_tag "$ssh_reverse_tag" || return 1
	[ "$reverse_tag" != "$ssh_reverse_tag" ] || die "reverse_tag и ssh_reverse_tag должны различаться"
	for xray_host in "$vps_host" "$admin_host" "$ssh_host"; do
		[ -n "$xray_host" ] || die "VPS/admin/SSH host пустой"
		if [ "$(printf '%s' "$xray_host" | LC_ALL=C tr -d '\001-\040\177')" != "$xray_host" ]; then
			die "VPS/admin/SSH host содержит пробел или управляющий символ"
		fi
	done
	case "$vps_host" in *://*|*/*) die "vps_host должен содержать IP или домен без http(s):// и пути" ;; esac

	if [ "$stdout" = "1" ]; then
		xray_config_dir="${TMPDIR:-/tmp}"
	else
		xray_config_dir="$(dirname "$xray_config")"
		mkdir -p "$xray_config_dir" || return 1
	fi
	temp_dir="$(mktemp -d "$xray_config_dir/.owrt-remote-client.XXXXXX")" || return 1
	# Xray detects JSON by extension; keep the candidate private and on the
	# same filesystem as the destination so the final rename is atomic.
	out="$temp_dir/config.json"
	cat >"$out" <<EOF
{
  "log": {
    "access": "none",
    "error": "",
    "loglevel": "warning"
  },
  "inbounds": [],
  "outbounds": [
    {
      "tag": "router-admin",
      "protocol": "freedom",
      "settings": {
        "redirect": "$(json_escape "$admin_host"):$admin_port"
      }
    },
    {
      "tag": "router-ssh",
      "protocol": "freedom",
      "settings": {
        "redirect": "$(json_escape "$ssh_host"):$ssh_port"
      }
    },
    {
      "tag": "vps-interconn",
      "protocol": "vless",
      "settings": {
        "address": "$(json_escape "$vps_host")",
        "port": $vps_port,
        "id": "$(json_escape "$uuid")",
        "encryption": "$(json_escape "$encryption")",
        "flow": "$(json_escape "$flow")",
        "reverse": {
          "tag": "$(json_escape "$reverse_tag")"
        }
      },
      "streamSettings": {
        "network": "tcp",
        "security": "none"$wan_sockopt
      }
    },
    {
      "tag": "vps-ssh-interconn",
      "protocol": "vless",
      "settings": {
        "address": "$(json_escape "$vps_host")",
        "port": $vps_port,
        "id": "$(json_escape "$ssh_uuid")",
        "encryption": "$(json_escape "$encryption")",
        "flow": "$(json_escape "$flow")",
        "reverse": {
          "tag": "$(json_escape "$ssh_reverse_tag")"
        }
      },
      "streamSettings": {
        "network": "tcp",
        "security": "none"$wan_sockopt
      }
    }
  ],
  "routing": {
    "rules": [
      {
        "type": "field",
        "inboundTag": [
          "$(json_escape "$reverse_tag")"
        ],
        "outboundTag": "router-admin"
      },
      {
        "type": "field",
        "inboundTag": [
          "$(json_escape "$ssh_reverse_tag")"
        ],
        "outboundTag": "router-ssh"
      }
    ]
  },
  "remarks": "OpenWrt Remote client for $(json_escape "$router_id")"
}
EOF
	rc=$?
	[ "$rc" = 0 ] || return "$rc"
	chmod 0600 "$out" || return 1

	if [ "$stdout" = "1" ]; then
		cat "$out"
		return
	fi

	ensure_xray_available >&2 || return 1
	validate_xray_config "$out" || return $?
	mv -f "$out" "$xray_config" || return 1
	printf '%s\n' "$xray_config"
)

run_xray() {
	local enabled xray_bin xray_config
	enabled="$(uci_get enabled 0)"
	truthy "$enabled" || die "сервис выключен: включи option enabled '1'"

	ensure_xray_available
	xray_bin="$(xray_bin_path)"
	xray_config="$(render_client_config)" || die "не удалось создать конфигурацию Xray"
	[ -n "$xray_config" ] && [ -s "$xray_config" ] || die "конфигурация Xray отсутствует или пуста"
	[ -x "$xray_bin" ] || die "xray не найден или не исполняемый: $xray_bin"

	if "$xray_bin" help 2>/dev/null | grep -q 'run'; then
		exec "$xray_bin" run -config "$xray_config"
	fi
	exec "$xray_bin" -config "$xray_config"
}

heartbeat_json() {
	local router_id router_name role public_url hub_url xray_state service_state ssh_state event heartbeat_interval
	event="${1:-}"
	router_id="$(safe_id "$(uci_get router_id main)")"
	router_name="$(uci_get router_name "$router_id")"
	role="$(uci_get role node)"
	public_url="$(uci_get public_url '')"
	hub_url="$(uci_get hub_url '')"
	heartbeat_interval="$(safe_num "$(uci_get heartbeat_interval 30)" 30)"
	[ "$heartbeat_interval" -lt 10 ] && heartbeat_interval=10

	if xray_running; then
		xray_state="running"
	else
		xray_state="stopped"
	fi
	if service_enabled; then
		service_state="enabled"
	else
		service_state="disabled"
	fi
	if ssh_running; then
		ssh_state="running"
	else
		ssh_state="stopped"
	fi

	cat <<EOF
{
  "id": $(json_string "$router_id"),
  "name": $(json_string "$router_name"),
  "role": $(json_string "$role"),
  "model": $(json_string "$(host_model)"),
  "board": $(json_string "$(board_name)"),
  "release": $(json_string "$(release_text)"),
  "hostname": $(json_string "$(hostname 2>/dev/null || printf openwrt)"),
  "public_url": $(json_string "$public_url"),
  "admin_host": $(json_string "$(uci_get admin_host 127.0.0.1)"),
  "admin_port": $(safe_num "$(uci_get admin_port 80)" 80),
  "ssh_host": $(json_string "$(uci_get ssh_host 127.0.0.1)"),
  "ssh_port": $(safe_num "$(uci_get ssh_port 22)" 22),
  "hub_url": $(json_string "$hub_url"),
  "vps_host": $(json_string "$(uci_get vps_host '')"),
  "vps_host_mode": $(json_string "$(vps_host_mode)"),
  "wan_direct": $(json_string "$(uci_get wan_direct 0)"),
  "heartbeat_interval": $heartbeat_interval,
  "uptime": $(safe_num "$(uptime_seconds)" 0),
  "load": $(json_string "$(load_text)"),
  "memory": $(json_string "$(memory_text)"),
  "flash": $(json_string "$(flash_text)"),
  "temperature": $(json_string "$(temperature_text)"),
  "xray": $(json_string "$xray_state"),
  "ssh": $(json_string "$ssh_state"),
  "event": $(json_string "$event"),
  "service": $(json_string "$service_state")
}
EOF
}

remote_clock_ms() {
	LC_ALL=C awk '{ printf "%.0f", $1 * 1000; exit }' /proc/uptime 2>/dev/null || date +%s000
}

remote_url_origin() {
	# Return only a validated origin, never userinfo, path, query or fragment.
	printf '%s\n' "$1" | LC_ALL=C awk '
		NR != 1 { bad=1 }
		NR == 1 {
			if ($0 ~ /[\001-\040\177]/ || $0 !~ /^https?:\/\//) { bad=1; next }
			scheme=$0; sub(/:.*/, "", scheme)
			authority=$0; sub(/^https?:\/\//, "", authority); sub(/[\/?#].*/, "", authority)
			if (authority ~ /@/) { bad=1; next }
			port=(scheme == "https" ? 443 : 80)
			if (authority ~ /^\[[0-9a-fA-F:]+\](:[0-9]+)?$/) {
				host=authority; sub(/\].*/, "]", host)
				if (authority ~ /\]:/) { port=authority; sub(/^.*\]:/, "", port) }
			} else if (authority ~ /^[a-zA-Z0-9_.-]+(:[0-9]+)?$/) {
				host=authority; sub(/:.*/, "", host)
				if (authority ~ /:/) { port=authority; sub(/^.*:/, "", port) }
			} else { bad=1; next }
			if (port + 0 < 1 || port + 0 > 65535) { bad=1; next }
		}
		END { if (bad || !host) exit 1; printf "%s://%s:%d", scheme, tolower(host), port + 0 }
	'
}

remote_curl_metrics() {
	[ -n "${OWRT_REMOTE_HTTP_METRICS:-}" ] || return 0
	# Parse numeric fields only. redirect_url may contain secrets and is excluded.
	LC_ALL=C awk -v secure="$2" -v resolver="$3" -v hop="$4" -v wan_dns="${5:-}" -v source="${6:-curl}" '
		NF >= 6 && $1 ~ /^[0-9][0-9][0-9]$/ {
			for (i=2; i<=6; i++) if ($i !~ /^[0-9]+(\.[0-9]+)?$/) exit
			dns=sprintf("%.1f", $2*1000); tcp=($3>0 ? sprintf("%.1f", ($3>$2 ? ($3-$2)*1000 : 0)) : "incomplete")
			if (source != "curl") dns=(wan_dns ~ /^[0-9]+$/ ? sprintf("%.1f", wan_dns+0) : "n/a")
			if (source !~ /^(curl|lookup|cache|literal|pinned|pre_resolved)$/) source="pre_resolved"
			tls=(secure == "https" ? ($4>0 ? sprintf("%.1f", ($4>$3 ? ($4-$3)*1000 : 0)) : "incomplete") : "n/a")
			printf "tool=curl HTTP=%s DNS_ms=%s TCP_ms=%s TLS_ms=%s TTFB_ms=%.1f total_ms=%.1f WAN_resolve_ms=%d hop=%d DNS_source=%s\n", $1, dns, tcp, tls, $5*1000, $6*1000, resolver, hop, source
			exit
		}' "$1" >>"$OWRT_REMOTE_HTTP_METRICS"
}

remote_curl_post() (
	local url token file mode dir rc hop origin next_origin redirect code dns tcp tls first total target device resolve started remaining resolver_started resolver_ms dns_ms dns_source OWRT_REMOTE_DNS_STATS_FILE
	url="$1"; token="$2"; file="$3"; mode="${4:-normal}"
	origin="$(remote_url_origin "$url")" || return 3
	dir="$(mktemp -d "${TMPDIR:-/tmp}/owrt-remote-http.XXXXXX")" || return 1
	chmod 700 "$dir"
	trap 'rm -f "$dir/body" "$dir/stats" "$dir/error" "$dir/dns"; rmdir "$dir" 2>/dev/null || true' EXIT
	trap 'exit 1' INT TERM
	started="$(remote_clock_ms)"; hop=0
	while :; do
		resolver_ms=0; dns_ms=''; dns_source=curl
		set -- -q -fsS --connect-timeout 4 --noproxy '*' --proto '=http,https'
		if [ "$mode" = wan ]; then
			OWRT_REMOTE_DNS_STATS_FILE="$dir/dns"; : >"$dir/dns"
			dns_source=pre_resolved
			resolver_started="$(remote_clock_ms)"
			target="$(wan_http_target "$url")" || return 1
			resolver_ms=$(( $(remote_clock_ms) - resolver_started ))
			read -r dns_ms dns_source <"$dir/dns" || true
			device="${target%%|*}"; resolve="${target#*|}"
			set -- "$@" --interface "$device" --resolve "$resolve"
		fi
		remaining=$((10000 - $(remote_clock_ms) + started))
		[ "$remaining" -gt 0 ] || return 28
		remaining="$(LC_ALL=C awk -v value="$remaining" 'BEGIN { printf "%.3f", value/1000 }')"
		rc=0
		# Each permitted redirect is a separate authenticated POST. curl -L
		# drops Bearer auth on an origin change, including HTTP -> HTTPS.
		curl "$@" --max-time "$remaining" -o "$dir/body" \
			-w '%{http_code} %{time_namelookup} %{time_connect} %{time_appconnect} %{time_starttransfer} %{time_total} %{redirect_url}\n' \
			-H "Authorization: Bearer $token" -H 'Content-Type: application/json' \
			--data-binary "@$file" "$url" >"$dir/stats" 2>"$dir/error" || rc=$?
		remote_curl_metrics "$dir/stats" "${url%%:*}" "$resolver_ms" "$hop" "$dns_ms" "$dns_source"
		if [ "$rc" != 0 ]; then cat "$dir/error" >&2; return "$rc"; fi
		code=''; redirect=''
		read -r code dns tcp tls first total redirect <"$dir/stats" || true
		redirect="${redirect%"$(printf '\r')"}"
		case "$code" in
			301|302|303|307|308)
				[ -n "$redirect" ] && [ "$hop" -lt 3 ] || return 47
				next_origin="$(remote_url_origin "$redirect")" || return 47
				# Send credentials only within the same origin or to HTTPS on
				# the very same host. Never trust arbitrary redirect destinations.
				if [ "$origin" != "$next_origin" ]; then
					case "$origin|$next_origin" in
						http://*'|'https://*)
							# Compare hosts independently of the two ports.
							target="${next_origin%:*}"
							[ "${origin%:*}" = "http://${target#https://}" ] || return 47
							;;
						*) return 47 ;;
					esac
				fi
				url="$redirect"; origin="$next_origin"; hop=$((hop+1))
				;;
			*) [ ! -f "$dir/body" ] || cat "$dir/body"; return 0 ;;
		esac
	done
)

post_json() (
	local url token file
	url="$1"
	token="$2"
	file="$3"
	# uclient treats an empty *_proxy env value as a proxy URL, then fails
	# to allocate its client for that empty URL. Remove variables entirely.
	unset http_proxy https_proxy HTTP_PROXY HTTPS_PROXY ALL_PROXY all_proxy
	if truthy "$(uci_get wan_direct 0)"; then
		wan_post_json "$url" "$token" "$file"
		return
	fi

	if command -v curl >/dev/null 2>&1; then
		remote_curl_post "$url" "$token" "$file"
		return
	fi
	[ -z "${OWRT_REMOTE_HTTP_METRICS:-}" ] || printf 'tool=uclient/wget DNS_ms=n/a TCP_ms=n/a TLS_ms=n/a\n' >>"$OWRT_REMOTE_HTTP_METRICS"
	if command -v wget >/dev/null 2>&1; then
		wget -q -T 10 -O - \
			--header="Authorization: Bearer $token" \
			--header="Content-Type: application/json" \
			--post-file="$file" "$url"
		return
	fi
	if command -v uclient-fetch >/dev/null 2>&1; then
		uclient-fetch -q -T 10 -O - \
			--header="Authorization: Bearer $token" \
			--header="Content-Type: application/json" \
			--post-file="$file" "$url"
		return
	fi
	die "для heartbeat нужен uclient-fetch, wget или curl"
)

log_post_json_bounded() (
	# Also bounds remote_curl_post's private response body. The subshell limit
	# cannot affect heartbeat/Xray. POSIX -f uses 512-byte blocks (32 KiB here).
	ulimit -f 64 || exit 1
	post_json "$1" "$2" "$3"
)

global_logs_state() {
	local enabled xray
	enabled=false; xray=stopped
	truthy "$(uci_get enabled 0)" && enabled=true
	xray_running && xray=running
	printf '{"enabled":%s,"xray":"%s"}' "$enabled" "$xray"
}

sync_global_logs() (
	local helper router_id file response endpoint base token journal offset clear_token rc sync_lock owner attempt runtime TMPDIR stale
	helper="${OWRT_REMOTE_LOG_HELPER:-/usr/lib/owrt-remote/logs.sh}"
	[ -r "$helper" ] || return 0
	token="$(uci_get hub_token '')"; [ -n "$token" ] || return 0
	# The journal is independent of Remote's enabled flag and Xray lifecycle.
	sh "$helper" check || return 1
	runtime="${OWRT_REMOTE_LOG_RUNTIME:-/tmp/owrt-remote-log-runtime}"
	# Older helpers create only their journal directory. An independent agent
	# update still needs a private runtime directory for delivery and its lock.
	(umask 077; mkdir -p "$runtime") || return 1
	sync_lock="$runtime/sync-lock"
	if ! mkdir "$sync_lock" 2>/dev/null; then
		# Give a sender time to write its PID, then recover an abandoned lock.
		for attempt in 1 2 3 4 5 6 7 8 9 10; do
			owner="$(cat "$sync_lock/pid" 2>/dev/null)"
			case "$owner" in ''|*[!0-9]*) sleep 0.1 ;; *) break ;; esac
		done
		owner="$(cat "$sync_lock/pid" 2>/dev/null)"
		case "$owner" in ''|*[!0-9]*) ;; *) kill -0 "$owner" 2>/dev/null && return 0 ;; esac
		if ! mkdir "$sync_lock/reap" 2>/dev/null; then
			owner="$(cat "$sync_lock/reap/pid" 2>/dev/null)"
			case "$owner" in ''|*[!0-9]*) sleep 1 ;; *) kill -0 "$owner" 2>/dev/null && return 0 ;; esac
			rm -f "$sync_lock/reap/pid"; rmdir "$sync_lock/reap" 2>/dev/null || return 0
			return 0
		fi
		printf '%s\n' "$$" >"$sync_lock/reap/pid"
		owner="$(cat "$sync_lock/pid" 2>/dev/null)"
		case "$owner" in ''|*[!0-9]*) ;; *) if kill -0 "$owner" 2>/dev/null; then rm -f "$sync_lock/reap/pid"; rmdir "$sync_lock/reap"; return 0; fi ;; esac
		rm -f "$sync_lock/pid"
		rm -f "$sync_lock/reap/pid"
		rmdir "$sync_lock/reap" || return 0
		rmdir "$sync_lock" 2>/dev/null || return 0
		mkdir "$sync_lock" 2>/dev/null || return 0
	fi
	# ash keeps $$ unchanged inside a subshell. Store the actual sender PID so
	# a killed sender is recoverable while its parent service is still alive.
	if read -r owner attempt </proc/self/stat 2>/dev/null; then
		printf '%s\n' "$owner" >"$sync_lock/pid"
	else
		printf '%s\n' "$$" >"$sync_lock/pid"
	fi
	file=''; response=''
	trap 'rm -f "$file" "$response" "$sync_lock/pid"; rmdir "$sync_lock" 2>/dev/null || true' EXIT
	trap 'exit 1' INT TERM
	# A killed sender can leave one bounded payload; reclaim it under the singleton.
	rm -f "$runtime"/sync.*
	# Give this sender its own temporary HTTP directory; never sweep heartbeat's
	# files. Clean a curl subprocess killed before its EXIT trap could run.
	TMPDIR="$runtime/http"; export TMPDIR
	mkdir -p "$TMPDIR" || return 1
	for stale in "$TMPDIR"/owrt-remote-http.*; do
		[ -d "$stale" ] || continue
		rm -f "$stale/body" "$stale/stats" "$stale/error" "$stale/dns"
		rmdir "$stale" 2>/dev/null || true
	done
	if truthy "$(uci_get wan_direct 0)" && [ ! -s "$WAN_STATE/active-interface" ]; then wan_prepare || return 1; fi
	router_id="$(safe_id "$(uci_get router_id main)")"
	# Export at most 16 KiB of raw records directly into a bounded request file.
	# Neither the Flash journal nor a base64 packet is copied into a shell variable.
	umask 077
	file="$runtime/sync.$$"; response="$file.response"
	{
		printf '{"id":%s,"batch":' "$(json_string "$router_id")"
		sh "$helper" export || exit 1
		printf ',"state":%s}\n' "$(global_logs_state)"
	} >"$file" || return 1
	for endpoint in $(heartbeat_candidate_endpoints); do
		base="$(heartbeat_base_from_endpoint "$endpoint")"
		if log_post_json_bounded "$base/api/router-logs" "$token" "$file" >"$response" 2>/dev/null &&
			grep -Eq '"ok"[[:space:]]*:[[:space:]]*true' "$response"; then
			journal="$(jsonfilter -i "$response" -e '@.journal_id' 2>/dev/null)"
			offset="$(jsonfilter -i "$response" -e '@.offset' 2>/dev/null)"
			clear_token="$(jsonfilter -i "$response" -e '@.clear_request' 2>/dev/null)"
			sh "$helper" ack "$journal" "$offset" "$clear_token"
			rc=$?
			rm -f "$file" "$response"
			rm -f "$sync_lock/pid"; rmdir "$sync_lock" 2>/dev/null || true
			trap - EXIT INT TERM
			return "$rc"
		fi
	done
	rm -f "$file" "$response"
	rm -f "$sync_lock/pid"; rmdir "$sync_lock" 2>/dev/null || true
	trap - EXIT INT TERM
	return 1
)

heartbeat_base_from_endpoint() {
	printf '%s' "${1%/api/heartbeat}"
}

heartbeat_emit_endpoint() {
	local base marker
	base="$(normalize_url_base "$1")"
	[ -n "$base" ] || return 0
	case "${HEARTBEAT_REQUIRE_HTTPS:-0}|$base" in 1'|'http://*) return 0 ;; esac
	marker="|$base|"
	case "${HEARTBEAT_ENDPOINT_SEEN:-}" in
		*"$marker"*) return 0 ;;
	esac
	HEARTBEAT_ENDPOINT_SEEN="${HEARTBEAT_ENDPOINT_SEEN:-}$marker"
	printf '%s/api/heartbeat\n' "$base"
}

heartbeat_candidate_endpoints() {
	local hub_url public_url vps_host HEARTBEAT_REQUIRE_HTTPS
	HEARTBEAT_ENDPOINT_SEEN='|'
	hub_url="$(uci_get hub_url '')"
	public_url="$(uci_get public_url '')"
	vps_host="$(uci_get vps_host '')"
	HEARTBEAT_REQUIRE_HTTPS=0
	case "$hub_url" in https://*) HEARTBEAT_REQUIRE_HTTPS=1 ;; esac
	heartbeat_emit_endpoint "$hub_url"
	heartbeat_emit_endpoint "$public_url"
	case "$vps_host" in
		'')
			;;
		http://*|https://*)
			heartbeat_emit_endpoint "$vps_host"
			;;
		*)
			heartbeat_emit_endpoint "https://$vps_host"
			heartbeat_emit_endpoint "http://$vps_host"
			heartbeat_emit_endpoint "http://$vps_host:8088"
			;;
	esac
}

heartbeat_set_url_if_changed() {
	local key next current ignored_file ignored
	key="$1"
	next="$2"
	case "$next" in http://?*|https://?*) ;; *) return 1 ;; esac
	current="$(uci_get "$key" '')"
	case "$current|$next" in
		https://*'|'http://*)
			ignored_file="${TMPDIR:-/tmp}/owrt-remote-$key-ignored"
			ignored="$current|$next"
			if [ "$(cat "$ignored_file" 2>/dev/null)" != "$ignored" ]; then
				log "heartbeat kept $key: current=$current proposed=$next reason=https-downgrade"
				printf '%s' "$ignored" >"$ignored_file"
			fi
			return 1
			;;
	esac
	uci_set_if_changed "$key" "$next"
}

heartbeat_apply_hub_update() {
	local response_file fallback_base next_hub_url next_public_url next_vps_host changed old_vps_host mode ignored_file ignored
	response_file="$1"
	fallback_base="$2"
	next_hub_url="$(json_extract_object_string "$response_file" hub_update hub_url)"
	next_public_url="$(json_extract_object_string "$response_file" hub_update public_url)"
	next_vps_host="$(json_extract_object_string "$response_file" hub_update vps_host)"
	old_vps_host="$(uci_get vps_host '')"
	mode="$(vps_host_mode)"
	# A fallback is a temporary transport, not a new configured Hub URL.
	if [ -z "$next_hub_url" ] && [ -z "$(uci_get hub_url '')" ]; then
		next_hub_url="$fallback_base"
	fi
	changed=0
	if heartbeat_set_url_if_changed hub_url "$next_hub_url"; then
		changed=1
	fi
	if heartbeat_set_url_if_changed public_url "$next_public_url"; then
		changed=1
	fi
	if [ "$mode" = auto ]; then
		if uci_set_if_changed vps_host "$next_vps_host"; then
			changed=1
		fi
	elif [ -n "$next_vps_host" ] && [ "$old_vps_host" != "$next_vps_host" ]; then
		ignored_file="${TMPDIR:-/tmp}/owrt-remote-vps-host-ignored"
		ignored="$old_vps_host|$next_vps_host"
		if [ "$(cat "$ignored_file" 2>/dev/null)" != "$ignored" ]; then
			log "heartbeat kept vps_host: current=$old_vps_host proposed=$next_vps_host reason=manual"
			printf '%s' "$ignored" >"$ignored_file"
		fi
	fi
	[ "$changed" = "1" ] || return 0
	uci commit "$CONFIG" >/dev/null 2>&1 || return 1
	log "heartbeat updated hub settings: hub_url=$(uci_get hub_url '') public_url=$(uci_get public_url '') vps_host=$(uci_get vps_host '')"
	if [ "$mode" = auto ] && [ -n "$next_vps_host" ] && [ "$old_vps_host" != "$next_vps_host" ]; then
		log "heartbeat updated vps_host: old=$old_vps_host new=$next_vps_host reason=hub_update mode=auto"
		# The running Xray keeps its old address until it is restarted.
		( sleep 2; /etc/init.d/owrt-remote restart >/dev/null 2>&1 ) </dev/null >/dev/null 2>&1 &
	fi
}

heartbeat_failure_reason() {
	case "$1|$2" in
		*'|'401|*'|'403) printf auth_rejected ;;
		28'|'*) printf timeout ;;
		5'|'*|6'|'*) printf dns_failed ;;
		7'|'*) printf connect_failed ;;
		35'|'*) printf tls_handshake_failed ;;
		51'|'*|58'|'*|60'|'*|77'|'*) printf tls_verification_failed ;;
		47'|'*) printf redirect_rejected ;;
		*'|'408|*'|'429|*'|'500|*'|'502|*'|'503|*'|'504) printf server_temporary ;;
		18'|'*|52'|'*|55'|'*|56'|'*|92'|'*) printf connection_interrupted ;;
		0'|'*) printf invalid_heartbeat_response ;;
		*) printf request_failed ;;
	esac
}

heartbeat_diagnostics() {
	local state
	state="${TMPDIR:-/tmp}/owrt-remote-heartbeat-last"
	printf 'Последний Heartbeat (только безопасные поля):\n'
	if [ -r "$state" ]; then cat "$state"; else printf 'Замеров пока нет; выполни owrt-remote heartbeat.\n'; fi
}

send_heartbeat() {
	local hub_url token endpoint tmp response event used fallback_base errors rc dir metrics http attempt max_attempts reason previous previous_reason safe_endpoint elapsed started diagnostic
	(
	event="${1:-}"
	hub_url="$(uci_get hub_url '')"
	token="$(uci_get hub_token '')"
	[ -n "$hub_url" ] || die "hub_url пустой"
	[ -n "$token" ] || die "hub_token пустой"
	if truthy "$(uci_get wan_direct 0)"; then
		command -v wan_prepare >/dev/null 2>&1 || die "WAN helper missing: $WAN_HELPER"
		wan_prepare || { log 'Heartbeat: не удалось подготовить прямой WAN'; return 1; }
		wan_reconcile_xray
	fi

	dir="$(mktemp -d "${TMPDIR:-/tmp}/owrt-remote-heartbeat.XXXXXX")" || return 1
	chmod 700 "$dir"
	trap 'rm -f "$dir/payload" "$dir/response" "$dir/response.error" "$dir/metrics" "$dir/last"; rmdir "$dir" 2>/dev/null || true' EXIT
	trap 'exit 1' INT TERM
	tmp="$dir/payload"; response="$dir/response"
	errors="$response.error"
	metrics="$dir/metrics"
	export OWRT_REMOTE_HTTP_METRICS="$metrics"
	heartbeat_json "$event" >"$tmp"
	used=0
	previous=''; previous_reason=''
	for endpoint in $(heartbeat_candidate_endpoints); do
		used=1
		safe_endpoint="$(remote_url_origin "$endpoint")" || { log 'Heartbeat: ошибка; reason=invalid_endpoint'; continue; }
		if [ -n "$previous" ]; then
			log "Heartbeat: fallback; from=$previous; to=$safe_endpoint; reason=$previous_reason; предыдущие попытки исчерпаны"
		fi
		attempt=1; max_attempts=1
		case "$endpoint" in https://*) max_attempts=2 ;; esac
		while [ "$attempt" -le "$max_attempts" ]; do
			rc=0; : >"$metrics"; started="$(remote_clock_ms)"
			post_json "$endpoint" "$token" "$tmp" >"$response" 2>"$errors" || rc=$?
			elapsed=$(( $(remote_clock_ms) - started ))
			http="$(sed -n 's/.*HTTP=\([0-9][0-9][0-9]\).*/\1/p' "$metrics" | tail -n 1)"
			reason="$(heartbeat_failure_reason "$rc" "$http")"
			if grep -Fq 'Failed to allocate uclient context' "$errors"; then reason=http_client_context_failed; fi
			diagnostic="endpoint=$safe_endpoint; attempt=$attempt/$max_attempts; rc=$rc; reason=$reason; elapsed_ms=$elapsed; $(tail -n 1 "$metrics")"
			printf '%s\n' "$diagnostic" >"$dir/last"
			mv -f "$dir/last" "${TMPDIR:-/tmp}/owrt-remote-heartbeat-last"
			if [ "$rc" = 0 ] && grep -Eq '"ok"[[:space:]]*:[[:space:]]*true' "$response"; then
				fallback_base="$(heartbeat_base_from_endpoint "$endpoint")"
				if ! heartbeat_apply_hub_update "$response" "$fallback_base"; then
					log 'Heartbeat: Hub ответил, но обновление настроек не применилось'
					return 1
				fi
				# Stable OK messages remain deduplicated by the RAM journal;
				# fresh timings are available separately in network-diagnostics.
				printf '%s\n' "endpoint=$safe_endpoint; attempt=$attempt/$max_attempts; rc=0; reason=ok; elapsed_ms=$elapsed; $(tail -n 1 "$metrics")" >"$dir/last"
				mv -f "$dir/last" "${TMPDIR:-/tmp}/owrt-remote-heartbeat-last"
				cat "$response"
				log "Heartbeat: OK; Hub=$safe_endpoint; WAN_direct=$(uci_get wan_direct 0); WAN_active=$(cat "$WAN_STATE/active-interface" 2>/dev/null)"
				return 0
			fi
			# Do not log curl stderr or response bodies: either may echo secrets.
			log "Heartbeat: ошибка; $diagnostic"
			[ "$reason" != auth_rejected ] || return 1
			case "$reason" in timeout|dns_failed|connect_failed|tls_handshake_failed|server_temporary|connection_interrupted)
				if [ "$attempt" -lt "$max_attempts" ]; then
					attempt=$((attempt+1))
					log "Heartbeat: retry HTTPS; endpoint=$safe_endpoint; attempt=$attempt/$max_attempts; reason=$reason; delay=1s"
					sleep 1
					continue
				fi ;;
			esac
			break
		done
		previous="$safe_endpoint"; previous_reason="$reason"
	done
	[ "$used" = "1" ] || die "hub_url/public_url/vps_host пустые"
	case "$hub_url" in https://*) log 'Heartbeat: fallback остановлен; reason=https_required; автоматический переход на HTTP отключён' ;; esac
	return 1
	)
}

wan_reconcile_xray() {
	local config bound device
	truthy "$(uci_get enabled 0)" || return 0
	device="$(wan_device)" || return 1
	if ! xray_running; then
		wan_recover_xray
		return $?
	fi
	config="$(uci_get xray_config /etc/xray/owrt-remote-client.json)"
	[ -r "$config" ] || return 0
	bound="$(jsonfilter -i "$config" -e '@.outbounds[@.tag="vps-interconn"].streamSettings.sockopt.interface' 2>/dev/null)"
	[ "$bound" != "$device" ] || return 0
	wan_reconnect_xray "$bound" "$device"
}

wan_recover_xray() {
	local lock owner rest state running heartbeat now last attempt
	(
	umask 077
	lock="${TMPDIR:-/tmp}/owrt-remote-xray-recovery"
	# A stopped procd instance cannot be revived by sending it a signal.
	# Serialize re-registration; do not interrupt the healthy heartbeat instance.
	attempt=0
	while ! mkdir "$lock" 2>/dev/null; do
		owner="$(cat "$lock/pid" 2>/dev/null)"
		case "$owner" in
			''|*[!0-9]*)
				# Allow a new worker to record its PID before reaping an empty lock.
				if [ "$attempt" -lt 10 ]; then attempt=$((attempt+1)); sleep 0.1; continue; fi ;;
			*) kill -0 "$owner" 2>/dev/null && return 0 ;;
		esac
		wan_recovery_reap "$lock" "$attempt"
		attempt=$((attempt+1)); [ "$attempt" -lt 20 ] || return 0
	done
	trap 'rm -f "$lock/pid"; rmdir "$lock" 2>/dev/null || true' EXIT
	trap 'exit 1' INT TERM
	owner=$$
	# ash keeps $$ unchanged in a subshell; /proc/self identifies this worker.
	if [ -r /proc/self/stat ]; then read -r owner rest </proc/self/stat || owner=$$; fi
	printf '%s\n' "$owner" >"$lock/pid"
	truthy "$(uci_get enabled 0)" || return 0
	wan_select_interface >/dev/null || return 0
	xray_running && return 0
	state="$(ubus call service list '{"name":"owrt-remote"}' 2>/dev/null)" || return 1
	running="$(printf '%s' "$state" | jsonfilter -e '@["owrt-remote"].instances.xray.running' 2>/dev/null)"
	[ "$running" != true ] || return 0
	heartbeat="$(printf '%s' "$state" | jsonfilter -e '@["owrt-remote"].instances.heartbeat.running' 2>/dev/null)"
	# Respect an explicit service stop, including stops made outside the panel.
	[ "$heartbeat" = true ] || return 0
	now="$(uptime_seconds)"
	now="$(safe_num "$now" 0)"
	[ "$now" -gt 0 ] || now="$(safe_num "$(date +%s 2>/dev/null)" 0)"
	last="$(safe_num "$(cat "${TMPDIR:-/tmp}/owrt-remote-xray-recovery.last" 2>/dev/null)" 0)"
	if [ "$last" -gt 0 ] && [ "$now" -ge "$last" ] && [ $((now-last)) -lt 300 ]; then return 0; fi
	printf '%s\n' "$now" >"${TMPDIR:-/tmp}/owrt-remote-xray-recovery.last"
	log 'Xray: WAN доступен, туннель остановлен; запрошен повторный запуск отдельного instance'
	ubus call service add '{"name":"owrt-remote","instances":{"xray":{"command":["/usr/sbin/owrt-remote","run"],"env":{"OWRT_REMOTE_SERVICE_LOG":"1"},"respawn":["3600","5","5"],"stdout":true,"stderr":true}}}' >/dev/null || {
		log 'ОШИБКА: procd не принял запрос восстановления Xray; Heartbeat продолжает работать'
		return 1
	}
	)
}

wan_recovery_reap() {
	local owner reaper rest
	# The reaper itself must be serialized and recoverable after SIGKILL.
	if ! mkdir "$1/reap" 2>/dev/null; then
		reaper="$(cat "$1/reap/pid" 2>/dev/null)"
		case "$reaper" in
			''|*[!0-9]*) [ "$2" -ge 15 ] || return 0 ;;
			*) kill -0 "$reaper" 2>/dev/null && return 0 ;;
		esac
		rm -f "$1/reap/pid"; rmdir "$1/reap" 2>/dev/null || return 0
		return 0
	fi
	reaper=$$
	if [ -r /proc/self/stat ]; then read -r reaper rest </proc/self/stat || reaper=$$; fi
	printf '%s\n' "$reaper" >"$1/reap/pid"
	owner="$(cat "$1/pid" 2>/dev/null)"
	case "$owner" in
		''|*[!0-9]*) ;;
		*) if kill -0 "$owner" 2>/dev/null; then rm -f "$1/reap/pid"; rmdir "$1/reap"; return 0; fi ;;
	esac
	rm -f "$1/pid" "$1/reap/pid"
	rmdir "$1/reap" 2>/dev/null && rmdir "$1" 2>/dev/null || true
}

wan_reconnect_xray() {
	local restart_lock owner
	restart_lock="${TMPDIR:-/tmp}/owrt-remote-wan-restart"
	# A concurrent heartbeat must not enqueue another restart of the same tunnel.
	if ! mkdir "$restart_lock" 2>/dev/null; then
		owner="$(cat "$restart_lock/pid" 2>/dev/null)"
		case "$owner" in ''|*[!0-9]*) return 0 ;; esac
		kill -0 "$owner" 2>/dev/null && return 0
		rm -f "$restart_lock/pid"
		rmdir "$restart_lock" 2>/dev/null || return 0
		mkdir "$restart_lock" 2>/dev/null || return 0
	fi
	log "Reconnecting reverse tunnel after WAN change: $1 -> $2"
	(
		trap 'rm -f "$restart_lock/pid"; rmdir "$restart_lock" 2>/dev/null || true' EXIT
		trap 'exit 1' INT TERM
		sleep 1
		/etc/init.d/owrt-remote restart >/dev/null 2>&1 || log 'WAN failover tunnel restart failed'
	) </dev/null >/dev/null 2>&1 &
	printf '%s' "$!" >"$restart_lock/pid"
}

heartbeat_mark_ok() {
	rm -f "${TMPDIR:-/tmp}/owrt-remote-heartbeat.fail"
}

heartbeat_self_heal() {
	local fail_file restart_file fails now last_restart threshold cooldown
	fail_file="${TMPDIR:-/tmp}/owrt-remote-heartbeat.fail"
	restart_file="${TMPDIR:-/tmp}/owrt-remote-heartbeat.restart"
	threshold=3
	cooldown=300
	now="$(date +%s 2>/dev/null || echo 0)"
	fails=0
	last_restart=0

	[ -f "$fail_file" ] && fails="$(cat "$fail_file" 2>/dev/null || echo 0)"
	fails="$(safe_num "$fails" 0)"
	fails=$((fails + 1))
	printf '%s\n' "$fails" >"$fail_file"

	[ "$fails" -lt "$threshold" ] && return 0
	if truthy "$(uci_get wan_direct 0)" && ! wan_select_interface >/dev/null; then
		log 'Heartbeat: перезапуск отложен; ни один выбранный WAN не имеет физического IPv4 default route'
		return 0
	fi
	if active_ssh_session; then
		log "heartbeat failed ${threshold} times, restart postponed because SSH session is active"
		return 0
	fi
	[ -f "$restart_file" ] && last_restart="$(cat "$restart_file" 2>/dev/null || echo 0)"
	last_restart="$(safe_num "$last_restart" 0)"
	[ $((now - last_restart)) -lt "$cooldown" ] && return 0

	printf '%s\n' "$now" >"$restart_file"
	rm -f "$fail_file"
	log "heartbeat failed ${threshold} times in a row, restarting owrt-remote"
	(
		sleep 1
		/etc/init.d/owrt-remote restart >/dev/null 2>&1
	) &
}

heartbeat_loop() {
	local interval
	interval="$(safe_num "$(uci_get heartbeat_interval 30)" 30)"
	[ "$interval" -lt 10 ] && interval=10
	log "Heartbeat: цикл запущен; интервал=${interval}s"
	while :; do
		if send_heartbeat >/dev/null 2>&1; then
			heartbeat_mark_ok
		else
			heartbeat_self_heal
		fi
		sleep "$interval"
	done
}

status() {
	printf 'router_id: %s\n' "$(uci_get router_id main)"
	printf 'router_name: %s\n' "$(uci_get router_name '')"
	printf 'enabled: %s\n' "$(uci_get enabled 0)"
	printf 'hub_url: %s\n' "$(uci_get hub_url '')"
	printf 'vps_host: %s\n' "$(uci_get vps_host '')"
	printf 'vps_host_mode: %s\n' "$(vps_host_mode)"
	printf 'wan_direct: %s\n' "$(uci_get wan_direct 0)"
	printf 'wan_interfaces: %s\n' "$(uci_get wan_interface wan)"
	printf 'wan_active_interface: %s\n' "$(cat "$WAN_STATE/active-interface" 2>/dev/null)"
	printf 'vps_port: %s\n' "$(uci_get vps_port 8443)"
	printf 'xray_bin: %s\n' "$(xray_bin_path)"
	printf 'xray_config: %s\n' "$(uci_get xray_config /etc/xray/owrt-remote-client.json)"
	if xray_running; then
		printf 'xray_state: running\n'
	else
		printf 'xray_state: stopped\n'
	fi
	if service_enabled; then
		printf 'service: enabled\n'
	else
		printf 'service: disabled\n'
	fi
}

doctor() {
	local ok xray_bin
	ok=1
	ensure_xray_available
	xray_bin="$(xray_bin_path)"

	[ -x "$xray_bin" ] || {
		log "нет Xray: $xray_bin"
		ok=0
	}
	[ -n "$(uci_get hub_url '')" ] || {
		log "hub_url пустой"
		ok=0
	}
	[ -n "$(uci_get hub_token '')" ] || {
		log "hub_token пустой"
		ok=0
	}
	[ -n "$(uci_get vps_host '')" ] || {
		log "vps_host пустой"
		ok=0
	}
	[ -n "$(uci_get vless_uuid '')" ] || {
		log "vless_uuid пустой"
		ok=0
	}

	if [ "$ok" = "1" ]; then
		printf '%s\n' "OK: конфиг выглядит готовым"
	else
		exit 1
	fi
}

# Keep the executable in RAM, but retain one compressed, verified boot copy.
# Cache writes happen only when the executable changes, never per Heartbeat.
xray_runtime_dir() { printf '%s' "${OWRT_REMOTE_XRAY_RUNTIME:-/tmp/owrt-xray}"; }
xray_process_start() { awk '{print $22}' "/proc/$1/stat" 2>/dev/null; }
xray_process_identity() {
	local rest
	read -r XRAY_SELF_PID rest </proc/self/stat || return 1
	XRAY_SELF_BIRTH="$(xray_process_start "$XRAY_SELF_PID")"
	[ -n "$XRAY_SELF_BIRTH" ]
}
xray_bootstrap_lock() {
	local owner attempt current saved
	XRAY_LOCK="$(xray_runtime_dir)/bootstrap-lock"
	mkdir -p "$(xray_runtime_dir)" || return 1
	xray_process_identity || return 1
	attempt=0
	while ! mkdir "$XRAY_LOCK" 2>/dev/null; do
		[ -d "$XRAY_LOCK" ] || return 1
		owner=''; current=''
		read -r owner current <"$XRAY_LOCK/owner" 2>/dev/null || true
		saved="$owner $current"
		case "$owner:$current" in
			*[!0-9:]*|:*|*:) current=''; [ "$attempt" -lt 5 ] || current=stale ;;
			*) [ "$(xray_process_start "$owner")" = "$current" ] || current=stale ;;
		esac
		if [ "$current" = stale ]; then xray_bootstrap_reap "$saved" "$attempt"; fi
		attempt=$((attempt+1)); [ "$attempt" -lt 150 ] || { log 'Xray: загрузчик уже работает; повтор будет выполнен позже'; return 1; }
		sleep 1
	done
	printf '%s %s\n' "$XRAY_SELF_PID" "$XRAY_SELF_BIRTH" >"$XRAY_LOCK/owner" || { rmdir "$XRAY_LOCK" 2>/dev/null || true; return 1; }
}
xray_bootstrap_reap() {
	local owner current saved
	saved="$1"
	if mkdir "$XRAY_LOCK/reap" 2>/dev/null; then
		printf '%s %s\n' "$XRAY_SELF_PID" "$XRAY_SELF_BIRTH" >"$XRAY_LOCK/reap/owner"
		# Re-read after claiming reaping: another waiter may have acquired
		# a new lock since our first observation of the dead process.
		owner=''; current=''; read -r owner current <"$XRAY_LOCK/owner" 2>/dev/null || true
		if [ "$saved" = "$owner $current" ]; then rm -f "$XRAY_LOCK/owner"; fi
		rm -f "$XRAY_LOCK/reap/owner"; rmdir "$XRAY_LOCK/reap"; rmdir "$XRAY_LOCK" 2>/dev/null || true
		return 0
	fi
	# A SIGKILL during reaping must not leave a permanent bootstrap lock.
	owner=''; current=''; read -r owner current <"$XRAY_LOCK/reap/owner" 2>/dev/null || true
	case "$owner:$current" in
		*[!0-9:]*|:*|*:) [ "$2" -ge 10 ] || return 0 ;;
		*) [ "$(xray_process_start "$owner")" != "$current" ] || return 0 ;;
	esac
	rm -f "$XRAY_LOCK/reap/owner"; rmdir "$XRAY_LOCK/reap" 2>/dev/null || true
}
xray_bootstrap_unlock() { rm -f "$XRAY_LOCK/owner"; rmdir "$XRAY_LOCK" 2>/dev/null || true; }
xray_cache_mount() {
	local path
	path="$1"
	while [ ! -e "$path" ]; do path="$(dirname "$path")"; done
	path="$(readlink -f "$path")" || return 1
	awk -v path="$path" '
		(path == $2 || index(path, $2 "/") == 1 || $2 == "/") && length($2) > best {
			best=length($2); mount=$2; fs=$3; flags=$4
		}
		END { if (best) print mount, fs, flags; else exit 1 }
	' /proc/mounts
}
xray_cache_dir() {
	local mount fs flags candidate
	read -r mount fs flags <<EOF
$(xray_cache_mount /overlay)
EOF
	if [ "$mount" = /overlay ]; then
		candidate=/overlay/owrt-remote/xray-cache
	else
		read -r mount fs flags <<EOF
$(xray_cache_mount /)
EOF
		candidate=/etc/owrt-remote/xray-cache
	fi
	case "$fs" in ubifs|jffs2|ext4|ext3|ext2|f2fs|btrfs) ;; *) return 1 ;; esac
	case ",$flags," in *,rw,*) ;; *) return 1 ;; esac
	# Existing symlinks or a nested tmpfs must not redirect this cache into RAM.
	read -r mount fs flags <<EOF
$(xray_cache_mount "$candidate")
EOF
	case "$fs" in ubifs|jffs2|ext4|ext3|ext2|f2fs|btrfs) ;; *) return 1 ;; esac
	case ",$flags," in *,rw,*) ;; *) return 1 ;; esac
	printf '%s' "$candidate"
}
xray_digest() {
	local digest
	digest="$(sha256sum "$1" 2>/dev/null)" || return 1
	digest="${digest%% *}"
	case "$digest" in ''|*[!0-9a-f]*) return 1 ;; esac
	[ "${#digest}" = 64 ] || return 1
	printf '%s' "$digest"
}
xray_cache_save() (
	# A subshell already isolates these variables (BusyBox ash rejects local here).
	bin="$1"
	[ -s "$bin" ] && [ -x "$bin" ] || return 1
	"$bin" version >/dev/null 2>&1 || return 1
	store="$(xray_cache_dir)" || { log 'Xray: постоянный кэш недоступен; после перезагрузки потребуется загрузка из сети'; return 1; }
	asset="$(xray_release_asset)" || return 1
	digest="$(xray_digest "$bin")" || return 1
	target="$store/$asset.$digest.gz"
	# An existing valid copy requires no Flash writes, including after reboot.
	if [ -s "$target" ] && gzip -t "$target" 2>/dev/null; then return 0; fi
	umask 077
	mkdir -p "$store" || return 1
	chmod 700 "$store" || return 1
	# Writers hold bootstrap-lock; only incomplete staging files are disposable.
	rm -f "$store"/.new.*
	free="$(df -Pk "$store" | awk 'NR==2 { print $4 }')"
	case "$free" in ''|*[!0-9]*) return 1 ;; esac
	# Size is measured by streaming compression, without a second RAM copy.
	size="$(gzip -c "$bin" | wc -c)"
	case "$size" in ''|*[!0-9]*) return 1 ;; esac
	if [ "$size" -le 0 ] || [ "$size" -gt 16777216 ] || [ "$free" -lt "$(( (size+1023)/1024 + 2048 ))" ]; then
		log 'Xray: недостаточно места для постоянного кэша с резервом 2 МиБ; рабочий Xray сохранён'
		return 1
	fi
	temp="$(mktemp "$store/.new.XXXXXX")" || return 1
	trap 'rm -f "$temp"' EXIT
	trap 'exit 1' INT TERM
	gzip -c "$bin" >"$temp" && gzip -t "$temp" || return 1
	[ "$(wc -c <"$temp")" -le 16777216 ] || return 1
	mv -f "$temp" "$target" || return 1
	# Once per binary update: commit the replacement before deleting the last
	# bootable copy. No Flash sync is performed by Heartbeat or normal startup.
	sync || return 1
	# Only after publishing the replacement may the previous copy be removed.
	for old in "$store"/Xray-*.zip.*.gz; do [ "$old" = "$target" ] || rm -f "$old"; done
	log "Xray: сжатая загрузочная копия сохранена на постоянном разделе; bytes=$(wc -c <"$target")"
)
xray_cache_restore() (
	store="$(xray_cache_dir)" || return 1
	asset="$(xray_release_asset)" || return 1
	dir="$(xray_runtime_dir)"; mkdir -p "$dir" || return 1
	temp="$(mktemp "$dir/.restore.XXXXXX")" || return 1
	trap 'rm -f "$temp"' EXIT
	trap 'exit 1' INT TERM
	for cache in "$store/$asset."*.gz; do
		[ -s "$cache" ] || continue
		[ "$(wc -c <"$cache")" -le 16777216 ] || continue
		digest="${cache#"$store/$asset."}"; digest="${digest%.gz}"
		case "$digest" in ''|*[!0-9a-f]*) continue ;; esac
		[ "${#digest}" = 64 ] || continue
		# Bound even an invalid compressed file; verify bytes before execution.
		gzip -t "$cache" 2>/dev/null || { log 'Xray: повреждён постоянный кэш; требуется повторная загрузка'; continue; }
		gzip -dc "$cache" | head -c 67108865 >"$temp"
		size="$(wc -c <"$temp")"
		[ "$size" -le 67108864 ] && [ "$(xray_digest "$temp")" = "$digest" ] || continue
		chmod 755 "$temp" && "$temp" version >/dev/null 2>&1 || continue
		mv -f "$temp" "$dir/xray" || return 1
		if [ "$(uci_get xray_bin '')" != "$dir/xray" ]; then
			uci set "$CONFIG.$SECTION.xray_bin=$dir/xray" && uci commit "$CONFIG" || return 1
		fi
		log 'Xray: восстановлен из постоянного кэша без загрузки из интернета'
		return 0
	done
	return 1
)

# Keep a finite wait even without BusyBox's optional timeout applet. The
# foreground poll avoids a racing/orphaned watchdog when downloads finish fast.
xray_native_fetch() (
	dst="$1"; shift
	client=''
	trap 'result=$?; [ -z "$client" ] || { kill -KILL "$client" 2>/dev/null || true; wait "$client" 2>/dev/null || true; }; [ "$result" = 0 ] || rm -f "$dst"' EXIT
	trap 'exit 1' INT TERM
	# Shells report file blocks in 512 or 1024 bytes: either limit stays <=32 MiB.
	ulimit -f 32768 || return 1
	"$@" & client=$!
	ticks=0
	while kill -0 "$client" 2>/dev/null; do
		if [ "$ticks" -ge 120 ]; then
			kill -KILL "$client" 2>/dev/null || true
			wait "$client" 2>/dev/null || true
			client=''; return 28
		fi
		sleep 1; ticks=$((ticks+1))
	done
	rc=0; wait "$client" || rc=$?; client=''
	return "$rc"
)

# Bound one complete download, including redirects. In WAN mode use the
# selected resolver on every HTTPS hop, retaining hostname verification/SNI.
fetch_file() (
	url="$1"; dst="$2"; rm -f "$dst"
	stats=''
	trap 'result=$?; rm -f "$stats"; [ "$result" = 0 ] || rm -f "$dst"' EXIT
	trap 'exit 1' INT TERM
	unset http_proxy https_proxy HTTP_PROXY HTTPS_PROXY all_proxy ALL_PROXY
	if command -v curl >/dev/null 2>&1; then
		stats="$(mktemp "${TMPDIR:-/tmp}/owrt-xray-http.XXXXXX")" || return 1
		started="$(remote_clock_ms)"; hop=0; rc=1
		while [ "$hop" -le 5 ]; do
			origin="$(remote_url_origin "$url")" || return 3
			case "$origin" in https://*) ;; *) log 'Xray: отклонена загрузка без HTTPS'; return 3 ;; esac
			set -- -q -fsS --connect-timeout 10 --noproxy '*' --proto '=https' --max-filesize 33554432
			if truthy "$(uci_get wan_direct 0)"; then
				host="${origin#https://}"; port="${host##*:}"; host="${host%:*}"
				device="$(wan_device)" || return 1
				ip="$(wan_resolve_host "$host")" || return 6
				set -- "$@" --interface "$device" --resolve "$host:$port:$ip"
			fi
			remaining=$((120000 - $(remote_clock_ms) + started))
			[ "$remaining" -gt 0 ] || return 28
			remaining="$(LC_ALL=C awk -v ms="$remaining" 'BEGIN { printf "%.3f", ms/1000 }')"
			rc=0
			curl "$@" --max-time "$remaining" -o "$dst" -w '%{http_code} %{redirect_url}\n' "$url" >"$stats" || rc=$?
			[ "$rc" = 0 ] || return "$rc"
			code=''; redirect=''; read -r code redirect <"$stats" || true
			case "$code" in
				301|302|303|307|308) rc=47; [ -n "$redirect" ] || return 47; url="$redirect"; hop=$((hop+1)) ;;
				200) [ -s "$dst" ] || { rc=1; return 1; }; return 0 ;;
				*) rc=22; return 22 ;;
			esac
		done
		return 47
	fi
	# Minimal images without curl keep bounded native HTTPS clients. These do
	# not offer curl's per-host resolver override.
	if truthy "$(uci_get wan_direct 0)"; then log 'Xray: curl отсутствует; загрузчик использует системный DNS'; fi
	rc=1
	case "$url" in https://*) ;; *) return 3 ;; esac
	if command -v uclient-fetch >/dev/null 2>&1; then
		xray_native_fetch "$dst" uclient-fetch -q -T 15 -O "$dst" "$url" && rc=0
	elif command -v wget >/dev/null 2>&1; then
		xray_native_fetch "$dst" wget -q -T 15 -O "$dst" "$url" && rc=0
	fi
	[ "$rc" = 0 ] && [ -s "$dst" ] && [ "$(wc -c <"$dst")" -le 33554432 ]
)

install_package() {
	local pkg
	pkg="$1"
	if command -v opkg >/dev/null 2>&1; then
		opkg update >/dev/null 2>&1 || return 1
		opkg install "$pkg" >/dev/null 2>&1 || return 1
		return 0
	fi
	if command -v apk >/dev/null 2>&1; then
		apk -U add "$pkg" >/dev/null 2>&1 || return 1
		return 0
	fi
	return 1
}

has_ca_certificates() {
	[ -s /etc/ssl/cert.pem ] && return 0
	[ -s /etc/ssl/certs/ca-certificates.crt ] && return 0
	[ -d /etc/ssl/certs ] && ls /etc/ssl/certs/* >/dev/null 2>&1 && return 0
	return 1
}

ensure_ca_certificates() {
	has_ca_certificates && return 0
	if command -v apk >/dev/null 2>&1; then
		install_package ca-certificates >/dev/null 2>&1 || true
	fi
	if command -v opkg >/dev/null 2>&1; then
		install_package ca-bundle >/dev/null 2>&1 || install_package ca-certificates >/dev/null 2>&1 || true
	fi
	has_ca_certificates
}

ensure_fetch_tool() {
	command -v curl >/dev/null 2>&1 && return 0
	command -v uclient-fetch >/dev/null 2>&1 && return 0
	command -v wget >/dev/null 2>&1 && return 0
	if command -v apk >/dev/null 2>&1; then
		install_package curl >/dev/null 2>&1 || install_package wget >/dev/null 2>&1 || true
	fi
	if command -v opkg >/dev/null 2>&1; then
		install_package curl >/dev/null 2>&1 || install_package wget-ssl >/dev/null 2>&1 || install_package wget >/dev/null 2>&1 || true
	fi
	command -v curl >/dev/null 2>&1 && return 0
	command -v uclient-fetch >/dev/null 2>&1 && return 0
	command -v wget >/dev/null 2>&1 && return 0
	return 1
}

install_xray_tmp() (
	xray_bootstrap_lock || return 1
	trap 'xray_bootstrap_unlock' EXIT
	trap 'exit 1' INT TERM
	install_xray_tmp_locked
)
install_xray_tmp_locked() (
	dir="$(xray_runtime_dir)"
	zip="$dir/xray.zip"
	asset="$(xray_release_asset)" || {
		log "unknown Xray asset for $(uname -m 2>/dev/null)"
		return 1
	}
	url="$XRAY_RELEASE_BASE_URL/$asset"

	mkdir -p "$dir" || return 1
	# An interrupted previous download is disposable; the working binary and
	# compressed boot copy are never removed before a candidate is validated.
	rm -f "$dir/xray.zip.new" "$dir/xray.new"
	trap 'rm -f "$dir/xray.zip.new" "$dir/xray.new"' EXIT
	trap 'exit 1' INT TERM
	if ! command -v unzip >/dev/null 2>&1; then
		install_package unzip || {
			log "cannot install unzip"
			return 1
		}
	fi
	ensure_ca_certificates || log "CA certificates not found, trying download anyway"
	ensure_fetch_tool || {
		log "need curl, uclient-fetch or wget to download Xray"
		return 1
	}

	log "Xray: загрузка $asset; общий тайм-аут=120s"
	fetch_file "$url" "$zip.new" || {
		log "Xray: не удалось загрузить $asset; рабочий бинарник и кэш сохранены"
		return 1
	}
	[ -s "$zip.new" ] || {
		log "downloaded Xray archive is empty: $zip"
		return 1
	}
	mv -f "$zip.new" "$zip" || return 1
	unzip -t "$zip" >/dev/null 2>&1 || { log 'Xray: архив не прошёл проверку целостности; рабочий бинарник сохранён'; return 1; }

	candidates="xray"
	case "$(xray_arch)" in
		mips*)
			candidates="xray_softfloat xray"
			;;
	esac

	for entry in $candidates; do
		# Extract only the named executable, never arbitrary paths from the ZIP.
		unzip -p "$zip" "$entry" 2>/dev/null | head -c 67108865 >"$dir/xray.new"
		[ -s "$dir/xray.new" ] || continue
		[ "$(wc -c <"$dir/xray.new")" -le 67108864 ] || continue
		chmod 755 "$dir/xray.new"
		version="$("$dir/xray.new" version 2>&1)" || {
			rm -f "$dir/xray.new"
			continue
		}
		version="$(printf '%s\n' "$version" | sed -n '1p')"
		mv -f "$dir/xray.new" "$dir/$entry" || return 1
		uci set "$CONFIG.$SECTION.xray_bin=$dir/$entry" && uci commit "$CONFIG" || return 1
		xray_cache_save "$dir/$entry" || true
		printf 'OK: Xray installed in %s\n' "$dir/$entry"
		printf 'OK: %s\n' "$version"
		printf 'OK: xray_bin saved in /etc/config/owrtremote\n'
		return 0
	done

	log "downloaded Xray does not start"
	return 1
)

ensure_xray_available() {
	local configured candidate found
	configured="$(uci_get xray_bin /usr/bin/xray)"
	if [ -x "$configured" ]; then
		return 0
	fi

	for candidate in /usr/bin/xray /usr/bin/xray-core /usr/local/bin/xray /opt/bin/xray /tmp/owrt-xray/xray /tmp/owrt-xray/xray_softfloat /tmp/xray /tmp/xray_softfloat; do
		if [ -x "$candidate" ]; then
			found="$candidate"
			break
		fi
	done

	if [ -z "$found" ]; then
		found="$(command -v xray 2>/dev/null || command -v xray-core 2>/dev/null || true)"
	fi

	if [ -n "$found" ] && [ -x "$found" ]; then
		[ "$found" = "$configured" ] || {
			uci set "$CONFIG.$SECTION.xray_bin=$found"
			uci commit "$CONFIG"
			log "Xray found: $found"
		}
		return 0
	fi

	prepare_xray_tmp
}
prepare_xray_tmp() (
	xray_bootstrap_lock || return 1
	trap 'xray_bootstrap_unlock' EXIT
	trap 'exit 1' INT TERM
	# Recheck after acquiring the lock: a concurrent installer may have finished.
	configured="$(uci_get xray_bin /usr/bin/xray)"
	[ ! -x "$configured" ] || return 0
	xray_cache_restore && return 0
	log 'Xray: загрузочной копии нет; требуется загрузка из сети'
	install_xray_tmp_locked
)
prepare_xray() (
	ensure_xray_available || return 1
	bin="$(xray_bin_path)"
	case "$bin" in
		/tmp/*|"$(xray_runtime_dir)"/*)
			xray_bootstrap_lock || return 1
			trap 'xray_bootstrap_unlock' EXIT
			trap 'exit 1' INT TERM
			xray_cache_save "$bin" || log 'Xray: запускается из RAM; автономное восстановление после перезагрузки пока недоступно'
			;;
	esac
)

ensure_xray_available_with_retry() {
	local attempts delay try_num managed
	attempts="${1:-18}"
	delay="${2:-10}"
	try_num=1
	managed="${OWRT_REMOTE_SERVICE_LOG:-0}"
	while [ "$try_num" -le "$attempts" ] || [ "$managed" = 1 ]; do
		if [ "$managed" = 1 ]; then
			truthy "$(uci_get enabled 0)" || return 1
			wait_for_selected_wan || return 1
		fi
		if ensure_xray_available; then
			return 0
		fi
		if [ "$try_num" -ge "$attempts" ]; then
			[ "$managed" = 1 ] || break
			delay=60
		fi
		log "Xray is not ready yet, retry in ${delay}s (${try_num}/${attempts})"
		sleep "$delay"
		try_num=$((try_num + 1))
	done
	return 1
}

wait_for_selected_wan() {
	local waiting
	waiting=0
	while truthy "$(uci_get wan_direct 0)"; do
		truthy "$(uci_get enabled 0)" || return 1
		if wan_select_interface >/dev/null; then
			[ "$waiting" = 0 ] || log 'Xray: выбранный WAN снова доступен; продолжается запуск туннеля'
			return 0
		fi
		[ "$waiting" = 1 ] || log 'Xray: ожидание выбранного WAN с физическим IPv4 default route; конфигурация сохранена'
		waiting=1
		sleep 5
	done
}

run_xray() {
	local enabled xray_bin xray_config
	enabled="$(uci_get enabled 0)"
	truthy "$enabled" || die "service disabled: set option enabled '1'"

	# Missing WAN is a temporary condition, not a failed Xray configuration.
	# Stay supervised instead of exhausting procd's six startup attempts.
	wait_for_selected_wan || return 1
	ensure_xray_available_with_retry || die "cannot prepare Xray for tunnel"
	xray_bin="$(xray_bin_path)"
	xray_config="$(render_client_config)" || die "cannot create Xray configuration"
	[ -n "$xray_config" ] && [ -s "$xray_config" ] || die "Xray configuration is missing or empty"
	[ -x "$xray_bin" ] || die "xray not found or not executable: $xray_bin"
	log "Xray: запуск туннеля; config=$xray_config; VPS=$(uci_get vps_host ''):$(uci_get vps_port 8443); WAN_direct=$(uci_get wan_direct 0); WAN_selected=$(uci_get wan_interface wan)"

	if "$xray_bin" help 2>/dev/null | grep -q 'run'; then
		exec "$xray_bin" run -config "$xray_config"
	fi
	exec "$xray_bin" -config "$xray_config"
}

cmd="${1:-help}"
shift || true

case "$cmd" in
	help|-h|--help)
		usage
		;;
	status)
		status
		;;
	doctor)
		doctor
		;;
	wan-prepare)
		wan_prepare
		;;
	wan-preflight)
		wan_preflight
		;;
	wan-cleanup)
		wan_cleanup
		;;
	network-diagnostics)
		wan_diagnostics
		heartbeat_diagnostics
		;;
	install-xray-tmp)
		install_xray_tmp
		;;
	prepare-xray)
		prepare_xray
		;;
	stop-xray)
		stop_xray
		;;
	render-client)
		xray_apply_trace render-client
		render_client_config "$@" || exit $?
		xray_apply_trace render-client-ok
		;;
	run)
		run_xray
		;;
	heartbeat)
		xray_apply_trace heartbeat
		send_heartbeat "$@" || exit $?
		xray_apply_trace heartbeat-ok
		;;
	heartbeat-loop)
		heartbeat_loop
		;;
	heartbeat-diagnostics)
		heartbeat_diagnostics
		;;
	logs-sync)
		sync_global_logs
		;;
	*)
		usage >&2
		exit 2
		;;
esac
