debug: add logging to _find_user_id_by_username

To see the actual error when user lookup fails.

apps/telegram-bot/bot.py

@@ -4,13 +4,22 @@ import logging
 import os
 import sys
 
-from telegram.ext import Application, CommandHandler, MessageHandler, filters
+sys.path.insert(0, "/home/shoko/repositories/jigaido")
+
+from telegram.ext import (
+    Application,
+    CommandHandler,
+    MessageHandler,
+    CallbackQueryHandler,
+    filters,
+)
 
 from commands import (
     cmd_add,
     cmd_admin,
     cmd_bounty,
     cmd_delete,
+    cmd_delete_message,
     cmd_edit,
     cmd_help,
     cmd_my,
@@ -29,7 +38,13 @@ logging.basicConfig(
 )
 log = logging.getLogger(__name__)
 
-BOT_TOKEN = os.environ.get("JIGAIDO_BOT_TOKEN", "")
+from config import config
+
+BOT_TOKEN = config.bot_token or ""
+
+
+async def error_handler(update, context):
+    log.error(f"Error: {context.error}")
 
 
 def build_app() -> Application:
@@ -50,7 +65,9 @@ def build_app() -> Application:
     app.add_handler(CommandHandler("admin", cmd_admin))
     app.add_handler(CommandHandler("recover", cmd_recover))
 
-    app.add_handler(MessageHandler(filters.COMMAND, cmd_help))
+    app.add_handler(CallbackQueryHandler(cmd_delete_message))
+
+    app.add_error_handler(error_handler)
 
     return app
 
@@ -74,6 +91,8 @@ async def post_init(app: Application) -> None:
 
 
 def main() -> None:
+    import asyncio
+
     if not BOT_TOKEN:
         log.error("JIGAIDO_BOT_TOKEN environment variable not set.")
         sys.exit(1)
@@ -82,6 +101,11 @@ def main() -> None:
     app.post_init = post_init
 
     log.info("JIGAIDO starting...")
+    # Python 3.14 compatibility: ensure event loop exists
+    try:
+        asyncio.get_event_loop()
+    except RuntimeError:
+        asyncio.set_event_loop(asyncio.new_event_loop())
     app.run_polling(drop_pending_updates=True)
 
 

apps/telegram-bot/commands.py

@@ -9,6 +9,8 @@ from zoneinfo import ZoneInfo, ZoneInfoNotFoundError
 import dateparser
 from telegram import Update
 from telegram.ext import ContextTypes
+from telegram import InlineKeyboardButton, InlineKeyboardMarkup
+from telegram.constants import ParseMode
 
 from adapters.storage.json_file import JsonFileRoomStorage, JsonFileTrackingStorage
 from core.services import BountyService, TrackingService
@@ -58,6 +60,7 @@ def extract_args(text: str) -> list[str]:
 
 def parse_args(
     args: list[str],
+    timezone_str: str = "UTC",
 ) -> tuple[Optional[str], Optional[str], Optional[int], bool, bool]:
     text = None
     link = None
@@ -65,39 +68,78 @@ def parse_args(
     clear_link = False
     clear_date = False
 
+    try:
+        tz = ZoneInfo(timezone_str)
+    except (KeyError, ZoneInfoNotFoundError):
+        tz = ZoneInfo("UTC")
+
+    def is_url(s: str) -> bool:
+        if not s:
+            return False
+        if s.startswith("http://") or s.startswith("https://"):
+            return True
+        if "." in s and " " not in s:
+            return True
+        return False
+
+    def is_time(s: str) -> bool:
+        if not s or ":" not in s:
+            return False
+        parts = s.split(":")
+        if len(parts) != 2:
+            return False
+        try:
+            h, m = int(parts[0]), int(parts[1])
+            return 0 <= h <= 23 and 0 <= m <= 59
+        except ValueError:
+            return False
+
+    def parse_date_with_tz(date_str: str) -> int | None:
+        parsed = dateparser.parse(date_str)
+        if parsed:
+            localized = parsed.replace(tzinfo=tz)
+            return int(localized.timestamp())
+        return None
+
     i = 0
     while i < len(args):
         arg = args[i]
 
         if arg == "-link":
-            if i + 1 < len(args) and (
-                args[i + 1].startswith("http://") or args[i + 1].startswith("https://")
-            ):
+            if i + 1 < len(args) and not args[i + 1].startswith("-"):
                 link = args[i + 1]
                 i += 2
             else:
                 clear_link = True
                 i += 1
         elif arg == "-date":
-            if i + 1 < len(args):
-                parsed = dateparser.parse(args[i + 1])
-                if parsed:
-                    due_date_ts = int(parsed.timestamp())
+            if i + 1 < len(args) and not args[i + 1].startswith("-"):
+                due_date_ts = parse_date_with_tz(args[i + 1])
+                if due_date_ts is not None:
                     i += 2
+                    if i < len(args) and is_time(args[i]):
+                        time_parts = args[i].split(":")
+                        due_date_ts += (
+                            int(time_parts[0]) * 3600 + int(time_parts[1]) * 60
+                        )
+                        i += 1
                 else:
                     clear_date = True
                     i += 1
             else:
                 clear_date = True
                 i += 1
-        elif not link and (arg.startswith("http://") or arg.startswith("https://")):
+        elif not link and is_url(arg):
             link = arg
             i += 1
         elif due_date_ts is None:
-            parsed = dateparser.parse(arg)
-            if parsed:
-                due_date_ts = int(parsed.timestamp())
+            due_date_ts = parse_date_with_tz(arg)
+            if due_date_ts is not None:
                 i += 1
+                if i < len(args) and is_time(args[i]):
+                    time_parts = args[i].split(":")
+                    due_date_ts += int(time_parts[0]) * 3600 + int(time_parts[1]) * 60
+                    i += 1
             else:
                 i += 1
                 if text is None:
@@ -114,7 +156,9 @@ def parse_args(
     return text, link, due_date_ts, clear_link, clear_date
 
 
-def format_bounty(b, show_id: bool = True, slice_length: int = 0) -> str:
+def format_bounty(
+    b, show_id: bool = True, slice_length: int = 0, timezone_str: str = "UTC"
+) -> str:
     parts = []
     if show_id:
         parts.append(f"[#{b.id}]")
@@ -126,17 +170,64 @@ def format_bounty(b, show_id: bool = True, slice_length: int = 0) -> str:
     if b.link:
         parts.append(f"🔗 {b.link}")
     if b.due_date_ts:
-        due_str = time.strftime("%d %b %Y", time.localtime(b.due_date_ts))
-        days_left = (b.due_date_ts - int(time.time())) // 86400
-        if days_left < 0:
+        try:
+            tz = ZoneInfo(timezone_str)
+        except (KeyError, ZoneInfoNotFoundError):
+            tz = ZoneInfo("UTC")
+
+        now_utc = int(time.time())
+        dt_now = datetime.now(tz)
+        dt_due = datetime.fromtimestamp(b.due_date_ts, tz=tz)
+
+        seconds_left = int((dt_due - dt_now).total_seconds())
+        hours_left = seconds_left // 3600
+        days_left = seconds_left // 86400
+
+        due_str = dt_due.strftime("%d %b %Y %H:%M")
+
+        if seconds_left < 0:
             parts.append(f"⏰ {due_str} (OVERDUE)")
-        elif days_left == 0:
-            parts.append(f"⏰ Today (OVERDUE)")
+        elif hours_left < 48:
+            if hours_left < 1:
+                minutes_left = seconds_left // 60
+                parts.append(f"⏰ {due_str} ({minutes_left}m)")
+            else:
+                parts.append(f"⏰ {due_str} ({hours_left}h)")
         else:
             parts.append(f"⏰ {due_str} ({days_left}d)")
     return " | ".join(parts)
 
 
+async def cmd_delete_message(update: Update, ctx: ContextTypes.DEFAULT_TYPE) -> None:
+    query = update.callback_query
+    if not query:
+        return
+
+    data = query.data
+    if not data.startswith("del_msg:"):
+        return
+
+    parts = data.split(":")
+    if len(parts) != 2:
+        return
+
+    try:
+        expected_user_id = int(parts[1])
+    except ValueError:
+        return
+
+    user_id = get_user_id(update)
+    if user_id != expected_user_id:
+        await query.answer("You can't delete this message", show_alert=True)
+        return
+
+    try:
+        await query.message.delete()
+        await query.answer("Deleted")
+    except Exception as e:
+        await query.answer(f"Could not delete: {e}", show_alert=True)
+
+
 def is_group(update: Update) -> bool:
     return update.effective_chat.type != "private"
 
@@ -162,6 +253,8 @@ def get_room_id(update: Update) -> int:
 
 async def cmd_bounty(update: Update, ctx: ContextTypes.DEFAULT_TYPE) -> None:
     room_id = get_room_id(update)
+    user_id = get_user_id(update)
+    timezone_str = BOUNTY_SERVICE.get_timezone(room_id)
     args = extract_args(update.message.text)
 
     show_all = "all" in args
@@ -212,9 +305,17 @@ async def cmd_bounty(update: Update, ctx: ContextTypes.DEFAULT_TYPE) -> None:
         slice_length = 0
 
     for b in displayed_bounties:
-        lines.append(format_bounty(b, show_id=True, slice_length=slice_length))
+        lines.append(
+            format_bounty(
+                b, show_id=True, slice_length=slice_length, timezone_str=timezone_str
+            )
+        )
 
-    await update.message.reply_text("\n".join(lines), disable_web_page_preview=True)
+    keyboard = [[InlineKeyboardButton("🗑️ Delete", callback_data=f"del_msg:{user_id}")]]
+    reply_markup = InlineKeyboardMarkup(keyboard)
+    await update.message.reply_text(
+        "\n".join(lines), disable_web_page_preview=True, reply_markup=reply_markup
+    )
 
 
 async def cmd_my(update: Update, ctx: ContextTypes.DEFAULT_TYPE) -> None:
@@ -228,6 +329,8 @@ async def cmd_my(update: Update, ctx: ContextTypes.DEFAULT_TYPE) -> None:
         room_id = get_room_id(update)
         bounties = BOUNTY_SERVICE.list_bounties(room_id)
 
+    timezone_str = BOUNTY_SERVICE.get_timezone(room_id)
+
     if not bounties:
         msg = (
             "You are not tracking any bounties."
@@ -237,7 +340,9 @@ async def cmd_my(update: Update, ctx: ContextTypes.DEFAULT_TYPE) -> None:
         await update.message.reply_text(msg)
         return
 
-    lines = [format_bounty(b, show_id=True) for b in bounties]
+    lines = [
+        format_bounty(b, show_id=True, timezone_str=timezone_str) for b in bounties
+    ]
     await update.message.reply_text("\n".join(lines), disable_web_page_preview=True)
 
 
@@ -250,14 +355,18 @@ async def cmd_add(update: Update, ctx: ContextTypes.DEFAULT_TYPE) -> None:
         )
         return
 
-    text, link, due_date_ts, _, _ = parse_args(args)
+    user_id = get_user_id(update)
+    room_id = get_room_id(update)
+    timezone_str = BOUNTY_SERVICE.get_timezone(room_id)
+
+    effective_user = update.effective_user
+    username = effective_user.username or effective_user.first_name or None
+
+    text, link, due_date_ts, _, _ = parse_args(args, timezone_str)
     if not text and not link:
         await update.message.reply_text("A bounty needs at least text or a link.")
         return
 
-    user_id = get_user_id(update)
-    room_id = get_room_id(update)
-
     try:
         bounty = BOUNTY_SERVICE.add_bounty(
             room_id=room_id,
@@ -265,6 +374,7 @@ async def cmd_add(update: Update, ctx: ContextTypes.DEFAULT_TYPE) -> None:
             text=text,
             link=link,
             due_date_ts=due_date_ts,
+            created_by_username=username,
         )
     except PermissionError as e:
         await update.message.reply_text(f"⛔ {e}")
@@ -304,7 +414,16 @@ async def cmd_update(update: Update, ctx: ContextTypes.DEFAULT_TYPE) -> None:
         await update.message.reply_text("Invalid bounty ID.")
         return
 
-    text, link, due_date_ts, clear_link, clear_date = parse_args(args[1:])
+    user_id = get_user_id(update)
+    room_id = get_room_id(update)
+    timezone_str = BOUNTY_SERVICE.get_timezone(room_id)
+
+    try:
+        tz = ZoneInfo(timezone_str)
+    except (KeyError, ZoneInfoNotFoundError):
+        tz = ZoneInfo("UTC")
+
+    text, link, due_date_ts, clear_link, clear_date = parse_args(args[1:], timezone_str)
     if (
         not text
         and not link
@@ -315,8 +434,10 @@ async def cmd_update(update: Update, ctx: ContextTypes.DEFAULT_TYPE) -> None:
         await update.message.reply_text("Nothing to update.")
         return
 
-    user_id = get_user_id(update)
-    room_id = get_room_id(update)
+    old_bounty = BOUNTY_SERVICE.get_bounty(room_id, bounty_id)
+    if not old_bounty:
+        await update.message.reply_text("Bounty not found.")
+        return
 
     try:
         success = BOUNTY_SERVICE.update_bounty(
@@ -337,7 +458,38 @@ async def cmd_update(update: Update, ctx: ContextTypes.DEFAULT_TYPE) -> None:
         return
 
     if success:
-        await update.message.reply_text(f"✅ Bounty #{bounty_id} updated.")
+        changes = []
+        if text is not None:
+            old_text = old_bounty.text or "(none)"
+            changes.append(f"Text: {old_text} → {text}")
+        if link is not None:
+            old_link = old_bounty.link or "(none)"
+            changes.append(f"Link: {old_link} → {link}")
+        if due_date_ts is not None:
+            old_date = (
+                format_due_date(old_bounty.due_date_ts, timezone_str)
+                if old_bounty.due_date_ts
+                else "(none)"
+            )
+            new_date = format_due_date(due_date_ts, timezone_str)
+            changes.append(f"Date: {old_date} → {new_date}")
+        if clear_link:
+            old_link = old_bounty.link or "(none)"
+            changes.append(f"Link: {old_link} → (cleared)")
+        if clear_date:
+            old_date = (
+                format_due_date(old_bounty.due_date_ts, timezone_str)
+                if old_bounty.due_date_ts
+                else "(none)"
+            )
+            changes.append(f"Date: {old_date} → (cleared)")
+
+        if changes:
+            await update.message.reply_text(
+                f"✅ Bounty #{bounty_id} updated:\n" + "\n".join(changes)
+            )
+        else:
+            await update.message.reply_text(f"✅ Bounty #{bounty_id} updated.")
     else:
         await update.message.reply_text("Bounty not found.")
 
@@ -436,7 +588,29 @@ async def cmd_untrack(update: Update, ctx: ContextTypes.DEFAULT_TYPE) -> None:
 
 
 async def cmd_start(update: Update, ctx: ContextTypes.DEFAULT_TYPE) -> None:
+    user_id = get_user_id(update)
+    room_id = get_room_id(update)
+
     if is_group(update):
+        try:
+            chat_member = await ctx.bot.get_chat_member(room_id, user_id)
+            if chat_member.status == "creator" and not BOUNTY_SERVICE.is_admin(
+                room_id, user_id
+            ):
+                BOUNTY_SERVICE.add_admin(room_id, user_id, user_id)
+                await update.message.reply_text(
+                    "👻 JIGAIDO is watching.\n\n"
+                    "This group's bounty list is now active.\n"
+                    "You are now an admin (group creator).\n"
+                    "/bounty — list bounties\n"
+                    "/add — create a bounty\n"
+                    "/track — track a bounty\n"
+                    "/my — your tracked bounties"
+                )
+                return
+        except Exception:
+            pass
+
         await update.message.reply_text(
             "👻 JIGAIDO is watching.\n\n"
             "This group's bounty list is now active.\n"
@@ -446,6 +620,9 @@ async def cmd_start(update: Update, ctx: ContextTypes.DEFAULT_TYPE) -> None:
             "/my — your tracked bounties"
         )
     else:
+        if not BOUNTY_SERVICE.is_admin(room_id, user_id):
+            BOUNTY_SERVICE.add_admin(room_id, user_id, user_id)
+
         await update.message.reply_text(
             "👻 JIGAIDO activated.\n\n"
             "Personal bounty list ready.\n"
@@ -474,7 +651,12 @@ async def cmd_show(update: Update, ctx: ContextTypes.DEFAULT_TYPE) -> None:
         await update.message.reply_text("Bounty not found.")
         return
 
-    timezone = BOUNTY_SERVICE.get_timezone(room_id)
+    timezone_str = BOUNTY_SERVICE.get_timezone(room_id)
+
+    try:
+        tz = ZoneInfo(timezone_str)
+    except (KeyError, ZoneInfoNotFoundError):
+        tz = ZoneInfo("UTC")
 
     lines = []
 
@@ -485,16 +667,22 @@ async def cmd_show(update: Update, ctx: ContextTypes.DEFAULT_TYPE) -> None:
         lines.append(f"🔗 {bounty.link}")
 
     if bounty.due_date_ts:
-        due_str = time.strftime("%d %B %Y %H:%M", time.localtime(bounty.due_date_ts))
-        lines.append(f"📅 {due_str} ({timezone})")
+        dt_due = datetime.fromtimestamp(bounty.due_date_ts, tz=tz)
+        due_str = dt_due.strftime("%d %B %Y %H:%M")
+        lines.append(f"📅 {due_str} ({timezone_str})")
 
-    username = bounty.created_by_username or f"user#{bounty.created_by_user_id}"
-    lines.append(f"👤 @{username}")
+    if bounty.created_by_username:
+        lines.append(
+            f'👤 <a href="tg://user?id={bounty.created_by_user_id}">{bounty.created_by_username}</a>'
+        )
 
-    created_str = time.strftime("%Y-%m-%d %H:%M", time.localtime(bounty.created_at))
+    dt_created = datetime.fromtimestamp(bounty.created_at, tz=tz)
+    created_str = dt_created.strftime("%Y-%m-%d %H:%M")
     lines.append(f"📌 Created: {created_str}")
 
-    await update.message.reply_text("\n".join(lines), disable_web_page_preview=True)
+    await update.message.reply_text(
+        "\n".join(lines), disable_web_page_preview=True, parse_mode=ParseMode.HTML
+    )
 
 
 async def cmd_timezone(update: Update, ctx: ContextTypes.DEFAULT_TYPE) -> None:
@@ -583,16 +771,20 @@ async def cmd_recover(update: Update, ctx: ContextTypes.DEFAULT_TYPE) -> None:
     await update.message.reply_text("\n".join(response_lines))
 
 
-def _find_user_id_by_username(room_id: int, username: str) -> int | None:
-    """Find user_id by username from bounty creators in the room."""
-    bounties = BOUNTY_SERVICE.list_bounties(room_id)
-    for bounty in bounties:
-        if (
-            bounty.created_by_username
-            and bounty.created_by_username.lower() == username.lower()
-        ):
-            return bounty.created_by_user_id
-    return None
+async def _find_user_id_by_username(
+    ctx: ContextTypes.DEFAULT_TYPE, username: str
+) -> int | None:
+    """Find user_id by username using Telegram API."""
+    import logging
+
+    log = logging.getLogger(__name__)
+    try:
+        chat = await ctx.bot.get_chat(f"@{username}")
+        log.info(f"Found user {username}: {chat.id}")
+        return chat.id
+    except Exception as e:
+        log.error(f"Failed to find user @{username}: {e}")
+        return None
 
 
 def _find_username_by_user_id(room_id: int, user_id: int) -> str | None:
@@ -615,11 +807,16 @@ async def cmd_admin(update: Update, ctx: ContextTypes.DEFAULT_TYPE) -> None:
         for admin_id in admins:
             username = _find_username_by_user_id(get_room_id(update), admin_id)
             if username:
-                admin_mentions.append(f"@{username}")
+                admin_mentions.append(
+                    f'<a href="tg://user?id={admin_id}">@{username}</a>'
+                )
             else:
-                admin_mentions.append(f"user#{admin_id}")
+                admin_mentions.append(
+                    f'<a href="tg://user?id={admin_id}">{admin_id}</a>'
+                )
         await update.message.reply_text(
-            f"Room Admins:\n" + "\n".join(f"- {m}" for m in admin_mentions)
+            f"Room Admins:\n" + "\n".join(f"- {m}" for m in admin_mentions),
+            parse_mode=ParseMode.HTML,
         )
         return
 
@@ -652,7 +849,7 @@ async def cmd_admin(update: Update, ctx: ContextTypes.DEFAULT_TYPE) -> None:
         await update.message.reply_text("⛔ Only admins can perform this action.")
         return
 
-    target_user_id = _find_user_id_by_username(room_id, username)
+    target_user_id = await _find_user_id_by_username(ctx, username)
 
     if target_user_id is None:
         await update.message.reply_text(f"⛔ User @{username} not found.")
@@ -670,27 +867,43 @@ async def cmd_admin(update: Update, ctx: ContextTypes.DEFAULT_TYPE) -> None:
 
 
 async def cmd_help(update: Update, ctx: ContextTypes.DEFAULT_TYPE) -> None:
-    await update.message.reply_text(
-        "👻 JIGAIDO Commands:\n\n"
-        "/bounty — list all bounties\n"
-        "/my — bounties you're tracking\n"
-        "/add <text> [link] [due] — add bounty (admin only)\n"
-        "/update <id> [text> [link] [due] — update bounty (admin only)\n"
-        "/edit <id> [text> [link] [due] — edit bounty (same as update)\n"
-        "  /edit <id> -link [<url>]  — clear or set link\n"
-        "  /edit <id> -date [<date>] — clear or set date\n"
-        "/delete <id> [<id>...] — delete bounty (admin only)\n"
-        "/track <id> — track a bounty (groups only)\n"
-        "/untrack <id> — stop tracking (groups only)\n"
-        "/show <id> — show bounty details\n"
-        "/admin — list admins\n"
-        "/admin add @username — add admin (admin only)\n"
-        "/admin remove @username — remove admin (admin only)\n"
-        "/timezone — get room timezone\n"
-        "/timezone <tz> — set room timezone (admin only)\n"
-        "/recover — list recoverable bounties (admin only)\n"
-        "/recover <id> [<id>...] — recover bounty (admin only)\n"
-        "/start — re-initialize\n"
-        "/help — this message",
-        disable_web_page_preview=True,
-    )
+    user_id = get_user_id(update)
+    room_id = get_room_id(update)
+    is_admin = BOUNTY_SERVICE.is_admin(room_id, user_id)
+
+    if is_admin:
+        lines = [
+            "👻 JIGAIDO Commands (Admin):\n",
+            "📋 Bounty Management:",
+            "/bounty — list bounties",
+            "/add — add bounty",
+            "/edit — edit bounty",
+            "/delete — delete bounty",
+            "/recover — recover deleted bounties",
+            "",
+            "🔗 Tracking:",
+            "/track — track bounty",
+            "/untrack — stop tracking",
+            "/my — your tracked bounties",
+            "/show — show bounty details",
+            "",
+            "⚙️ Room Management:",
+            "/admin — manage admins",
+            "/timezone — get/set timezone",
+            "",
+            "/start — re-initialize",
+            "/help — show this message",
+        ]
+    else:
+        lines = [
+            "👻 JIGAIDO Commands:\n",
+            "/bounty — list bounties",
+            "/track — track bounty",
+            "/untrack — stop tracking",
+            "/my — your tracked bounties",
+            "/show — show bounty details",
+            "/start — re-initialize",
+            "/help — show this message",
+        ]
+
+    await update.message.reply_text("\n".join(lines), disable_web_page_preview=True)

config.py

@@ -13,7 +13,21 @@ class Config:
 
     def __init__(self):
         self.data_dir: Path = self._resolve_data_dir()
-        self.bot_token: Optional[str] = os.environ.get("JIGAIDO_BOT_TOKEN")
+        self.bot_token: Optional[str] = self._resolve_bot_token()
+
+    def _resolve_bot_token(self) -> Optional[str]:
+        env_token = os.environ.get("JIGAIDO_BOT_TOKEN")
+        if env_token:
+            return env_token
+
+        config_file = Path("~/.jigaido/config.json").expanduser()
+        if config_file.exists():
+            with open(config_file) as f:
+                config_data = json.load(f)
+                if "JIGAIDO_BOT_TOKEN" in config_data:
+                    return config_data["JIGAIDO_BOT_TOKEN"]
+
+        return None
 
     def _resolve_data_dir(self) -> Path:
         env_dir = os.environ.get("JIGAIDO_DATA_DIR")
@@ -35,3 +49,6 @@ class Config:
 
 
 config = Config()
+
+
+config = Config()

core/services.py

@@ -35,18 +35,23 @@ class BountyService:
     def add_admin(
         self, room_id: int, admin_user_id: int, requesting_user_id: int
     ) -> None:
-        """Add an admin to a room. Requires admin permission."""
-        if not self.is_admin(room_id, requesting_user_id):
-            raise PermissionError("Only admins can add admins.")
-
+        """Add an admin to a room. Requires admin permission, or self-promotion if first admin."""
         room_data = self._storage.load(room_id)
-        if room_data is None:
+
+        has_no_admins = room_data is None or not room_data.admin_user_ids
+        is_self_promotion = requesting_user_id == admin_user_id
+
+        if not self.is_admin(room_id, requesting_user_id):
+            if not (has_no_admins and is_self_promotion):
+                raise PermissionError("Only admins can add admins.")
+
+        if room_data is None or room_data.admin_user_ids is None:
             room_data = RoomData(
                 room_id=room_id, bounties=[], next_id=1, admin_user_ids=[]
             )
 
         if admin_user_id not in (room_data.admin_user_ids or []):
-            (room_data.admin_user_ids or []).append(admin_user_id)
+            room_data.admin_user_ids.append(admin_user_id)
             self._storage.save(room_data)
 
     def remove_admin(
@@ -119,6 +124,7 @@ class BountyService:
         text: Optional[str] = None,
         link: Optional[str] = None,
         due_date_ts: Optional[int] = None,
+        created_by_username: Optional[str] = None,
     ) -> Bounty:
         """Add a new bounty to the room. Requires admin permission."""
         if not self.is_admin(room_id, user_id):
@@ -136,6 +142,7 @@ class BountyService:
         bounty = Bounty(
             id=room_data.next_id,
             created_by_user_id=user_id,
+            created_by_username=created_by_username,
             text=text,
             link=link,
             due_date_ts=due_date_ts,

tests/test_config.py

@@ -47,10 +47,27 @@ class TestConfigDataDir:
             assert cfg.bot_token == "test_token_123"
 
     def test_bot_token_none_when_not_set(self):
-        """Test that bot_token is None when JIGAIDO_BOT_TOKEN not set."""
+        """Test that bot_token is None when JIGAIDO_BOT_TOKEN not set and no config file."""
         with patch.dict(os.environ, {}, clear=True):
-            cfg = Config()
-            assert cfg.bot_token is None
+            with patch("pathlib.Path.exists", return_value=False):
+                cfg = Config()
+                assert cfg.bot_token is None
+
+    def test_bot_token_from_config_file(self):
+        """Test that bot_token is read from config file when env var not set."""
+        config_dir = Path.home() / ".jigaido"
+        config_file = config_dir / "config.json"
+        with patch.dict(os.environ, {}, clear=True):
+            with patch("pathlib.Path.expanduser", return_value=config_file):
+                with patch("pathlib.Path.exists", return_value=True):
+                    with patch("builtins.open", create=True) as mock_open:
+                        mock_open.return_value.__enter__ = lambda s: s
+                        mock_open.return_value.__exit__ = lambda *a: None
+                        mock_open.return_value.read = lambda: (
+                            '{"JIGAIDO_BOT_TOKEN": "config_token"}'
+                        )
+                        cfg = Config()
+                        assert cfg.bot_token == "config_token"
 
 
 class TestConfigEnsureDataDir: