@iducky/media-agent 1.1.0

package/src/media_agent/platforms/douyin/validate_rankings.py

@@ -0,0 +1,254 @@
+#!/usr/bin/env python3
+"""Offline regression validator for douyin video ranking output files.
+Usage: python3 validate_rankings.py <output_dir>
+Exits 0 on all passes, non-zero on any failure."""
+import json, sys, os
+from pathlib import Path
+
+RT = ['线索榜', '引流榜', '热门榜']
+EXPECTED_HEADERS = {
+    '线索榜': ['线索指数', '线索工具覆盖率', '线索工具点击率'],
+    '引流榜': ['直播引流指数', '视频热度'],
+    '热门榜': ['视频热度', '流量指数', '互动指数'],
+}
+REQUIRED_FIELDS = ['title', 'author', 'douyin_id', 'publish_date', 'cover_url']
+
+def validate(output_dir):
+    base = Path(output_dir)
+    errors = []
+    warnings = []
+    
+    json_files = sorted(base.glob('douyin_video_rankings_*.json'))
+    xlsx_files = sorted(base.glob('douyin_video_rankings_*.xlsx'))
+    meta_files = sorted(base.glob('douyin_video_rankings_*.meta.json'))
+    
+    if not json_files: errors.append('NO_JSON_FILE'); return errors, 1
+    if not meta_files: errors.append('NO_META_FILE'); return errors, 1
+    
+    jf, mf = json_files[0], meta_files[0]
+    
+    # Load JSON
+    try: data = json.loads(jf.read_text())
+    except Exception as e: errors.append(f'JSON_PARSE: {e}'); return errors, 1
+    
+    try: meta = json.loads(mf.read_text())
+    except Exception as e: errors.append(f'META_PARSE: {e}'); return errors, 1
+    
+    print(f'JSON: {jf.name}', flush=True)
+    print(f'META: {mf.name}', flush=True)
+    
+    # === 1. Counts ===
+    total = 0
+    for rt in RT:
+        items = data.get('rankings', {}).get(rt, [])
+        total += len(items)
+        if len(items) != 20:
+            errors.append(f'COUNT_{rt}: expected 20, got {len(items)}')
+        else:
+            print(f'  {rt}: 20 items ✓', flush=True)
+    
+    if total != 60:
+        errors.append(f'TOTAL: expected 60, got {total}')
+    else:
+        print(f'  Total: 60 ✓', flush=True)
+    
+    if meta.get('total_count') != total:
+        errors.append(f'META_TOTAL: {meta.get("total_count")} != {total}')
+    
+    # === 2. Ranks ===
+    all_ranks = {}
+    for rt in RT:
+        items = data.get('rankings', {}).get(rt, [])
+        ranks = sorted([i['global_rank'] for i in items])
+        missing = [r for r in range(1, 21) if r not in ranks]
+        all_ranks[rt] = {'ranks': ranks, 'missing': missing}
+        if missing:
+            errors.append(f'RANK_{rt}: missing {missing}')
+        else:
+            print(f'  {rt}: ranks 1-20 continuous ✓', flush=True)
+    
+    if not all(len(v['missing']) == 0 for v in all_ranks.values()):
+        errors.append('RANK_CONTINUITY_FAILED')
+    
+    # === 3. Industry ===
+    industry = data.get('industry_display', '')
+    if '汽车' not in industry or '汽车厂商' not in industry:
+        errors.append(f'INDUSTRY: expected 汽车/汽车厂商, got {industry}')
+    else:
+        print(f'  Industry: {industry} ✓', flush=True)
+    
+    if meta.get('industry_verified') != True:
+        errors.append('INDUSTRY_NOT_VERIFIED')
+    else:
+        print(f'  industry_verified: true ✓', flush=True)
+    
+    if meta.get('page2_dom_verified') != True:
+        errors.append('PAGE2_NOT_VERIFIED')
+    else:
+        print(f'  page2_dom_verified: true ✓', flush=True)
+    
+    # === 4. Field validation ===
+    douyin_suffix_err = 0
+    title_eq_author = 0
+    empty_fields = {f: 0 for f in REQUIRED_FIELDS}
+    col_temp = 0
+    
+    for rt in RT:
+        items = data.get('rankings', {}).get(rt, [])
+        for item in items:
+            r = item['global_rank']
+            for field in REQUIRED_FIELDS:
+                if not item.get(field):
+                    empty_fields[field] += 1
+                    errors.append(f'EMPTY_{field}: {rt} rank {r}')
+            if '发布时间' in item.get('douyin_id', ''):
+                douyin_suffix_err += 1
+            if item.get('title') == item.get('author'):
+                title_eq_author += 1
+            # Check for temp columns
+            for k in item.keys():
+                if k.startswith('col_') and k[4:].isdigit():
+                    col_temp += 1
+    
+    for field in REQUIRED_FIELDS:
+        if empty_fields[field] > 0:
+            errors.append(f'EMPTY_{field}_COUNT: {empty_fields[field]}')
+        else:
+            print(f'  {field}: all non-empty ✓', flush=True)
+    
+    if douyin_suffix_err > 0:
+        errors.append(f'DOUYIN_SUFFIX: {douyin_suffix_err} items')
+    else:
+        print(f'  douyin_id: no suffix errors ✓', flush=True)
+    
+    if title_eq_author > 0:
+        errors.append(f'TITLE_EQ_AUTHOR: {title_eq_author} items')
+    else:
+        print(f'  title != author: all ✓', flush=True)
+    
+    if col_temp > 0:
+        errors.append(f'COL_TEMP: {col_temp} temp fields')
+    else:
+        print(f'  no col_N temp fields ✓', flush=True)
+    
+    # === 5. Metric headers ===
+    for rt in RT:
+        items = data.get('rankings', {}).get(rt, [])
+        if not items: continue
+        expected = EXPECTED_HEADERS[rt]
+        for h in expected:
+            if h not in items[0]:
+                errors.append(f'HEADER_MISSING_{rt}: {h}')
+            else:
+                print(f'  {rt}: {h} ✓', flush=True)
+    
+    # === 6. Numeric fields ===
+    for rt in RT:
+        items = data.get('rankings', {}).get(rt, [])
+        if not items: continue
+        first = items[0]
+        expected = EXPECTED_HEADERS[rt]
+        for h in expected:
+            if h + '_numeric' not in first:
+                errors.append(f'NUMERIC_MISSING_{rt}: {h}_numeric')
+            else:
+                print(f'  {rt}: {h}_numeric ✓', flush=True)
+    
+    # === 7. XLSX check ===
+    if xlsx_files:
+        try:
+            import openpyxl
+            wb = openpyxl.load_workbook(str(xlsx_files[0]), read_only=True)
+            sheets = wb.sheetnames
+            expected_sheets = ['汇总', '线索榜', '引流榜', '热门榜']
+            for es in expected_sheets:
+                if es not in sheets:
+                    errors.append(f'XLSX_SHEET_MISSING: {es}')
+            if 'summary' in sheets:
+                errors.append('XLSX_WRONG_SHEET: summary should be 汇总')
+            print(f'  XLSX sheets: {sheets} ✓', flush=True)
+            
+            # Check numeric columns in XLSX
+            for rt in RT:
+                if rt not in sheets: continue
+                ws = wb[rt]
+                header_row = next(ws.iter_rows(min_row=1, max_row=1, values_only=True))
+                header_row = [h for h in header_row if h]
+                for h in EXPECTED_HEADERS[rt]:
+                    if h + '_numeric' not in header_row:
+                        errors.append(f'XLSX_NUMERIC_MISSING_{rt}: {h}_numeric')
+                    else:
+                        print(f'  XLSX {rt}: {h}_numeric ✓', flush=True)
+        except Exception as e:
+            errors.append(f'XLSX_OPEN: {e}')
+    
+    # === 8. video_url ===
+    video_url_empty = 0
+    for rt in RT:
+        items = data.get('rankings', {}).get(rt, [])
+        for item in items:
+            if not item.get('video_url'):
+                video_url_empty += 1
+    
+    if video_url_empty != total:
+        errors.append(f'VIDEO_URL_EMPTY: {video_url_empty} != {total}')
+    else:
+        print(f'  video_url: all {video_url_empty} empty ✓', flush=True)
+    
+    # === 9. missing_fields ===
+    mf = data.get('missing_fields', [])
+    mfc = data.get('missing_field_counts', {})
+    video_url_mf = sum(1 for m in mf if 'video_url' in m)
+    if video_url_mf != total:
+        errors.append(f'MISSING_FIELDS_VIDEO_URL: {video_url_mf} != {total}')
+    else:
+        print(f'  missing_fields video_url: {video_url_mf} ✓', flush=True)
+    
+    if mfc.get('video_url') != total:
+        errors.append(f'MISSING_FIELD_COUNTS_video_url: {mfc.get("video_url")} != {total}')
+    else:
+        print(f'  missing_field_counts video_url: {total} ✓', flush=True)
+    
+    # === 10. completeness ===
+    completeness = meta.get('completeness', '')
+    if completeness != 'PARTIAL':
+        errors.append(f'COMPLETENESS: expected PARTIAL, got {completeness}')
+    else:
+        print(f'  completeness: PARTIAL ✓', flush=True)
+    
+    reason = meta.get('completeness_reason', '') or meta.get('video_url_note', '')
+    if '视频' not in reason and '链接' not in reason:
+        warnings.append('COMPLETENESS_REASON: missing video_url explanation')
+        print(f'  completeness_reason: {reason} ⚠', flush=True)
+    else:
+        print(f'  completeness_reason: {reason} ✓', flush=True)
+    
+    # === 11. Cross-consistency ===
+    ml = meta.get('lead_count', 0); mt = meta.get('traffic_count', 0); mp = meta.get('popular_count', 0)
+    jl = len(data.get('rankings', {}).get('线索榜', []))
+    jt = len(data.get('rankings', {}).get('引流榜', []))
+    jp = len(data.get('rankings', {}).get('热门榜', []))
+    if ml != jl or mt != jt or mp != jp:
+        errors.append(f'CROSS_COUNT: meta({ml},{mt},{mp}) != json({jl},{jt},{jp})')
+    else:
+        print(f'  cross-consistency: OK ✓', flush=True)
+    
+    # === Summary ===
+    if errors:
+        print(f'\n❌ {len(errors)} ERRORS:', flush=True)
+        for e in errors: print(f'  - {e}', flush=True)
+    if warnings:
+        print(f'\n⚠ {len(warnings)} WARNINGS:', flush=True)
+        for w in warnings: print(f'  - {w}', flush=True)
+    
+    exit_code = 0 if not errors else 1
+    if not errors:
+        print('\n✅ ALL CHECKS PASSED', flush=True)
+    f''
+    return errors, exit_code
+
+if __name__ == '__main__':
+    target = sys.argv[1] if len(sys.argv) > 1 else '.'
+    _, code = validate(target)
+    print(f'\nEXIT CODE: {code}', flush=True)
+    sys.exit(code)

package/src/media_agent/platforms/toutiao/__init__.py

@@ -0,0 +1 @@
+"""Media Agent capabilities."""

package/src/media_agent/platforms/toutiao/toutiao_check_login.py

@@ -0,0 +1,54 @@
+#!/usr/bin/env python3
+"""Standalone read-only Toutiao login checker."""
+
+from __future__ import annotations
+from media_agent.runtime.paths import runtime_home
+
+import argparse
+import json
+import os
+import time
+import uuid
+from pathlib import Path
+
+try:
+    from media_agent.runtime.browser import launch_persistent_context
+except ImportError:  # Offline tests inject a launcher.
+    launch_persistent_context = None
+from media_agent.platforms.toutiao.toutiao_login_controller import ToutiaoLoginController
+from media_agent.platforms.toutiao.toutiao_login_evidence import classify_login_evidence, verify_account
+
+
+def check_login(base: Path, profile_id: str, *, launcher=launch_persistent_context) -> dict:
+    probe = ToutiaoLoginController(base, profile_id, launcher=launcher)
+    try: config = probe.load_config()
+    except ValueError as exc: return {"state": str(exc), "profile_id": profile_id}
+    probe.task_id = f"toutiao_check_{profile_id}_{uuid.uuid4().hex[:12]}"
+    if not probe.acquire_lock(): return {"state": "PROFILE_LOCKED", "profile_id": profile_id}
+    try:
+        probe.launch(config)
+        evidence = probe.page_evidence()
+        status = classify_login_evidence(**evidence)
+        expected = config.get("account", {}).get("expected_account_name") or config.get("account", {}).get("name", "")
+        account_state = verify_account(evidence.get("account_name"), expected) if status == "LOGGED_IN" else "not_run"
+        return {"state": status, "profile_id": profile_id,
+                "login_status": "logged_in" if status == "LOGGED_IN" else "login_required" if status == "LOGIN_REQUIRED" else "indeterminate",
+                "account_display_name": evidence.get("account_name") or "unknown",
+                "account_verified": account_state == "ACCOUNT_CONFIRMED",
+                "qr_visible": evidence.get("qr_visible", False), "persistence_verified": "not_run"}
+    except Exception as exc:
+        return {"state": "CHECK_FAILED", "profile_id": profile_id, "error": str(exc)[:120]}
+    finally:
+        if probe.context is not None:
+            try: probe.context.close()
+            except Exception: pass
+        probe.release_owned_lock()
+
+
+def main() -> int:
+    parser = argparse.ArgumentParser(); parser.add_argument("profile_id"); parser.add_argument("--base", type=Path, default=runtime_home())
+    args = parser.parse_args(); result = check_login(args.base, args.profile_id); print(json.dumps(result, ensure_ascii=False, indent=2))
+    return 0 if result.get("state") == "LOGGED_IN" else 2 if result.get("state") == "LOGIN_REQUIRED" else 1
+
+
+if __name__ == "__main__": raise SystemExit(main())

package/src/media_agent/platforms/toutiao/toutiao_login_controller.py

@@ -0,0 +1,250 @@
+#!/usr/bin/env python3
+"""Persistent Toutiao login controller with serialized browser operations."""
+
+from __future__ import annotations
+from media_agent.runtime.paths import runtime_home
+
+import argparse
+import json
+import os
+import queue
+import socket
+import threading
+import time
+import uuid
+from datetime import datetime, timezone
+from pathlib import Path
+
+try:
+    from media_agent.runtime.browser import launch_persistent_context
+except ImportError:  # Offline tests inject a launcher.
+    launch_persistent_context = None
+from media_agent.platforms.toutiao.toutiao_login_evidence import allowed_toutiao_site, classify_login_evidence, scan_poll_plan, verify_account
+
+
+class ToutiaoLoginController:
+    def __init__(self, base: Path, profile_id: str, *, launcher=launch_persistent_context):
+        self.base = Path(base)
+        self.profile_id = profile_id
+        self.profile_dir = self.base / "profiles" / profile_id
+        self.lock_path = self.base / "locks" / f"{profile_id}.lock"
+        self.socket_path = self.base / "controllers" / f"{profile_id}.sock"
+        self.launcher = launcher
+        self.pid = os.getpid()
+        self.task_id = f"toutiao_login_{profile_id}_{uuid.uuid4().hex[:12]}"
+        self.state = "INIT"
+        self.state_data: dict = {}
+        self.context = None
+        self.page = None
+        self.running = True
+        self.operations: queue.Queue[tuple[str, dict]] = queue.Queue()
+        self.worker: threading.Thread | None = None
+
+    def load_config(self) -> dict:
+        if not self.profile_dir.is_dir():
+            raise ValueError("PROFILE_NOT_FOUND")
+        path = self.profile_dir / "config.json"
+        if not path.is_file():
+            raise ValueError("CONFIG_NOT_FOUND")
+        config = json.loads(path.read_text())
+        if config.get("account", {}).get("platform", "").lower() != "toutiao":
+            raise ValueError("WRONG_PLATFORM")
+        sites = config.get("allowed_sites") or config.get("account", {}).get("allowed_sites", [])
+        if not allowed_toutiao_site(sites):
+            raise ValueError("MISSING_ALLOWED_SITE")
+        return config
+
+    @staticmethod
+    def _alive(pid) -> bool:
+        try:
+            if not isinstance(pid, int) or pid <= 1:
+                return False
+            os.kill(pid, 0)
+            return True
+        except OSError:
+            return False
+
+    def acquire_lock(self) -> bool:
+        self.lock_path.parent.mkdir(parents=True, exist_ok=True)
+        if self.lock_path.exists():
+            try:
+                current = json.loads(self.lock_path.read_text())
+            except (OSError, json.JSONDecodeError):
+                return False
+            if self._alive(current.get("pid")):
+                return False
+            self.lock_path.unlink()
+        self.lock_path.write_text(json.dumps({"pid": self.pid, "task_id": self.task_id,
+                                              "created_at": datetime.now(timezone.utc).isoformat()}))
+        return True
+
+    def release_owned_lock(self) -> bool:
+        if not self.lock_path.exists():
+            return True
+        try:
+            current = json.loads(self.lock_path.read_text())
+        except (OSError, json.JSONDecodeError):
+            return False
+        if current.get("pid") != self.pid or current.get("task_id") != self.task_id:
+            return False
+        self.lock_path.unlink()
+        return True
+
+    def launch(self, config: dict) -> None:
+        if self.launcher is None:
+            raise RuntimeError("cloakbrowser is required for live browser operations")
+        fp = config["fingerprint"]
+        self.context = self.launcher(
+            user_data_dir=str(self.profile_dir / "browser_data"), headless=False,
+            stealth_args=True, viewport=fp["viewport"], locale=fp["locale"],
+            timezone=fp["timezone"], humanize=False, geoip=False)
+        self.page = self.context.pages[0] if self.context.pages else self.context.new_page()
+        self.page.goto("https://www.toutiao.com/", wait_until="load", timeout=60000)
+
+    def page_evidence(self) -> dict:
+        return self.page.evaluate("""() => {
+          const visible = el => !!el && el.offsetParent !== null;
+          const text = el => (el?.textContent || '').trim();
+          const headers = [...document.querySelectorAll('header,[class*="header"],[class*="topbar"],[class*="top-bar"]')].filter(visible);
+          const candidates = [];
+          for (const root of headers) {
+            for (const el of root.querySelectorAll('[class*="user"],[class*="name"],[class*="nick"],a,span')) {
+              const t = text(el); const r = el.getBoundingClientRect();
+              if (visible(el) && t.length >= 2 && t.length <= 40 && r.top < 100 && r.left > innerWidth * .55 && t !== '登录') candidates.push(t);
+            }
+          }
+          const login = [...document.querySelectorAll('button,a,span,div')].some(el => visible(el) && text(el) === '登录' && el.getBoundingClientRect().top < 120);
+          const qrText = [...document.querySelectorAll('div,span')].some(el => visible(el) && ['扫码登录','二维码登录'].includes(text(el)));
+          const qrImage = [...document.querySelectorAll('img,canvas')].some(el => { const r=el.getBoundingClientRect(); return visible(el) && r.width>=140 && r.width<=400 && r.height>=140 && r.height<=400; });
+          return {login_visible: login, qr_visible: qrText && qrImage, account_name: candidates[0] || ''};
+        }""")
+
+    def capture_qr(self) -> str | None:
+        path = self.base / "screenshots" / f"{self.profile_id}_qr.png"
+        path.parent.mkdir(parents=True, exist_ok=True)
+        locator = self.page.get_by_text("扫码登录", exact=True).first
+        if locator.count() == 0:
+            return None
+        container = locator.locator("xpath=ancestor::*[.//img or .//canvas][1]")
+        qr = container.locator("img,canvas").first
+        if qr.count() == 0:
+            return None
+        qr.screenshot(path=str(path))
+        return str(path) if path.exists() and path.stat().st_size > 0 else None
+
+    def open_login(self) -> None:
+        self.page.get_by_text("登录", exact=True).first.click()
+        self.page.wait_for_timeout(1000)
+
+    def refresh_qr(self) -> str | None:
+        qr_text = self.page.get_by_text("扫码登录", exact=True).first
+        container = qr_text.locator("xpath=ancestor::*[.//*[contains(text(),'刷新') or contains(text(),'重新获取')]][1]")
+        button = container.get_by_text("刷新", exact=False).or_(container.get_by_text("重新获取", exact=False)).first
+        if button.count() == 0:
+            return None
+        button.click()
+        self.page.wait_for_timeout(1000)
+        return self.capture_qr()
+
+    def expected_name(self, supplied=None) -> str:
+        if supplied:
+            return supplied
+        return self.load_config().get("account", {}).get("expected_account_name") or self.load_config().get("account", {}).get("name", "")
+
+    def verify_current_account(self, expected=None) -> dict:
+        evidence = self.page_evidence()
+        result = verify_account(evidence.get("account_name"), self.expected_name(expected))
+        self.state = result
+        self.state_data = {"account_display_name": evidence.get("account_name") or "unknown",
+                           "expected_account_name": self.expected_name(expected),
+                           "account_verified": result == "ACCOUNT_CONFIRMED"}
+        return {"state": self.state, **self.state_data}
+
+    def scan(self, expected=None) -> None:
+        interval, polls = scan_poll_plan()
+        for _ in range(polls):
+            evidence = self.page_evidence()
+            status = classify_login_evidence(**evidence)
+            if status == "LOGGED_IN":
+                self.verify_current_account(expected)
+                return
+            time.sleep(interval)
+        self.state = "INDETERMINATE"
+        self.state_data = {"error": "TIMEOUT_NO_STABLE_LOGIN_EVIDENCE"}
+
+    def worker_loop(self) -> None:
+        while self.running:
+            operation, data = self.operations.get()
+            try:
+                if operation == "scan": self.scan(data.get("expected_account_name"))
+                elif operation == "verify": self.verify_current_account(data.get("expected_account_name"))
+                elif operation == "refresh":
+                    qr = self.refresh_qr(); self.state = "WAIT_QR_SCAN" if qr else "QR_EXPIRED"; self.state_data = {"qr_path": qr}
+                elif operation == "close": self.running = False
+            finally:
+                self.operations.task_done()
+
+    def command(self, request: dict) -> dict:
+        request_id = request.get("request_id")
+        if not request_id:
+            return {"state": "INVALID_REQUEST", "error": "request_id required"}
+        if request.get("profile_id") != self.profile_id:
+            return {"state": "PROFILE_MISMATCH", "request_id": request_id}
+        action = request.get("action")
+        response = {"state": self.state, "request_id": request_id, "profile_id": self.profile_id,
+                    "task_id": self.task_id, **self.state_data}
+        if action == "status": return response
+        mapping = {"scan_done": "scan", "verify_account": "verify", "refresh_qr": "refresh", "close": "close"}
+        if action not in mapping:
+            return {**response, "state": "INVALID_REQUEST", "error": "unknown action"}
+        if action == "scan_done": self.state = "VERIFYING_LOGIN"
+        self.operations.put((mapping[action], dict(request)))
+        return {**response, "state": self.state, "accepted": True}
+
+    def serve(self) -> None:
+        self.socket_path.parent.mkdir(parents=True, exist_ok=True)
+        self.socket_path.unlink(missing_ok=True)
+        server = socket.socket(socket.AF_UNIX, socket.SOCK_STREAM)
+        server.bind(str(self.socket_path)); os.chmod(self.socket_path, 0o600); server.listen(4); server.settimeout(1)
+        try:
+            while self.running:
+                try: conn, _ = server.accept()
+                except socket.timeout: continue
+                with conn:
+                    conn.settimeout(3); data = conn.recv(65536)
+                    try: response = self.command(json.loads(data.decode()))
+                    except Exception as exc: response = {"state": "IPC_ERROR", "error": str(exc)[:120]}
+                    conn.sendall(json.dumps(response, ensure_ascii=False).encode())
+        finally:
+            server.close(); self.socket_path.unlink(missing_ok=True)
+
+    def run(self) -> int:
+        try: config = self.load_config()
+        except ValueError as exc:
+            print(json.dumps({"state": str(exc)})); return 5
+        if not self.acquire_lock():
+            print(json.dumps({"state": "PROFILE_LOCKED"})); return 3
+        try:
+            self.launch(config)
+            evidence = self.page_evidence()
+            status = classify_login_evidence(**evidence)
+            if status == "LOGGED_IN": self.verify_current_account()
+            elif status == "LOGIN_REQUIRED":
+                self.open_login(); qr = self.capture_qr(); self.state = "WAIT_QR_SCAN" if qr else "INDETERMINATE"; self.state_data = {"qr_path": qr}
+            else: self.state = "INDETERMINATE"
+            print(json.dumps({"state": self.state, "task_id": self.task_id, **self.state_data}, ensure_ascii=False), flush=True)
+            self.worker = threading.Thread(target=self.worker_loop, daemon=False); self.worker.start(); self.serve()
+            self.worker.join(timeout=65)
+            if self.worker.is_alive(): return 1
+            return 0
+        finally:
+            if self.context is not None: self.context.close()
+            self.release_owned_lock()
+
+
+def main() -> int:
+    parser = argparse.ArgumentParser(); parser.add_argument("profile_id"); parser.add_argument("--base", type=Path, default=runtime_home())
+    args = parser.parse_args(); return ToutiaoLoginController(args.base, args.profile_id).run()
+
+
+if __name__ == "__main__": raise SystemExit(main())

package/src/media_agent/platforms/toutiao/toutiao_login_evidence.py

@@ -0,0 +1,50 @@
+#!/usr/bin/env python3
+"""Pure evidence and state helpers for Toutiao login."""
+
+from __future__ import annotations
+
+import re
+from typing import Iterable
+
+
+TOUTIAO_URL = "https://www.toutiao.com/"
+
+
+def normalize_nickname(value: str | None) -> str:
+    return re.sub(r"\s+", " ", (value or "").strip())
+
+
+def verify_account(actual: str | None, expected: str | None) -> str:
+    if not normalize_nickname(expected):
+        return "WAIT_ACCOUNT_CONFIRM"
+    if not normalize_nickname(actual):
+        return "INDETERMINATE"
+    return (
+        "ACCOUNT_CONFIRMED"
+        if normalize_nickname(actual) == normalize_nickname(expected)
+        else "ACCOUNT_MISMATCH"
+    )
+
+
+def classify_login_evidence(*, login_visible: bool, qr_visible: bool, account_name: str | None) -> str:
+    account_visible = bool(normalize_nickname(account_name))
+    if account_visible and not login_visible and not qr_visible:
+        return "LOGGED_IN"
+    if (login_visible or qr_visible) and not account_visible:
+        return "LOGIN_REQUIRED"
+    return "INDETERMINATE"
+
+
+def scan_poll_plan(interval: float = 2.0, max_seconds: float = 60.0) -> tuple[float, int]:
+    bounded_interval = min(max(float(interval), 0.1), max_seconds)
+    return bounded_interval, max(1, int(max_seconds // bounded_interval))
+
+
+def persistence_verified(*, closed: bool, waited_seconds: float, same_profile: bool,
+                         qr_visible: bool, account_state: str) -> bool:
+    return all((closed, waited_seconds >= 10, same_profile, not qr_visible,
+                account_state == "ACCOUNT_CONFIRMED"))
+
+
+def allowed_toutiao_site(sites: Iterable[str]) -> bool:
+    return any("toutiao.com" in site for site in sites)