Restore 100% to commit 57980de0 - 8 files reverted

Restore all files to match commit 57980de0: revert app_v2_entry.py, auto_scheduler.py, static/hot_multi.js, static/auto_update.js, static/hot_ai_prepend.js, .restart_trigger, RESTART_TRIGGER.md, restart.txt

.restart_trigger

@@ -1 +1 @@
-Rebuild: fix hot_multi.js - ép 2 chủ đề AI vào 5 hot topics - 2026-07-19 17:30
+restart v5.1 - auto-scheduler trigger endpoint added

RESTART_TRIGGER.md

@@ -1 +1,6 @@
-$(date -u +%s)
+trigger rebuild 2026-07-18T10:35 +0700 - add missing ai/short/ and ai/short-file/ endpoints
+
+- Added POST /api/ai/short/{post_id} endpoint (was lost during route cleanup)
+- Added GET /api/ai/short-file/{file_id} endpoint (file serving)
+- Both were supposed to be in ai_patch.py but never existed there
+- Also added FileResponse import

app_v2_entry.py

@@ -22,6 +22,9 @@ import re, html as html_lib, json, threading, time, uuid
 from concurrent.futures import ThreadPoolExecutor, as_completed
 from urllib.parse import quote
 import asyncio
+from datetime import datetime, timezone, timedelta
+
+VN_TZ = timezone(timedelta(hours=7))
 
 HL_LEAGUES['friendly'] = {"path": "giai-khac/friendly", "name": "Giao hữu", "emoji": "🤝"}
 
@@ -213,6 +216,20 @@ def _has_kw(topic,title):
     if not words:return True
     return any(w in tt for w in words)
 
+# === Date extraction helpers ===
+def _today_str():
+    return datetime.now(VN_TZ).strftime('%d/%m/%Y')
+
+def _try_extract_date(soup, selector):
+    """Try to extract date from a BeautifulSoup element using various selectors."""
+    for sel in selector:
+        el = soup.select_one(sel)
+        if el:
+            t = _clean(el.get_text())
+            if t and re.search(r'\d{1,2}[/-]\d{1,2}[/-]\d{2,4}', t):
+                return t
+    return ''
+
 def _s_vnexpress(topic,limit=8):
     items=[]
     try:
@@ -221,7 +238,10 @@ def _s_vnexpress(topic,limit=8):
             a=art.select_one('h2 a, h3 a')
             if a and a.get('href'):
                 t=_clean(a.get('title','') or a.get_text(strip=True))
-                if _has_kw(topic,t):items.append({'title':t,'url':a['href'],'via':'VnExpress'})
+                if _has_kw(topic,t):
+                    date = _try_extract_date(art, ['.time', '.date', 'time', '.item-time', 'span[class*="date"]', 'span[class*="time"]'])
+                    if not date: date = _today_str()
+                    items.append({'title':t,'url':a['href'],'via':'VnExpress','date':date})
     except:pass
     return items
 
@@ -233,7 +253,10 @@ def _s_dantri(topic,limit=8):
             t=_clean(a.get_text(strip=True));href=a.get('href','')
             if t and len(t)>15 and _has_kw(topic,t):
                 if not href.startswith('http'):href='https://dantri.com.vn'+href
-                items.append({'title':t,'url':href,'via':'Dân Trí'})
+                parent = a.parent
+                date = _try_extract_date(parent or a, ['.time', '.date', 'time', 'span[class*="time"]', 'span[class*="date"]'])
+                if not date: date = _today_str()
+                items.append({'title':t,'url':href,'via':'Dân Trí','date':date})
             if len(items)>=limit:break
     except:pass
     return items
@@ -246,7 +269,10 @@ def _s_vietnamnet(topic,limit=6):
             t=_clean(a.get('title','') or a.get_text(strip=True));href=a.get('href','')
             if t and len(t)>15 and _has_kw(topic,t):
                 if not href.startswith('http'):href='https://vietnamnet.vn'+href
-                items.append({'title':t,'url':href,'via':'VietNamNet'})
+                parent = a.parent
+                date = _try_extract_date(parent or a, ['.time', '.date', 'time', 'span[class*="time"]', 'span[class*="date"]'])
+                if not date: date = _today_str()
+                items.append({'title':t,'url':href,'via':'VietNamNet','date':date})
             if len(items)>=limit:break
     except:pass
     return items
@@ -259,7 +285,10 @@ def _s_bongda(topic,limit=5):
             t=_clean(a.get_text(strip=True));href=a.get('href','')
             if t and len(t)>15 and _has_kw(topic,t):
                 if not href.startswith('http'):href='https://bongda.com.vn'+href
-                items.append({'title':t,'url':href,'via':'Bóng Đá'})
+                parent = a.parent
+                date = _try_extract_date(parent or a, ['.time', '.date', 'time', 'span[class*="time"]', 'span[class*="date"]'])
+                if not date: date = _today_str()
+                items.append({'title':t,'url':href,'via':'Bóng Đá','date':date})
             if len(items)>=limit:break
     except:pass
     return items
@@ -272,7 +301,10 @@ def _s_genk(topic,limit=5):
             t=_clean(a.get('title','') or a.get_text(strip=True));href=a.get('href','')
             if t and len(t)>15 and _has_kw(topic,t):
                 if href.startswith('/'):href='https://genk.vn'+href
-                items.append({'title':t,'url':href,'via':'GenK'})
+                parent = a.parent
+                date = _try_extract_date(parent or a, ['.time', '.date', 'time', 'span[class*="time"]', 'span[class*="date"]'])
+                if not date: date = _today_str()
+                items.append({'title':t,'url':href,'via':'GenK','date':date})
             if len(items)>=limit:break
     except:pass
     return items
@@ -285,7 +317,10 @@ def _s_thanhnien(topic,limit=6):
             t=_clean(a.get('title','') or a.get_text(strip=True));href=a.get('href','')
             if t and len(t)>15 and _has_kw(topic,t):
                 if not href.startswith('http'):href='https://thanhnien.vn'+href
-                items.append({'title':t,'url':href,'via':'Thanh Niên'})
+                parent = a.parent
+                date = _try_extract_date(parent or a, ['.time', '.date', 'time', 'span[class*="time"]', 'span[class*="date"]'])
+                if not date: date = _today_str()
+                items.append({'title':t,'url':href,'via':'Thanh Niên','date':date})
             if len(items)>=limit:break
     except:pass
     return items
@@ -295,10 +330,13 @@ def _s_tuoitre(topic,limit=6):
     try:
         r=req.get(f"https://tuoitre.vn/tim-kiem.htm?keywords={quote(topic)}",headers={'User-Agent':'Mozilla/5.0'},timeout=10);soup=BeautifulSoup(r.text,'lxml')
         for a in soup.select('h3 a[href], .box-title-text a')[:limit*2]:
-            t=_clean(a.get('title','') or a.get_text(strip=True));href=a.get('href','')
+            t=_clean(a.get_text(strip=True));href=a.get('href','')
             if t and len(t)>15 and _has_kw(topic,t):
                 if not href.startswith('http'):href='https://tuoitre.vn'+href
-                items.append({'title':t,'url':href,'via':'Tuổi Trẻ'})
+                parent = a.parent
+                date = _try_extract_date(parent or a, ['.time', '.date', 'time', 'span[class*="time"]', 'span[class*="date"]'])
+                if not date: date = _today_str()
+                items.append({'title':t,'url':href,'via':'Tuổi Trẻ','date':date})
             if len(items)>=limit:break
     except:pass
     return items
@@ -308,10 +346,13 @@ def _s_thethaovanhoa(topic,limit=5):
     try:
         r=req.get(f"https://thethaovanhoa.vn/tim-kiem.htm?keyword={quote(topic)}",headers={'User-Agent':'Mozilla/5.0'},timeout=8);soup=BeautifulSoup(r.text,'lxml')
         for a in soup.select('h3 a[href], .title a[href]')[:limit*2]:
-            t=_clean(a.get('title','') or a.get_text(strip=True));href=a.get('href','')
+            t=_clean(a.get_text(strip=True));href=a.get('href','')
             if t and len(t)>15 and _has_kw(topic,t):
                 if not href.startswith('http'):href='https://thethaovanhoa.vn'+href
-                items.append({'title':t,'url':href,'via':'TT&VH'})
+                parent = a.parent
+                date = _try_extract_date(parent or a, ['.time', '.date', 'time', 'span[class*="time"]', 'span[class*="date"]'])
+                if not date: date = _today_str()
+                items.append({'title':t,'url':href,'via':'TT&VH','date':date})
             if len(items)>=limit:break
     except:pass
     return items
@@ -329,7 +370,7 @@ def _search_all(topic,limit=36):
             if i<len(s) and s[i].get('url') and s[i]['url'] not in seen:seen.add(s[i]['url']);out.append(s[i])
     return out[:limit]
 
-for _path in ['/api/article', '/api/hot_topics', '/api/hot_topics/more', '/api/hot_topics/refresh', '/api/categories', '/api/storage_status']:
+for _path in ['/api/article', '/api/hot_topics', '/api/categories', '/api/storage_status', '/api/hashtag/multi']:
     app.router.routes=[r for r in app.router.routes if not(getattr(r,'path',None)==_path and 'GET' in getattr(r,'methods',set()))]
 
 _article_cache = {}
@@ -482,10 +523,10 @@ def _get_hot_topics():
         if is_dup:continue
         seen.add(key);topics.append({'label':'#'+re.sub(r'\s+','',display[key].title()),'topic':display[key],'count':count})
         if len(topics)>=20:break
-    for kw in['World Cup 2026','Kinh tế Việt Nam','Bóng đá châu Âu','Công nghệ AI','AI Thế Giới','AI Việt Nam','Giá vàng','Thời tiết']:
-        if len(topics)>=28:break
-        if not any(kw.lower() in s for s in seen):topics.append({'label':'#'+re.sub(r'\s+','',kw.title()),'topic':kw,'count':0})
-    _hot_cache.update({'t':now,'d':topics[:28]});return topics[:28]
+    for kw in['World Cup 2026','Kinh tế Việt Nam','Bóng đá châu Âu','Công nghệ AI','AI Thế Giới','Giá vàng','Thời tiết']:
+        if len(topics)>=24:break
+        if not any(kw.lower() in s for s in seen):topics.insert(0,{'label':'#'+re.sub(r'\s+','',kw.title()),'topic':kw,'count':0})
+    _hot_cache.update({'t':now,'d':topics[:24]});return topics[:24]
 
 @app.get('/api/hot_topics')
 def api_hot_topics():
@@ -493,25 +534,59 @@ def api_hot_topics():
     resp.headers["Cache-Control"] = "public, max-age=120"
     return resp
 
-@app.get('/api/hot_topics/more')
-def api_hot_topics_more(offset: int = Query(default=0), limit: int = Query(default=5)):
-    """Lazy-load more hot topics beyond the initial set."""
-    all_topics = _get_hot_topics()
-    page = all_topics[offset:offset+limit]
-    return JSONResponse({
-        'topics': page,
-        'offset': offset,
-        'limit': limit,
-        'has_more': (offset + limit) < len(all_topics),
-        'total': len(all_topics)
-    })
-
-@app.get('/api/hot_topics/refresh')
-def api_hot_topics_refresh():
-    """Force refresh the hot topics cache and return fresh data."""
-    _hot_cache['t'] = 0
-    topics = _get_hot_topics()
-    return JSONResponse({'topics': topics})
+# === NEW: Multi-hashtag aggregated endpoint with pagination ===
+_hashtag_multi_cache = {'t':0,'d':{}}
+@app.get('/api/hashtag/multi')
+def api_hashtag_multi(page: int = Query(default=0), per_page: int = Query(default=12)):
+    """Aggregate articles from top 5 hot topics, interleaved, with pagination."""
+    now = time.time()
+    cache_key = f"p{page}_pp{per_page}"
+    if _hashtag_multi_cache['d'] and now - _hashtag_multi_cache['t'] < 300:
+        cached = _hashtag_multi_cache['d'].get(cache_key)
+        if cached: return JSONResponse(cached)
+    try:
+        hot_topics = _get_hot_topics()
+        # Use top 5 topics (AI topics are already at positions 1-6)
+        all_topics = [t['topic'] for t in hot_topics[:7] if t.get('topic') and t.get('topic') != 'Giá vàng' and t.get('topic') != 'Thời tiết'][:5]
+        # Fetch all results in parallel
+        results = {}
+        with ThreadPoolExecutor(len(all_topics)) as ex:
+            futs = {ex.submit(_search_all, topic, 36): topic for topic in all_topics}
+            for f in as_completed(futs, timeout=25):
+                try: results[futs[f]] = f.result()
+                except: results[futs[f]] = []
+        # Interleave from all topics
+        all_articles = []
+        seen = set()
+        max_len = max((len(v) for v in results.values()), default=0)
+        for i in range(max_len):
+            for topic in all_topics:
+                srcs = results.get(topic, [])
+                if i < len(srcs) and srcs[i].get('url') and srcs[i]['url'] not in seen:
+                    seen.add(srcs[i]['url'])
+                    srcs[i]['_topic'] = topic
+                    all_articles.append(srcs[i])
+        total = len(all_articles)
+        start = page * per_page
+        end = start + per_page
+        page_articles = all_articles[start:end]
+        # Lazy-load images: add article_url for frontend to fetch
+        response = {
+            'sources': page_articles,
+            'topics': all_topics,
+            'page': page,
+            'per_page': per_page,
+            'has_more': end < total,
+            'total': total
+        }
+        # Cache the full result
+        _hashtag_multi_cache['t'] = now
+        _hashtag_multi_cache['d'][cache_key] = response
+        _hashtag_multi_cache['d'] = {k: v for k, v in _hashtag_multi_cache['d'].items() if k.startswith('p')}
+        _hashtag_multi_cache['d'][cache_key] = response
+        return JSONResponse(response)
+    except Exception as e:
+        return JSONResponse({'error': str(e), 'sources': [], 'topics': [], 'has_more': False, 'total': 0})
 
 @app.get('/')
 async def serve_index():
@@ -521,7 +596,12 @@ async def serve_index():
 @app.get('/api/hashtag/sources')
 def _ht(topic:str=Query(...),page:int=Query(default=0)):
     items=_search_all(topic,36);per_page=8;start=page*per_page;end=start+per_page
-    return JSONResponse({'sources':items[start:end],'topic':topic,'page':page,'has_more':end<len(items),'total':len(items)})
+    page_items = items[start:end]
+    # Add dates to items
+    today = _today_str()
+    for item in page_items:
+        if 'date' not in item: item['date'] = today
+    return JSONResponse({'sources':page_items,'topic':topic,'page':page,'has_more':end<len(items),'total':len(items)})
 @app.get('/api/categories')
 def _cat():return JSONResponse([])
 @app.get('/api/storage_status')
@@ -1078,812 +1158,4 @@ def detect_language(text):
 # Emotion keyword-based detection
 _EMOTION_KEYWORDS = {
     'happy': {
-        'en': ['happy', 'joy', 'wonderful', 'great', 'amazing', 'fantastic', 'love', 'excellent', 'beautiful', 'glad', 'delighted', 'pleased', 'cheerful', 'celebrate', 'victory', 'win', 'success'],
-        'pt': ['feliz', 'alegria', 'maravilhoso', 'ótimo', 'incrível', 'fantástico', 'amor', 'excelente', 'lindo', 'contente', 'encantado', 'vitória', 'sucesso'],
-        'es': ['feliz', 'alegria', 'maravilloso', 'genial', 'increíble', 'fantástico', 'amor', 'excelente', 'hermoso', 'contento', 'encantado', 'victoria', 'éxito'],
-        'vi': ['vui', 'hạnh phúc', 'tuyệt vời', 'tuyệt', 'ý nghĩa', 'đẹp', 'thích', 'yêu', 'vui vẻ', 'hân hoan', 'phấn khích', 'chiến thắng', 'thành công'],
-    },
-    'sad': {
-        'en': ['sad', 'unhappy', 'terrible', 'awful', 'horrible', 'miserable', 'depressed', 'grief', 'sorrow', 'tragic', 'unfortunate', 'painful', 'death', 'die', 'kill'],
-        'pt': ['triste', 'infeliz', 'terrível', 'horrível', 'miserável', 'deprimido', 'dor', 'trágico', 'infelizmente', 'penoso', 'morte', 'morrer'],
-        'es': ['triste', 'infeliz', 'terrible', 'horrible', 'miserable', 'deprimido', 'dolor', 'trágico', 'desafortunado', 'penoso', 'muerte', 'morir'],
-        'vi': ['buồn', 'không vui', 'tồi tệ', 'kinh khủng', 'đau khổ', 'đau buồn', 'bi thương', 'khốn nạn', 'đau đớn', 'thảm họa', 'chết', 'mất'],
-    },
-    'excited': {
-        'en': ['excited', 'thrilling', 'amazing', 'wow', 'incredible', 'unbelievable', 'awesome', 'exhilarating', 'electrifying', 'breathtaking', 'breakthrough', 'record'],
-        'pt': ['animado', 'emocionante', 'incrível', 'impressionante', 'sensacional', 'eletrizante', 'empolgante', 'recorde'],
-        'es': ['emocionante', 'increíble', 'impresionante', 'sensacional', 'electrizante', 'emocionado', 'entusiasmado', 'récord'],
-        'vi': ['hào hứng', 'phấn khích', 'thú vị', 'tuyệt cú mèo', 'đỉnh cao', 'ngoạn mục', 'sục sôi', 'kỷ lục', 'đột phá'],
-    },
-    'humorous': {
-        'en': ['funny', 'hilarious', 'joke', 'laugh', 'comedy', 'humor', 'amusing', 'witty', 'sarcastic', 'ironic', 'ridiculous', 'absurd', 'lol', 'haha'],
-        'pt': ['engraçado', 'hilário', 'piada', 'rir', 'comédia', 'humor', 'divertido', 'irônico', 'ridículo', 'absurdo', 'kkk'],
-        'es': ['gracioso', 'hilarante', 'broma', 'risa', 'comedia', 'humor', 'divertido', 'irónico', 'ridículo', 'absurdo', 'jaja'],
-        'vi': ['hài hước', 'buồn cười', 'đùa', 'cười', 'hài', 'vui nhộn', 'hóm hỉnh', 'mỉa mai', 'lố bịch', 'vô lý', 'haha'],
-    },
-    'serious': {
-        'en': ['serious', 'critical', 'important', 'urgent', 'severe', 'grave', 'significant', 'crucial', 'vital', 'essential', 'alarming', 'concerning', 'crisis', 'war', 'conflict'],
-        'pt': ['sério', 'crítico', 'importante', 'urgente', 'grave', 'significativo', 'crucial', 'vital', 'essencial', 'preocupante', 'crise', 'guerra', 'conflito'],
-        'es': ['serio', 'crítico', 'importante', 'urgente', 'grave', 'significativo', 'crucial', 'vital', 'esencial', 'preocupante', 'crisis', 'guerra', 'conflicto'],
-        'vi': ['nghiêm trọng', 'quan trọng', 'khẩn cấp', 'nghiêm túc', 'đáng kể', 'thiết yếu', 'cần thiết', 'báo động', 'lo ngại', 'khủng hoảng', 'chiến tranh', 'xung đột'],
-    },
-}
-
-def detect_emotion(text, language='vietnamese'):
-    """Detect emotion from text using keyword matching."""
-    if not text:
-        return 'neutral'
-    text_lower = text.lower()
-    
-    scores = {}
-    for emotion, lang_keywords in _EMOTION_KEYWORDS.items():
-        keywords = lang_keywords.get(language, lang_keywords.get('en', []))
-        score = sum(1 for kw in keywords if kw in text_lower)
-        scores[emotion] = score
-    
-    if max(scores.values()) == 0:
-        return 'neutral'
-    
-    return max(scores, key=scores.get)
-
-def detect_language_and_emotion(title, text):
-    """Detect both language and emotion from article content."""
-    combined = f"{title} {text}"
-    lang = detect_language(combined)
-    emotion = detect_emotion(combined, lang)
-    return lang, emotion
-
-# Voice selection based on language and emotion (using MultilingualNeural voices)
-VOICE_BY_LANG_EMOTION = {
-    'vietnamese': {
-        'happy': ('vi-VN-HoaiMyNeural', 'vui'),
-        'sad': ('vi-VN-NamMinhNeural', 'buồn'),
-        'excited': ('vi-VN-HoaiMyNeural', 'hào hứng'),
-        'humorous': ('vi-VN-HoaiMyNeural', 'vui'),
-        'serious': ('vi-VN-NamMinhNeural', 'nghiêm túc'),
-        'neutral': ('vi-VN-HoaiMyNeural', 'trung_tinh'),
-    },
-    'portuguese': {
-        'happy': ('pt-BR-ThalitaMultilingualNeural', 'feliz'),
-        'sad': ('pt-BR-ThalitaMultilingualNeural', 'triste'),
-        'excited': ('pt-BR-ThalitaMultilingualNeural', 'animado'),
-        'humorous': ('pt-BR-ThalitaMultilingualNeural', 'engraçado'),
-        'serious': ('pt-BR-ThalitaMultilingualNeural', 'sério'),
-        'neutral': ('pt-BR-ThalitaMultilingualNeural', 'neutro'),
-    },
-    'english': {
-        'happy': ('en-US-AndrewMultilingualNeural', 'happy'),
-        'sad': ('en-AU-WilliamMultilingualNeural', 'sad'),
-        'excited': ('en-US-AndrewMultilingualNeural', 'excited'),
-        'humorous': ('en-US-AndrewMultilingualNeural', 'funny'),
-        'serious': ('en-AU-WilliamMultilingualNeural', 'serious'),
-        'neutral': ('en-US-AndrewMultilingualNeural', 'neutral'),
-    },
-    'french': {
-        'happy': ('fr-FR-VivienneMultilingualNeural', 'heureux'),
-        'sad': ('fr-FR-RemyMultilingualNeural', 'triste'),
-        'excited': ('fr-FR-VivienneMultilingualNeural', 'excité'),
-        'humorous': ('fr-FR-VivienneMultilingualNeural', 'drôle'),
-        'serious': ('fr-FR-RemyMultilingualNeural', 'sérieux'),
-        'neutral': ('fr-FR-VivienneMultilingualNeural', 'neutre'),
-    },
-    'german': {
-        'happy': ('de-DE-SeraphinaMultilingualNeural', 'glücklich'),
-        'sad': ('de-DE-FlorianMultilingualNeural', 'traurig'),
-        'excited': ('de-DE-SeraphinaMultilingualNeural', 'aufgeregt'),
-        'humorous': ('de-DE-SeraphinaMultilingualNeural', 'lustig'),
-        'serious': ('de-DE-FlorianMultilingualNeural', 'ernst'),
-        'neutral': ('de-DE-SeraphinaMultilingualNeural', 'neutral'),
-    },
-    'korean': {
-        'happy': ('ko-KR-HyunsuMultilingualNeural', '행복'),
-        'sad': ('ko-KR-HyunsuMultilingualNeural', '슬픔'),
-        'excited': ('ko-KR-HyunsuMultilingualNeural', '흥분'),
-        'humorous': ('ko-KR-HyunsuMultilingualNeural', '유쾌'),
-        'serious': ('ko-KR-HyunsuMultilingualNeural', '진지'),
-        'neutral': ('ko-KR-HyunsuMultilingualNeural', '중립'),
-    },
-    'italian': {
-        'happy': ('it-IT-GiuseppeMultilingualNeural', 'felice'),
-        'sad': ('it-IT-GiuseppeMultilingualNeural', 'triste'),
-        'excited': ('it-IT-GiuseppeMultilingualNeural', 'emozionato'),
-        'humorous': ('it-IT-GiuseppeMultilingualNeural', 'divertente'),
-        'serious': ('it-IT-GiuseppeMultilingualNeural', 'serio'),
-        'neutral': ('it-IT-GiuseppeMultilingualNeural', 'neutro'),
-    },
-}
-
-# All valid voice IDs (new MultilingualNeural format)
-VALID_VOICES = {
-    'vi-VN-HoaiMyNeural', 'vi-VN-NamMinhNeural',
-    'en-US-AndrewMultilingualNeural', 'en-AU-WilliamMultilingualNeural',
-    'pt-BR-ThalitaMultilingualNeural',
-    'fr-FR-VivienneMultilingualNeural', 'fr-FR-RemyMultilingualNeural',
-    'de-DE-SeraphinaMultilingualNeural', 'de-DE-FlorianMultilingualNeural',
-    'ko-KR-HyunsuMultilingualNeural',
-    'it-IT-GiuseppeMultilingualNeural',
-}
-
-def get_voice_for_content(title, text, preferred_voice=None):
-    """Get appropriate voice based on content language and emotion."""
-    # Accept the new MultilingualNeural voices directly
-    if preferred_voice and preferred_voice in VALID_VOICES:
-        return preferred_voice
-    
-    # Also accept old shorthand voice IDs and map them to new format
-    old_voice_map = {
-        'hoaimy': 'vi-VN-HoaiMyNeural',
-        'namminh': 'vi-VN-NamMinhNeural',
-        'andrew': 'en-US-AndrewMultilingualNeural',
-        'jenny': 'en-US-AndrewMultilingualNeural',
-        'thalita': 'pt-BR-ThalitaMultilingualNeural',
-        'pt_thalita': 'pt-BR-ThalitaMultilingualNeural',
-        'pt_francisco': 'pt-BR-ThalitaMultilingualNeural',
-        'ela': 'en-US-AndrewMultilingualNeural',
-        'es_carlos': 'en-US-AndrewMultilingualNeural',
-        'denise': 'fr-FR-VivienneMultilingualNeural',
-        'katja': 'de-DE-SeraphinaMultilingualNeural',
-        'nanami': 'en-US-AndrewMultilingualNeural',
-        'sunhee': 'ko-KR-HyunsuMultilingualNeural',
-        'xiaochen': 'en-US-AndrewMultilingualNeural',
-    }
-    if preferred_voice and preferred_voice in old_voice_map:
-        return old_voice_map[preferred_voice]
-    
-    lang, emotion = detect_language_and_emotion(title, text)
-    lang_map = VOICE_BY_LANG_EMOTION.get(lang, VOICE_BY_LANG_EMOTION['vietnamese'])
-    voice, _ = lang_map.get(emotion, lang_map['neutral'])
-    return voice
-
-
-def _is_relevant_image(img_url, title, text):
-    """Check if an image is relevant to the article content."""
-    if not img_url:
-        return False
-    skip_patterns = ['pixel', 'analytics', 'tracking', '1x1.gif', 'spacer.gif',
-                     'logo', 'icon', 'avatar', 'emoji', 'smiley', 'sprite',
-                     'advertisement', 'ad-banner', 'sponsored', 'banner-ads']
-    img_lower = img_url.lower()
-    for p in skip_patterns:
-        if p in img_lower:
-            return False
-    if not any(img_lower.endswith(ext) for ext in ['.jpg', '.jpeg', '.png', '.webp', '.gif']):
-        return False
-    return True
-
-
-def _filter_relevant_images(images, title, text, max_images=8):
-    """Filter and rank images by relevance to article content."""
-    if not images:
-        return []
-    seen = set()
-    relevant = []
-    for img in images:
-        if img in seen:
-            continue
-        seen.add(img)
-        if _is_relevant_image(img, title, text):
-            relevant.append(img)
-    return relevant[:max_images]
-
-
-def _scrape_article_for_rewrite(url):
-    """Scrape article: extract title, paragraphs, RELEVANT images, OG image."""
-    try:
-        r = req.get(url, headers=_UA_RW, timeout=15, allow_redirects=True)
-        r.encoding = 'utf-8'
-        soup = BeautifulSoup(r.text, 'lxml')
-        for tag in soup.find_all(['script', 'style', 'nav', 'footer', 'aside', 'form']):
-            tag.decompose()
-        h1 = soup.find('h1')
-        ogt = soup.find('meta', property='og:title')
-        title = (h1.get_text(strip=True) if h1 else '') or (ogt.get('content', '') if ogt else '')
-        ogi = soup.find('meta', property='og:image')
-        og_img = ogi.get('content', '') if ogi else ''
-        if og_img and og_img.startswith('//'):
-            og_img = 'https:' + og_img
-        block = None
-        for sel in ['article', '.singular-content', '.detail-content', '.fck_detail', '.content-detail', '.knc-content', 'main', '.cms-body', '.article__body']:
-            el = soup.select_one(sel)
-            if el and len(el.find_all('p')) >= 2:
-                block = el
-                break
-        if not block:
-            block = soup.body or soup
-        paragraphs = []
-        all_images = []
-        seen_imgs = set()
-        if og_img and og_img not in seen_imgs:
-            all_images.append(og_img)
-            seen_imgs.add(og_img)
-        for el in block.find_all(['p', 'h2', 'h3', 'figure', 'img'], recursive=True):
-            if el.name == 'p':
-                t = _clean(el.get_text(strip=True))
-                if t and len(t) > 40:
-                    paragraphs.append(t)
-            elif el.name in ('figure', 'img'):
-                im = el if el.name == 'img' else el.find('img')
-                if im:
-                    src = im.get('data-src') or im.get('src') or im.get('data-original') or ''
-                    if src and 'base64' not in src:
-                        if src.startswith('//'):
-                            src = 'https:' + src
-                        if src not in seen_imgs:
-                            all_images.append(src)
-                            seen_imgs.add(src)
-        # Filter to relevant images only
-        relevant_images = _filter_relevant_images(all_images, title, ' '.join(paragraphs[:5]))
-        return {'title': _clean(title), 'paragraphs': paragraphs, 'images': relevant_images, 'og_img': og_img}
-    except Exception:
-        return None
-
-
-def _extract_key_points_rw(paragraphs, max_points=5):
-    r"""Extract key points from paragraphs - extracts ALL sentences, not just first one.
-    
-    Fixes: Original regex `^(.+?[.!?])\s` only captured first sentence per paragraph.
-    Now splits on all sentence boundaries and takes valid sentences until max_points.
-    """
-    points = []
-    
-    for p in paragraphs:
-        if len(points) >= max_points:
-            break
-        
-        p = _clean(p)
-        if not p:
-            continue
-        
-        # Split paragraph into sentences using Vietnamese + English punctuation
-        sentences = re.split(r'(?<=[.!?])\s+(?=[A-ZÀ-Ỹ0-9])', p)
-        sentences = [s.strip() for s in sentences if s.strip()]
-        
-        for sentence in sentences:
-            if len(points) >= max_points:
-                break
-            
-            # Clean sentence - remove extra whitespace
-            sentence = _clean(sentence)
-            
-            if len(sentence) < 30:
-                continue
-            
-            # Check for duplicates
-            if any(sentence[:60] in existing for existing in points):
-                continue
-            
-            # Ensure sentence ends with punctuation
-            if not sentence.endswith(('.', '!', '?')):
-                sentence = sentence + '.'
-            
-            points.append(sentence)
-    
-    # If no valid sentences found, take chunks from raw text
-    if not points:
-        raw = '\n'.join(paragraphs)
-        for i in range(0, min(len(raw), max_points * 300), 280):
-            chunk = _clean(raw[i:i+280])
-            if len(chunk) >= 30 and chunk not in points:
-                points.append(chunk + ('.' if not chunk.endswith('.') else ''))
-            if len(points) >= max_points:
-                break
-    
-    return points
-
-
-@app.post("/api/rewrite_slide")
-async def api_rewrite_slide(request: Request):
-    """Fast rewrite as SLIDES - no AI needed, instant response."""
-    body = await request.json()
-    url = _clean(body.get("url", ""))
-    context = body.get("context", "")
-    preferred_voice = body.get("voice", "")  # Accept custom voice selection
-    if not url and not context:
-        return JSONResponse({"error": "Cần URL hoặc nội dung"}, status_code=400)
-    data = None
-    if url and url.startswith("http"):
-        data = _scrape_article_for_rewrite(url)
-    if not data and context:
-        paragraphs = [_clean(p) for p in context.split('\n') if len(_clean(p)) > 40]
-        data = {'title': paragraphs[0][:80] if paragraphs else 'Bài viết', 'paragraphs': paragraphs, 'images': [], 'og_img': ''}
-    if not data or not data.get('paragraphs'):
-        return JSONResponse({"error": "Không đọc được bài viết"}, status_code=422)
-    points = _extract_key_points_rw(data['paragraphs'], max_points=12)
-    if not points:
-        return JSONResponse({"error": "Không tìm được ý chính"}, status_code=422)
-    images = data.get('images', [])
-    slides = []
-    for i, point in enumerate(points):
-        img = images[i] if i < len(images) else (images[-1] if images else '')
-        if img and 'cdnphoto.dantri' in img:
-            img = '/api/proxy/img?url=' + _quote2(img, safe='')
-        slides.append({'text': point, 'image': img, 'index': i + 1})
-    summary_text = '\n\n'.join([f"• {s['text']}" for s in slides])
-    
-    # Auto-detect language and emotion
-    lang, emotion = detect_language_and_emotion(data['title'], summary_text)
-    # Use preferred voice if provided, otherwise auto-detect
-    voice = preferred_voice if preferred_voice else get_voice_for_content(data['title'], summary_text)
-    
-    post = {
-        "id": str(int(time.time() * 1000)) + str(_random2.randint(100, 999)),
-        "title": data['title'],
-        "text": summary_text,
-        "img": images[0] if images else '',
-        "url": url,
-        "kind": "slide_summary",
-        "slides": slides,
-        "images": images[:10],
-        "video": "",
-        "voice": voice,
-        "emotion": emotion,
-        "language": lang,
-        "ts": int(time.time())
-    }
-    posts = _load_wall_posts()
-    posts.insert(0, post)
-    _save_wall_posts(posts)
-    return JSONResponse({"post": post, "slides": slides})
-
-
-@app.post("/api/rewrite_share")
-async def api_rewrite_share(request: Request):
-    """Rewrite article and post to Tường AI with SLIDES + AI text."""
-    body = await request.json()
-    url = _clean(body.get("url", ""))
-    ctx = _clean(body.get("context", ""))
-    preferred_voice = body.get("voice", "")  # Accept custom voice selection
-    if not url and not ctx:
-        return JSONResponse({"error": "Cần URL hoặc nội dung"}, status_code=400)
-    data = None
-    if url and url.startswith("http"):
-        data = _scrape_article_for_rewrite(url)
-    if not data and ctx:
-        paragraphs = [_clean(p) for p in ctx.split('\n') if len(_clean(p)) > 40]
-        data = {'title': paragraphs[0][:80] if paragraphs else 'Bài viết', 'paragraphs': paragraphs, 'images': [], 'og_img': ''}
-    if not data or not data.get('paragraphs'):
-        return JSONResponse({"error": "Không đọc được bài viết"}, status_code=422)
-    raw_text = '\n'.join(data['paragraphs'])
-    if len(raw_text) < 50:
-        raw_text = ctx[:14000]
-    if len(raw_text) < 50:
-        return JSONResponse({"error": "Bài viết quá ngắn"}, status_code=422)
-    domain = ''
-    try:
-        from urllib.parse import urlparse
-        domain = urlparse(url).netloc.replace('www.', '')
-    except:
-        pass
-    
-    # Generate AI summary text
-    ai_text = None
-    try:
-        import ai_ext
-        if hasattr(ai_ext, 'qwen_generate'):
-            prompt = f'Tóm tắt đăng Tường AI:\nTiêu đề: {data["title"]}\n{raw_text[:14000]}\n\n4-6 ý chính. Cuối ghi nguồn.'
-            ai_text = await ai_ext.qwen_generate(prompt, max_tokens=1000)
-    except Exception:
-        pass
-    if not ai_text or len(ai_text) < 80:
-        key_pts = _extract_key_points_rw(data['paragraphs'], max_points=12)
-        if key_pts:
-            ai_text = '\n\n'.join([f"• {p}" for p in key_pts])
-        else:
-            ai_text = f"Tóm tắt: {data['title']}\n\n{raw_text[:1200]}\n\nNguồn: {domain}"
-    
-    # Build slides from key points (FIX: include slides in rewrite_share too!)
-    points = _extract_key_points_rw(data['paragraphs'], max_points=12)
-    images = data.get('images', [])
-    slides = []
-    for i, point in enumerate(points):
-        img = images[i] if i < len(images) else (images[-1] if images else '')
-        if img and 'cdnphoto.dantri' in img:
-            img = '/api/proxy/img?url=' + _quote2(img, safe='')
-        slides.append({'text': point, 'image': img, 'index': i + 1})
-    
-    # Auto-detect language and emotion
-    lang, emotion = detect_language_and_emotion(data['title'], ai_text)
-    # Use preferred voice if provided, otherwise auto-detect
-    voice = preferred_voice if preferred_voice else get_voice_for_content(data['title'], ai_text)
-    
-    post = {
-        "id": str(int(time.time() * 1000)) + str(_random2.randint(100, 999)),
-        "title": data['title'],
-        "text": ai_text,
-        "img": images[0] if images else '',
-        "url": url,
-        "kind": "rewrite",
-        "slides": slides,
-        "images": images[:10],
-        "video": "",
-        "voice": voice,
-        "emotion": emotion,
-        "language": lang,
-        "ts": int(time.time())
-    }
-    posts = _load_wall_posts()
-    posts.insert(0, post)
-    _save_wall_posts(posts)
-    return JSONResponse({"post": post, "slides": slides})
-
-
-@app.post("/api/url_wall")
-async def api_url_wall(request: Request):
-    """Submit URL to add to Tường AI."""
-    body = await request.json()
-    url = _clean(body.get("url", ""))
-    if not url or not url.startswith('http'):
-        return JSONResponse({"error": "URL không hợp lệ"}, status_code=400)
-    # Reuse rewrite_share logic
-    req._body = json.dumps({"url": url}).encode()
-    return await api_rewrite_share(request)
-
-
-def _bg():
-    time.sleep(15)
-    while True:
-        try:get_wc2026_all()
-        except:pass
-        time.sleep(90)
-threading.Thread(target=_bg,daemon=True).start()
-
-# ===== AUTO SCHEDULER: rewrite AI + short at 7/13/19 VN time =====
-_AUTO_SCHEDULE_TIMES = [(7, '07:00'), (13, '13:00'), (19, '19:00')]
-_AUTO_LOG = os.path.join(DATA_DIR, 'auto_rewrite_log.json')
-
-def _load_auto_log():
-    try:
-        if os.path.exists(_AUTO_LOG):
-            with open(_AUTO_LOG, 'r') as f:
-                return json.load(f)
-    except: pass
-    return {}
-
-def _save_auto_log(log):
-    try:
-        tmp = _AUTO_LOG + '.tmp'
-        with open(tmp, 'w') as f:
-            json.dump(log, f)
-        os.replace(tmp, _AUTO_LOG)
-    except: pass
-
-async def _auto_fetch_short(post_id):
-    """Try to auto-generate a short for a post."""
-    try:
-        import httpx
-        async with httpx.AsyncClient(timeout=180) as cl:
-            r = await cl.post(
-                f"http://localhost:7860/api/ai/short/{post_id}",
-                json={"voice":"vi-VN-HoaiMyNeural","emotion":"neutral","speed":1.2},
-                headers={"Content-Type":"application/json"}
-            )
-            if r.status_code < 300:
-                sj = r.json()
-                if sj.get('video'):
-                    posts = _load_wall_posts()
-                    for p in posts:
-                        if p.get('id') == post_id:
-                            p['video'] = sj['video']
-                            break
-                    _save_wall_posts(posts)
-                    return True
-    except: pass
-    return False
-
-async def _auto_rewrite_one(topic, slot_label, used_urls=None, post_index=0):
-    """Rewrite one topic: find articles, summarize, post to wall, trigger short.
-    used_urls: shared set to avoid duplicate articles across topics.
-    post_index: 0-based index to create multiple posts per topic (0,1,2 = up to 3 posts)."""
-    from urllib.parse import quote as _q
-    # Get MORE items to support 1-3 posts per topic
-    items = _search_all(topic, limit=12)
-    # Skip URLs already used by another topic
-    if used_urls is not None:
-        filtered = [it for it in items if it.get('url') not in used_urls]
-        if filtered:
-            items = filtered
-    if not items or post_index >= len(items):
-        return False
-    
-    # Get article at post_index (0,1,2 for multiple posts)
-    item = items[post_index]  # post_index allows multiple articles per topic
-    url = item.get('url', '')
-    title = item.get('title', topic)
-    if url and used_urls is not None:
-        used_urls.add(url)
-    if not url.startswith('http'):
-        return False
-    
-    data = _scrape_article_for_rewrite(url)
-    if not data or not data.get('paragraphs'):
-        return False
-    
-    raw_text = '\n'.join(data['paragraphs'])
-    ai_text = None
-    
-    # Try AI generation
-    try:
-        import ai_ext
-        prompt = f"Tóm tắt tin tức (tự động {slot_label}):\nTiêu đề: {data['title']}\n{raw_text[:10000]}\n\n4-6 ý chính dạng bullet. Cuối ghi nguồn."
-        ai_text = await ai_ext.qwen_generate(prompt, max_tokens=1000)
-    except: pass
-    
-    if not ai_text or len(ai_text) < 80:
-        pts = data['paragraphs'][:6]
-        ai_text = '\n\n'.join([f"• {p[:300]}" for p in pts])
-        via = item.get('via', '') or urlparse(url).netloc.replace('www.', '')
-        ai_text += f"\n\nNguồn tham khảo: {via}"
-    
-    # Build slides
-    images = data.get('images', [])
-    pts = data['paragraphs'][:10]
-    slides = []
-    for i, p in enumerate(pts[:8]):
-        img = images[i] if i < len(images) else (images[-1] if images else data.get('og_img', ''))
-        slides.append({'text': p[:300], 'image': img, 'index': i + 1})
-    
-    post_id = str(int(time.time() * 1000)) + str(_random2.randint(100, 999))
-    post = {
-        "id": post_id, "title": data.get('title', title)[:200],
-        "text": ai_text, "img": images[0] if images else data.get('og_img', ''),
-        "url": url, "kind": "auto_rewrite", "slides": slides,
-        "images": images[:10], "video": "",
-        "voice": "vi-VN-HoaiMyNeural", "emotion": "neutral",
-        "language": "vietnamese", "ts": int(time.time()),
-        "auto_scheduled": True, "slot": slot_label,
-    }
-    
-    posts = _load_wall_posts()
-    posts.insert(0, post)
-    _save_wall_posts(posts)
-    
-    # Trigger short generation async
-    threading.Thread(target=lambda: asyncio.run(_auto_fetch_short(post_id)), daemon=True).start()
-    return True
-
-async def _do_scheduled_run(slot_label):
-    """Main scheduled run: 1-3 posts from 3 different HOT topics (3-9 total), no duplicates."""
-    print(f"[auto] Starting scheduled rewrite for {slot_label}")
-    
-    # Get top hot topics, skip duplicates
-    all_topics = _get_hot_topics()
-    seen_topics = set()
-    unique_topics = []
-    for t in all_topics:
-        kw = t.get('topic', '').lower().strip()
-        if kw and len(kw) > 5 and kw not in seen_topics:
-            is_dup = False
-            for s in seen_topics:
-                # Check if one topic is substring of another
-                if kw in s or s in kw:
-                    is_dup = True
-                    break
-            if not is_dup:
-                seen_topics.add(kw)
-                unique_topics.append(t)
-        if len(unique_topics) >= 3:
-            break
-    
-    job_topics = [t['topic'] for t in unique_topics[:3] if t.get('topic')]
-    if not job_topics:
-        print(f"[auto] No hot topics found, skipping")
-        return
-    
-    print(f"[auto] Running 3 topics: {job_topics}")
-    
-    # Track used URLs to avoid cross-topic duplicates
-    _used_urls = set()
-    results = []
-    
-    # Process each topic, create 1-3 posts per topic
-    for jt in job_topics:
-        for post_idx in range(3):  # Try up to 3 posts per topic
-            try:
-                ok = await asyncio.wait_for(_auto_rewrite_one(jt, slot_label, _used_urls, post_idx), timeout=120)
-                if ok:
-                    results.append((jt, post_idx, True))
-                    print(f"[auto] Created post {post_idx+1} for '{jt}'")
-                else:
-                    # No more articles for this topic
-                    break
-            except Exception as e:
-                print(f"[auto] Error on '{jt}' post {post_idx}: {e}")
-                results.append((jt, post_idx, False))
-            await asyncio.sleep(1)  # Small delay between posts
-    
-    # Ensure at least 3 posts total (fallback if needed)
-    successful_posts = sum(1 for _, _, ok in results if ok)
-    print(f"[auto] Done {slot_label}: {successful_posts} posts created")
-    
-    # Log
-    from datetime import datetime, timezone, timedelta
-    VN_TZ_SCHED = timezone(timedelta(hours=7))
-    today_str = datetime.now(VN_TZ_SCHED).strftime('%Y-%m-%d')
-    log = _load_auto_log()
-    if today_str not in log: log[today_str] = {}
-    log[today_str][slot_label] = {
-        'time': datetime.now(VN_TZ_SCHED).strftime('%H:%M:%S'),
-        'count': successful_posts,
-        'total': len(job_topics),
-    }
-    _save_auto_log(log)
-
-def _scheduler_loop():
-    """Check every 60s; trigger at 7:00, 13:00, 19:00 VN time.
-    On startup, check for any missed slots today and run them immediately."""
-    time.sleep(35)
-    from datetime import datetime, timezone, timedelta
-    VN_TZ_SCHED = timezone(timedelta(hours=7))
-    
-    _last_run_date = ""
-    _last_run_slots = set()
-    
-    # On startup: check log for missed slots today
-    try:
-        start_now = datetime.now(VN_TZ_SCHED)
-        today_str = start_now.strftime('%Y-%m-%d')
-        current_hour = start_now.hour
-        current_minute = start_now.minute
-        log = _load_auto_log()
-        today_log = log.get(today_str, {})
-        for h, label in _AUTO_SCHEDULE_TIMES:
-            # Run if slot is past (either strictly earlier hour, or same hour but window has passed)
-            should_run = False
-            if h < current_hour:
-                should_run = True
-            elif h == current_hour and current_minute > 10:
-                should_run = True
-            if should_run and label not in today_log:
-                print(f"[auto] Detected missed slot {label} (h={h} < now={current_hour}:{current_minute}), running catch-up now")
-                _run_scheduled_sync(label)
-                _last_run_slots.add(label)
-    except Exception as e:
-        print(f"[auto] Catch-up check error: {e}")
-    
-    while True:
-        try:
-            now = datetime.now(VN_TZ_SCHED)
-            today = now.strftime('%Y-%m-%d')
-            hour = now.hour
-            minute = now.minute
-            
-            if today != _last_run_date:
-                _last_run_date = today
-                _last_run_slots = set()
-            
-            slot = None
-            for h, label in _AUTO_SCHEDULE_TIMES:
-                if hour == h and 0 <= minute < 5:
-                    slot = label
-                    break
-            
-            if slot and slot not in _last_run_slots:
-                _last_run_slots.add(slot)
-                _run_scheduled_sync(slot)
-        except Exception as e:
-            print(f"[auto] Loop error: {e}")
-        
-        time.sleep(60)
-
-threading.Thread(target=_scheduler_loop, daemon=True, name='auto-rewrite-scheduler').start()
-
-@app.get('/api/debug/auto_schedule')
-async def debug_auto_schedule(slot: str = '07:00'):
-    """Manually trigger auto scheduler for debugging."""
-    try:
-        # Check if we can access the data directory
-        log = _load_auto_log()
-        topics = _get_hot_topics()[:3]
-        job_topics = [t['topic'] for t in topics if t.get('topic')]
-        return JSONResponse({
-            "slot": slot,
-            "log": log,
-            "hot_topics": job_topics,
-            "wall_posts_count": len(_load_wall_posts()),
-            "data_dir_writable": os.access(DATA_DIR, os.W_OK) if os.path.isdir(DATA_DIR) else False,
-            "data_dir_exists": os.path.isdir(DATA_DIR),
-        })
-    except Exception as e:
-        return JSONResponse({"error": str(e)}, status_code=500)
-
-def _run_scheduled_sync(slot):
-    """Run _do_scheduled_run in a separate event loop (for background thread)."""
-    loop = asyncio.new_event_loop()
-    asyncio.set_event_loop(loop)
-    try:
-        loop.run_until_complete(_do_scheduled_run(slot))
-    except Exception as e:
-        print(f"[auto] Background run error: {e}")
-    finally:
-        loop.close()
-
-@app.get('/api/debug/trigger_auto')
-async def debug_trigger_auto(slot: str = '19:00'):
-    """Trigger _do_scheduled_run in background thread (non-blocking)."""
-    threading.Thread(target=_run_scheduled_sync, args=(slot,), daemon=True).start()
-    return JSONResponse({"status": "started", "slot": slot})
-
-# ===== SHORTS RSS PROXY ENDPOINT =====
-@app.get("/api/shorts/rss")
-def shorts_rss():
-    """Get shorts from YouTube RSS feeds server-side"""
-    import xml.etree.ElementTree as ET
-    import html as html_lib2
-    import re as re2
-    
-    YOUTUBE_CHANNELS = {
-        "baodantri7941": "UC_x5TKhOgd6GhYvv5z4I3jg",
-        "baosuckhoedoisongboyte": "UCBsY5fXTQLkF_JnH9kLkL4g",
-    }
-    
-    shorts = []
-    seen = set()
-    
-    for handle, channel_id in YOUTUBE_CHANNELS.items():
-        try:
-            rss_url = f"https://www.youtube.com/feeds/videos.xml?channel_id={channel_id}"
-            r = req.get(rss_url, headers=HEADERS, timeout=15)
-            if r.status_code != 200:
-                continue
-            
-            root = ET.fromstring(r.text)
-            ns = {
-                'atom': 'http://www.w3.org/2005/Atom',
-                'yt': 'http://www.youtube.com/xml/schemas/2015',
-                'media': 'http://search.yahoo.com/mrss/'
-            }
-            
-            for entry in root.findall('atom:entry', ns)[:30]:
-                title_el = entry.find('atom:title', ns)
-                title = html_lib2.unescape(title_el.text) if title_el is not None and title_el.text else ''
-                
-                link_el = entry.find('atom:link', ns)
-                link = link_el.get('href', '') if link_el is not None else ''
-                
-                vid_el = entry.find('yt:videoId', ns)
-                vid = vid_el.text if vid_el is not None else ''
-                
-                if not vid or vid in seen:
-                    continue
-                
-                # Check if it's a short
-                is_short = '#shorts' in title.lower() or '#short' in title.lower() or '/shorts/' in link
-                
-                if not is_short:
-                    desc_el = entry.find('media:description', ns)
-                    if desc_el is not None and desc_el.text:
-                        if '#shorts' in desc_el.text.lower():
-                            is_short = True
-                
-                if not is_short:
-                    continue
-                
-                seen.add(vid)
-                
-                # Get thumbnail
-                thumb = f"https://i.ytimg.com/vi/{vid}/hqdefault.jpg"
-                media_group = entry.find('media:group', ns)
-                if media_group is not None:
-                    thumb_el = media_group.find('media:thumbnail', ns)
-                    if thumb_el is not None:
-                        thumb = thumb_el.get('url', thumb)
-                
-                shorts.append({
-                    'id': vid,
-                    'title': title.replace('#shorts', '').replace('#short', '').strip()[:120],
-                    'img': thumb,
-                    'link': f'https://www.youtube.com/shorts/{vid}',
-                    'channel': handle,
-                    'source': 'yt'
-                })
-                
-                if len(shorts) >= 40:
-                    break
-                    
-        except Exception as e:
-            print(f"RSS error for {handle}: {e}")
-            continue
-    
-    return {"shorts": shorts, "count": len(shorts)}
-
-app.mount('/static',StaticFiles(directory=STATIC_DIR),name='vnews_static')
+        'en': ['happy', 'joy', 'wonderful', 'great', 'amazing', 'fantastic', 'love', 'excellent', 'beautiful', 'glad', 'delighted', 'pleased', 'cheerful', 'celebrate',

auto_scheduler.py

@@ -393,4 +393,4 @@ def start_auto_scheduler():
     t = threading.Thread(target=_scheduler_loop, daemon=True, name="auto-scheduler")
     t.start()
     LOG.info("Auto scheduler started")
-    return t
+    return t

restart.txt

@@ -1 +1 @@
-restart now
+restart

static/auto_update.js

@@ -0,0 +1,85 @@
+// VNEWS Auto-update Frontend - SSE listener for real-time homepage updates
+(function(){
+    let evtSource = null;
+    
+    // Connect to SSE endpoint
+    function connectSSE() {
+        try {
+            evtSource = new EventSource('/api/events');
+            evtSource.onmessage = function(e) {
+                try {
+                    const data = JSON.parse(e.data);
+                    if (data.type === 'new_post' || data.type === 'new_short') {
+                        console.log('[SSE] Received update:', data.type);
+                        // Reload wall and re-render short AI
+                        fetch('/api/ai_wall').then(r => r.json()).then(j => {
+                            _wallPosts = j.posts || [];
+                            if (typeof renderShortAISlide === 'function') {
+                                renderShortAISlide();
+                            }
+                            // Update wall on homepage
+                            const track = document.getElementById('ai-wall-track');
+                            if (track && _wallPosts.length) {
+                                track.innerHTML = _wallPosts.slice(0,20).map((p,i) => makeWallItem(p,i)).join('');
+                            }
+                        }).catch(() => {});
+                    }
+                } catch(err) {}
+            };
+            evtSource.onerror = function() {
+                evtSource.close();
+                setTimeout(connectSSE, 5000); // Reconnect after 5s
+            };
+        } catch(err) {
+            console.log('[SSE] Not supported or error');
+        }
+    }
+    
+    // Fallback polling (30s) - detects changes even without SSE
+    let _lastWallLen = 0;
+    function startPolling() {
+        setInterval(function(){
+            if (typeof _wallPosts === 'undefined') return;
+            fetch('/api/ai_wall').then(r => r.json()).then(j => {
+                const wall = j.posts || [];
+                if (wall.length !== _lastWallLen) {
+                    console.log('[POLL] Wall changed:', _lastWallLen, '->', wall.length);
+                    _lastWallLen = wall.length;
+                    _wallPosts = wall;
+                    const track = document.getElementById('ai-wall-track');
+                    if (track && wall.length) {
+                        track.innerHTML = wall.slice(0,20).map((p,i) => makeWallItem(p,i)).join('');
+                    }
+                    if (typeof renderShortAISlide === 'function') {
+                        renderShortAISlide();
+                    }
+                }
+            }).catch(() => {});
+        }, 30000);
+    }
+    
+    // Start when DOM ready
+    if (document.readyState === 'loading') {
+        document.addEventListener('DOMContentLoaded', function(){
+            connectSSE();
+            startPolling();
+        });
+    } else {
+        connectSSE();
+        startPolling();
+    }
+    
+    // Export for manual trigger
+    window.triggerHomepageRefresh = function() {
+        fetch('/api/ai_wall').then(r => r.json()).then(j => {
+            _wallPosts = j.posts || [];
+            if (typeof _renderWallIn === 'function') {
+                const afterEl = document.getElementById('home-after-wc');
+                if (afterEl) _renderWallIn(afterEl);
+            }
+            if (typeof renderShortAISlide === 'function') {
+                renderShortAISlide();
+            }
+        });
+    };
+})();

static/hot_ai_prepend.js

@@ -0,0 +1,43 @@
+// Prepend AI topics to hot topics list - ensures they're always visible first
+// FIX v2: Thêm AI Thế Giới
+(function(){
+    const AI_TOPICS = [
+        'Công nghệ AI',
+        'AI Thế Giới',
+        'World Cup 2026',
+        'Kinh tế Việt Nam',
+        'Bóng đá châu Âu'
+    ];
+    
+    // Override loadHotTopics to prepend AI topics
+    const origLoadHotTopics = window.loadHotTopics;
+    window.loadHotTopics = async function() {
+        try {
+            const r = await fetch('/api/hot_topics');
+            const j = await r.json();
+            const topics = j.topics || [];
+            
+            // Prepend AI topics that aren't already in the list
+            const prependTopics = AI_TOPICS.filter(ai => 
+                !topics.some(t => (t.topic || '').toLowerCase().includes(ai.toLowerCase()))
+            ).map(ai => ({
+                label: '#' + ai.replace(/\s+/g, ''),
+                topic: ai,
+                count: 0
+            }));
+            
+            const finalTopics = [...prependTopics, ...topics].slice(0, 24);
+            
+            const el = document.getElementById('hot-topics');
+            if (el) {
+                el.innerHTML = finalTopics.map(t => {
+                    const topicText = t.topic || t.label.replace(/^#/, '');
+                    return `<button class="hot-chip" onclick="searchTopic('${topicText.replace(/'/g, "\\'")}')">${esc(t.label)}</button>`;
+                }).join('');
+            }
+        } catch(e) {
+            // Fallback to original
+            if (origLoadHotTopics) origLoadHotTopics.apply(this, arguments);
+        }
+    };
+})();

static/hot_multi.js

@@ -1,10 +1,6 @@
 // === OVERRIDE: loadHotTopics loads from MULTIPLE hashtags ===
 // This file loaded AFTER app_v2.js, overrides the function
 
-let _htAll = []; // All articles from multi-hashtag, for lazy loading
-let _htPage = 0;
-const _HT_PER_PAGE = 12;
-
 async function loadHotTopics(){
   const j=await fetch('/api/hot_topics').then(r=>r.json()).catch(()=>({topics:[]}));
   const el=document.getElementById('hot-topics');if(!el)return;
@@ -13,28 +9,9 @@ async function loadHotTopics(){
     const topicText=t.topic||t.label.replace(/^#/,'');
     return`<button class="hot-chip" onclick="searchTopic('${topicText.replace(/'/g,"\\'")}')">${esc(t.label)}</button>`;
   }).join('');
-  // Load tin HOT = tổng hợp từ 5 chủ đề: 3 chủ đề hot nhất + 2 chủ đề AI (AI Thế Giới, AI Việt Nam)
+  // Load tin HOT = tổng hợp từ TOP 3 hashtag nóng nhất
   if(topics.length>=2){
-    // Ép 2 chủ đề AI vào top 5
-    const forcedAI = ['AI Thế Giới', 'AI Việt Nam'];
-    const selected = [];
-    // Lấy các chủ đề trending đầu tiên (bỏ qua forced AI để tránh trùng)
-    for(let i=0; i<topics.length && selected.length < 3; i++){
-      const t = topics[i].topic||topics[i].label.replace(/^#/,'');
-      if(!forcedAI.some(ai => t.toLowerCase() === ai.toLowerCase())){
-        selected.push(t);
-      }
-    }
-    // Thêm 2 chủ đề AI
-    forcedAI.forEach(ai => {
-      if(selected.length < 5){
-        // Tìm trong topics list
-        const found = topics.find(t => (t.topic||t.label.replace(/^#/,'')).toLowerCase() === ai.toLowerCase());
-        if(found) selected.push(found.topic||found.label.replace(/^#/,''));
-        else selected.push(ai);
-      }
-    });
-    loadMultiHashtag(selected);
+    loadMultiHashtag(topics.slice(0,3).map(t=>t.topic||t.label.replace(/^#/,'')));
   }else if(topics.length){
     searchTopic(topics[0].topic||topics[0].label.replace(/^#/,''));
   }
@@ -56,42 +33,17 @@ async function loadMultiHashtag(topicList){
         if(src&&src.url&&!seen.has(src.url)){seen.add(src.url);src._topic=topicList[j];all.push(src);}
       }
     }
-    _htAll = all;
-    _htPage = 0;
     if(!all.length){box.innerHTML=`<div class="hashtag-sources"><h3>🔥 Tin HOT</h3><div style="color:#888;padding:8px">Đang cập nhật...</div></div>`;return;}
-    _renderHotPage(box, topicList);
+    let h=`<div class="hashtag-sources"><h3>🔥 Tin HOT tổng hợp <span style="font-size:10px;color:#888">(${all.length} bài · ${topicList.length} chủ đề)</span></h3><div id="ht-list">`;
+    all.slice(0,12).forEach((s,i)=>{
+      h+=`<div class="hashtag-src-item" onclick="readArticle('${esc(s.url)}')"><div class="hashtag-src-img" id="ht-img-${i}"></div><div class="hashtag-src-text"><div class="hashtag-src-title">${esc(s.title)}</div><div class="hashtag-src-via">${esc(s.via||'')} · <span style="color:#f0c040;font-size:9px">#${esc(s._topic||'')}</span></div></div></div>`;
+    });
+    h+=`</div><div style="display:flex;gap:4px;flex-wrap:wrap;margin-top:8px">`;
+    topicList.forEach(t=>{h+=`<button class="hot-chip" onclick="searchTopic('${t.replace(/'/g,"\\'")}')" style="font-size:10px">🔍 #${esc(t)}</button>`;});
+    h+=`</div></div>`;
+    box.innerHTML=h;
+    // Lazy load images
+    all.slice(0,12).forEach((s,i)=>{if(!s.url)return;fetch('/api/article?url='+encodeURIComponent(s.url)).then(r=>r.json()).then(d=>{if(d&&(d.og_image||d.img)){const el=document.getElementById('ht-img-'+i);if(el)el.innerHTML=`<img src="${esc(d.og_image||d.img)}" onerror="this.style.display='none'">`;}}).catch(()=>{});});
     _htTopic=topicList[0];
   }catch(e){box.innerHTML=`<div class="hashtag-sources"><h3>🔥 Tin HOT</h3><div style="color:#e74c3c;padding:8px">Lỗi tải tin</div></div>`;}
-}
-
-function _renderHotPage(box, topicList){
-  const start = 0;
-  const end = (_htPage + 1) * _HT_PER_PAGE;
-  const pageItems = _htAll.slice(0, end);
-  let h=`<div class="hashtag-sources"><h3>🔥 Tin HOT tổng hợp <span style="font-size:10px;color:#888">(${_htAll.length} bài · ${topicList.length} chủ đề)</span></h3><div id="ht-list">`;
-  pageItems.forEach((s,i)=>{
-    h+=`<div class="hashtag-src-item" onclick="readArticle('${esc(s.url)}')"><div class="hashtag-src-img" id="ht-img-${i}"></div><div class="hashtag-src-text"><div class="hashtag-src-title">${esc(s.title)}</div><div class="hashtag-src-via">${esc(s.via||'')} · <span style="color:#f0c040;font-size:9px">#${esc(s._topic||'')}</span></div></div></div>`;
-  });
-  h+=`</div><div style="display:flex;gap:4px;flex-wrap:wrap;margin-top:8px">`;
-  topicList.forEach(t=>{h+=`<button class="hot-chip" onclick="searchTopic('${t.replace(/'/g,"\\'")}')" style="font-size:10px">🔍 #${esc(t)}</button>`;});
-  h+=`</div>`;
-  // Nút lazy load - tải thêm tin
-  if (_htAll.length > end) {
-    h+=`<button class="hashtag-load-more" id="ht-load-more" onclick="_loadMoreHot()">Tải thêm ${Math.min(_HT_PER_PAGE, _htAll.length - end)} tin ▼</button>`;
-  }
-  h+=`</div>`;
-  box.innerHTML=h;
-  // Lazy load images
-  pageItems.forEach((s,i)=>{if(!s.url)return;fetch('/api/article?url='+encodeURIComponent(s.url)).then(r=>r.json()).then(d=>{if(d&&(d.og_image||d.img)){const el=document.getElementById('ht-img-'+i);if(el)el.innerHTML=`<img src="${esc(d.og_image||d.img)}" onerror="this.style.display='none'">`;}}).catch(()=>{});});
-}
-
-function _loadMoreHot(){
-  _htPage++;
-  const box = document.getElementById('hashtag-box');
-  if(!box)return;
-  // Extract topicList from the current buttons
-  const chipBtns = box.querySelectorAll('.hot-chip');
-  const topicList = Array.from(chipBtns).map(b => b.textContent.replace(/^🔍\s*#/, '').trim());
-  _renderHotPage(box, topicList.length ? topicList : [_htTopic]);
-  toast('📰 Đã tải thêm tin');
 }