Merge remote-tracking branch 'origin/fix-perform-speed' into feat/mqtt_merge

manage.sh

@@ -500,7 +500,7 @@ if [ -n "$ARCH_TAG" ]; then
     PY_TAG=$("$VENV_PYTHON" -c 'import sys; v=f"cp{sys.version_info.major}{sys.version_info.minor}"; print(f"{v}-{v}")' 2>/dev/null || echo "cp311-cp311")
     WHEEL_BASE="${R2_BASE_URL}/${ARCH_TAG}/${PLATFORM_TAG}/${PY_TAG}"
     echo "[pymc-do-upgrade] Trying dependencies from R2 wheels..."
-    "$VENV_PIP" install --no-index --find-links "${WHEEL_BASE}/index.html" --no-cache-dir "pycryptodome>=3.23.0" "PyNaCl>=1.5.0" cffi "pyyaml>=6.0.0" 2>/dev/null || true
+    "$VENV_PIP" install --find-links "${WHEEL_BASE}/index.html" --no-cache-dir "pycryptodome>=3.23.0" "PyNaCl>=1.5.0" cffi "pyyaml>=6.0.0" 2>/dev/null || true
 fi
 # ---- Install pymc_repeater from git ----
 exec "$VENV_PIP" install \
@@ -563,7 +563,7 @@ UPGRADEEOF
             WHEEL_BASE="${R2_BASE_URL}/${ARCH_TAG}/${PLATFORM_TAG}/${PY_TAG}"
             echo "  Checking for R2 wheels (${ARCH_TAG}/${PLATFORM_TAG}/${PY_TAG})..."
             echo "  Trying install from R2 pre-built wheels..."
-            "$VENV_PIP" install --no-index --find-links "${WHEEL_BASE}/index.html" --no-cache-dir "pycryptodome>=3.23.0" "PyNaCl>=1.5.0" cffi "pyyaml>=6.0.0" 2>/dev/null && R2_SUCCESS=1 || R2_SUCCESS=0
+            "$VENV_PIP" install --find-links "${WHEEL_BASE}/index.html" --no-cache-dir "pycryptodome>=3.23.0" "PyNaCl>=1.5.0" cffi "pyyaml>=6.0.0" 2>/dev/null && R2_SUCCESS=1 || R2_SUCCESS=0
             if [ "$R2_SUCCESS" -eq 1 ]; then
                 echo "  ✓ R2 wheels installed"
             else
@@ -904,7 +904,7 @@ python3 -m pip uninstall -y pymc_core 2>/dev/null || true
             PY_TAG=$("$VENV_PYTHON" -c 'import sys; v=f"cp{sys.version_info.major}{sys.version_info.minor}"; print(f"{v}-{v}")' 2>/dev/null || echo "cp311-cp311")
             WHEEL_BASE="${R2_BASE_URL}/${ARCH_TAG}/${PLATFORM_TAG}/${PY_TAG}"
             echo "[pymc-do-upgrade] Trying dependencies from R2 wheels..."
-            "$VENV_PIP" install --no-index --find-links "${WHEEL_BASE}/index.html" --no-cache-dir "pycryptodome>=3.23.0" "PyNaCl>=1.5.0" cffi "pyyaml>=6.0.0" 2>/dev/null || true
+            "$VENV_PIP" install --find-links "${WHEEL_BASE}/index.html" --no-cache-dir "pycryptodome>=3.23.0" "PyNaCl>=1.5.0" cffi "pyyaml>=6.0.0" 2>/dev/null || true
         fi
         # ---- Install pymc_repeater from git ----
         exec "$VENV_PIP" install \
@@ -967,7 +967,7 @@ UPGRADEEOF
                 WHEEL_BASE="${R2_BASE_URL}/${ARCH_TAG}/${PLATFORM_TAG}/${PY_TAG}"
                 echo "  Checking for R2 wheels (${ARCH_TAG}/${PLATFORM_TAG}/${PY_TAG})..."
                 echo "  Trying install from R2 pre-built wheels..."
-                "$VENV_PIP" install --no-index --find-links "${WHEEL_BASE}/index.html" --no-cache-dir "pycryptodome>=3.23.0" "PyNaCl>=1.5.0" cffi "pyyaml>=6.0.0" 2>/dev/null && R2_SUCCESS=1 || R2_SUCCESS=0
+                "$VENV_PIP" install --find-links "${WHEEL_BASE}/index.html" --no-cache-dir "pycryptodome>=3.23.0" "PyNaCl>=1.5.0" cffi "pyyaml>=6.0.0" 2>/dev/null && R2_SUCCESS=1 || R2_SUCCESS=0
                 if [ "$R2_SUCCESS" -eq 1 ]; then
                     echo "  ✓ R2 wheels installed"
                 else

repeater/data_acquisition/letsmesh_handler.py

@@ -0,0 +1,732 @@
+import base64
+import binascii
+import json
+import logging
+import threading
+from datetime import datetime, timedelta
+from typing import Callable, Dict, List, Optional
+
+import paho.mqtt.client as mqtt
+from nacl.signing import SigningKey
+
+# Try to import datetime.UTC (Python 3.11+) otherwise fallback to timezone.utc
+try:
+    from datetime import UTC
+except Exception:
+    from datetime import timezone
+    UTC = timezone.utc
+
+from repeater import __version__
+
+# Try to import paho-mqtt error code mappings
+try:
+    from paho.mqtt.reasoncodes import ReasonCode
+
+    HAS_REASON_CODES = True
+except ImportError:
+    HAS_REASON_CODES = False
+
+logger = logging.getLogger("LetsMeshHandler")
+
+
+# --------------------------------------------------------------------
+# Helper: Base64URL without padding
+# --------------------------------------------------------------------
+def b64url(x: bytes) -> str:
+    return base64.urlsafe_b64encode(x).rstrip(b"=").decode()
+
+
+# --------------------------------------------------------------------
+# Let's Mesh MQTT Broker List (WebSocket Secure)
+# --------------------------------------------------------------------
+LETSMESH_BROKERS = [
+    {
+        "name": "Europe (LetsMesh v1)",
+        "host": "mqtt-eu-v1.letsmesh.net",
+        "port": 443,
+        "audience": "mqtt-eu-v1.letsmesh.net",
+    },
+    {
+        "name": "US West (LetsMesh v1)",
+        "host": "mqtt-us-v1.letsmesh.net",
+        "port": 443,
+        "audience": "mqtt-us-v1.letsmesh.net",
+    },
+]
+
+
+# ====================================================================
+# Single Broker Connection Manager
+# ====================================================================
+class _BrokerConnection:
+    """
+    Manages a single MQTT broker connection with independent lifecycle.
+    Internal class - not exposed publicly.
+    """
+
+    def __init__(
+        self,
+        broker: dict,
+        local_identity,
+        public_key: str,
+        iata_code: str,
+        jwt_expiry_minutes: int,
+        use_tls: bool,
+        email: str,
+        owner: str,
+        broker_index: int = 0,
+        on_connect_callback: Optional[Callable] = None,
+        on_disconnect_callback: Optional[Callable] = None,
+    ):
+        self.broker = broker
+        self.local_identity = local_identity
+        self.public_key = public_key.upper()
+        self.iata_code = iata_code
+        self.jwt_expiry_minutes = jwt_expiry_minutes
+        self.broker_index = broker_index
+        self.use_tls = use_tls
+        self.email = email
+        self.owner = owner
+        self._on_connect_callback = on_connect_callback
+        self._on_disconnect_callback = on_disconnect_callback
+        self._connect_time = None
+        self._tls_verified = False
+        self._running = False
+        self._reconnect_attempts = 0
+        self._reconnect_timer = None
+        self._max_reconnect_delay = 300  # 5 minutes max
+        self._jwt_refresh_timer = None
+        self._shutdown_requested = False
+        client_id = f"meshcore_{self.public_key}_{broker['host']}"
+        self.client = mqtt.Client(client_id=client_id, transport="websockets")
+        self.client.on_connect = self._on_connect
+        self.client.on_disconnect = self._on_disconnect
+
+    def _generate_jwt(self) -> str:
+        """Generate MeshCore-style Ed25519 JWT token"""
+        now = datetime.now(UTC)
+
+        header = {"alg": "Ed25519", "typ": "JWT"}
+
+        payload = {
+            "publicKey": self.public_key.upper(),
+            "aud": self.broker["audience"],
+            "iat": int(now.timestamp()),
+            "exp": int((now + timedelta(minutes=self.jwt_expiry_minutes)).timestamp()),
+        }
+
+        # Only include email/owner for verified TLS connections
+        if self.use_tls and self._tls_verified and (self.email or self.owner):
+            payload["email"] = self.email
+            payload["owner"] = self.owner
+        else:
+            payload["email"] = ""
+            payload["owner"] = ""
+
+        # Encode header and payload (compact JSON - no spaces)
+        header_b64 = b64url(json.dumps(header, separators=(",", ":")).encode())
+        payload_b64 = b64url(json.dumps(payload, separators=(",", ":")).encode())
+
+        signing_input = f"{header_b64}.{payload_b64}".encode()
+
+        # Sign using LocalIdentity (supports both standard and firmware keys)
+        try:
+            signature = self.local_identity.sign(signing_input)
+        except Exception as e:
+            logger.error(f"JWT signing failed for {self.broker['name']}: {e}")
+            logger.error(f"  - public_key: {self.public_key}")
+            logger.error(f"  - signing_input length: {len(signing_input)}")
+            raise
+
+        signature_hex = binascii.hexlify(signature).decode()
+        token = f"{header_b64}.{payload_b64}.{signature_hex}"
+
+        logger.debug(f"JWT token generated for {self.broker['name']}: {token[:50]}...")
+
+        return token
+
+    def _on_connect(self, client, userdata, flags, rc):
+        """MQTT connection callback"""
+        if rc == 0:
+            logger.info(f"Connected to {self.broker['name']}")
+            self._running = True
+            self._reconnect_attempts = 0  # Reset counter on success
+            self._schedule_jwt_refresh()  # Schedule proactive JWT refresh
+            if self._on_connect_callback:
+                self._on_connect_callback(self.broker["name"])
+        else:
+            error_msg = get_mqtt_error_message(rc, is_disconnect=False)
+            logger.error(f"Failed to connect to {self.broker['name']}: {error_msg}")
+            self._schedule_reconnect()
+
+    def _on_disconnect(self, client, userdata, rc):
+        """MQTT disconnection callback"""
+        was_running = self._running
+        self._running = False
+
+        if self._shutdown_requested:
+            logger.info(f"Clean disconnect from {self.broker['name']}")
+            if self._on_disconnect_callback:
+                self._on_disconnect_callback(self.broker["name"])
+            return
+
+        if rc != 0:  # Unexpected disconnect
+            error_msg = get_mqtt_error_message(rc, is_disconnect=True)
+            logger.warning(f"Disconnected from {self.broker['name']} (rc={rc}): {error_msg}")
+            if was_running:  # Only reconnect if we were intentionally connected
+                self._schedule_reconnect(reason=error_msg)
+        else:
+            logger.info(f"Clean disconnect from {self.broker['name']}")
+
+        if self._on_disconnect_callback:
+            self._on_disconnect_callback(self.broker["name"])
+
+    def _schedule_reconnect(self, reason: str = "connection lost"):
+        """Schedule reconnection with exponential backoff"""
+        if self._shutdown_requested:
+            return
+
+        if self._reconnect_timer:
+            self._reconnect_timer.cancel()
+
+        # Exponential backoff: 5s, 10s, 20s, 40s, 80s, up to max
+        delay = min(5 * (2**self._reconnect_attempts), self._max_reconnect_delay)
+        self._reconnect_attempts += 1
+
+        logger.info(
+            f"Scheduling reconnect to {self.broker['name']} in {delay}s (attempt {self._reconnect_attempts}, reason: {reason})"
+        )
+        self._reconnect_timer = threading.Timer(delay, lambda: self._attempt_reconnect(reason))
+        self._reconnect_timer.daemon = True
+        self._reconnect_timer.start()
+
+    def _attempt_reconnect(self, reason: str = "connection lost"):
+        """Attempt to reconnect to broker with fresh JWT"""
+        if self._shutdown_requested:
+            return
+
+        try:
+            logger.info(f"Attempting reconnection to {self.broker['name']} (reason: {reason})...")
+
+            # Stop the loop if it's still running (websocket mode requires clean restart)
+            try:
+                self.client.loop_stop()
+            except Exception:
+                pass
+
+            self._set_jwt_credentials()
+
+            # Reconnect and restart loop
+            self.client.connect(self.broker["host"], self.broker["port"], keepalive=60)
+            self.client.loop_start()
+            self._loop_running = True
+        except Exception as e:
+            logger.error(f"Reconnection failed for {self.broker['name']}: {e}")
+            self._schedule_reconnect()  # Try again later
+
+    def _set_jwt_credentials(self):
+        """Set JWT token credentials before connecting (CONNECT handshake only)"""
+        try:
+            token = self._generate_jwt()
+            username = f"v1_{self.public_key}"
+            self.client.username_pw_set(username=username, password=token)
+            self._connect_time = datetime.now(UTC)
+            logger.debug(f"JWT credentials set for {self.broker['name']}")
+            logger.debug(f"Using username: {username}")
+            logger.debug(f"Public key: {self.public_key[:16]}...{self.public_key[-16:]}")
+        except Exception as e:
+            logger.error(f"Failed to set JWT credentials for {self.broker['name']}: {e}")
+            raise
+
+    def connect(self):
+        """Establish connection to broker"""
+        self._shutdown_requested = False
+
+        # Conditional TLS setup
+        if self.use_tls:
+            import ssl
+
+            self.client.tls_set(cert_reqs=ssl.CERT_REQUIRED, tls_version=ssl.PROTOCOL_TLS_CLIENT)
+            self.client.tls_insecure_set(False)
+            self._tls_verified = True
+            protocol = "wss"
+        else:
+            protocol = "ws"
+
+        # Set JWT credentials before CONNECT handshake
+        self._set_jwt_credentials()
+
+        logger.info(
+            f"Connecting to {self.broker['name']} "
+            f"({protocol}://{self.broker['host']}:{self.broker['port']}) ..."
+        )
+
+        self.client.connect(self.broker["host"], self.broker["port"], keepalive=60)
+        self.client.loop_start()
+        self._loop_running = True
+
+    def disconnect(self):
+        """Disconnect from broker"""
+        self._shutdown_requested = True
+        self._running = False
+        self._loop_running = False
+
+        # Cancel any pending timers
+        if self._reconnect_timer:
+            self._reconnect_timer.cancel()
+            self._reconnect_timer = None
+        if self._jwt_refresh_timer:
+            self._jwt_refresh_timer.cancel()
+            self._jwt_refresh_timer = None
+
+        self.client.loop_stop()
+        self.client.disconnect()
+        logger.info(f"Disconnected from {self.broker['name']}")
+
+    def publish(self, topic: str, payload: str, retain: bool = False):
+        """Publish message to broker"""
+        if self._running:
+            result = self.client.publish(topic, payload, retain=retain)
+            return result
+        return None
+
+    def is_connected(self) -> bool:
+        """Check if connection is active"""
+        return self._running
+
+    def has_pending_reconnect(self) -> bool:
+        """Check if a reconnection is scheduled"""
+        return self._reconnect_timer is not None and self._reconnect_timer.is_alive()
+
+    def should_reconnect_for_token_expiry(self) -> bool:
+        """Check if connection should be reconnected due to JWT expiry (at 80% of lifetime)"""
+        if not self._connect_time:
+            return False
+        elapsed = (datetime.now(UTC) - self._connect_time).total_seconds()
+        expiry_seconds = self.jwt_expiry_minutes * 60
+        # Stagger refresh by 5% per broker to prevent simultaneous disconnects
+        # Broker 0: 80%, Broker 1: 85%, Broker 2: 90%, etc.
+        stagger_offset = self.broker_index * 0.05
+        refresh_threshold = 0.80 + stagger_offset
+        return elapsed >= expiry_seconds * refresh_threshold
+
+    def _schedule_jwt_refresh(self):
+        """Schedule proactive JWT refresh before token expires"""
+        if self._jwt_refresh_timer:
+            self._jwt_refresh_timer.cancel()
+
+        expiry_seconds = self.jwt_expiry_minutes * 60
+        # Stagger refresh by 5% per broker to prevent simultaneous disconnects
+        # Broker 0: 80%, Broker 1: 85%, Broker 2: 90%, etc.
+        stagger_offset = self.broker_index * 0.05
+        refresh_threshold = 0.80 + stagger_offset
+        refresh_delay = expiry_seconds * refresh_threshold
+
+        logger.info(
+            f"JWT refresh scheduled for {self.broker['name']} in {refresh_delay:.0f}s "
+            f"({refresh_threshold*100:.0f}% of {self.jwt_expiry_minutes}min token lifetime)"
+        )
+        self._jwt_refresh_timer = threading.Timer(refresh_delay, self.reconnect_for_token_expiry)
+        self._jwt_refresh_timer.daemon = True
+        self._jwt_refresh_timer.start()
+
+    def reconnect_for_token_expiry(self):
+        """Proactively reconnect with new JWT before current one expires"""
+        if not self._running:
+            return
+
+        logger.info(f"JWT token expiring soon for {self.broker['name']}, refreshing...")
+        self._running = False
+        self._jwt_refresh_timer = None
+
+        self._schedule_reconnect(reason="JWT token expiry")
+        self.client.disconnect()
+
+
+# ====================================================================
+# MeshCore → MQTT Publisher with Ed25519 auth token
+# ====================================================================
+class MeshCoreToMqttJwtPusher:
+
+    def __init__(
+        self,
+        local_identity,
+        config: dict,
+        jwt_expiry_minutes: int = 10,
+        use_tls: bool = True,
+        stats_provider: Optional[Callable[[], dict]] = None,
+    ):
+        # Store local identity and get public key
+        self.local_identity = local_identity
+        public_key = local_identity.get_public_key().hex().upper()
+
+        # Extract values from config
+        from ..config import get_node_info
+
+        node_info = get_node_info(config)
+
+        iata_code = node_info["iata_code"]
+        broker_index = node_info.get("broker_index")
+        self.email = node_info.get("email", "")
+        self.owner = node_info.get("owner", "")
+        status_interval = node_info["status_interval"]
+        node_name = node_info["node_name"]
+        radio_config = node_info["radio_config"]
+
+        # Get additional brokers from config (optional)
+        letsmesh_config = config.get("letsmesh", {})
+        additional_brokers = letsmesh_config.get("additional_brokers", [])
+
+        # Determine which brokers to connect to
+        if broker_index == -2:
+            # Custom brokers only - no built-in brokers
+            self.brokers = []
+            logger.info("Custom broker mode: using only user-defined brokers")
+        elif broker_index is None or broker_index == -1:
+            # Connect to all built-in brokers + additional ones
+            self.brokers = LETSMESH_BROKERS.copy()
+            logger.info(
+                f"Multi-broker mode: connecting to all {len(LETSMESH_BROKERS)} built-in brokers"
+            )
+        else:
+
+            if broker_index >= len(LETSMESH_BROKERS):
+                raise ValueError(f"Invalid broker_index {broker_index}")
+            self.brokers = [LETSMESH_BROKERS[broker_index]]
+            logger.info(f"Single broker mode: connecting to {self.brokers[0]['name']}")
+
+        # Add additional brokers from config
+        if additional_brokers:
+            for broker_config in additional_brokers:
+                if all(k in broker_config for k in ["name", "host", "port", "audience"]):
+                    self.brokers.append(broker_config)
+                    logger.info(f"Added custom broker: {broker_config['name']}")
+                else:
+                    logger.warning(f"Skipping invalid broker config: {broker_config}")
+
+        # Validate that we have at least one broker
+        if not self.brokers:
+            raise ValueError(
+                "No brokers configured. Either set broker_index to a valid value "
+                "or provide additional_brokers in config."
+            )
+
+        self.local_identity = local_identity
+        self.public_key = public_key
+        self.iata_code = iata_code
+        self.jwt_expiry_minutes = jwt_expiry_minutes
+        self.use_tls = use_tls
+        self.status_interval = status_interval
+        self.app_version = __version__
+        self.node_name = node_name
+        self.radio_config = radio_config
+        self.stats_provider = stats_provider
+        self._status_task = None
+        self._running = False
+        self._shutdown_requested = False
+        self._lock = threading.Lock()
+        self._connect_timers: List[threading.Timer] = []
+
+        # Create broker connections
+        self.connections: List[_BrokerConnection] = []
+        for idx, broker in enumerate(self.brokers):
+            conn = _BrokerConnection(
+                broker=broker,
+                local_identity=self.local_identity,
+                public_key=self.public_key,
+                iata_code=self.iata_code,
+                jwt_expiry_minutes=self.jwt_expiry_minutes,
+                use_tls=self.use_tls,
+                email=self.email,
+                owner=self.owner,
+                broker_index=idx,
+                on_connect_callback=self._on_broker_connected,
+                on_disconnect_callback=self._on_broker_disconnected,
+            )
+            self.connections.append(conn)
+
+        logger.info(f"Initialized with {len(self.connections)} broker connection(s)")
+
+    def _on_broker_connected(self, broker_name: str):
+        """Callback when a broker connects"""
+        if self._shutdown_requested:
+            return
+
+        # Publish initial status on first connection
+        if not self._status_task and self.status_interval > 0:
+            self._running = True
+            self.publish_status(
+                state="online", origin=self.node_name, radio_config=self.radio_config
+            )
+            # Start heartbeat thread
+            self._status_task = threading.Thread(target=self._status_heartbeat_loop, daemon=True)
+            self._status_task.start()
+            logger.info(f"Started status heartbeat (interval: {self.status_interval}s)")
+
+    def _on_broker_disconnected(self, broker_name: str):
+        """Callback when a broker disconnects"""
+        # Check if all connections are down AND none have pending reconnects
+        all_down = all(not conn.is_connected() for conn in self.connections)
+        any_reconnecting = any(conn.has_pending_reconnect() for conn in self.connections)
+
+        if all_down and not any_reconnecting:
+            logger.warning("All broker connections lost with no pending reconnects")
+        elif all_down:
+            logger.info("All brokers temporarily disconnected, reconnects pending")
+
+    def connect(self):
+        """Establish connections to all configured brokers"""
+        self._shutdown_requested = False
+        self._connect_timers = []
+
+        for idx, conn in enumerate(self.connections):
+            try:
+                if idx == 0:
+                    # Connect first broker immediately
+                    conn.connect()
+                else:
+                    # Stagger additional brokers using background timers
+                    delay = idx * 30
+                    logger.info(f"Staggering connection to {conn.broker['name']} by {delay}s")
+                    timer = threading.Timer(delay, lambda c=conn: self._delayed_connect(c))
+                    timer.daemon = True
+                    timer.start()
+                    self._connect_timers.append(timer)
+            except Exception as e:
+                logger.error(f"Failed to connect to {conn.broker['name']}: {e}")
+
+    def _delayed_connect(self, conn):
+        """Connect a broker after a delay (called by timer)"""
+        if self._shutdown_requested:
+            return
+
+        try:
+            conn.connect()
+        except Exception as e:
+            logger.error(f"Failed to connect to {conn.broker['name']}: {e}")
+
+    def disconnect(self):
+        """Disconnect from all brokers"""
+        self._shutdown_requested = True
+
+        # Cancel any delayed connect timers first.
+        for timer in self._connect_timers:
+            try:
+                timer.cancel()
+            except Exception:
+                pass
+        self._connect_timers = []
+
+        # Stop the heartbeat loop
+        self._running = False
+
+        # Publish offline status before disconnecting
+        try:
+            self.publish_status(state="offline", origin=self.node_name, radio_config=self.radio_config)
+        except Exception:
+            pass
+
+        # Disconnect all brokers
+        for conn in self.connections:
+            try:
+                conn.disconnect()
+            except Exception as e:
+                logger.error(f"Error disconnecting from {conn.broker['name']}: {e}")
+
+        self._status_task = None
+        logger.info("Disconnected from all brokers")
+
+    def _status_heartbeat_loop(self):
+        """Background thread that publishes periodic status updates"""
+        import time
+
+        while self._running:
+            try:
+                # Publish status (JWT refresh now handled by individual broker timers)
+                self.publish_status(
+                    state="online", origin=self.node_name, radio_config=self.radio_config
+                )
+                logger.debug(f"Status heartbeat sent (next in {self.status_interval}s)")
+
+                time.sleep(self.status_interval)
+            except Exception as e:
+                logger.error(f"Status heartbeat error: {e}")
+                time.sleep(self.status_interval)
+
+    # ----------------------------------------------------------------
+    # Packet helpers
+    # ----------------------------------------------------------------
+    def _process_packet(self, pkt: dict) -> dict:
+        return {"timestamp": datetime.now(UTC).isoformat(), "origin_id": self.public_key, **pkt}
+
+    def _topic(self, subtopic: str) -> str:
+        return f"meshcore/{self.iata_code}/{self.public_key}/{subtopic}"
+
+    def publish_packet(self, pkt: dict, subtopic="packets", retain=False):
+        return self.publish(subtopic, self._process_packet(pkt), retain)
+
+    def publish_raw_data(self, raw_hex: str, subtopic="raw", retain=False):
+        pkt = {"type": "raw", "data": raw_hex, "bytes": len(raw_hex) // 2}
+        return self.publish_packet(pkt, subtopic, retain)
+
+    def publish_status(
+        self,
+        state: str = "online",
+        location: Optional[dict] = None,
+        extra_stats: Optional[dict] = None,
+        origin: Optional[str] = None,
+        radio_config: Optional[str] = None,
+    ):
+        """
+        Publish device status/heartbeat message
+
+        Args:
+            state: Device state (online/offline)
+            location: Optional dict with latitude/longitude
+            extra_stats: Optional additional statistics to include
+            origin: Node name/description
+            radio_config: Radio configuration string (freq,bw,sf,cr)
+        """
+        # Get live stats from provider if available
+        if self.stats_provider:
+            live_stats = self.stats_provider()
+        else:
+            live_stats = {"uptime_secs": 0, "packets_sent": 0, "packets_received": 0}
+
+        status = {
+            "status": state,
+            "timestamp": datetime.now(UTC).isoformat(),
+            "origin": origin or self.node_name,
+            "origin_id": self.public_key,
+            "model": "PyMC-Repeater",
+            "firmware_version": self.app_version,
+            "radio": radio_config or self.radio_config,
+            "client_version": f"pyMC_repeater/{self.app_version}",
+            "stats": {**live_stats, "errors": 0, "queue_len": 0, **(extra_stats or {})},
+        }
+
+        if location:
+            status["location"] = location
+
+        return self.publish("status", status, retain=False)
+
+    def publish(self, subtopic: str, payload: dict, retain: bool = False):
+        """Publish message to all connected brokers"""
+        topic = self._topic(subtopic)
+        message = json.dumps(payload)
+
+        results = []
+        with self._lock:
+            for conn in self.connections:
+                if conn.is_connected():
+                    result = conn.publish(topic, message, retain=retain)
+                    results.append((conn.broker["name"], result))
+                    logger.debug(f"Published to {conn.broker['name']}/{topic}")
+
+        if not results:
+            logger.warning(f"No active broker connections for publishing to {topic}")
+
+        return results
+
+
+# ====================================================================
+# Helper Functions
+# ====================================================================
+
+
+def get_mqtt_error_message(rc: int, is_disconnect: bool = False) -> str:
+    """
+    Get human-readable MQTT error message.
+
+    Args:
+        rc: Return code from paho-mqtt
+        is_disconnect: True if from on_disconnect, False if from on_connect
+
+    Returns:
+        Human-readable error message
+    """
+    if HAS_REASON_CODES:
+        try:
+            # ReasonCode object has getName() method and value property
+            reason = ReasonCode(mqtt.CONNACK if not is_disconnect else mqtt.DISCONNECT, identifier=rc)
+            name = reason.getName() if hasattr(reason, 'getName') else str(reason)
+            return f"{name} (code {rc})"
+        except Exception as e:
+            # Log the exception for debugging
+            logger.debug(f"Could not decode reason code {rc}: {e}")
+
+    # Fallback to manual mappings - Extended with MQTT v5 codes
+    connect_errors = {
+        0: "Connection accepted",
+        1: "Incorrect protocol version",
+        2: "Invalid client identifier",
+        3: "Server unavailable",
+        4: "Bad username or password (JWT invalid)",
+        5: "Not authorized (JWT signature/format invalid)",
+        # MQTT v5 codes
+        128: "Unspecified error",
+        129: "Malformed packet",
+        130: "Protocol error",
+        131: "Implementation specific error",
+        132: "Unsupported protocol version",
+        133: "Client identifier not valid",
+        134: "Bad username or password",
+        135: "Not authorized",
+        136: "Server unavailable",
+        137: "Server busy",
+        138: "Banned",
+        140: "Bad authentication method",
+        144: "Topic name invalid",
+        149: "Packet too large",
+        151: "Quota exceeded",
+        153: "Payload format invalid",
+        154: "Retain not supported",
+        155: "QoS not supported",
+        156: "Use another server",
+        157: "Server moved",
+        159: "Connection rate exceeded",
+    }
+
+    disconnect_errors = {
+        0: "Normal disconnect",
+        1: "Unacceptable protocol version",
+        2: "Identifier rejected",
+        3: "Server unavailable",
+        4: "Bad username or password",
+        5: "Not authorized",
+        7: "Connection lost / network error",
+        16: "Connection lost / protocol error",
+        17: "Client timeout",
+        # MQTT v5 codes
+        4: "Disconnect with Will message",
+        128: "Unspecified error",
+        129: "Malformed packet",
+        130: "Protocol error",
+        131: "Implementation specific error",
+        135: "Not authorized",
+        137: "Server busy",
+        139: "Server shutting down",
+        141: "Keep alive timeout",
+        142: "Session taken over",
+        143: "Topic filter invalid",
+        144: "Topic name invalid",
+        147: "Receive maximum exceeded",
+        148: "Topic alias invalid",
+        149: "Packet too large",
+        150: "Message rate too high",
+        151: "Quota exceeded",
+        152: "Administrative action",
+        153: "Payload format invalid",
+        154: "Retain not supported",
+        155: "QoS not supported",
+        156: "Use another server",
+        157: "Server moved",
+        158: "Shared subscriptions not supported",
+        159: "Connection rate exceeded",
+        160: "Maximum connect time",
+        161: "Subscription identifiers not supported",
+        162: "Wildcard subscriptions not supported",
+    }
+
+    error_dict = disconnect_errors if is_disconnect else connect_errors
+    return error_dict.get(rc, f"Unknown error code {rc}")

repeater/data_acquisition/mqtt_handler.py

@@ -102,6 +102,7 @@ class _BrokerConnection:
         self._reconnect_timer = None
         self._max_reconnect_delay = 300  # 5 minutes max
         self._jwt_refresh_timer = None
+        self._shutdown_requested = False
         self.transport = broker.get('transport', 'websockets')
         
         self.use_jwt_auth = broker.get('use_jwt_auth', False)
@@ -211,6 +212,12 @@ class _BrokerConnection:
         was_running = self._running
         self._running = False
 
+        if self._shutdown_requested:
+            logger.info(f"Clean disconnect from {self.broker['name']}")
+            if self._on_disconnect_callback:
+                self._on_disconnect_callback(self.broker["name"])
+            return
+
         if rc != 0:  # Unexpected disconnect
             error_msg = get_mqtt_error_message(rc, is_disconnect=True)
             logger.warning(f"Disconnected from {self.broker['name']} (rc={rc}): {error_msg}")
@@ -224,6 +231,9 @@ class _BrokerConnection:
 
     def _schedule_reconnect(self, reason: str = "connection lost"):
         """Schedule reconnection with exponential backoff"""
+        if self._shutdown_requested:
+            return
+
         if self._reconnect_timer:
             self._reconnect_timer.cancel()
 
@@ -240,6 +250,9 @@ class _BrokerConnection:
 
     def _attempt_reconnect(self, reason: str = "connection lost"):
         """Attempt to reconnect to broker with fresh JWT"""
+        if self._shutdown_requested:
+            return
+
         try:
             logger.info(f"Attempting reconnection to {self.broker['name']} (reason: {reason})...")
 
@@ -284,6 +297,8 @@ class _BrokerConnection:
 
     def connect(self):
         """Establish connection to broker"""
+        self._shutdown_requested = False
+
         # Conditional TLS setup
         if self.enabled == False:
             logger.info(f"Connection to {self.broker['name']} is disabled in configuration")
@@ -318,6 +333,7 @@ class _BrokerConnection:
 
     def disconnect(self):
         """Disconnect from broker"""
+        self._shutdown_requested = False
         self._running = False
         self._loop_running = False
 
@@ -443,7 +459,9 @@ class MeshCoreToMqttPusher:
         self.stats_provider = stats_provider
         self._status_task = None
         self._running = False
+        self._shutdown_requested = False        
         self._lock = threading.Lock()
+        self._connect_timers: List[threading.Timer] = []
 
         # Initialize brokers list        
         mqtt_brokers_config = config.get("mqtt_brokers", {})
@@ -603,6 +621,9 @@ class MeshCoreToMqttPusher:
 
     def _on_broker_connected(self, broker_name: str):
         """Callback when a broker connects"""
+        if self._shutdown_requested:
+            return
+
         # Publish initial status on first connection
         if not self._status_task and self.status_interval > 0:
             self._running = True
@@ -628,6 +649,9 @@ class MeshCoreToMqttPusher:
 
     def connect(self):
         """Establish connections to all configured brokers"""
+        self._shutdown_requested = False
+        self._connect_timers = []
+
         for idx, conn in enumerate(self.connections):
             try:
                 if idx == 0:
@@ -640,11 +664,15 @@ class MeshCoreToMqttPusher:
                     timer = threading.Timer(delay, lambda c=conn: self._delayed_connect(c))
                     timer.daemon = True
                     timer.start()
+                    self._connect_timers.append(timer)                    
             except Exception as e:
                 logger.error(f"Failed to connect to {conn.broker['name']}: {e}")
 
     def _delayed_connect(self, conn):
         """Connect a broker after a delay (called by timer)"""
+        if self._shutdown_requested:
+            return
+
         try:
             conn.connect()
         except Exception as e:
@@ -652,15 +680,24 @@ class MeshCoreToMqttPusher:
 
     def disconnect(self):
         """Disconnect from all brokers"""
+        self._shutdown_requested = True
+
+        # Cancel any delayed connect timers first.
+        for timer in self._connect_timers:
+            try:
+                timer.cancel()
+            except Exception:
+                pass
+        self._connect_timers = []
+
         # Stop the heartbeat loop
         self._running = False
 
         # Publish offline status before disconnecting
-        self.publish_status(state="offline", origin=self.node_name, radio_config=self.radio_config)
-
-        import time
-
-        time.sleep(0.5)  # Give time for messages to be sent
+        try:
+            self.publish_status(state="offline", origin=self.node_name, radio_config=self.radio_config)
+        except Exception:
+            pass
 
         # Disconnect all brokers
         for conn in self.connections:
@@ -668,7 +705,8 @@ class MeshCoreToMqttPusher:
                 conn.disconnect()
             except Exception as e:
                 logger.error(f"Error disconnecting from {conn.broker['name']}: {e}")
-
+        
+        self._status_task = None
         logger.info("Disconnected from all brokers")
 
     def _status_heartbeat_loop(self):

repeater/data_acquisition/rrdtool_handler.py

@@ -19,6 +19,10 @@ class RRDToolHandler:
         self.rrd_path = self.storage_dir / "metrics.rrd"
         self.available = RRDTOOL_AVAILABLE
         self._init_rrd()
+        # Batch RRD updates: track pending update and last cached info
+        self._pending_rrd_update = None
+        self._last_rrd_info_time = 0
+        self._last_rrd_info_cache = None
 
     def _init_rrd(self):
         if not self.available:
@@ -73,20 +77,41 @@ class RRDToolHandler:
             logger.error(f"Failed to create RRD database: {e}")
 
     def update_packet_metrics(self, record: dict, cumulative_counts: dict):
+        """Buffer packet metrics for batch RRD update instead of per-packet writes.
+        
+        RRD uses 60-second time steps, so we batch updates within each period
+        and only write when the time period changes or buffer is full.
+        """
         if not self.available or not self.rrd_path.exists():
             return
 
         try:
             timestamp = int(record.get("timestamp", time.time()))
 
-            try:
-                info = rrdtool.info(str(self.rrd_path))
-                last_update = int(info.get("last_update", timestamp - 60))
-                if timestamp <= last_update:
+            # Cache RRD info for up to 5 seconds to avoid repeated rrdtool.info() calls
+            now = time.time()
+            if now - self._last_rrd_info_time > 5 or self._last_rrd_info_cache is None:
+                try:
+                    self._last_rrd_info_cache = rrdtool.info(str(self.rrd_path))
+                    self._last_rrd_info_time = now
+                except Exception as e:
+                    logger.debug(f"Failed to cache RRD info: {e}")
+                    self._last_rrd_info_cache = None
                     return
-            except Exception as e:
-                logger.debug(f"Failed to get RRD info for packet update: {e}")
 
+            if self._last_rrd_info_cache is None:
+                return
+
+            last_update = int(self._last_rrd_info_cache.get("last_update", timestamp - 60))
+            
+            # Skip if timestamp is in same or earlier time period than last update
+            # (RRD step is 60 seconds)
+            if timestamp <= last_update:
+                # But still buffer cumulative counts for when we do update
+                self._pending_rrd_update = (timestamp, cumulative_counts, record)
+                return
+
+            # Build update string from cumulative counts
             rx_total = cumulative_counts.get("rx_total", 0)
             tx_total = cumulative_counts.get("tx_total", 0)
             drop_total = cumulative_counts.get("drop_total", 0)
@@ -97,7 +122,6 @@ class RRDToolHandler:
                 type_values.append(str(type_counts.get(f"type_{i}", 0)))
             type_values.append(str(type_counts.get("type_other", 0)))
 
-            # Handle None values for TX packets - use 'U' (unknown) for RRD
             rssi = record.get("rssi")
             snr = record.get("snr")
             score = record.get("score")
@@ -116,7 +140,11 @@ class RRDToolHandler:
             type_values_str = ":".join(type_values)
             values = f"{basic_values}:{type_values_str}"
 
+            # Write to RRD - this is now only called once per 60-second period
             rrdtool.update(str(self.rrd_path), values)
+            # Invalidate cache so next period fetches fresh info
+            self._last_rrd_info_cache = None
+            self._pending_rrd_update = None
 
         except Exception as e:
             logger.error(f"Failed to update RRD packet metrics: {e}")

repeater/data_acquisition/storage_collector.py

@@ -1,3 +1,4 @@
+import asyncio
 import json
 import logging
 import time
@@ -18,6 +19,7 @@ class StorageCollector:
         self.config = config
         self.repeater_handler = repeater_handler
         self.glass_publish_callback = None
+        self._pending_tasks = set()
 
         storage_dir_cfg = (
             config.get("storage", {}).get("storage_dir")
@@ -68,6 +70,33 @@ class StorageCollector:
         except ImportError:
             logger.debug("WebSocket handler not available")
 
+    def _track_task(self, task: asyncio.Task):
+        """Track background task for lifecycle management and error handling."""
+        self._pending_tasks.add(task)
+
+        def on_done(t: asyncio.Task):
+            self._pending_tasks.discard(t)
+            try:
+                t.result()
+            except asyncio.CancelledError:
+                pass
+            except Exception as e:
+                logger.error(f"Background task error: {e}", exc_info=True)
+
+        task.add_done_callback(on_done)
+
+    def _schedule_background(self, coro_factory, *args, sync_fallback=None):
+        """Schedule a coroutine if a loop exists; otherwise run sync fallback."""
+        try:
+            loop = asyncio.get_running_loop()
+        except RuntimeError:
+            if sync_fallback is not None:
+                sync_fallback(*args)
+            return
+
+        task = loop.create_task(coro_factory(*args))
+        self._track_task(task)
+
     def _get_live_stats(self) -> dict:
         """Get live stats from RepeaterHandler"""
         if not self.repeater_handler:
@@ -125,40 +154,48 @@ class StorageCollector:
             f"transmitted={packet_record.get('transmitted')}"
         )
 
-        # Store to local databases and publish to local MQTT
+        # HOT PATH: Store to local databases only (fast, non-blocking)
         self.sqlite_handler.store_packet(packet_record)
         cumulative_counts = self.sqlite_handler.get_cumulative_counts()
         self.rrd_handler.update_packet_metrics(packet_record, cumulative_counts)
+
+        # DEFERRED: Publish to network sinks and WebSocket in background tasks
+        # This prevents network latency from blocking packet processing
+        self._schedule_background(
+            self._deferred_publish,
+            packet_record,
+            skip_mqtt_if_invalid,
+            sync_fallback=self._publish_packet_sync,
+        )
+
+    async def _deferred_publish(self, packet_record: dict, skip_mqtt: bool):
+        """Deferred background task for all network publishing operations."""
+        try:
+            self._publish_packet_sync(packet_record, skip_mqtt)
+        except Exception as e:
+            logger.error(f"Deferred publish failed: {e}", exc_info=True)
+
+    def _publish_packet_sync(self, packet_record: dict, skip_mqtt: bool):
+        """Publish packet updates synchronously (used when no asyncio loop is active)."""
         self._publish_to_glass(packet_record, "packet")
 
-        # Broadcast to WebSocket clients for real-time updates
         if self.websocket_available:
             try:
                 self.websocket_broadcast_packet(packet_record)
-
-                # Broadcast 24-hour packet stats (same as /api/packet_stats?hours=24)
                 packet_stats_24h = self.sqlite_handler.get_packet_stats(hours=24)
                 uptime_seconds = (
                     time.time() - self.repeater_handler.start_time if self.repeater_handler else 0
                 )
-
                 self.websocket_broadcast_stats(
                     {
                         "packet_stats": packet_stats_24h,
-                        "system_stats": {
-                            "uptime_seconds": uptime_seconds,
-                        },
+                        "system_stats": {"uptime_seconds": uptime_seconds},
                     }
                 )
             except Exception as e:
                 logger.debug(f"WebSocket broadcast failed: {e}")
 
-        # # Publish to mqtt if enabled (skip invalid packets if requested)
-        # if skip_mqtt_if_invalid and packet_record.get("drop_reason"):
-        #     logger.debug(
-        #         f"Skipping mqtt publish for packet with drop_reason: {packet_record.get('drop_reason')}"
-        #     )
-        # else:
+
         self._publish_packet_to_mqtt(packet_record)
 
     def _publish_packet_to_mqtt(self, packet_record: dict):
@@ -187,24 +224,68 @@ class StorageCollector:
             logger.error(f"Failed to publish packet to mqtt: {e}", exc_info=True)
 
     def record_advert(self, advert_record: dict):
+        """Record advert to storage and defer network publishing to background tasks."""
         self.sqlite_handler.store_advert(advert_record)
+        self._schedule_background(
+            self._deferred_publish_advert,
+            advert_record,
+            sync_fallback=self._publish_advert_sync,
+        )
+
+    async def _deferred_publish_advert(self, advert_record: dict):
+        """Deferred background task for advert publishing."""
+        try:
+            self._publish_advert_sync(advert_record)
+        except Exception as e:
+            logger.error(f"Deferred advert publish failed: {e}", exc_info=True)
+
+    def _publish_advert_sync(self, advert_record: dict):
         if self.mqtt_handler:
-            self.mqtt_handler.publish_mqtt("advert", advert_record)
+            self.mqtt_handler.publish("advert", advert_record)
         self._publish_to_glass(advert_record, "advert")
 
     def record_noise_floor(self, noise_floor_dbm: float):
+        """Record noise floor to storage and defer network publishing to background tasks."""
         noise_record = {"timestamp": time.time(), "noise_floor_dbm": noise_floor_dbm}
         self.sqlite_handler.store_noise_floor(noise_record)
+        self._schedule_background(
+            self._deferred_publish_noise_floor,
+            noise_record,
+            sync_fallback=self._publish_noise_floor_sync,
+        )
+
+    async def _deferred_publish_noise_floor(self, noise_record: dict):
+        """Deferred background task for noise floor publishing."""
+        try:
+            self._publish_noise_floor_sync(noise_record)
+        except Exception as e:
+            logger.error(f"Deferred noise floor publish failed: {e}", exc_info=True)
+
+    def _publish_noise_floor_sync(self, noise_record: dict):
         if self.mqtt_handler:
-            self.mqtt_handler.publish_mqtt("noise_floor", noise_record)
+            self.mqtt_handler.publish("noise_floor", noise_record)
         self._publish_to_glass(noise_record, "noise_floor")
 
     def record_crc_errors(self, count: int):
-        """Record a batch of CRC errors detected since last poll."""
+        """Record a batch of CRC errors detected since last poll and defer publishing."""
         crc_record = {"timestamp": time.time(), "count": count}
         self.sqlite_handler.store_crc_errors(crc_record)
+        self._schedule_background(
+            self._deferred_publish_crc_errors,
+            crc_record,
+            sync_fallback=self._publish_crc_errors_sync,
+        )
+
+    async def _deferred_publish_crc_errors(self, crc_record: dict):
+        """Deferred background task for CRC error publishing."""
+        try:
+            self._publish_crc_errors_sync(crc_record)
+        except Exception as e:
+            logger.error(f"Deferred CRC errors publish failed: {e}", exc_info=True)
+
+    def _publish_crc_errors_sync(self, crc_record: dict):
         if self.mqtt_handler:
-            self.mqtt_handler.publish_mqtt("crc_errors", crc_record)
+            self.mqtt_handler.publish("crc_errors", crc_record)
         self._publish_to_glass(crc_record, "crc_errors")
 
     def get_crc_error_count(self, hours: int = 24) -> int:
@@ -240,6 +321,20 @@ class StorageCollector:
     ) -> list:
         return self.sqlite_handler.get_airtime_data(start_timestamp, end_timestamp, limit)
 
+    def get_airtime_buckets(
+        self,
+        start_timestamp: float,
+        end_timestamp: float,
+        bucket_seconds: int = 60,
+        sf: int = 9,
+        bw_hz: int = 62500,
+        cr: int = 5,
+        preamble: int = 17,
+    ) -> dict:
+        return self.sqlite_handler.get_airtime_buckets(
+            start_timestamp, end_timestamp, bucket_seconds, sf, bw_hz, cr, preamble
+        )
+
     def get_packet_by_hash(self, packet_hash: str) -> Optional[dict]:
         return self.sqlite_handler.get_packet_by_hash(packet_hash)
 
@@ -298,6 +393,11 @@ class StorageCollector:
         return self.sqlite_handler.get_noise_floor_stats(hours)
 
     def close(self):
+        # Cancel all pending background tasks
+        for task in self._pending_tasks:
+            if not task.done():
+                task.cancel()
+
         if self.mqtt_handler:
             try:
                 self.mqtt_handler.disconnect()

repeater/engine.py

@@ -3,7 +3,7 @@ import copy
 import logging
 import struct
 import time
-from collections import OrderedDict
+from collections import OrderedDict, deque
 from typing import Optional, Tuple
 
 from pymc_core.node.handlers.base import BaseHandler
@@ -99,8 +99,9 @@ class RepeaterHandler(BaseHandler):
         self.rx_count = 0
         self.forwarded_count = 0
         self.dropped_count = 0
-        self.recent_packets = []
         self.max_recent_packets = 50
+        self.recent_packets = deque(maxlen=self.max_recent_packets)
+        self._recent_hash_index = {}
         self.start_time = time.time()
         # Flood/direct and duplicate counters (for GET_STATUS / firmware RepeaterStats)
         self.recv_flood_count = 0
@@ -126,6 +127,7 @@ class RepeaterHandler(BaseHandler):
         self.last_db_cleanup = time.time()
         self.noise_floor_interval = NOISE_FLOOR_INTERVAL  # 30 seconds
         self._background_task = None
+        self._cached_noise_floor = None
         self._last_crc_error_count = 0  # Track radio counter for delta persistence
         
         # Cache transport keys for efficient lookup
@@ -157,6 +159,7 @@ class RepeaterHandler(BaseHandler):
                 pass
 
         route_type = packet.header & PH_ROUTE_MASK
+        pkt_hash_full = packet.calculate_packet_hash().hex().upper()
 
         # TX mode: forward (repeat on), monitor (no repeat, tenants can TX), no_tx (all TX off)
         mode = self.config.get("repeater", {}).get("mode", "forward")
@@ -197,7 +200,7 @@ class RepeaterHandler(BaseHandler):
         # For local transmissions, create a direct transmission result (if local TX allowed)
         if local_transmission and allow_local_tx:
             # Mark local packet as seen to prevent duplicate processing when received back
-            self.mark_seen(packet)
+            self.mark_seen(packet, packet_hash=pkt_hash_full)
             # Calculate transmission delay for local packets
             delay = self._calculate_tx_delay(packet, snr)
             result = (packet, delay)
@@ -318,8 +321,7 @@ class RepeaterHandler(BaseHandler):
             )
 
         # Check if this is a duplicate
-        pkt_hash = packet.calculate_packet_hash().hex().upper()
-        is_dupe = pkt_hash in self.seen_packets and not transmitted
+        is_dupe = pkt_hash_full in self.seen_packets and not transmitted
 
         # Set drop reason for duplicates and count flood vs direct dups
         if is_dupe and drop_reason is None:
@@ -356,6 +358,7 @@ class RepeaterHandler(BaseHandler):
             lbt_attempts=lbt_attempts,
             lbt_backoff_delays_ms=lbt_backoff_delays_ms,
             lbt_channel_busy=lbt_channel_busy,
+            packet_hash=pkt_hash_full,
         )
 
         # Store packet record to persistent storage
@@ -371,30 +374,24 @@ class RepeaterHandler(BaseHandler):
 
         # If this is a duplicate, try to attach it to the original packet
         if is_dupe and len(self.recent_packets) > 0:
-            # Find the original packet with same hash
-            for idx in range(len(self.recent_packets) - 1, -1, -1):
-                prev_pkt = self.recent_packets[idx]
-                if prev_pkt.get("packet_hash") == packet_record["packet_hash"]:
-                    # Add duplicate to original packet's duplicate list
-                    if "duplicates" not in prev_pkt:
-                        prev_pkt["duplicates"] = []
-                    if len(prev_pkt["duplicates"]) < self.max_duplicates_per_packet:
-                        prev_pkt["duplicates"].append(packet_record)
-                    # Don't add duplicate to main list, just track in original
-                    break
+            prev_pkt = self._recent_hash_index.get(packet_record["packet_hash"])
+            if prev_pkt is not None:
+                # Add duplicate to original packet's duplicate list
+                if "duplicates" not in prev_pkt:
+                    prev_pkt["duplicates"] = []
+                if len(prev_pkt["duplicates"]) < self.max_duplicates_per_packet:
+                    prev_pkt["duplicates"].append(packet_record)
+                # Don't add duplicate to main list, just track in original
             else:
                 # Original not found, add as regular packet
-                self.recent_packets.append(packet_record)
+                self._append_recent_packet(packet_record)
         else:
             # Not a duplicate or first occurrence
-            self.recent_packets.append(packet_record)
-
-        if len(self.recent_packets) > self.max_recent_packets:
-            self.recent_packets.pop(0)
+            self._append_recent_packet(packet_record)
 
     def log_trace_record(self, packet_record: dict) -> None:
         """Manually log a packet trace record (used by external callers)"""
-        self.recent_packets.append(packet_record)
+        self._append_recent_packet(packet_record)
 
         self.rx_count += 1
         if packet_record.get("transmitted", False):
@@ -409,9 +406,6 @@ class RepeaterHandler(BaseHandler):
             except Exception as e:
                 logger.error(f"Failed to store packet record: {e}")
 
-        if len(self.recent_packets) > self.max_recent_packets:
-            self.recent_packets.pop(0)
-
     def record_packet_only(self, packet: Packet, metadata: dict) -> None:
         """Record a packet for UI/storage without running forwarding or duplicate logic.
 
@@ -448,15 +442,14 @@ class RepeaterHandler(BaseHandler):
             path_hash,
             src_hash,
             dst_hash,
+            packet_hash=packet.calculate_packet_hash().hex().upper(),
         )
         try:
             self.storage.record_packet(packet_record, skip_mqtt_if_invalid=False)
         except Exception as e:
             logger.error(f"Failed to store packet record (record_packet_only): {e}")
             return
-        self.recent_packets.append(packet_record)
-        if len(self.recent_packets) > self.max_recent_packets:
-            self.recent_packets.pop(0)
+        self._append_recent_packet(packet_record)
 
     def record_duplicate(self, packet: Packet, rssi: int = 0, snr: float = 0.0) -> None:
         """Record a known-duplicate packet for UI/storage visibility without forwarding.
@@ -489,6 +482,7 @@ class RepeaterHandler(BaseHandler):
             transmitted=False,
             drop_reason="Duplicate",
             is_duplicate=True,
+            packet_hash=packet.calculate_packet_hash().hex().upper(),
         )
 
         if self.storage:
@@ -499,20 +493,15 @@ class RepeaterHandler(BaseHandler):
 
         # Group under original in recent_packets
         if len(self.recent_packets) > 0:
-            for idx in range(len(self.recent_packets) - 1, -1, -1):
-                prev_pkt = self.recent_packets[idx]
-                if prev_pkt.get("packet_hash") == packet_record["packet_hash"]:
-                    if "duplicates" not in prev_pkt:
-                        prev_pkt["duplicates"] = []
-                    prev_pkt["duplicates"].append(packet_record)
-                    break
+            prev_pkt = self._recent_hash_index.get(packet_record["packet_hash"])
+            if prev_pkt is not None:
+                if "duplicates" not in prev_pkt:
+                    prev_pkt["duplicates"] = []
+                prev_pkt["duplicates"].append(packet_record)
             else:
-                self.recent_packets.append(packet_record)
+                self._append_recent_packet(packet_record)
         else:
-            self.recent_packets.append(packet_record)
-
-        if len(self.recent_packets) > self.max_recent_packets:
-            self.recent_packets.pop(0)
+            self._append_recent_packet(packet_record)
 
     def cleanup_cache(self):
 
@@ -570,9 +559,10 @@ class RepeaterHandler(BaseHandler):
         lbt_attempts: int = 0,
         lbt_backoff_delays_ms=None,
         lbt_channel_busy: bool = False,
+        packet_hash: Optional[str] = None,
     ) -> dict:
         """Build a single packet_record dict for storage and recent_packets."""
-        pkt_hash = packet.calculate_packet_hash().hex().upper()
+        pkt_hash = packet_hash or packet.calculate_packet_hash().hex().upper()
         payload = getattr(packet, "payload", None)
         payload_len = len(payload or b"")
         return {
@@ -609,6 +599,19 @@ class RepeaterHandler(BaseHandler):
             "lbt_channel_busy": lbt_channel_busy,
         }
 
+    def _append_recent_packet(self, packet_record: dict) -> None:
+        """Append packet to bounded recent list and keep hash index aligned."""
+        if len(self.recent_packets) >= self.max_recent_packets:
+            oldest = self.recent_packets.popleft()
+            oldest_hash = oldest.get("packet_hash") if isinstance(oldest, dict) else None
+            if oldest_hash and self._recent_hash_index.get(oldest_hash) is oldest:
+                del self._recent_hash_index[oldest_hash]
+
+        self.recent_packets.append(packet_record)
+        pkt_hash = packet_record.get("packet_hash") if isinstance(packet_record, dict) else None
+        if pkt_hash:
+            self._recent_hash_index[pkt_hash] = packet_record
+
     def _get_drop_reason(self, packet: Packet) -> str:
 
         if self.is_duplicate(packet):
@@ -646,9 +649,9 @@ class RepeaterHandler(BaseHandler):
             return True
         return False
 
-    def mark_seen(self, packet: Packet):
+    def mark_seen(self, packet: Packet, packet_hash: Optional[str] = None):
 
-        pkt_hash = packet.calculate_packet_hash().hex().upper()
+        pkt_hash = packet_hash or packet.calculate_packet_hash().hex().upper()
         self.seen_packets[pkt_hash] = time.time()
 
         if len(self.seen_packets) > self.max_cache_size:
@@ -1047,6 +1050,10 @@ class RepeaterHandler(BaseHandler):
             logger.debug(f"Failed to get noise floor: {e}")
             return None
 
+    def get_cached_noise_floor(self) -> Optional[float]:
+        """Return the last asynchronously-sampled noise floor value."""
+        return self._cached_noise_floor
+
     def get_stats(self) -> dict:
 
         uptime_seconds = time.time() - self.start_time
@@ -1065,8 +1072,8 @@ class RepeaterHandler(BaseHandler):
         rx_per_hour = len(packets_last_hour)
         forwarded_per_hour = sum(1 for p in packets_last_hour if p.get("transmitted", False))
 
-        # Get current noise floor from radio
-        noise_floor_dbm = self.get_noise_floor()
+        # Use cached value sampled by the background timer to avoid serial I/O on stats requests.
+        noise_floor_dbm = self.get_cached_noise_floor()
 
         # Get CRC error count from radio hardware
         radio = self.dispatcher.radio if self.dispatcher else None
@@ -1097,7 +1104,7 @@ class RepeaterHandler(BaseHandler):
             "direct_dup_count": self.direct_dup_count,
             "rx_per_hour": rx_per_hour,
             "forwarded_per_hour": forwarded_per_hour,
-            "recent_packets": self.recent_packets,
+            "recent_packets": list(self.recent_packets),
             "neighbors": neighbors,
             "uptime_seconds": uptime_seconds,
             "noise_floor_dbm": noise_floor_dbm,
@@ -1212,6 +1219,7 @@ class RepeaterHandler(BaseHandler):
             loop = asyncio.get_running_loop()
             noise_floor = await loop.run_in_executor(None, self.get_noise_floor)
             if noise_floor is not None:
+                self._cached_noise_floor = noise_floor
                 self.storage.record_noise_floor(noise_floor)
                 logger.debug(f"Recorded noise floor: {noise_floor} dBm")
             else:

repeater/handler_helpers/discovery.py

@@ -44,11 +44,26 @@ class DiscoveryHelper:
             log_fn=log_fn or logger.info,
             debug_log_fn=debug_log_fn,
         )
+        self._pending_tasks = set()
 
         # Set up the request callback
         self.control_handler.set_request_callback(self._on_discovery_request)
         logger.debug("Discovery handler initialized")
 
+    def _track_task(self, task: asyncio.Task) -> None:
+        self._pending_tasks.add(task)
+
+        def _on_done(done_task: asyncio.Task) -> None:
+            self._pending_tasks.discard(done_task)
+            try:
+                done_task.result()
+            except asyncio.CancelledError:
+                pass
+            except Exception as e:
+                logger.error(f"Background discovery task failed: {e}", exc_info=True)
+
+        task.add_done_callback(_on_done)
+
     def _on_discovery_request(self, request_data: dict) -> None:
         """
         Handle incoming discovery request.
@@ -115,7 +130,8 @@ class DiscoveryHelper:
 
             # Send response via router injection
             if self.packet_injector:
-                asyncio.create_task(self._send_packet_async(response_packet, tag))
+                task = asyncio.create_task(self._send_packet_async(response_packet, tag))
+                self._track_task(task)
             else:
                 logger.warning("No packet injector available - discovery response not sent")
 

repeater/handler_helpers/login.py

@@ -22,6 +22,21 @@ class LoginHelper:
         
         self.handlers = {}
         self.acls = {}  # Per-identity ACLs keyed by hash_byte
+        self._pending_tasks = set()
+
+    def _track_task(self, task: asyncio.Task) -> None:
+        self._pending_tasks.add(task)
+
+        def _on_done(done_task: asyncio.Task) -> None:
+            self._pending_tasks.discard(done_task)
+            try:
+                done_task.result()
+            except asyncio.CancelledError:
+                pass
+            except Exception as e:
+                logger.error(f"Background login task failed: {e}", exc_info=True)
+
+        task.add_done_callback(_on_done)
 
     def register_identity(
         self, name: str, identity, identity_type: str = "room_server", config: dict = None
@@ -141,7 +156,8 @@ class LoginHelper:
     def _send_packet_with_delay(self, packet, delay_ms: int):
    
         if self.packet_injector:
-            asyncio.create_task(self._delayed_send(packet, delay_ms))
+            task = asyncio.create_task(self._delayed_send(packet, delay_ms))
+            self._track_task(task)
         else:
             logger.error("No packet injector configured, cannot send login response")
 

repeater/handler_helpers/text.py

@@ -65,6 +65,21 @@ class TextHelper:
 
         # Initialize CLI handler later when repeater identity is registered
         self.cli = None
+        self._pending_tasks = set()
+
+    def _track_task(self, task: asyncio.Task) -> None:
+        self._pending_tasks.add(task)
+
+        def _on_done(done_task: asyncio.Task) -> None:
+            self._pending_tasks.discard(done_task)
+            try:
+                done_task.result()
+            except asyncio.CancelledError:
+                pass
+            except Exception as e:
+                logger.error(f"Background text task failed: {e}", exc_info=True)
+
+        task.add_done_callback(_on_done)
 
     def register_identity(
         self, name: str, identity, identity_type: str = "room_server", radio_config=None
@@ -152,7 +167,8 @@ class TextHelper:
                 self.room_servers[hash_byte] = room_server
 
                 # Start sync loop
-                asyncio.create_task(room_server.start())
+                start_task = asyncio.create_task(room_server.start())
+                self._track_task(start_task)
 
                 logger.info(
                     f"Registered room server '{name}': hash=0x{hash_byte:02X}, "

repeater/main.py

@@ -53,6 +53,8 @@ class RepeaterDaemon:
         self.router = None
         self.companion_bridges: dict[int, object] = {}
         self.companion_frame_servers: list = []
+        self._shutdown_started = False
+        self._main_task = None
 
         log_level = config.get("logging", {}).get("level", "INFO")
         logging.basicConfig(
@@ -940,7 +942,7 @@ class RepeaterDaemon:
                 "queue_len": min(255, queue_len),
             }
         if stats_type == STATS_TYPE_RADIO:
-            noise_floor = int(engine.get_noise_floor() or 0)
+            noise_floor = int(engine.get_cached_noise_floor() or 0)
             radio = getattr(self, "dispatcher", None) and getattr(self.dispatcher, "radio", None)
             if radio:
                 _r = getattr(radio, "get_last_rssi", lambda: 0)
@@ -1020,11 +1022,37 @@ class RepeaterDaemon:
 
     def _signal_shutdown(self, sig, loop):
         """Handle SIGTERM/SIGINT by scheduling async shutdown."""
+        if self._shutdown_started:
+            logger.info(f"Received signal {sig.name}, shutdown already in progress")
+            return
         logger.info(f"Received signal {sig.name}, shutting down...")
         loop.create_task(self._shutdown())
+        # Cancel run() so dispatcher.run_forever() unwinds cleanly.
+        if self._main_task and not self._main_task.done():
+            self._main_task.cancel()
 
     async def _shutdown(self):
         """Best-effort shutdown: stop background services and release hardware."""
+        if self._shutdown_started:
+            return
+        self._shutdown_started = True
+
+        # Stop companion frame servers first to close client sockets and child workers.
+        for frame_server in getattr(self, "companion_frame_servers", []):
+            try:
+                await frame_server.stop()
+            except Exception as e:
+                logger.warning(f"Companion frame server stop error: {e}")
+
+        # Stop companion bridges to flush/persist state.
+        if hasattr(self, "companion_bridges"):
+            for bridge in self.companion_bridges.values():
+                if hasattr(bridge, "stop"):
+                    try:
+                        await bridge.stop()
+                    except Exception as e:
+                        logger.warning(f"Companion bridge stop error: {e}")
+
         # Stop router
         if self.router:
             try:
@@ -1035,7 +1063,9 @@ class RepeaterDaemon:
         # Stop HTTP server
         if self.http_server:
             try:
-                self.http_server.stop()
+                await asyncio.wait_for(asyncio.to_thread(self.http_server.stop), timeout=3)
+            except asyncio.TimeoutError:
+                logger.warning("Timeout stopping HTTP server")
             except Exception as e:
                 logger.warning(f"Error stopping HTTP server: {e}")
 
@@ -1046,6 +1076,17 @@ class RepeaterDaemon:
             except Exception as e:
                 logger.warning(f"Error stopping Glass handler: {e}")
 
+        # Close storage publishers (MQTT/LetsMesh) to stop their worker threads.
+        try:
+            if self.repeater_handler and self.repeater_handler.storage:
+                await asyncio.wait_for(
+                    asyncio.to_thread(self.repeater_handler.storage.close), timeout=5
+                )
+        except asyncio.TimeoutError:
+            logger.warning("Timeout closing storage publishers")
+        except Exception as e:
+            logger.warning(f"Error closing storage: {e}")
+
         # Release radio resources
         if self.radio and hasattr(self.radio, "cleanup"):
             try:
@@ -1062,12 +1103,7 @@ class RepeaterDaemon:
         except Exception as e:
             logger.debug(f"CH341 reset skipped/failed: {e}")
 
-        # Stop the event loop so the process can exit cleanly
-        try:
-            loop = asyncio.get_running_loop()
-            loop.stop()
-        except RuntimeError:
-            pass
+        # Do not force-stop the event loop here; asyncio.run() owns loop lifecycle.
 
     @staticmethod
     def _detect_container() -> bool:
@@ -1083,6 +1119,7 @@ class RepeaterDaemon:
     async def run(self):
 
         logger.info("Repeater daemon started")
+        self._main_task = asyncio.current_task()
 
         # Register signal handlers for graceful shutdown
         loop = asyncio.get_running_loop()
@@ -1141,6 +1178,8 @@ class RepeaterDaemon:
             # Run dispatcher (handles RX/TX via pymc_core)
             try:
                 await self.dispatcher.run_forever()
+            except asyncio.CancelledError:
+                logger.info("Dispatcher loop cancelled for shutdown")
             except KeyboardInterrupt:
                 logger.info("Shutting down...")
                 for frame_server in getattr(self, "companion_frame_servers", []):

repeater/packet_router.py

@@ -24,6 +24,7 @@ logger = logging.getLogger("PacketRouter")
 # Deliver PATH and protocol-response (PATH) to companion at most once per logical packet
 # so the client is not spammed with duplicate telemetry when the mesh delivers multiple copies.
 _COMPANION_DEDUPE_TTL_SEC = 60.0
+_COMPANION_DEDUPE_PRUNE_THRESHOLD = 1000
 
 
 def _companion_dedup_key(packet) -> str | None:
@@ -50,6 +51,7 @@ class PacketRouter:
         self.queue = asyncio.Queue(maxsize=500)
         self.running = False
         self.router_task = None
+        self._route_tasks = set()
         # Serialize injects so one local TX completes before the next is processed
         self._inject_lock = asyncio.Lock()
         # Hash -> expiry time; skip delivering same PATH/protocol-response to companions more than once
@@ -68,7 +70,22 @@ class PacketRouter:
                 await self.router_task
             except asyncio.CancelledError:
                 pass
+        # Cancel in-flight packet routing tasks during shutdown.
+        if self._route_tasks:
+            tasks = list(self._route_tasks)
+            for task in tasks:
+                task.cancel()
+            await asyncio.gather(*tasks, return_exceptions=True)
         logger.info("Packet router stopped")
+
+    def _on_route_task_done(self, task: asyncio.Task) -> None:
+        self._route_tasks.discard(task)
+        try:
+            task.result()
+        except asyncio.CancelledError:
+            pass
+        except Exception as e:
+            logger.error("Router packet task error: %s", e, exc_info=True)
     
     def _should_deliver_path_to_companions(self, packet) -> bool:
         """Return True if this PATH/protocol-response should be delivered to companions (first of duplicates)."""
@@ -76,8 +93,11 @@ class PacketRouter:
         if not key:
             return True
         now = time.time()
-        # Prune expired
-        self._companion_delivered = {k: v for k, v in self._companion_delivered.items() if v > now}
+        # Prune expired entries only when map grows beyond threshold to avoid per-packet full sweeps.
+        if len(self._companion_delivered) > _COMPANION_DEDUPE_PRUNE_THRESHOLD:
+            self._companion_delivered = {
+                k: v for k, v in self._companion_delivered.items() if v > now
+            }
         if key in self._companion_delivered:
             return False
         self._companion_delivered[key] = now + _COMPANION_DEDUPE_TTL_SEC
@@ -146,7 +166,9 @@ class PacketRouter:
         while self.running:
             try:
                 packet = await asyncio.wait_for(self.queue.get(), timeout=0.1)
-                await self._route_packet(packet)
+                task = asyncio.create_task(self._route_packet(packet))
+                self._route_tasks.add(task)
+                task.add_done_callback(self._on_route_task_done)
             except asyncio.TimeoutError:
                 continue
             except Exception as e:

repeater/web/api_endpoints.py

@@ -1217,6 +1217,104 @@ class APIEndpoints:
             logger.error(f"Error getting hardware stats: {e}")
             return self._error(e)
 
+    @cherrypy.expose
+    @cherrypy.tools.json_out()
+    @cherrypy.tools.json_in()
+    def memory_debug(self, **kwargs):
+        """Memory diagnostics endpoint.
+
+        GET  — returns current status + data if tracing is active.
+        POST {"action": "start"} — starts tracemalloc and captures baseline.
+        POST {"action": "stop"}  — stops tracemalloc and clears data.
+        """
+        import tracemalloc
+
+        self._set_cors_headers()
+        if cherrypy.request.method == "OPTIONS":
+            return ""
+
+        # ---------- POST: start / stop ----------
+        if cherrypy.request.method == "POST":
+            data = cherrypy.request.json or {}
+            action = data.get("action")
+
+            if action == "start":
+                if not tracemalloc.is_tracing():
+                    # Use 1 frame instead of 10 — much less overhead & faster snapshots
+                    tracemalloc.start(1)
+                self._tracemalloc_baseline = tracemalloc.take_snapshot().filter_traces((
+                    tracemalloc.Filter(False, tracemalloc.__file__),
+                    tracemalloc.Filter(False, "<frozen importlib._bootstrap>"),
+                ))
+                logger.info("Memory tracing started")
+                return self._success({
+                    "tracing": True,
+                    "message": "Tracing started — check again after some time to see growth",
+                })
+
+            if action == "stop":
+                if tracemalloc.is_tracing():
+                    tracemalloc.stop()
+                self._tracemalloc_baseline = None
+                logger.info("Memory tracing stopped")
+                return self._success({"tracing": False})
+
+            return self._error("Invalid action — use 'start' or 'stop'")
+
+        # ---------- GET: status + data ----------
+        tracing = tracemalloc.is_tracing()
+        result: dict = {"tracing": tracing}
+
+        # Always include RSS regardless of tracing state
+        try:
+            import resource
+            rusage = resource.getrusage(resource.RUSAGE_SELF)
+            result["rss_mb"] = round(rusage.ru_maxrss / 1024, 1)
+        except Exception:
+            pass
+
+        if not tracing:
+            return self._success(result)
+
+        # Filter out tracemalloc's own allocations to keep snapshot small & fast
+        current = tracemalloc.take_snapshot().filter_traces((
+            tracemalloc.Filter(False, tracemalloc.__file__),
+            tracemalloc.Filter(False, "<frozen importlib._bootstrap>"),
+        ))
+        baseline = getattr(self, "_tracemalloc_baseline", None)
+
+        # Top 20 allocations right now
+        top_current = current.statistics("lineno")[:20]
+        current_stats = []
+        for stat in top_current:
+            current_stats.append({
+                "file": str(stat.traceback),
+                "size_kb": round(stat.size / 1024, 1),
+                "count": stat.count,
+            })
+        result["current_top_20"] = current_stats
+
+        # Growth since baseline
+        if baseline:
+            diff = current.compare_to(baseline, "lineno")
+            growth = [d for d in diff if d.size_diff > 0]
+            growth.sort(key=lambda d: d.size_diff, reverse=True)
+            growth_stats = []
+            for stat in growth[:20]:
+                growth_stats.append({
+                    "file": str(stat.traceback),
+                    "size_diff_kb": round(stat.size_diff / 1024, 1),
+                    "count_diff": stat.count_diff,
+                    "current_size_kb": round(stat.size / 1024, 1),
+                })
+            result["growth_since_baseline"] = growth_stats
+
+        traced_current, traced_peak = tracemalloc.get_traced_memory()
+        result["traced_current_mb"] = round(traced_current / (1024 * 1024), 2)
+        result["traced_peak_mb"] = round(traced_peak / (1024 * 1024), 2)
+
+        return self._success(result)
+
     @cherrypy.expose
     @cherrypy.tools.json_out()
     def hardware_processes(self):
@@ -1379,6 +1477,42 @@ class APIEndpoints:
             logger.error(f"Error getting airtime data: {e}")
             return self._error(e)
 
+    @cherrypy.expose
+    @cherrypy.tools.json_out()
+    def airtime_chart_data(
+        self,
+        start_timestamp=None,
+        end_timestamp=None,
+        bucket_seconds=60,
+        sf=9,
+        bw_hz=62500,
+        cr=5,
+        preamble=17,
+    ):
+        """Server-side aggregated airtime utilization for chart rendering.
+
+        Returns pre-bucketed rx_ms/tx_ms per time bucket instead of raw packet rows,
+        reducing response size from potentially hundreds of KB to a few KB.
+        """
+        try:
+            now = __import__("time").time()
+            start_ts = float(start_timestamp) if start_timestamp is not None else now - 86400
+            end_ts = float(end_timestamp) if end_timestamp is not None else now
+            bucket_s = max(10, min(int(bucket_seconds), 3600))
+            result = self._get_storage().get_airtime_buckets(
+                start_timestamp=start_ts,
+                end_timestamp=end_ts,
+                bucket_seconds=bucket_s,
+                sf=int(sf),
+                bw_hz=int(bw_hz),
+                cr=int(cr),
+                preamble=int(preamble),
+            )
+            return self._success(result)
+        except Exception as e:
+            logger.error(f"Error getting airtime chart data: {e}")
+            return self._error(e)
+
     @cherrypy.expose
     @cherrypy.tools.json_out()
     def packet_by_hash(self, packet_hash=None):

repeater/web/companion_endpoints.py

@@ -37,6 +37,10 @@ class CompanionAPIEndpoints:
         self.config = config or {}
         self.config_manager = config_manager
 
+        http_cfg = self.config.get("http", {}) if isinstance(self.config, dict) else {}
+        self._sse_queue_maxsize = max(32, int(http_cfg.get("sse_queue_maxsize", 64)))
+        self._sse_keepalive_sec = max(5, int(http_cfg.get("sse_keepalive_sec", 15)))
+
         # SSE clients: each gets a thread-safe queue
         self._sse_clients: list[queue.Queue] = []
         self._sse_lock = threading.Lock()
@@ -666,7 +670,7 @@ class CompanionAPIEndpoints:
         cherrypy.response.headers["Connection"] = "keep-alive"
         cherrypy.response.headers["X-Accel-Buffering"] = "no"
 
-        client_queue: queue.Queue = queue.Queue(maxsize=256)
+        client_queue: queue.Queue = queue.Queue(maxsize=self._sse_queue_maxsize)
         with self._sse_lock:
             self._sse_clients.append(client_queue)
 
@@ -677,12 +681,12 @@ class CompanionAPIEndpoints:
 
                 while True:
                     try:
-                        item = client_queue.get(timeout=15.0)
+                        item = client_queue.get(timeout=float(self._sse_keepalive_sec))
                         yield f"data: {json.dumps(item)}\n\n"
                     except queue.Empty:
-                        # Keep-alive comment
-                        payload = {"event": "keepalive", "timestamp": int(time.time())}
-                        yield f"data: {json.dumps(payload)}\n\n"
+                        # Keep-alive comment frame keeps EventSource connected
+                        # without allocating additional JSON payload objects.
+                        yield ": keepalive\n\n"
             except GeneratorExit:
                 pass
             except Exception as exc:

repeater/web/html/assets/ConfirmDialog-h2bJ_WKJ.js

@@ -1 +0,0 @@
-import{dt as e,g as t,l as n,lt as r,s as i,u as a,w as o}from"./runtime-core.esm-bundler-IofF4kUm.js";import{m as s}from"./index-cutq4vvY.js";var c={class:`flex items-center justify-between mb-4`},l={class:`text-xl font-semibold text-content-primary dark:text-content-primary`},u={class:`mb-6`},d={key:0,class:`w-6 h-6`,fill:`none`,stroke:`currentColor`,viewBox:`0 0 24 24`},f={key:1,class:`w-6 h-6`,fill:`none`,stroke:`currentColor`,viewBox:`0 0 24 24`},p={key:2,class:`w-6 h-6`,fill:`none`,stroke:`currentColor`,viewBox:`0 0 24 24`},m={class:`text-content-secondary dark:text-content-primary/80 text-base leading-relaxed`},h={class:`flex gap-3`},g=t({__name:`ConfirmDialog`,props:{show:{type:Boolean},title:{default:`Confirm Action`},message:{},confirmText:{default:`Confirm`},cancelText:{default:`Cancel`},variant:{default:`warning`}},emits:[`close`,`confirm`],setup(t,{emit:g}){let _=t,v=g,y=e=>{e.target===e.currentTarget&&v(`close`)},b={danger:`bg-red-100 dark:bg-red-500/20 border-red-500/30 text-red-600 dark:text-red-400`,warning:`bg-yellow-100 dark:bg-yellow-500/20 border-yellow-500/30 text-yellow-600 dark:text-yellow-400`,info:`bg-blue-500/20 border-blue-500/30 text-blue-600 dark:text-blue-400`},x={danger:`bg-red-500 hover:bg-red-600`,warning:`bg-yellow-500 hover:bg-yellow-600`,info:`bg-blue-500 hover:bg-blue-600`};return(t,g)=>_.show?(o(),a(`div`,{key:0,onClick:y,class:`fixed inset-0 bg-black/40 backdrop-blur-lg z-[99999] flex items-center justify-center p-4`,style:{"backdrop-filter":`blur(8px) saturate(180%)`,position:`fixed`,top:`0`,left:`0`,right:`0`,bottom:`0`}},[i(`div`,{class:`bg-white dark:bg-surface-elevated backdrop-blur-xl rounded-[20px] p-6 w-full max-w-md border border-stroke-subtle dark:border-white/10`,onClick:g[3]||=s(()=>{},[`stop`])},[i(`div`,c,[i(`h3`,l,e(_.title),1),i(`button`,{onClick:g[0]||=e=>v(`close`),class:`text-content-secondary dark:text-content-muted hover:text-content-primary dark:hover:text-content-primary transition-colors`},[...g[4]||=[i(`svg`,{class:`w-6 h-6`,fill:`none`,stroke:`currentColor`,viewBox:`0 0 24 24`},[i(`path`,{"stroke-linecap":`round`,"stroke-linejoin":`round`,"stroke-width":`2`,d:`M6 18L18 6M6 6l12 12`})],-1)]])]),i(`div`,u,[i(`div`,{class:r([`inline-flex p-3 rounded-xl mb-4`,b[_.variant]])},[_.variant===`danger`?(o(),a(`svg`,d,[...g[5]||=[i(`path`,{"stroke-linecap":`round`,"stroke-linejoin":`round`,"stroke-width":`2`,d:`M12 9v2m0 4h.01m-6.938 4h13.856c1.54 0 2.502-1.667 1.732-3L13.732 4c-.77-1.333-2.694-1.333-3.464 0L3.34 16c-.77 1.333.192 3 1.732 3z`},null,-1)]])):_.variant===`warning`?(o(),a(`svg`,f,[...g[6]||=[i(`path`,{"stroke-linecap":`round`,"stroke-linejoin":`round`,"stroke-width":`2`,d:`M12 9v2m0 4h.01m-6.938 4h13.856c1.54 0 2.502-1.667 1.732-3L13.732 4c-.77-1.333-2.694-1.333-3.464 0L3.34 16c-.77 1.333.192 3 1.732 3z`},null,-1)]])):(o(),a(`svg`,p,[...g[7]||=[i(`path`,{"stroke-linecap":`round`,"stroke-linejoin":`round`,"stroke-width":`2`,d:`M13 16h-1v-4h-1m1-4h.01M21 12a9 9 0 11-18 0 9 9 0 0118 0z`},null,-1)]]))],2),i(`p`,m,e(_.message),1)]),i(`div`,h,[i(`button`,{onClick:g[1]||=e=>v(`close`),class:`flex-1 px-4 py-3 rounded-xl bg-background-mute dark:bg-white/5 hover:bg-stroke-subtle dark:hover:bg-white/10 text-content-primary dark:text-content-primary transition-all duration-200 border border-stroke-subtle dark:border-stroke/10`},e(_.cancelText),1),i(`button`,{onClick:g[2]||=e=>v(`confirm`),class:r([`flex-1 px-4 py-3 rounded-xl text-white transition-all duration-200`,x[_.variant]])},e(_.confirmText),3)])])])):n(``,!0)}});export{g as t};

repeater/web/html/assets/Help-CaIFoQMt.js

@@ -1 +1 @@
-import{f as e,g as t,u as n,w as r}from"./runtime-core.esm-bundler-IofF4kUm.js";var i=t({name:`HelpView`,__name:`Help`,setup(t){return(t,i)=>(r(),n(`div`,null,[...i[0]||=[e(`<div class="glass-card backdrop-blur border border-stroke-subtle dark:border-white/10 rounded-[15px] p-8"><h1 class="text-content-primary dark:text-content-primary text-2xl font-semibold mb-6"> Help &amp; Documentation </h1><div class="text-center py-12"><div class="text-primary mb-6"><svg class="w-20 h-20 mx-auto mb-4" fill="none" stroke="currentColor" viewBox="0 0 24 24"><path stroke-linecap="round" stroke-linejoin="round" stroke-width="2" d="M12 6.253v13m0-13C10.832 5.477 9.246 5 7.5 5S4.168 5.477 3 6.253v13C4.168 18.477 5.754 18 7.5 18s3.332.477 4.5 1.253m0-13C13.168 5.477 14.754 5 16.5 5c1.746 0 3.332.477 4.5 1.253v13C19.832 18.477 18.246 18 16.5 18c-1.746 0-3.332.477-4.5 1.253"></path></svg></div><h2 class="text-content-primary dark:text-content-primary text-xl font-medium mb-3"> pyMC Repeater Wiki </h2><p class="text-content-secondary dark:text-content-muted mb-8 max-w-md mx-auto"> Access documentation, setup guides, troubleshooting tips, and community resources on our official wiki. </p><a href="https://github.com/rightup/pyMC_Repeater/wiki" target="_blank" rel="noopener noreferrer" class="inline-flex items-center gap-2 bg-primary hover:bg-primary/80 text-white dark:text-background font-medium py-3 px-6 rounded-xl transition-colors duration-200"><svg class="w-5 h-5" fill="none" stroke="currentColor" viewBox="0 0 24 24"><path stroke-linecap="round" stroke-linejoin="round" stroke-width="2" d="M10 6H6a2 2 0 00-2 2v10a2 2 0 002 2h10a2 2 0 002-2v-4M14 4h6m0 0v6m0-6L10 14"></path></svg> Visit Wiki Documentation </a><div class="mt-8 text-xs text-content-muted dark:text-content-muted"> Opens in a new tab </div></div></div>`,1)]]))}});export{i as default};
+import{f as e,g as t,u as n,w as r}from"./runtime-core.esm-bundler-HnidnMFy.js";var i=t({name:`HelpView`,__name:`Help`,setup(t){return(t,i)=>(r(),n(`div`,null,[...i[0]||=[e(`<div class="glass-card backdrop-blur border border-stroke-subtle dark:border-white/10 rounded-[15px] p-8"><h1 class="text-content-primary dark:text-content-primary text-2xl font-semibold mb-6"> Help &amp; Documentation </h1><div class="text-center py-12"><div class="text-primary mb-6"><svg class="w-20 h-20 mx-auto mb-4" fill="none" stroke="currentColor" viewBox="0 0 24 24"><path stroke-linecap="round" stroke-linejoin="round" stroke-width="2" d="M12 6.253v13m0-13C10.832 5.477 9.246 5 7.5 5S4.168 5.477 3 6.253v13C4.168 18.477 5.754 18 7.5 18s3.332.477 4.5 1.253m0-13C13.168 5.477 14.754 5 16.5 5c1.746 0 3.332.477 4.5 1.253v13C19.832 18.477 18.246 18 16.5 18c-1.746 0-3.332.477-4.5 1.253"></path></svg></div><h2 class="text-content-primary dark:text-content-primary text-xl font-medium mb-3"> pyMC Repeater Wiki </h2><p class="text-content-secondary dark:text-content-muted mb-8 max-w-md mx-auto"> Access documentation, setup guides, troubleshooting tips, and community resources on our official wiki. </p><a href="https://github.com/rightup/pyMC_Repeater/wiki" target="_blank" rel="noopener noreferrer" class="inline-flex items-center gap-2 bg-primary hover:bg-primary/80 text-white dark:text-background font-medium py-3 px-6 rounded-xl transition-colors duration-200"><svg class="w-5 h-5" fill="none" stroke="currentColor" viewBox="0 0 24 24"><path stroke-linecap="round" stroke-linejoin="round" stroke-width="2" d="M10 6H6a2 2 0 00-2 2v10a2 2 0 002 2h10a2 2 0 002-2v-4M14 4h6m0 0v6m0-6L10 14"></path></svg> Visit Wiki Documentation </a><div class="mt-8 text-xs text-content-muted dark:text-content-muted"> Opens in a new tab </div></div></div>`,1)]]))}});export{i as default};

repeater/web/html/assets/Login-CRioMgum.css

@@ -0,0 +1 @@
+.bg-gradient-light[data-v-fec81ee3]{background:linear-gradient(#0ea5e966,#06b6d44d)}.bg-gradient-dark[data-v-fec81ee3]{background:linear-gradient(#67e8f94d,#a5f3fc26)}.login-card[data-v-fec81ee3]{-webkit-backdrop-filter:blur(40px)saturate(180%);background:#ffffffb3}.dark .login-card[data-v-fec81ee3]{background:#11191c66}.input-glass[data-v-fec81ee3]{-webkit-backdrop-filter:blur(20px);background:#ffffffe6;border:1px solid #d1d5db}.dark .input-glass[data-v-fec81ee3]{background:#ffffff0d;border-color:#ffffff1a}.input-glass[data-v-fec81ee3]:focus{background:#fff}.dark .input-glass[data-v-fec81ee3]:focus{background:#ffffff1a}.input-glass[data-v-fec81ee3]:focus{box-shadow:0 0 0 1px #aae8e833,0 0 20px #aae8e826,inset 0 1px #ffffff1a}.input-glow[data-v-fec81ee3]{opacity:0;transition:opacity .3s;box-shadow:inset 0 1px #ffffff0d}.input-glass:focus+.input-glow[data-v-fec81ee3]{opacity:1;box-shadow:0 0 20px #aae8e833,inset 0 1px #ffffff1a}.button-glass[data-v-fec81ee3]{-webkit-backdrop-filter:blur(20px);position:relative}.button-glass[data-v-fec81ee3]:before{content:"";-webkit-mask-composite:xor;background:linear-gradient(90deg,#0000 0%,#aae8e84d 50%,#0000 100%);border-radius:12px;padding:1px;transition:transform 1s;position:absolute;inset:0;transform:translate(-100%);-webkit-mask-image:linear-gradient(#fff 0 0),linear-gradient(#fff 0 0);-webkit-mask-position:0 0,0 0;-webkit-mask-size:auto,auto;-webkit-mask-repeat:repeat,repeat;-webkit-mask-clip:content-box,border-box;-webkit-mask-origin:content-box,border-box;-webkit-mask-composite:xor;mask-composite:exclude;-webkit-mask-source-type:auto,auto;mask-mode:match-source,match-source}.button-glass[data-v-fec81ee3]:hover:not(:disabled):before{transform:translate(100%)}.button-glass[data-v-fec81ee3]{box-shadow:0 0 0 1px #aae8e833,0 4px 16px #0003,inset 0 1px #ffffff1a}.button-glass[data-v-fec81ee3]:hover:not(:disabled){box-shadow:0 0 0 1px #aae8e866,0 0 30px #aae8e84d,0 4px 20px #0000004d,inset 0 1px #ffffff26}.login-content:has(.button-glass:hover:not(:disabled)) .logo-image[data-v-fec81ee3]{filter:brightness(1.4)drop-shadow(0 0 12px #aae8e8b3);transform:scale(1.02)}.login-content:has(.button-glass:hover:not(:disabled)) .logo-glow[data-v-fec81ee3]{opacity:.6;transform:scale(1.15)}.logo-glow[data-v-fec81ee3]{opacity:0}.dark .logo-glow[data-v-fec81ee3]{opacity:1}@keyframes float-fec81ee3{0%,to{transform:translateY(0)}50%{transform:translateY(-10px)}}@keyframes pulse-slow-fec81ee3{0%,to{opacity:.8;transform:scale(1)}50%{opacity:.6;transform:scale(1.05)}}@keyframes pulse-slower-fec81ee3{0%,to{opacity:.75;transform:scale(1)}50%{opacity:.5;transform:scale(1.08)}}@keyframes pulse-slowest-fec81ee3{0%,to{opacity:.8;transform:scale(1)}50%{opacity:.6;transform:scale(1.06)}}.animate-pulse-slow[data-v-fec81ee3]{animation:8s ease-in-out infinite pulse-slow-fec81ee3}.animate-pulse-slower[data-v-fec81ee3]{animation:10s ease-in-out infinite pulse-slower-fec81ee3}.animate-pulse-slowest[data-v-fec81ee3]{animation:12s ease-in-out infinite pulse-slowest-fec81ee3}@keyframes shake-fec81ee3{0%,to{transform:translate(0)}10%,30%,50%,70%,90%{transform:translate(-5px)}20%,40%,60%,80%{transform:translate(5px)}}.animate-shake[data-v-fec81ee3]{animation:.5s ease-in-out shake-fec81ee3}@keyframes logo-aura-cycle-fec81ee3{0%,to{filter:brightness()saturate()drop-shadow(0 0 7px #38bdf873)}25%{filter:brightness(1.02)saturate(1.05)drop-shadow(0 0 10px #6366f16b)}50%{filter:brightness()saturate(1.03)drop-shadow(0 0 8px #22d3ee73)}75%{filter:brightness(1.02)saturate(1.05)drop-shadow(0 0 10px #34d3996b)}}.logo-image-animated[data-v-fec81ee3]{will-change:filter;animation:6s ease-in-out infinite logo-aura-cycle-fec81ee3}.form-group[data-v-fec81ee3]{position:relative}.form-group:hover label[data-v-fec81ee3]{color:#aae8e8e6;transition:color .3s}

repeater/web/html/assets/MessageDialog-Cp4W1enq.js

@@ -1 +0,0 @@
-import{dt as e,g as t,l as n,lt as r,s as i,u as a,w as o}from"./runtime-core.esm-bundler-IofF4kUm.js";import{m as s}from"./index-cutq4vvY.js";var c={class:`mb-6`},l={key:0,class:`w-6 h-6`,fill:`none`,stroke:`currentColor`,viewBox:`0 0 24 24`},u={key:1,class:`w-6 h-6`,fill:`none`,stroke:`currentColor`,viewBox:`0 0 24 24`},d={key:2,class:`w-6 h-6`,fill:`none`,stroke:`currentColor`,viewBox:`0 0 24 24`},f={class:`text-content-secondary dark:text-content-primary/80 text-base leading-relaxed`},p={class:`flex`},m=t({__name:`MessageDialog`,props:{show:{type:Boolean},message:{},variant:{default:`success`}},emits:[`close`],setup(t,{emit:m}){let h=t,g=m,_=e=>{e.target===e.currentTarget&&g(`close`)},v={success:`bg-green-100 dark:bg-green-500/20 border-green-600/40 dark:border-green-500/30 text-green-600 dark:text-green-400`,error:`bg-red-100 dark:bg-red-500/20 border-red-500/30 text-red-600 dark:text-red-400`,info:`bg-blue-500/20 border-blue-500/30 text-blue-600 dark:text-blue-400`},y={success:`bg-green-500 hover:bg-green-600`,error:`bg-red-500 hover:bg-red-600`,info:`bg-blue-500 hover:bg-blue-600`};return(t,m)=>h.show?(o(),a(`div`,{key:0,onClick:_,class:`fixed inset-0 bg-black/40 backdrop-blur-lg z-[99999] flex items-center justify-center p-4`,style:{"backdrop-filter":`blur(8px) saturate(180%)`,position:`fixed`,top:`0`,left:`0`,right:`0`,bottom:`0`}},[i(`div`,{class:`bg-white dark:bg-surface-elevated backdrop-blur-xl rounded-[20px] p-6 w-full max-w-md border border-stroke-subtle dark:border-white/10`,onClick:m[1]||=s(()=>{},[`stop`])},[i(`div`,c,[i(`div`,{class:r([`inline-flex p-3 rounded-xl mb-4`,v[h.variant]])},[h.variant===`success`?(o(),a(`svg`,l,[...m[2]||=[i(`path`,{"stroke-linecap":`round`,"stroke-linejoin":`round`,"stroke-width":`2`,d:`M5 13l4 4L19 7`},null,-1)]])):h.variant===`error`?(o(),a(`svg`,u,[...m[3]||=[i(`path`,{"stroke-linecap":`round`,"stroke-linejoin":`round`,"stroke-width":`2`,d:`M6 18L18 6M6 6l12 12`},null,-1)]])):(o(),a(`svg`,d,[...m[4]||=[i(`path`,{"stroke-linecap":`round`,"stroke-linejoin":`round`,"stroke-width":`2`,d:`M13 16h-1v-4h-1m1-4h.01M21 12a9 9 0 11-18 0 9 9 0 0118 0z`},null,-1)]]))],2),i(`p`,f,e(h.message),1)]),i(`div`,p,[i(`button`,{onClick:m[0]||=e=>g(`close`),class:r([`flex-1 px-4 py-3 rounded-xl text-white transition-all duration-200`,y[h.variant]])},` OK `,2)])])])):n(``,!0)}});export{m as t};

repeater/web/html/assets/RFNoiseFloor-DhLKjd9G.js

@@ -0,0 +1 @@
+import{n as e}from"./index-BFltqMtv.js";export{e as default};

repeater/web/html/assets/Statistics-2MFwNAp1.css

@@ -1 +0,0 @@
-.plotly-chart[data-v-bf282927]{background:0 0!important}

repeater/web/html/assets/Statistics-CsAO5q_U.css

@@ -0,0 +1 @@
+.plotly-chart[data-v-54d032e1]{background:0 0!important}

repeater/web/html/assets/packets-B_GG5R7y.js

@@ -0,0 +1 @@
+import{t as e}from"./packets-C-dzvp0W.js";export{e as usePacketStore};

repeater/web/html/assets/system-BH4r-ii6.js

@@ -0,0 +1 @@
+import{o as e,z as t}from"./runtime-core.esm-bundler-HnidnMFy.js";import{o as n}from"./vue-router-Cr0wB7EX.js";import{t as r}from"./api-CbM6k1ZB.js";var i=n(`system`,()=>{let n=t(null),i=t(!1),a=t(null),o=t(null),s=t(`forward`),c=t(!0),l=t(0),u=t(10),d=t(!1),f=e(()=>n.value?.config?.node_name??`Unknown`),p=e(()=>{let e=n.value?.public_key;return!e||e===`Unknown`?`Unknown`:e.length>=16?`${e.slice(0,8)} ... ${e.slice(-8)}`:`${e}`}),m=e(()=>n.value!==null),h=e(()=>n.value?.version??`Unknown`),g=e(()=>n.value?.core_version??`Unknown`),_=e(()=>n.value?.noise_floor_dbm??null),v=e(()=>u.value>0?Math.min(l.value/u.value*100,100):0),y=e(()=>s.value===`no_tx`?{text:`No TX`,title:`No repeat, no local TX; adverts skipped`}:s.value===`monitor`?{text:`Monitor Mode`,title:`Monitoring only - not forwarding packets`}:c.value?{text:`Active`,title:`Forwarding with duty cycle enforcement`}:{text:`No Limits`,title:`Forwarding without duty cycle enforcement`}),b=e(()=>({mode:s.value})),x=e(()=>c.value?{active:!0,warning:!1}:{active:!1,warning:!0}),S=e=>{d.value=e};async function C(){try{i.value=!0,a.value=null;let e=await r.get(`/stats`);if(e.success&&e.data)return n.value=e.data,o.value=new Date,w(e.data),e.data;if(e&&`version`in e){let t=e;return n.value=t,o.value=new Date,w(t),t}else throw Error(e.error||`Failed to fetch stats`)}catch(e){throw a.value=e instanceof Error?e.message:`Unknown error occurred`,console.error(`Error fetching stats:`,e),e}finally{i.value=!1}}function w(e){if(e.config){let t=e.config.repeater?.mode;t===`forward`||t===`monitor`||t===`no_tx`?s.value=t:t!==void 0&&(s.value=`forward`);let n=e.config.duty_cycle;if(n){c.value=n.enforcement_enabled!==!1;let e=n.max_airtime_percent;typeof e==`number`?u.value=e:e&&typeof e==`object`&&`parsedValue`in e&&(u.value=e.parsedValue||10)}}let t=e.utilization_percent;typeof t==`number`?l.value=t:t&&typeof t==`object`&&`parsedValue`in t&&(l.value=t.parsedValue||0)}async function T(e){try{let t=await r.post(`/set_mode`,{mode:e});if(t.success)return s.value=e,!0;throw Error(t.error||`Failed to set mode`)}catch(e){throw a.value=e instanceof Error?e.message:`Unknown error occurred`,console.error(`Error setting mode:`,e),e}}async function E(e){try{let t=await r.post(`/set_duty_cycle`,{enabled:e});if(t.success)return c.value=e,!0;throw Error(t.error||`Failed to set duty cycle`)}catch(e){throw a.value=e instanceof Error?e.message:`Unknown error occurred`,console.error(`Error setting duty cycle:`,e),e}}async function D(){try{let e=await r.post(`/send_advert`,{},{timeout:1e4});if(e.success)return!0;throw Error(e.error||`Failed to send advert`)}catch(e){throw a.value=e instanceof Error?e.message:`Unknown error occurred`,console.error(`Error sending advert:`,e),e}}async function O(){return await E(!c.value)}function k(e){n.value?(e.uptime_seconds!==void 0&&(n.value.uptime_seconds=e.uptime_seconds),e.noise_floor_dbm!==void 0&&(n.value.noise_floor_dbm=e.noise_floor_dbm)):n.value=e,o.value=new Date,w(e)}async function A(e=5e3,t=!1){t||await C();let n=null;return t||(n=setInterval(async()=>{try{await C()}catch(e){console.error(`Auto-refresh error:`,e)}},e)),()=>{n&&clearInterval(n)}}function j(){n.value=null,a.value=null,o.value=null,i.value=!1,s.value=`forward`,c.value=!0,l.value=0,u.value=10}return{stats:n,isLoading:i,error:a,lastUpdated:o,currentMode:s,dutyCycleEnabled:c,dutyCycleUtilization:l,dutyCycleMax:u,cadCalibrationRunning:d,nodeName:f,pubKey:p,hasStats:m,version:h,coreVersion:g,noiseFloorDbm:_,dutyCyclePercentage:v,statusBadge:y,modeButtonState:b,dutyCycleButtonState:x,fetchStats:C,setMode:T,setDutyCycle:E,sendAdvert:D,toggleDutyCycle:O,startAutoRefresh:A,updateRealtimeStats:k,reset:j,setCadCalibrationRunning:S}});export{i as t};

repeater/web/html/assets/system-Cl32lKH8.js

@@ -0,0 +1 @@
+import{t as e}from"./system-BH4r-ii6.js";export{e as useSystemStore};

repeater/web/html/assets/system-CsY7_jKa.js

@@ -1 +0,0 @@
-import{o as e,z as t}from"./runtime-core.esm-bundler-IofF4kUm.js";import{n}from"./pinia-BrpcNUEi.js";import{t as r}from"./api-DjLVJkR1.js";var i=n(`system`,()=>{let n=t(null),i=t(!1),a=t(null),o=t(null),s=t(`forward`),c=t(!0),l=t(0),u=t(10),d=t(!1),f=e(()=>n.value?.config?.node_name??`Unknown`),p=e(()=>{let e=n.value?.public_key;return!e||e===`Unknown`?`Unknown`:e.length>=16?`${e.slice(0,8)} ... ${e.slice(-8)}`:`${e}`}),m=e(()=>n.value!==null),h=e(()=>n.value?.version??`Unknown`),g=e(()=>n.value?.core_version??`Unknown`),_=e(()=>n.value?.noise_floor_dbm??null),v=e(()=>u.value>0?Math.min(l.value/u.value*100,100):0),y=e(()=>s.value===`no_tx`?{text:`No TX`,title:`No repeat, no local TX; adverts skipped`}:s.value===`monitor`?{text:`Monitor Mode`,title:`Monitoring only - not forwarding packets`}:c.value?{text:`Active`,title:`Forwarding with duty cycle enforcement`}:{text:`No Limits`,title:`Forwarding without duty cycle enforcement`}),b=e(()=>({mode:s.value})),x=e(()=>c.value?{active:!0,warning:!1}:{active:!1,warning:!0}),S=e=>{d.value=e};async function C(){try{i.value=!0,a.value=null;let e=await r.get(`/stats`);if(e.success&&e.data)return n.value=e.data,o.value=new Date,w(e.data),e.data;if(e&&`version`in e){let t=e;return n.value=t,o.value=new Date,w(t),t}else throw Error(e.error||`Failed to fetch stats`)}catch(e){throw a.value=e instanceof Error?e.message:`Unknown error occurred`,console.error(`Error fetching stats:`,e),e}finally{i.value=!1}}function w(e){if(e.config){let t=e.config.repeater?.mode;t===`forward`||t===`monitor`||t===`no_tx`?s.value=t:t!==void 0&&(s.value=`forward`);let n=e.config.duty_cycle;if(n){c.value=n.enforcement_enabled!==!1;let e=n.max_airtime_percent;typeof e==`number`?u.value=e:e&&typeof e==`object`&&`parsedValue`in e&&(u.value=e.parsedValue||10)}}let t=e.utilization_percent;typeof t==`number`?l.value=t:t&&typeof t==`object`&&`parsedValue`in t&&(l.value=t.parsedValue||0)}async function T(e){try{let t=await r.post(`/set_mode`,{mode:e});if(t.success)return s.value=e,!0;throw Error(t.error||`Failed to set mode`)}catch(e){throw a.value=e instanceof Error?e.message:`Unknown error occurred`,console.error(`Error setting mode:`,e),e}}async function E(e){try{let t=await r.post(`/set_duty_cycle`,{enabled:e});if(t.success)return c.value=e,!0;throw Error(t.error||`Failed to set duty cycle`)}catch(e){throw a.value=e instanceof Error?e.message:`Unknown error occurred`,console.error(`Error setting duty cycle:`,e),e}}async function D(){try{let e=await r.post(`/send_advert`,{},{timeout:1e4});if(e.success)return!0;throw Error(e.error||`Failed to send advert`)}catch(e){throw a.value=e instanceof Error?e.message:`Unknown error occurred`,console.error(`Error sending advert:`,e),e}}async function O(){return await E(!c.value)}function k(e){n.value?(e.uptime_seconds!==void 0&&(n.value.uptime_seconds=e.uptime_seconds),e.noise_floor_dbm!==void 0&&(n.value.noise_floor_dbm=e.noise_floor_dbm)):n.value=e,o.value=new Date,w(e)}async function A(e=5e3,t=!1){t||await C();let n=null;return t||(n=setInterval(async()=>{try{await C()}catch(e){console.error(`Auto-refresh error:`,e)}},e)),()=>{n&&clearInterval(n)}}function j(){n.value=null,a.value=null,o.value=null,i.value=!1,s.value=`forward`,c.value=!0,l.value=0,u.value=10}return{stats:n,isLoading:i,error:a,lastUpdated:o,currentMode:s,dutyCycleEnabled:c,dutyCycleUtilization:l,dutyCycleMax:u,cadCalibrationRunning:d,nodeName:f,pubKey:p,hasStats:m,version:h,coreVersion:g,noiseFloorDbm:_,dutyCyclePercentage:v,statusBadge:y,modeButtonState:b,dutyCycleButtonState:x,fetchStats:C,setMode:T,setDutyCycle:E,sendAdvert:D,toggleDutyCycle:O,startAutoRefresh:A,updateRealtimeStats:k,reset:j,setCadCalibrationRunning:S}});export{i as t};

repeater/web/html/assets/useSignalQuality-BfZWbBxN.js

@@ -0,0 +1,5 @@
+<<<<<<<< HEAD:repeater/web/html/assets/useSignalQuality-DlXA7j0p.js
+import{o as e}from"./runtime-core.esm-bundler-IofF4kUm.js";import{t}from"./system-CsY7_jKa.js";var n={7:-7.5,8:-10,9:-12.5,10:-15,11:-17.5,12:-20},r=-116,i=8,a=5;function o(e,t){return e-t}function s(e){return n[e]??n[i]}function c(e,t){let n=t+a;if(e<=t){let n=e<=t-5?0:1;return{bars:n,color:`text-red-600 dark:text-red-400`,snr:e,quality:n===0?`none`:`poor`}}if(e<n){let n=(e-t)/a<.5?2:3;return{bars:n,color:n===2?`text-orange-600 dark:text-orange-400`:`text-yellow-600 dark:text-yellow-400`,snr:e,quality:`fair`}}let r=e-n>=10?5:4;return{bars:r,color:r===5?`text-green-600 dark:text-green-400`:`text-green-600 dark:text-green-300`,snr:e,quality:r===5?`excellent`:`good`}}function l(){let n=t(),a=e(()=>n.noiseFloorDbm??r),l=e(()=>n.stats?.config?.radio?.spreading_factor??i),u=e(()=>s(l.value));return{getSignalQuality:e=>{if(!e||e>0||e<-120)return{bars:0,color:`text-gray-400 dark:text-gray-500`,snr:-999,quality:`none`};let t=o(e,a.value);return c(Math.max(-30,Math.min(20,t)),u.value)},noiseFloor:a,spreadingFactor:l,minSNR:u}}export{l as t};
+========
+import{o as e}from"./runtime-core.esm-bundler-HnidnMFy.js";import{t}from"./system-BH4r-ii6.js";var n={7:-7.5,8:-10,9:-12.5,10:-15,11:-17.5,12:-20},r=-116,i=8,a=5;function o(e,t){return e-t}function s(e){return n[e]??n[i]}function c(e,t){let n=t+a;if(e<=t){let n=e<=t-5?0:1;return{bars:n,color:`text-red-600 dark:text-red-400`,snr:e,quality:n===0?`none`:`poor`}}if(e<n){let n=(e-t)/a<.5?2:3;return{bars:n,color:n===2?`text-orange-600 dark:text-orange-400`:`text-yellow-600 dark:text-yellow-400`,snr:e,quality:`fair`}}let r=e-n>=10?5:4;return{bars:r,color:r===5?`text-green-600 dark:text-green-400`:`text-green-600 dark:text-green-300`,snr:e,quality:r===5?`excellent`:`good`}}function l(){let n=t(),a=e(()=>n.noiseFloorDbm??r),l=e(()=>n.stats?.config?.radio?.spreading_factor??i),u=e(()=>s(l.value));return{getSignalQuality:e=>{if(!e||e>0||e<-120)return{bars:0,color:`text-gray-400 dark:text-gray-500`,snr:-999,quality:`none`};let t=o(e,a.value);return c(Math.max(-30,Math.min(20,t)),u.value)},noiseFloor:a,spreadingFactor:l,minSNR:u}}export{l as t};
+>>>>>>>> origin/fix-perform-speed:repeater/web/html/assets/useSignalQuality-BfZWbBxN.js

repeater/web/html/assets/useSignalQuality-DlXA7j0p.js

@@ -1 +0,0 @@
-import{o as e}from"./runtime-core.esm-bundler-IofF4kUm.js";import{t}from"./system-CsY7_jKa.js";var n={7:-7.5,8:-10,9:-12.5,10:-15,11:-17.5,12:-20},r=-116,i=8,a=5;function o(e,t){return e-t}function s(e){return n[e]??n[i]}function c(e,t){let n=t+a;if(e<=t){let n=e<=t-5?0:1;return{bars:n,color:`text-red-600 dark:text-red-400`,snr:e,quality:n===0?`none`:`poor`}}if(e<n){let n=(e-t)/a<.5?2:3;return{bars:n,color:n===2?`text-orange-600 dark:text-orange-400`:`text-yellow-600 dark:text-yellow-400`,snr:e,quality:`fair`}}let r=e-n>=10?5:4;return{bars:r,color:r===5?`text-green-600 dark:text-green-400`:`text-green-600 dark:text-green-300`,snr:e,quality:r===5?`excellent`:`good`}}function l(){let n=t(),a=e(()=>n.noiseFloorDbm??r),l=e(()=>n.stats?.config?.radio?.spreading_factor??i),u=e(()=>s(l.value));return{getSignalQuality:e=>{if(!e||e>0||e<-120)return{bars:0,color:`text-gray-400 dark:text-gray-500`,snr:-999,quality:`none`};let t=o(e,a.value);return c(Math.max(-30,Math.min(20,t)),u.value)},noiseFloor:a,spreadingFactor:l,minSNR:u}}export{l as t};

repeater/web/html/assets/useTheme-DMOVV09x.js

@@ -1 +1 @@
-import{k as e,z as t}from"./runtime-core.esm-bundler-IofF4kUm.js";var n=`theme-preference`,r=t(`dark`),i=t(!1);function a(e){let t=document.documentElement;e===`dark`?t.classList.add(`dark`):t.classList.remove(`dark`)}function o(){if(i.value)return;let e=localStorage.getItem(n);e&&(e===`light`||e===`dark`)?r.value=e:window.matchMedia(`(prefers-color-scheme: light)`).matches?r.value=`light`:r.value=`dark`,a(r.value),i.value=!0}typeof window<`u`&&o(),e(r,e=>{localStorage.setItem(n,e),a(e)});function s(){return{theme:r,toggleTheme:()=>{r.value=r.value===`dark`?`light`:`dark`},setTheme:e=>{r.value=e},isDark:()=>r.value===`dark`}}export{s as t};
+import{k as e,z as t}from"./runtime-core.esm-bundler-HnidnMFy.js";var n=`theme-preference`,r=t(`dark`),i=t(!1);function a(e){let t=document.documentElement;e===`dark`?t.classList.add(`dark`):t.classList.remove(`dark`)}function o(){if(i.value)return;let e=localStorage.getItem(n);e&&(e===`light`||e===`dark`)?r.value=e:window.matchMedia(`(prefers-color-scheme: light)`).matches?r.value=`light`:r.value=`dark`,a(r.value),i.value=!0}typeof window<`u`&&o(),e(r,e=>{localStorage.setItem(n,e),a(e)});function s(){return{theme:r,toggleTheme:()=>{r.value=r.value===`dark`?`light`:`dark`},setTheme:e=>{r.value=e},isDark:()=>r.value===`dark`}}export{s as t};

repeater/web/html/assets/websocket-NnYyxr--.js

@@ -0,0 +1 @@
+import{t as e}from"./websocket-nXR7EYbj.js";export{e as useWebSocketStore};

repeater/web/html/assets/websocket-nXR7EYbj.js

@@ -0,0 +1 @@
+import{o as e,z as t}from"./runtime-core.esm-bundler-HnidnMFy.js";import{o as n}from"./vue-router-Cr0wB7EX.js";import{c as r,d as i,r as a,s as o}from"./api-CbM6k1ZB.js";import{t as s}from"./system-BH4r-ii6.js";import{t as c}from"./packets-C-dzvp0W.js";var l=n(`websocket`,()=>{let n=t(null),l=t(`idle`),u=t(0),d=t(Date.now()),f=t(null),p=t(null),m=t(!1),h=t(!1),g=t(!1),_=t({visible:!1,message:``,variant:`info`}),v=null,y=c(),b=s(),x=a(),S=e(()=>l.value===`open`);function C(e,t,n=0){v!==null&&(clearTimeout(v),v=null),_.value={visible:!0,message:e,variant:t},n>0&&(v=window.setTimeout(()=>{w()},n))}function w(){v!==null&&(clearTimeout(v),v=null),_.value.visible=!1}function T(){f.value!==null&&(clearTimeout(f.value),f.value=null)}function E(){p.value!==null&&(clearInterval(p.value),p.value=null)}function D(){C(`Reconnecting...`,`info`)}function O(){let e=r();return!m.value&&!h.value&&!!e&&!i()&&x.canMaintainConnections}function k(){let e,t=r(),n=o(),i=new URLSearchParams;return t&&i.set(`token`,t),n&&i.set(`client_id`,n),e=`${window.location.protocol===`https:`?`wss:`:`ws:`}//${``?.trim()?new URL(``).host:window.location.host}/ws/packets?${i.toString()}`,e}async function A(){await Promise.allSettled([b.fetchStats(),y.fetchSystemStats(),y.fetchPacketStats({hours:24}),y.fetchRecentPackets({limit:100}),y.initializeSparklineHistory()])}function j(e=!1){E(),n.value&&e&&(n.value.onopen=null,n.value.onmessage=null,n.value.onerror=null,n.value.onclose=null)}function M(){if(T(),!O()){l.value=`closed`;return}if(u.value>=6){l.value=`closed`,C(`Connection lost`,`error`,5e3);return}l.value=`reconnecting`,D();let e=Math.min(1e3*2**u.value,3e4);u.value+=1,f.value=window.setTimeout(()=>{f.value=null,N(!0)},e)}function N(e=!1){if(!O()||n.value?.readyState===WebSocket.OPEN||n.value?.readyState===WebSocket.CONNECTING)return;T(),j(!0),l.value=e||u.value>0||g.value?`reconnecting`:`connecting`,g.value&&D();let t=new WebSocket(k());n.value=t,t.onopen=()=>{l.value=`open`,d.value=Date.now();let e=u.value>0||g.value;u.value=0,g.value=!1,E(),p.value=window.setInterval(()=>{n.value?.readyState===WebSocket.OPEN&&(n.value.send(JSON.stringify({type:`ping`})),Date.now()-d.value>6e4&&(j(!0),n.value?.close()))},3e4),A(),e?C(`Back online`,`success`,2500):w()},t.onmessage=e=>{try{let t=JSON.parse(e.data);t.type===`packet`?y.addRealtimePacket(t.data):t.type===`stats`?(t.data?.packet_stats&&y.updateRealtimeStats({packet_stats:t.data.packet_stats}),t.data?.system_stats&&b.updateRealtimeStats(t.data.system_stats)):t.type===`packet_stats`?y.updateRealtimeStats(t.data):t.type===`system_stats`?b.updateRealtimeStats(t.data):(t.type===`pong`||t.type===`ping`)&&(d.value=Date.now(),t.type===`ping`&&n.value?.readyState===WebSocket.OPEN&&n.value.send(JSON.stringify({type:`pong`})))}catch(e){console.error(`[WebSocket] Parse error:`,e)}},t.onerror=()=>{l.value=u.value>0?`reconnecting`:`closed`},t.onclose=e=>{let t=n.value;if(j(),t===n.value&&(n.value=null),m.value||h.value){l.value=`closed`;return}if(e.code===1008||e.code===4001||e.code===4003){x.handleAuthFailure(`expired`);return}M()}}function P(e=`lifecycle`){if(h.value=!0,T(),l.value=`closed`,e===`offline`?(g.value=!0,C(`Connection lost`,`error`,4e3)):e===`hidden`?(g.value=!0,w()):e===`logout`&&(g.value=!1,w()),n.value){let e=n.value;n.value=null,j(!0),e.close()}}function F(){m.value=!1,h.value=!1}function I(e={}){m.value=e.preventReconnect??m.value,e.silent||w(),P(e.preventReconnect?`logout`:`lifecycle`),u.value=0}return{isConnected:S,connectionState:l,reconnectAttempts:u,snackbar:_,connect:N,disconnect:I,pause:P,allowReconnect:F,hideSnackbar:w,resyncData:A}});export{l as t};

repeater/web/html/index.html

@@ -8,17 +8,17 @@
     <link rel="preconnect" href="https://fonts.googleapis.com">
     <link rel="preconnect" href="https://fonts.gstatic.com" crossorigin>
     <link href="https://fonts.googleapis.com/css2?family=Noto+Sans:wght@400;500;600;700&display=swap" rel="stylesheet">
-    <script type="module" crossorigin src="/assets/index-cutq4vvY.js"></script>
-    <link rel="modulepreload" crossorigin href="/assets/_plugin-vue_export-helper-V-yks4gF.js">
+    <script type="module" crossorigin src="/assets/index-BFltqMtv.js"></script>
+    <link rel="modulepreload" crossorigin href="/assets/_plugin-vue_export-helper-B7aGp3iI.js">
     <link rel="modulepreload" crossorigin href="/assets/chunk-DECur_0Z.js">
-    <link rel="modulepreload" crossorigin href="/assets/runtime-core.esm-bundler-IofF4kUm.js">
-    <link rel="modulepreload" crossorigin href="/assets/vue-router-BsDVl_JC.js">
-    <link rel="modulepreload" crossorigin href="/assets/api-DjLVJkR1.js">
-    <link rel="modulepreload" crossorigin href="/assets/pinia-BrpcNUEi.js">
-    <link rel="modulepreload" crossorigin href="/assets/useTheme-Dlt6-wEf.js">
-    <link rel="modulepreload" crossorigin href="/assets/packets-CPLd89q8.js">
-    <link rel="modulepreload" crossorigin href="/assets/system-CsY7_jKa.js">
-    <link rel="stylesheet" crossorigin href="/assets/index-BMaV7Ce0.css">
+    <link rel="modulepreload" crossorigin href="/assets/runtime-core.esm-bundler-HnidnMFy.js">
+    <link rel="modulepreload" crossorigin href="/assets/vue-router-Cr0wB7EX.js">
+    <link rel="modulepreload" crossorigin href="/assets/api-CbM6k1ZB.js">
+    <link rel="modulepreload" crossorigin href="/assets/useTheme-DMOVV09x.js">
+    <link rel="modulepreload" crossorigin href="/assets/packets-C-dzvp0W.js">
+    <link rel="modulepreload" crossorigin href="/assets/system-BH4r-ii6.js">
+    <link rel="modulepreload" crossorigin href="/assets/websocket-nXR7EYbj.js">
+    <link rel="stylesheet" crossorigin href="/assets/index-Crl6CjFg.css">
   </head>
   <body>
     <div id="app"></div>

repeater/web/http_server.py

@@ -432,10 +432,17 @@ class HTTPStatsServer:
                     config["/_next"]["cors.expose.on"] = True
                 config["/favicon.ico"]["cors.expose.on"] = True
 
+            http_cfg = self.config.get("http", {}) if isinstance(self.config, dict) else {}
+            thread_pool = max(2, int(http_cfg.get("thread_pool", 8)))
+            thread_pool_max = max(thread_pool, int(http_cfg.get("thread_pool_max", 16)))
+            socket_timeout = max(15, int(http_cfg.get("socket_timeout", 65)))
+            socket_queue_size = max(10, int(http_cfg.get("socket_queue_size", 100)))
+
             cherrypy.config.update(
                 {
                     "server.socket_host": self.host,
                     "server.socket_port": self.port,
+                    "server.socket_queue_size": socket_queue_size,
                     "engine.autoreload.on": False,
                     "log.screen": False,
                     "log.access_file": "",  # Disable access log file
@@ -447,8 +454,22 @@ class HTTPStatsServer:
                     # Add auth handlers to config so they're accessible in endpoints
                     "jwt_handler": self.jwt_handler,
                     "token_manager": self.token_manager,
+                    # Bound the thread pool to prevent unbounded growth.
+                    # SSE streams each hold one thread; allow headroom for concurrent
+                    # SSE clients plus normal API polling without growing unboundedly.
+                    "server.thread_pool": thread_pool,
+                    "server.thread_pool_max": thread_pool_max,
+                    # Close idle/stale connections so their threads return to the pool.
+                    "server.socket_timeout": socket_timeout,
                 }
             )
+            logger.info(
+                "HTTP worker config: thread_pool=%s, thread_pool_max=%s, socket_timeout=%ss, socket_queue_size=%s",
+                thread_pool,
+                thread_pool_max,
+                socket_timeout,
+                socket_queue_size,
+            )
 
             # Mount main app
             cherrypy.tree.mount(self.app, "/", config)

repeater/web/update_endpoints.py

@@ -19,6 +19,7 @@ import json
 import logging
 import os
 import re
+import ssl
 import subprocess
 import threading
 import time
@@ -43,6 +44,19 @@ PACKAGE_NAME = "pymc_repeater"
 # How long (seconds) before a cached check result expires
 CHECK_CACHE_TTL = 600  # 10 minutes
 
+_github_ssl_ctx: Optional[ssl.SSLContext] = None
+_disk_version_mismatch_logged: Optional[tuple] = None
+_DISK_VERSION_MISMATCH_LOG_TTL = 300  # seconds
+_installed_version_cache: Optional[tuple] = None
+_INSTALLED_VERSION_CACHE_TTL = 15  # seconds
+
+
+def _get_github_ssl_context() -> ssl.SSLContext:
+    global _github_ssl_ctx
+    if _github_ssl_ctx is None:
+        _github_ssl_ctx = ssl.create_default_context()
+    return _github_ssl_ctx
+
 
 class _RateLimitError(Exception):
     """Raised when GitHub returns HTTP 403 due to rate limiting."""
@@ -51,7 +65,7 @@ class _RateLimitError(Exception):
         self.reset_at = reset_at
 
 
-def _get_installed_version() -> str:
+def _get_installed_version(force_refresh: bool = False) -> str:
     """
     Return the highest dist-info version found for pymc_repeater across all
     directories the running interpreter actually uses.
@@ -69,6 +83,20 @@ def _get_installed_version() -> str:
     import site as _site
     import sys
 
+    global _installed_version_cache
+    now = time.time()
+    if (
+        not force_refresh
+        and _installed_version_cache is not None
+        and (now - _installed_version_cache[1]) < _INSTALLED_VERSION_CACHE_TTL
+    ):
+        return _installed_version_cache[0]
+
+    def _cache_and_return(value: str) -> str:
+        global _installed_version_cache
+        _installed_version_cache = (value, now)
+        return value
+
     # -- 1. Collect candidate directories ---------------------------------- #
     dirs: list = []
     try:
@@ -132,9 +160,9 @@ def _get_installed_version() -> str:
     if disk_version is None:
         try:
             from repeater import __version__
-            return __version__
+            return _cache_and_return(__version__)
         except Exception:
-            return "unknown"
+            return _cache_and_return("unknown")
 
     # -- 5. Sanity check: never return a version older than what's running -- #
     # If the running process is already on a higher version than anything found
@@ -143,17 +171,33 @@ def _get_installed_version() -> str:
         from repeater import __version__ as _running
         from packaging.version import Version
         if Version(_running) > Version(disk_version):
-            logger.debug(
-                f"[Update] Disk version {disk_version!r} < running {_running!r};"
-                " using running __version__ as installed version."
-            )
+            # status() polls can call this frequently; throttle mismatch logs.
+            global _disk_version_mismatch_logged
+            now = time.time()
+            should_log = True
+            if _disk_version_mismatch_logged is not None:
+                last_disk, last_running, last_ts = _disk_version_mismatch_logged
+                if (
+                    last_disk == disk_version
+                    and last_running == _running
+                    and (now - last_ts) < _DISK_VERSION_MISMATCH_LOG_TTL
+                ):
+                    should_log = False
+
+            if should_log:
+                logger.debug(
+                    f"[Update] Disk version {disk_version!r} < running {_running!r};"
+                    " using running __version__ as installed version."
+                )
+                _disk_version_mismatch_logged = (disk_version, _running, now)
+
             # Strip PEP 440 local identifier (+gXXXXXX) – it only encodes
             # the git hash and causes spurious mismatches with GitHub versions.
-            return re.sub(r'\+[a-zA-Z0-9.]+$', '', _running)
+            return _cache_and_return(re.sub(r'\+[a-zA-Z0-9.]+$', '', _running))
     except Exception:
         pass
 
-    return re.sub(r'\+[a-zA-Z0-9.]+$', '', disk_version)
+    return _cache_and_return(re.sub(r'\+[a-zA-Z0-9.]+$', '', disk_version))
 
 # Channels file – persisted so the choice survives daemon restarts
 _CHANNELS_FILE = "/var/lib/pymc_repeater/.update_channel"
@@ -371,6 +415,8 @@ class _UpdateState:
     def append_line(self, line: str) -> None:
         with self._lock:
             self.progress_lines.append(line)
+            if len(self.progress_lines) > 500:
+                self.progress_lines = self.progress_lines[-500:]
 
 
 _state = _UpdateState()
@@ -394,7 +440,8 @@ def _fetch_url(url: str, timeout: int = 10) -> str:
         headers["Authorization"] = f"Bearer {token}"
     req = urllib.request.Request(url, headers=headers)
     try:
-        with urllib.request.urlopen(req, timeout=timeout) as resp:
+        ctx = _get_github_ssl_context() if url.startswith("https") else None
+        with urllib.request.urlopen(req, timeout=timeout, context=ctx) as resp:
             return resp.read().decode("utf-8", errors="replace")
     except urllib.error.HTTPError as exc:
         if exc.code == 403:
@@ -463,7 +510,7 @@ def _parse_dev_number(version_str: str) -> Optional[int]:
     return int(m.group(1)) if m else None
 
 
-def _cleanup_stale_dist_info() -> None:
+def _cleanup_stale_dist_info(allow_sudo: bool = True) -> None:
     import glob
     import shutil
     import site as _site
@@ -511,6 +558,7 @@ def _cleanup_stale_dist_info() -> None:
     except Exception:
         return  # can't determine winner safely — leave everything alone
 
+    removed_any = False
     for path, ver in found.items():
         if path == keep:
             continue
@@ -518,7 +566,13 @@ def _cleanup_stale_dist_info() -> None:
             shutil.rmtree(path)
             logger.info(f"[Update] Removed stale dist-info: {path} (version {ver})")
             _state.append_line(f"[pyMC updater] Removed stale dist-info: {os.path.basename(path)}")
+            removed_any = True
         except PermissionError:
+            if not allow_sudo:
+                logger.debug(
+                    f"[Update] Skipping stale dist-info cleanup without sudo permissions: {path}"
+                )
+                continue
             # dist-info is root-owned (pip ran via sudo); use sudo to remove
             try:
                 subprocess.run(
@@ -527,11 +581,28 @@ def _cleanup_stale_dist_info() -> None:
                 )
                 logger.info(f"[Update] Removed stale dist-info (sudo): {path} (version {ver})")
                 _state.append_line(f"[pyMC updater] Removed stale dist-info: {os.path.basename(path)}")
+                removed_any = True
             except Exception as exc2:
                 logger.warning(f"[Update] Could not remove stale dist-info {path}: {exc2}")
         except Exception as exc:
             logger.warning(f"[Update] Could not remove stale dist-info {path}: {exc}")
 
+    if removed_any:
+        global _installed_version_cache
+        _installed_version_cache = None
+
+
+def _startup_dist_info_cleanup() -> None:
+    """Best-effort cleanup during startup without sudo escalation."""
+    try:
+        _cleanup_stale_dist_info(allow_sudo=False)
+        fresh = _get_installed_version(force_refresh=True)
+        if fresh != "unknown":
+            with _state._lock:
+                _state.current_version = fresh
+    except Exception as exc:
+        logger.debug(f"[Update] Startup dist-info cleanup skipped: {exc}")
+
 
 def _has_update(installed: str, latest: str) -> bool:
     """
@@ -801,6 +872,9 @@ def _do_install() -> None:
         _state.finish_install(False, "pip install failed – see progress log for details")
 
 
+_startup_dist_info_cleanup()
+
+
 # ---------------------------------------------------------------------------
 # CherryPy Endpoint class
 # ---------------------------------------------------------------------------