meshconsole 3.2.0__tar.gz → 3.2.2__tar.gz

{meshconsole-3.2.0 → meshconsole-3.2.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: meshconsole
-Version: 3.2.0
+Version: 3.2.2
 Summary: A powerful CLI and web interface for Meshtastic and MeshCore mesh networking devices
 Project-URL: Homepage, https://github.com/m9wav/MeshConsole
 Project-URL: Repository, https://github.com/m9wav/MeshConsole

{meshconsole-3.2.0 → meshconsole-3.2.2}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "meshconsole"
-version = "3.2.0"
+version = "3.2.2"
 description = "A powerful CLI and web interface for Meshtastic and MeshCore mesh networking devices"
 readme = "README.md"
 license = "MIT"

{meshconsole-3.2.0 → meshconsole-3.2.2}/src/meshconsole/__init__.py

@@ -5,7 +5,7 @@ Author: M9WAV
 License: MIT
 """
 
-__version__ = "3.2.0"
+__version__ = "3.2.2"
 __author__ = "M9WAV"
 
 from meshconsole.core import (

{meshconsole-3.2.0 → meshconsole-3.2.2}/src/meshconsole/backend/base.py

@@ -64,6 +64,11 @@ class MeshBackend(ABC):
         """Cleanly disconnect from the device."""
         ...
 
+    def reconnect(self) -> None:
+        """Disconnect and reconnect to the same device."""
+        self.disconnect()
+        self.connect()
+
     @abstractmethod
     def get_nodes(self) -> dict[str, UnifiedNode]:
         """Return all known nodes, keyed by canonical node_id."""

{meshconsole-3.2.0 → meshconsole-3.2.2}/src/meshconsole/backend/meshtastic.py

@@ -156,6 +156,7 @@ class MeshtasticBackend(MeshBackend):
 
     def disconnect(self) -> None:
         """Cleanly disconnect from the device."""
+        self._connected = False
         # Unsubscribe from pypubsub to prevent stale callbacks
         if self._subscribed:
             try:
@@ -164,15 +165,26 @@ class MeshtasticBackend(MeshBackend):
             except Exception:
                 pass
             self._subscribed = False
-        try:
-            if self._interface:
-                if hasattr(self._interface, 'close'):
-                    self._interface.close()
-        except Exception as e:
-            logger.error(f"Error closing Meshtastic interface: {e}")
-        finally:
-            self._interface = None
-            self._connected = False
+        # Close the interface, suppressing any broken pipe errors
+        iface = self._interface
+        self._interface = None
+        if iface:
+            try:
+                # Kill the heartbeat timer to prevent BrokenPipeError
+                if hasattr(iface, 'heartbeatTimer') and iface.heartbeatTimer:
+                    iface.heartbeatTimer.cancel()
+                    iface.heartbeatTimer = None
+                if hasattr(iface, 'close'):
+                    iface.close()
+            except (BrokenPipeError, OSError, Exception) as e:
+                logger.debug(f"Expected error closing Meshtastic interface: {e}")
+
+    def reconnect(self) -> None:
+        """Disconnect and reconnect to the same device."""
+        logger.info(f"Reconnecting Meshtastic ({self._connection_type})...")
+        self.disconnect()
+        time.sleep(1)
+        self.connect()
 
     def get_nodes(self) -> dict[str, UnifiedNode]:
         """Return all known nodes, keyed by canonical node_id."""

{meshconsole-3.2.0 → meshconsole-3.2.2}/src/meshconsole/cli.py

@@ -25,7 +25,7 @@ def build_parser() -> argparse.ArgumentParser:
         formatter_class=argparse.ArgumentDefaultsHelpFormatter
     )
 
-    parser.add_argument('--version', action='version', version='MeshConsole 3.2.0')
+    parser.add_argument('--version', action='version', version='MeshConsole 3.2.2')
 
     subparsers = parser.add_subparsers(dest='command', help='Available commands')
 

{meshconsole-3.2.0 → meshconsole-3.2.2}/src/meshconsole/core.py

@@ -746,43 +746,46 @@ class MeshtasticTool:
                     # ── Health check each backend independently ──
                     failed_backends = []
                     for b in list(self.backends):
-                        if b.backend_type == BackendType.MESHTASTIC:
-                            iface = getattr(b, 'interface', None)
-                            if not iface:
-                                failed_backends.append(b)
-                                continue
+                        try:
+                            if b.backend_type == BackendType.MESHTASTIC:
+                                iface = getattr(b, 'interface', None)
+                                if not iface:
+                                    failed_backends.append(b)
+                                    continue
+
+                                healthy = True
+                                if hasattr(iface, 'isConnected') and not iface.isConnected:
+                                    healthy = False
 
-                            healthy = True
-                            if hasattr(iface, 'isConnected') and not iface.isConnected:
-                                healthy = False
+                                if hasattr(iface, 'socket') and iface.socket:
+                                    try:
+                                        error = iface.socket.getsockopt(socket.SOL_SOCKET, socket.SO_ERROR)
+                                        if error != 0:
+                                            healthy = False
+                                    except (BrokenPipeError, OSError):
+                                        healthy = False
 
-                            if hasattr(iface, 'socket') and iface.socket:
                                 try:
-                                    error = iface.socket.getsockopt(socket.SOL_SOCKET, socket.SO_ERROR)
-                                    if error != 0:
-                                        healthy = False
-                                except Exception:
+                                    if hasattr(iface, 'nodes'):
+                                        _ = len(iface.nodes)
+                                except (BrokenPipeError, OSError, Exception):
                                     healthy = False
 
-                            if current_time - last_packet_time > connection_timeout * 2:
-                                healthy = False
-
-                            try:
-                                if hasattr(iface, 'nodes'):
-                                    _ = len(iface.nodes)
-                            except Exception:
-                                healthy = False
-
-                            if not healthy:
-                                failed_backends.append(b)
+                                if not healthy:
+                                    failed_backends.append(b)
 
-                        elif b.backend_type == BackendType.MESHCORE:
-                            if not b.is_connected:
-                                failed_backends.append(b)
+                            elif b.backend_type == BackendType.MESHCORE:
+                                if not b.is_connected:
+                                    failed_backends.append(b)
+                        except (BrokenPipeError, OSError) as health_err:
+                            logger.debug(f"Health check error for {b.device_id}: {health_err}")
+                            failed_backends.append(b)
 
                     if failed_backends:
+                        # Only raise if at least one backend was supposed to be connected
+                        names = [b.device_id for b in failed_backends]
                         raise ConnectionError(
-                            f"{len(failed_backends)} backend(s) failed health check"
+                            f"Backend(s) failed health check: {', '.join(names)}"
                         )
 
                     # ── Track packet activity ──
@@ -800,30 +803,43 @@ class MeshtasticTool:
             except (ConnectionError, BrokenPipeError, OSError, socket.error, Exception) as e:
                 logger.error(f"Connection lost: {e}")
 
-                # ── Cleanup failed backends ──
-                for b in list(self.backends):
-                    if not b.is_connected or (b.backend_type == BackendType.MESHTASTIC and not getattr(b, 'interface', None)):
-                        try:
-                            b.disconnect()
-                        except Exception:
-                            pass
-
                 time.sleep(2)
-
                 logger.info(f"Attempting to reconnect in {retry_delay} seconds...")
                 time.sleep(retry_delay)
 
-                try:
-                    logger.info("Reconnecting backends...")
-                    self._connect_interface()
-                    self._sync_node_db()
+                # ── Reconnect only failed backends, leave healthy ones alone ──
+                reconnected_any = False
+                for b in list(self.backends):
+                    # Check if this backend needs reconnection
+                    needs_reconnect = False
+                    if b.backend_type == BackendType.MESHTASTIC:
+                        iface = getattr(b, 'interface', None)
+                        if not iface or not b.is_connected:
+                            needs_reconnect = True
+                        elif hasattr(iface, 'isConnected') and not iface.isConnected:
+                            needs_reconnect = True
+                    elif not b.is_connected:
+                        needs_reconnect = True
+
+                    if not needs_reconnect:
+                        continue
+
+                    try:
+                        logger.info(f"Reconnecting {b.device_id}...")
+                        b.reconnect()
+                        if b.backend_type == BackendType.MESHTASTIC:
+                            b._sync_node_db()
+                        reconnected_any = True
+                        logger.info(f"Reconnected {b.device_id}")
+                    except Exception as re:
+                        logger.error(f"Reconnection failed for {b.device_id}: {re}")
+
+                if reconnected_any:
                     retry_delay = 1
                     last_packet_time = time.time()
-                    logger.info("Successfully reconnected.")
-                except Exception as reconnect_error:
-                    logger.error(f"Reconnection attempt failed: {reconnect_error}")
+                else:
                     retry_delay = min(retry_delay * 2, max_retry_delay)
-                    continue
+                continue
 
     def _load_recent_packets_from_db(self):
         """Load recent packets from database into memory for web interface."""

{meshconsole-3.2.0 → meshconsole-3.2.2}/src/meshconsole/templates/index.html

@@ -1594,9 +1594,11 @@
 
                 appState.nodes = nodes;
                 // Sort by lastSeen descending (most recent first)
-                const sortedNodes = Object.values(nodes).sort((a, b) =>
-                    new Date(b.lastSeen) - new Date(a.lastSeen)
-                );
+                const sortedNodes = Object.values(nodes).sort((a, b) => {
+                    const dateA = new Date(a.lastSeen || 0);
+                    const dateB = new Date(b.lastSeen || 0);
+                    return (isNaN(dateB) ? 0 : dateB) - (isNaN(dateA) ? 0 : dateA);
+                });
                 appState.sortedNodes = sortedNodes;
                 renderNodes(sortedNodes);
                 populateNodeSelects(sortedNodes);
@@ -1740,7 +1742,7 @@
                                 ${nodeIdDisplay}
                             </p>
                             <p class="text-muted small mb-0">
-                                <i class="bi bi-clock"></i> Last seen: ${new Date(node.lastSeen).toLocaleString()}
+                                <i class="bi bi-clock"></i> Last seen: ${node.lastSeen ? (isNaN(new Date(node.lastSeen).getTime()) ? 'Unknown' : new Date(node.lastSeen).toLocaleString()) : 'Unknown'}
                             </p>
                         </div>
                     </div>
@@ -2197,16 +2199,15 @@
                             entries.forEach((info, idx) => {
                                 const isConn = info.connected;
                                 const indicatorClass = isConn ? 'status-online' : 'status-offline';
-                                const typeName = (info.type || 'unknown');
-                                const label = typeName.charAt(0).toUpperCase() + typeName.slice(1);
-                                const statusLabel = isConn ? 'Connected' : 'Disconnected';
-                                const deviceName = info.device_name ? ` (${info.device_name})` : '';
+                                const deviceName = info.device_name || '';
                                 statusHtml += `<span class="backend-status-item">`;
                                 statusHtml += `<span class="status-indicator ${indicatorClass}"></span>`;
-                                if (entries.length > 1) {
-                                    statusHtml += `${label}: ${statusLabel}${deviceName}`;
+                                if (isConn && deviceName) {
+                                    statusHtml += deviceName;
                                 } else {
-                                    statusHtml += `${statusLabel}${deviceName}`;
+                                    const typeName = (info.type || 'unknown');
+                                    const label = typeName.charAt(0).toUpperCase() + typeName.slice(1);
+                                    statusHtml += isConn ? label : `${label}: Offline`;
                                 }
                                 statusHtml += `</span>`;
                                 if (idx < entries.length - 1) {