Update bot/handlers.py

bot/handlers.py

@@ -2,48 +2,65 @@
 from __future__ import annotations
 
 import asyncio
+import json
 import os
 import re
+import tempfile
 import time
 from dataclasses import dataclass
-from typing import Any, Dict, Optional, Tuple, List, Union
+from typing import Any, Dict, List, Optional, Tuple, Union
 
+import httpx
 from hydrogram import Client, filters
 from hydrogram.types import CallbackQuery, Message
 
-from bot.config import Auth, Workers
+from bot.config import Auth, Telegram, 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_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_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 (
+    AUTH_CI,
+    AUTH_JSON,
+    BACK,
+    CANCEL,
     MENU_AUTH,
     MENU_HELP,
     MENU_PROFILES,
     MENU_SPEED,
+    NAME_CAPTION,
+    NAME_CUSTOM,
+    NAME_ORIGINAL,
+    UP_CANCEL,
     UP_DEL,
     UP_EDIT,
     UP_GO,
     UP_PRIV,
-    UP_CANCEL,
-    NAME_ORIGINAL,
-    NAME_CAPTION,
-    NAME_CUSTOM,
-    BACK,
 )
-from bot.ui.keyboards import auth_menu_keyboard, filename_keyboard, main_menu_keyboard, profiles_keyboard, upload_confirm_keyboard
+from bot.ui.keyboards import (
+    auth_menu_keyboard,
+    filename_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.ui.texts import CANCELLED, HELP_TEXT, NEED_AUTH, NOT_ALLOWED, OWNER_ONLY, START_TEXT
 from bot.youtube.link_parser import parse_telegram_link
 
 ChatRef = Union[int, str]
 
-
+# ---- In-memory state ----
 @dataclass
 class PendingUpload:
     request_msg: Message              # where user triggered command / sent media
@@ -74,7 +91,6 @@ class EditState:
     privacy: str
 
 
-# In-memory state
 _PENDING_UPLOAD: Dict[int, PendingUpload] = {}
 _AWAIT_EDIT: Dict[int, EditState] = {}
 _PENDING_DELETE: Dict[int, str] = {}
@@ -82,9 +98,36 @@ _IN_PROGRESS: Dict[int, bool] = {}
 _UPLOAD_TASK: Dict[int, asyncio.Task] = {}
 _BATCH_TASK: Dict[int, asyncio.Task] = {}
 
+# ✅ Auth input state (fixes: auth buttons "no response")
+# value: "json" or "ci"
+_AWAIT_AUTH: Dict[int, str] = {}
+
+# Batch range cap (Settings may not define it yet)
+_BATCH_MAX_RANGE = int(getattr(Settings, "BATCH_MAX_RANGE", 80) or 80)
+
+
+def _norm_ids(xs: Any) -> set[int]:
+    out: set[int] = set()
+    if not xs:
+        return out
+    if isinstance(xs, (int, float, str)):
+        xs = [xs]
+    for v in list(xs):
+        try:
+            s = str(v).strip()
+            if not s:
+                continue
+            out.add(int(float(s)))
+        except Exception:
+            continue
+    return out
+
 
 def _is_admin_or_owner(uid: int) -> bool:
-    return uid in set(Auth.OWNERS) or uid in set(Auth.ADMINS)
+    # Accept both Auth.* and Telegram.* and handle str/int mixes safely.
+    owners = _norm_ids(getattr(Auth, "OWNERS", None)) | _norm_ids(getattr(Telegram, "OWNER_ID", None))
+    admins = _norm_ids(getattr(Auth, "ADMINS", None)) | _norm_ids(getattr(Telegram, "ADMIN_IDS", None))
+    return uid in owners or uid in admins
 
 
 async def _ensure_allowed_uid(uid: int, reply_target: Message) -> bool:
@@ -106,9 +149,9 @@ async def _ensure_allowed_uid(uid: int, reply_target: Message) -> bool:
 
 def _media_and_filename(m: Message) -> Tuple[Optional[Any], str, int]:
     if m.video:
-        return m.video, (m.video.file_name or "video.mp4"), (m.video.file_size or 0)
+        return m.video, (m.video.file_name or "video.mp4"), int(m.video.file_size or 0)
     if m.document:
-        return m.document, (m.document.file_name or "file.bin"), (m.document.file_size or 0)
+        return m.document, (m.document.file_name or "file.bin"), int(m.document.file_size or 0)
     return None, "", 0
 
 
@@ -246,6 +289,20 @@ def _as_int(v: Any) -> int:
     return 0
 
 
+async def _get_public_ip() -> Optional[str]:
+    # No extra dependency / no extra file needed
+    try:
+        async with httpx.AsyncClient(timeout=10) as c:
+            r = await c.get("https://api.ipify.org", params={"format": "text"})
+            if r.status_code < 400:
+                ip = (r.text or "").strip()
+                if ip and len(ip) <= 60:
+                    return ip
+    except Exception:
+        pass
+    return None
+
+
 async def _run_upload(uid: int) -> Dict[str, Any]:
     """
     Runs one upload for uid, editing p.status_msg.
@@ -392,6 +449,7 @@ async def _run_upload(uid: int) -> Dict[str, Any]:
         _PENDING_UPLOAD.pop(uid, None)
         _AWAIT_EDIT.pop(uid, None)
         _PENDING_DELETE.pop(uid, None)
+        _AWAIT_AUTH.pop(uid, None)
         if file_path:
             try:
                 cleanup_file(file_path)
@@ -416,7 +474,6 @@ def _parse_link_or_range(line: str) -> Tuple[ChatRef, int, int]:
     if not s:
         raise ValueError("empty")
 
-    # quick detect ".... / 4012-4046"
     m = _BATCH_RANGE_RE.match(s)
     if m:
         base = m.group(1).strip()
@@ -427,25 +484,173 @@ def _parse_link_or_range(line: str) -> Tuple[ChatRef, int, int]:
         if a > b:
             a, b = b, a
 
-        # rebuild a normal single link to extract chat_ref
         single = f"{base}/{a}"
         chat_ref, _mid = parse_telegram_link(single)
         return chat_ref, a, b
 
-    # normal single link
     chat_ref, mid = parse_telegram_link(s)
     return chat_ref, int(mid), int(mid)
 
 
+def _extract_client_secrets_from_json(obj: dict) -> Tuple[str, str]:
+    """
+    Accepts client_secret.json formats:
+      {"installed": {"client_id": "...", "client_secret": "..."}}
+      {"web": {"client_id": "...", "client_secret": "..."}}
+      {"client_id": "...", "client_secret": "..."}
+    Returns (client_id, client_secret) or raises.
+    """
+    if not isinstance(obj, dict):
+        raise ValueError("json_not_object")
+
+    for k in ("installed", "web"):
+        v = obj.get(k)
+        if isinstance(v, dict) and v.get("client_id") and v.get("client_secret"):
+            return str(v["client_id"]).strip(), str(v["client_secret"]).strip()
+
+    if obj.get("client_id") and obj.get("client_secret"):
+        return str(obj["client_id"]).strip(), str(obj["client_secret"]).strip()
+
+    raise ValueError("missing_client_id_or_secret")
+
+
+async def _handle_auth_json_input(app: Client, m: Message) -> bool:
+    """
+    Returns True if message was consumed as auth input.
+    """
+    if not m.from_user:
+        return False
+    uid = m.from_user.id
+    if _AWAIT_AUTH.get(uid) != "json":
+        return False
+
+    if not await _ensure_allowed_uid(uid, m):
+        return True
+
+    # document .json
+    if m.document:
+        name = (m.document.file_name or "").lower()
+        if not name.endswith(".json"):
+            await safe_reply(m, "❌ Please send a `.json` file (Google client_secret.json). Or paste JSON text.")
+            return True
+
+        fd, path = tempfile.mkstemp(prefix="yt_auth_", suffix=".json")
+        os.close(fd)
+        try:
+            await app.download_media(message=m, file_name=path)
+            raw = ""
+            try:
+                with open(path, "r", encoding="utf-8") as f:
+                    raw = f.read()
+            except Exception:
+                with open(path, "rb") as f:
+                    raw = f.read().decode("utf-8", errors="ignore")
+
+            obj = json.loads(raw)
+            client_id, client_secret = _extract_client_secrets_from_json(obj)
+
+            out = await profile_add(uid, client_id=client_id, client_secret=client_secret, label="main")
+            if isinstance(out, dict) and out.get("ok"):
+                _AWAIT_AUTH.pop(uid, None)
+                await safe_reply(
+                    m,
+                    "✅ Profile added.\n\nNow run /profiles → *Login* → *Set default*.",
+                    reply_markup=main_menu_keyboard(),
+                )
+            else:
+                err = (out or {}).get("err") if isinstance(out, dict) else "profile_add_failed"
+                await safe_reply(m, f"❌ Failed to add profile: `{err}`")
+            return True
+        except Exception as e:
+            await safe_reply(m, f"❌ JSON parse/add failed: `{str(e)[:220]}`")
+            return True
+        finally:
+            try:
+                if os.path.exists(path):
+                    os.remove(path)
+            except Exception:
+                pass
+
+    # pasted JSON
+    txt = (m.text or "").strip()
+    if txt.startswith("{") and txt.endswith("}"):
+        try:
+            obj = json.loads(txt)
+            client_id, client_secret = _extract_client_secrets_from_json(obj)
+
+            out = await profile_add(uid, client_id=client_id, client_secret=client_secret, label="main")
+            if isinstance(out, dict) and out.get("ok"):
+                _AWAIT_AUTH.pop(uid, None)
+                await safe_reply(
+                    m,
+                    "✅ Profile added.\n\nNow run /profiles → *Login* → *Set default*.",
+                    reply_markup=main_menu_keyboard(),
+                )
+            else:
+                err = (out or {}).get("err") if isinstance(out, dict) else "profile_add_failed"
+                await safe_reply(m, f"❌ Failed to add profile: `{err}`")
+        except Exception as e:
+            await safe_reply(m, f"❌ JSON parse/add failed: `{str(e)[:220]}`")
+        return True
+
+    await safe_reply(m, "📄 Send the `.json` file or paste JSON text (client_secret.json).")
+    return True
+
+
+async def _handle_auth_ci_input(m: Message) -> bool:
+    """
+    Returns True if message was consumed as auth input.
+    """
+    if not m.from_user:
+        return False
+    uid = m.from_user.id
+    if _AWAIT_AUTH.get(uid) != "ci":
+        return False
+
+    if not await _ensure_allowed_uid(uid, m):
+        return True
+
+    txt = (m.text or "").strip()
+    if not txt:
+        await safe_reply(m, "Send:\n`<CLIENT_ID>`\n`<CLIENT_SECRET>`\n(Optional 3rd line: label)")
+        return True
+
+    lines = [ln.strip() for ln in txt.splitlines() if ln.strip()]
+    if len(lines) == 1:
+        # maybe space separated
+        parts = [p for p in lines[0].split() if p.strip()]
+        if len(parts) >= 2:
+            client_id, client_secret = parts[0], parts[1]
+            label = parts[2] if len(parts) >= 3 else "main"
+        else:
+            await safe_reply(m, "Send:\n`<CLIENT_ID>`\n`<CLIENT_SECRET>`\n(Optional 3rd line: label)")
+            return True
+    else:
+        client_id = lines[0]
+        client_secret = lines[1] if len(lines) >= 2 else ""
+        label = lines[2] if len(lines) >= 3 else "main"
+
+    out = await profile_add(uid, client_id=client_id, client_secret=client_secret, label=label)
+    if isinstance(out, dict) and out.get("ok"):
+        _AWAIT_AUTH.pop(uid, None)
+        await safe_reply(
+            m,
+            f"✅ Profile added (label: `{label}`).\n\nNow run /profiles → *Login* → *Set default*.",
+            reply_markup=main_menu_keyboard(),
+        )
+    else:
+        err = (out or {}).get("err") if isinstance(out, dict) else "profile_add_failed"
+        await safe_reply(m, f"❌ Failed to add profile: `{err}`")
+    return True
+
+
 def setup_handlers(app: Client, user_app: Optional[Client]) -> None:
     # ---- basic ----
     @app.on_message(filters.command(["start", "help"]))
     async def start_help_cmd(_, m: Message) -> None:
-        # always show menu + help text
         if (m.text or "").strip().lower().startswith("/help"):
             await safe_reply(m, HELP_TEXT, reply_markup=main_menu_keyboard())
         else:
-            from bot.ui.texts import START_TEXT
             await safe_reply(m, START_TEXT, reply_markup=main_menu_keyboard())
 
     @app.on_message(filters.command("speedtest"))
@@ -453,11 +658,12 @@ def setup_handlers(app: Client, user_app: Optional[Client]) -> None:
         uid = m.from_user.id if m.from_user else 0
         if not await _ensure_allowed_uid(uid, m):
             return
-        from bot.core.speedtest import net_download_test, net_upload_test, public_ip
-        await safe_reply(m, "⏱ Running speed test…")
+        from bot.core.speedtest import net_download_test, net_upload_test
+
+        st = await safe_reply(m, "⏱ Running speed test…")
         dl = await net_download_test()
         ul = await net_upload_test()
-        ip = await public_ip()
+        ip = await _get_public_ip()
 
         dl_bps = float((dl or {}).get("bps", 0) or 0)
         ul_bps = float((ul or {}).get("bps", 0) or 0)
@@ -469,11 +675,16 @@ def setup_handlers(app: Client, user_app: Optional[Client]) -> None:
             f"*Download:* `{human_bytes(dl_bps)}/s`\n"
             f"*Upload:* `{human_bytes(ul_bps)}/s`"
         )
-        await safe_reply(m, msg, reply_markup=main_menu_keyboard())
+        if st:
+            await safe_edit(st, msg, reply_markup=main_menu_keyboard())
+        else:
+            await safe_reply(m, msg, reply_markup=main_menu_keyboard())
 
     @app.on_message(filters.command("cancel"))
     async def cancel_cmd(_, m: Message) -> None:
-        uid = m.from_user.id
+        uid = m.from_user.id if m.from_user else 0
+
+        _AWAIT_AUTH.pop(uid, None)
         _AWAIT_EDIT.pop(uid, None)
         _PENDING_UPLOAD.pop(uid, None)
         _PENDING_DELETE.pop(uid, None)
@@ -493,7 +704,7 @@ def setup_handlers(app: Client, user_app: Optional[Client]) -> None:
     # ---- admin allowlist ----
     @app.on_message(filters.command("allow"))
     async def allow_cmd(_, m: Message) -> None:
-        uid = m.from_user.id
+        uid = m.from_user.id if m.from_user else 0
         if not _is_admin_or_owner(uid):
             await safe_reply(m, OWNER_ONLY)
             return
@@ -511,7 +722,7 @@ def setup_handlers(app: Client, user_app: Optional[Client]) -> None:
 
     @app.on_message(filters.command("disallow"))
     async def disallow_cmd(_, m: Message) -> None:
-        uid = m.from_user.id
+        uid = m.from_user.id if m.from_user else 0
         if not _is_admin_or_owner(uid):
             await safe_reply(m, OWNER_ONLY)
             return
@@ -529,7 +740,7 @@ def setup_handlers(app: Client, user_app: Optional[Client]) -> None:
 
     @app.on_message(filters.command("stats"))
     async def stats_cmd(_, m: Message) -> None:
-        uid = m.from_user.id
+        uid = m.from_user.id if m.from_user else 0
         if not _is_admin_or_owner(uid):
             await safe_reply(m, OWNER_ONLY)
             return
@@ -547,7 +758,7 @@ def setup_handlers(app: Client, user_app: Optional[Client]) -> None:
 
     @app.on_message(filters.command("diag"))
     async def diag_cmd(_, m: Message) -> None:
-        uid = m.from_user.id
+        uid = m.from_user.id if m.from_user else 0
         if not _is_admin_or_owner(uid):
             await safe_reply(m, OWNER_ONLY)
             return
@@ -561,20 +772,22 @@ def setup_handlers(app: Client, user_app: Optional[Client]) -> None:
             f"Uptime: `{uptime_text()}`\n"
             f"WORKER1_URL: `{w1}`\n"
             f"WORKER2_URL: `{w2}`\n"
-            f"Owners: `{len(Auth.OWNERS)}` Admins: `{len(Auth.ADMINS)}`",
+            f"Owners: `{len(_norm_ids(getattr(Auth, 'OWNERS', None)) | _norm_ids(getattr(Telegram, 'OWNER_ID', None)))}` "
+            f"Admins: `{len(_norm_ids(getattr(Auth, 'ADMINS', None)) | _norm_ids(getattr(Telegram, 'ADMIN_IDS', None)))}`",
         )
 
     # ---- auth/profile flow ----
     @app.on_message(filters.command("auth"))
     async def auth_cmd(_, m: Message) -> None:
-        uid = m.from_user.id
+        uid = m.from_user.id if m.from_user else 0
         if not await _ensure_allowed_uid(uid, m):
             return
+        _AWAIT_AUTH.pop(uid, None)
         await safe_reply(m, "🔐 Add a profile:", reply_markup=auth_menu_keyboard())
 
     @app.on_message(filters.command("profiles"))
     async def profiles_cmd(_, m: Message) -> None:
-        uid = m.from_user.id
+        uid = m.from_user.id if m.from_user else 0
         if not await _ensure_allowed_uid(uid, m):
             return
         data = await list_profiles(uid, only_connected=False)
@@ -585,10 +798,17 @@ 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 ----
+    # ---- upload from DM media / OR auth-json doc handling ----
     @app.on_message(filters.private & (filters.video | filters.document))
     async def media_in_dm(_, m: Message) -> None:
+        if not m.from_user:
+            return
         uid = m.from_user.id
+
+        # ✅ If we're waiting for auth JSON, consume json file instead of treating it as "upload media"
+        if await _handle_auth_json_input(app, m):
+            return
+
         if not await _ensure_allowed_uid(uid, m):
             return
         if _IN_PROGRESS.get(uid):
@@ -599,6 +819,8 @@ def setup_handlers(app: Client, user_app: Optional[Client]) -> None:
     # ---- upload from link (admin/owner) ----
     @app.on_message(filters.command(["yt", "dl", "archive"]))
     async def archive_cmd(_, m: Message) -> None:
+        if not m.from_user:
+            return
         uid = m.from_user.id
         if not await _ensure_allowed_uid(uid, m):
             return
@@ -636,6 +858,8 @@ def setup_handlers(app: Client, user_app: Optional[Client]) -> None:
     # ---- batch mode ----
     @app.on_message(filters.command("batch"))
     async def batch_cmd(_, m: Message) -> None:
+        if not m.from_user:
+            return
         uid = m.from_user.id
         if not await _ensure_allowed_uid(uid, m):
             return
@@ -665,7 +889,6 @@ def setup_handlers(app: Client, user_app: Optional[Client]) -> None:
             await safe_reply(m, "No links found. Put one t.me link per line after /batch")
             return
 
-        # Expand links/ranges
         items: List[Tuple[ChatRef, int]] = []
         for ln in lines:
             try:
@@ -677,8 +900,8 @@ def setup_handlers(app: Client, user_app: Optional[Client]) -> None:
                 continue
 
             count = (b - a + 1)
-            if count > Settings.BATCH_MAX_RANGE:
-                await safe_reply(m, f"❌ Range too large ({count}). Max is {Settings.BATCH_MAX_RANGE}.")
+            if count > _BATCH_MAX_RANGE:
+                await safe_reply(m, f"❌ Range too large ({count}). Max is {_BATCH_MAX_RANGE}.")
                 if not continue_on_fail:
                     return
                 continue
@@ -690,16 +913,16 @@ def setup_handlers(app: Client, user_app: Optional[Client]) -> None:
             await safe_reply(m, "No valid items to process.")
             return
 
-        await safe_reply(m, f"🧾 Batch starting: {len(items)} item(s). Mode: `{'continue' if continue_on_fail else 'stop_on_fail'}`")
+        await safe_reply(
+            m,
+            f"🧾 Batch starting: {len(items)} item(s).\nMode: `{'continue' if continue_on_fail else 'stop_on_fail'}`",
+        )
 
         async def runner() -> None:
             batch_start = time.time()
             total = len(items)
-            for i, (chat_ref, msg_id) in enumerate(items, 1):
-                if _IN_PROGRESS.get(uid):
-                    # should not happen (we do sequential), but keep safe
-                    await asyncio.sleep(0.2)
 
+            for i, (chat_ref, msg_id) in enumerate(items, 1):
                 st = await safe_reply(m, f"🔎 Batch {i}/{total}: fetching message `{msg_id}`…")
                 if not st:
                     if not continue_on_fail:
@@ -714,7 +937,7 @@ def setup_handlers(app: Client, user_app: Optional[Client]) -> None:
                         break
                     continue
 
-                media, file_name, size = _media_and_filename(src)
+                media, _, _ = _media_and_filename(src)
                 if not media:
                     await safe_edit(st, f"⏭ Batch {i}/{total}: no media in that message. Skipped.")
                     continue
@@ -722,27 +945,25 @@ def setup_handlers(app: Client, user_app: Optional[Client]) -> None:
                 # Create pending upload targeting THIS chat (m), not source chat
                 await _start_pending_upload(uid=uid, request_msg=m, src_msg=src, downloader=user_app, via_link=True)
 
-                # Force the status message to be this st (so progress edits this line)
+                # Force progress to edit THIS batch line
                 p = _PENDING_UPLOAD.get(uid)
                 if p:
                     p.status_msg = st
                     _PENDING_UPLOAD[uid] = p
 
-                    # Apply the current chosen title/desc and start upload
                     await safe_edit(st, f"⏳ Batch {i}/{total}: starting upload…")
                     out = await _run_upload(uid)
 
-                    if not out.get("ok"):
-                        if not continue_on_fail:
-                            await safe_reply(m, f"🛑 Batch stopped (failed at {i}/{total}).")
-                            break
+                    if not out.get("ok") and not continue_on_fail:
+                        await safe_reply(m, f"🛑 Batch stopped (failed at {i}/{total}).")
+                        break
                 else:
                     await safe_edit(st, f"❌ Batch {i}/{total}: internal error (no pending).")
                     if not continue_on_fail:
                         break
 
             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
@@ -751,12 +972,27 @@ def setup_handlers(app: Client, user_app: Optional[Client]) -> None:
     @app.on_callback_query()
     async def cb_handler(_, q: CallbackQuery) -> None:
         uid = q.from_user.id
+
+        # ✅ Stop Telegram loading spinner
+        try:
+            await q.answer()
+        except Exception:
+            pass
+
         action, value = parse_cb(q.data or "")
 
-        # Ignore noop
         if action == "noop":
             return
 
+        # Cancel from keyboards (used in filename keyboard, and we support it globally)
+        if action == CANCEL:
+            _AWAIT_AUTH.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
+
         # Menus
         if action == MENU_HELP:
             await safe_edit(q.message, HELP_TEXT, reply_markup=main_menu_keyboard())
@@ -765,11 +1001,12 @@ def setup_handlers(app: Client, user_app: Optional[Client]) -> None:
         if action == MENU_SPEED:
             if not await _ensure_allowed_uid(uid, q.message):
                 return
-            from bot.core.speedtest import net_download_test, net_upload_test, public_ip
+            from bot.core.speedtest import net_download_test, net_upload_test
+
             await safe_edit(q.message, "⏱ Running speed test…")
             dl = await net_download_test()
             ul = await net_upload_test()
-            ip = await public_ip()
+            ip = await _get_public_ip()
 
             dl_bps = float((dl or {}).get("bps", 0) or 0)
             ul_bps = float((ul or {}).get("bps", 0) or 0)
@@ -788,6 +1025,7 @@ def setup_handlers(app: Client, user_app: Optional[Client]) -> None:
         if action == MENU_AUTH:
             if not await _ensure_allowed_uid(uid, q.message):
                 return
+            _AWAIT_AUTH.pop(uid, None)
             await safe_edit(q.message, "🔐 Add a profile:", reply_markup=auth_menu_keyboard())
             return
 
@@ -804,9 +1042,40 @@ def setup_handlers(app: Client, user_app: Optional[Client]) -> None:
             return
 
         if action == BACK:
+            _AWAIT_AUTH.pop(uid, None)
             await safe_edit(q.message, "🏠 Menu", reply_markup=main_menu_keyboard())
             return
 
+        # ✅ AUTH buttons (THIS is what was missing -> no response)
+        if action == AUTH_JSON:
+            if not await _ensure_allowed_uid(uid, q.message):
+                return
+            _AWAIT_AUTH[uid] = "json"
+            await safe_edit(
+                q.message,
+                "📄 *Send JSON credentials*\n\n"
+                "Send `client_secret.json` as a file OR paste the JSON text here.\n\n"
+                "Use /cancel to stop.",
+                reply_markup=auth_menu_keyboard(),
+            )
+            return
+
+        if action == AUTH_CI:
+            if not await _ensure_allowed_uid(uid, q.message):
+                return
+            _AWAIT_AUTH[uid] = "ci"
+            await safe_edit(
+                q.message,
+                "🔑 *Send Client ID + Secret*\n\n"
+                "Send like this:\n"
+                "`CLIENT_ID`\n"
+                "`CLIENT_SECRET`\n"
+                "(Optional 3rd line: label)\n\n"
+                "Use /cancel to stop.",
+                reply_markup=auth_menu_keyboard(),
+            )
+            return
+
         # Filename/Caption choice
         if action in (NAME_ORIGINAL, NAME_CAPTION, NAME_CUSTOM):
             p = _PENDING_UPLOAD.get(uid)
@@ -815,7 +1084,6 @@ def setup_handlers(app: Client, user_app: Optional[Client]) -> None:
 
             if action == NAME_ORIGINAL:
                 p.title = (p.title_from_filename or "Untitled")[: Settings.MAX_TITLE]
-                # keep caption as description (if present)
                 p.description = (p.caption_raw or "")[: Settings.MAX_DESC]
                 _PENDING_UPLOAD[uid] = p
                 await safe_edit(q.message, _render_preview(p), reply_markup=upload_confirm_keyboard(p.privacy))
@@ -826,7 +1094,6 @@ def setup_handlers(app: Client, user_app: Optional[Client]) -> None:
                     p.title = p.title_from_caption[: Settings.MAX_TITLE]
                     p.description = p.desc_from_caption[: Settings.MAX_DESC]
                 else:
-                    # no caption actually
                     p.title = (p.title_from_filename or "Untitled")[: Settings.MAX_TITLE]
                     p.description = ""
                 _PENDING_UPLOAD[uid] = p
@@ -880,7 +1147,11 @@ def setup_handlers(app: Client, user_app: Optional[Client]) -> None:
             if not p:
                 return
             if _IN_PROGRESS.get(uid):
-                await safe_edit(q.message, "⏳ Upload already running. Use /cancel to stop.", reply_markup=main_menu_keyboard())
+                await safe_edit(
+                    q.message,
+                    "⏳ Upload already running. Use /cancel to stop.",
+                    reply_markup=main_menu_keyboard(),
+                )
                 return
             p.status_msg = q.message
             _PENDING_UPLOAD[uid] = p
@@ -927,13 +1198,22 @@ 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 (private or group, only triggers when waiting) ----
+    # ---- text handler ----
     @app.on_message(filters.text)
     async def text_anywhere(_, m: Message) -> None:
         if not m.from_user:
             return
         uid = m.from_user.id
 
+        # ✅ Auth CI input
+        if await _handle_auth_ci_input(m):
+            return
+
+        # ✅ Auth JSON pasted input (when user pastes text)
+        if _AWAIT_AUTH.get(uid) == "json":
+            if await _handle_auth_json_input(app, m):
+                return
+
         # Confirm delete
         if uid in _PENDING_DELETE:
             if (m.text or "").strip().lower() == "yes":
@@ -950,7 +1230,7 @@ def setup_handlers(app: Client, user_app: Optional[Client]) -> None:
 
         # Edit title/desc
         if uid in _AWAIT_EDIT:
-            st = _AWAIT_EDIT.pop(uid)
+            _ = _AWAIT_EDIT.pop(uid)
             p = _PENDING_UPLOAD.get(uid)
             if not p:
                 return
@@ -965,7 +1245,6 @@ def setup_handlers(app: Client, user_app: Optional[Client]) -> None:
 
             _PENDING_UPLOAD[uid] = p
 
-            # Update preview in the current chat
             if p.status_msg:
                 await safe_edit(p.status_msg, _render_preview(p), reply_markup=upload_confirm_keyboard(p.privacy))
             else: