update

Dockerfile

@@ -0,0 +1,14 @@
+FROM python:3.11-slim
+
+WORKDIR /app
+
+COPY requirements.txt .
+
+RUN pip install --no-cache-dir -r requirements.txt
+
+COPY . .
+
+ENV PORT=7860
+EXPOSE 7860
+
+CMD ["python", "app.py"]=

README.md

@@ -3,9 +3,8 @@ title: SMS OTP Bot
 emoji: 🤖
 colorFrom: blue
 colorTo: green
-sdk: gradio
+sdk: docker
 sdk_version: 4.31.0
-app_file: app.py
 pinned: false
 license: apache-2.0
 short_description: Bot Telegram untuk forward OTP dari panel SMS

app.py

@@ -1,318 +1,912 @@
 import httpx
 from bs4 import BeautifulSoup
 import re
-from datetime import datetime, timedelta
+from datetime import datetime, timedelta, timezone
 import time
-import threading
-import gradio as gr
+from flask import Flask, Response, request
+from threading import Thread
+from collections import deque
+import json
+import os
 
-# ================= CONFIG =================
 BASE = "http://159.69.3.189"
 LOGIN_URL = f"{BASE}/login"
 GET_RANGE_URL = f"{BASE}/portal/sms/received/getsms"
 GET_NUMBER_URL = f"{BASE}/portal/sms/received/getsms/number"
 GET_SMS_URL = f"{BASE}/portal/sms/received/getsms/number/sms"
 
-USERNAME = "rezaciledug35@gmail.com"
-PASSWORD = "Ciledug577"
+USERNAME = os.getenv("HF_USERNAME", "rezaciledug35@gmail.com")
+PASSWORD = os.getenv("HF_PASSWORD", "Ciledug577")
+BOT_TOKEN = os.getenv("BOT_TOKEN", "8458437657:AAGtvRh5dBdLIhONXN3rH1heDrgCSW-jyHQ")
+CHAT_ID = os.getenv("CHAT_ID", "-1003328735276")
+CUSTOM_DOMAIN = os.getenv("CUSTOM_DOMAIN", "https://fourstore-tele.hf.space")
 
-BOT_TOKEN = "8458437657:AAGtvRh5dBdLIhONXN3rH1heDrgCSW-jyHQ"
-CHAT_ID = "-1003328735276"
-
-session = httpx.Client(follow_redirects=True, timeout=30)
+session = httpx.Client(follow_redirects=True, timeout=30.0)
 sent_cache = set()
 csrf_token = None
-bot_running = False
-bot_thread = None
-log_messages = []
-# ==========================================
+LOGIN_SUCCESS = False
+
+sms_cache = {}
+sms_counter = {}
+range_counter = {}
+otp_logs = deque(maxlen=100)
+sse_clients = []
+
+def get_wib_time():
+    return datetime.now(timezone.utc) + timedelta(hours=7)
 
-# ================= DATE LOGIC =================
 def get_search_date():
-    now = datetime.now()
-    if now.hour < 7:
-        yesterday = now - timedelta(days=1)
-        return yesterday.strftime("%Y-%m-%d")
-    else:
-        return now.strftime("%Y-%m-%d")
+    wib = get_wib_time()
+    return (wib - timedelta(days=1)).strftime("%Y-%m-%d") if wib.hour < 7 else wib.strftime("%Y-%m-%d")
 
-# ================= TELEGRAM =================
-def tg_send(msg):
+def login():
+    global csrf_token, LOGIN_SUCCESS
+    try:
+        print("🔐 Login...")
+        r = session.get(LOGIN_URL, timeout=30)
+        soup = BeautifulSoup(r.text, "html.parser")
+        token = soup.find("input", {"name": "_token"})
+        if not token:
+            print("❌ Token tidak ditemukan!")
+            return False
+        csrf_token = token.get("value")
+        
+        r = session.post(LOGIN_URL, data={
+            "_token": csrf_token,
+            "email": USERNAME,
+            "password": PASSWORD
+        }, timeout=30)
+        
+        if "dashboard" in r.text.lower() or "logout" in r.text.lower():
+            LOGIN_SUCCESS = True
+            print("✅ Login BERHASIL!")
+            return True
+        else:
+            LOGIN_SUCCESS = False
+            print("❌ Login GAGAL!")
+            return False
+    except Exception as e:
+        LOGIN_SUCCESS = False
+        print(f"❌ Login Error: {e}")
+        return False
+
+def get_ranges_with_count():
+    try:
+        date = get_search_date()
+        r = session.post(GET_RANGE_URL, data={
+            "_token": csrf_token,
+            "from": date,
+            "to": date
+        }, timeout=15)
+        
+        soup = BeautifulSoup(r.text, "html.parser")
+        ranges_data = []
+        
+        for item in soup.select(".item"):
+            name_div = item.select_one(".col-sm-4")
+            if not name_div: continue
+            rng = name_div.get_text(strip=True)
+            
+            count_p = item.select_one(".col-3 .mb-0.pb-0")
+            count = int(count_p.get_text(strip=True)) if count_p else 0
+            
+            ranges_data.append({
+                "name": rng,
+                "count": count
+            })
+        
+        return ranges_data
+    except Exception as e:
+        return []
+
+def get_numbers_with_count(rng):
     try:
-        url = f"https://api.telegram.org/bot{BOT_TOKEN}/sendMessage"
-        session.post(url, data={
-            "chat_id": CHAT_ID,
-            "text": msg,
-            "parse_mode": "Markdown"
-        })
+        date = get_search_date()
+        r = session.post(GET_NUMBER_URL, data={
+            "_token": csrf_token,
+            "start": date,
+            "end": date,
+            "range": rng
+        }, timeout=15)
+        
+        soup = BeautifulSoup(r.text, "html.parser")
+        numbers_data = []
+        
+        for div in soup.find_all("div", onclick=True):
+            onclick = div.get("onclick", "")
+            if "getDetialsNumber" in onclick:
+                num = div.get_text(strip=True)
+                if num and num.isdigit() and len(num) > 5:
+                    parent = div.find_parent("div", class_="card")
+                    count = 0
+                    if parent:
+                        p_tag = parent.find("p", class_="mb-0 pb-0")
+                        if p_tag:
+                            count = int(p_tag.get_text(strip=True))
+                    
+                    numbers_data.append({
+                        "number": num,
+                        "count": count
+                    })
+        
+        return numbers_data
     except Exception as e:
-        add_log(f"[TELEGRAM ERROR] {e}")
+        return []
+
+def get_sms_fast(rng, number):
+    try:
+        date = get_search_date()
+        cache_key = f"{rng}-{number}"
+        
+        if cache_key in sms_cache:
+            timestamp, results = sms_cache[cache_key]
+            if time.time() - timestamp < 5:
+                return results
+        
+        parts = rng.split()
+        range_name = parts[0] + " " + parts[1] if len(parts) >= 2 else rng
+        
+        r = session.post(GET_SMS_URL, data={
+            "_token": csrf_token,
+            "start": date,
+            "end": date,
+            "Number": number,
+            "Range": range_name
+        }, timeout=20)
+        
+        soup = BeautifulSoup(r.text, "html.parser")
+        results = []
+        
+        for card in soup.select("div.card.card-body"):
+            try:
+                service = "UNKNOWN"
+                service_div = card.select_one("div.col-sm-4")
+                if service_div:
+                    raw = service_div.get_text(strip=True)
+                    service = map_service(raw)
+                
+                msg_p = card.find("p", class_="mb-0 pb-0")
+                if msg_p:
+                    sms = msg_p.get_text(strip=True)
+                    otp = extract_otp(sms)
+                    if otp:
+                        results.append((service, sms, otp))
+            except:
+                continue
+        
+        sms_cache[cache_key] = (time.time(), results)
+        return results
+    except:
+        return []
 
-# ================= UTIL =================
 def extract_otp(text):
-    m = re.search(r"\b(\d{3}[- ]?\d{3}|\d{4,6})\b", text)
-    return m.group(0) if m else None
+    if not text: return None
+    m = re.search(r"\b(\d{4,6})\b", text) 
+    if not m:
+        m = re.search(r"\b(\d{3}[- ]?\d{3})\b", text)
+    if m:
+        return m.group(0).replace("-", "").replace(" ", "")
+    return None
 
-def clean_country(rng: str) -> str:
-    return re.sub(r"\s*\d+$", "", rng).strip()
+def clean_country(rng):
+    return re.sub(r"\s*\d+$", "", rng).strip() if rng else "UNKNOWN"
 
-def mask_number(number: str) -> str:
+def mask_number(number):
+    if not number: return "UNKNOWN"
     clean = re.sub(r"[^\d+]", "", number)
-    if len(clean) <= 6:
-        return clean
-    start = clean[:5]
-    end = clean[-3:]
-    masked = "*" * (len(clean) - len(start) - len(end))
-    return f"{start}{masked}{end}"
-
-# ================= SERVICE MAPPING =================
-SERVICE_MAPPING = {
-    "WHATSAPP": ["whatsapp", "wa", "whatsapp business"],
-    "TELEGRAM": ["telegram"],
-    "GOOGLE": ["google", "gmail"],
-    "FACEBOOK": ["facebook", "fb"],
-    "INSTAGRAM": ["instagram", "ig"],
-    "TIKTOK": ["tiktok"],
-    "TWITTER": ["twitter", "x"],
-    "DISCORD": ["discord"],
-    "AMAZON": ["amazon", "aws"],
-}
+    if len(clean) <= 6: return clean
+    return f"{clean[:4]}****{clean[-3:]}"
 
-def map_service(raw_service: str) -> str:
-    if not raw_service:
-        return "UNKNOWN"
-    s = raw_service.lower().strip()
-    for service, keywords in SERVICE_MAPPING.items():
-        for k in keywords:
-            if k in s:
-                return service
-    return raw_service.upper()
+def map_service(raw):
+    if not raw: return "UNKNOWN"
+    s = raw.lower().strip()
+    if 'whatsapp' in s: return "WHATSAPP"
+    if 'telegram' in s: return "TELEGRAM"
+    if 'google' in s or 'gmail' in s: return "GOOGLE"
+    if 'facebook' in s or 'fb' in s: return "FACEBOOK"
+    if 'instagram' in s or 'ig' in s: return "INSTAGRAM"
+    if 'tiktok' in s: return "TIKTOK"
+    return raw.upper()
 
-# ================= LOGIN =================
-def login():
-    global csrf_token
+def tg_send(msg):
     try:
-        r = session.get(LOGIN_URL)
-        soup = BeautifulSoup(r.text, "html.parser")
-        csrf_token = soup.find("input", {"name": "_token"})["value"]
-        session.post(LOGIN_URL, data={
-            "_token": csrf_token,
-            "email": USERNAME,
-            "password": PASSWORD
-        })
-        add_log("[LOGIN] BERHASIL")
-        tg_send("✅ BOT AKTIF & LOGIN BERHASIL")
+        httpx.post(f"https://api.telegram.org/bot{BOT_TOKEN}/sendMessage",
+                  data={"chat_id": CHAT_ID, "text": msg, "parse_mode": "Markdown"},
+                  timeout=10)
         return True
-    except Exception as e:
-        add_log(f"[LOGIN ERROR] {e}")
+    except:
         return False
 
-# ================= GET RANGE =================
-def get_ranges():
-    date = get_search_date()
-    
-    r = session.post(GET_RANGE_URL, data={
-        "_token": csrf_token,
-        "from": date,
-        "to": date
-    })
-    
-    soup = BeautifulSoup(r.text, "html.parser")
-    ranges = []
-    for div in soup.find_all("div", onclick=True):
-        if "getDetials" in div["onclick"]:
-            ranges.append(div["onclick"].split("'")[1])
-    return ranges
+def add_otp_log(country, number, service, otp, sms):
+    wib = get_wib_time()
+    log_entry = {
+        "time": wib.strftime("%H:%M:%S"),
+        "country": country,
+        "number": number,
+        "service": service,
+        "otp": otp,
+        "sms": sms[:80] + "..." if len(sms) > 80 else sms
+    }
+    otp_logs.appendleft(log_entry)
+    broadcast_sse(log_entry)
+    return log_entry
 
-# ================= GET NUMBERS =================
-def get_numbers(rng):
-    date = get_search_date()
+def broadcast_sse(data):
+    msg = f"data: {json.dumps(data)}\n\n"
+    dead = []
+    for q in sse_clients:
+        try:
+            q.put(msg)
+        except:
+            dead.append(q)
+    for q in dead:
+        sse_clients.remove(q)
+
+app = Flask('')
+
+@app.route('/')
+def home():
+    wib = get_wib_time()
+    search_date = get_search_date()
     
-    r = session.post(GET_NUMBER_URL, data={
-        "_token": csrf_token,
-        "start": date,
-        "end": date,
-        "range": rng
-    })
+    search_query = request.args.get('q', '').lower()
+    filter_service = request.args.get('service', '')
     
-    soup = BeautifulSoup(r.text, "html.parser")
-    numbers = []
-    for div in soup.find_all("div", onclick=True):
-        if "getDetialsNumber" in div["onclick"]:
-            numbers.append(div["onclick"].split("'")[1])
-    return numbers
-
-# ================= GET SMS =================
-def get_sms(rng, number):
-    date = get_search_date()
+    filtered_logs = list(otp_logs)
+    if search_query:
+        filtered_logs = [log for log in filtered_logs if 
+                        search_query in log['country'].lower() or 
+                        search_query in log['number'].lower() or 
+                        search_query in log['otp'].lower() or 
+                        search_query in log['sms'].lower()]
     
-    r = session.post(GET_SMS_URL, data={
-        "_token": csrf_token,
-        "start": date,
-        "end": date,
-        "Number": number,
-        "Range": rng
-    })
+    if filter_service:
+        filtered_logs = [log for log in filtered_logs if log['service'] == filter_service]
     
-    soup = BeautifulSoup(r.text, "html.parser")
-    results = []
+    all_services = list(set([log['service'] for log in otp_logs]))
     
-    for card in soup.select("div.card.card-body"):
-        service = "UNKNOWN"
-        service_div = card.select_one("div.col-sm-4")
+    html = f"""
+    <!DOCTYPE html>
+    <html lang="en">
+    <head>
+        <meta charset="UTF-8">
+        <meta name="viewport" content="width=device-width, initial-scale=1.0">
+        <title>OTP DASHBOARD · SEARCH</title>
+        <link href="https://fonts.googleapis.com/css2?family=Inter:wght@400;500;600;700&display=swap" rel="stylesheet">
+        <style>
+            * {{
+                margin: 0;
+                padding: 0;
+                box-sizing: border-box;
+            }}
+            
+            body {{
+                font-family: 'Inter', -apple-system, BlinkMacSystemFont, sans-serif;
+                background: #0a0c10;
+                color: #e4e6eb;
+                padding: 24px;
+            }}
+            
+            .container {{
+                max-width: 1400px;
+                margin: 0 auto;
+            }}
+            
+            .header {{
+                background: linear-gradient(145deg, #1a1f2c, #0f131c);
+                border-radius: 24px;
+                padding: 28px;
+                margin-bottom: 28px;
+                border: 1px solid #2d3540;
+                box-shadow: 0 8px 20px rgba(0,0,0,0.4);
+            }}
+            
+            .header-top {{
+                display: flex;
+                justify-content: space-between;
+                align-items: center;
+                margin-bottom: 24px;
+            }}
+            
+            .title h1 {{
+                font-size: 28px;
+                font-weight: 700;
+                background: linear-gradient(135deg, #00f2fe, #4facfe);
+                -webkit-background-clip: text;
+                -webkit-text-fill-color: transparent;
+                margin-bottom: 6px;
+            }}
+            
+            .title p {{
+                color: #8b949e;
+                font-size: 14px;
+            }}
+            
+            .status-badge {{
+                padding: 10px 24px;
+                border-radius: 100px;
+                font-weight: 600;
+                font-size: 14px;
+                background: {'#0a4d3c' if LOGIN_SUCCESS else '#4a2c2c'};
+                color: {'#a0f0d0' if LOGIN_SUCCESS else '#ffb3b3'};
+                border: 1px solid {'#1a6e5a' if LOGIN_SUCCESS else '#6e3a3a'};
+            }}
+            
+            .stats-grid {{
+                display: grid;
+                grid-template-columns: repeat(4, 1fr);
+                gap: 20px;
+                margin-top: 20px;
+            }}
+            
+            .stat-card {{
+                background: #1a1f2c;
+                padding: 20px;
+                border-radius: 20px;
+                border: 1px solid #2d3540;
+            }}
+            
+            .stat-label {{
+                color: #8b949e;
+                font-size: 13px;
+                text-transform: uppercase;
+                letter-spacing: 0.5px;
+                margin-bottom: 8px;
+            }}
+            
+            .stat-value {{
+                font-size: 32px;
+                font-weight: 700;
+                color: #00f2fe;
+            }}
+            
+            .search-section {{
+                background: #0f131c;
+                border-radius: 20px;
+                padding: 20px;
+                margin-bottom: 24px;
+                border: 1px solid #2d3540;
+                display: flex;
+                gap: 16px;
+                align-items: center;
+                flex-wrap: wrap;
+            }}
+            
+            .search-box {{
+                flex: 2;
+                min-width: 280px;
+                position: relative;
+            }}
+            
+            .search-icon {{
+                position: absolute;
+                left: 16px;
+                top: 14px;
+                color: #8b949e;
+            }}
+            
+            .search-input {{
+                width: 100%;
+                padding: 14px 20px 14px 48px;
+                background: #1a1f2c;
+                border: 1px solid #2d3540;
+                border-radius: 100px;
+                color: #e4e6eb;
+                font-size: 15px;
+                transition: all 0.2s;
+            }}
+            
+            .search-input:focus {{
+                outline: none;
+                border-color: #00f2fe;
+                background: #1e2433;
+                box-shadow: 0 0 0 3px #00f2fe20;
+            }}
+            
+            .filter-box {{
+                flex: 1;
+                min-width: 180px;
+            }}
+            
+            .filter-select {{
+                width: 100%;
+                padding: 14px 20px;
+                background: #1a1f2c;
+                border: 1px solid #2d3540;
+                border-radius: 100px;
+                color: #e4e6eb;
+                font-size: 15px;
+                cursor: pointer;
+            }}
+            
+            .filter-select:focus {{
+                outline: none;
+                border-color: #00f2fe;
+            }}
+            
+            .clear-btn {{
+                padding: 14px 28px;
+                background: #2d3a4a;
+                border: none;
+                border-radius: 100px;
+                color: white;
+                font-size: 14px;
+                font-weight: 600;
+                cursor: pointer;
+                transition: all 0.2s;
+                text-decoration: none;
+                display: inline-block;
+            }}
+            
+            .clear-btn:hover {{
+                background: #3d4a5a;
+            }}
+            
+            .result-count {{
+                color: #8b949e;
+                font-size: 13px;
+                margin-left: 8px;
+            }}
+            
+            .otp-section {{
+                background: #0f131c;
+                border-radius: 24px;
+                padding: 28px;
+                border: 1px solid #2d3540;
+            }}
+            
+            .section-title {{
+                font-size: 18px;
+                font-weight: 600;
+                color: #e4e6eb;
+                margin-bottom: 20px;
+                display: flex;
+                align-items: center;
+                gap: 10px;
+            }}
+            
+            .section-title span {{
+                background: #00f2fe20;
+                padding: 6px 12px;
+                border-radius: 100px;
+                font-size: 12px;
+                color: #00f2fe;
+            }}
+            
+            table {{
+                width: 100%;
+                border-collapse: collapse;
+            }}
+            
+            th {{
+                text-align: left;
+                padding: 16px 12px;
+                background: #1a1f2c;
+                color: #00f2fe;
+                font-weight: 600;
+                font-size: 13px;
+                text-transform: uppercase;
+                letter-spacing: 0.5px;
+                border-bottom: 2px solid #2d3540;
+            }}
+            
+            td {{
+                padding: 16px 12px;
+                border-bottom: 1px solid #262c38;
+                font-size: 14px;
+            }}
+            
+            .otp-badge {{
+                background: #002b36;
+                color: #00f2fe;
+                font-family: 'Monaco', 'Menlo', monospace;
+                font-size: 16px;
+                font-weight: 700;
+                padding: 6px 14px;
+                border-radius: 100px;
+                border: 1px solid #00f2fe40;
+                display: inline-block;
+                user-select: all;
+                -webkit-user-select: all;
+                -moz-user-select: all;
+                cursor: pointer;
+                transition: all 0.2s;
+            }}
+            
+            .otp-badge:hover {{
+                background: #003d4a;
+                border-color: #00f2fe;
+                transform: scale(1.05);
+            }}
+            
+            .service-badge {{
+                background: #2d3a4a;
+                padding: 6px 14px;
+                border-radius: 100px;
+                font-size: 12px;
+                font-weight: 600;
+                color: #e4e6eb;
+                display: inline-block;
+            }}
+            
+            .service-badge.whatsapp {{ background: #25D36620; color: #25D366; border: 1px solid #25D36640; }}
+            .service-badge.telegram {{ background: #26A5E420; color: #26A5E4; border: 1px solid #26A5E440; }}
+            .service-badge.google {{ background: #EA433520; color: #EA4335; border: 1px solid #EA433540; }}
+            .service-badge.facebook {{ background: #4267B220; color: #4267B2; border: 1px solid #4267B240; }}
+            .service-badge.instagram {{ background: #E4405F20; color: #E4405F; border: 1px solid #E4405F40; }}
+            .service-badge.tiktok {{ background: #00000020; color: #ffffff; border: 1px solid #ffffff40; }}
+            
+            .number {{
+                font-family: 'Monaco', 'Menlo', monospace;
+                color: #e4e6eb;
+            }}
+            
+            .empty-state {{
+                text-align: center;
+                padding: 60px;
+                color: #8b949e;
+            }}
+            
+            .empty-state h3 {{
+                font-size: 20px;
+                margin-bottom: 12px;
+                color: #b1bac4;
+            }}
+            
+            .highlight {{
+                background: #00f2fe30;
+                border-radius: 4px;
+                padding: 0 2px;
+            }}
+            
+            @keyframes fadeIn {{
+                from {{ opacity: 0; transform: translateY(-10px); }}
+                to {{ opacity: 1; transform: translateY(0); }}
+            }}
+            
+            .new-row {{
+                animation: fadeIn 0.3s ease;
+                background: linear-gradient(90deg, #00f2fe10, transparent);
+            }}
+            
+            .toast {{
+                position: fixed;
+                bottom: 24px;
+                right: 24px;
+                background: #00f2fe;
+                color: #000;
+                padding: 14px 28px;
+                border-radius: 100px;
+                font-weight: 600;
+                animation: slideIn 0.3s ease;
+                z-index: 9999;
+                box-shadow: 0 8px 20px rgba(0,242,254,0.3);
+            }}
+            
+            @keyframes slideIn {{
+                from {{ opacity: 0; transform: translateX(30px); }}
+                to {{ opacity: 1; transform: translateX(0); }}
+            }}
+        </style>
+    </head>
+    <body>
+        <div class="container">
+            <div class="header">
+                <div class="header-top">
+                    <div class="title">
+                        <h1>OTP MONITOR · SEARCH</h1>
+                        <p>{CUSTOM_DOMAIN}</p>
+                    </div>
+                    <div class="status-badge">
+                        {'● ONLINE' if LOGIN_SUCCESS else '○ OFFLINE'}
+                    </div>
+                </div>
+                
+                <div class="stats-grid">
+                    <div class="stat-card">
+                        <div class="stat-label">Total OTP</div>
+                        <div class="stat-value" id="total-otp">{len(sent_cache)}</div>
+                    </div>
+                    <div class="stat-card">
+                        <div class="stat-label">Today</div>
+                        <div class="stat-value" id="today-otp">{len(otp_logs)}</div>
+                    </div>
+                    <div class="stat-card">
+                        <div class="stat-label">WIB</div>
+                        <div class="stat-value" id="wib-time">{wib.strftime('%H:%M:%S')}</div>
+                    </div>
+                    <div class="stat-card">
+                        <div class="stat-label">Date</div>
+                        <div class="stat-value">{search_date}</div>
+                    </div>
+                </div>
+            </div>
+            
+            <div class="search-section">
+                <div class="search-box">
+                    <span class="search-icon">🔍</span>
+                    <form action="/" method="get" style="margin: 0;" id="searchForm">
+                        <input type="text" 
+                               class="search-input" 
+                               name="q" 
+                               placeholder="Cari negara, nomor, OTP, atau SMS..." 
+                               value="{request.args.get('q', '')}"
+                               autocomplete="off">
+                    </form>
+                </div>
+                
+                <div class="filter-box">
+                    <select class="filter-select" name="service" onchange="window.location.href='/?' + (document.getElementById('searchForm').q.value ? 'q=' + document.getElementById('searchForm').q.value + '&' : '') + 'service=' + this.value">
+                        <option value="">📋 Semua Service</option>
+                        {''.join([f'<option value="{s}" {"selected" if filter_service == s else ""}>📱 {s}</option>' for s in sorted(all_services)])}
+                    </select>
+                </div>
+                
+                <a href="/" class="clear-btn">✕ Clear</a>
+                
+                <span class="result-count">📊 {len(filtered_logs)} results</span>
+            </div>
+            
+            <div class="otp-section">
+                <div class="section-title">
+                    📨 OTP TERBARU
+                    <span>LIVE</span>
+                </div>
+                
+                <div style="overflow-x: auto;">
+                    <table>
+                        <thead>
+                            <tr>
+                                <th>WIB</th>
+                                <th>Country</th>
+                                <th>Number</th>
+                                <th>Service</th>
+                                <th>OTP</th>
+                                <th>Message</th>
+                            </tr>
+                        </thead>
+                        <tbody id="otp-table-body">
+                            {generate_filtered_rows(filtered_logs, search_query)}
+                        </tbody>
+                    </table>
+                </div>
+            </div>
+        </div>
         
-        if service_div:
-            span = service_div.find("span")
-            raw = service_div.get_text(strip=True)
-            if span:
-                raw = raw.replace(span.get_text(strip=True), "").strip()
-            service = map_service(raw)
+        <script>
+            let eventSource;
+            
+            function connectSSE() {{
+                eventSource = new EventSource('/stream');
+                
+                eventSource.onmessage = function(e) {{
+                    try {{
+                        const data = JSON.parse(e.data);
+                        if (data.otp) {{
+                            addRow(data);
+                            updateStats();
+                        }}
+                    }} catch (err) {{
+                        console.error('SSE Error:', err);
+                    }}
+                }};
+                
+                eventSource.onerror = function() {{
+                    setTimeout(connectSSE, 3000);
+                }};
+            }}
+            
+            function addRow(data) {{
+                const tbody = document.getElementById('otp-table-body');
+                
+                if (tbody.children.length === 1 && tbody.children[0].innerHTML.includes('Belum ada OTP')) {{
+                    tbody.innerHTML = '';
+                }}
+                
+                const row = tbody.insertRow(0);
+                row.className = 'new-row';
+                
+                const serviceClass = data.service.toLowerCase().replace(' ', '');
+                
+                row.innerHTML = `
+                    <td style="color: #00f2fe;">${{data.time}}</td>
+                    <td>${{data.country}}</td>
+                    <td><span class="number">${{data.number}}</span></td>
+                    <td><span class="service-badge ${{serviceClass}}">${{data.service}}</span></td>
+                    <td><span class="otp-badge" onclick="copyOTP('${{data.otp}}')">${{data.otp}}</span></td>
+                    <td><div style="max-width: 350px; overflow: hidden; text-overflow: ellipsis;" title="${{data.sms}}">${{data.sms}}</div></td>
+                `;
+                
+                while (tbody.children.length > 50) {{
+                    tbody.removeChild(tbody.lastChild);
+                }}
+            }}
+            
+            function copyOTP(otp) {{
+                navigator.clipboard.writeText(otp).then(() => {{
+                    const toast = document.createElement('div');
+                    toast.className = 'toast';
+                    toast.textContent = '✅ OTP copied!';
+                    document.body.appendChild(toast);
+                    setTimeout(() => toast.remove(), 2000);
+                }});
+            }}
+            
+            function updateStats() {{
+                const totalEl = document.getElementById('total-otp');
+                const todayEl = document.getElementById('today-otp');
+                
+                if (totalEl) {{
+                    totalEl.textContent = parseInt(totalEl.textContent || 0) + 1;
+                }}
+                if (todayEl) {{
+                    todayEl.textContent = parseInt(todayEl.textContent || 0) + 1;
+                }}
+            }}
+            
+            function updateTime() {{
+                const now = new Date();
+                now.setHours(now.getHours() + 7);
+                const timeStr = now.toISOString().substr(11, 8);
+                const wibEl = document.getElementById('wib-time');
+                if (wibEl) wibEl.textContent = timeStr;
+            }}
+            
+            document.querySelector('.search-input')?.addEventListener('keypress', function(e) {{
+                if (e.key === 'Enter') {{
+                    document.getElementById('searchForm').submit();
+                }}
+            }});
+            
+            connectSSE();
+            setInterval(updateTime, 1000);
+        </script>
+    </body>
+    </html>
+    """
+    return html
+
+def generate_filtered_rows(filtered_logs, search_query=""):
+    if not filtered_logs:
+        return '''
+        <tr>
+            <td colspan="6" class="empty-state">
+                <h3>🔍 Tidak ada hasil</h3>
+                <p>Coba kata kunci lain atau reset filter</p>
+            </td>
+        </tr>
+        '''
+    
+    rows = ""
+    for entry in filtered_logs[:50]:
+        country = entry["country"]
+        number = entry["number"]
+        otp = entry["otp"]
+        sms = entry["sms"]
         
-        msg_p = card.find("p")
-        sms = msg_p.get_text(strip=True) if msg_p else ""
+        if search_query:
+            country = re.sub(f'({re.escape(search_query)})', r'<span class="highlight">\1</span>', country, flags=re.I)
+            number = re.sub(f'({re.escape(search_query)})', r'<span class="highlight">\1</span>', number, flags=re.I)
+            otp = re.sub(f'({re.escape(search_query)})', r'<span class="highlight">\1</span>', otp, flags=re.I)
+            sms = re.sub(f'({re.escape(search_query)})', r'<span class="highlight">\1</span>', sms, flags=re.I)
         
-        results.append((service, sms))
-    
-    return results
+        service_class = entry["service"].lower().replace(' ', '')
+        
+        rows += f'''
+        <tr>
+            <td style="color: #00f2fe;">{entry["time"]}</td>
+            <td>{country}</td>
+            <td><span class="number">{number}</span></td>
+            <td><span class="service-badge {service_class}">{entry["service"]}</span></td>
+            <td><span class="otp-badge" onclick="copyOTP('{entry["otp"]}')">{otp}</span></td>
+            <td><div style="max-width: 350px; overflow: hidden; text-overflow: ellipsis;" title="{entry["sms"]}">{sms}</div></td>
+        </tr>
+        '''
+    return rows
+
+@app.route('/stream')
+def stream():
+    def generate():
+        q = Queue()
+        sse_clients.append(q)
+        try:
+            while True:
+                yield q.get()
+        except:
+            if q in sse_clients:
+                sse_clients.remove(q)
+    return Response(generate(), mimetype="text/event-stream")
 
-# ================= LOGGING =================
-def add_log(msg):
-    timestamp = datetime.now().strftime("%Y-%m-%d %H:%M:%S")
-    log_entry = f"[{timestamp}] {msg}"
-    log_messages.append(log_entry)
-    if len(log_messages) > 100:
-        log_messages.pop(0)
-    print(log_entry)
+from queue import Queue
+def run_server():
+    app.run(host='0.0.0.0', port=7860, debug=False, threaded=True)
 
-def get_logs():
-    return "\n".join(log_messages)
+Thread(target=run_server, daemon=True).start()
 
-# ================= BOT LOOP =================
-def bot_worker():
-    global bot_running, csrf_token, sent_cache
+def main():
+    print("\n" + "="*60)
+    print("  🔥 OTP BOT - RANGE FOCUS MODE")
+    print("  ⚡ HANYA FOKUS KE RANGE YANG BERUBAH")
+    print("  🔍 DASHBOARD DENGAN SEARCH & FILTER")
+    print("="*60 + "\n")
     
-    add_log("🤖 Memulai bot...")
+    for i in range(5):
+        if login():
+            break
+        time.sleep(3)
     
-    if not login():
-        add_log("❌ Login gagal, bot berhenti")
-        bot_running = False
-        return
+    last_cleanup = time.time()
     
-    while bot_running:
+    while True:
         try:
-            ranges = get_ranges()
-            add_log(f"📊 Mendapatkan {len(ranges)} range")
+            if not LOGIN_SUCCESS or not csrf_token:
+                login()
+                time.sleep(2)
+                continue
             
-            for rng in ranges:
-                if not bot_running:
-                    break
-                    
-                country = clean_country(rng)
-                numbers = get_numbers(rng)
+            if time.time() - last_cleanup > 300:
+                sms_cache.clear()
+                sms_counter.clear()
+                range_counter.clear()
+                print("🧹 Cache cleared")
+                last_cleanup = time.time()
+            
+            ranges_data = get_ranges_with_count()
+            print(f"\n📡 Scan {len(ranges_data)} ranges...")
+            
+            for range_item in ranges_data:
+                rng = range_item["name"]
+                current_count = range_item["count"]
+                prev_count = range_counter.get(rng, 0)
                 
-                for num in numbers:
-                    if not bot_running:
-                        break
-                        
-                    masked_num = mask_number(num)
+                if current_count > prev_count:
+                    country = clean_country(rng)
+                    print(f"\n🔥 RANGE BERUBAH: {country}")
+                    print(f"   📊 {prev_count} → {current_count} SMS")
+                    range_counter[rng] = current_count
                     
-                    for service, sms in get_sms(rng, num):
-                        otp = extract_otp(sms)
-                        sms_id = f"{rng}-{num}-{sms[:50]}"
-                        
-                        if sms_id in sent_cache:
-                            continue
+                    numbers_data = get_numbers_with_count(rng)
+                    print(f"   📞 Scan {len(numbers_data)} nomor...")
+                    
+                    for number_item in numbers_data:
+                        num = number_item["number"]
+                        num_count = number_item["count"]
+                        key = f"{rng}-{num}"
+                        prev_num_count = sms_counter.get(key, 0)
                         
-                        if otp:
-                            msg = (
-                                f"🔔 *NEW OTP RECEIVED!*\n\n"
-                                f"🌍 *Country* : {country}\n"
-                                f"📞 *Number* : {masked_num}\n"
-                                f"💬 *Service* : {service}\n"
-                                f"🔐 *OTP Code* : `{otp}`\n\n"
-                                f"✉️ *Message* :\n"
-                                f"```\n{sms[:200]}\n```"
-                            )
+                        if num_count > prev_num_count:
+                            print(f"   📱 Nomor: {mask_number(num)}")
+                            print(f"      📨 {prev_num_count} → {num_count} SMS")
+                            sms_counter[key] = num_count
+                            
+                            all_sms = get_sms_fast(rng, num)
+                            new_sms = all_sms[prev_num_count:]
                             
-                            tg_send(msg)
-                            sent_cache.add(sms_id)
-                            add_log(f"✅ SENT | {country} | {masked_num} | {service} | {otp}")
+                            for service, sms, otp in new_sms:
+                                if otp:
+                                    sms_id = f"{rng}-{num}-{otp}"
+                                    if sms_id not in sent_cache:
+                                        masked = mask_number(num)
+                                        
+                                        msg = f"🔔 *NEW OTP*\n🌍 {country}\n📞 `{masked}`\n💬 {service}\n🔐 `{otp}`\n\n{sms[:300]}"
+                                        
+                                        if tg_send(msg):
+                                            sent_cache.add(sms_id)
+                                            add_otp_log(country, masked, service, otp, sms)
+                                            print(f"      ✅ OTP: {otp} - {service}")
+                    
+                    print(f"   ✅ Selesai proses {country}")
+                    time.sleep(0.5)
             
-            time.sleep(5)
+            print("\n⏳ Tidur 2 detik...")
+            time.sleep(2)
             
         except Exception as e:
-            add_log(f"[ERROR] {e}")
-            time.sleep(5)
-    
-    add_log("🛑 Bot berhenti")
+            print(f"❌ Error: {e}")
+            time.sleep(3)
 
-# ================= BOT CONTROL =================
-def start_bot():
-    global bot_running, bot_thread, sent_cache
-    
-    if bot_running:
-        return "⚠️ Bot sudah berjalan!"
-    
-    bot_running = True
-    sent_cache = set()
-    bot_thread = threading.Thread(target=bot_worker, daemon=True)
-    bot_thread.start()
-    
-    return "✅ Bot dimulai!"
-
-def stop_bot():
-    global bot_running
-    
-    if not bot_running:
-        return "⚠️ Bot tidak berjalan!"
-    
-    bot_running = False
-    add_log("⏹️ Menghentikan bot...")
-    
-    return "🛑 Bot dihentikan!"
-
-def clear_cache():
-    global sent_cache
-    count = len(sent_cache)
-    sent_cache.clear()
-    return f"🧹 Cache dibersihkan! {count} entry dihapus."
-
-def get_status():
-    status = "🟢 BERJALAN" if bot_running else "🔴 BERHENTI"
-    return f"Status Bot: {status}\nCache Size: {len(sent_cache)}"
-
-# ================= GRADIO INTERFACE =================
-with gr.Blocks(title="SMS OTP Bot", theme=gr.themes.Soft()) as demo:
-    gr.Markdown("# 🤖 SMS OTP Telegram Bot")
-    gr.Markdown(f"Bot akan mengirim OTP ke Telegram Channel")
-    
-    with gr.Row():
-        with gr.Column(scale=1):
-            start_btn = gr.Button("▶️ Start Bot", variant="primary")
-            stop_btn = gr.Button("⏹️ Stop Bot", variant="stop")
-            clear_btn = gr.Button("🧹 Clear Cache")
-            status_btn = gr.Button("📊 Status")
-            
-        with gr.Column(scale=2):
-            status_output = gr.Textbox(label="Status", value="🔴 BERHENTI", lines=2)
-            log_output = gr.Textbox(label="Log Activity", value="", lines=15, max_lines=20)
-    
-    # Events
-    start_btn.click(start_bot, outputs=status_output).then(
-        lambda: get_logs(), outputs=log_output
-    )
-    
-    stop_btn.click(stop_bot, outputs=status_output).then(
-        lambda: get_logs(), outputs=log_output
-    )
-    
-    clear_btn.click(clear_cache, outputs=status_output)
-    
-    status_btn.click(get_status, outputs=status_output)
-    
-    # Auto refresh logs
-    demo.load(lambda: get_logs(), outputs=log_output, every=2)
-
-# ================= MAIN =================
 if __name__ == "__main__":
-    demo.launch()
+    try:
+        main()
+    except KeyboardInterrupt:
+        print("\n🛑 BOT STOPPED")

requirement.txt

@@ -1,3 +1,4 @@
-httpx
-beautifulsoup4
-gradio
+flask==2.3.3
+httpx==0.25.2
+beautifulsoup4==4.12.2
+gunicorn==21.2.0