feat: telegram commands, app settings, bot polling, webhook handling, UI improvements

Adds telegram bot command system with 13 commands (search, latest, random, etc.),
webhook/polling handlers, rate limiting, app settings page, and various UI/UX
improvements across all entity pages.

Co-Authored-By: Claude Opus 4.6 (1M context) <noreply@anthropic.com>

packages/server/src/notify_bridge_server/services/notifier.py

@@ -1,6 +1,7 @@
-"""Test notification sender."""
+"""Notification sender — unified send logic for all paths (dispatch + test)."""
 
 import logging
+from typing import Any
 
 import aiohttp
 
@@ -25,41 +26,69 @@ def _get_test_message(locale: str, target_type: str) -> str:
     return msgs.get(target_type, msgs.get("webhook", "Test"))
 
 
-async def send_test_notification(target: NotificationTarget, locale: str = "en") -> dict:
-    """Send a simple test message to a notification target."""
+async def send_to_target(target: NotificationTarget, message: str) -> dict:
+    """Send a message to a target, respecting all target config settings.
+
+    This is the SINGLE send path used by dispatch, test, and real-data notifications.
+    """
     try:
         if target.type == "telegram":
-            return await _test_telegram(target, locale)
+            return await _send_telegram(target, message)
         elif target.type == "webhook":
-            return await _test_webhook(target, locale)
+            return await _send_webhook(target, message)
         return {"success": False, "error": f"Unknown target type: {target.type}"}
     except Exception as e:
-        _LOGGER.error("Test notification failed: %s", e)
+        _LOGGER.error("Send failed: %s", e)
         return {"success": False, "error": str(e)}
 
 
-async def _test_telegram(target: NotificationTarget, locale: str = "en") -> dict:
+async def _send_telegram(target: NotificationTarget, message: str) -> dict:
     from notify_bridge_core.notifications.telegram.client import TelegramClient
 
     bot_token = target.config.get("bot_token")
     chat_id = target.config.get("chat_id")
+    disable_preview = target.config.get("disable_url_preview", False)
+
     if not bot_token or not chat_id:
         return {"success": False, "error": "Missing bot_token or chat_id"}
 
     async with aiohttp.ClientSession() as session:
         client = TelegramClient(session, bot_token)
-        return await client.send_notification(
+        return await client.send_message(
             chat_id=str(chat_id),
-            caption=_get_test_message(locale, "telegram"),
+            text=message,
+            disable_web_page_preview=bool(disable_preview),
         )
 
 
+async def _send_webhook(target: NotificationTarget, message: str, event_type: str = "notification") -> dict:
+    from notify_bridge_core.notifications.webhook.client import WebhookClient
+
+    url = target.config.get("url")
+    headers = target.config.get("headers", {})
+    if not url:
+        return {"success": False, "error": "Missing url in target config"}
+
+    async with aiohttp.ClientSession() as session:
+        client = WebhookClient(session, url, headers)
+        return await client.send({"message": message, "event_type": event_type})
+
+
+# --- Public API used by routes ---
+
+
+async def send_test_notification(target: NotificationTarget, locale: str = "en") -> dict:
+    """Send a simple test message."""
+    message = _get_test_message(locale, target.type)
+    return await send_to_target(target, message)
+
+
 async def send_test_template_notification(
     target: NotificationTarget, slot: str, template_str: str
 ) -> dict:
-    """Render a template slot with sample data and send it to a target."""
+    """Render a template slot with sample data and send."""
     from jinja2.sandbox import SandboxedEnvironment
-    from ..api.template_configs import _SAMPLE_CONTEXT
+    from .sample_context import _SAMPLE_CONTEXT
 
     if not template_str:
         return await send_test_notification(target)
@@ -71,53 +100,7 @@ async def send_test_template_notification(
     except Exception as e:
         return {"success": False, "error": f"Template render error: {e}"}
 
-    try:
-        if target.type == "telegram":
-            return await _test_telegram_with_message(target, message)
-        elif target.type == "webhook":
-            return await _test_webhook_with_message(target, message)
-        return {"success": False, "error": f"Unknown target type: {target.type}"}
-    except Exception as e:
-        _LOGGER.error("Test template notification failed: %s", e)
-        return {"success": False, "error": str(e)}
-
-
-async def _test_telegram_with_message(target: NotificationTarget, message: str) -> dict:
-    from notify_bridge_core.notifications.telegram.client import TelegramClient
-    bot_token = target.config.get("bot_token")
-    chat_id = target.config.get("chat_id")
-    if not bot_token or not chat_id:
-        return {"success": False, "error": "Missing bot_token or chat_id"}
-    async with aiohttp.ClientSession() as session:
-        client = TelegramClient(session, bot_token)
-        return await client.send_notification(chat_id=str(chat_id), caption=message)
-
-
-async def _test_webhook_with_message(target: NotificationTarget, message: str) -> dict:
-    from notify_bridge_core.notifications.webhook.client import WebhookClient
-    url = target.config.get("url")
-    headers = target.config.get("headers", {})
-    if not url:
-        return {"success": False, "error": "Missing url in target config"}
-    async with aiohttp.ClientSession() as session:
-        client = WebhookClient(session, url, headers)
-        return await client.send({"message": message, "event_type": "test_template"})
-
-
-async def _test_webhook(target: NotificationTarget, locale: str = "en") -> dict:
-    from notify_bridge_core.notifications.webhook.client import WebhookClient
-
-    url = target.config.get("url")
-    headers = target.config.get("headers", {})
-    if not url:
-        return {"success": False, "error": "Missing url in target config"}
-
-    async with aiohttp.ClientSession() as session:
-        client = WebhookClient(session, url, headers)
-        return await client.send({
-            "message": _get_test_message(locale, "webhook"),
-            "event_type": "test",
-        })
+    return await send_to_target(target, message)
 
 
 async def send_real_data_notification(
@@ -129,20 +112,19 @@ async def send_real_data_notification(
     collection_ids: list[str],
     date_format: str = "%d.%m.%Y, %H:%M UTC",
     date_only_format: str = "%d.%m.%Y",
+    memory_source: str = "albums",
 ) -> dict:
-    """Fetch real data from provider, render template, and send notification."""
-    from datetime import datetime, timezone
+    """Fetch real data from provider, render template, and send."""
     from jinja2.sandbox import SandboxedEnvironment
 
     if not template_str:
         return {"success": False, "error": f"No template configured for {test_type}"}
 
-    # Fetch real data from provider
-    ctx: dict = {}
     try:
         ctx = await _build_real_context(
             provider_type, provider_config, collection_ids,
             test_type, date_format, date_only_format,
+            memory_source=memory_source,
         )
     except Exception as e:
         _LOGGER.error("Failed to fetch real data for test: %s", e)
@@ -152,7 +134,6 @@ async def send_real_data_notification(
     ctx["date_format"] = date_format
     ctx["date_only_format"] = date_only_format
 
-    # Render template
     try:
         env = SandboxedEnvironment(autoescape=False)
         tmpl = env.from_string(template_str)
@@ -160,16 +141,7 @@ async def send_real_data_notification(
     except Exception as e:
         return {"success": False, "error": f"Template render error: {e}"}
 
-    # Send
-    try:
-        if target.type == "telegram":
-            return await _test_telegram_with_message(target, message)
-        elif target.type == "webhook":
-            return await _test_webhook_with_message(target, message)
-        return {"success": False, "error": f"Unknown target type: {target.type}"}
-    except Exception as e:
-        _LOGGER.error("Test notification failed: %s", e)
-        return {"success": False, "error": str(e)}
+    return await send_to_target(target, message)
 
 
 async def _build_real_context(
@@ -179,6 +151,7 @@ async def _build_real_context(
     test_type: str,
     date_format: str,
     date_only_format: str,
+    memory_source: str = "albums",
 ) -> dict:
     """Build template context from real provider data."""
     from datetime import datetime, timezone
@@ -200,16 +173,77 @@ async def _build_real_context(
         if not connected:
             raise RuntimeError("Failed to connect to Immich")
 
-        # Fetch album data for all tracked collections
-        collections = []
-        all_assets = []
+        ext_domain = provider_config.get("external_domain") or provider_config.get("url", "")
+
+        # --- Native Immich memories ---
+        if test_type == "memory" and memory_source == "native":
+            memories = await immich.client.get_memories()
+            all_assets: list[dict[str, Any]] = []
+            tracked_ids = set(collection_ids) if collection_ids else None
+            for mem in memories:
+                for raw_asset in mem.get("assets", []):
+                    asset_id = raw_asset.get("id", "")
+                    # Optional album filtering: keep only assets in tracked albums
+                    if tracked_ids:
+                        asset_albums = raw_asset.get("albums", [])
+                        if not any(a.get("id") in tracked_ids for a in asset_albums):
+                            continue
+                    exif = raw_asset.get("exifInfo") or {}
+                    people_raw = raw_asset.get("people", [])
+                    all_assets.append({
+                        "id": asset_id,
+                        "filename": raw_asset.get("originalFileName", ""),
+                        "type": (raw_asset.get("type") or "IMAGE").upper(),
+                        "created_at": raw_asset.get("fileCreatedAt", raw_asset.get("createdAt", "")),
+                        "owner": "",
+                        "description": exif.get("description", "") or raw_asset.get("description", "") or "",
+                        "people": [p.get("name", "") for p in people_raw if p.get("name")],
+                        "is_favorite": raw_asset.get("isFavorite", False),
+                        "rating": exif.get("rating"),
+                        "city": exif.get("city", "") or "",
+                        "state": exif.get("state", "") or "",
+                        "country": exif.get("country", "") or "",
+                        "public_url": "",
+                        "url": f"{ext_domain.rstrip('/')}/api/assets/{asset_id}/original",
+                        "photo_url": f"{ext_domain.rstrip('/')}/api/assets/{asset_id}/thumbnail",
+                        "year": mem.get("data", {}).get("year"),
+                    })
+
+            now = datetime.now(timezone.utc)
+            ctx: dict[str, Any] = {
+                "date": now.strftime(date_only_format),
+                "timestamp": now.isoformat(),
+                "service_name": "Immich",
+                "service_type": "immich",
+                "collections": [],
+                "albums": [],
+                "assets": all_assets,
+                "common_date": "",
+                "common_location": "",
+                "collection_name": "", "album_name": "",
+                "public_url": "", "album_url": "",
+                "shared": False, "photo_count": 0, "video_count": 0, "owner": "",
+            }
+            people: set[str] = set()
+            for a in all_assets:
+                people.update(a.get("people", []))
+            ctx["people"] = list(people)
+            ctx["has_videos"] = any(a.get("type") == "VIDEO" for a in all_assets)
+            ctx["has_photos"] = any(a.get("type") == "IMAGE" for a in all_assets)
+            ctx["added_count"] = len(all_assets)
+            ctx["added_assets"] = all_assets
+            ctx["protected_url"] = ""
+            return ctx
+
+        # --- Album-based asset collection (default path) ---
+        collections: list[dict[str, Any]] = []
+        all_assets: list[dict[str, Any]] = []
 
         for album_id in collection_ids:
             album = await immich.client.get_album(album_id)
             if not album:
                 continue
 
-            # Get shared link for public URL
             shared_links = await immich.client.get_shared_links(album_id)
             ext_domain = provider_config.get("external_domain") or provider_config.get("url", "")
             album_public_url = ""
@@ -229,7 +263,6 @@ async def _build_real_context(
                 "owner": album.owner,
             })
 
-            # Collect assets (limited sample)
             for asset_id, asset in list(album.assets.items())[:10]:
                 asset_public_url = f"{album_public_url}/photos/{asset_id}" if album_public_url else ""
                 all_assets.append({
@@ -250,60 +283,42 @@ async def _build_real_context(
                     "photo_url": f"{ext_domain.rstrip('/')}/api/assets/{asset.id}/thumbnail",
                 })
 
-        # Build context based on test type
         now = datetime.now(timezone.utc)
-        ctx: dict = {
+        ctx: dict[str, Any] = {
             "date": now.strftime(date_only_format),
             "timestamp": now.isoformat(),
             "service_name": "Immich",
             "service_type": "immich",
             "collections": collections,
-            "albums": collections,  # alias
+            "albums": collections,
             "assets": all_assets,
+            "common_date": "",
+            "common_location": "",
         }
 
-        # Common date/location for assets
         if len(all_assets) > 1:
-            dates = set()
-            for a in all_assets:
-                ca = a.get("created_at", "")
-                if ca:
-                    dates.add(ca[:10])
+            dates = {a.get("created_at", "")[:10] for a in all_assets if a.get("created_at")}
             if len(dates) == 1:
                 try:
                     ctx["common_date"] = datetime.fromisoformat(dates.pop()).strftime(date_only_format)
                 except (ValueError, TypeError):
-                    ctx["common_date"] = ""
-            else:
-                ctx["common_date"] = ""
+                    pass
 
             locations = set()
             for a in all_assets:
                 city = a.get("city", "")
                 country = a.get("country", "")
-                if city:
-                    locations.add(f"{city}, {country}" if country else city)
-                else:
-                    locations.add("")
+                locations.add(f"{city}, {country}" if city and country else city or "")
             if len(locations) == 1 and "" not in locations:
                 ctx["common_location"] = locations.pop()
-            else:
-                ctx["common_location"] = ""
-        else:
-            ctx["common_date"] = ""
-            ctx["common_location"] = ""
 
-        # Add first collection details as top-level for periodic-style templates
         if collections:
             first = collections[0]
             ctx.update({
-                "collection_name": first["name"],
-                "album_name": first["name"],
-                "public_url": first.get("public_url", ""),
-                "album_url": first.get("url", ""),
+                "collection_name": first["name"], "album_name": first["name"],
+                "public_url": first.get("public_url", ""), "album_url": first.get("url", ""),
                 "shared": first.get("shared", False),
-                "photo_count": first.get("photo_count", 0),
-                "video_count": first.get("video_count", 0),
+                "photo_count": first.get("photo_count", 0), "video_count": first.get("video_count", 0),
                 "owner": first.get("owner", ""),
             })
         else:
@@ -313,8 +328,7 @@ async def _build_real_context(
                 "shared": False, "photo_count": 0, "video_count": 0, "owner": "",
             })
 
-        # People across all assets
-        people = set()
+        people: set[str] = set()
         for a in all_assets:
             people.update(a.get("people", []))
         ctx["people"] = list(people)