feat(down list): port đường tải qua site tải hộ từ tool local down_ads

Bản web mới chỉ có yt-dlp + tikwm/ssstik, còn Douyin thì đi qua trang chia sẻ
iesdouyin — mà trang đó đã bị ByteDance rút sạch dữ liệu (đo 2026-09), nên
Douyin trên web coi như không tải được. Bản local down_ads đã giải bằng cách
hỏi các SITE TẢI HỘ; nay bê phần đó sang.

Thêm backend/app/services/downloader/webdl.py (port từ down_ads/core/webdl.py):
- 4 site: savetik, tiktokio, snapsave, lovetik; parser CHUNG (quét URL giống
link media, không dò thẻ/class) nên site đổi giao diện vẫn chạy.
- Lưới cuối: không khớp tên miền CDN nào thì quét mọi URL rồi HỎI SERVER cái nào
là video qua Content-Type — không cần biết trước tên miền.
- Đo dung lượng thật bằng Range rồi lấy bản to nhất; nhãn "MP4 HD" của savetik
trỏ file 576p nhỏ hơn cả link thường, không tin được.
- Bóc link CDN gốc trong token JWT của snapcdn; giữ token nguyên vẹn lúc tải vì
token dùng được đúng MỘT LẦN.
- Giữ nhịp hỏi theo từng site (savetik chịu ~1 request/2.5s).

Nối vào ydl.py:
- douyin: site tải hộ -> iesdouyin -> yt-dlp (trước là iesdouyin -> yt-dlp).
- tiktok: sau tikwm thì thử site tải hộ.
- download_many chạy SONG SONG (trần 4, đổi bằng DOWNLOAD_WORKERS) — trước là
vòng for tuần tự dù phần lớn thời gian chỉ ngồi chờ mạng. Giữ nguyên thứ tự
kết quả, 1 link hỏng không giết cả mẻ.

Khác bản local, đều vì môi trường máy chủ:
- KHÔNG gọi thẳng site. Space từng bị HF khoá vì "Suspicious domain call", nên
mọi request đi qua Worker relay. Worker thêm endpoint '?form=' (POST hộ, tự
gắn Referer/Origin) và '?proxy=' nay chuyển tiếp header Range.
- Bỏ lớp DNS-over-HTTPS + xoay IP của bản local: sinh ra để vượt nhà mạng VN
chặn savetik, Worker chạy IP Cloudflare nên không vướng — mà chính kiểu
outbound đó làm Space bị gắn cờ.
- Worker chưa deploy bản mới -> nhận ra ngay từ site đầu và báo đúng việc cần
làm, thay vì thử 4 site x 3 lần mất ~30s vô ích.

Kiểm thật (không phải mock): hỏi 4 site bằng link TikTok công khai -> savetik
1.2s/3 link, tiktokio 6.6s/3 link, snapsave và lovetik không ra link. Tải trọn
đường qua savetik: 8.9s, ra file h264 576x1024, 2.82 MB, 10.5s.

117/117 test PASS (thêm 12 test).

VIỆC CÒN LẠI CỦA USER: deploy lại Cloudflare Worker bằng bản mới của
deploy/tiktok_relay_worker.js, nếu không thì đường site tải hộ chưa chạy trên
Space (các đường cũ vẫn nguyên, không hồi quy).

Co-Authored-By: Claude Opus 5 <noreply@anthropic.com>

backend/app/services/downloader/webdl.py

@@ -0,0 +1,384 @@
+"""Tải video bằng cách HỎI CÁC SITE TẢI HỘ (savetik, tiktokio, snapsave, lovetik).
+
+Port từ tool local `down_ads` (core/webdl.py) sang bản chạy trên máy chủ. Đây là
+lưới dự phòng cho TikTok và là ĐƯỜNG CHÍNH cho Douyin: trang chia sẻ iesdouyin đã
+bị ByteDance rút sạch dữ liệu (đo 2026-09), API detail trả 403, nên `_douyin_direct`
+trong ydl.py gần như không còn tải được gì.
+
+Khác bản local ở hai chỗ, đều vì môi trường máy chủ:
+
+1. KHÔNG gọi thẳng site. Space từng bị Hugging Face khoá với lý do "Suspicious
+   domain call" vì IP máy chủ gọi thẳng các domain scraper. Nên mọi request ở đây
+   đi qua Worker relay (`TIKTOK_RELAY_URL`) — Worker mới cần endpoint `?form=`
+   (POST hộ) và `?proxy=` biết chuyển tiếp header Range. Dev local (không phải
+   Space) vẫn gọi thẳng cho tiện thử.
+2. Bỏ lớp DNS-over-HTTPS + xoay IP của bản local. Lớp đó sinh ra để vượt nhà mạng
+   VN chặn savetik.co; Worker chạy trên IP Cloudflare nên không vướng, mà kiểu
+   outbound đó chính là thứ làm Space bị gắn cờ.
+
+Parser CHUNG (quét mọi URL giống link media, không dò thẻ/class) nên site đổi giao
+diện vẫn chạy; thêm site mới chỉ là thêm một dòng vào SITES.
+"""
+
+from __future__ import annotations
+
+import base64
+import json
+import os
+import re
+import threading
+import time
+
+_UA = ("Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 "
+       "(KHTML, like Gecko) Chrome/124.0 Safari/537.36")
+
+# gap: nhịp tối thiểu giữa 2 lần hỏi CÙNG một site. Đo thực tế ở bản local:
+# savetik chỉ chịu ~1 request/2.5s, gọi dồn là 429 hàng loạt. Quan trọng hơn từ
+# khi download_many chạy SONG SONG — nhiều luồng cùng hỏi một site.
+BUILTIN_SITES: list[dict] = [
+    {"name": "savetik", "home": "https://savetik.co/vi",
+     "api": "https://savetik.co/api/ajaxSearch", "gap": 2.5},
+    {"name": "tiktokio", "home": "https://tiktokio.to/en",
+     "api": "https://tiktokio.to/api/ajaxSearch", "gap": 1.5},
+    {"name": "snapsave", "home": "https://snapsave.app/vn",
+     "api": "https://snapsave.app/action.php", "gap": 1.5},
+    {"name": "lovetik", "home": "https://lovetik.com/",
+     "api": "https://lovetik.com/api/ajax/search", "gap": 1.5},
+]
+
+
+def get_sites() -> list[dict]:
+    """Danh sách site. Đổi được bằng biến môi trường DL_SITES_JSON mà không build lại."""
+    raw = (os.environ.get("DL_SITES_JSON") or "").strip()
+    if raw:
+        try:
+            got = json.loads(raw)
+            if isinstance(got, list) and got:
+                return [s for s in got if s.get("api") and s.get("home")]
+        except Exception:
+            pass
+    return BUILTIN_SITES
+
+
+# Link media của Douyin/TikTok, hoặc link proxy của chính site tải hộ.
+MEDIA_RE = re.compile(
+    r"https?://[^\s\"'<>\\]{0,250}?"
+    r"(?:douyinvod|zjcdn|douyinstatic|bytecdn|amemv|tikcdn|snapcdn\.app/get"
+    r"|tikwm\.com/video|\.mp4)"
+    # Đuôi phải RỘNG: token JWT của dl.snapcdn.app dài hơn 250 ký tự. Cắt cụt thì
+    # link vừa hỏng vừa âm thầm rơi mất bản nét nhất (bản local đã dính: tải về
+    # 576p trong khi bản 1080p nằm ở đoạn link bị cắt).
+    r"[^\s\"'<>\\]{0,2000}",
+    re.I,
+)
+# Link chỉ là nhạc/ảnh bìa — không phải video cần tải.
+SKIP_RE = re.compile(r"(music|/aweme/v1/play|cover|avatar|thumb|\.jpe?g|\.png|\.mp3)", re.I)
+
+# Lưới cuối: nhận video KHÔNG dựa vào tên miền. MEDIA_RE vẫn phải liệt kê tên CDN
+# (zjcdn, douyinvod…) vì link Douyin không có đuôi .mp4 — ngày ByteDance đổi sang
+# CDN tên khác là regex đó trượt sạch. Khi không khớp gì, quét MỌI url rồi HỎI
+# SERVER cái nào là video (Content-Type), không cần biết trước tên miền nào.
+ANY_URL_RE = re.compile(r"https?://[^\s\"'<>\\)]{10,2000}", re.I)
+STATIC_RE = re.compile(
+    r"\.(css|js|mjs|png|jpe?g|gif|svg|webp|ico|woff2?|ttf|eot|xml|txt)(\?|$)", re.I)
+NOISE_RE = re.compile(
+    r"(google|gstatic|doubleclick|facebook|twitter|cloudflare|jquery|bootstrap"
+    r"|fontawesome|analytics|adsbygoogle|recaptcha|sentry|cdnjs)", re.I)
+
+_LOCK = threading.Lock()
+_LAST: dict[str, float] = {}
+
+
+def _wait(site: dict) -> None:
+    """Giữ nhịp hỏi cho TỪNG site, dùng chung cho mọi luồng tải."""
+    name, gap = site["name"], float(site.get("gap", 1.5))
+    with _LOCK:
+        wait = gap - (time.time() - _LAST.get(name, 0.0))
+        if wait > 0:
+            time.sleep(wait)
+        _LAST[name] = time.time()
+
+
+def _unescape(u: str) -> str:
+    return (u.replace("\\u002F", "/").replace("\\u0026", "&")
+             .replace("\\/", "/").replace("\\", "").replace("&amp;", "&"))
+
+
+def _snapcdn_origin(link: str) -> str:
+    """Link proxy dl.snapcdn.app/get?token=<JWT> có chứa sẵn link CDN gốc.
+
+    Token là JWT KHÔNG mã hoá: payload base64 chứa {"url": "<link thật>"}. Bóc ra
+    để lỡ proxy của họ hỏng thì vẫn tải thẳng được.
+    """
+    try:
+        payload = link.split("token=", 1)[1].split(".")[1]
+        payload += "=" * (-len(payload) % 4)
+        return json.loads(base64.urlsafe_b64decode(payload)).get("url") or ""
+    except Exception:
+        return ""
+
+
+# ───────────────────────── lớp đi mạng (relay hay thẳng) ─────────────────────
+
+class RelayTooOld(RuntimeError):
+    """Worker relay đang chạy bản CŨ, chưa có endpoint `?form=`.
+
+    Đây không phải lỗi site — thử tiếp 4 site nữa chỉ tốn thêm ~30s chờ vô ích,
+    nên gặp là dừng cả chuỗi và nói thẳng việc cần làm.
+    """
+
+
+def _relay() -> str | None:
+    from .ydl import _tiktok_relay
+    return _tiktok_relay()
+
+
+def _guard() -> None:
+    from .ydl import _guard_direct
+    _guard_direct("site tải hộ")
+
+
+def _post_site(site: dict, ask_url: str, timeout: int = 30):
+    """POST tới API của site -> requests.Response. Qua relay khi có cấu hình."""
+    import requests  # type: ignore
+
+    payload = {"q": ask_url, "url": ask_url, "query": ask_url, "lang": "vi"}
+    relay = _relay()
+    if relay:
+        # Worker POST hộ: nó tự gắn Referer/Origin theo `ref` nên site không chặn.
+        r = requests.post(relay, params={"form": site["api"], "ref": site["home"]},
+                          data=payload, timeout=timeout,
+                          headers={"User-Agent": _UA})
+        # Worker bản cũ không biết `?form=` -> trả JSON lỗi tham số của chính nó.
+        body = (r.text or "")[:200]
+        if "thiếu tham số" in body and '"code"' in body:
+            raise RelayTooOld(
+                "Worker relay chưa có endpoint '?form='. Mở Cloudflare Workers, dán đè "
+                "deploy/tiktok_relay_worker.js bản mới rồi Deploy lại.")
+        return r
+    _guard()                     # trên Space mà thiếu relay -> báo lỗi, KHÔNG gọi thẳng
+    hdr = {"User-Agent": _UA, "Referer": site["home"],
+           "Origin": site["home"].rstrip("/").rsplit("/", 1)[0],
+           "X-Requested-With": "XMLHttpRequest"}
+    return requests.post(site["api"], data=payload, headers=hdr, timeout=timeout)
+
+
+def _get_media(link: str, timeout: int = 60, stream: bool = False,
+               headers: dict | None = None):
+    """GET một URL media -> requests.Response. Qua relay khi có cấu hình.
+
+    Header `Range` được chuyển tiếp qua relay để đo dung lượng mà không tải cả file.
+    """
+    import requests  # type: ignore
+
+    hdr = dict(headers or {})
+    hdr.setdefault("User-Agent", _UA)
+    relay = _relay()
+    if relay:
+        fwd = {"User-Agent": _UA}
+        if hdr.get("Range"):
+            fwd["Range"] = hdr["Range"]
+        return requests.get(relay, params={"proxy": link}, timeout=timeout,
+                            stream=stream, headers=fwd)
+    _guard()
+    return requests.get(link, timeout=timeout, stream=stream, headers=hdr)
+
+
+# ────────────────────────────── hỏi site & chọn link ─────────────────────────
+
+def _sniff_video_urls(text: str, limit: int = 8) -> list[str]:
+    """Quét mọi url trong phản hồi rồi hỏi server cái nào là video.
+
+    Lưới cuối cho tình huống site/CDN đổi tên miền: không đoán theo tên, chỉ tải
+    1 byte đầu (Range) và xem Content-Type. Chỉ chạy khi cách nhanh phía trên
+    không tìm được gì nên không làm chậm đường chạy bình thường.
+    """
+    seen: list[str] = []
+    for m in ANY_URL_RE.finditer(text):
+        u = _unescape(m.group(0)).rstrip("\"',);")
+        if (u in seen or STATIC_RE.search(u) or NOISE_RE.search(u)
+                or SKIP_RE.search(u)):
+            continue
+        seen.append(u)
+        if len(seen) >= 60:
+            break
+    found: list[str] = []
+    for u in seen[:limit]:
+        try:
+            with _get_media(u, timeout=15, stream=True,
+                            headers={"Range": "bytes=0-0"}) as r:
+                ctype = (r.headers.get("Content-Type") or "").lower()
+                clen = r.headers.get("Content-Range") or r.headers.get("Content-Length") or ""
+            if ctype.startswith("video/") or ("octet-stream" in ctype and clen):
+                found.append(u)
+        except Exception:
+            continue
+    return found
+
+
+def _ask_site(site: dict, ask_url: str) -> tuple[list[str], str]:
+    """Hỏi 1 site -> (danh sách link media, tiêu đề). Ném lỗi nếu site không trả gì."""
+    text = ""
+    last = ""
+    for att in range(3):
+        _wait(site)
+        try:
+            r = _post_site(site, ask_url)
+            if r.status_code == 429:
+                last = "giới hạn tần suất (429)"
+                time.sleep(3.0 * (att + 1))
+                continue
+            text = r.text or ""
+            if len(text) >= 200:
+                break
+            last = f"HTTP {r.status_code}, phản hồi rỗng"
+        except RelayTooOld:
+            raise                                # không retry, không nuốt
+        except Exception as e:
+            from .ydl import clean_error
+            last = clean_error(e)
+        time.sleep(1.0 * (att + 1))
+    if not text:
+        raise RuntimeError(last or "không có phản hồi")
+
+    links: list[str] = []
+    for m in MEDIA_RE.finditer(text):
+        u = _unescape(m.group(0))
+        if not SKIP_RE.search(u) and u not in links:
+            links.append(u)
+    if not links:
+        links = _sniff_video_urls(text)
+    title = ""
+    mt = (re.search(r"<h3[^>]*>([^<]{1,200})</h3>", text)
+          or re.search(r'"(?:title|desc)"\s*:\s*"([^"]{1,200})"', text))
+    if mt:
+        title = _unescape(mt.group(1)).strip()
+    return links, title
+
+
+def _probe_size(link: str) -> int:
+    """Dung lượng thật, đo bằng 1 byte (Range) nên gần như không tốn gì.
+
+    QUAN TRỌNG: chỉ đo trên link CDN GỐC. Token dl.snapcdn.app dùng được đúng MỘT
+    LẦN — hỏi trước là lúc tải thật nhận 500, bản local đã dính rồi.
+    """
+    try:
+        with _get_media(link, timeout=20, stream=True,
+                        headers={"Range": "bytes=0-0"}) as r:
+            cr = r.headers.get("Content-Range", "")
+            if "/" in cr:
+                return int(cr.rsplit("/", 1)[1])
+            return int(r.headers.get("Content-Length") or 0)
+    except Exception:
+        return 0
+
+
+def _measure(link: str) -> tuple[int, str]:
+    """(dung lượng, link dùng để đo) — link snapcdn thì đo trên URL gốc trong token.
+
+    Không tin nhãn chất lượng của site: đo thực tế thấy nhãn "MP4 HD" của savetik
+    trỏ file 576p nhỏ hơn cả link thường 720p.
+    """
+    origin = _snapcdn_origin(link)
+    probe = origin or link
+    return _probe_size(probe), probe
+
+
+def _ask_url_for(url: str) -> str:
+    """Dạng link mà các site nhận chắc nhất (Douyin -> trang chia sẻ)."""
+    if "douyin.com" in url and "iesdouyin" not in url:
+        m = re.search(r"/video/(\d{6,})", url) or re.search(r"modal_id=(\d{6,})", url)
+        if m:
+            return f"https://www.iesdouyin.com/share/video/{m.group(1)}/"
+    return url
+
+
+def _safe_name(title: str, fallback: str) -> str:
+    import html as _html
+    # Site trả tiêu đề dạng HTML (&#x1F60D;, &amp;) -> giải mã trước, không thì tên
+    # file đầy mã thực thể, nhìn như lỗi. Test thật trên savetik đã dính.
+    s = re.sub(r'[\\/:*?"<>|\n\r\t]+', "_", _html.unescape(title or ""))[:60].strip()
+    return s or fallback
+
+
+def _unique_path(path: str) -> str:
+    if not os.path.exists(path):
+        return path
+    base, ext = os.path.splitext(path)
+    for i in range(2, 999):
+        cand = f"{base} ({i}){ext}"
+        if not os.path.exists(cand):
+            return cand
+    return path
+
+
+def _stream_to_file(link: str, path: str) -> None:
+    """Tải link về file. Ghi ra .part rồi đổi tên -> không để lại file dở."""
+    tmp = path + ".part"
+    try:
+        with _get_media(link, timeout=120, stream=True) as r:
+            r.raise_for_status()
+            with open(tmp, "wb") as f:
+                for chunk in r.iter_content(1 << 17):
+                    if chunk:
+                        f.write(chunk)
+    except BaseException:
+        try:
+            os.remove(tmp)
+        except OSError:
+            pass
+        raise
+    os.replace(tmp, path)
+
+
+def download_via_sites(url: str, out_dir: str) -> dict:
+    """Thử lần lượt các site tới khi ra VIDEO THẬT. Ném lỗi nếu hết site.
+
+    Trả dict: {path, title, ext, size, duration, url, via}.
+    """
+    from .ydl import _has_video_stream, clean_error
+
+    ask = _ask_url_for(url)
+    m = re.search(r"/(?:video|photo)/(\d{6,})", url) or re.search(r"(\d{15,})", url)
+    vid = m.group(1) if m else "video"
+    errors: list[str] = []
+
+    for site in get_sites():
+        try:
+            links, title = _ask_site(site, ask)
+        except RelayTooOld as e:
+            raise RuntimeError(str(e))          # site nào cũng sẽ hỏng như nhau
+        except Exception as e:
+            errors.append(f"{site['name']}: {clean_error(e)[:70]}")
+            continue
+        if not links:
+            errors.append(f"{site['name']}: không thấy link video")
+            continue
+
+        # Đo dung lượng thật rồi lấy bản TO NHẤT (= nét nhất). Với link proxy thì
+        # đo trên URL gốc bóc từ token, giữ token nguyên vẹn cho lúc tải.
+        measured = [(sz, probe, u) for u, (sz, probe) in
+                    ((u, _measure(u)) for u in links[:6])]
+        measured.sort(key=lambda t: -t[0])
+        targets: list[str] = []
+        for _sz, probe, u in measured:
+            for cand in (probe, u):          # ưu tiên CDN gốc, hỏng thì qua proxy
+                if cand and cand not in targets:
+                    targets.append(cand)
+
+        for target in targets[:8]:
+            path = _unique_path(os.path.join(
+                out_dir, f"{_safe_name(title, vid)} [{vid}].mp4"))
+            try:
+                _stream_to_file(target, path)
+                if not _has_video_stream(path):
+                    os.remove(path)
+                    continue
+                from .ydl import _duration
+                return {"path": path, "title": title or vid, "ext": "mp4",
+                        "size": os.path.getsize(path), "duration": _duration(path),
+                        "url": url, "via": site["name"]}
+            except Exception as e:
+                errors.append(f"{site['name']}: tải lỗi {clean_error(e)[:50]}")
+
+    raise RuntimeError("mọi site tải hộ đều không ra video — " + " | ".join(errors[:4]))

backend/app/services/downloader/ydl.py

@@ -153,6 +153,21 @@ def _has_video_stream(path: str) -> bool:
         return False
 
 
+def _duration(path: str) -> float:
+    """Thời lượng file (giây). Không đọc được -> 0.0, không làm hỏng luồng tải."""
+    import shutil as _sh
+    import subprocess as _sp
+    ff = _sh.which("ffprobe") or "ffprobe"
+    try:
+        out = _sp.run(
+            [ff, "-v", "error", "-show_entries", "format=duration",
+             "-of", "csv=p=0", path],
+            capture_output=True, text=True).stdout.strip()
+        return float(out)
+    except Exception:
+        return 0.0
+
+
 # Trình duyệt giả để nhiều site (Douyin/TikTok...) không chặn request như bot.
 _UA = ("Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 "
        "(KHTML, like Gecko) Chrome/124.0.0.0 Safari/537.36")
@@ -443,6 +458,18 @@ _UA_MOBILE = ("Mozilla/5.0 (iPhone; CPU iPhone OS 16_0 like Mac OS X) "
               "Mobile/15E148 Safari/604.1")
 
 
+def _via_sites(url: str, out_dir: str) -> DownloadResult:
+    """Tải qua các SITE TẢI HỘ (savetik/tiktokio/snapsave/lovetik).
+
+    Port từ tool local `down_ads`. Nhiều nguồn độc lập nhau nên một site chết
+    không kéo sập cả đường tải. Chi tiết xem services/downloader/webdl.py.
+    """
+    from . import webdl
+    d = webdl.download_via_sites(url, out_dir)
+    return DownloadResult(url=url, ok=True, path=d["path"], title=d["title"],
+                          ext=d["ext"], size=d["size"], duration=d["duration"])
+
+
 def _douyin_direct(url: str, out_dir: str) -> DownloadResult:
     """Tải Douyin KHÔNG cần cookies.
 
@@ -826,16 +853,24 @@ def download_one(url: str, out_dir: str, cookies_file: str | None = None) -> Dow
     os.makedirs(out_dir, exist_ok=True)
     url = normalize_url(url)
     source = detect_source(url)
-    # Douyin: dùng cách bóc link trực tiếp (không cookies) TRƯỚC; yt-dlp là dự phòng.
+    # Douyin: HỎI SITE TẢI HỘ trước. Trang chia sẻ iesdouyin đã bị ByteDance rút
+    # sạch dữ liệu (đo 2026-09: `_ROUTER_DATA` chỉ còn ua/webId/itemId) và API
+    # detail trả 403, nên `_douyin_direct` gần như luôn fail — nay nó tụt xuống
+    # làm lưới dự phòng, yt-dlp là lớp cuối.
     if source == "douyin":
-        try:
-            return _douyin_direct(url, out_dir)
-        except Exception as e_d:
+        errs = []
+        for name, fn in (("site tải hộ", lambda: _via_sites(url, out_dir)),
+                         ("iesdouyin", lambda: _douyin_direct(url, out_dir))):
             try:
-                return _attempt(url, out_dir, _build_opts(out_dir, cookies_file, source=source))
-            except Exception:
-                return DownloadResult(url=url, ok=False,
-                                      error=clean_error(f"douyin: {e_d}"))
+                return fn()
+            except Exception as e_d:
+                errs.append(f"{name}: {clean_error(e_d)}")
+        try:
+            return _attempt(url, out_dir, _build_opts(out_dir, cookies_file, source=source))
+        except Exception as e_y:
+            errs.append(f"yt-dlp: {clean_error(e_y)}")
+            return DownloadResult(url=url, ok=False,
+                                  error=clean_error("douyin — " + " | ".join(errs[:3])))
     try:
         return _attempt(url, out_dir, _build_opts(out_dir, cookies_file, source=source))
     except Exception as e:  # pragma: no cover - lỗi mạng/extractor
@@ -862,6 +897,12 @@ def download_one(url: str, out_dir: str, cookies_file: str | None = None) -> Dow
             try:
                 return _tiktok_via_tikwm(url, out_dir)
             except Exception as e_tk:
+                # Lưới cuối: hỏi các site tải hộ (savetik/tiktokio/…) — cùng cách
+                # bản local down_ads dùng, nhiều nguồn thì khó chết cả loạt.
+                try:
+                    return _via_sites(url, out_dir)
+                except Exception as e_site:
+                    e_tk = RuntimeError(f"{clean_error(e_tk)} | {clean_error(e_site)}")
                 msg = f"{first_err} | tikwm: {e_tk}"
                 # Ads nhắm mục tiêu (targeted Spark Ads) đôi khi chỉ hiện trong app
                 # cho đúng tài khoản được target -> KHÔNG server nào (kể cả tikwm) có
@@ -882,14 +923,51 @@ def download_one(url: str, out_dir: str, cookies_file: str | None = None) -> Dow
         return DownloadResult(url=url, ok=False, error=first_err)
 
 
+def _dl_workers(n: int) -> int:
+    """Số link tải CÙNG LÚC. Tải là chờ MẠNG chứ không ăn CPU nên chạy song song
+    rất lợi; trần 4 để không dội request vào cùng một nguồn (savetik chỉ chịu
+    ~1 request/2.5s — webdl tự giữ nhịp, nhưng đông luồng quá thì chỉ xếp hàng
+    lâu hơn chứ không nhanh thêm)."""
+    env = (os.environ.get("DOWNLOAD_WORKERS") or "").strip()
+    if env.isdigit():
+        return max(1, min(8, int(env)))
+    return max(1, min(4, n))
+
+
 def download_many(urls: list[str], out_dir: str,
                   cookies_file: str | None = None,
                   on_item: Callable[[int, DownloadResult], None] | None = None
                   ) -> list[DownloadResult]:
-    results = []
-    for i, url in enumerate(urls):
-        res = download_one(url, out_dir, cookies_file)
-        results.append(res)
+    """Tải nhiều link SONG SONG, giữ nguyên thứ tự kết quả theo thứ tự link vào.
+
+    Trước đây chạy tuần tự từng link: 20 link mỗi link 5s = 100s dù phần lớn thời
+    gian chỉ ngồi chờ mạng. `on_item` được gọi NGAY khi từng link xong (không theo
+    thứ tự) để thanh tiến độ nhúc nhích liên tục.
+    """
+    from concurrent.futures import ThreadPoolExecutor
+    import threading as _th
+
+    n = len(urls)
+    results: list[DownloadResult | None] = [None] * n
+    if n == 0:
+        return []
+    lock = _th.Lock()
+
+    def one(i: int):
+        try:
+            res = download_one(urls[i], out_dir, cookies_file)
+        except Exception as e:                 # không để 1 link làm chết cả mẻ
+            res = DownloadResult(url=urls[i], ok=False, error=clean_error(e))
+        results[i] = res
         if on_item:
-            on_item(i, res)
-    return results
+            with lock:                         # on_item ghi tiến độ job -> gọi 1 luồng
+                on_item(i, res)
+
+    workers = _dl_workers(n)
+    if workers <= 1 or n == 1:
+        for i in range(n):
+            one(i)
+    else:
+        with ThreadPoolExecutor(max_workers=workers) as ex:
+            list(ex.map(one, range(n)))
+    return [r for r in results if r is not None]

backend/tests/test_webdl.py

@@ -0,0 +1,305 @@
+"""Test đường tải qua SITE TẢI HỘ (savetik/tiktokio/…) và tải nhiều link song song.
+
+Không gọi mạng thật: thay `requests` trong module bằng bản giả, để kiểm ĐÚNG
+cái mình viết — chọn link to nhất, bóc link gốc trong token snapcdn, đi qua relay
+khi có TIKTOK_RELAY_URL, và một link hỏng không kéo sập cả mẻ.
+"""
+from __future__ import annotations
+
+import base64
+import json
+import os
+import subprocess
+import tempfile
+import time
+
+from app.services.downloader import webdl, ydl
+from tests._util import FFMPEG
+
+
+class _Resp:
+    def __init__(self, text="", content=b"", status=200, headers=None):
+        self.text = text
+        self.content = content
+        self.status_code = status
+        self.headers = headers or {}
+
+    def raise_for_status(self):
+        if self.status_code >= 400:
+            raise RuntimeError(f"HTTP {self.status_code}")
+
+    def iter_content(self, _n=1 << 17):
+        yield self.content
+
+    def __enter__(self):
+        return self
+
+    def __exit__(self, *a):
+        return False
+
+
+class _FakeRequests:
+    """requests giả — ghi lại mọi lời gọi để test soi được đi đường nào."""
+
+    def __init__(self, on_post, on_get):
+        self.on_post, self.on_get = on_post, on_get
+        self.posts, self.gets = [], []
+
+    def post(self, url, **kw):
+        self.posts.append((url, kw))
+        return self.on_post(url, kw)
+
+    def get(self, url, **kw):
+        self.gets.append((url, kw))
+        return self.on_get(url, kw)
+
+
+def _install(monkey_requests):
+    """Nhét requests giả vào webdl (module import requests bên trong hàm)."""
+    import sys
+    sys.modules["requests"] = monkey_requests          # type: ignore
+    return monkey_requests
+
+
+def _restore():
+    import importlib
+    import sys
+    sys.modules.pop("requests", None)
+    try:
+        importlib.import_module("requests")
+    except Exception:
+        pass
+
+
+def _snapcdn_link(origin: str) -> str:
+    """Dựng link dl.snapcdn.app/get?token=<JWT> có nhúng link gốc, như savetik trả."""
+    payload = base64.urlsafe_b64encode(
+        json.dumps({"url": origin}).encode()).decode().rstrip("=")
+    return f"https://dl.snapcdn.app/get?token=hdr.{payload}.sig"
+
+
+def _real_mp4(path: str) -> bytes:
+    subprocess.run([FFMPEG, "-y", "-v", "error", "-f", "lavfi",
+                    "-i", "color=c=red:s=64x64:d=1:r=10",
+                    "-c:v", "libx264", "-pix_fmt", "yuv420p", path],
+                   check=True, capture_output=True)
+    return open(path, "rb").read()
+
+
+def test_snapcdn_origin_boc_duoc_link_goc():
+    """Token snapcdn là JWT không mã hoá -> bóc ra link CDN gốc để đo/tải thẳng."""
+    origin = "https://v3-web.douyinvod.com/abc/video.mp4?a=1&b=2"
+    assert webdl._snapcdn_origin(_snapcdn_link(origin)) == origin
+    assert webdl._snapcdn_origin("https://khong-phai-token.mp4") == ""
+
+
+def test_media_re_khong_cat_cut_token_dai():
+    """JWT của snapcdn dài >250 ký tự — regex cắt cụt là âm thầm tụt chất lượng."""
+    long_token = "https://dl.snapcdn.app/get?token=" + ("a" * 1200)
+    got = webdl.MEDIA_RE.search(f'html "{long_token}" html')
+    assert got and got.group(0) == long_token
+
+
+def test_ask_url_for_doi_douyin_sang_trang_chia_se():
+    assert webdl._ask_url_for("https://www.douyin.com/video/7123456789012345678") == \
+        "https://www.iesdouyin.com/share/video/7123456789012345678/"
+    tt = "https://www.tiktok.com/@a/video/123456789012"
+    assert webdl._ask_url_for(tt) == tt          # tiktok giữ nguyên
+
+
+def test_download_via_sites_chon_ban_to_nhat():
+    """Site trả 2 link; phải ĐO dung lượng thật rồi lấy bản to hơn, không tin nhãn."""
+    d = tempfile.mkdtemp()
+    small = "https://v3.douyinvod.com/small.mp4"
+    big = "https://v3.douyinvod.com/big.mp4"
+    big_bytes = _real_mp4(os.path.join(d, "src.mp4"))
+    sizes = {small: 1000, big: 999999}
+    tai_ve = []
+
+    def on_post(url, kw):
+        # site trả nhãn ngược: "MP4 HD" gán cho link NHỎ (đúng như savetik thật)
+        return _Resp(text=f'<h3>Clip thu nghiem</h3> "MP4 HD" {small} ... {big} ' + "x" * 300)
+
+    def on_get(url, kw):
+        if kw.get("headers", {}).get("Range"):           # đang ĐO dung lượng
+            return _Resp(headers={"Content-Range": f"bytes 0-0/{sizes.get(url, 0)}"})
+        tai_ve.append(url)
+        return _Resp(content=big_bytes)
+
+    fake = _FakeRequests(on_post, on_get)
+    _install(fake)
+    try:
+        res = webdl.download_via_sites("https://www.douyin.com/video/7123456789012345678", d)
+    finally:
+        _restore()
+
+    assert tai_ve[0] == big, f"phải tải bản to nhất, lại tải {tai_ve[0]}"
+    assert res["size"] == len(big_bytes) and res["duration"] > 0
+    assert res["title"] == "Clip thu nghiem" and res["via"] == "savetik"
+    assert os.path.exists(res["path"]) and not os.path.exists(res["path"] + ".part")
+
+
+def test_download_via_sites_bo_file_khong_phai_video():
+    """Site trả trang HTML/ảnh rác -> phải bỏ, không nhận bừa là video."""
+    d = tempfile.mkdtemp()
+    link = "https://v3.douyinvod.com/rac.mp4"
+
+    def on_post(url, kw):
+        return _Resp(text=f'"{link}" ' + "x" * 300)
+
+    def on_get(url, kw):
+        if kw.get("headers", {}).get("Range"):
+            return _Resp(headers={"Content-Length": "500"})
+        return _Resp(content=b"<html>khong phai video</html>")
+
+    _install(_FakeRequests(on_post, on_get))
+    try:
+        err = ""
+        try:
+            webdl.download_via_sites("https://www.douyin.com/video/7123456789012345678", d)
+        except RuntimeError as e:
+            err = str(e)
+    finally:
+        _restore()
+    assert "không ra video" in err, err
+    assert not [f for f in os.listdir(d) if f.endswith((".mp4", ".part"))], os.listdir(d)
+
+
+def test_di_qua_relay_khi_co_cau_hinh():
+    """Có TIKTOK_RELAY_URL -> KHÔNG được gọi thẳng savetik (Space từng bị HF khoá
+    vì gọi thẳng domain scraper); mọi request phải đi qua Worker."""
+    d = tempfile.mkdtemp()
+    link = "https://v3.douyinvod.com/a.mp4"
+    mp4 = _real_mp4(os.path.join(d, "src.mp4"))
+
+    def on_post(url, kw):
+        return _Resp(text=f'"{link}" ' + "x" * 300)
+
+    def on_get(url, kw):
+        if kw.get("headers", {}).get("Range"):
+            return _Resp(headers={"Content-Range": "bytes 0-0/123"})
+        return _Resp(content=mp4)
+
+    fake = _FakeRequests(on_post, on_get)
+    _install(fake)
+    old = os.environ.get("TIKTOK_RELAY_URL", "")
+    os.environ["TIKTOK_RELAY_URL"] = "https://relay.example.dev"
+    try:
+        webdl.download_via_sites("https://www.douyin.com/video/7123456789012345678", d)
+    finally:
+        os.environ["TIKTOK_RELAY_URL"] = old
+        _restore()
+
+    assert all(u.startswith("https://relay.example.dev") for u, _ in fake.posts), fake.posts
+    assert all(u.startswith("https://relay.example.dev") for u, _ in fake.gets), fake.gets
+    # POST phải kèm ?form=<api site> + ?ref=<home> để Worker gắn đúng Referer
+    params = fake.posts[0][1]["params"]
+    assert params["form"] == "https://savetik.co/api/ajaxSearch"
+    assert params["ref"] == "https://savetik.co/vi"
+    # GET media đi qua ?proxy= và có chuyển tiếp Range khi đo dung lượng
+    assert fake.gets[0][1]["params"]["proxy"] == link
+    assert fake.gets[0][1]["headers"].get("Range") == "bytes=0-0"
+
+
+def test_giu_nhip_hoi_cung_mot_site():
+    """Nhiều luồng cùng hỏi 1 site phải xếp hàng theo `gap`, nếu không là 429 hàng loạt."""
+    site = {"name": "test_gap", "home": "https://x.dev", "api": "https://x.dev/a", "gap": 0.4}
+    webdl._LAST.pop("test_gap", None)
+    t0 = time.time()
+    webdl._wait(site)
+    webdl._wait(site)
+    assert time.time() - t0 >= 0.35
+
+
+def test_download_many_chay_song_song_va_giu_thu_tu():
+    """Tải nhiều link cùng lúc; kết quả vẫn theo đúng thứ tự link vào."""
+    calls = []
+
+    def fake_one(url, out_dir, cookies_file=None):
+        calls.append(url)
+        time.sleep(0.3)                     # giả lập chờ mạng
+        return ydl.DownloadResult(url=url, ok=True, path=f"/tmp/{url[-1]}.mp4")
+
+    urls = [f"https://x.dev/v{i}" for i in range(4)]
+    orig = ydl.download_one
+    ydl.download_one = fake_one
+    try:
+        t0 = time.time()
+        res = ydl.download_many(urls, "/tmp")
+        el = time.time() - t0
+    finally:
+        ydl.download_one = orig
+
+    assert [r.url for r in res] == urls, "phải giữ nguyên thứ tự link vào"
+    assert el < 0.9, f"4 link x 0.3s mà mất {el:.2f}s -> vẫn đang chạy tuần tự"
+
+
+def test_download_many_mot_link_hong_khong_giet_ca_me():
+    def fake_one(url, out_dir, cookies_file=None):
+        if url.endswith("2"):
+            raise RuntimeError("link nay hong")
+        return ydl.DownloadResult(url=url, ok=True)
+
+    urls = [f"https://x.dev/v{i}" for i in range(4)]
+    orig = ydl.download_one
+    ydl.download_one = fake_one
+    try:
+        res = ydl.download_many(urls, "/tmp")
+    finally:
+        ydl.download_one = orig
+
+    assert len(res) == 4
+    assert [r.ok for r in res] == [True, True, False, True]
+    assert "link nay hong" in res[2].error
+
+
+def test_download_many_bao_tien_do_tung_link():
+    seen = []
+
+    def fake_one(url, out_dir, cookies_file=None):
+        return ydl.DownloadResult(url=url, ok=True)
+
+    orig = ydl.download_one
+    ydl.download_one = fake_one
+    try:
+        ydl.download_many([f"https://x.dev/v{i}" for i in range(3)], "/tmp",
+                          on_item=lambda i, r: seen.append(i))
+    finally:
+        ydl.download_one = orig
+    assert sorted(seen) == [0, 1, 2]
+
+
+def test_worker_cu_thi_dung_ngay_va_noi_ro_viec_can_lam():
+    """Worker chưa deploy bản mới -> không thử vô ích 4 site x 3 lần, báo thẳng."""
+    d = tempfile.mkdtemp()
+
+    def on_post(url, kw):
+        # đúng ph��n hồi của Worker bản cũ khi gặp tham số nó không biết
+        return _Resp(text='{"code":-1,"msg":"thiếu tham số ?url= hoặc ?proxy="}', status=400)
+
+    fake = _FakeRequests(on_post, lambda u, k: _Resp())
+    _install(fake)
+    old = os.environ.get("TIKTOK_RELAY_URL", "")
+    os.environ["TIKTOK_RELAY_URL"] = "https://relay.example.dev"
+    err = ""
+    t0 = time.time()
+    try:
+        webdl.download_via_sites("https://www.douyin.com/video/7123456789012345678", d)
+    except RuntimeError as e:
+        err = str(e)
+    finally:
+        os.environ["TIKTOK_RELAY_URL"] = old
+        _restore()
+    el = time.time() - t0
+
+    assert "?form=" in err and "Deploy" in err, err
+    assert len(fake.posts) == 1, f"phải dừng sau site đầu, lại hỏi {len(fake.posts)} lần"
+    assert el < 3, f"mất {el:.1f}s — vẫn đang chờ retry vô ích"
+
+
+def test_ten_file_giai_ma_thuc_the_html():
+    """Site trả tiêu đề dạng HTML; tên file không được dính &#x...; hay &amp;."""
+    assert "&#x1F60D;" not in webdl._safe_name("Vui&#x1F60D; &amp; khoe", "x")
+    assert "&" in webdl._safe_name("Vui &amp; khoe", "x")
+    assert webdl._safe_name("", "du_phong") == "du_phong"
+    assert "/" not in webdl._safe_name("a/b\c", "x")

deploy/tiktok_relay_worker.js

@@ -20,6 +20,8 @@
  *   <URL>/?url=<link tiktok>          -> JSON (xem code, _via)
  *   <URL>/?url=<link>&only=ssstik     -> ép chỉ thử ssstik
  *   <URL>/?url=<link>&only=tikwm      -> ép chỉ thử tikwm
+ *   <URL>/?form=<api site>&ref=<home>  -> POST hộ tới site tải hộ (savetik...)
+ *   <URL>/?proxy=<url media>           -> tải hộ file; chuyển tiếp cả header Range
  */
 
 const UA_MOBILE =
@@ -114,6 +116,7 @@ export default {
     const u = new URL(request.url);
     const target = u.searchParams.get("url");
     const proxy = u.searchParams.get("proxy");
+    const form = u.searchParams.get("form"); // POST hộ tới site tải hộ
     const resolve = u.searchParams.get("resolve"); // giải link rút gọn -> URL cuối
     const only = u.searchParams.get("only"); // "ssstik" | "tikwm" | null
 
@@ -128,21 +131,58 @@ export default {
         return jsonResp({ code: 0, url: r.url || resolve });
       }
 
+      // POST hộ tới API của các SITE TẢI HỘ (savetik, tiktokio, snapsave,
+      // lovetik). Backend không gọi thẳng được vì (a) IP Space bị Cloudflare của
+      // họ chặn 403, (b) HF từng khoá Space vì "Suspicious domain call" khi máy
+      // chủ gọi thẳng domain scraper. Mấy API này CHỈ nhận POST form-urlencoded
+      // (thử GET trả 404), nên phải có endpoint riêng chứ ?proxy= không thay được.
+      if (form) {
+        const home = u.searchParams.get("ref") || "";
+        const origin = home ? new URL(home).origin : "";
+        const body = await request.text();
+        const r = await fetch(form, {
+          method: "POST",
+          headers: {
+            "User-Agent": UA_DESKTOP,
+            "Content-Type": "application/x-www-form-urlencoded",
+            "X-Requested-With": "XMLHttpRequest",
+            ...(home ? { Referer: home } : {}),
+            ...(origin ? { Origin: origin } : {}),
+          },
+          body,
+        });
+        return new Response(await r.text(), {
+          status: r.status,
+          headers: { ...CORS, "Content-Type": r.headers.get("content-type") || "text/plain" },
+        });
+      }
+
       // Tải hộ 1 file media (video/ảnh/nhạc) / trang share qua IP sạch.
       if (proxy) {
         // Referer PHẢI đúng theo nguồn: CDN Douyin (aweme.snssdk/douyinvod...)
-        // chống hotlink — sai Referer -> 403. Douyin -> douyin.com; còn lại
-        // (tikcdn/tikwm) -> tikwm.com.
-        const ref = /douyin|snssdk|iesdouyin/i.test(proxy)
+        // chống hotlink — sai Referer -> 403. Douyin -> douyin.com; link proxy
+        // của site tải hộ -> chính site đó; còn lại (tikcdn/tikwm) -> tikwm.com.
+        const ref = /douyin|snssdk|iesdouyin|zjcdn|bytecdn/i.test(proxy)
           ? "https://www.douyin.com/"
+          : /snapcdn\.app/i.test(proxy)
+          ? "https://savetik.co/"
           : "https://www.tikwm.com/";
+        // Chuyển tiếp Range: backend đo dung lượng thật bằng 'bytes=0-0' để chọn
+        // bản nét nhất. Không chuyển tiếp thì mỗi lần đo là tải trọn cả file.
+        const range = request.headers.get("Range");
         const r = await fetch(proxy, {
-          headers: { "User-Agent": UA_MOBILE, "Referer": ref },
-        });
-        return new Response(r.body, {
-          status: r.status,
-          headers: { ...CORS, "Content-Type": r.headers.get("content-type") || "application/octet-stream" },
+          headers: {
+            "User-Agent": UA_MOBILE, "Referer": ref,
+            ...(range ? { Range: range } : {}),
+          },
         });
+        const pass = { ...CORS,
+          "Content-Type": r.headers.get("content-type") || "application/octet-stream" };
+        for (const h of ["content-length", "content-range", "accept-ranges"]) {
+          const v = r.headers.get(h);
+          if (v) pass[h] = v;
+        }
+        return new Response(r.body, { status: r.status, headers: pass });
       }
 
       if (target) {
@@ -160,7 +200,7 @@ export default {
         return jsonResp({ code: -1, msg: errs.join(" | ") });
       }
 
-      return jsonResp({ code: -1, msg: "thiếu tham số ?url= hoặc ?proxy=" }, 400);
+      return jsonResp({ code: -1, msg: "thiếu tham số ?url= / ?proxy= / ?form= / ?resolve=" }, 400);
     } catch (e) {
       return jsonResp({ code: -1, msg: String(e) }, 502);
     }