Update bot_core.py

bot_core.py

@@ -1,10 +1,26 @@
 # bot_core.py
-import os, re, time, asyncio, nest_asyncio
+import os, re, time, sys, asyncio, nest_asyncio, logging
 from typing import Optional, Tuple
 from telethon import TelegramClient, events
 from telethon.sessions import StringSession
 from telethon.errors.rpcerrorlist import FloodWaitError
 
+# ========= LOGGING =========
+LOG_LEVEL = os.environ.get("LOG_LEVEL", "INFO").upper()
+logger = logging.getLogger("midastouch-bot")
+if not logger.handlers:
+    handler = logging.StreamHandler(sys.stdout)
+    fmt = logging.Formatter(
+        fmt="%(asctime)s | %(levelname)-7s | %(message)s",
+        datefmt="%Y-%m-%d %H:%M:%S",
+    )
+    handler.setFormatter(fmt)
+    logger.addHandler(handler)
+logger.setLevel(LOG_LEVEL)
+
+# Biar log Telethon ikut muncul saat DEBUG
+logging.getLogger("telethon").setLevel(logging.WARNING if LOG_LEVEL != "DEBUG" else logging.INFO)
+
 # ======== ENV & KONFIG ========
 API_ID   = int(os.environ.get("API_ID", "0"))
 API_HASH = os.environ.get("API_HASH", "")
@@ -21,6 +37,8 @@ RETRY_MAX_ATTEMPTS    = int(os.environ.get("RETRY_MAX_ATTEMPTS", "12"))
 RETRY_SLEEP_SECONDS   = float(os.environ.get("RETRY_SLEEP_SECONDS", "1.2"))
 RETRY_OVERALL_TIMEOUT = float(os.environ.get("RETRY_OVERALL_TIMEOUT", "60"))
 RECENT_CA_TTL_MINUTES = int(os.environ.get("RECENT_CA_TTL_MINUTES", "60"))
+
+# Ambang tier minimum (low < medium < strong/high < fomo)
 TIER_MIN = os.environ.get("TIER_MIN", "medium").strip().lower()
 
 if not (API_ID and API_HASH and STRING_SESSION):
@@ -36,6 +54,7 @@ BUY_PAT     = re.compile(r"(?i)buy")
 REFRESH_PAT = re.compile(r"(?i)refresh")
 RETRY_PAT   = re.compile(r"(?i)(" + "|".join(map(re.escape, RETRY_LABELS)) + r")") if RETRY_LABELS else re.compile(r"$^")
 
+# [Low 🌱], [Medium ⚡️], [Strong 💪], [High], [FOMO🔥]
 TIER_PAT = re.compile(r"\[\s*(low|medium|strong|high|fomo)\b.*?\]", re.IGNORECASE | re.UNICODE)
 _TIER_ORDER = {"low": 1, "medium": 2, "strong": 3, "high": 3, "fomo": 4}
 _MIN_RANK = _TIER_ORDER.get(TIER_MIN, 2)
@@ -60,11 +79,14 @@ def extract_tier(text: str) -> Optional[str]:
 def has_valid_tier(text: str) -> bool:
     t = extract_tier(text)
     if not t:
-        print("[SKIP] Pesan tanpa tier → dilewati")
+        logger.info("SKIP | pesan TANPA tier → dilewati")
         return False
     rank = _TIER_ORDER.get(t, 0)
-    print(f"[INFO] Tier terdeteksi: {t} (rank={rank}), minimum={_MIN_RANK}")
-    return rank >= _MIN_RANK
+    if rank >= _MIN_RANK:
+        logger.info("PASS | tier=%s (rank=%d) >= min=%d", t, rank, _MIN_RANK)
+        return True
+    logger.info("SKIP | tier=%s (rank=%d) < min=%d", t, rank, _MIN_RANK)
+    return False
 
 def find_first_ca(text: str) -> Optional[Tuple[str, str]]:
     if not text:
@@ -81,7 +103,7 @@ def find_first_ca(text: str) -> Optional[Tuple[str, str]]:
     if not cand:
         return None
     chain, _, addr = sorted(cand, key=lambda x: x[1])[0]
-    print(f"[INFO] CA ditemukan: {addr} (chain={chain})")
+    logger.info("CA  | ditemukan chain=%s addr=%s", chain, addr)
     return chain, addr
 
 # ======== STATE ========
@@ -107,10 +129,10 @@ async def wait_new_keyboard(chat, *, min_id: int, timeout=25, interval=0.8):
         msgs = await client.get_messages(chat, limit=8)
         for m in msgs:
             if m.id > min_id and m.buttons:
-                print(f"[DEBUG] Keyboard baru ditemukan (msg.id={m.id})")
+                logger.debug("KB  | keyboard baru id=%s", m.id)
                 return m
         await asyncio.sleep(interval)
-    print("[WARN] Tidak menemukan keyboard baru dalam timeout")
+    logger.warning("KB  | tidak menemukan keyboard (timeout=%ss)", timeout)
     return None
 
 async def click_first_match(msg, pat) -> bool:
@@ -123,7 +145,7 @@ async def click_first_match(msg, pat) -> bool:
         for j, btn in enumerate(row):
             label = (getattr(btn, "text", "") or "").strip()
             if label and pat.search(label):
-                print(f"[ACTION] Klik tombol: {label}")
+                logger.info("UI  | klik tombol: %s (i=%d, j=%d)", label, i, j)
                 await msg.click(i, j)
                 return True
     return False
@@ -134,6 +156,7 @@ async def search_latest_with_button(chat, pat, *, min_id: int, limit=10):
         if m.id >= min_id and m.buttons:
             m2 = await client.get_messages(chat, ids=m.id)
             if m2 and await click_first_match(m2, pat):
+                logger.debug("UI  | tombol ditemukan di pesan id=%s", m.id)
                 return m2
     return None
 
@@ -141,11 +164,11 @@ async def click_retry_until_gone(anchor_msg, *, baseline_id: int) -> bool:
     attempts = 0
     started = time.monotonic()
     msg_kb = anchor_msg
-    while attempts < RETRY_MAX_ATTEMPTS and (time.monotonic() - started) < RETRY_OVERALL_TIMEOUT:
+    while attempts < RETRY_MAX_ATTEMPTS and (time.monotonic() - started) < (RETRY_OVERALL_TIMEOUT):
         msg_kb = await refresh_message(msg_kb)
         if await click_first_match(msg_kb, RETRY_PAT):
             attempts += 1
-            print(f"[RETRY] Klik Retry ke-{attempts}")
+            logger.info("RET | klik Retry ke-%d", attempts)
             await asyncio.sleep(RETRY_SLEEP_SECONDS)
             continue
         msgs = await client.get_messages(TARGET_CHAT, limit=8)
@@ -155,69 +178,73 @@ async def click_retry_until_gone(anchor_msg, *, baseline_id: int) -> bool:
                 if m2 and await click_first_match(m2, RETRY_PAT):
                     attempts += 1
                     baseline_id = max(baseline_id, m2.id)
-                    print(f"[RETRY] Klik Retry di pesan baru id={m.id}")
+                    logger.info("RET | klik Retry di msg.id=%s (total=%d)", m.id, attempts)
                     await asyncio.sleep(RETRY_SLEEP_SECONDS)
                     break
         else:
             break
-    print("[INFO] Retry selesai / tidak ada tombol lagi")
+    logger.info("RET | selesai (attempts=%d)", attempts)
     return True
 
 async def buy_flow_with_ca(addr: str):
-    print(f"[FLOW] Mulai buy_flow dengan CA: {addr}")
+    logger.info("FLOW| start buy_flow CA=%s", addr)
     last = await client.get_messages(TARGET_CHAT, limit=1)
     baseline_id = last[0].id if last else 0
 
     await client.send_message(TARGET_CHAT, addr)
-    print("[SEND] CA terkirim ke target bot")
+    logger.info("SEND| CA terkirim ke target bot")
 
     msg_kb = await wait_new_keyboard(TARGET_CHAT, min_id=baseline_id, timeout=25)
     if not msg_kb:
-        print("[WARN] Keyboard tidak muncul, fallback ke /start")
+        logger.warning("KB  | no keyboard → fallback /start")
         await client.send_message(TARGET_CHAT, "/start")
         await asyncio.sleep(1.0)
         await client.send_message(TARGET_CHAT, addr)
         msg_kb = await wait_new_keyboard(TARGET_CHAT, min_id=baseline_id, timeout=25)
         if not msg_kb:
-            print("[ERROR] Gagal mendapatkan keyboard setelah fallback")
+            logger.error("KB  | gagal dapat keyboard setelah fallback")
             return
 
     if AMOUNT_LABEL:
-        if await click_first_match(msg_kb, re.compile(re.escape(AMOUNT_LABEL), re.IGNORECASE)):
+        ok_amt = await click_first_match(msg_kb, re.compile(re.escape(AMOUNT_LABEL), re.IGNORECASE))
+        logger.info("UI  | pilih amount '%s' → %s", AMOUNT_LABEL, "OK" if ok_amt else "MISS")
+        if ok_amt:
             await asyncio.sleep(1.0)
             msg2 = await wait_new_keyboard(TARGET_CHAT, min_id=baseline_id, timeout=12)
             msg_kb = msg2 or await refresh_message(msg_kb)
             baseline_id = max(baseline_id, getattr(msg_kb, "id", baseline_id))
 
-    # === Tambahan: tunggu + Refresh 2x sebelum BUY ===
-    print("[WAIT] Tunggu 15 detik sebelum klik Refresh pertama")
+    # === Tunggu + Refresh 2x sebelum BUY ===
+    logger.info("WAIT| 15s sebelum Refresh #1")
     await asyncio.sleep(15)
-    await click_first_match(msg_kb, REFRESH_PAT)
+    ok_r1 = await click_first_match(msg_kb, REFRESH_PAT)
+    logger.info("UI  | Refresh #1 → %s", "OK" if ok_r1 else "MISS")
 
-    print("[WAIT] Tunggu 15 detik sebelum klik Refresh kedua")
+    logger.info("WAIT| 15s sebelum Refresh #2")
     await asyncio.sleep(15)
     msg_kb = await refresh_message(msg_kb)
-    await click_first_match(msg_kb, REFRESH_PAT)
-    # ================================================
+    ok_r2 = await click_first_match(msg_kb, REFRESH_PAT)
+    logger.info("UI  | Refresh #2 → %s", "OK" if ok_r2 else "MISS")
+    # ================================
 
-    print("[STEP] Klik tombol BUY")
+    logger.info("STEP| klik BUY")
     ok_buy = await click_first_match(msg_kb, BUY_PAT)
     if not ok_buy:
         hit = await search_latest_with_button(TARGET_CHAT, BUY_PAT, min_id=baseline_id, limit=10)
         if hit:
             msg_kb = hit
             ok_buy = True
-
+            logger.info("UI  | BUY ditemukan di pesan lain")
     if not ok_buy and msg_kb.buttons and msg_kb.buttons[-1]:
         try:
             await msg_kb.click(len(msg_kb.buttons) - 1, 0)
-            print("[FALLBACK] Klik tombol terakhir sebagai BUY")
             ok_buy = True
-        except:
-            pass
+            logger.info("FALL| klik tombol terakhir sebagai BUY")
+        except Exception as e:
+            logger.debug("FALL| gagal klik tombol terakhir: %s", e)
 
     if not ok_buy:
-        print("[WARN] Tidak menemukan tombol BUY, ulangi dengan /start")
+        logger.warning("BUY | tombol tidak ditemukan → ulangi /start")
         await client.send_message(TARGET_CHAT, "/start")
         await asyncio.sleep(1.0)
         await client.send_message(TARGET_CHAT, addr)
@@ -226,20 +253,21 @@ async def buy_flow_with_ca(addr: str):
         if not await click_first_match(msg_kb, BUY_PAT):
             hit2 = await search_latest_with_button(TARGET_CHAT, BUY_PAT, min_id=baseline_id, limit=10)
             if not hit2:
-                print("[ERROR] BUY tetap gagal setelah ulang")
+                logger.error("BUY | tetap gagal setelah ulang")
                 return
             msg_kb = hit2
+            logger.info("UI  | BUY ditemukan setelah ulang")
 
     await asyncio.sleep(1.0)
     await click_retry_until_gone(msg_kb, baseline_id=baseline_id)
-    print("[SUCCESS] Buy flow selesai")
+    logger.info("DONE| buy_flow selesai untuk CA=%s", addr)
 
 # ======== ACCEPT / QUEUE ========
 def _accept_ca(addr: str) -> bool:
     if not addr:
         return False
     if _is_recent(addr):
-        print(f"[SKIP] CA {addr} sudah diproses baru-baru ini")
+        logger.info("SKIP| CA %s sudah diproses baru-baru ini", addr)
         return False
     _mark_ca(addr)
     return True
@@ -248,19 +276,19 @@ def _accept_ca(addr: str) -> bool:
 @client.on(events.NewMessage(chats=_normalize_chat(SOURCE_CHAT)))
 async def on_message_from_source(event: events.NewMessage.Event):
     txt = (event.raw_text or "").strip()
-    print(f"[EVENT] Pesan baru dari source (len={len(txt)})")
+    logger.info("EVNT| pesan baru (len=%d)", len(txt))
 
     if not has_valid_tier(txt):
         return
 
     found = find_first_ca(txt)
     if not found:
-        print("[INFO] Tidak ada CA ditemukan di pesan ini")
+        logger.info("INFO| tidak ada CA di pesan ini")
         return
     _, addr = found
     if _accept_ca(addr):
-        print(f"[QUEUE] Tambah CA {addr} ke antrean")
         await ca_queue.put(addr)
+        logger.info("QUEUE| enqueue CA %s", addr)
 
 # ======== LIFECYCLE ========
 async def _worker():
@@ -269,18 +297,19 @@ async def _worker():
         try:
             await buy_flow_with_ca(addr)
         except FloodWaitError as fw:
-            print(f"[ERROR] FloodWait, tidur {fw.seconds} detik")
+            logger.error("ERR | FloodWait %ss → tidur", fw.seconds)
             await asyncio.sleep(fw.seconds + 2)
         except Exception as e:
-            print(f"[ERROR] Exception worker: {e}")
+            logger.exception("ERR | Exception di worker: %s", e)
         finally:
             ca_queue.task_done()
 
 async def start_bot_background():
-    print("[START] Menjalankan bot...")
+    logger.info("BOOT| starting bot (source=%s, target=%s, tier_min=%s, log=%s)",
+                SOURCE_CHAT, TARGET_CHAT, TIER_MIN, LOG_LEVEL)
     await client.start()
     asyncio.create_task(_worker())
 
 async def stop_bot():
-    print("[STOP] Memutus koneksi bot...")
+    logger.info("BOOT| stopping bot…")
     await client.disconnect()