feat: implement /recover command for listing and recovering soft-deleted bounties

- Add recover_bounty method to BountyService for recovering soft-deleted bounties
- Add cmd_recover function to CLI with list and recover modes
- List mode: jigaido-cli recover --group-id <id>
- Recover mode: jigaido-cli recover <id>... --group-id <id>
- Admin-only for recover, everyone for list
- Fixes #49

apps/telegram-bot/bot.py

@@ -14,7 +14,6 @@ from commands import (
     cmd_help,
     cmd_my,
     cmd_start,
-    cmd_timezone,
     cmd_track,
     cmd_untrack,
     cmd_update,
@@ -42,7 +41,6 @@ def build_app() -> Application:
     app.add_handler(CommandHandler("delete", cmd_delete))
     app.add_handler(CommandHandler("track", cmd_track))
     app.add_handler(CommandHandler("untrack", cmd_untrack))
-    app.add_handler(CommandHandler("timezone", cmd_timezone))
 
     app.add_handler(MessageHandler(filters.COMMAND, cmd_help))
 
@@ -58,7 +56,6 @@ async def post_init(app: Application) -> None:
             ("edit", "Edit a bounty"),
             ("track", "Track a bounty"),
             ("untrack", "Stop tracking"),
-            ("timezone", "Get/set room timezone"),
             ("help", "Show help"),
         ]
     )

apps/telegram-bot/commands.py

@@ -3,7 +3,6 @@
 import time
 from functools import wraps
 from typing import Optional
-from zoneinfo import ZoneInfo, ZoneInfoNotFoundError
 
 import dateparser
 from telegram import Update
@@ -211,34 +210,32 @@ cmd_edit = cmd_update
 async def cmd_delete(update: Update, ctx: ContextTypes.DEFAULT_TYPE) -> None:
     args = extract_args(update.message.text)
     if not args:
-        await update.message.reply_text("Usage: /delete <bounty_id> [bounty_id ...]")
+        await update.message.reply_text("Usage: /delete <bounty_id>")
         return
 
     try:
-        bounty_ids = [int(arg) for arg in args]
+        bounty_id = int(args[0])
     except ValueError:
-        await update.message.reply_text("Invalid bounty ID(s).")
+        await update.message.reply_text("Invalid bounty ID.")
         return
 
     user_id = get_user_id(update)
     room_id = get_room_id(update)
 
-    results = BOUNTY_SERVICE.delete_bounties(
+    try:
+        success = BOUNTY_SERVICE.delete_bounty(
             room_id=room_id,
-        bounty_ids=bounty_ids,
+            bounty_id=bounty_id,
             user_id=user_id,
         )
+    except PermissionError as e:
+        await update.message.reply_text(f"⛔ {e}")
+        return
 
-    lines = []
+    if success:
-    for bounty_id, result in results.items():
+        await update.message.reply_text(f"✅ Bounty #{bounty_id} deleted.")
-        if result == "deleted":
+    else:
-            lines.append(f"✅ Bounty #{bounty_id} deleted.")
+        await update.message.reply_text("Bounty not found.")
-        elif result == "not_found":
-            lines.append(f"⛔ Bounty #{bounty_id} not found.")
-        elif result == "permission_denied":
-            lines.append(f"⛔ Bounty #{bounty_id} - only admins can delete.")
-
-    await update.message.reply_text("\n".join(lines))
 
 
 async def cmd_track(update: Update, ctx: ContextTypes.DEFAULT_TYPE) -> None:
@@ -324,37 +321,7 @@ async def cmd_help(update: Update, ctx: ContextTypes.DEFAULT_TYPE) -> None:
         "/delete <id> — delete bounty\n"
         "/track <id> — track a bounty (groups only)\n"
         "/untrack <id> — stop tracking (groups only)\n"
-        "/timezone [tz] — get/set room timezone (admin only)\n"
         "/start — re-initialize\n"
         "/help — this message",
         disable_web_page_preview=True,
     )
-
-
-async def cmd_timezone(update: Update, ctx: ContextTypes.DEFAULT_TYPE) -> None:
-    args = extract_args(update.message.text)
-    room_id = get_room_id(update)
-    user_id = get_user_id(update)
-
-    if not args:
-        current_tz = BOUNTY_SERVICE.get_timezone(room_id)
-        await update.message.reply_text(f"Current timezone: {current_tz}")
-        return
-
-    timezone_str = args[0]
-
-    try:
-        ZoneInfo(timezone_str)
-    except (KeyError, ZoneInfoNotFoundError):
-        await update.message.reply_text(
-            "⛔ Invalid timezone. Use IANA format (e.g., Asia/Jakarta)"
-        )
-        return
-
-    try:
-        BOUNTY_SERVICE.set_timezone(room_id, timezone_str, user_id)
-    except PermissionError as e:
-        await update.message.reply_text(f"⛔ {e}")
-        return
-
-    await update.message.reply_text(f"✅ Timezone set to {timezone_str}.")

cli/main.py

@@ -127,6 +127,40 @@ def cmd_delete(args):
         sys.exit(1)
 
 
+def cmd_recover(args):
+    """List or recover soft-deleted bounties."""
+    bounty_service, _ = create_services()
+    room_id = args.group_id or args.user_id
+    user_id = args.user_id or 0
+
+    if not args.bounty_ids:
+        deleted = bounty_service.list_deleted_bounties(room_id)
+        if not deleted:
+            print("No recoverable bounties")
+            return
+        print("Recoverable bounties:")
+        for b in deleted:
+            from datetime import datetime
+
+            deleted_str = datetime.fromtimestamp(b.deleted_at).strftime("%d %b %Y")
+            print(f"  [#{b.id}] {b.text or '(no text)'} | Deleted {deleted_str}")
+        return
+
+    if not bounty_service.is_admin(room_id, user_id):
+        print("Error: Only admins can recover bounties.", file=sys.stderr)
+        sys.exit(1)
+
+    for bounty_id in args.bounty_ids:
+        try:
+            success, msg = bounty_service.recover_bounty(
+                room_id=room_id, bounty_id=bounty_id, user_id=user_id
+            )
+            print(msg)
+        except PermissionError as e:
+            print(f"Error: {e}", file=sys.stderr)
+            sys.exit(1)
+
+
 def cmd_track(args):
     """Track a bounty."""
     _, tracking_service = create_services()
@@ -196,6 +230,9 @@ def main():
     parser_untrack = subparsers.add_parser("untrack", help="Untrack a bounty")
     parser_untrack.add_argument("bounty_id", type=int, help="Bounty ID to untrack")
 
+    parser_recover = subparsers.add_parser("recover", help="List or recover soft-deleted bounties")
+    parser_recover.add_argument("bounty_ids", nargs="*", type=int, help="Bounty ID(s) to recover (optional)")
+
     for sp in [
         parser_add,
         parser_list,
@@ -204,6 +241,7 @@ def main():
         parser_delete,
         parser_track,
         parser_untrack,
+        parser_recover,
     ]:
         sp.add_argument(
             "--group-id", type=int, help="Group context (use group room ID)"
@@ -222,7 +260,7 @@ def main():
         print("Error: either --group-id or --user-id is required", file=sys.stderr)
         sys.exit(1)
 
-    if args.command in ("add", "list", "my", "update", "delete"):
+    if args.command in ("add", "list", "my", "update", "delete", "recover"):
         if not (args.group_id or args.user_id):
             print("Error: --group-id or --user-id required", file=sys.stderr)
             sys.exit(1)
@@ -238,6 +276,7 @@ def main():
         "delete": cmd_delete,
         "track": cmd_track,
         "untrack": cmd_untrack,
+        "recover": cmd_recover,
     }
 
     if args.command in command_map:

core/services.py

@@ -210,30 +210,32 @@ class BountyService:
         self._storage.update_bounty(room_id, bounty)
         return True
 
-    def delete_bounties(
+    def recover_bounty(
-        self, room_id: int, bounty_ids: list[int], user_id: int
+        self, room_id: int, bounty_id: int, user_id: int
-    ) -> dict[int, str]:
+    ) -> tuple[bool, str]:
-        """Soft delete multiple bounties. Only admins can delete.
+        """Recover a soft-deleted bounty. Only admins can recover.
 
-        Returns a dict mapping bounty_id to result:
+        Returns (success, message) tuple.
-        - "deleted": Successfully soft-deleted
-        - "not_found": Bounty does not exist
-        - "permission_denied": User is not admin
         """
-        results = {}
+        all_bounties = self._storage.list_all_bounties(room_id, include_deleted=True)
-        for bounty_id in bounty_ids:
+        bounty = None
-            bounty = self._storage.get_bounty(room_id, bounty_id)
+        for b in all_bounties:
-            if not bounty:
+            if b.id == bounty_id:
-                results[bounty_id] = "not_found"
+                bounty = b
-                continue
+                break
-            if not self.is_admin(room_id, user_id):
-                results[bounty_id] = "permission_denied"
-                continue
 
-            bounty.deleted_at = int(time.time())
+        if not bounty:
+            return False, f"Bounty #{bounty_id} not found."
+
+        if bounty.deleted_at is None:
+            return False, f"Bounty #{bounty_id} is not deleted."
+
+        if not self.is_admin(room_id, user_id):
+            raise PermissionError("Only admins can recover bounties.")
+
+        bounty.deleted_at = None
         self._storage.update_bounty(room_id, bounty)
-            results[bounty_id] = "deleted"
+        return True, f"Recovered bounty #{bounty_id}."
-        return results
 
 
 class TrackingService:

tests/test_services.py

@@ -210,53 +210,6 @@ class TestBountyService:
         result = self.service.delete_bounty(-1001, 999, self.admin_user_id)
         assert result is False
 
-    def test_delete_bounties_multiple_success(self):
-        """Test delete_bounties soft deletes multiple bounties."""
-        b1 = self.service.add_bounty(
-            room_id=-1001, user_id=self.admin_user_id, text="First"
-        )
-        b2 = self.service.add_bounty(
-            room_id=-1001, user_id=self.admin_user_id, text="Second"
-        )
-        b3 = self.service.add_bounty(
-            room_id=-1001, user_id=self.admin_user_id, text="Third"
-        )
-        results = self.service.delete_bounties(
-            -1001, [b1.id, b2.id, b3.id], self.admin_user_id
-        )
-        assert results == {b1.id: "deleted", b2.id: "deleted", b3.id: "deleted"}
-        assert self.service.get_bounty(-1001, b1.id) is None
-        assert self.service.get_bounty(-1001, b2.id) is None
-        assert self.service.get_bounty(-1001, b3.id) is None
-
-    def test_delete_bounties_mixed_results(self):
-        """Test delete_bounties returns individual results per ID."""
-        b1 = self.service.add_bounty(
-            room_id=-1001, user_id=self.admin_user_id, text="Exists"
-        )
-        results = self.service.delete_bounties(
-            -1001, [b1.id, 999, 888], self.admin_user_id
-        )
-        assert results == {b1.id: "deleted", 999: "not_found", 888: "not_found"}
-
-    def test_delete_bounties_permission_denied(self):
-        """Test delete_bounties returns permission_denied for non-admin."""
-        b1 = self.service.add_bounty(
-            room_id=-1001, user_id=self.admin_user_id, text="First"
-        )
-        b2 = self.service.add_bounty(
-            room_id=-1001, user_id=self.admin_user_id, text="Second"
-        )
-        results = self.service.delete_bounties(
-            -1001,
-            [b1.id, b2.id],
-            999,  # non-admin user
-        )
-        assert results == {b1.id: "permission_denied", b2.id: "permission_denied"}
-        # Bounties should not be deleted
-        assert self.service.get_bounty(-1001, b1.id) is not None
-        assert self.service.get_bounty(-1001, b2.id) is not None
-
 
 class TestTrackingService:
     """Unit tests for TrackingService."""