Add contact blocking

app/migrations.py

@@ -275,6 +275,13 @@ async def run_migrations(conn: aiosqlite.Connection) -> int:
         await set_version(conn, 34)
         applied += 1
 
+    # Migration 35: Add blocked_keys and blocked_names columns to app_settings
+    if version < 35:
+        logger.info("Applying migration 35: add blocked_keys and blocked_names to app_settings")
+        await _migrate_035_add_block_lists(conn)
+        await set_version(conn, 35)
+        applied += 1
+
     if applied > 0:
         logger.info(
             "Applied %d migration(s), schema now at version %d", applied, await get_version(conn)
@@ -1976,3 +1983,34 @@ async def _migrate_034_add_flood_scope(conn: aiosqlite.Connection) -> None:
             logger.debug("app_settings table not ready, skipping flood_scope migration")
         else:
             raise
+
+
+async def _migrate_035_add_block_lists(conn: aiosqlite.Connection) -> None:
+    """Add blocked_keys and blocked_names columns to app_settings.
+
+    These store JSON arrays of blocked public keys and display names.
+    Blocking hides messages from the UI but does not affect MQTT or bots.
+    """
+    try:
+        await conn.execute("ALTER TABLE app_settings ADD COLUMN blocked_keys TEXT DEFAULT '[]'")
+    except Exception as e:
+        error_msg = str(e).lower()
+        if "duplicate column" in error_msg:
+            logger.debug("blocked_keys column already exists, skipping")
+        elif "no such table" in error_msg:
+            logger.debug("app_settings table not ready, skipping blocked_keys migration")
+        else:
+            raise
+
+    try:
+        await conn.execute("ALTER TABLE app_settings ADD COLUMN blocked_names TEXT DEFAULT '[]'")
+    except Exception as e:
+        error_msg = str(e).lower()
+        if "duplicate column" in error_msg:
+            logger.debug("blocked_names column already exists, skipping")
+        elif "no such table" in error_msg:
+            logger.debug("app_settings table not ready, skipping blocked_names migration")
+        else:
+            raise
+
+    await conn.commit()

app/models.py

@@ -522,6 +522,14 @@ class AppSettings(BaseModel):
         default="",
         description="Outbound flood scope / region name (empty = disabled, no tagging)",
     )
+    blocked_keys: list[str] = Field(
+        default_factory=list,
+        description="Public keys whose messages are hidden from the UI",
+    )
+    blocked_names: list[str] = Field(
+        default_factory=list,
+        description="Display names whose messages are hidden from the UI",
+    )
 
 
 class BusyChannel(BaseModel):

app/repository/messages.py

@@ -170,10 +170,31 @@ class MessageRepository:
         after: int | None = None,
         after_id: int | None = None,
         q: str | None = None,
+        blocked_keys: list[str] | None = None,
+        blocked_names: list[str] | None = None,
     ) -> list[Message]:
         query = "SELECT * FROM messages WHERE 1=1"
         params: list[Any] = []
 
+        if blocked_keys:
+            placeholders = ",".join("?" for _ in blocked_keys)
+            query += (
+                f" AND NOT (outgoing=0 AND ("
+                f"(type='PRIV' AND LOWER(conversation_key) IN ({placeholders}))"
+                f" OR (type='CHAN' AND sender_key IS NOT NULL AND LOWER(sender_key) IN ({placeholders}))"
+                f"))"
+            )
+            params.extend(blocked_keys)
+            params.extend(blocked_keys)
+
+        if blocked_names:
+            placeholders = ",".join("?" for _ in blocked_names)
+            query += (
+                f" AND NOT (outgoing=0 AND sender_name IS NOT NULL"
+                f" AND sender_name IN ({placeholders}))"
+            )
+            params.extend(blocked_names)
+
         if msg_type:
             query += " AND type = ?"
             params.append(msg_type)
@@ -214,6 +235,8 @@ class MessageRepository:
         msg_type: str | None = None,
         conversation_key: str | None = None,
         context_size: int = 100,
+        blocked_keys: list[str] | None = None,
+        blocked_names: list[str] | None = None,
     ) -> tuple[list[Message], bool, bool]:
         """Get messages around a target message.
 
@@ -231,6 +254,24 @@ class MessageRepository:
             where_parts.append(clause.removeprefix("AND "))
             base_params.append(norm_key)
 
+        if blocked_keys:
+            placeholders = ",".join("?" for _ in blocked_keys)
+            where_parts.append(
+                f"NOT (outgoing=0 AND ("
+                f"(type='PRIV' AND LOWER(conversation_key) IN ({placeholders}))"
+                f" OR (type='CHAN' AND sender_key IS NOT NULL AND LOWER(sender_key) IN ({placeholders}))"
+                f"))"
+            )
+            base_params.extend(blocked_keys)
+            base_params.extend(blocked_keys)
+
+        if blocked_names:
+            placeholders = ",".join("?" for _ in blocked_names)
+            where_parts.append(
+                f"NOT (outgoing=0 AND sender_name IS NOT NULL AND sender_name IN ({placeholders}))"
+            )
+            base_params.extend(blocked_names)
+
         where_sql = " AND ".join(["1=1", *where_parts])
 
         # 1. Get the target message (must satisfy filters if provided)

app/repository/settings.py

@@ -32,7 +32,8 @@ class AppSettingsRepository:
                    mqtt_publish_messages, mqtt_publish_raw_packets,
                    community_mqtt_enabled, community_mqtt_iata,
                    community_mqtt_broker_host, community_mqtt_broker_port,
-                   community_mqtt_email, flood_scope
+                   community_mqtt_email, flood_scope,
+                   blocked_keys, blocked_names
             FROM app_settings WHERE id = 1
             """
         )
@@ -82,6 +83,22 @@ class AppSettingsRepository:
                 )
                 bots = []
 
+        # Parse blocked_keys JSON
+        blocked_keys: list[str] = []
+        if row["blocked_keys"]:
+            try:
+                blocked_keys = json.loads(row["blocked_keys"])
+            except (json.JSONDecodeError, TypeError):
+                blocked_keys = []
+
+        # Parse blocked_names JSON
+        blocked_names: list[str] = []
+        if row["blocked_names"]:
+            try:
+                blocked_names = json.loads(row["blocked_names"])
+            except (json.JSONDecodeError, TypeError):
+                blocked_names = []
+
         # Validate sidebar_sort_order (fallback to "recent" if invalid)
         sort_order = row["sidebar_sort_order"]
         if sort_order not in ("recent", "alpha"):
@@ -113,6 +130,8 @@ class AppSettingsRepository:
             community_mqtt_broker_port=row["community_mqtt_broker_port"] or 443,
             community_mqtt_email=row["community_mqtt_email"] or "",
             flood_scope=row["flood_scope"] or "",
+            blocked_keys=blocked_keys,
+            blocked_names=blocked_names,
         )
 
     @staticmethod
@@ -141,6 +160,8 @@ class AppSettingsRepository:
         community_mqtt_broker_port: int | None = None,
         community_mqtt_email: str | None = None,
         flood_scope: str | None = None,
+        blocked_keys: list[str] | None = None,
+        blocked_names: list[str] | None = None,
     ) -> AppSettings:
         """Update app settings. Only provided fields are updated."""
         updates = []
@@ -244,6 +265,14 @@ class AppSettingsRepository:
             updates.append("flood_scope = ?")
             params.append(flood_scope)
 
+        if blocked_keys is not None:
+            updates.append("blocked_keys = ?")
+            params.append(json.dumps(blocked_keys))
+
+        if blocked_names is not None:
+            updates.append("blocked_names = ?")
+            params.append(json.dumps(blocked_names))
+
         if updates:
             query = f"UPDATE app_settings SET {', '.join(updates)} WHERE id = 1"
             await db.conn.execute(query, params)
@@ -272,6 +301,27 @@ class AppSettingsRepository:
         ]
         return await AppSettingsRepository.update(favorites=new_favorites)
 
+    @staticmethod
+    async def toggle_blocked_key(key: str) -> AppSettings:
+        """Toggle a public key in the blocked list. Keys are normalized to lowercase."""
+        normalized = key.lower()
+        settings = await AppSettingsRepository.get()
+        if normalized in settings.blocked_keys:
+            new_keys = [k for k in settings.blocked_keys if k != normalized]
+        else:
+            new_keys = settings.blocked_keys + [normalized]
+        return await AppSettingsRepository.update(blocked_keys=new_keys)
+
+    @staticmethod
+    async def toggle_blocked_name(name: str) -> AppSettings:
+        """Toggle a display name in the blocked list."""
+        settings = await AppSettingsRepository.get()
+        if name in settings.blocked_names:
+            new_names = [n for n in settings.blocked_names if n != name]
+        else:
+            new_names = settings.blocked_names + [name]
+        return await AppSettingsRepository.update(blocked_names=new_names)
+
     @staticmethod
     async def migrate_preferences_from_frontend(
         favorites: list[dict],

app/routers/messages.py

@@ -14,7 +14,7 @@ from app.models import (
     SendDirectMessageRequest,
 )
 from app.radio import radio_manager
-from app.repository import AmbiguousPublicKeyPrefixError, MessageRepository
+from app.repository import AmbiguousPublicKeyPrefixError, AppSettingsRepository, MessageRepository
 from app.websocket import broadcast_event
 
 logger = logging.getLogger(__name__)
@@ -29,11 +29,16 @@ async def get_messages_around(
     context: int = Query(default=100, ge=1, le=500, description="Number of messages before/after"),
 ) -> MessagesAroundResponse:
     """Get messages around a specific message for jump-to-message navigation."""
+    settings = await AppSettingsRepository.get()
+    blocked_keys = settings.blocked_keys or None
+    blocked_names = settings.blocked_names or None
     messages, has_older, has_newer = await MessageRepository.get_around(
         message_id=message_id,
         msg_type=type,
         conversation_key=conversation_key,
         context_size=context,
+        blocked_keys=blocked_keys,
+        blocked_names=blocked_names,
     )
     return MessagesAroundResponse(messages=messages, has_older=has_older, has_newer=has_newer)
 
@@ -59,6 +64,9 @@ async def list_messages(
     q: str | None = Query(default=None, description="Full-text search query"),
 ) -> list[Message]:
     """List messages from the database."""
+    settings = await AppSettingsRepository.get()
+    blocked_keys = settings.blocked_keys or None
+    blocked_names = settings.blocked_names or None
     return await MessageRepository.get_all(
         limit=limit,
         offset=offset,
@@ -69,6 +77,8 @@ async def list_messages(
         after=after,
         after_id=after_id,
         q=q,
+        blocked_keys=blocked_keys,
+        blocked_names=blocked_names,
     )
 
 

app/routers/settings.py

@@ -125,6 +125,22 @@ class AppSettingsUpdate(BaseModel):
         default=None,
         description="Outbound flood scope / region name (empty = disabled)",
     )
+    blocked_keys: list[str] | None = Field(
+        default=None,
+        description="Public keys whose messages are hidden from the UI",
+    )
+    blocked_names: list[str] | None = Field(
+        default=None,
+        description="Display names whose messages are hidden from the UI",
+    )
+
+
+class BlockKeyRequest(BaseModel):
+    key: str = Field(description="Public key to toggle block status")
+
+
+class BlockNameRequest(BaseModel):
+    name: str = Field(description="Display name to toggle block status")
 
 
 class FavoriteRequest(BaseModel):
@@ -241,6 +257,12 @@ async def update_settings(update: AppSettingsUpdate) -> AppSettings:
         kwargs["community_mqtt_email"] = update.community_mqtt_email
         community_mqtt_changed = True
 
+    # Block lists
+    if update.blocked_keys is not None:
+        kwargs["blocked_keys"] = [k.lower() for k in update.blocked_keys]
+    if update.blocked_names is not None:
+        kwargs["blocked_names"] = update.blocked_names
+
     # Flood scope
     flood_scope_changed = False
     if update.flood_scope is not None:
@@ -317,6 +339,20 @@ async def toggle_favorite(request: FavoriteRequest) -> AppSettings:
     return result
 
 
+@router.post("/blocked-keys/toggle", response_model=AppSettings)
+async def toggle_blocked_key(request: BlockKeyRequest) -> AppSettings:
+    """Toggle a public key's blocked status."""
+    logger.info("Toggling blocked key: %s", request.key[:12])
+    return await AppSettingsRepository.toggle_blocked_key(request.key)
+
+
+@router.post("/blocked-names/toggle", response_model=AppSettings)
+async def toggle_blocked_name(request: BlockNameRequest) -> AppSettings:
+    """Toggle a display name's blocked status."""
+    logger.info("Toggling blocked name: %s", request.name)
+    return await AppSettingsRepository.toggle_blocked_name(request.name)
+
+
 @router.post("/migrate", response_model=MigratePreferencesResponse)
 async def migrate_preferences(request: MigratePreferencesRequest) -> MigratePreferencesResponse:
     """Migrate all preferences from frontend localStorage to database.