@le-space/rootfs 0.1.4 → 0.1.5

package/reference/uc-go-peer/rootfs/uc-go-peer-autotls-refresh.service

@@ -0,0 +1,23 @@
+[Unit]
+Description=Persist AutoTLS secure announce addresses for uc-go-peer
+After=uc-go-peer.service
+Wants=uc-go-peer.service
+ConditionPathExists=/etc/default/uc-go-peer.ready
+ConditionPathExists=!/etc/default/uc-go-peer.autotls-ready
+
+[Service]
+Type=oneshot
+Environment=ENV_FILE=/etc/default/uc-go-peer
+Environment=READY_FILE=/etc/default/uc-go-peer.ready
+Environment=AUTOTLS_READY_FILE=/etc/default/uc-go-peer.autotls-ready
+Environment=AUTOTLS_ZONE_FILE=/etc/default/uc-go-peer.autotls-zone
+Environment=AUTOTLS_HOSTS_FILE=/etc/default/uc-go-peer.autotls-hosts
+Environment=AUTOTLS_CADDY_READY_FILE=/etc/default/uc-go-peer.caddy-ready
+Environment=SERVICE_NAME=uc-go-peer.service
+Environment=WS_BACKEND_PORT=9097
+ExecStart=/usr/bin/python3 /usr/local/sbin/uc-go-peer-autotls-refresh.py
+StandardOutput=journal
+StandardError=journal
+
+[Install]
+WantedBy=multi-user.target

package/reference/uc-go-peer/rootfs/uc-go-peer-bootstrap.service

@@ -0,0 +1,17 @@
+[Unit]
+Description=Temporary universal-connectivity go-peer setup endpoint
+Wants=network-online.target
+After=network-online.target
+ConditionPathExists=!/etc/default/uc-go-peer.ready
+
+[Service]
+Environment=ENV_FILE=/etc/default/uc-go-peer
+Environment=READY_FILE=/etc/default/uc-go-peer.ready
+ExecStart=/usr/bin/python3 /usr/local/sbin/uc-go-peer-setup-server.py
+StandardOutput=journal
+StandardError=journal
+Restart=on-failure
+RestartSec=2s
+
+[Install]
+WantedBy=multi-user.target

package/reference/uc-go-peer/rootfs/uc-go-peer-bootstrap.sh

@@ -0,0 +1,118 @@
+#!/usr/bin/env bash
+set -euo pipefail
+set -x
+
+INSTALL_DIR="${INSTALL_DIR:-/opt/go-peer}"
+SERVICE_USER="${SERVICE_USER:-uc-go-peer}"
+DATA_DIR="${DATA_DIR:-/var/lib/uc-go-peer}"
+ENV_FILE="${ENV_FILE:-/etc/default/uc-go-peer}"
+READY_FILE="${READY_FILE:-/etc/default/uc-go-peer.ready}"
+AUTOTLS_READY_FILE="${AUTOTLS_READY_FILE:-/etc/default/uc-go-peer.autotls-ready}"
+AUTOTLS_ZONE_FILE="${AUTOTLS_ZONE_FILE:-/etc/default/uc-go-peer.autotls-zone}"
+AUTOTLS_HOSTS_FILE="${AUTOTLS_HOSTS_FILE:-/etc/default/uc-go-peer.autotls-hosts}"
+AUTOTLS_CADDY_READY_FILE="${AUTOTLS_CADDY_READY_FILE:-/etc/default/uc-go-peer.caddy-ready}"
+APP_BINARY="${APP_BINARY:-/usr/local/bin/universal-chat-go}"
+PHASE="${1:-all}"
+
+if [ ! -d "${INSTALL_DIR}" ]; then
+  echo "Missing ${INSTALL_DIR}; the rootfs build did not create the relay support directory."
+  exit 1
+fi
+
+echo "[uc-go-peer-bootstrap] starting"
+echo "[uc-go-peer-bootstrap] support dir: ${INSTALL_DIR}"
+echo "[uc-go-peer-bootstrap] data dir: ${DATA_DIR}"
+echo "[uc-go-peer-bootstrap] env file: ${ENV_FILE}"
+echo "[uc-go-peer-bootstrap] app binary: ${APP_BINARY}"
+
+run_phase_base() {
+  export DEBIAN_FRONTEND=noninteractive
+  echo "[uc-go-peer-bootstrap] phase=base"
+  echo "[uc-go-peer-bootstrap] running apt-get update"
+  apt-get update
+  echo "[uc-go-peer-bootstrap] installing base packages"
+  apt-get install -y ca-certificates curl caddy
+  rm -rf /var/lib/apt/lists/*
+}
+
+run_phase_build() {
+  echo "[uc-go-peer-bootstrap] phase=build"
+  if [ ! -x "${APP_BINARY}" ]; then
+    echo "[uc-go-peer-bootstrap] missing application binary: ${APP_BINARY}"
+    exit 1
+  fi
+  echo "[uc-go-peer-bootstrap] application binary already provisioned"
+}
+
+run_phase_finalize() {
+  echo "[uc-go-peer-bootstrap] phase=finalize"
+  echo "[uc-go-peer-bootstrap] creating runtime directories"
+  mkdir -p "${DATA_DIR}" "$(dirname "${ENV_FILE}")"
+
+  if ! id "${SERVICE_USER}" >/dev/null 2>&1; then
+    echo "[uc-go-peer-bootstrap] creating service user ${SERVICE_USER}"
+    useradd --system --home "${DATA_DIR}" --create-home --shell /usr/sbin/nologin "${SERVICE_USER}"
+  fi
+
+  echo "[uc-go-peer-bootstrap] fixing ownership"
+  chown -R "${SERVICE_USER}:${SERVICE_USER}" "${DATA_DIR}" "${INSTALL_DIR}"
+
+  echo "[uc-go-peer-bootstrap] preparing environment file"
+  touch "${ENV_FILE}"
+  chmod 0640 "${ENV_FILE}"
+  chown "root:${SERVICE_USER}" "${ENV_FILE}"
+  rm -f "${READY_FILE}" "${AUTOTLS_READY_FILE}" "${AUTOTLS_ZONE_FILE}" "${AUTOTLS_HOSTS_FILE}" "${AUTOTLS_CADDY_READY_FILE}"
+
+  mkdir -p /etc/caddy /etc/systemd/system/caddy.service.d
+  cat > /etc/systemd/system/caddy.service.d/uc-go-peer.conf <<EOF
+[Unit]
+ConditionPathExists=${AUTOTLS_CADDY_READY_FILE}
+EOF
+}
+
+write_env_var() {
+  local key="$1"
+  local value="$2"
+
+  if grep -Eq "^[#[:space:]]*${key}=" "${ENV_FILE}"; then
+    sed -i "s|^[#[:space:]]*${key}=.*|${key}=${value}|" "${ENV_FILE}"
+  else
+    printf '%s=%s\n' "${key}" "${value}" >> "${ENV_FILE}"
+  fi
+}
+
+seed_env() {
+  write_env_var "GO_PEER_DATA_DIR" "${DATA_DIR}"
+  write_env_var "GO_PEER_TCP_PORT" "9095"
+  write_env_var "GO_PEER_WS_PORT" "9096"
+  write_env_var "GO_PEER_WSS_PORT" "9097"
+  write_env_var "GO_PEER_IDENTITY_PATH" "${DATA_DIR}/identity.key"
+  write_env_var "GO_PEER_WS_BACKEND_PORT" "9096"
+  write_env_var "GO_PEER_AUTOTLS_CERT_DIR" "${DATA_DIR}/p2p-forge-certs"
+  write_env_var "LIBP2P_AUTO_PUBLIC_IP" "0"
+}
+
+case "${PHASE}" in
+  base)
+    run_phase_base
+    ;;
+  build)
+    run_phase_build
+    ;;
+  finalize)
+    run_phase_finalize
+    seed_env
+    ;;
+  all)
+    run_phase_base
+    run_phase_build
+    run_phase_finalize
+    seed_env
+    ;;
+  *)
+    echo "Unknown phase: ${PHASE}" >&2
+    exit 1
+    ;;
+esac
+
+echo "[uc-go-peer-bootstrap] completed phase ${PHASE}"

package/reference/uc-go-peer/rootfs/uc-go-peer-configure.sh

@@ -0,0 +1,204 @@
+#!/usr/bin/env bash
+set -euo pipefail
+
+ENV_FILE="${ENV_FILE:-/etc/default/uc-go-peer}"
+READY_FILE="${READY_FILE:-/etc/default/uc-go-peer.ready}"
+AUTOTLS_READY_FILE="${AUTOTLS_READY_FILE:-/etc/default/uc-go-peer.autotls-ready}"
+AUTOTLS_ZONE_FILE="${AUTOTLS_ZONE_FILE:-/etc/default/uc-go-peer.autotls-zone}"
+AUTOTLS_HOSTS_FILE="${AUTOTLS_HOSTS_FILE:-/etc/default/uc-go-peer.autotls-hosts}"
+AUTOTLS_CADDY_READY_FILE="${AUTOTLS_CADDY_READY_FILE:-/etc/default/uc-go-peer.caddy-ready}"
+SERVICE_NAME="${SERVICE_NAME:-uc-go-peer.service}"
+AUTOTLS_REFRESH_SERVICE="${AUTOTLS_REFRESH_SERVICE:-uc-go-peer-autotls-refresh.service}"
+CADDY_SERVICE="${CADDY_SERVICE:-caddy.service}"
+CADDYFILE="${CADDYFILE:-/etc/caddy/Caddyfile}"
+BOOTSTRAP_SERVICE="${BOOTSTRAP_SERVICE:-uc-go-peer-bootstrap.service}"
+P2P_FORGE_DOMAIN="${P2P_FORGE_DOMAIN:-libp2p.direct}"
+PUBLIC_IPV4=""
+PUBLIC_IPV6=""
+TCP_PORT="9095"
+WS_PORT="9097"
+WS_BACKEND_PORT="9096"
+PROXY_HOSTNAME=""
+UDP_PORT=""
+START_SERVICE=1
+
+usage() {
+  cat <<'EOF'
+Usage:
+  uc-go-peer-configure.sh \
+    --public-ipv4 <ip> \
+    [--public-ipv6 <ipv6>] \
+    [--proxy-hostname <hostname>] \
+    [--tcp-port <host-port>] \
+    [--ws-port <host-port>] \
+    [--udp-port <host-port>] \
+    [--quic-port <host-port>] \
+    [--webtransport-port <host-port>] \
+    [--webrtc-port <host-port>] \
+    [--no-start]
+EOF
+}
+
+write_env_var() {
+  local key="$1"
+  local value="$2"
+
+  if grep -Eq "^[#[:space:]]*${key}=" "${ENV_FILE}"; then
+    sed -i "s|^[#[:space:]]*${key}=.*|${key}=${value}|" "${ENV_FILE}"
+  else
+    printf '%s=%s\n' "${key}" "${value}" >> "${ENV_FILE}"
+  fi
+}
+
+render_proxy_caddyfile() {
+  local proxy_hostname="$1"
+  cat <<EOF
+{
+    auto_https disable_redirects
+}
+
+https://${proxy_hostname} {
+    tls {
+        issuer acme {
+            disable_http_challenge
+        }
+    }
+    reverse_proxy http://127.0.0.1:${WS_BACKEND_PORT}
+}
+EOF
+}
+
+while [ "$#" -gt 0 ]; do
+  case "$1" in
+    --public-ipv4)
+      PUBLIC_IPV4="${2:-}"
+      shift 2
+      ;;
+    --public-ipv6)
+      PUBLIC_IPV6="${2:-}"
+      shift 2
+      ;;
+    --tcp-port)
+      TCP_PORT="${2:-}"
+      shift 2
+      ;;
+    --ws-port)
+      WS_PORT="${2:-}"
+      shift 2
+      ;;
+    --udp-port)
+      UDP_PORT="${2:-}"
+      shift 2
+      ;;
+    --proxy-hostname)
+      PROXY_HOSTNAME="${2:-}"
+      shift 2
+      ;;
+    --quic-port)
+      UDP_PORT="${2:-}"
+      shift 2
+      ;;
+    --webtransport-port)
+      UDP_PORT="${2:-}"
+      shift 2
+      ;;
+    --webrtc-port)
+      UDP_PORT="${2:-}"
+      shift 2
+      ;;
+    --no-start)
+      START_SERVICE=0
+      shift
+      ;;
+    -h|--help)
+      usage
+      exit 0
+      ;;
+    *)
+      echo "Unknown argument: $1" >&2
+      usage >&2
+      exit 1
+      ;;
+  esac
+done
+
+if [ -z "${PUBLIC_IPV4}" ]; then
+  usage >&2
+  exit 1
+fi
+
+touch "${ENV_FILE}"
+rm -f "${AUTOTLS_READY_FILE}" "${AUTOTLS_ZONE_FILE}" "${AUTOTLS_HOSTS_FILE}" "${AUTOTLS_CADDY_READY_FILE}"
+
+announce=(
+  "/ip4/${PUBLIC_IPV4}/tcp/${TCP_PORT}"
+)
+
+if [ -n "${WS_PORT}" ]; then
+  announce+=("/ip4/${PUBLIC_IPV4}/tcp/${WS_PORT}/tls/sni/*.${P2P_FORGE_DOMAIN}/ws")
+fi
+
+if [ -n "${UDP_PORT}" ]; then
+  announce+=(
+    "/ip4/${PUBLIC_IPV4}/udp/${UDP_PORT}/quic-v1"
+    "/ip4/${PUBLIC_IPV4}/udp/${UDP_PORT}/quic-v1/webtransport"
+    "/ip4/${PUBLIC_IPV4}/udp/${UDP_PORT}/webrtc-direct"
+  )
+fi
+
+if [ -n "${PUBLIC_IPV6}" ]; then
+  announce+=("/ip6/${PUBLIC_IPV6}/tcp/${TCP_PORT}")
+  if [ -n "${WS_PORT}" ]; then
+    announce+=("/ip6/${PUBLIC_IPV6}/tcp/${WS_PORT}/tls/sni/*.${P2P_FORGE_DOMAIN}/ws")
+  fi
+  if [ -n "${UDP_PORT}" ]; then
+    announce+=(
+      "/ip6/${PUBLIC_IPV6}/udp/${UDP_PORT}/quic-v1"
+      "/ip6/${PUBLIC_IPV6}/udp/${UDP_PORT}/quic-v1/webtransport"
+      "/ip6/${PUBLIC_IPV6}/udp/${UDP_PORT}/webrtc-direct"
+    )
+  fi
+fi
+
+announce_value="$(IFS=,; printf '%s' "${announce[*]}")"
+write_env_var "PUBLIC_IPV4" "${PUBLIC_IPV4}"
+if [ -n "${PUBLIC_IPV6}" ]; then
+  write_env_var "PUBLIC_IPV6" "${PUBLIC_IPV6}"
+fi
+write_env_var "EXTERNAL_RELAY_TCP_PORT" "${TCP_PORT}"
+write_env_var "EXTERNAL_RELAY_WS_PORT" "${WS_PORT}"
+write_env_var "GO_PEER_WSS_PORT" "${GO_PEER_WSS_PORT:-9097}"
+if [ -n "${PROXY_HOSTNAME}" ]; then
+  write_env_var "PROXY_HOSTNAME" "${PROXY_HOSTNAME}"
+  mkdir -p "$(dirname "${CADDYFILE}")"
+  render_proxy_caddyfile "${PROXY_HOSTNAME}" > "${CADDYFILE}"
+  touch "${AUTOTLS_CADDY_READY_FILE}"
+else
+  write_env_var "PROXY_HOSTNAME" ""
+  rm -f "${AUTOTLS_CADDY_READY_FILE}"
+fi
+if [ -n "${UDP_PORT}" ]; then
+  write_env_var "EXTERNAL_RELAY_UDP_PORT" "${UDP_PORT}"
+  write_env_var "EXTERNAL_RELAY_QUIC_PORT" "${UDP_PORT}"
+  write_env_var "EXTERNAL_RELAY_WEBTRANSPORT_PORT" "${UDP_PORT}"
+  write_env_var "EXTERNAL_RELAY_WEBRTC_PORT" "${UDP_PORT}"
+fi
+write_env_var "LIBP2P_ANNOUNCE_ADDRS" "${announce_value}"
+touch "${READY_FILE}"
+
+if [ "${START_SERVICE}" -eq 1 ]; then
+  systemctl daemon-reload
+  systemctl enable "${SERVICE_NAME}"
+  systemctl restart "${SERVICE_NAME}"
+  systemctl enable "${AUTOTLS_REFRESH_SERVICE}"
+  if [ -n "${PROXY_HOSTNAME}" ]; then
+    systemctl enable "${CADDY_SERVICE}"
+    systemctl restart "${CADDY_SERVICE}"
+  else
+    systemctl stop "${CADDY_SERVICE}" || true
+  fi
+  systemctl restart --no-block "${AUTOTLS_REFRESH_SERVICE}"
+fi
+
+printf 'Configured LIBP2P_ANNOUNCE_ADDRS=%s\n' "${announce_value}"
+printf 'Ready file: %s\n' "${READY_FILE}"

package/reference/uc-go-peer/rootfs/uc-go-peer-describe.py

@@ -0,0 +1,195 @@
+#!/usr/bin/env python3
+import json
+import os
+import re
+import subprocess
+import time
+
+
+ENV_FILE = os.environ.get("ENV_FILE", "/etc/default/uc-go-peer")
+SERVICE_NAME = os.environ.get("SERVICE_NAME", "uc-go-peer.service")
+WAIT_TIMEOUT_SECONDS = int(os.environ.get("DESCRIBE_WAIT_TIMEOUT_SECONDS", "240"))
+WAIT_INTERVAL_SECONDS = float(os.environ.get("DESCRIBE_WAIT_INTERVAL_SECONDS", "2"))
+AUTOTLS_EXTRA_WAIT_SECONDS = int(os.environ.get("DESCRIBE_AUTOTLS_EXTRA_WAIT_SECONDS", "120"))
+
+PEER_ID_PATTERNS = [
+    re.compile(r"PeerID:\s+(\S+)"),
+    re.compile(r"Host created with PeerID:\s+(\S+)"),
+]
+LISTENING_PATTERN = re.compile(r"Listening on:\s+(\S+)/p2p/(\S+)")
+
+
+def parse_env_file(path: str) -> dict[str, str]:
+    values: dict[str, str] = {}
+    if not os.path.exists(path):
+        return values
+
+    with open(path, encoding="utf-8") as handle:
+        for line in handle:
+            stripped = line.strip()
+            if not stripped or stripped.startswith("#") or "=" not in stripped:
+                continue
+            key, value = stripped.split("=", 1)
+            values[key.strip()] = value.strip()
+    return values
+
+
+def dedupe(values: list[str]) -> list[str]:
+    seen: set[str] = set()
+    result: list[str] = []
+    for value in values:
+        if value and value not in seen:
+            seen.add(value)
+            result.append(value)
+    return result
+
+
+def append_peer_id(addr: str, peer_id: str) -> str:
+    return addr if "/p2p/" in addr else f"{addr}/p2p/{peer_id}"
+
+
+def parse_logs() -> tuple[str | None, list[str]]:
+    result = subprocess.run(
+        ["journalctl", "-u", SERVICE_NAME, "-n", "500", "--no-pager"],
+        capture_output=True,
+        text=True,
+        check=False,
+    )
+    output = result.stdout or ""
+
+    peer_id = None
+    for pattern in PEER_ID_PATTERNS:
+        match = pattern.search(output)
+        if match:
+            peer_id = match.group(1)
+            break
+
+    listening_addrs = []
+    for addr, logged_peer_id in LISTENING_PATTERN.findall(output):
+        if peer_id is None:
+            peer_id = logged_peer_id
+        listening_addrs.append(addr)
+
+    return peer_id, dedupe(listening_addrs)
+
+
+def build_probe_multiaddrs(env_values: dict[str, str], peer_id: str, listening_addrs: list[str]) -> dict[str, list[str]]:
+    announce_addrs = [
+        entry.strip()
+        for entry in env_values.get("LIBP2P_ANNOUNCE_ADDRS", "").split(",")
+        if entry.strip()
+    ]
+    probe_multiaddrs: list[str] = []
+    direct_tcp_multiaddrs: list[str] = []
+    autotls_multiaddrs: list[str] = []
+    proxy_multiaddrs: list[str] = []
+    webtransport_multiaddrs: list[str] = []
+    webrtc_direct_multiaddrs: list[str] = []
+
+    for addr in announce_addrs:
+        if "/tcp/" in addr and "/tls/" not in addr and "/ws" not in addr:
+            direct_tcp_multiaddrs.append(append_peer_id(addr, peer_id))
+
+    ws_port = env_values.get("EXTERNAL_RELAY_WS_PORT", "").strip()
+    for addr in listening_addrs:
+        if "/tls/" not in addr or not addr.endswith("/ws"):
+            continue
+
+        dns_match = re.search(r"/dns[46]/([^/]+)/tcp/(\d+)/tls/ws$", addr)
+        if dns_match:
+            host = dns_match.group(1)
+            autotls_multiaddrs.append(f"/dns4/{host}/tcp/{ws_port or dns_match.group(2)}/tls/ws/p2p/{peer_id}")
+            autotls_multiaddrs.append(f"/dns6/{host}/tcp/{ws_port or dns_match.group(2)}/tls/ws/p2p/{peer_id}")
+            continue
+
+        sni_match = re.search(r"/tls/sni/([^/]+)/ws$", addr)
+        if sni_match:
+            host = sni_match.group(1)
+            if ws_port:
+                autotls_multiaddrs.append(f"/dns4/{host}/tcp/{ws_port}/tls/ws/p2p/{peer_id}")
+                autotls_multiaddrs.append(f"/dns6/{host}/tcp/{ws_port}/tls/ws/p2p/{peer_id}")
+
+    proxy_hostname = env_values.get("PROXY_HOSTNAME", "").strip()
+    if proxy_hostname:
+        proxy_multiaddrs.append(f"/dns4/{proxy_hostname}/tcp/443/tls/ws/p2p/{peer_id}")
+        proxy_multiaddrs.append(f"/dns6/{proxy_hostname}/tcp/443/tls/ws/p2p/{peer_id}")
+
+    public_ipv4 = env_values.get("PUBLIC_IPV4", "").strip()
+    public_ipv6 = env_values.get("PUBLIC_IPV6", "").strip()
+    udp_port = env_values.get("EXTERNAL_RELAY_UDP_PORT", "").strip()
+    if udp_port:
+        if public_ipv4:
+            webtransport_multiaddrs.append(f"/ip4/{public_ipv4}/udp/{udp_port}/quic-v1/webtransport/p2p/{peer_id}")
+            webrtc_direct_multiaddrs.append(f"/ip4/{public_ipv4}/udp/{udp_port}/webrtc-direct/p2p/{peer_id}")
+        if public_ipv6:
+            webtransport_multiaddrs.append(f"/ip6/{public_ipv6}/udp/{udp_port}/quic-v1/webtransport/p2p/{peer_id}")
+            webrtc_direct_multiaddrs.append(f"/ip6/{public_ipv6}/udp/{udp_port}/webrtc-direct/p2p/{peer_id}")
+
+    probe_multiaddrs.extend(direct_tcp_multiaddrs)
+    probe_multiaddrs.extend(autotls_multiaddrs)
+    probe_multiaddrs.extend(proxy_multiaddrs)
+
+    return {
+        "direct_tcp_multiaddrs": dedupe(direct_tcp_multiaddrs),
+        "autotls_wss_multiaddrs": dedupe(autotls_multiaddrs),
+        "proxy_wss_multiaddrs": dedupe(proxy_multiaddrs),
+        "webtransport_multiaddrs": dedupe(webtransport_multiaddrs),
+        "webrtc_direct_multiaddrs": dedupe(webrtc_direct_multiaddrs),
+        "browser_bootstrap_multiaddrs": dedupe(
+            autotls_multiaddrs + proxy_multiaddrs + webtransport_multiaddrs + webrtc_direct_multiaddrs
+        ),
+        "probe_multiaddrs": dedupe(probe_multiaddrs),
+    }
+
+
+def main() -> None:
+    started_at = time.monotonic()
+    deadline = time.monotonic() + WAIT_TIMEOUT_SECONDS
+    peer_id = None
+    listening_addrs: list[str] = []
+    grouped = {
+        "direct_tcp_multiaddrs": [],
+        "autotls_wss_multiaddrs": [],
+        "proxy_wss_multiaddrs": [],
+        "webtransport_multiaddrs": [],
+        "webrtc_direct_multiaddrs": [],
+        "browser_bootstrap_multiaddrs": [],
+        "probe_multiaddrs": [],
+    }
+
+    while time.monotonic() < deadline:
+        env_values = parse_env_file(ENV_FILE)
+        peer_id, listening_addrs = parse_logs()
+        if not peer_id:
+            time.sleep(WAIT_INTERVAL_SECONDS)
+            continue
+
+        grouped = build_probe_multiaddrs(env_values, peer_id, listening_addrs)
+        proxy_hostname = env_values.get("PROXY_HOSTNAME", "").strip()
+        if grouped["autotls_wss_multiaddrs"]:
+            break
+        if proxy_hostname and grouped["proxy_wss_multiaddrs"] and time.monotonic() - started_at >= AUTOTLS_EXTRA_WAIT_SECONDS:
+            break
+        if not proxy_hostname and time.monotonic() - started_at >= AUTOTLS_EXTRA_WAIT_SECONDS:
+            break
+        time.sleep(WAIT_INTERVAL_SECONDS)
+
+    if not peer_id:
+        raise SystemExit("unable to discover relay peer ID from service logs")
+
+    env_values = parse_env_file(ENV_FILE)
+    payload = {
+        "peer_id": peer_id,
+        "announce_addrs": [
+            entry.strip()
+            for entry in env_values.get("LIBP2P_ANNOUNCE_ADDRS", "").split(",")
+            if entry.strip()
+        ],
+        "listening_addrs": listening_addrs,
+        **grouped,
+    }
+    print(json.dumps(payload))
+
+
+if __name__ == "__main__":
+    main()