feat: add user settings feature

.gitignore

@@ -60,6 +60,7 @@ cover/
 local_settings.py
 db.sqlite3
 db.sqlite3-journal
+*.db
 
 # Flask stuff:
 instance/
@@ -149,7 +150,19 @@ cython_debug/
 #  be found at https://github.com/github/gitignore/blob/main/Global/JetBrains.gitignore
 #  and can be added to the global gitignore or merged into this file.  For a more nuclear
 #  option (not recommended) you can uncomment the following to ignore the entire idea folder.
-.idea/
+.idea/*
+!.idea/runConfigurations/
+.idea/runConfigurations/*
+!.idea/runConfigurations/*.xml
+!.idea/codeStyles/
+.idea/codeStyles/*
+!.idea/codeStyles/*.xml
+!.idea/inspectionProfiles/
+.idea/inspectionProfiles/*
+!.idea/inspectionProfiles/*.xml
+!.idea/vcs.xml
+!.idea/modules.xml
+!.idea/*.iml
 
 # Covers JetBrains IDEs: IntelliJ, RubyMine, PhpStorm, AppCode, PyCharm, CLion, Android Studio, WebStorm and Rider
 # Reference: https://intellij-support.jetbrains.com/hc/en-us/articles/206544839

apps/telegram-bot/Dockerfile

@@ -47,4 +47,5 @@ COPY --from=builder-base $PYSETUP_PATH $PYSETUP_PATH
 COPY packages/ /app/packages/
 COPY apps/telegram-bot/ /app/apps/telegram-bot/
 WORKDIR /app/apps/telegram-bot
+RUN mkdir -p /app/apps/telegram-bot/data
 CMD ["python", "-m", "core.main"]

apps/telegram-bot/core/config.py

@@ -122,11 +122,16 @@ def ban_list_resolver(ban_list_string: str) -> list:
 GENERAL_SCRAPING_ON = get_env_bool(env, "GENERAL_SCRAPING_ON", False)
 
 # Database configuration
-DATABASE_ON = get_env_bool(env, "DATABASE_ON", False)
+ITEM_DATABASE_ON = get_env_bool(env, "ITEM_DATABASE_ON", False)
 MONGODB_PORT = int(env.get("MONGODB_PORT", 27017)) or 27017
 MONGODB_HOST = env.get("MONGODB_HOST", "localhost")
 MONGODB_URL = env.get("MONGODB_URL", f"mongodb://{MONGODB_HOST}:{MONGODB_PORT}")
 
+# User settings database (SQLAlchemy async)
+SETTINGS_DATABASE_URL = env.get(
+    "SETTINGS_DATABASE_URL", "sqlite+aiosqlite:///data/fastfetchbot.db"
+)
+
 # Jinja2 template configuration
 templates_directory = os.path.join(current_directory, "templates")
 JINJA2_ENV = Environment(

apps/telegram-bot/core/handlers/commands.py

@@ -0,0 +1,83 @@
+from telegram import Update, InlineKeyboardButton, InlineKeyboardMarkup
+from telegram.ext import CallbackContext
+
+from core.services.user_settings import (
+    ensure_user_settings,
+    get_auto_fetch_in_dm,
+    toggle_auto_fetch_in_dm,
+)
+
+
+async def start_command(update: Update, context: CallbackContext) -> None:
+    """Handle /start command: greet user and ensure settings row exists."""
+    user_id = update.effective_user.id
+    await ensure_user_settings(user_id)
+
+    await update.message.reply_text(
+        "Welcome to FastFetchBot!\n\n"
+        "Send me a URL in this chat and I'll fetch the content for you.\n\n"
+        "Available commands:\n"
+        "/settings — Customize bot behavior\n"
+    )
+
+
+async def settings_command(update: Update, context: CallbackContext) -> None:
+    """Handle /settings command: show current user settings with toggle buttons."""
+    user_id = update.effective_user.id
+    await ensure_user_settings(user_id)
+    auto_fetch = await get_auto_fetch_in_dm(user_id)
+
+    keyboard = _build_settings_keyboard(auto_fetch)
+    await update.message.reply_text(
+        text=_build_settings_text(auto_fetch),
+        reply_markup=InlineKeyboardMarkup(keyboard),
+    )
+
+
+async def settings_callback(update: Update, context: CallbackContext) -> None:
+    """Handle settings toggle button presses."""
+    query = update.callback_query
+    await query.answer()
+
+    data = query.data
+
+    if data == "settings:close":
+        await query.message.delete()
+        return
+
+    if data != "settings:toggle_auto_fetch":
+        return
+
+    user_id = update.effective_user.id
+    new_value = await toggle_auto_fetch_in_dm(user_id)
+
+    keyboard = _build_settings_keyboard(new_value)
+    await query.edit_message_text(
+        text=_build_settings_text(new_value),
+        reply_markup=InlineKeyboardMarkup(keyboard),
+    )
+
+
+def _build_settings_keyboard(auto_fetch: bool) -> list[list[InlineKeyboardButton]]:
+    status = "ON" if auto_fetch else "OFF"
+    return [
+        [
+            InlineKeyboardButton(
+                f"Auto-fetch in DM: {status}",
+                callback_data="settings:toggle_auto_fetch",
+            )
+        ],
+        [
+            InlineKeyboardButton("Close", callback_data="settings:close"),
+        ],
+    ]
+
+
+def _build_settings_text(auto_fetch: bool) -> str:
+    status = "enabled" if auto_fetch else "disabled"
+    return (
+        f"Your Settings\n\n"
+        f"Auto-fetch in DM: {status}\n"
+        f"When enabled, URLs sent in private chat will be automatically processed.\n"
+        f"When disabled, you will see action buttons to choose how to process each URL."
+    )

apps/telegram-bot/core/handlers/messages.py

@@ -13,17 +13,28 @@
 
 from core.database import save_instances
 from core.models.telegram_chat import TelegramMessage, TelegramUser, TelegramChat
+from core.services.user_settings import ensure_user_settings
 from fastfetchbot_shared.utils.logger import logger
 from core.config import (
     TELEBOT_DEBUG_CHANNEL,
-    DATABASE_ON,
+    ITEM_DATABASE_ON,
 )
 
 
 async def all_messages_process(update: Update, context: CallbackContext) -> None:
     message = update.message
     logger.debug(message)
-    if message and DATABASE_ON:
+
+    # Ensure every private-chat user has a settings row from their first interaction.
+    if message and message.chat.type == "private" and message.from_user:
+        try:
+            await ensure_user_settings(message.from_user.id)
+        except Exception:
+            logger.warning(
+                "Failed to ensure user settings for user {}", message.from_user.id
+            )
+
+    if message and ITEM_DATABASE_ON:
         telegram_chat = TelegramChat.construct(**message.chat.to_dict())
         telegram_user = TelegramUser.construct(**message.from_user.to_dict())
         telegram_message = TelegramMessage(

apps/telegram-bot/core/handlers/url_process.py

@@ -9,6 +9,7 @@
 
 from core import api_client
 from core.services.message_sender import send_item_message
+from core.services.user_settings import get_auto_fetch_in_dm
 from fastfetchbot_shared.utils.config import SOCIAL_MEDIA_WEBSITE_PATTERNS, VIDEO_WEBSITE_PATTERNS
 from fastfetchbot_shared.utils.logger import logger
 from core.config import (
@@ -24,6 +25,13 @@
 
 async def https_url_process(update: Update, context: CallbackContext) -> None:
     message = update.message
+
+    # Check user's auto-fetch preference
+    auto_fetch = await get_auto_fetch_in_dm(message.from_user.id)
+    if auto_fetch:
+        await _auto_fetch_urls(message)
+        return
+
     welcome_message = await message.reply_text(
         text="Processing...",
     )
@@ -198,6 +206,33 @@ async def https_url_process(update: Update, context: CallbackContext) -> None:
             await process_message.delete()
 
 
+async def _auto_fetch_urls(message) -> None:
+    """Auto-fetch all URLs in a DM message without showing action buttons."""
+    url_dict = message.parse_entities(types=["url"])
+    for i, url in enumerate(url_dict.values()):
+        url_metadata = await api_client.get_url_metadata(
+            url, ban_list=TELEGRAM_BOT_MESSAGE_BAN_LIST
+        )
+        if url_metadata["source"] == "unknown" and GENERAL_SCRAPING_ON:
+            metadata_item = await api_client.get_item(url=url_metadata["url"])
+            await send_item_message(
+                metadata_item, chat_id=message.chat_id
+            )
+        elif url_metadata["source"] == "unknown" or url_metadata["source"] == "banned":
+            logger.debug(f"for the {i + 1}th url {url}, no supported url found.")
+            continue
+        if url_metadata.get("source") in SOCIAL_MEDIA_WEBSITE_PATTERNS.keys():
+            metadata_item = await api_client.get_item(url=url_metadata["url"])
+            await send_item_message(
+                metadata_item, chat_id=message.chat_id
+            )
+        if url_metadata.get("source") in VIDEO_WEBSITE_PATTERNS.keys():
+            metadata_item = await api_client.get_item(url=url_metadata["url"])
+            await send_item_message(
+                metadata_item, chat_id=message.chat_id
+            )
+
+
 async def https_url_auto_process(update: Update, context: CallbackContext) -> None:
     message = update.message
     url_dict = message.parse_entities(types=["url"])

apps/telegram-bot/core/services/bot_app.py

@@ -3,11 +3,13 @@
 mimetypes.init()
 
 from telegram import (
+    BotCommand,
     Update,
     MessageEntity,
 )
 from telegram.ext import (
     Application,
+    CommandHandler,
     MessageHandler,
     CallbackQueryHandler,
     filters,
@@ -32,6 +34,7 @@
 
 from core.handlers.url_process import https_url_process, https_url_auto_process
 from core.handlers.buttons import buttons_process, invalid_buttons
+from core.handlers.commands import start_command, settings_command, settings_callback
 from core.handlers.messages import all_messages_process, error_process
 
 # Re-export for external consumers
@@ -94,6 +97,11 @@ async def startup() -> None:
                 & filters.USER,
         callback=https_url_auto_process,
     )
+    start_command_handler = CommandHandler("start", start_command)
+    settings_command_handler = CommandHandler("settings", settings_command)
+    settings_callback_handler = CallbackQueryHandler(
+        callback=settings_callback, pattern=r"^settings:"
+    )
     invalid_buttons_handler = CallbackQueryHandler(
         callback=invalid_buttons,
         pattern=InvalidCallbackData,
@@ -104,14 +112,24 @@ async def startup() -> None:
     # add handlers
     application.add_handlers(
         [
+            start_command_handler,
+            settings_command_handler,
             https_url_process_handler,
             https_url_auto_process_handler,
             all_messages_handler,
+            settings_callback_handler,
             invalid_buttons_handler,
             buttons_process_handler,
         ]
     )
     application.add_error_handler(error_process)
+    # Register bot menu commands
+    await application.bot.set_my_commands(
+        [
+            BotCommand("start", "Start the bot"),
+            BotCommand("settings", "Customize bot behavior"),
+        ]
+    )
     if application.post_init:
         await application.post_init()
     await application.start()

apps/telegram-bot/core/services/user_settings.py

@@ -0,0 +1,52 @@
+from sqlalchemy import select
+
+from fastfetchbot_shared.database.session import get_session
+from fastfetchbot_shared.database.models.user_setting import UserSetting
+
+# In-memory cache of user IDs known to have a settings row.
+# Resets on process restart — cheap way to avoid a DB query on every message.
+_known_user_ids: set[int] = set()
+
+
+async def ensure_user_settings(user_id: int) -> None:
+    """Create a UserSetting row with defaults if one doesn't exist yet."""
+    if user_id in _known_user_ids:
+        return
+    async with get_session() as session:
+        result = await session.execute(
+            select(UserSetting).where(UserSetting.telegram_user_id == user_id)
+        )
+        if result.scalar_one_or_none() is None:
+            session.add(UserSetting(telegram_user_id=user_id))
+    _known_user_ids.add(user_id)
+
+
+async def get_auto_fetch_in_dm(user_id: int) -> bool:
+    """Return the user's auto_fetch_in_dm preference. Defaults to True."""
+    async with get_session() as session:
+        result = await session.execute(
+            select(UserSetting.auto_fetch_in_dm).where(
+                UserSetting.telegram_user_id == user_id
+            )
+        )
+        value = result.scalar_one_or_none()
+    return value if value is not None else True
+
+
+async def toggle_auto_fetch_in_dm(user_id: int) -> bool:
+    """Toggle auto_fetch_in_dm for the given user. Returns the new value."""
+    async with get_session() as session:
+        result = await session.execute(
+            select(UserSetting).where(UserSetting.telegram_user_id == user_id)
+        )
+        user_setting = result.scalar_one_or_none()
+        if user_setting is None:
+            # Safety fallback — ensure_user_settings should have been called,
+            # but handle gracefully.
+            user_setting = UserSetting(
+                telegram_user_id=user_id, auto_fetch_in_dm=False
+            )
+            session.add(user_setting)
+        else:
+            user_setting.auto_fetch_in_dm = not user_setting.auto_fetch_in_dm
+        return user_setting.auto_fetch_in_dm