Instead of embed or text mode, optionally send a full-page screenshot of the entry URL as a Discord file upload

discord_rss_bot/feeds.py

@@ -1,5 +1,7 @@
 from __future__ import annotations
 
+import asyncio
+import concurrent.futures
 import datetime
 import json
 import logging
@@ -8,6 +10,8 @@ import pprint
 import re
 from typing import TYPE_CHECKING
 from typing import Any
+from typing import Literal
+from typing import cast
 from urllib.parse import ParseResult
 from urllib.parse import urlparse
 
@@ -16,6 +20,10 @@ from discord_webhook import DiscordEmbed
 from discord_webhook import DiscordWebhook
 from fastapi import HTTPException
 from markdownify import markdownify
+from playwright.sync_api import Browser
+from playwright.sync_api import Page
+from playwright.sync_api import TimeoutError as PlaywrightTimeoutError
+from playwright.sync_api import sync_playwright
 from reader import Entry
 from reader import EntryNotFoundError
 from reader import Feed
@@ -48,6 +56,13 @@ if TYPE_CHECKING:
 
 logger: logging.Logger = logging.getLogger(__name__)
 
+type DeliveryMode = Literal["embed", "text", "screenshot"]
+type ScreenshotLayout = Literal["desktop", "mobile"]
+type ScreenshotFileType = Literal["png", "jpeg"]
+
+MAX_DISCORD_UPLOAD_BYTES: int = 8 * 1024 * 1024
+JPEG_QUALITY_STEPS: tuple[int, ...] = (85, 70, 55, 40)
+
 
 def extract_domain(url: str) -> str:  # noqa: PLR0911
     """Extract the domain name from a URL.
@@ -98,7 +113,7 @@ def extract_domain(url: str) -> str:  # noqa: PLR0911
         return "Other"
 
 
-def send_entry_to_discord(entry: Entry, reader: Reader) -> str | None:  # noqa: C901
+def send_entry_to_discord(entry: Entry, reader: Reader) -> str | None:
     """Send a single entry to Discord.
 
     Args:
@@ -116,8 +131,16 @@ def send_entry_to_discord(entry: Entry, reader: Reader) -> str | None:  # noqa:
     # If https://discord.com/quests/<quest_id> is in the URL, send a separate message with the URL.
     send_discord_quest_notification(entry, webhook_url, reader=reader)
 
-    # Check if this is a c3kay feed
-    if is_c3kay_feed(entry.feed.url):
+    delivery_mode: DeliveryMode = get_entry_delivery_mode(reader, entry)
+    logger.info(
+        "Manual send entry %s from %s using delivery_mode=%s",
+        entry.id,
+        entry.feed.url,
+        delivery_mode,
+    )
+
+    # Hoyolab/c3kay feeds use a custom embed only when embed mode is selected.
+    if delivery_mode == "embed" and is_c3kay_feed(entry.feed.url):
         entry_link: str | None = entry.link
         if entry_link:
             post_id: str | None = extract_post_id_from_hoyolab_url(entry_link)
@@ -134,33 +157,332 @@ def send_entry_to_discord(entry: Entry, reader: Reader) -> str | None:  # noqa:
         else:
             logger.warning("No entry link found for feed %s, falling back to regular processing", entry.feed.url)
 
+    if delivery_mode == "embed":
+        webhook: DiscordWebhook = create_embed_webhook(webhook_url, entry, reader=reader)
+    elif delivery_mode == "screenshot":
+        webhook = create_screenshot_webhook(webhook_url, entry, reader=reader)
+    else:
+        webhook = create_text_webhook(webhook_url, entry, reader=reader, use_default_message_on_empty=False)
+
+    execute_webhook(webhook, entry, reader=reader)
+    return None
+
+
+def get_entry_delivery_mode(reader: Reader, entry: Entry) -> DeliveryMode:
+    """Resolve the effective delivery mode for an entry.
+
+    Priority order:
+    1. YouTube feeds are forced to text mode.
+    2. New `delivery_mode` tag when valid.
+    3. Legacy `should_send_embed` flag for backwards compatibility.
+
+    Returns:
+        DeliveryMode: The effective delivery mode for this entry.
+    """
+    if is_youtube_feed(entry.feed.url):
+        return "text"
+
+    try:
+        delivery_mode_raw: str = str(reader.get_tag(entry.feed, "delivery_mode", "")).strip().lower()
+    except ReaderError:
+        logger.exception("Error getting delivery_mode tag for feed: %s", entry.feed.url)
+        delivery_mode_raw = ""
+
+    if delivery_mode_raw in {"embed", "text", "screenshot"}:
+        return cast("DeliveryMode", delivery_mode_raw)
+
+    try:
+        should_send_embed = bool(reader.get_tag(entry.feed, "should_send_embed", True))
+    except ReaderError:
+        logger.exception("Error getting should_send_embed tag for feed: %s", entry.feed.url)
+        should_send_embed = True
+
+    return "embed" if should_send_embed else "text"
+
+
+def get_feed_delivery_mode(reader: Reader, feed: Feed) -> DeliveryMode:
+    """Resolve the effective delivery mode for a feed.
+
+    This mirrors `get_entry_delivery_mode` and is used by the web UI.
+
+    Returns:
+        DeliveryMode: The effective delivery mode for this feed.
+    """
+    if is_youtube_feed(feed.url):
+        return "text"
+
+    try:
+        delivery_mode_raw: str = str(reader.get_tag(feed, "delivery_mode", "")).strip().lower()
+    except ReaderError:
+        logger.exception("Error getting delivery_mode tag for feed: %s", feed.url)
+        delivery_mode_raw = ""
+
+    if delivery_mode_raw in {"embed", "text", "screenshot"}:
+        return cast("DeliveryMode", delivery_mode_raw)
+
+    try:
+        should_send_embed = bool(reader.get_tag(feed, "should_send_embed", True))
+    except ReaderError:
+        logger.exception("Error getting should_send_embed tag for feed: %s", feed.url)
+        should_send_embed = True
+
+    return "embed" if should_send_embed else "text"
+
+
+def get_screenshot_layout(reader: Reader, feed: Feed) -> ScreenshotLayout:
+    """Resolve the screenshot layout for a feed.
+
+    Returns:
+        ScreenshotLayout: The screenshot layout (`desktop` or `mobile`).
+    """
+    try:
+        screenshot_layout_raw: str = str(reader.get_tag(feed, "screenshot_layout", "desktop")).strip().lower()
+    except ReaderError:
+        logger.exception("Error getting screenshot_layout tag for feed: %s", feed.url)
+        screenshot_layout_raw = "desktop"
+
+    if screenshot_layout_raw == "mobile":
+        return "mobile"
+    return "desktop"
+
+
+def create_text_webhook(
+    webhook_url: str,
+    entry: Entry,
+    reader: Reader,
+    *,
+    use_default_message_on_empty: bool,
+) -> DiscordWebhook:
+    """Create a text webhook using the configured custom message for a feed.
+
+    Returns:
+        DiscordWebhook: Configured webhook that sends a text message.
+    """
     webhook_message: str = ""
 
-    # Try to get the custom message for the feed. If the user has none, we will use the default message.
-    # This has to be a string for some reason so don't change it to "not custom_message.get_custom_message()"
     if get_custom_message(reader, entry.feed) != "":  # noqa: PLC1901
-        webhook_message: str = replace_tags_in_text_message(entry=entry, reader=reader)
+        webhook_message = replace_tags_in_text_message(entry=entry, reader=reader)
+
+    if not webhook_message and use_default_message_on_empty:
+        webhook_message = str(default_custom_message)
 
     if not webhook_message:
         webhook_message = "No message found."
 
-    # Create the webhook.
+    webhook_message = truncate_webhook_message(webhook_message)
+    return DiscordWebhook(url=webhook_url, content=webhook_message, rate_limit_retry=True)
+
+
+def create_screenshot_webhook(webhook_url: str, entry: Entry, reader: Reader) -> DiscordWebhook:
+    """Create a webhook that uploads a full-page screenshot of the entry URL.
+
+    Returns:
+        DiscordWebhook: Configured webhook with screenshot upload, or text fallback on failure.
+    """
+    entry_link: str = str(entry.link or "").strip()
+    webhook_content: str | None = f"<{entry_link}>" if entry_link else None
+    webhook = DiscordWebhook(url=webhook_url, content=webhook_content, rate_limit_retry=True)
+
+    if not entry_link:
+        logger.warning("Entry %s has no link. Falling back to text message for screenshot mode.", entry.id)
+        return create_text_webhook(webhook_url, entry, reader=reader, use_default_message_on_empty=True)
+
+    screenshot_layout: ScreenshotLayout = get_screenshot_layout(reader, entry.feed)
+    logger.info(
+        "Attempting screenshot capture for entry %s with layout=%s: %s",
+        entry.id,
+        screenshot_layout,
+        entry_link,
+    )
+    screenshot_bytes: bytes | None = capture_full_page_screenshot(
+        entry_link,
+        screenshot_layout=screenshot_layout,
+        screenshot_type="png",
+    )
+    screenshot_extension: str = "png"
+
+    if screenshot_bytes and len(screenshot_bytes) > MAX_DISCORD_UPLOAD_BYTES:
+        logger.info(
+            "Screenshot for entry %s is too large as PNG (%d bytes). Trying JPEG compression.",
+            entry.id,
+            len(screenshot_bytes),
+        )
+
+        for quality in JPEG_QUALITY_STEPS:
+            jpeg_bytes = capture_full_page_screenshot(
+                entry_link,
+                screenshot_layout=screenshot_layout,
+                screenshot_type="jpeg",
+                jpeg_quality=quality,
+            )
+            if jpeg_bytes is None:
+                continue
+
+            logger.info(
+                "JPEG quality=%d produced %d bytes for entry %s",
+                quality,
+                len(jpeg_bytes),
+                entry.id,
+            )
+            screenshot_bytes = jpeg_bytes
+            screenshot_extension = "jpg"
+
+            if len(screenshot_bytes) <= MAX_DISCORD_UPLOAD_BYTES:
+                break
+
+    if screenshot_bytes is None:
+        logger.warning(
+            "Screenshot capture failed for entry %s (%s). Falling back to text message.",
+            entry.id,
+            entry_link,
+        )
+        return create_text_webhook(webhook_url, entry, reader=reader, use_default_message_on_empty=True)
+
+    if len(screenshot_bytes) > MAX_DISCORD_UPLOAD_BYTES:
+        logger.warning(
+            "Screenshot for entry %s is still too large after compression (%d bytes). Falling back to text message.",
+            entry.id,
+            len(screenshot_bytes),
+        )
+        return create_text_webhook(webhook_url, entry, reader=reader, use_default_message_on_empty=True)
+
+    filename: str = screenshot_filename_for_entry(entry, extension=screenshot_extension)
+    logger.info("Screenshot capture succeeded for entry %s (%d bytes)", entry.id, len(screenshot_bytes))
+    webhook.add_file(file=screenshot_bytes, filename=filename)
+    return webhook
+
+
+def screenshot_filename_for_entry(entry: Entry, *, extension: str = "png") -> str:
+    """Build a safe screenshot filename for Discord uploads.
+
+    Args:
+        entry: Entry used to derive a stable filename.
+        extension: File extension to use.
+
+    Returns:
+        str: Safe filename ending in the selected extension.
+    """
+    base_name: str = str(entry.id or "entry").strip().lower()
+    safe_name: str = re.sub(r"[^a-z0-9._-]+", "_", base_name)
+    safe_name: str = safe_name.strip("._")
+    if not safe_name:
+        safe_name = "entry"
+    safe_extension: str = re.sub(r"[^a-z0-9]+", "", extension.lower())
+    if not safe_extension:
+        safe_extension = "png"
+    return f"{safe_name[:80]}.{safe_extension}"
+
+
+def capture_full_page_screenshot(
+    url: str,
+    *,
+    screenshot_layout: ScreenshotLayout = "desktop",
+    screenshot_type: ScreenshotFileType = "png",
+    jpeg_quality: int = 85,
+) -> bytes | None:
+    """Capture a full-page PNG screenshot for a URL.
+
+    Returns:
+        bytes | None: PNG bytes on success, otherwise None.
+    """
+    # Playwright sync API cannot run in an active asyncio loop.
+    # FastAPI manual routes run on the event loop, so offload to a worker thread.
     try:
-        should_send_embed = bool(reader.get_tag(entry.feed, "should_send_embed", True))
-    except StorageError:
-        logger.exception("Error getting should_send_embed tag for feed: %s", entry.feed.url)
-        should_send_embed = True
+        asyncio.get_running_loop()
+        with concurrent.futures.ThreadPoolExecutor(max_workers=1) as executor:
+            future = executor.submit(
+                _capture_full_page_screenshot_sync,
+                url,
+                screenshot_layout=screenshot_layout,
+                screenshot_type=screenshot_type,
+                jpeg_quality=jpeg_quality,
+            )
+            return future.result()
+    except RuntimeError:
+        # No running loop in this thread (e.g. scheduler path).
+        return _capture_full_page_screenshot_sync(
+            url,
+            screenshot_layout=screenshot_layout,
+            screenshot_type=screenshot_type,
+            jpeg_quality=jpeg_quality,
+        )
 
-    # YouTube feeds should never use embeds
-    if is_youtube_feed(entry.feed.url):
-        should_send_embed = False
 
-    if should_send_embed:
-        webhook = create_embed_webhook(webhook_url, entry, reader=reader)
-    else:
-        webhook: DiscordWebhook = DiscordWebhook(url=webhook_url, content=webhook_message, rate_limit_retry=True)
+def _capture_full_page_screenshot_sync(
+    url: str,
+    *,
+    screenshot_layout: ScreenshotLayout = "desktop",
+    screenshot_type: ScreenshotFileType = "png",
+    jpeg_quality: int = 85,
+) -> bytes | None:
+    """Capture a full-page PNG screenshot for a URL.
 
-    execute_webhook(webhook, entry, reader=reader)
+    Returns:
+        bytes | None: PNG bytes on success, otherwise None.
+    """
+    try:
+        with sync_playwright() as playwright:
+            browser: Browser = playwright.chromium.launch(
+                headless=True,
+                args=["--disable-dev-shm-usage", "--no-sandbox"],
+            )
+            try:
+                if screenshot_layout == "mobile":
+                    page = browser.new_page(
+                        viewport={"width": 390, "height": 844},
+                        is_mobile=True,
+                        has_touch=True,
+                        device_scale_factor=3,
+                        color_scheme="dark",
+                        user_agent=(
+                            "Mozilla/5.0 (iPhone; CPU iPhone OS 17_0 like Mac OS X) "
+                            "AppleWebKit/605.1.15 (KHTML, like Gecko) Version/17.0 "
+                            "Mobile/15E148 Safari/604.1"
+                        ),
+                    )
+                else:
+                    page = browser.new_page(viewport={"width": 1366, "height": 768}, color_scheme="dark")
+
+                page = cast("Page", page)
+                # `networkidle` can hang on pages with long-polling/analytics;
+                # load DOM first and then best-effort wait for network idle.
+                page.goto(url, wait_until="domcontentloaded", timeout=30000)
+                try:
+                    page.wait_for_load_state("networkidle", timeout=5000)
+                except PlaywrightTimeoutError:
+                    logger.debug("Timed out waiting for network idle for URL: %s", url)
+
+                # Scroll through the page in viewport-sized steps to trigger
+                # lazy-loaded images and content before taking the screenshot.
+                page.evaluate(
+                    """
+                    async () => {
+                        const viewportHeight = window.innerHeight;
+                        const totalHeight = document.body.scrollHeight;
+                        let scrolled = 0;
+                        while (scrolled < totalHeight) {
+                            window.scrollBy(0, viewportHeight);
+                            scrolled += viewportHeight;
+                            await new Promise(r => setTimeout(r, 200));
+                        }
+                        window.scrollTo(0, 0);
+                    }
+                    """,
+                )
+                # Brief pause for any content revealed by scrolling to settle.
+                page.wait_for_timeout(500)
+
+                if screenshot_type == "jpeg":
+                    clamped_quality: int = max(1, min(100, jpeg_quality))
+                    return page.screenshot(type="jpeg", quality=clamped_quality, full_page=True)
+
+                return page.screenshot(type="png", full_page=True)
+            finally:
+                browser.close()
+    except OSError:
+        logger.exception("Playwright browser is not installed. Failed to capture screenshot for URL: %s", url)
+    except Exception:
+        logger.exception("Failed to capture screenshot for URL: %s", url)
     return None
 
 
@@ -375,26 +697,19 @@ def send_to_discord(reader: Reader | None = None, feed: Feed | None = None, *, d
             logger.info("No webhook URL found for feed: %s", entry.feed.url)
             continue
 
-        should_send_embed: bool = should_send_embed_check(effective_reader, entry)
+        delivery_mode: DeliveryMode = get_entry_delivery_mode(effective_reader, entry)
 
-        # Youtube feeds only need to send the link
-        if is_youtube_feed(entry.feed.url):
-            should_send_embed = False
-
-        if should_send_embed:
+        if delivery_mode == "embed":
             webhook = create_embed_webhook(webhook_url, entry, reader=effective_reader)
+        elif delivery_mode == "screenshot":
+            webhook = create_screenshot_webhook(webhook_url, entry, reader=effective_reader)
         else:
-            # If the user has set the custom message to an empty string, we will use the default message, otherwise we
-            # will use the custom message.
-            if get_custom_message(effective_reader, entry.feed) != "":  # noqa: PLC1901
-                webhook_message = replace_tags_in_text_message(entry, reader=effective_reader)
-            else:
-                webhook_message: str = str(default_custom_message)
-
-            webhook_message = truncate_webhook_message(webhook_message)
-
-            # Create the webhook.
-            webhook: DiscordWebhook = DiscordWebhook(url=webhook_url, content=webhook_message, rate_limit_retry=True)
+            webhook = create_text_webhook(
+                webhook_url,
+                entry,
+                reader=effective_reader,
+                use_default_message_on_empty=True,
+            )
 
         # Check if the entry is blacklisted, and if it is, we will skip it.
         if entry_should_be_skipped(effective_reader, entry):
@@ -455,6 +770,7 @@ def execute_webhook(webhook: DiscordWebhook, entry: Entry, reader: Reader) -> No
         return
 
     response: Response = webhook.execute()
+    logger.debug("Discord webhook response for entry %s: status=%s", entry.id, response.status_code)
     if response.status_code not in {200, 204}:
         msg: str = f"Error sending entry to Discord: {response.text}\n{pprint.pformat(webhook.json)}"
         if entry:
@@ -487,17 +803,7 @@ def should_send_embed_check(reader: Reader, entry: Entry) -> bool:
     Returns:
         bool: True if we should send an embed, False otherwise.
     """
-    # YouTube feeds should never use embeds - only links
-    if is_youtube_feed(entry.feed.url):
-        return False
-
-    try:
-        should_send_embed = bool(reader.get_tag(entry.feed, "should_send_embed", True))
-    except ReaderError:
-        logger.exception("Error getting should_send_embed tag for feed: %s", entry.feed.url)
-        should_send_embed = True
-
-    return should_send_embed
+    return get_entry_delivery_mode(reader, entry) == "embed"
 
 
 def truncate_webhook_message(webhook_message: str) -> str:
@@ -516,7 +822,7 @@ def truncate_webhook_message(webhook_message: str) -> str:
     return webhook_message
 
 
-def create_feed(reader: Reader, feed_url: str, webhook_dropdown: str) -> None:  # noqa: C901
+def create_feed(reader: Reader, feed_url: str, webhook_dropdown: str) -> None:  # noqa: C901, PLR0912
     """Add a new feed, update it and mark every entry as read.
 
     Args:
@@ -572,8 +878,19 @@ def create_feed(reader: Reader, feed_url: str, webhook_dropdown: str) -> None:
     # This is the default message that will be sent to Discord.
     reader.set_tag(clean_feed_url, "custom_message", default_custom_message)  # pyright: ignore[reportArgumentType]
 
+    global_screenshot_layout: str = str(reader.get_tag((), "screenshot_layout", "desktop")).strip().lower()
+    if global_screenshot_layout not in {"desktop", "mobile"}:
+        global_screenshot_layout = "desktop"
+    reader.set_tag(clean_feed_url, "screenshot_layout", global_screenshot_layout)  # pyright: ignore[reportArgumentType]
+
+    global_delivery_mode: str = str(reader.get_tag((), "delivery_mode", "embed")).strip().lower()
+    if global_delivery_mode not in {"embed", "text"}:
+        global_delivery_mode = "embed"
+    reader.set_tag(clean_feed_url, "delivery_mode", global_delivery_mode)  # pyright: ignore[reportArgumentType]
+    reader.set_tag(clean_feed_url, "should_send_embed", global_delivery_mode == "embed")  # pyright: ignore[reportArgumentType]
+
     # Set the default embed tag when creating the feed
-    reader.set_tag(clean_feed_url, "embed", json.dumps(default_custom_embed))
+    reader.set_tag(clean_feed_url, "embed", json.dumps(default_custom_embed))  # pyright: ignore[reportArgumentType]
 
     # Update the full-text search index so our new feed is searchable.
     reader.update_search()

discord_rss_bot/git_backup.py

@@ -47,6 +47,8 @@ type TAG_VALUE = (
 _FEED_TAGS: tuple[str, ...] = (
     "webhook",
     "custom_message",
+    "delivery_mode",
+    "screenshot_layout",
     "should_send_embed",
     "embed",
     "blacklist_title",
@@ -184,9 +186,18 @@ def export_state(reader: Reader, backup_path: Path) -> None:
     if isinstance(global_update_config, dict):
         global_update_interval = global_update_config
 
+    global_screenshot_layout: str | None = None
+    screenshot_layout = reader.get_tag((), "screenshot_layout", None)
+    if isinstance(screenshot_layout, str):
+        clean_layout = screenshot_layout.strip().lower()
+        if clean_layout in {"desktop", "mobile"}:
+            global_screenshot_layout = clean_layout
+
     state: dict = {"feeds": feeds_state, "webhooks": webhooks}
     if global_update_interval is not None:
         state["global_update_interval"] = global_update_interval
+    if global_screenshot_layout is not None:
+        state["global_screenshot_layout"] = global_screenshot_layout
     state_file: Path = backup_path / "state.json"
     state_file.write_text(json.dumps(state, indent=2, default=str), encoding="utf-8")
 

discord_rss_bot/main.py

@@ -50,6 +50,8 @@ from discord_rss_bot.custom_message import replace_tags_in_text_message
 from discord_rss_bot.custom_message import save_embed
 from discord_rss_bot.feeds import create_feed
 from discord_rss_bot.feeds import extract_domain
+from discord_rss_bot.feeds import get_feed_delivery_mode
+from discord_rss_bot.feeds import get_screenshot_layout
 from discord_rss_bot.feeds import send_entry_to_discord
 from discord_rss_bot.feeds import send_to_discord
 from discord_rss_bot.git_backup import commit_state_change
@@ -67,7 +69,7 @@ if TYPE_CHECKING:
 
 LOGGING_CONFIG: dict[str, Any] = {
     "version": 1,
-    "disable_existing_loggers": True,
+    "disable_existing_loggers": False,
     "formatters": {
         "standard": {
             "format": "%(asctime)s [%(processName)s: %(process)d] [%(threadName)s: %(thread)d] [%(levelname)s] %(name)s: %(message)s",  # noqa: E501
@@ -179,10 +181,10 @@ templates: Jinja2Templates = Jinja2Templates(directory="discord_rss_bot/template
 
 
 # Add the filters to the Jinja2 environment so they can be used in html templates.
-templates.env.filters["encode_url"] = lambda url: urllib.parse.quote(url) if url else ""
-templates.env.filters["discord_markdown"] = markdownify
+templates.env.filters["encode_url"] = lambda url: urllib.parse.quote(str(url)) if url else ""
+templates.env.filters["discord_markdown"] = markdownify  # pyright: ignore[reportArgumentType]
 templates.env.filters["relative_time"] = relative_time
-templates.env.globals["get_backup_path"] = get_backup_path
+templates.env.globals["get_backup_path"] = get_backup_path  # pyright: ignore[reportArgumentType]
 
 
 @app.post("/add_webhook")
@@ -703,6 +705,7 @@ async def post_use_embed(
         RedirectResponse: Redirect to the feed page.
     """
     clean_feed_url: str = feed_url.strip()
+    reader.set_tag(clean_feed_url, "delivery_mode", "embed")  # pyright: ignore[reportArgumentType]
     reader.set_tag(clean_feed_url, "should_send_embed", True)  # pyright: ignore[reportArgumentType]
     commit_state_change(reader, f"Enable embed mode for {clean_feed_url}")
     return RedirectResponse(url=f"/feed?feed_url={urllib.parse.quote(clean_feed_url)}", status_code=303)
@@ -723,11 +726,78 @@ async def post_use_text(
         RedirectResponse: Redirect to the feed page.
     """
     clean_feed_url: str = feed_url.strip()
+    reader.set_tag(clean_feed_url, "delivery_mode", "text")  # pyright: ignore[reportArgumentType]
     reader.set_tag(clean_feed_url, "should_send_embed", False)  # pyright: ignore[reportArgumentType]
     commit_state_change(reader, f"Disable embed mode for {clean_feed_url}")
     return RedirectResponse(url=f"/feed?feed_url={urllib.parse.quote(clean_feed_url)}", status_code=303)
 
 
+@app.post("/use_screenshot")
+async def post_use_screenshot(
+    feed_url: Annotated[str, Form()],
+    reader: Annotated[Reader, Depends(get_reader_dependency)],
+) -> RedirectResponse:
+    """Use full-page screenshot mode instead of embed or text.
+
+    Args:
+        feed_url: The feed to change.
+        reader: The Reader instance.
+
+    Returns:
+        RedirectResponse: Redirect to the feed page.
+    """
+    clean_feed_url: str = feed_url.strip()
+    reader.set_tag(clean_feed_url, "delivery_mode", "screenshot")  # pyright: ignore[reportArgumentType]
+    reader.set_tag(clean_feed_url, "screenshot_layout", "desktop")  # pyright: ignore[reportArgumentType]
+    reader.set_tag(clean_feed_url, "should_send_embed", False)  # pyright: ignore[reportArgumentType]
+    commit_state_change(reader, f"Enable screenshot mode for {clean_feed_url}")
+    return RedirectResponse(url=f"/feed?feed_url={urllib.parse.quote(clean_feed_url)}", status_code=303)
+
+
+@app.post("/use_screenshot_mobile")
+async def post_use_screenshot_mobile(
+    feed_url: Annotated[str, Form()],
+    reader: Annotated[Reader, Depends(get_reader_dependency)],
+) -> RedirectResponse:
+    """Use screenshot mode with mobile layout.
+
+    Args:
+        feed_url: The feed to change.
+        reader: The Reader instance.
+
+    Returns:
+        RedirectResponse: Redirect to the feed page.
+    """
+    clean_feed_url: str = feed_url.strip()
+    reader.set_tag(clean_feed_url, "delivery_mode", "screenshot")  # pyright: ignore[reportArgumentType]
+    reader.set_tag(clean_feed_url, "screenshot_layout", "mobile")  # pyright: ignore[reportArgumentType]
+    reader.set_tag(clean_feed_url, "should_send_embed", False)  # pyright: ignore[reportArgumentType]
+    commit_state_change(reader, f"Enable screenshot mobile layout for {clean_feed_url}")
+    return RedirectResponse(url=f"/feed?feed_url={urllib.parse.quote(clean_feed_url)}", status_code=303)
+
+
+@app.post("/use_screenshot_desktop")
+async def post_use_screenshot_desktop(
+    feed_url: Annotated[str, Form()],
+    reader: Annotated[Reader, Depends(get_reader_dependency)],
+) -> RedirectResponse:
+    """Use screenshot mode with desktop layout.
+
+    Args:
+        feed_url: The feed to change.
+        reader: The Reader instance.
+
+    Returns:
+        RedirectResponse: Redirect to the feed page.
+    """
+    clean_feed_url: str = feed_url.strip()
+    reader.set_tag(clean_feed_url, "delivery_mode", "screenshot")  # pyright: ignore[reportArgumentType]
+    reader.set_tag(clean_feed_url, "screenshot_layout", "desktop")  # pyright: ignore[reportArgumentType]
+    reader.set_tag(clean_feed_url, "should_send_embed", False)  # pyright: ignore[reportArgumentType]
+    commit_state_change(reader, f"Enable screenshot desktop layout for {clean_feed_url}")
+    return RedirectResponse(url=f"/feed?feed_url={urllib.parse.quote(clean_feed_url)}", status_code=303)
+
+
 @app.post("/set_update_interval")
 async def post_set_update_interval(
     feed_url: Annotated[str, Form()],
@@ -886,6 +956,52 @@ async def post_set_global_update_interval(
     return RedirectResponse(url="/settings", status_code=303)
 
 
+@app.post("/set_global_screenshot_layout")
+async def post_set_global_screenshot_layout(
+    screenshot_layout: Annotated[str, Form()],
+    reader: Annotated[Reader, Depends(get_reader_dependency)],
+) -> RedirectResponse:
+    """Set the global default screenshot layout for newly added feeds.
+
+    Args:
+        screenshot_layout: The screenshot layout (`desktop` or `mobile`).
+        reader: The Reader instance.
+
+    Returns:
+        RedirectResponse: Redirect to the settings page.
+    """
+    clean_layout: str = screenshot_layout.strip().lower()
+    if clean_layout not in {"desktop", "mobile"}:
+        clean_layout = "desktop"
+
+    reader.set_tag((), "screenshot_layout", clean_layout)  # pyright: ignore[reportArgumentType]
+    commit_state_change(reader, f"Set global screenshot layout to {clean_layout}")
+    return RedirectResponse(url="/settings", status_code=303)
+
+
+@app.post("/set_global_delivery_mode")
+async def post_set_global_delivery_mode(
+    delivery_mode: Annotated[str, Form()],
+    reader: Annotated[Reader, Depends(get_reader_dependency)],
+) -> RedirectResponse:
+    """Set the global default delivery mode for newly added feeds.
+
+    Args:
+        delivery_mode: The delivery mode (`embed` or `text`).
+        reader: The Reader instance.
+
+    Returns:
+        RedirectResponse: Redirect to the settings page.
+    """
+    clean_delivery_mode: str = delivery_mode.strip().lower()
+    if clean_delivery_mode not in {"embed", "text"}:
+        clean_delivery_mode = "embed"
+
+    reader.set_tag((), "delivery_mode", clean_delivery_mode)  # pyright: ignore[reportArgumentType]
+    commit_state_change(reader, f"Set global delivery mode to {clean_delivery_mode}")
+    return RedirectResponse(url="/settings", status_code=303)
+
+
 @app.get("/add", response_class=HTMLResponse)
 def get_add(
     request: Request,
@@ -900,9 +1016,14 @@ def get_add(
     Returns:
         HTMLResponse: The add feed page.
     """
+    global_delivery_mode: str = str(reader.get_tag((), "delivery_mode", "embed")).strip().lower()
+    if global_delivery_mode not in {"embed", "text"}:
+        global_delivery_mode = "embed"
+
     context = {
         "request": request,
         "webhooks": reader.get_tag((), "webhooks", []),
+        "global_delivery_mode": global_delivery_mode,
     }
     return templates.TemplateResponse(request=request, name="add.html", context=context)
 
@@ -974,6 +1095,8 @@ async def get_feed(  # noqa: C901, PLR0912, PLR0914, PLR0915
                 "feed_counts": reader.get_feed_counts(feed=clean_feed_url),
                 "html": html,
                 "should_send_embed": False,
+                "delivery_mode": "text",
+                "screenshot_layout": "desktop",
                 "last_entry": None,
                 "messages": msg,
                 "is_show_more_entries_button_visible": is_show_more_entries_button_visible,
@@ -1002,7 +1125,9 @@ async def get_feed(  # noqa: C901, PLR0912, PLR0914, PLR0915
     # Create the html for the entries.
     html: str = create_html_for_feed(reader=reader, entries=entries, current_feed_url=clean_feed_url)
 
-    should_send_embed: bool = bool(reader.get_tag(feed, "should_send_embed", True))
+    delivery_mode: str = get_feed_delivery_mode(reader, feed)
+    should_send_embed: bool = delivery_mode == "embed"
+    screenshot_layout: str = get_screenshot_layout(reader, feed)
 
     # Get the update interval for this feed
     feed_interval: int | None = None
@@ -1027,6 +1152,8 @@ async def get_feed(  # noqa: C901, PLR0912, PLR0914, PLR0915
         "feed_counts": reader.get_feed_counts(feed=clean_feed_url),
         "html": html,
         "should_send_embed": should_send_embed,
+        "delivery_mode": delivery_mode,
+        "screenshot_layout": screenshot_layout,
         "last_entry": last_entry,
         "is_show_more_entries_button_visible": is_show_more_entries_button_visible,
         "total_entries": total_entries,
@@ -1212,6 +1339,14 @@ async def get_settings(
         if isinstance(interval_value, int):
             global_interval = interval_value
 
+    global_screenshot_layout: str = str(reader.get_tag((), "screenshot_layout", "desktop")).strip().lower()
+    if global_screenshot_layout not in {"desktop", "mobile"}:
+        global_screenshot_layout = "desktop"
+
+    global_delivery_mode: str = str(reader.get_tag((), "delivery_mode", "embed")).strip().lower()
+    if global_delivery_mode not in {"embed", "text"}:
+        global_delivery_mode = "embed"
+
     # Get all feeds with their intervals
     feeds: Iterable[Feed] = reader.get_feeds()
     feed_intervals = []
@@ -1233,6 +1368,8 @@ async def get_settings(
     context = {
         "request": request,
         "global_interval": global_interval,
+        "global_delivery_mode": global_delivery_mode,
+        "global_screenshot_layout": global_screenshot_layout,
         "feed_intervals": feed_intervals,
     }
     return templates.TemplateResponse(request=request, name="settings.html", context=context)

discord_rss_bot/settings.py

@@ -51,4 +51,12 @@ def get_reader(custom_location: Path | None = None) -> Reader:
         # Set default
         reader.set_tag((), ".reader.update", {"interval": 15})
 
+    # Set the default screenshot layout to desktop if not already configured.
+    if reader.get_tag((), "screenshot_layout", None) is None:
+        reader.set_tag((), "screenshot_layout", "desktop")  # pyright: ignore[reportArgumentType]
+
+    # Set the default delivery mode for new feeds to embed if not already configured.
+    if reader.get_tag((), "delivery_mode", None) is None:
+        reader.set_tag((), "delivery_mode", "embed")  # pyright: ignore[reportArgumentType]
+
     return reader

discord_rss_bot/static/styles.css

@@ -17,3 +17,50 @@ body {
 .interval-input {
     max-width: 120px;
 }
+
+.screenshot-requirement {
+    color: #9c9c9c;
+    font-size: 0.9rem;
+}
+
+.screenshot-requirement code {
+    color: #cfcfcf;
+    background: #1b1b1b;
+    border: 1px solid #2a2a2a;
+    border-radius: 4px;
+    padding: 0 0.35rem;
+}
+
+.status-chip {
+    display: inline-flex !important;
+    align-items: center;
+    width: auto !important;
+    max-width: 100%;
+    white-space: normal;
+}
+
+.feed-page,
+.feed-page .card,
+.feed-page .card-body,
+.feed-page .input-group,
+.feed-page .input-group>* {
+    min-width: 0;
+}
+
+.feed-page__content {
+    min-width: 0;
+    max-width: 100%;
+}
+
+.feed-page__wrap {
+    overflow-wrap: anywhere;
+    word-break: break-word;
+}
+
+.feed-page__pre {
+    max-width: 100%;
+    overflow-x: auto;
+    white-space: pre-wrap;
+    overflow-wrap: anywhere;
+    word-break: break-word;
+}

discord_rss_bot/templates/add.html

@@ -1,32 +1,41 @@
 {% extends "base.html" %}
 {% block title %}
-| Add new feed
+    | Add new feed
 {% endblock title %}
 {% block content %}
-<div class="p-2 border border-dark">
-    <form action="/add" method="post">
-        <!-- Feed URL -->
-        <div class="row pb-2">
-            <label for="feed_url" class="col-sm-2 col-form-label">Feed URL</label>
-            <div class="col-sm-10">
-                <input name="feed_url" type="text" class="form-control bg-dark border-dark text-muted" id="feed_url" />
+    <div class="p-2 border border-dark">
+        <form action="/add" method="post">
+            <div class="mb-3 text-muted">
+                New feeds currently default to
+                <strong>{{ global_delivery_mode }}</strong>
+                delivery mode.
             </div>
-        </div>
-        <!-- Webhook dropdown -->
-        <div class="row pb-2">
-            <label for="webhook_dropdown" class="col-sm-2 col-form-label">Webhook</label>
-            <div class="col-sm-10">
-                <select class="col-auto form-select bg-dark border-dark text-muted" id="webhook_dropdown"
-                    name="webhook_dropdown">
-                    <option selected>Choose webhook...</option>
-                    {% for hook in webhooks %}<option value="{{ hook.name }}">{{- hook.name -}}</option>{% endfor %}
-                </select>
+            <!-- Feed URL -->
+            <div class="row pb-2">
+                <label for="feed_url" class="col-sm-2 col-form-label">Feed URL</label>
+                <div class="col-sm-10">
+                    <input name="feed_url"
+                           type="text"
+                           class="form-control bg-dark border-dark text-muted"
+                           id="feed_url" />
+                </div>
             </div>
-        </div>
-        <!-- Submit button -->
-        <div class="d-md-flex">
-            <button class="btn btn-dark btn-sm">Add feed</button>
-        </div>
-    </form>
-</div>
+            <!-- Webhook dropdown -->
+            <div class="row pb-2">
+                <label for="webhook_dropdown" class="col-sm-2 col-form-label">Webhook</label>
+                <div class="col-sm-10">
+                    <select class="col-auto form-select bg-dark border-dark text-muted"
+                            id="webhook_dropdown"
+                            name="webhook_dropdown">
+                        <option selected>Choose webhook...</option>
+                        {% for hook in webhooks %}<option value="{{ hook.name }}">{{- hook.name -}}</option>{% endfor %}
+                    </select>
+                </div>
+            </div>
+            <!-- Submit button -->
+            <div class="d-md-flex">
+                <button class="btn btn-dark btn-sm">Add feed</button>
+            </div>
+        </form>
+    </div>
 {% endblock content %}

discord_rss_bot/templates/feed.html

@@ -3,170 +3,264 @@
     | {{ feed.title }}
 {% endblock title %}
 {% block content %}
-    <div class="card mb-3 border border-dark p-3 text-light">
-        <!-- Feed Title -->
-        <h2>
-            <a class="text-muted" href="{{ feed.url }}">{{ feed.title }}</a> ({{ total_entries }} entries)
-        </h2>
-        {% if not feed.updates_enabled %}<span class="badge bg-danger">Disabled</span>{% endif %}
-        {% if feed.last_exception %}
-            <div class="mt-3">
-                <h5 class="text-danger">{{ feed.last_exception.type_name }}:</h5>
-                <code class="d-block">{{ feed.last_exception.value_str }}</code>
-                <button class="btn btn-secondary btn-sm mt-2"
-                        type="button"
-                        data-bs-toggle="collapse"
-                        data-bs-target="#exceptionDetails"
-                        aria-expanded="false"
-                        aria-controls="exceptionDetails">Show Traceback</button>
-                <div class="collapse" id="exceptionDetails">
-                    <pre><code>{{ feed.last_exception.traceback_str }}</code></pre>
+    <div class="row g-3 feed-page">
+        <div class="col-12">
+            <article class="card border border-dark shadow-sm text-light">
+                <div class="card-body p-3 p-md-4 text-light">
+                    <div class="d-flex flex-wrap justify-content-between align-items-start gap-3">
+                        <div class="feed-page__content">
+                            <h2 class="h3 mb-1">
+                                <a class="text-muted text-decoration-none feed-page__wrap"
+                                   href="{{ feed.url }}">{{ feed.title }}</a>
+                            </h2>
+                            <p class="text-muted mb-0">{{ total_entries }} entries</p>
+                        </div>
+                        <div class="d-flex flex-wrap gap-2">
+                            {% if not feed.updates_enabled %}<span class="badge bg-danger status-chip">Disabled</span>{% endif %}
+                            <span class="badge status-chip {% if delivery_mode == "embed" %} bg-primary {% else %} bg-secondary {% endif %}">
+                                Current mode:
+                                {% if delivery_mode == "embed" %}
+                                    Embed
+                                {% elif delivery_mode == "screenshot" %}
+                                    Screenshot
+                                {% else %}
+                                    Text
+                                {% endif %}
+                            </span>
+                            {% if delivery_mode == "screenshot" %}
+                                <span class="badge status-chip bg-secondary">
+                                    Screenshot layout:
+                                    {% if screenshot_layout == "mobile" %}
+                                        Mobile
+                                    {% else %}
+                                        Desktop
+                                    {% endif %}
+                                </span>
+                            {% endif %}
+                        </div>
+                    </div>
+                    {% if feed.last_exception %}
+                        <div class="alert alert-danger mt-4 mb-0" role="alert">
+                            <h5 class="alert-heading mb-2">{{ feed.last_exception.type_name }}</h5>
+                            <code class="d-block mb-2 feed-page__wrap">{{ feed.last_exception.value_str }}</code>
+                            <button class="btn btn-outline-light btn-sm"
+                                    type="button"
+                                    data-bs-toggle="collapse"
+                                    data-bs-target="#exceptionDetails"
+                                    aria-expanded="false"
+                                    aria-controls="exceptionDetails">Show Traceback</button>
+                            <div class="collapse mt-2" id="exceptionDetails">
+                                <pre class="mb-0 feed-page__pre"><code>{{ feed.last_exception.traceback_str }}</code></pre>
+                            </div>
+                        </div>
+                    {% endif %}
+                    <section class="mt-4 pt-3 border-top border-secondary-subtle">
+                        <h3 class="h6 text-uppercase text-muted mb-3">Actions</h3>
+                        <div class="d-flex flex-wrap gap-2">
+                            <a href="/update?feed_url={{ feed.url|encode_url }}"
+                               class="btn btn-primary btn-sm">Update</a>
+                            <form action="/remove" method="post" class="d-inline">
+                                <button class="btn btn-danger btn-sm"
+                                        name="feed_url"
+                                        value="{{ feed.url }}"
+                                        onclick="return confirm('Are you sure you want to delete this feed?')">
+                                    Remove
+                                </button>
+                            </form>
+                            {% if not feed.updates_enabled %}
+                                <form action="/unpause" method="post" class="d-inline">
+                                    <button class="btn btn-secondary btn-sm"
+                                            name="feed_url"
+                                            value="{{ feed.url }}">Unpause</button>
+                                </form>
+                            {% else %}
+                                <form action="/pause" method="post" class="d-inline">
+                                    <button class="btn btn-danger btn-sm" name="feed_url" value="{{ feed.url }}">Pause</button>
+                                </form>
+                            {% endif %}
+                            {% if not "youtube.com/feeds/videos.xml" in feed.url %}
+                                {% if delivery_mode == "embed" %}
+                                    <form action="/use_text" method="post" class="d-inline">
+                                        <button class="btn btn-outline-light btn-sm"
+                                                name="feed_url"
+                                                value="{{ feed.url }}">Send text message instead of embed</button>
+                                    </form>
+                                    <form action="/use_screenshot" method="post" class="d-inline">
+                                        <button class="btn btn-outline-light btn-sm"
+                                                name="feed_url"
+                                                value="{{ feed.url }}">
+                                            Send full-page screenshot instead of embed
+                                        </button>
+                                    </form>
+                                {% elif delivery_mode == "screenshot" %}
+                                    <form action="/use_embed" method="post" class="d-inline">
+                                        <button class="btn btn-outline-light btn-sm"
+                                                name="feed_url"
+                                                value="{{ feed.url }}">Send embed instead of screenshot</button>
+                                    </form>
+                                    <form action="/use_text" method="post" class="d-inline">
+                                        <button class="btn btn-outline-light btn-sm"
+                                                name="feed_url"
+                                                value="{{ feed.url }}">Send text message instead of screenshot</button>
+                                    </form>
+                                    {% if screenshot_layout == "mobile" %}
+                                        <form action="/use_screenshot_desktop" method="post" class="d-inline">
+                                            <button class="btn btn-outline-secondary btn-sm"
+                                                    name="feed_url"
+                                                    value="{{ feed.url }}">Use desktop screenshot layout</button>
+                                        </form>
+                                    {% else %}
+                                        <form action="/use_screenshot_mobile" method="post" class="d-inline">
+                                            <button class="btn btn-outline-secondary btn-sm"
+                                                    name="feed_url"
+                                                    value="{{ feed.url }}">Use mobile screenshot layout</button>
+                                        </form>
+                                    {% endif %}
+                                {% else %}
+                                    <form action="/use_embed" method="post" class="d-inline">
+                                        <button class="btn btn-outline-light btn-sm"
+                                                name="feed_url"
+                                                value="{{ feed.url }}">Send embed instead of text message</button>
+                                    </form>
+                                    <form action="/use_screenshot" method="post" class="d-inline">
+                                        <button class="btn btn-outline-light btn-sm"
+                                                name="feed_url"
+                                                value="{{ feed.url }}">
+                                            Send full-page screenshot instead of text message
+                                        </button>
+                                    </form>
+                                {% endif %}
+                                <div class="w-100 mt-1 screenshot-requirement">
+                                    Screenshot mode requires Chromium to be installed for Playwright. Run <code>uv run playwright install chromium</code> once on this machine.
+                                </div>
+                            {% endif %}
+                        </div>
+                    </section>
+                    <section class="mt-4 pt-3 border-top border-secondary-subtle">
+                        <h3 class="h6 text-uppercase text-muted mb-3">Customization</h3>
+                        <div class="d-flex flex-column align-items-start gap-2">
+                            <a class="text-muted text-decoration-none"
+                               href="/whitelist?feed_url={{ feed.url|encode_url }}">Whitelist</a>
+                            <a class="text-muted text-decoration-none"
+                               href="/blacklist?feed_url={{ feed.url|encode_url }}">Blacklist</a>
+                            <a class="text-muted text-decoration-none"
+                               href="/custom?feed_url={{ feed.url|encode_url }}">
+                                Customize message
+                                {% if delivery_mode == "text" %}(Currently active){% endif %}
+                            </a>
+                            {% if not "youtube.com/feeds/videos.xml" in feed.url %}
+                                <a class="text-muted text-decoration-none"
+                                   href="/embed?feed_url={{ feed.url|encode_url }}">
+                                    Customize embed
+                                    {% if delivery_mode == "embed" %}(Currently active){% endif %}
+                                </a>
+                            {% endif %}
+                        </div>
+                    </section>
+                    <section class="mt-4 pt-3 border-top border-secondary-subtle">
+                        <h3 class="h6 text-uppercase text-muted mb-3">Feed URL</h3>
+                        <form action="/change_feed_url" method="post" class="mb-0">
+                            <input type="hidden" name="old_feed_url" value="{{ feed.url }}" />
+                            <div class="input-group input-group-sm feed-page__content">
+                                <input type="url"
+                                       class="form-control feed-page__wrap"
+                                       name="new_feed_url"
+                                       value="{{ feed.url }}"
+                                       required />
+                                <button class="btn btn-warning" type="submit">Update URL</button>
+                            </div>
+                        </form>
+                    </section>
+                    <section class="mt-4 pt-3 border-top border-secondary-subtle">
+                        <h3 class="h6 text-uppercase text-muted mb-3">Feed Information</h3>
+                        <div class="row g-2 text-muted small">
+                            <div class="col-12 col-md-6">
+                                <div class="p-2 border border-secondary rounded">Added: {{ feed.added | relative_time }}</div>
+                            </div>
+                            <div class="col-12 col-md-6">
+                                <div class="p-2 border border-secondary rounded">Last Updated: {{ feed.last_updated | relative_time }}</div>
+                            </div>
+                            <div class="col-12 col-md-6">
+                                <div class="p-2 border border-secondary rounded">Last Retrieved: {{ feed.last_retrieved | relative_time }}</div>
+                            </div>
+                            <div class="col-12 col-md-6">
+                                <div class="p-2 border border-secondary rounded">Next Update: {{ feed.update_after | relative_time }}</div>
+                            </div>
+                            <div class="col-12 col-md-6">
+                                <div class="p-2 border border-secondary rounded">
+                                    Updates:
+                                    <span class="badge {{ 'bg-success' if feed.updates_enabled else 'bg-danger' }}">
+                                        {{ 'Enabled' if feed.updates_enabled else 'Disabled' }}
+                                    </span>
+                                </div>
+                            </div>
+                        </div>
+                    </section>
+                    <section class="mt-4 pt-3 border-top border-secondary-subtle">
+                        <div class="d-flex flex-wrap align-items-center justify-content-between gap-2 mb-3">
+                            <h3 class="h6 text-uppercase text-muted mb-0">Update Interval</h3>
+                            <span class="badge {% if feed_interval %} bg-info {% else %} bg-secondary {% endif %}">
+                                {% if feed_interval %}
+                                    Custom
+                                {% else %}
+                                    Using global default
+                                {% endif %}
+                            </span>
+                        </div>
+                        <p class="text-muted mb-3">
+                            Current:
+                            <strong>
+                                {% if feed_interval %}
+                                    {{ feed_interval }}
+                                    {% if feed_interval >= 60 %}({{ (feed_interval / 60) | round(1) }} hours){% endif %}
+                                {% else %}
+                                    {{ global_interval }}
+                                    {% if global_interval >= 60 %}({{ (global_interval / 60) | round(1) }} hours){% endif %}
+                                {% endif %}
+                                minutes
+                            </strong>
+                        </p>
+                        <div class="d-flex flex-wrap align-items-center gap-2">
+                            <form action="/set_update_interval"
+                                  method="post"
+                                  class="d-inline-flex gap-2 align-items-center">
+                                <input type="hidden" name="feed_url" value="{{ feed.url }}" />
+                                <input type="number"
+                                       class="form-control form-control-sm interval-input"
+                                       style="width: 100px"
+                                       name="interval_minutes"
+                                       placeholder="Minutes"
+                                       min="1"
+                                       value="{{ feed_interval if feed_interval else global_interval }}"
+                                       required />
+                                <button class="btn btn-primary btn-sm" type="submit">Set Interval</button>
+                            </form>
+                            {% if feed_interval %}
+                                <form action="/reset_update_interval" method="post" class="d-inline">
+                                    <input type="hidden" name="feed_url" value="{{ feed.url }}" />
+                                    <button class="btn btn-secondary btn-sm" type="submit">Reset to Global Default</button>
+                                </form>
+                            {% endif %}
+                        </div>
+                    </section>
                 </div>
+            </article>
+        </div>
+        <div class="col-12">
+            <section class="card border border-dark shadow-sm text-light">
+                <div class="card-header bg-transparent text-muted border-secondary">Rendered HTML content</div>
+                <div class="card-body p-0">
+                    <pre class="m-0 p-3 feed-page__pre">{{ html|safe }}</pre>
+                </div>
+            </section>
+        </div>
+        {% if is_show_more_entries_button_visible %}
+            <div class="col-12">
+                <a class="btn btn-dark"
+                   href="/feed?feed_url={{ feed.url|encode_url }}&starting_after={{ last_entry.id|encode_url }}">
+                    Show more entries
+                </a>
             </div>
         {% endif %}
-        <!-- Feed Actions -->
-        <div class="mt-3 d-flex flex-wrap gap-2">
-            <a href="/update?feed_url={{ feed.url|encode_url }}"
-               class="btn btn-primary btn-sm">Update</a>
-            <form action="/remove" method="post" class="d-inline">
-                <button class="btn btn-danger btn-sm"
-                        name="feed_url"
-                        value="{{ feed.url }}"
-                        onclick="return confirm('Are you sure you want to delete this feed?')">Remove</button>
-            </form>
-            {% if not feed.updates_enabled %}
-                <form action="/unpause" method="post" class="d-inline">
-                    <button class="btn btn-secondary btn-sm"
-                            name="feed_url"
-                            value="{{ feed.url }}">Unpause</button>
-                </form>
-            {% else %}
-                <form action="/pause" method="post" class="d-inline">
-                    <button class="btn btn-danger btn-sm" name="feed_url" value="{{ feed.url }}">Pause</button>
-                </form>
-            {% endif %}
-            {% if not "youtube.com/feeds/videos.xml" in feed.url %}
-                {% if should_send_embed %}
-                    <form action="/use_text" method="post" class="d-inline">
-                        <button class="btn btn-dark btn-sm" name="feed_url" value="{{ feed.url }}">Send text message instead of embed</button>
-                    </form>
-                {% else %}
-                    <form action="/use_embed" method="post" class="d-inline">
-                        <button class="btn btn-dark btn-sm" name="feed_url" value="{{ feed.url }}">Send embed instead of text message</button>
-                    </form>
-                {% endif %}
-            {% endif %}
-        </div>
-        <!-- Additional Links -->
-        <div class="mt-3">
-            <a class="text-muted d-block"
-               href="/whitelist?feed_url={{ feed.url|encode_url }}">Whitelist</a>
-            <a class="text-muted d-block"
-               href="/blacklist?feed_url={{ feed.url|encode_url }}">Blacklist</a>
-            <a class="text-muted d-block"
-               href="/custom?feed_url={{ feed.url|encode_url }}">
-                Customize message
-                {% if not should_send_embed %}(Currently active){% endif %}
-            </a>
-            {% if not "youtube.com/feeds/videos.xml" in feed.url %}
-                <a class="text-muted d-block"
-                   href="/embed?feed_url={{ feed.url|encode_url }}">
-                    Customize embed
-                    {% if should_send_embed %}(Currently active){% endif %}
-                </a>
-            {% endif %}
-        </div>
-        <!-- Feed URL Configuration -->
-        <div class="mt-4 border-top border-secondary pt-3">
-            <h5 class="mb-3">Feed URL</h5>
-            <form action="/change_feed_url" method="post" class="mb-2">
-                <input type="hidden" name="old_feed_url" value="{{ feed.url }}" />
-                <div class="input-group input-group-sm mb-2">
-                    <input type="url"
-                           class="form-control form-control-sm"
-                           name="new_feed_url"
-                           value="{{ feed.url }}"
-                           required />
-                    <button class="btn btn-warning" type="submit">Update URL</button>
-                </div>
-            </form>
-        </div>
-        <!-- Feed Metadata -->
-        <div class="mt-4 border-top border-secondary pt-3">
-            <h5 class="mb-3">Feed Information</h5>
-            <div class="row text-muted">
-                <div class="col-md-6 mb-2">
-                    <small><strong>Added:</strong> {{ feed.added | relative_time }}</small>
-                </div>
-                <div class="col-md-6 mb-2">
-                    <small><strong>Last Updated:</strong> {{ feed.last_updated | relative_time }}</small>
-                </div>
-                <div class="col-md-6 mb-2">
-                    <small><strong>Last Retrieved:</strong> {{ feed.last_retrieved | relative_time }}</small>
-                </div>
-                <div class="col-md-6 mb-2">
-                    <small><strong>Next Update:</strong> {{ feed.update_after | relative_time }}</small>
-                </div>
-                <div class="col-md-6 mb-2">
-                    <small><strong>Updates:</strong> <span class="badge {{ 'bg-success' if feed.updates_enabled else 'bg-danger' }}">{{ 'Enabled' if feed.updates_enabled else 'Disabled' }}</span></small>
-                </div>
-            </div>
-        </div>
-        <!-- Update Interval Configuration -->
-        <div class="mt-4 border-top border-secondary pt-3">
-            <h5 class="mb-3">
-                Update Interval <span class="badge
-              {% if feed_interval %}
-                  bg-info
-              {% else %}
-                  bg-secondary
-              {% endif %}">
-                {% if feed_interval %}
-                    Custom
-                {% else %}
-                    Using global default
-                {% endif %}
-            </span>
-        </h5>
-        <div class="d-flex align-items-center gap-2 flex-wrap">
-            <span class="text-muted">Current: <strong>
-                {% if feed_interval %}
-                    {{ feed_interval }}
-                    {% if feed_interval >= 60 %}({{ (feed_interval / 60) | round(1) }} hours){% endif %}
-                {% else %}
-                    {{ global_interval }}
-                    {% if global_interval >= 60 %}({{ (global_interval / 60) | round(1) }} hours){% endif %}
-                {% endif %}
-            minutes</strong></span>
-            <form action="/set_update_interval"
-                  method="post"
-                  class="d-inline-flex gap-2 align-items-center">
-                <input type="hidden" name="feed_url" value="{{ feed.url }}" />
-                <input type="number"
-                       class="form-control form-control-sm interval-input"
-                       style="width: 100px"
-                       name="interval_minutes"
-                       placeholder="Minutes"
-                       min="1"
-                       value="{{ feed_interval if feed_interval else global_interval }}"
-                       required />
-                <button class="btn btn-primary btn-sm" type="submit">Set Interval</button>
-            </form>
-            {% if feed_interval %}
-                <form action="/reset_update_interval" method="post" class="d-inline">
-                    <input type="hidden" name="feed_url" value="{{ feed.url }}" />
-                    <button class="btn btn-secondary btn-sm" type="submit">Reset to Global Default</button>
-                </form>
-            {% endif %}
-        </div>
     </div>
-</div>
-{# Rendered HTML content #}
-<pre>{{ html|safe }}</pre>
-{% if is_show_more_entries_button_visible %}
-    <a class="btn btn-dark mt-3"
-       href="/feed?feed_url={{ feed.url|encode_url }}&starting_after={{ last_entry.id|encode_url }}">
-        Show more entries
-    </a>
-{% endif %}
 {% endblock content %}

discord_rss_bot/templates/settings.html

@@ -34,6 +34,47 @@
                 </div>
             </div>
         </form>
+        <form action="/set_global_delivery_mode" method="post" class="mt-4">
+            <div class="settings-form-row mb-2">
+                <label for="delivery_mode" class="form-label mb-1">Default delivery mode for new feeds</label>
+                <div class="input-group input-group-lg">
+                    <select id="delivery_mode"
+                            class="form-select settings-input"
+                            name="delivery_mode">
+                        <option value="embed"
+                                {% if global_delivery_mode == "embed" %}selected{% endif %}>Embed</option>
+                        <option value="text"
+                                {% if global_delivery_mode == "text" %}selected{% endif %}>Text</option>
+                    </select>
+                    <button class="btn btn-primary px-4" type="submit">Save</button>
+                </div>
+                <div class="form-text text-muted mt-2">
+                    New feeds inherit this value. Existing feeds keep their current delivery mode.
+                </div>
+            </div>
+        </form>
+        <form action="/set_global_screenshot_layout" method="post" class="mt-4">
+            <div class="settings-form-row mb-2">
+                <label for="screenshot_layout" class="form-label mb-1">Default screenshot layout for new feeds</label>
+                <div class="input-group input-group-lg">
+                    <select id="screenshot_layout"
+                            class="form-select settings-input"
+                            name="screenshot_layout">
+                        <option value="desktop"
+                                {% if global_screenshot_layout == "desktop" %}selected{% endif %}>Desktop</option>
+                        <option value="mobile"
+                                {% if global_screenshot_layout == "mobile" %}selected{% endif %}>Mobile</option>
+                    </select>
+                    <button class="btn btn-primary px-4" type="submit">Save</button>
+                </div>
+                <div class="form-text text-muted mt-2">
+                    New feeds inherit this value. Existing feeds keep their current screenshot layout.
+                </div>
+                <div class="form-text screenshot-requirement mt-1">
+                    Screenshot mode requires Chromium to be installed for Playwright. Run <code>uv run playwright install chromium</code> once on this machine.
+                </div>
+            </div>
+        </form>
     </section>
     <section class="mt-5">
         <div class="text-light">