Update bot/handlers.py

bot/handlers.py

@@ -1,7 +1,4 @@
 # PATH: bot/handlers.py
-# NOTE: Fixes callback "not allowed" bug by using q.from_user.id for inline buttons.
-# Also includes basic auth flow handlers for AUTH_JSON / AUTH_CI / BACK / CANCEL.
-
 from __future__ import annotations
 
 import asyncio
@@ -14,25 +11,13 @@ from hydrogram import Client, filters
 from hydrogram.types import CallbackQuery, Message
 
 from bot.config import Auth, Workers
-from bot.core.progress import SpeedETA, human_bytes, human_eta
-from bot.core.settings import Settings
-from bot.core.uptime import uptime_text
 from bot.integrations.auth import allow_user, disallow_user, get_stats, is_allowed
-from bot.integrations.cf_worker1 import profile_add, profile_check_auth, profile_delete
-from bot.integrations.cf_worker2 import (
-    get_default_profile,
-    list_profiles,
-    record_upload,
-    set_default_profile,
-)
+from bot.integrations.cf_worker1 import profile_check_auth, profile_delete
+from bot.integrations.cf_worker2 import get_default_profile, list_profiles, record_upload, set_default_profile
 from bot.telegram.files import cleanup_file
 from bot.telegram.media import download_to_temp
 from bot.telegram.replies import safe_edit, safe_reply
 from bot.ui.callbacks import (
-    AUTH_CI,
-    AUTH_JSON,
-    BACK,
-    CANCEL,
     MENU_AUTH,
     MENU_HELP,
     MENU_PROFILES,
@@ -41,25 +26,31 @@ from bot.ui.callbacks import (
     UP_EDIT,
     UP_GO,
     UP_PRIV,
+    NAME_ORIGINAL,
+    NAME_CAPTION,
+    NAME_CUSTOM,
+    BACK,
+    UP_CANCEL,
 )
 from bot.ui.keyboards import auth_menu_keyboard, main_menu_keyboard, profiles_keyboard, upload_confirm_keyboard
 from bot.ui.parse import parse_cb
 from bot.ui.texts import CANCELLED, HELP_TEXT, NEED_AUTH, NOT_ALLOWED, OWNER_ONLY
+from bot.core.progress import SpeedETA, human_bytes, human_eta
+from bot.core.settings import Settings
+from bot.core.uptime import uptime_text
 from bot.youtube.link_parser import parse_telegram_link
 
 
-# ============================================================
-# STATE
-# ============================================================
-
 @dataclass
 class PendingUpload:
     src_msg: Message
     downloader: Client
     file_name: str
+    caption: str
     title: str
     description: str
     privacy: str = "private"
+    title_mode: str = "caption"  # filename | caption | custom
     status_msg: Optional[Message] = None
     via_link: bool = False
 
@@ -71,38 +62,39 @@ class EditState:
     privacy: str
 
 
-# In-memory state
-_PENDING_UPLOAD: Dict[int, PendingUpload] = {}         # uid -> pending upload
-_AWAIT_EDIT: Dict[int, EditState] = {}                # uid -> editing title/desc
-_AWAIT_AUTH_MODE: Dict[int, str] = {}                 # uid -> "json" | "ci"
-_PENDING_DELETE: Dict[int, str] = {}                  # uid -> profile_id to delete
-_IN_PROGRESS: Dict[int, bool] = {}                    # uid -> upload is running
-_UPLOAD_TASK: Dict[int, asyncio.Task] = {}            # uid -> running upload task (so /cancel can stop it)
-_BATCH_TASK: Dict[int, asyncio.Task] = {}             # uid -> running batch task
-
+_PENDING_UPLOAD: Dict[int, PendingUpload] = {}
+_AWAIT_EDIT: Dict[int, EditState] = {}
+_AWAIT_AUTH_MODE: Dict[int, str] = {}
+_PENDING_DELETE: Dict[int, str] = {}
+_IN_PROGRESS: Dict[int, bool] = {}
+_UPLOAD_TASK: Dict[int, asyncio.Task] = {}
+_BATCH_TASK: Dict[int, asyncio.Task] = {}
 
-# ============================================================
-# HELPERS
-# ============================================================
 
 def _is_admin_or_owner(uid: int) -> bool:
-    return uid in set(Auth.OWNERS or []) or uid in set(Auth.ADMINS or [])
+    return uid in set(Auth.OWNERS) or uid in set(Auth.ADMINS)
 
 
-async def _ensure_allowed(reply_target: Message, uid: int | None = None) -> bool:
+async def _ensure_allowed_msg(m: Message) -> bool:
+    uid = m.from_user.id if m.from_user else 0
+    if _is_admin_or_owner(uid):
+        return True
+    ok = await is_allowed(uid)
+    if not ok:
+        await safe_reply(m, NOT_ALLOWED)
+    return ok
+
+
+async def _ensure_allowed_cb(uid: int, msg_to_edit: Message) -> bool:
     """
-    IMPORTANT: For callback queries, pass uid=q.from_user.id
-    because q.message.from_user is the BOT (not the clicker).
+    IMPORTANT FIX:
+    CallbackQuery should check q.from_user.id (clicker), NOT q.message.from_user (bot).
     """
-    if uid is None:
-        uid = int(getattr(getattr(reply_target, "from_user", None), "id", 0) or 0)
-
     if _is_admin_or_owner(uid):
         return True
-
     ok = await is_allowed(uid)
     if not ok:
-        await safe_reply(reply_target, NOT_ALLOWED)
+        await safe_edit(msg_to_edit, NOT_ALLOWED, reply_markup=main_menu_keyboard())
     return ok
 
 
@@ -114,128 +106,153 @@ def _media_and_filename(m: Message) -> Tuple[Optional[Any], str, int]:
     return None, "", 0
 
 
-def extract_title_description(src: Message, file_name: str) -> Tuple[str, str]:
-    # Prefer caption text
-    caption = (src.caption or "").strip()
-    if caption:
-        parts = caption.splitlines()
-        title = (parts[0] or "").strip()
-        desc = "\n".join([p.strip() for p in parts[1:]]).strip()
-        return title[: Settings.MAX_TITLE], desc[: Settings.MAX_DESC]
-
+def _build_title_desc_from_mode(src: Message, file_name: str, mode: str) -> Tuple[str, str]:
+    cap = (src.caption or "").strip()
     base = os.path.splitext(file_name)[0].strip()
-    title = (base or "Untitled")[: Settings.MAX_TITLE]
-    return title, ""
+    title_from_filename = (base or "Untitled")[: Settings.MAX_TITLE]
+
+    if cap:
+        parts = cap.splitlines()
+        title_from_caption = parts[0].strip()[: Settings.MAX_TITLE]
+        desc_from_caption = "\n".join([p.strip() for p in parts[1:]]).strip()[: Settings.MAX_DESC]
+    else:
+        title_from_caption = ""
+        desc_from_caption = ""
+
+    mode = (mode or "").lower().strip()
+
+    if mode == "filename":
+        # filename as title, keep full caption as description (useful)
+        return title_from_filename, cap[: Settings.MAX_DESC]
+    if mode == "caption":
+        if title_from_caption:
+            return title_from_caption, desc_from_caption
+        return title_from_filename, cap[: Settings.MAX_DESC]
+    # custom fallback
+    return title_from_filename, cap[: Settings.MAX_DESC]
 
 
 def _render_preview(p: PendingUpload, size: int) -> str:
+    cap = (p.caption or "").strip()
+    cap_short = (cap[:200] + "…") if len(cap) > 200 else (cap or "—")
+
+    mode = (p.title_mode or "caption").lower()
     return (
-        "📦 Ready to upload\n\n"
-        f"File: {p.file_name}\n"
-        f"Size: {human_bytes(size)}\n"
-        f"Privacy: {p.privacy}\n\n"
-        f"Title: {p.title}\n"
-        f"Description: {(p.description[:600] + '…') if len(p.description) > 600 else (p.description or '—')}"
+        "📦 *Ready to upload*\n\n"
+        f"*File:* `{p.file_name}`\n"
+        f"*Size:* `{human_bytes(size)}`\n"
+        f"*Privacy:* `{p.privacy}`\n"
+        f"*Title source:* `{mode}`\n\n"
+        f"*Caption (preview):*\n`{cap_short}`\n\n"
+        f"*Current Title:*\n`{p.title}`\n\n"
+        f"*Current Description:*\n"
+        f"`{(p.description[:600] + '…') if len(p.description) > 600 else (p.description or '—')}`"
     )
 
 
-async def _start_pending_upload(uid: int, src: Message, downloader: Client, via_link: bool = False) -> None:
+async def _start_pending_upload(
+    *,
+    uid: int,
+    request_msg: Message,           # where user asked (DM/group)
+    src: Message,                   # actual media message (maybe from another chat)
+    downloader: Client,
+    via_link: bool = False,
+    ui_msg: Optional[Message] = None,  # if provided, edit this message instead of replying
+) -> None:
     media, file_name, size = _media_and_filename(src)
     if not media:
+        if ui_msg:
+            await safe_edit(ui_msg, "❌ No video/document found in that message.", reply_markup=main_menu_keyboard())
+        else:
+            await safe_reply(request_msg, "❌ No video/document found in that message.")
         return
 
-    title, desc = extract_title_description(src, file_name)
+    caption = (src.caption or "").strip()
+
+    # default: prefer caption if present
+    default_mode = "caption" if caption else "filename"
+    title, desc = _build_title_desc_from_mode(src, file_name, default_mode)
 
     p = PendingUpload(
         src_msg=src,
         downloader=downloader,
         file_name=file_name,
+        caption=caption,
         title=title,
         description=desc,
         privacy="private",
+        title_mode=default_mode,
         via_link=via_link,
         status_msg=None,
     )
-    _PENDING_UPLOAD[uid] = p
 
     txt = _render_preview(p, size)
-    await safe_reply(src, txt, reply_markup=upload_confirm_keyboard(p.privacy))
-
-
-def _as_int(v: Any) -> int:
-    if v is None:
-        return 0
-    if isinstance(v, bool):
-        return int(v)
-    if isinstance(v, (int, float)):
-        return int(v)
-    if isinstance(v, str):
-        try:
-            return int(float(v.strip()))
-        except Exception:
-            return 0
-    if isinstance(v, dict):
-        for k in ("current", "sent", "bytes", "done", "downloaded", "uploaded", "processed", "total"):
-            if k in v:
-                try:
-                    return int(float(v.get(k) or 0))
-                except Exception:
-                    continue
-        try:
-            return int(float(next(iter(v.values()))))
-        except Exception:
-            return 0
-    return 0
-
 
-def _extract_client_secrets_from_json(obj: dict) -> tuple[str, str]:
-    """
-    Accepts either:
-      {"client_id": "...", "client_secret": "..."}
-    or Google style:
-      {"installed": {"client_id": "...", "client_secret": "..."}}
-      {"web": {"client_id": "...", "client_secret": "..."}}
-    """
-    if not isinstance(obj, dict):
-        return "", ""
-
-    if obj.get("client_id") and obj.get("client_secret"):
-        return str(obj.get("client_id") or "").strip(), str(obj.get("client_secret") or "").strip()
-
-    for k in ("installed", "web"):
-        sub = obj.get(k)
-        if isinstance(sub, dict) and sub.get("client_id") and sub.get("client_secret"):
-            return str(sub.get("client_id") or "").strip(), str(sub.get("client_secret") or "").strip()
+    # IMPORTANT FIX:
+    # Preview must appear in the request chat (DM/group), not inside the source chat.
+    if ui_msg:
+        p.status_msg = ui_msg
+        _PENDING_UPLOAD[uid] = p
+        await safe_edit(ui_msg, txt, reply_markup=upload_confirm_keyboard(p.privacy, p.title_mode))
+        return
 
-    return "", ""
+    st = await safe_reply(request_msg, txt, reply_markup=upload_confirm_keyboard(p.privacy, p.title_mode))
+    p.status_msg = st
+    _PENDING_UPLOAD[uid] = p
 
 
-async def _run_upload(uid: int) -> None:
+async def _run_upload(uid: int) -> Dict[str, Any]:
     if _IN_PROGRESS.get(uid):
-        return
+        return {"ok": False, "err": "already_running"}
+
     pending = _PENDING_UPLOAD.get(uid)
     if not pending:
-        return
-    if not pending.status_msg:
-        return
+        return {"ok": False, "err": "no_pending"}
 
-    _IN_PROGRESS[uid] = True
     st = pending.status_msg
+    if not st:
+        return {"ok": False, "err": "no_status_msg"}
+
+    _IN_PROGRESS[uid] = True
     file_path: Optional[str] = None
 
     try:
-        # Ensure there is a default profile
         prof = await get_default_profile(uid)
         if not (isinstance(prof, dict) and prof.get("ok") and prof.get("profile_id") and prof.get("access_token")):
             await safe_edit(st, NEED_AUTH, reply_markup=main_menu_keyboard())
-            return
+            return {"ok": False, "err": "need_auth"}
 
         prof_id = str(prof["profile_id"])
         access_token = str(prof["access_token"])
 
         overall_start = time.time()
 
-        # ---- Download (TG -> temp) with live speed ----
+        def _as_int(v: Any) -> int:
+            if v is None:
+                return 0
+            if isinstance(v, bool):
+                return int(v)
+            if isinstance(v, (int, float)):
+                return int(v)
+            if isinstance(v, str):
+                try:
+                    return int(float(v.strip()))
+                except Exception:
+                    return 0
+            if isinstance(v, dict):
+                for k in ("current", "sent", "bytes", "done", "downloaded", "uploaded", "processed"):
+                    if k in v:
+                        try:
+                            return int(float(v.get(k) or 0))
+                        except Exception:
+                            continue
+                try:
+                    return int(float(next(iter(v.values()))))
+                except Exception:
+                    return 0
+            return 0
+
+        # ---- Download (TG -> temp) ----
         await safe_edit(st, "⬇️ Downloading…")
         dl_speed = SpeedETA()
         dl_last_ui = 0.0
@@ -255,26 +272,23 @@ async def _run_upload(uid: int) -> None:
 
             rate = dl_speed.update(cur_i, total_i)
             txt = (
-                "⬇️ Downloading…\n\n"
-                f"{human_bytes(cur_i)} / {human_bytes(total_i)}\n"
-                f"Speed: {human_bytes(rate)}/s\n"
-                f"ETA: {human_eta(dl_speed.eta_seconds)}"
+                "⬇️ *Downloading…*\n\n"
+                f"`{human_bytes(cur_i)} / {human_bytes(total_i)}`\n"
+                f"*Speed:* `{human_bytes(rate)}/s`\n"
+                f"*ETA:* `{human_eta(dl_speed.eta_seconds)}`"
             )
             await safe_edit(st, txt)
 
-        file_path, _, _ = await download_to_temp(
-            pending.downloader,
-            pending.src_msg,
-            progress_cb=dl_progress,
-        )
+        file_path, _, _ = await download_to_temp(pending.downloader, pending.src_msg, progress_cb=dl_progress)
         dl_dur = max(0.001, time.time() - dl_start)
+
         try:
             file_bytes = int(os.path.getsize(file_path))
         except Exception:
             file_bytes = 0
 
-        # ---- Upload (temp -> YouTube) with live speed ----
-        from bot.youtube.uploader import upload_video  # local import
+        # ---- Upload (temp -> YouTube) ----
+        from bot.youtube.uploader import upload_video
 
         ul_speed = SpeedETA()
         ul_last_ui = 0.0
@@ -294,10 +308,10 @@ async def _run_upload(uid: int) -> None:
 
             rate = ul_speed.update(sent_i, total_i)
             txt = (
-                "⬆️ Uploading…\n\n"
-                f"{human_bytes(sent_i)} / {human_bytes(total_i)}\n"
-                f"Speed: {human_bytes(rate)}/s\n"
-                f"ETA: {human_eta(ul_speed.eta_seconds)}"
+                "⬆️ *Uploading…*\n\n"
+                f"`{human_bytes(sent_i)} / {human_bytes(total_i)}`\n"
+                f"*Speed:* `{human_bytes(rate)}/s`\n"
+                f"*ETA:* `{human_eta(ul_speed.eta_seconds)}`"
             )
             await safe_edit(st, txt)
 
@@ -319,38 +333,42 @@ async def _run_upload(uid: int) -> None:
                 d = str(detail)
                 msg += f"\n`{d[:280]}`"
                 if "uploadLimitExceeded" in d or "quotaExceeded" in d:
-                    msg += "\n\nℹ️ This looks like a YouTube daily upload/quota limit. Try another profile or wait and retry later."
+                    msg += "\n\nℹ️ Daily quota limit. Try another profile or retry later."
 
             await safe_edit(st, msg, reply_markup=main_menu_keyboard())
-            return
-
-        url = str(up.get("url") or "")
+            return {"ok": False, "err": err, "detail": detail}
 
+        url = up.get("url") or ""
         await record_upload(uid, prof_id)
 
         ul_dur = max(0.001, time.time() - ul_start)
         total_dur = max(0.001, time.time() - overall_start)
 
-        dl_avg = (human_bytes(file_bytes / dl_dur) + "/s") if file_bytes and dl_dur else "—"
-        ul_avg = (human_bytes(file_bytes / ul_dur) + "/s") if file_bytes and ul_dur else "—"
+        dl_avg = (human_bytes(file_bytes / dl_dur) + "/s") if file_bytes else "—"
+        ul_avg = (human_bytes(file_bytes / ul_dur) + "/s") if file_bytes else "—"
 
-        done = "✅ Uploaded!"
+        done = "✅ *Uploaded!*"
         if url:
             done += f"\n\n{url}"
         done += (
-            f"\n\nDownload: {dl_dur:.1f}s • avg {dl_avg}"
-            f"\nUpload: {ul_dur:.1f}s • avg {ul_avg}"
-            f"\nTotal: {total_dur:.1f}s"
+            f"\n\n*Download:* `{dl_dur:.1f}s` • avg `{dl_avg}`"
+            f"\n*Upload:* `{ul_dur:.1f}s` • avg `{ul_avg}`"
+            f"\n*Total:* `{total_dur:.1f}s`"
         )
         await safe_edit(st, done, reply_markup=main_menu_keyboard())
+        return {"ok": True, "url": url}
 
     except asyncio.CancelledError:
         try:
             await safe_edit(st, CANCELLED, reply_markup=main_menu_keyboard())
         except Exception:
             pass
+        return {"ok": False, "err": "cancelled"}
+
     except Exception as e:
         await safe_edit(st, f"❌ Error: `{str(e)[:180]}`", reply_markup=main_menu_keyboard())
+        return {"ok": False, "err": "exception", "detail": str(e)}
+
     finally:
         _PENDING_UPLOAD.pop(uid, None)
         _AWAIT_EDIT.pop(uid, None)
@@ -363,21 +381,15 @@ async def _run_upload(uid: int) -> None:
         _UPLOAD_TASK.pop(uid, None)
 
 
-# ============================================================
-# HANDLERS
-# ============================================================
-
 def setup_handlers(app: Client, user_app: Optional[Client]) -> None:
-    # ---- basic ----
-    @app.on_message(filters.command(["start", "help"]) & filters.private)
+    @app.on_message(filters.command(["start", "help"]))
     async def start_cmd(_, m: Message) -> None:
         from bot.ui.texts import START_TEXT
         await safe_reply(m, START_TEXT, reply_markup=main_menu_keyboard())
 
-    @app.on_message(filters.command("cancel") & filters.private)
+    @app.on_message(filters.command("cancel"))
     async def cancel_cmd(_, m: Message) -> None:
         uid = m.from_user.id
-
         _AWAIT_AUTH_MODE.pop(uid, None)
         _AWAIT_EDIT.pop(uid, None)
         _PENDING_UPLOAD.pop(uid, None)
@@ -392,17 +404,14 @@ def setup_handlers(app: Client, user_app: Optional[Client]) -> None:
             btask.cancel()
 
         _IN_PROGRESS.pop(uid, None)
-
         await safe_reply(m, CANCELLED, reply_markup=main_menu_keyboard())
 
-    # ---- admin allowlist ----
-    @app.on_message(filters.command("allow") & filters.private)
+    @app.on_message(filters.command("allow"))
     async def allow_cmd(_, m: Message) -> None:
         uid = m.from_user.id
         if not _is_admin_or_owner(uid):
             await safe_reply(m, OWNER_ONLY)
             return
-
         args = (m.text or "").split(maxsplit=1)
         if len(args) < 2:
             await safe_reply(m, "Usage: /allow <tg_id>")
@@ -412,17 +421,15 @@ def setup_handlers(app: Client, user_app: Optional[Client]) -> None:
         except Exception:
             await safe_reply(m, "Invalid tg_id")
             return
-
         await allow_user(tid)
         await safe_reply(m, f"✅ Allowed `{tid}`")
 
-    @app.on_message(filters.command("disallow") & filters.private)
+    @app.on_message(filters.command("disallow"))
     async def disallow_cmd(_, m: Message) -> None:
         uid = m.from_user.id
         if not _is_admin_or_owner(uid):
             await safe_reply(m, OWNER_ONLY)
             return
-
         args = (m.text or "").split(maxsplit=1)
         if len(args) < 2:
             await safe_reply(m, "Usage: /disallow <tg_id>")
@@ -432,22 +439,19 @@ def setup_handlers(app: Client, user_app: Optional[Client]) -> None:
         except Exception:
             await safe_reply(m, "Invalid tg_id")
             return
-
         await disallow_user(tid)
         await safe_reply(m, f"✅ Disallowed `{tid}`")
 
-    @app.on_message(filters.command("stats") & filters.private)
+    @app.on_message(filters.command("stats"))
     async def stats_cmd(_, m: Message) -> None:
         uid = m.from_user.id
         if not _is_admin_or_owner(uid):
             await safe_reply(m, OWNER_ONLY)
             return
-
         st = await get_stats()
         if not isinstance(st, dict):
             await safe_reply(m, "❌ stats failed")
             return
-
         await safe_reply(
             m,
             "📊 *Today stats*\n\n"
@@ -456,7 +460,7 @@ def setup_handlers(app: Client, user_app: Optional[Client]) -> None:
             f"Uploads today: `{st.get('uploads_today', 0)}`",
         )
 
-    @app.on_message(filters.command("diag") & filters.private)
+    @app.on_message(filters.command("diag"))
     async def diag_cmd(_, m: Message) -> None:
         uid = m.from_user.id
         if not _is_admin_or_owner(uid):
@@ -475,16 +479,17 @@ def setup_handlers(app: Client, user_app: Optional[Client]) -> None:
             f"Owners: `{len(Auth.OWNERS)}` Admins: `{len(Auth.ADMINS)}`",
         )
 
-    # ---- auth/profile flow ----
-    @app.on_message(filters.command("auth") & filters.private)
+    @app.on_message(filters.command("auth"))
     async def auth_cmd(_, m: Message) -> None:
-        if not await _ensure_allowed(m):
+        if not await _ensure_allowed_msg(m):
             return
+        uid = m.from_user.id
+        _AWAIT_AUTH_MODE[uid] = "oauth"
         await safe_reply(m, "🔐 Add a profile:", reply_markup=auth_menu_keyboard())
 
-    @app.on_message(filters.command("profiles") & filters.private)
+    @app.on_message(filters.command("profiles"))
     async def profiles_cmd(_, m: Message) -> None:
-        if not await _ensure_allowed(m):
+        if not await _ensure_allowed_msg(m):
             return
         uid = m.from_user.id
         data = await list_profiles(uid, only_connected=False)
@@ -495,66 +500,23 @@ def setup_handlers(app: Client, user_app: Optional[Client]) -> None:
         default_id = data.get("default_profile_id") or ""
         await safe_reply(m, "👤 *Profiles*", reply_markup=profiles_keyboard(profiles, default_id))
 
-    # ---- upload from DM media ----
-    @app.on_message(filters.private & (filters.video | filters.document))
-    async def media_in_dm(_, m: Message) -> None:
-        # If user is in auth-json mode and sends a JSON document, treat it as auth input.
-        uid = m.from_user.id
-        mode = _AWAIT_AUTH_MODE.get(uid)
-        if mode == "json" and m.document:
-            fn = str(getattr(m.document, "file_name", "") or "")
-            if fn.lower().endswith(".json"):
-                # Download JSON and parse
-                st = await safe_reply(m, "📄 Reading JSON…")
-                try:
-                    path, _, _ = await download_to_temp(app, m, progress_cb=None)
-                    if not path or not os.path.exists(path):
-                        await safe_edit(st, "❌ Failed to download JSON file.")
-                        return
-                    try:
-                        import json
-                        with open(path, "r", encoding="utf-8") as f:
-                            obj = json.load(f)
-                    finally:
-                        cleanup_file(path)
-
-                    client_id, client_secret = _extract_client_secrets_from_json(obj if isinstance(obj, dict) else {})
-                    label = str((obj.get("label") if isinstance(obj, dict) else "") or "main")[:40]
-
-                    if not client_id or not client_secret:
-                        await safe_edit(st, "❌ JSON missing client_id/client_secret. Paste JSON or send ID+Secret.")
-                        return
-
-                    out = await profile_add(uid, client_id, client_secret, label=label, ttl_sec=600)
-                    _AWAIT_AUTH_MODE.pop(uid, None)
-
-                    if isinstance(out, dict) and out.get("ok") and out.get("login_url"):
-                        await safe_edit(
-                            st,
-                            f"✅ Profile added.\n\n🔗 Login URL:\n{out.get('login_url')}\n\nAfter login, run /profiles.",
-                            reply_markup=main_menu_keyboard(),
-                        )
-                    else:
-                        await safe_edit(st, f"❌ Add failed: `{(out or {}).get('err', 'unknown')}`", reply_markup=main_menu_keyboard())
-                    return
-                except Exception as e:
-                    await safe_edit(st, f"❌ JSON read failed: `{str(e)[:180]}`", reply_markup=main_menu_keyboard())
-                    return
-
-        if not await _ensure_allowed(m):
+    # ✅ accept media in any chat (DM/group) - still gated by allowed
+    @app.on_message((filters.video | filters.document))
+    async def media_in_chat(_, m: Message) -> None:
+        if not await _ensure_allowed_msg(m):
             return
-
+        uid = m.from_user.id
         if _IN_PROGRESS.get(uid):
             await safe_reply(m, "⏳ Upload already running. Use /cancel to stop.")
             return
 
-        await _start_pending_upload(uid, m, app, via_link=False)
+        await _start_pending_upload(uid=uid, request_msg=m, src=m, downloader=app, via_link=False, ui_msg=None)
 
-    # ---- upload from link (admin/owner) ----
-    @app.on_message(filters.command(["yt", "dl", "archive"]) & filters.private)
+    # ✅ /yt /dl /archive in ANY chat; preview + progress stays in request chat
+    @app.on_message(filters.command(["yt", "dl", "archive"]))
     async def archive_cmd(_, m: Message) -> None:
         uid = m.from_user.id
-        if not await _ensure_allowed(m):
+        if not await _ensure_allowed_msg(m):
             return
         if not _is_admin_or_owner(uid):
             await safe_reply(m, OWNER_ONLY)
@@ -565,17 +527,17 @@ def setup_handlers(app: Client, user_app: Optional[Client]) -> None:
 
         args = (m.text or "").split(maxsplit=1)
         if len(args) < 2:
-            await safe_reply(m, "Usage: /archive <t.me message link>")
+            await safe_reply(m, "Usage: /yt <t.me message link>")
+            return
+
+        st = await safe_reply(m, "🔎 Fetching message…")
+        if not st:
             return
 
         try:
             chat_ref, msg_id = parse_telegram_link(args[1].strip())
         except Exception as e:
-            await safe_reply(m, f"Bad link: {e}")
-            return
-
-        st = await safe_reply(m, "🔎 Fetching message…")
-        if not st:
+            await safe_edit(st, f"Bad link: {e}", reply_markup=main_menu_keyboard())
             return
 
         try:
@@ -584,13 +546,13 @@ def setup_handlers(app: Client, user_app: Optional[Client]) -> None:
             await safe_edit(st, f"❌ Fetch failed: `{str(e)[:180]}`", reply_markup=main_menu_keyboard())
             return
 
-        await safe_edit(st, "✅ Message fetched. Preparing preview…", reply_markup=main_menu_keyboard())
-        await _start_pending_upload(uid, src, user_app, via_link=True)
+        await safe_edit(st, "✅ Message fetched. Preparing preview…")
+        await _start_pending_upload(uid=uid, request_msg=m, src=src, downloader=user_app, via_link=True, ui_msg=st)
 
-    # batch mode (owner/admin only): /batch <t.me links...> (one per line)
-    @app.on_message(filters.command("batch") & filters.private)
+    # ✅ batch sequential, stop on first failure by default
+    @app.on_message(filters.command("batch"))
     async def batch_cmd(_, m: Message) -> None:
-        if not await _ensure_allowed(m):
+        if not await _ensure_allowed_msg(m):
             return
         uid = m.from_user.id
         if not _is_admin_or_owner(uid):
@@ -614,151 +576,97 @@ def setup_handlers(app: Client, user_app: Optional[Client]) -> None:
             await safe_reply(m, "⏳ A batch is already running. Use /cancel to stop it.")
             return
 
-        await safe_reply(m, f"🧾 Batch starting: {len(links)} item(s).")
+        await safe_reply(m, f"🧾 Batch starting: {len(links)} item(s). (Sequential queue)")
 
         async def runner() -> None:
             batch_start = time.time()
             for i, link in enumerate(links, 1):
-                try:
-                    chat_ref, msg_id = parse_telegram_link(link)
-                except Exception as e:
-                    await safe_reply(m, f"❌ {i}/{len(links)} bad link: {e}")
-                    continue
-
                 st = await safe_reply(m, f"🔎 Batch {i}/{len(links)}: fetching…")
                 if not st:
                     continue
 
+                try:
+                    chat_ref, msg_id = parse_telegram_link(link)
+                except Exception as e:
+                    await safe_edit(st, f"❌ Batch {i}/{len(links)} bad link: {e}", reply_markup=main_menu_keyboard())
+                    return
+
                 try:
                     src = await user_app.get_messages(chat_ref, msg_id)
                 except Exception as e:
                     await safe_edit(st, f"❌ Batch {i}/{len(links)} fetch failed: `{str(e)[:180]}`", reply_markup=main_menu_keyboard())
-                    continue
+                    return
 
-                media, file_name, _ = _media_and_filename(src)
-                if not media:
-                    await safe_edit(st, f"❌ Batch {i}/{len(links)}: no video/document in that message.", reply_markup=main_menu_keyboard())
-                    continue
+                await safe_edit(st, f"✅ Batch {i}/{len(links)}: preview…")
+                await _start_pending_upload(uid=uid, request_msg=m, src=src, downloader=user_app, via_link=True, ui_msg=st)
 
-                title, desc = extract_title_description(src, file_name)
-
-                _PENDING_UPLOAD[uid] = PendingUpload(
-                    src_msg=src,
-                    downloader=user_app,
-                    file_name=file_name,
-                    title=title,
-                    description=desc,
-                    privacy="private",
-                    status_msg=st,
-                    via_link=True,
-                )
+                await safe_edit(st, f"⏳ Batch {i}/{len(links)}: starting upload…")
+                res = await _run_upload(uid)
 
-                await safe_edit(st, f"⏳ Batch {i}/{len(links)}: starting upload…", reply_markup=main_menu_keyboard())
-                await _run_upload(uid)
+                if not (isinstance(res, dict) and res.get("ok")):
+                    # STOP ON FAILURE (your requested behavior)
+                    await safe_reply(m, f"🛑 Batch stopped at item {i}/{len(links)} due to failure.")
+                    return
 
             batch_dur = max(0.001, time.time() - batch_start)
-            await safe_reply(m, f"✅ Batch done in {batch_dur:.1f}s.", reply_markup=main_menu_keyboard())
+            await safe_reply(m, f"✅ Batch done in {batch_dur:.1f}s.")
 
         t = asyncio.create_task(runner())
         _BATCH_TASK[uid] = t
 
-    # ============================================================
-    # CALLBACKS
-    # ============================================================
-    @app.on_callback_query(filters.private)
+    @app.on_callback_query()
     async def cb_handler(_, q: CallbackQuery) -> None:
-        # stop Telegram "loading..."
-        try:
-            await q.answer()
-        except Exception:
-            pass
-
-        uid = int(getattr(getattr(q, "from_user", None), "id", 0) or 0)
+        uid = q.from_user.id
         action, value = parse_cb(q.data or "")
 
-        # Menus (help is public)
         if action == MENU_HELP:
             await safe_edit(q.message, HELP_TEXT, reply_markup=main_menu_keyboard())
             return
 
-        # Back/cancel
         if action == BACK:
-            _AWAIT_AUTH_MODE.pop(uid, None)
-            await safe_edit(q.message, "🏠 Menu", reply_markup=main_menu_keyboard())
+            from bot.ui.texts import START_TEXT
+            await safe_edit(q.message, START_TEXT, reply_markup=main_menu_keyboard())
             return
 
-        if action == CANCEL:
-            _AWAIT_AUTH_MODE.pop(uid, None)
-            _AWAIT_EDIT.pop(uid, None)
-            _PENDING_UPLOAD.pop(uid, None)
-            _PENDING_DELETE.pop(uid, None)
-            await safe_edit(q.message, CANCELLED, reply_markup=main_menu_keyboard())
-            return
-
-        # Auth menu actions
-        if action == MENU_AUTH:
-            if not await _ensure_allowed(q.message, uid):
-                return
-            await safe_edit(q.message, "🔐 Add a profile:", reply_markup=auth_menu_keyboard())
-            return
-
-        if action == AUTH_JSON:
-            if not await _ensure_allowed(q.message, uid):
-                return
-            _AWAIT_AUTH_MODE[uid] = "json"
-            await safe_edit(
-                q.message,
-                "📄 Send your OAuth client JSON now.\n\n"
-                "• You can paste JSON text here, OR send a .json file.\n"
-                "• It must contain client_id and client_secret (Google style JSON works).",
-                reply_markup=main_menu_keyboard(),
-            )
-            return
-
-        if action == AUTH_CI:
-            if not await _ensure_allowed(q.message, uid):
-                return
-            _AWAIT_AUTH_MODE[uid] = "ci"
-            await safe_edit(
-                q.message,
-                "🔑 Send Client ID + Secret like this:\n\n"
-                "client_id_here\n"
-                "client_secret_here\n"
-                "[optional label]\n\n"
-                "Example label: main / alt / channelname",
-                reply_markup=main_menu_keyboard(),
-            )
-            return
-
-        # Speedtest / Profiles
         if action == MENU_SPEED:
-            if not await _ensure_allowed(q.message, uid):
+            if not await _ensure_allowed_cb(uid, q.message):
                 return
-            from bot.core.speedtest import net_download_test, net_upload_test
+            from bot.core.speedtest import net_download_test, net_upload_test, public_ip, ping_ms
+            await safe_edit(q.message, "⏱ Running speed test…")
+
+            ip = await public_ip()
+            ping = await ping_ms()
 
-            await safe_edit(q.message, "⏱ Running speed test…", reply_markup=main_menu_keyboard())
             dl = await net_download_test()
             ul = await net_upload_test()
-            try:
-                dl_bps = float(dl.get("bps", 0) or 0)
-            except Exception:
-                dl_bps = 0.0
-            try:
-                ul_bps = float(ul.get("bps", 0) or 0)
-            except Exception:
-                ul_bps = 0.0
 
-            await safe_edit(
-                q.message,
-                "📶 *Speed Test*\n\n"
-                f"Download: `{human_bytes(dl_bps)}/s`\n"
-                f"Upload: `{human_bytes(ul_bps)}/s`",
-                reply_markup=main_menu_keyboard(),
-            )
+            dl_bps = float((dl or {}).get("bps", 0) or 0)
+            ul_bps = float((ul or {}).get("bps", 0) or 0)
+
+            lines = [
+                "📶 *Speed Test*",
+                f"Uptime: `{uptime_text()}`",
+            ]
+            if ip:
+                lines.append(f"Public IP: `{ip}`")
+            if ping is not None:
+                lines.append(f"Ping(443): `{ping:.0f} ms`")
+
+            lines.append("")
+            lines.append(f"Download: `{human_bytes(dl_bps)}/s`")
+            lines.append(f"Upload: `{human_bytes(ul_bps)}/s`")
+
+            await safe_edit(q.message, "\n".join(lines), reply_markup=main_menu_keyboard())
+            return
+
+        if action == MENU_AUTH:
+            if not await _ensure_allowed_cb(uid, q.message):
+                return
+            await safe_edit(q.message, "🔐 Add a profile:", reply_markup=auth_menu_keyboard())
             return
 
         if action == MENU_PROFILES:
-            if not await _ensure_allowed(q.message, uid):
+            if not await _ensure_allowed_cb(uid, q.message):
                 return
             data = await list_profiles(uid, only_connected=False)
             if not (isinstance(data, dict) and data.get("ok")):
@@ -769,11 +677,37 @@ def setup_handlers(app: Client, user_app: Optional[Client]) -> None:
             await safe_edit(q.message, "👤 *Profiles*", reply_markup=profiles_keyboard(profiles, default_id))
             return
 
-        # Ignore "noop" buttons
-        if action == "noop":
+        # title-source buttons
+        if action in (NAME_ORIGINAL, NAME_CAPTION, NAME_CUSTOM):
+            p = _PENDING_UPLOAD.get(uid)
+            if not p:
+                return
+
+            if action == NAME_ORIGINAL:
+                p.title_mode = "filename"
+                p.title, p.description = _build_title_desc_from_mode(p.src_msg, p.file_name, "filename")
+            elif action == NAME_CAPTION:
+                p.title_mode = "caption"
+                p.title, p.description = _build_title_desc_from_mode(p.src_msg, p.file_name, "caption")
+            else:
+                # custom -> reuse edit flow
+                p.title_mode = "custom"
+                _AWAIT_EDIT[uid] = EditState(title=p.title, description=p.description, privacy=p.privacy)
+                _PENDING_UPLOAD[uid] = p
+                await safe_edit(
+                    q.message,
+                    "✍️ Send new title + description like this:\n\n"
+                    "Title line\n"
+                    "Description lines…\n\n"
+                    "(Send only 1 line to change title only)",
+                )
+                return
+
+            _PENDING_UPLOAD[uid] = p
+            media, _, size = _media_and_filename(p.src_msg)
+            await safe_edit(q.message, _render_preview(p, size), reply_markup=upload_confirm_keyboard(p.privacy, p.title_mode))
             return
 
-        # Upload buttons
         if action == UP_PRIV:
             p = _PENDING_UPLOAD.get(uid)
             if not p:
@@ -782,25 +716,26 @@ def setup_handlers(app: Client, user_app: Optional[Client]) -> None:
             p.privacy = cycle.get(p.privacy, "private")
             _PENDING_UPLOAD[uid] = p
             _, _, size = _media_and_filename(p.src_msg)
-            await safe_edit(q.message, _render_preview(p, size), reply_markup=upload_confirm_keyboard(p.privacy))
+            await safe_edit(q.message, _render_preview(p, size), reply_markup=upload_confirm_keyboard(p.privacy, p.title_mode))
             return
 
         if action == UP_EDIT:
             p = _PENDING_UPLOAD.get(uid)
             if not p:
                 return
+            p.title_mode = "custom"
             _AWAIT_EDIT[uid] = EditState(title=p.title, description=p.description, privacy=p.privacy)
+            _PENDING_UPLOAD[uid] = p
             await safe_edit(
                 q.message,
                 "✍️ Send new title + description like this:\n\n"
                 "Title line\n"
                 "Description lines…\n\n"
                 "(Send only 1 line to change title only)",
-                reply_markup=main_menu_keyboard(),
             )
             return
 
-        if action == UP_DEL:
+        if action in (UP_DEL, UP_CANCEL):
             _PENDING_UPLOAD.pop(uid, None)
             await safe_edit(q.message, CANCELLED, reply_markup=main_menu_keyboard())
             return
@@ -814,22 +749,22 @@ def setup_handlers(app: Client, user_app: Optional[Client]) -> None:
                 return
             p.status_msg = q.message
             _PENDING_UPLOAD[uid] = p
-            await safe_edit(q.message, "⏳ Starting upload…", reply_markup=main_menu_keyboard())
+            await safe_edit(q.message, "⏳ Starting upload…")
             t = asyncio.create_task(_run_upload(uid))
             _UPLOAD_TASK[uid] = t
             return
 
-        # Profile callbacks
+        # profile actions
         if action == "pdel":
-            if not await _ensure_allowed(q.message, uid):
+            if not await _ensure_allowed_cb(uid, q.message):
                 return
             pid = value
             _PENDING_DELETE[uid] = pid
-            await safe_edit(q.message, f"❓ Delete profile `{pid}`? Reply YES to confirm.", reply_markup=main_menu_keyboard())
+            await safe_edit(q.message, f"❓ Delete profile `{pid}`? Reply YES to confirm.")
             return
 
         if action == "pdef":
-            if not await _ensure_allowed(q.message, uid):
+            if not await _ensure_allowed_cb(uid, q.message):
                 return
             pid = value
             out = await set_default_profile(uid, pid)
@@ -843,7 +778,7 @@ def setup_handlers(app: Client, user_app: Optional[Client]) -> None:
             return
 
         if action == "plog":
-            if not await _ensure_allowed(q.message, uid):
+            if not await _ensure_allowed_cb(uid, q.message):
                 return
             pid = value
             chk = await profile_check_auth(uid, pid)
@@ -857,20 +792,12 @@ def setup_handlers(app: Client, user_app: Optional[Client]) -> None:
                 await safe_edit(q.message, "❌ Failed to create login URL.", reply_markup=main_menu_keyboard())
             return
 
-        # Unknown action
-        return
-
-    # ============================================================
-    # TEXT INPUT HANDLER (delete confirm + edit + auth input)
-    # ============================================================
-    @app.on_message(filters.private & filters.text)
-    async def text_in_dm(_, m: Message) -> None:
-        uid = m.from_user.id
-        txt = (m.text or "").strip()
+    @app.on_message(filters.text)
+    async def text_in_chat(_, m: Message) -> None:
+        uid = m.from_user.id if m.from_user else 0
 
-        # Confirm delete
         if uid in _PENDING_DELETE:
-            if txt.lower() == "yes":
+            if (m.text or "").strip().lower() == "yes":
                 pid = _PENDING_DELETE.pop(uid)
                 out = await profile_delete(uid, pid)
                 if isinstance(out, dict) and out.get("ok"):
@@ -882,89 +809,20 @@ def setup_handlers(app: Client, user_app: Optional[Client]) -> None:
                 await safe_reply(m, "Cancelled.", reply_markup=main_menu_keyboard())
             return
 
-        # Auth input
-        if uid in _AWAIT_AUTH_MODE:
-            if not await _ensure_allowed(m):
-                return
-
-            mode = _AWAIT_AUTH_MODE.get(uid, "")
-            if mode == "ci":
-                lines = [ln.strip() for ln in txt.splitlines() if ln.strip()]
-                client_id = ""
-                client_secret = ""
-                label = "main"
-
-                if len(lines) >= 2:
-                    client_id, client_secret = lines[0], lines[1]
-                    if len(lines) >= 3:
-                        label = lines[2][:40] or "main"
-                else:
-                    parts = txt.split()
-                    if len(parts) >= 2:
-                        client_id, client_secret = parts[0], parts[1]
-                        if len(parts) > 2:
-                            label = " ".join(parts[2:])[:40] or "main"
-
-                if not client_id or not client_secret:
-                    await safe_reply(m, "❌ Format:\nclient_id\nclient_secret\n[optional label]")
-                    return
-
-                out = await profile_add(uid, client_id, client_secret, label=label, ttl_sec=600)
-                _AWAIT_AUTH_MODE.pop(uid, None)
-
-                if isinstance(out, dict) and out.get("ok") and out.get("login_url"):
-                    await safe_reply(
-                        m,
-                        f"✅ Profile added.\n\n🔗 Login URL:\n{out.get('login_url')}\n\nAfter login, run /profiles.",
-                        reply_markup=main_menu_keyboard(),
-                    )
-                else:
-                    await safe_reply(m, f"❌ Add failed: `{(out or {}).get('err', 'unknown')}`", reply_markup=main_menu_keyboard())
-                return
-
-            if mode == "json":
-                try:
-                    import json
-                    obj = json.loads(txt)
-                except Exception:
-                    await safe_reply(m, "❌ Invalid JSON. Paste valid JSON or send a .json file.", reply_markup=main_menu_keyboard())
-                    return
-
-                client_id, client_secret = _extract_client_secrets_from_json(obj if isinstance(obj, dict) else {})
-                label = str((obj.get("label") if isinstance(obj, dict) else "") or "main")[:40]
-
-                if not client_id or not client_secret:
-                    await safe_reply(m, "❌ JSON missing client_id/client_secret.", reply_markup=main_menu_keyboard())
-                    return
-
-                out = await profile_add(uid, client_id, client_secret, label=label, ttl_sec=600)
-                _AWAIT_AUTH_MODE.pop(uid, None)
-
-                if isinstance(out, dict) and out.get("ok") and out.get("login_url"):
-                    await safe_reply(
-                        m,
-                        f"✅ Profile added.\n\n🔗 Login URL:\n{out.get('login_url')}\n\nAfter login, run /profiles.",
-                        reply_markup=main_menu_keyboard(),
-                    )
-                else:
-                    await safe_reply(m, f"❌ Add failed: `{(out or {}).get('err', 'unknown')}`", reply_markup=main_menu_keyboard())
-                return
-
-        # Edit title/desc
         if uid in _AWAIT_EDIT:
             _AWAIT_EDIT.pop(uid, None)
             p = _PENDING_UPLOAD.get(uid)
             if not p:
                 return
-
+            txt = (m.text or "").strip()
             lines = txt.splitlines()
             if len(lines) == 1:
                 p.title = lines[0].strip()[: Settings.MAX_TITLE]
             else:
-                p.title = (lines[0] or "").strip()[: Settings.MAX_TITLE]
+                p.title = lines[0].strip()[: Settings.MAX_TITLE]
                 p.description = "\n".join(lines[1:]).strip()[: Settings.MAX_DESC]
-
+            p.title_mode = "custom"
             _PENDING_UPLOAD[uid] = p
             _, _, size = _media_and_filename(p.src_msg)
-            await safe_reply(m, _render_preview(p, size), reply_markup=upload_confirm_keyboard(p.privacy))
+            await safe_reply(m, _render_preview(p, size), reply_markup=upload_confirm_keyboard(p.privacy, p.title_mode))
             return