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/telegram_poller.py

@@ -0,0 +1,158 @@
+"""Telegram long-polling service for bots in polling mode.
+
+Uses APScheduler to run getUpdates periodically for each bot
+with update_mode == "polling". Processes updates identically
+to the webhook handler (auto-save chat, dispatch commands).
+"""
+
+from __future__ import annotations
+
+import logging
+from typing import Any
+
+import aiohttp
+from sqlmodel import select
+from sqlmodel.ext.asyncio.session import AsyncSession
+
+from notify_bridge_core.notifications.telegram.media import TELEGRAM_API_BASE_URL
+
+from ..database.engine import get_engine
+from ..database.models import TelegramBot
+from ..services.telegram import save_chat_from_webhook
+from .scheduler import get_scheduler
+
+_LOGGER = logging.getLogger(__name__)
+
+# Track last update_id per bot to use as offset
+_last_update_id: dict[int, int] = {}
+
+
+async def start_bot_polling() -> None:
+    """Schedule polling jobs for all bots with update_mode == 'polling'."""
+    engine = get_engine()
+    async with AsyncSession(engine) as session:
+        result = await session.exec(
+            select(TelegramBot).where(TelegramBot.update_mode == "polling")
+        )
+        bots = result.all()
+
+    for bot in bots:
+        schedule_bot_polling(bot.id)
+
+
+def schedule_bot_polling(bot_id: int) -> None:
+    """Add a polling job for a bot (idempotent)."""
+    scheduler = get_scheduler()
+    job_id = f"telegram_poll_{bot_id}"
+    if scheduler.get_job(job_id):
+        return
+    scheduler.add_job(
+        _poll_bot,
+        "interval",
+        seconds=3,
+        id=job_id,
+        args=[bot_id],
+        replace_existing=True,
+        max_instances=1,
+    )
+    _LOGGER.info("Started polling for bot %d", bot_id)
+
+
+def unschedule_bot_polling(bot_id: int) -> None:
+    """Remove polling job for a bot."""
+    scheduler = get_scheduler()
+    job_id = f"telegram_poll_{bot_id}"
+    if scheduler.get_job(job_id):
+        scheduler.remove_job(job_id)
+        _LOGGER.info("Stopped polling for bot %d", bot_id)
+
+
+async def _poll_bot(bot_id: int) -> None:
+    """Fetch updates from Telegram and process them."""
+    engine = get_engine()
+    async with AsyncSession(engine) as session:
+        bot = await session.get(TelegramBot, bot_id)
+        if not bot or bot.update_mode != "polling":
+            unschedule_bot_polling(bot_id)
+            return
+
+        offset = _last_update_id.get(bot_id, 0)
+        params: dict[str, Any] = {
+            "timeout": 0,
+            "limit": 50,
+            "allowed_updates": '["message"]',
+        }
+        if offset:
+            params["offset"] = offset + 1
+
+        try:
+            async with aiohttp.ClientSession() as http:
+                async with http.get(
+                    f"{TELEGRAM_API_BASE_URL}{bot.token}/getUpdates",
+                    params=params,
+                    timeout=aiohttp.ClientTimeout(total=10),
+                ) as resp:
+                    data = await resp.json()
+                    if not data.get("ok"):
+                        return
+                    updates = data.get("result", [])
+        except Exception as e:
+            _LOGGER.debug("Polling error for bot %d: %s", bot_id, e)
+            return
+
+        if not updates:
+            return
+
+        # Update offset to latest
+        _last_update_id[bot_id] = updates[-1]["update_id"]
+
+        # Process each update
+        from ..commands.handler import handle_command, send_media_group
+
+        for update in updates:
+            message = update.get("message")
+            if not message:
+                continue
+
+            chat_info = message.get("chat", {})
+            chat_id = str(chat_info.get("id", ""))
+            text = message.get("text", "")
+
+            if not chat_id:
+                continue
+
+            # Auto-persist chat
+            try:
+                async with AsyncSession(engine) as save_session:
+                    await save_chat_from_webhook(save_session, bot.id, chat_info)
+                    await save_session.commit()
+            except Exception:
+                _LOGGER.debug("Failed to auto-save chat %s", chat_id, exc_info=True)
+
+            # Dispatch commands
+            if text and text.startswith("/"):
+                try:
+                    cmd_response = await handle_command(bot, chat_id, text)
+                    if cmd_response is not None:
+                        if isinstance(cmd_response, list):
+                            await send_media_group(bot.token, chat_id, cmd_response)
+                        else:
+                            await _send_reply(bot.token, chat_id, cmd_response)
+                except Exception:
+                    _LOGGER.error("Error handling command from bot %d", bot_id, exc_info=True)
+
+
+async def _send_reply(bot_token: str, chat_id: str, text: str) -> None:
+    """Send a text reply via Telegram Bot API."""
+    async with aiohttp.ClientSession() as http:
+        url = f"{TELEGRAM_API_BASE_URL}{bot_token}/sendMessage"
+        payload: dict[str, Any] = {"chat_id": chat_id, "text": text, "parse_mode": "HTML"}
+        try:
+            async with http.post(url, json=payload) as resp:
+                if resp.status != 200:
+                    result = await resp.json()
+                    if "parse" in str(result.get("description", "")).lower():
+                        payload.pop("parse_mode", None)
+                        await http.post(url, json=payload)
+        except aiohttp.ClientError as err:
+            _LOGGER.error("Failed to send Telegram reply: %s", err)