Update bot/handlers.py

bot/handlers.py

@@ -1,10 +1,6 @@
-# FILE: bot/handlers.py
-# NOTE: Updated:
-# - Fix float(dict) crash by using SpeedETA that returns float and safe int conversions
-# - Show download speed/ETA + upload speed/ETA + total time summary
-# - Fix upload_video return-type mismatch (now dict)
-# - /cancel actually cancels running upload and batch tasks
-# - Add /batch (admin/owner only)
+# 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
 
@@ -15,30 +11,47 @@ from dataclasses import dataclass
 from typing import Any, Dict, Optional, Tuple
 
 from hydrogram import Client, filters
-from hydrogram.types import CallbackQuery, InlineKeyboardMarkup, Message
+from hydrogram.types import CallbackQuery, Message
 
 from bot.config import Auth, Workers
-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.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.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 (MENU_AUTH, MENU_HELP, MENU_PROFILES, MENU_SPEED,
-                              UP_DEL, UP_EDIT, UP_GO, UP_PRIV)
-from bot.ui.keyboards import (auth_menu_keyboard, main_menu_keyboard,
-                              profiles_keyboard, upload_confirm_keyboard)
+from bot.ui.callbacks import (
+    AUTH_CI,
+    AUTH_JSON,
+    BACK,
+    CANCEL,
+    MENU_AUTH,
+    MENU_HELP,
+    MENU_PROFILES,
+    MENU_SPEED,
+    UP_DEL,
+    UP_EDIT,
+    UP_GO,
+    UP_PRIV,
+)
+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
@@ -59,26 +72,37 @@ class EditState:
 
 
 # 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 -> "oauth" | "token"
-_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] = {}         # 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
+
 
+# ============================================================
+# HELPERS
+# ============================================================
 
 def _is_admin_or_owner(uid: int) -> bool:
-    return uid in set(Auth.OWNERS) or uid in set(Auth.ADMINS)
+    return uid in set(Auth.OWNERS or []) or uid in set(Auth.ADMINS or [])
 
 
-async def _ensure_allowed(m: Message) -> bool:
-    uid = m.from_user.id
+async def _ensure_allowed(reply_target: Message, uid: int | None = None) -> bool:
+    """
+    IMPORTANT: For callback queries, pass uid=q.from_user.id
+    because q.message.from_user is the BOT (not the clicker).
+    """
+    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(m, NOT_ALLOWED)
+        await safe_reply(reply_target, NOT_ALLOWED)
     return ok
 
 
@@ -94,25 +118,24 @@ def extract_title_description(src: Message, file_name: str) -> Tuple[str, str]:
     # Prefer caption text
     caption = (src.caption or "").strip()
     if caption:
-        # title = first line, desc = remaining lines
         parts = caption.splitlines()
-        title = parts[0].strip()
+        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]
-    # fallback to filename
+        return title[: Settings.MAX_TITLE], desc[: Settings.MAX_DESC]
+
     base = os.path.splitext(file_name)[0].strip()
-    title = (base or "Untitled")[:Settings.MAX_TITLE]
+    title = (base or "Untitled")[: Settings.MAX_TITLE]
     return title, ""
 
 
 def _render_preview(p: PendingUpload, size: int) -> str:
     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\n"
+        f"Title: {p.title}\n"
+        f"Description: {(p.description[:600] + '…') if len(p.description) > 600 else (p.description or '—')}"
     )
 
 
@@ -139,6 +162,54 @@ async def _start_pending_upload(uid: int, src: Message, downloader: Client, via_
     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()
+
+    return "", ""
+
+
 async def _run_upload(uid: int) -> None:
     if _IN_PROGRESS.get(uid):
         return
@@ -162,37 +233,8 @@ async def _run_upload(uid: int) -> None:
         prof_id = str(prof["profile_id"])
         access_token = str(prof["access_token"])
 
-        # Track total time (download + upload)
         overall_start = time.time()
 
-        # Safety: Telegram/hydrogram callbacks sometimes pass dict/None.
-        # Convert to int to avoid int(dict)/float(dict) crashes.
-        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
-                # common pattern: {"current":..., "total":...}
-                try:
-                    return int(float(next(iter(v.values()))))
-                except Exception:
-                    return 0
-            return 0
-
         # ---- Download (TG -> temp) with live speed ----
         await safe_edit(st, "⬇️ Downloading…")
         dl_speed = SpeedETA()
@@ -213,14 +255,18 @@ 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"
+                "⬇️ 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))
@@ -229,6 +275,7 @@ async def _run_upload(uid: int) -> None:
 
         # ---- Upload (temp -> YouTube) with live speed ----
         from bot.youtube.uploader import upload_video  # local import
+
         ul_speed = SpeedETA()
         ul_last_ui = 0.0
         ul_start = time.time()
@@ -247,9 +294,9 @@ 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"
+                "⬆️ 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)
@@ -271,14 +318,13 @@ async def _run_upload(uid: int) -> None:
             if detail:
                 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."
 
-            await safe_edit(st, msg)
+            await safe_edit(st, msg, reply_markup=main_menu_keyboard())
             return
 
-        url = up.get("url") or ""
+        url = str(up.get("url") or "")
 
         await record_upload(uid, prof_id)
 
@@ -296,16 +342,15 @@ async def _run_upload(uid: int) -> None:
             f"\nUpload: {ul_dur:.1f}s • avg {ul_avg}"
             f"\nTotal: {total_dur:.1f}s"
         )
-        await safe_edit(st, done)
+        await safe_edit(st, done, reply_markup=main_menu_keyboard())
 
     except asyncio.CancelledError:
-        # /cancel pressed
         try:
             await safe_edit(st, CANCELLED, reply_markup=main_menu_keyboard())
         except Exception:
             pass
     except Exception as e:
-        await safe_edit(st, f"❌ Error: `{str(e)[:180]}`")
+        await safe_edit(st, f"❌ Error: `{str(e)[:180]}`", reply_markup=main_menu_keyboard())
     finally:
         _PENDING_UPLOAD.pop(uid, None)
         _AWAIT_EDIT.pop(uid, None)
@@ -318,6 +363,10 @@ 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)
@@ -328,12 +377,12 @@ def setup_handlers(app: Client, user_app: Optional[Client]) -> None:
     @app.on_message(filters.command("cancel") & filters.private)
     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)
         _PENDING_DELETE.pop(uid, None)
 
-        # stop running upload task (if any)
         task = _UPLOAD_TASK.pop(uid, None)
         if task and not task.done():
             task.cancel()
@@ -353,6 +402,7 @@ def setup_handlers(app: Client, user_app: Optional[Client]) -> None:
         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>")
@@ -362,6 +412,7 @@ 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}`")
 
@@ -371,6 +422,7 @@ def setup_handlers(app: Client, user_app: Optional[Client]) -> None:
         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>")
@@ -380,6 +432,7 @@ 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}`")
 
@@ -389,10 +442,12 @@ def setup_handlers(app: Client, user_app: Optional[Client]) -> None:
         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"
@@ -425,8 +480,6 @@ def setup_handlers(app: Client, user_app: Optional[Client]) -> None:
     async def auth_cmd(_, m: Message) -> None:
         if not await _ensure_allowed(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)
@@ -445,12 +498,56 @@ def setup_handlers(app: Client, user_app: Optional[Client]) -> None:
     # ---- 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):
             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)
 
     # ---- upload from link (admin/owner) ----
@@ -465,24 +562,29 @@ def setup_handlers(app: Client, user_app: Optional[Client]) -> None:
         if user_app is None:
             await safe_reply(m, "❌ This mode requires user session (user_app missing).")
             return
+
         args = (m.text or "").split(maxsplit=1)
         if len(args) < 2:
             await safe_reply(m, "Usage: /archive <t.me message link>")
             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:
             return
+
         try:
             src = await user_app.get_messages(chat_ref, msg_id)
         except Exception as e:
-            await safe_edit(st, f"❌ Fetch failed: `{str(e)[:180]}`")
+            await safe_edit(st, f"❌ Fetch failed: `{str(e)[:180]}`", reply_markup=main_menu_keyboard())
             return
-        await safe_edit(st, "✅ Message fetched. Preparing preview…")
+
+        await safe_edit(st, "✅ Message fetched. Preparing preview…", reply_markup=main_menu_keyboard())
         await _start_pending_upload(uid, src, user_app, via_link=True)
 
     # batch mode (owner/admin only): /batch <t.me links...> (one per line)
@@ -530,12 +632,12 @@ def setup_handlers(app: Client, user_app: Optional[Client]) -> None:
                 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]}`")
+                    await safe_edit(st, f"❌ Batch {i}/{len(links)} fetch failed: `{str(e)[:180]}`", reply_markup=main_menu_keyboard())
                     continue
 
                 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.")
+                    await safe_edit(st, f"❌ Batch {i}/{len(links)}: no video/document in that message.", reply_markup=main_menu_keyboard())
                     continue
 
                 title, desc = extract_title_description(src, file_name)
@@ -551,30 +653,90 @@ def setup_handlers(app: Client, user_app: Optional[Client]) -> None:
                     via_link=True,
                 )
 
-                await safe_edit(st, f"⏳ Batch {i}/{len(links)}: starting upload…")
+                await safe_edit(st, f"⏳ Batch {i}/{len(links)}: starting upload…", reply_markup=main_menu_keyboard())
                 await _run_upload(uid)
 
             batch_dur = max(0.001, time.time() - batch_start)
-            await safe_reply(m, f"✅ Batch done in {batch_dur:.1f}s.")
+            await safe_reply(m, f"✅ Batch done in {batch_dur:.1f}s.", reply_markup=main_menu_keyboard())
 
         t = asyncio.create_task(runner())
         _BATCH_TASK[uid] = t
 
-    # callbacks
+    # ============================================================
+    # CALLBACKS
+    # ============================================================
     @app.on_callback_query(filters.private)
     async def cb_handler(_, q: CallbackQuery) -> None:
-        uid = q.from_user.id
+        # stop Telegram "loading..."
+        try:
+            await q.answer()
+        except Exception:
+            pass
+
+        uid = int(getattr(getattr(q, "from_user", None), "id", 0) or 0)
         action, value = parse_cb(q.data or "")
-        # Menus
+
+        # 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())
+            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):
+            if not await _ensure_allowed(q.message, uid):
                 return
             from bot.core.speedtest import net_download_test, net_upload_test
-            await safe_edit(q.message, "⏱ Running speed test…")
+
+            await safe_edit(q.message, "⏱ Running speed test…", reply_markup=main_menu_keyboard())
             dl = await net_download_test()
             ul = await net_upload_test()
             try:
@@ -595,14 +757,8 @@ def setup_handlers(app: Client, user_app: Optional[Client]) -> None:
             )
             return
 
-        if action == MENU_AUTH:
-            if not await _ensure_allowed(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):
+            if not await _ensure_allowed(q.message, uid):
                 return
             data = await list_profiles(uid, only_connected=False)
             if not (isinstance(data, dict) and data.get("ok")):
@@ -613,6 +769,10 @@ 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":
+            return
+
         # Upload buttons
         if action == UP_PRIV:
             p = _PENDING_UPLOAD.get(uid)
@@ -621,7 +781,7 @@ def setup_handlers(app: Client, user_app: Optional[Client]) -> None:
             cycle = {"private": "unlisted", "unlisted": "public", "public": "private"}
             p.privacy = cycle.get(p.privacy, "private")
             _PENDING_UPLOAD[uid] = p
-            media, _, size = _media_and_filename(p.src_msg)
+            _, _, size = _media_and_filename(p.src_msg)
             await safe_edit(q.message, _render_preview(p, size), reply_markup=upload_confirm_keyboard(p.privacy))
             return
 
@@ -636,6 +796,7 @@ def setup_handlers(app: Client, user_app: Optional[Client]) -> None:
                 "Title line\n"
                 "Description lines…\n\n"
                 "(Send only 1 line to change title only)",
+                reply_markup=main_menu_keyboard(),
             )
             return
 
@@ -653,22 +814,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…")
+            await safe_edit(q.message, "⏳ Starting upload…", reply_markup=main_menu_keyboard())
             t = asyncio.create_task(_run_upload(uid))
             _UPLOAD_TASK[uid] = t
             return
 
-        # Profile callbacks (from profiles_keyboard)
+        # Profile callbacks
         if action == "pdel":
-            if not await _ensure_allowed(q.message):
+            if not await _ensure_allowed(q.message, uid):
                 return
             pid = value
             _PENDING_DELETE[uid] = pid
-            await safe_edit(q.message, f"❓ Delete profile `{pid}`? Reply YES to confirm.")
+            await safe_edit(q.message, f"❓ Delete profile `{pid}`? Reply YES to confirm.", reply_markup=main_menu_keyboard())
             return
 
         if action == "pdef":
-            if not await _ensure_allowed(q.message):
+            if not await _ensure_allowed(q.message, uid):
                 return
             pid = value
             out = await set_default_profile(uid, pid)
@@ -682,7 +843,7 @@ def setup_handlers(app: Client, user_app: Optional[Client]) -> None:
             return
 
         if action == "plog":
-            if not await _ensure_allowed(q.message):
+            if not await _ensure_allowed(q.message, uid):
                 return
             pid = value
             chk = await profile_check_auth(uid, pid)
@@ -696,14 +857,20 @@ 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
 
-    # ---- edit text handler ----
+        # 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()
 
         # Confirm delete
         if uid in _PENDING_DELETE:
-            if (m.text or "").strip().lower() == "yes":
+            if txt.lower() == "yes":
                 pid = _PENDING_DELETE.pop(uid)
                 out = await profile_delete(uid, pid)
                 if isinstance(out, dict) and out.get("ok"):
@@ -715,20 +882,89 @@ 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:
-            st = _AWAIT_EDIT.pop(uid)
+            _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]
+                p.title = lines[0].strip()[: Settings.MAX_TITLE]
             else:
-                p.title = lines[0].strip()[:Settings.MAX_TITLE]
-                p.description = "\n".join(lines[1:]).strip()[:Settings.MAX_DESC]
+                p.title = (lines[0] or "").strip()[: Settings.MAX_TITLE]
+                p.description = "\n".join(lines[1:]).strip()[: Settings.MAX_DESC]
+
             _PENDING_UPLOAD[uid] = p
-            media, _, size = _media_and_filename(p.src_msg)
+            _, _, size = _media_and_filename(p.src_msg)
             await safe_reply(m, _render_preview(p, size), reply_markup=upload_confirm_keyboard(p.privacy))
             return