Remove some unneeded duplication and fix up reconnection management

app/config.py

@@ -11,7 +11,6 @@ class Settings(BaseSettings):
     serial_baudrate: int = 115200
     log_level: Literal["DEBUG", "INFO", "WARNING", "ERROR"] = "INFO"
     database_path: str = "data/meshcore.db"
-    max_radio_contacts: int = 200  # Max non-repeater contacts to keep on radio for DM ACKs
 
 
 settings = Settings()

app/decoder.py

@@ -393,21 +393,6 @@ def parse_advertisement(payload: bytes) -> ParsedAdvertisement | None:
     )
 
 
-def try_parse_advertisement(raw_packet: bytes) -> ParsedAdvertisement | None:
-    """
-    Try to parse a raw packet as an advertisement.
-    Returns parsed advertisement if successful, None otherwise.
-    """
-    packet_info = parse_packet(raw_packet)
-    if packet_info is None:
-        return None
-
-    if packet_info.payload_type != PayloadType.ADVERT:
-        return None
-
-    return parse_advertisement(packet_info.payload)
-
-
 # =============================================================================
 # Direct Message (TEXT_MESSAGE) Decryption
 # =============================================================================

app/keystore.py

@@ -64,14 +64,6 @@ def has_private_key() -> bool:
     return _private_key is not None
 
 
-def clear_private_key() -> None:
-    """Clear the stored private key from memory."""
-    global _private_key, _public_key
-    _private_key = None
-    _public_key = None
-    logger.info("Private key cleared from keystore")
-
-
 async def export_and_store_private_key(mc: "MeshCore") -> bool:
     """Export private key from the radio and store it in the keystore.
 

app/models.py

@@ -103,20 +103,6 @@ class Message(BaseModel):
     acked: int = 0
 
 
-class RawPacket(BaseModel):
-    """Raw packet as stored in the database."""
-
-    id: int
-    timestamp: int
-    data: str = Field(description="Hex-encoded packet data")
-    message_id: int | None = None
-
-    @property
-    def decrypted(self) -> bool:
-        """A packet is decrypted iff it has a linked message_id."""
-        return self.message_id is not None
-
-
 class RawPacketDecryptedInfo(BaseModel):
     """Decryption info for a raw packet (when successfully decrypted)."""
 

app/radio.py

@@ -107,6 +107,20 @@ class RadioManager:
         self._last_connected: bool = False
         self._reconnect_lock: asyncio.Lock | None = None
 
+    async def post_connect_setup(self) -> None:
+        """Register event handlers, export private key, and start message fetching.
+
+        Called after every successful connection or reconnection.
+        """
+        from app.event_handlers import register_event_handlers
+        from app.keystore import export_and_store_private_key
+
+        if self._meshcore:
+            register_event_handlers(self._meshcore)
+            await export_and_store_private_key(self._meshcore)
+            await self._meshcore.start_auto_message_fetching()
+            logger.info("Post-connect setup complete (handlers, key export, message fetching)")
+
     @property
     def meshcore(self) -> MeshCore | None:
         return self._meshcore
@@ -229,15 +243,7 @@ class RadioManager:
                         # Attempt reconnection
                         await asyncio.sleep(3)  # Wait a bit before trying
                         if await self.reconnect():
-                            # Re-register event handlers after successful reconnect
-                            from app.event_handlers import register_event_handlers
-                            from app.keystore import export_and_store_private_key
-
-                            if self._meshcore:
-                                register_event_handlers(self._meshcore)
-                                await export_and_store_private_key(self._meshcore)
-                                await self._meshcore.start_auto_message_fetching()
-                                logger.info("Event handlers re-registered after auto-reconnect")
+                            await self.post_connect_setup()
 
                     elif not self._last_connected and current_connected:
                         # Connection restored (might have reconnected automatically)

app/radio_sync.py

@@ -16,10 +16,9 @@ from contextlib import asynccontextmanager
 
 from meshcore import EventType
 
-from app.config import settings
 from app.models import Contact
 from app.radio import radio_manager
-from app.repository import ChannelRepository, ContactRepository
+from app.repository import AppSettingsRepository, ChannelRepository, ContactRepository
 
 logger = logging.getLogger(__name__)
 
@@ -347,8 +346,6 @@ async def send_advertisement(force: bool = False) -> bool:
 
     Returns True if successful, False otherwise (including if throttled).
     """
-    from app.repository import AppSettingsRepository
-
     if not radio_manager.is_connected or radio_manager.meshcore is None:
         logger.debug("Cannot send advertisement: radio not connected")
         return False
@@ -530,7 +527,8 @@ async def sync_recent_contacts_to_radio(force: bool = False) -> dict:
 
     try:
         # Get recent non-repeater contacts from database
-        max_contacts = settings.max_radio_contacts
+        app_settings = await AppSettingsRepository.get()
+        max_contacts = app_settings.max_radio_contacts
         contacts = await ContactRepository.get_recent_non_repeaters(limit=max_contacts)
         logger.debug("Found %d recent non-repeater contacts to sync", len(contacts))
 

app/repository.py

@@ -15,7 +15,6 @@ from app.models import (
     Favorite,
     Message,
     MessagePath,
-    RawPacket,
 )
 
 logger = logging.getLogger(__name__)
@@ -271,13 +270,6 @@ class MessageRepository:
         except (json.JSONDecodeError, TypeError, KeyError):
             return None
 
-    @staticmethod
-    def _serialize_paths(paths: list[dict] | None) -> str | None:
-        """Serialize paths list to JSON string."""
-        if not paths:
-            return None
-        return json.dumps(paths)
-
     @staticmethod
     async def create(
         msg_type: str,
@@ -621,29 +613,6 @@ class RawPacketRepository:
         )
         await db.conn.commit()
 
-    @staticmethod
-    async def get_undecrypted(limit: int = 100) -> list[RawPacket]:
-        """Get undecrypted packets (those without a linked message)."""
-        cursor = await db.conn.execute(
-            """
-            SELECT id, timestamp, data, message_id FROM raw_packets
-            WHERE message_id IS NULL
-            ORDER BY timestamp DESC
-            LIMIT ?
-            """,
-            (limit,),
-        )
-        rows = await cursor.fetchall()
-        return [
-            RawPacket(
-                id=row["id"],
-                timestamp=row["timestamp"],
-                data=row["data"].hex(),
-                message_id=row["message_id"],
-            )
-            for row in rows
-        ]
-
     @staticmethod
     async def prune_old_undecrypted(max_age_days: int) -> int:
         """Delete undecrypted packets older than max_age_days. Returns count deleted."""

app/routers/radio.py

@@ -189,13 +189,7 @@ async def reboot_radio() -> dict:
     success = await radio_manager.reconnect()
 
     if success:
-        # Re-register event handlers after successful reconnect
-        from app.event_handlers import register_event_handlers
-
-        if radio_manager.meshcore:
-            register_event_handlers(radio_manager.meshcore)
-            await radio_manager.meshcore.start_auto_message_fetching()
-            logger.info("Event handlers re-registered and auto message fetching started")
+        await radio_manager.post_connect_setup()
 
         return {"status": "ok", "message": "Reconnected successfully", "connected": True}
     else:
@@ -228,14 +222,7 @@ async def reconnect_radio() -> dict:
     success = await radio_manager.reconnect()
 
     if success:
-        # Re-register event handlers after successful reconnect
-        from app.event_handlers import register_event_handlers
-
-        if radio_manager.meshcore:
-            register_event_handlers(radio_manager.meshcore)
-            # Restart auto message fetching
-            await radio_manager.meshcore.start_auto_message_fetching()
-            logger.info("Event handlers re-registered and auto message fetching started")
+        await radio_manager.post_connect_setup()
 
         return {"status": "ok", "message": "Reconnected successfully", "connected": True}
     else:

app/routers/settings.py

@@ -130,20 +130,6 @@ async def update_settings(update: AppSettingsUpdate) -> AppSettings:
     return await AppSettingsRepository.get()
 
 
-@router.post("/favorites", response_model=AppSettings)
-async def add_favorite(request: FavoriteRequest) -> AppSettings:
-    """Add a conversation to favorites."""
-    logger.info("Adding favorite: %s %s", request.type, request.id[:12])
-    return await AppSettingsRepository.add_favorite(request.type, request.id)
-
-
-@router.delete("/favorites", response_model=AppSettings)
-async def remove_favorite(request: FavoriteRequest) -> AppSettings:
-    """Remove a conversation from favorites."""
-    logger.info("Removing favorite: %s %s", request.type, request.id[:12])
-    return await AppSettingsRepository.remove_favorite(request.type, request.id)
-
-
 @router.post("/favorites/toggle", response_model=AppSettings)
 async def toggle_favorite(request: FavoriteRequest) -> AppSettings:
     """Toggle a conversation's favorite status."""