@iducky/media-agent 1.1.0

package/src/media_agent/platforms/xiaohongshu/xiaohongshu_login_controller.py

@@ -0,0 +1,449 @@
+#!/usr/bin/env python3
+"""Xiaohongshu Creator persistent login controller with Unix Socket IPC.
+Usage: python3 xiaohongshu_login_controller.py <profile_id>
+Commands via socket: login-start, login-status, login-scan-done, login-refresh-qr, login-close
+"""
+from media_agent.runtime.paths import runtime_home
+import errno
+import json
+import os
+import socket
+import sys
+import threading
+import time
+from pathlib import Path
+from datetime import datetime, timezone, timedelta
+from media_agent.runtime.browser import launch_persistent_context
+from media_agent.platforms.xiaohongshu.xiaohongshu_login_evidence import (
+    DASHBOARD_KEYWORDS,
+    LOGIN_KEYWORDS,
+    classify_login_evidence,
+    post_scan_timeout_state,
+    scan_poll_schedule,
+)
+
+BASE = runtime_home()
+ALIAS = PROFILE_DIR = LOCK_FILE = SOCK_FILE = SCREENSHOT_DIR = cfg = None
+
+def configure(profile_id):
+    global ALIAS, PROFILE_DIR, LOCK_FILE, SOCK_FILE, SCREENSHOT_DIR, cfg
+    ALIAS = profile_id
+
+    PROFILE_DIR = BASE / 'profiles' / ALIAS
+    LOCK_FILE = BASE / 'locks' / f'{ALIAS}.lock'
+    SOCK_FILE = BASE / 'controllers' / f'{ALIAS}.sock'
+    SCREENSHOT_DIR = BASE / 'screenshots'
+    SCREENSHOT_DIR.mkdir(parents=True, exist_ok=True)
+    SOCK_FILE.parent.mkdir(parents=True, exist_ok=True)
+
+    cfg = json.loads((PROFILE_DIR / 'config.json').read_text())
+
+tz = timezone(timedelta(hours=8))
+
+# Global state
+controller_state = 'INIT'
+browser = None
+context = None
+page = None
+task_id = None
+request_id = None
+
+def now_iso():
+    return datetime.now(tz).isoformat()
+
+def log(msg):
+    print(json.dumps(msg, ensure_ascii=False), flush=True)
+
+def process_alive(pid):
+    if not isinstance(pid, int) or pid <= 1:
+        return False
+    try:
+        os.kill(pid, 0)
+        return True
+    except OSError as exc:
+        if exc.errno == errno.ESRCH:
+            return False
+        if exc.errno == errno.EPERM:
+            return True
+        raise
+
+def acquire_lock():
+    if LOCK_FILE.exists():
+        try:
+            old = json.loads(LOCK_FILE.read_text())
+        except (OSError, json.JSONDecodeError):
+            return False
+        if process_alive(old.get('pid')):
+            return False
+        try:
+            LOCK_FILE.unlink()
+        except OSError:
+            return False
+    LOCK_FILE.write_text(json.dumps({'pid': os.getpid(), 'time': now_iso(), 'task_id': task_id}))
+    return True
+
+def release_lock():
+    try:
+        LOCK_FILE.unlink(missing_ok=True)
+    except:
+        pass
+
+def check_logged_in():
+    """Check if current page shows dashboard."""
+    global page
+    url = page.url
+    body = page.evaluate('() => document.body.innerText')
+    dashboard = [kw for kw in DASHBOARD_KEYWORDS if kw in body]
+    has_login = any(kw in body for kw in LOGIN_KEYWORDS)
+    return classify_login_evidence(
+        url=url,
+        dashboard_evidence=dashboard,
+        login_form_detected=has_login,
+        qr_detected='APP扫一扫登录' in body or '扫码登录' in body,
+    )
+
+def navigate_to_qr():
+    """Navigate to login page and switch to QR scan mode. Returns state."""
+    global page, context
+    page.goto('https://creator.xiaohongshu.com/', wait_until='load', timeout=30000)
+    time.sleep(3)
+
+    url = page.url
+    body = page.evaluate('() => document.body.innerText')
+    # Check if already logged in
+    if '/new/home' in url or ('创作服务平台' in body and '发布笔记' in body):
+        return 'logged_in'
+
+    # Check if on SMS login page
+    if '短信登录' in body:
+        return 'sms_login_found'
+
+    # Check if QR mode already
+    if 'APP扫一扫登录' in body:
+        return 'qr_already'
+
+    return 'sms_login_found'
+
+def switch_to_qr():
+    """Click the QR icon in the login card. Returns True if successful."""
+    global page
+    result = page.evaluate('''() => {
+        // Find login card with SMS login content
+        for (const el of document.querySelectorAll('div[class*="login"], div[class*="card"], div[class*="panel"]')) {
+            const rect = el.getBoundingClientRect();
+            const text = el.textContent || '';
+            if (rect.width > 300 && rect.height > 200 && text.includes('短信登录')) {
+                // Find the QR icon in the top-right corner of this card
+                const icons = el.querySelectorAll('img, svg');
+                for (const icon of icons) {
+                    const ir = icon.getBoundingClientRect();
+                    if (ir.width > 15 && ir.width < 80 && ir.height > 15 && ir.height < 80
+                        && ir.x > rect.x + rect.width - 100) {
+                        icon.dispatchEvent(new MouseEvent('click', {bubbles: true}));
+                        return 'clicked_card_icon';
+                    }
+                }
+                // Try clicking the last small element in the card
+                const children = el.querySelectorAll('*');
+                for (let i = children.length - 1; i >= 0; i--) {
+                    const c = children[i];
+                    const cr = c.getBoundingClientRect();
+                    if (cr.width > 20 && cr.width < 80 && cr.height > 20 && cr.height < 80
+                        && cr.x > rect.x + rect.width - 100) {
+                        c.dispatchEvent(new MouseEvent('click', {bubbles: true}));
+                        return 'clicked_small_element';
+                    }
+                }
+            }
+        }
+        return 'not_found';
+    }''')
+    log({'step': 'qr_switch', 'result': result})
+    time.sleep(2)
+    return result != 'not_found'
+
+def verify_qr_mode():
+    """Verify QR mode is active: APP扫一扫 + QR visible + no phone input."""
+    global page
+    result = page.evaluate('''() => {
+        const body = document.body.innerText;
+        const hasQRText = body.includes('APP扫一扫登录') || body.includes('扫码登录');
+        const hasPhoneInput = document.querySelector('input[placeholder*="手机号"]');
+        const hasPhoneVisible = hasPhoneInput && hasPhoneInput.offsetParent !== null;
+        // Check for QR image
+        let hasQRImage = false;
+        for (const img of document.querySelectorAll('img')) {
+            const rect = img.getBoundingClientRect();
+            if (rect.width >= 100 && rect.width <= 400 && rect.height >= 100 && rect.height <= 400
+                && img.offsetParent !== null) {
+                hasQRImage = true;
+                break;
+            }
+        }
+        return {
+            qr_text: hasQRText,
+            qr_image: hasQRImage,
+            phone_input: hasPhoneVisible,
+            success: hasQRText && hasQRImage && !hasPhoneVisible
+        };
+    }''')
+    result['success'] = (
+        result.get('qr_text')
+        and result.get('qr_image')
+        and not result.get('phone_input')
+    )
+    return result
+
+def capture_qr():
+    """Capture QR code screenshot."""
+    global page
+    qr_path = str(SCREENSHOT_DIR / f'{ALIAS}_qr.png')
+    page.screenshot(path=qr_path)
+    return qr_path
+
+def remove_qr_capture():
+    try:
+        (SCREENSHOT_DIR / f'{ALIAS}_qr.png').unlink(missing_ok=True)
+    except OSError:
+        pass
+
+def write_response(result):
+    resp_file = BASE / 'signals' / f'{ALIAS}_response.json'
+    resp_file.parent.mkdir(parents=True, exist_ok=True)
+    tmp_file = resp_file.with_suffix('.json.tmp')
+    tmp_file.write_text(json.dumps(result, ensure_ascii=False))
+    os.replace(tmp_file, resp_file)
+
+def handle_command(cmd, data=None):
+    global controller_state, browser, context, page, task_id, request_id
+
+    if cmd == 'login-status':
+        if not page:
+            return {'state': controller_state, 'error': 'NO_PAGE'}
+        url = page.url
+        alive = True
+        try:
+            page.title()
+        except Exception:
+            alive = False
+        status = check_logged_in() if alive else 'unknown'
+        if status == 'logged_in':
+            controller_state = 'LOGGED_IN'
+        return {
+            'state': controller_state,
+            'controller_pid': os.getpid(),
+            'browser_alive': alive,
+            'page_count': len(context.pages) if context else 0,
+            'current_url': url[:120],
+            'lock_owner': os.getpid(),
+            'task_id': task_id,
+            'request_id': request_id,
+            'login_status': status
+        }
+
+    elif cmd == 'login-scan-done':
+        if controller_state != 'WAIT_QR_SCAN':
+            return {'state': controller_state, 'error': 'NOT_WAITING_QR'}
+        # Wait 10-15s for platform to process, then poll up to 60s.
+        initial_wait, poll_interval, poll_count = scan_poll_schedule()
+        time.sleep(initial_wait)
+        for i in range(poll_count):
+            time.sleep(poll_interval)
+            try:
+                url = page.url
+                body = page.evaluate('() => document.body.innerText')
+                # SPA: URL may still be /login but dashboard already rendered
+                dashboard = [kw for kw in DASHBOARD_KEYWORDS if kw in body]
+                has_login = any(kw in body for kw in LOGIN_KEYWORDS)
+                status = classify_login_evidence(
+                    url=url,
+                    dashboard_evidence=dashboard,
+                    login_form_detected=has_login,
+                    qr_detected='APP扫一扫登录' in body or '扫码登录' in body,
+                )
+                if status == 'logged_in':
+                    controller_state = 'LOGGED_IN'
+                    remove_qr_capture()
+                    return {
+                        'state': 'LOGGED_IN',
+                        'url': url[:120],
+                        'elapsed': initial_wait + (i + 1) * poll_interval,
+                        'spa': '/login' in url,
+                        'dashboard_evidence': dashboard,
+                    }
+            except Exception as exc:
+                log({'step': 'scan_poll_error', 'error': str(exc)[:100]})
+        controller_state = post_scan_timeout_state()
+        return {
+            'state': controller_state,
+            'error': 'TIMEOUT_NO_BACKEND_EVIDENCE',
+            'rescan_requested': False,
+        }
+
+    elif cmd == 'login-refresh-qr':
+        if controller_state != 'WAIT_QR_SCAN':
+            return {'state': controller_state, 'error': 'NOT_WAITING_QR'}
+        # Find and click refresh button on QR area
+        page.evaluate('''() => {
+            for (const el of document.querySelectorAll('div, span, a, button')) {
+                const t = el.textContent.trim();
+                if (t === '刷新' || t === '重新获取' || t.includes('点击刷新')) {
+                    el.click(); return 'clicked';
+                }
+            }
+            return 'not_found';
+        }''')
+        time.sleep(2)
+        qr_path = capture_qr()
+        return {'state': 'WAIT_QR_SCAN', 'qr_path': qr_path}
+
+    elif cmd == 'login-close':
+        controller_state = 'CLOSING'
+        try:
+            if context:
+                context.close()
+        except Exception:
+            pass
+        try:
+            if browser:
+                browser.close()
+        except Exception:
+            pass
+        browser = None
+        context = None
+        page = None
+        remove_qr_capture()
+        release_lock()
+        controller_state = 'COMPLETE'
+        return {'state': 'COMPLETE'}
+
+    return {'error': 'UNKNOWN_COMMAND'}
+
+def server_thread():
+    """Unix Socket IPC server."""
+    if SOCK_FILE.exists():
+        SOCK_FILE.unlink()
+    sock = socket.socket(socket.AF_UNIX, socket.SOCK_STREAM)
+    sock.bind(str(SOCK_FILE))
+    os.chmod(str(SOCK_FILE), 0o600)
+    sock.listen(1)
+    sock.settimeout(1.0)
+
+    while controller_state != 'CLOSING' and controller_state != 'COMPLETE':
+        try:
+            conn, _ = sock.accept()
+            data = b''
+            while True:
+                chunk = conn.recv(4096)
+                if not chunk:
+                    break
+                data += chunk
+                if len(data) > 65536:
+                    break
+            conn.close()
+            if data:
+                msg = json.loads(data.decode())
+                cmd = msg.get('command', '')
+                cmd_data = msg.get('data', {})
+                cmd_data['request_id'] = msg.get('request_id', '')
+                result = handle_command(cmd, cmd_data)
+                result['request_id'] = msg.get('request_id', '')
+                write_response(result)
+                log({'step': 'cmd_handled', 'command': cmd, 'result': list(result.keys())})
+        except socket.timeout:
+            continue
+        except Exception as e:
+            log({'step': 'socket_error', 'error': str(e)[:100]})
+
+    try:
+        sock.close()
+        SOCK_FILE.unlink(missing_ok=True)
+    except OSError:
+        pass
+
+def main():
+    global controller_state, task_id
+    if len(sys.argv) < 2:
+        raise SystemExit('profile_id required')
+    configure(sys.argv[1])
+    # Initial startup
+    task_id = f'xhs_login_{ALIAS}_{datetime.now(tz).strftime("%Y%m%d_%H%M%S")}'
+    if not acquire_lock():
+        log({'error': 'PROFILE_LOCKED'})
+        sys.exit(1)
+
+    browser_obj = launch_persistent_context(
+        user_data_dir=str(PROFILE_DIR / 'browser_data'),
+        headless=False, stealth_args=True,
+        viewport=cfg['fingerprint']['viewport'],
+        locale=cfg['fingerprint']['locale'],
+        timezone=cfg['fingerprint']['timezone'],
+        humanize=False, geoip=False
+    )
+    global browser, context, page
+    browser = browser_obj
+    context = browser_obj
+    page = context.pages[0] if context.pages else context.new_page()
+
+    result = navigate_to_qr()
+    if result == 'logged_in':
+        controller_state = 'LOGGED_IN'
+        startup = {'event': 'controller_started', 'state': 'LOGGED_IN', 'controller_pid': os.getpid(), 'task_id': task_id}
+        write_response(startup)
+        log(startup)
+    elif result in ('sms_login_found', 'qr_already'):
+        switched = result == 'qr_already' or switch_to_qr()
+        if switched:
+            qr_verify = verify_qr_mode()
+            if qr_verify.get('success'):
+                controller_state = 'WAIT_QR_SCAN'
+                qr_path = capture_qr()
+                startup = {'event': 'controller_started', 'state': 'WAIT_QR_SCAN', 'qr_path': qr_path, 'task_id': task_id, 'pid': os.getpid(), 'qr_verified': qr_verify}
+                write_response(startup)
+                log(startup)
+            else:
+                controller_state = 'WAIT_QR_MODE'
+                startup = {'event': 'controller_started', 'state': 'WAIT_QR_MODE', 'error': 'QR_SWITCH_FAILED', 'task_id': task_id, 'qr_verify': qr_verify}
+                write_response(startup)
+                log(startup)
+        else:
+            controller_state = 'WAIT_QR_MODE'
+            startup = {'event': 'controller_started', 'state': 'WAIT_QR_MODE', 'error': 'QR_ICON_NOT_FOUND', 'task_id': task_id}
+            write_response(startup)
+            log(startup)
+    else:
+        controller_state = 'WAIT_QR_MODE'
+        startup = {'event': 'controller_started', 'state': 'WAIT_QR_MODE', 'error': 'UNKNOWN_FORM', 'task_id': task_id}
+        write_response(startup)
+        log(startup)
+
+    # Start IPC server in background
+    t = threading.Thread(target=server_thread, daemon=True)
+    t.start()
+
+    # Keep alive
+    try:
+        while controller_state not in ('CLOSING', 'COMPLETE'):
+            time.sleep(1)
+    except KeyboardInterrupt:
+        pass
+
+    # Cleanup
+    try:
+        if context:
+            context.close()
+    except:
+        pass
+    try:
+        if browser:
+            browser.close()
+    except:
+        pass
+    release_lock()
+    try:
+        SOCK_FILE.unlink(missing_ok=True)
+    except:
+        pass
+
+if __name__ == '__main__':
+    main()

package/src/media_agent/platforms/xiaohongshu/xiaohongshu_login_evidence.py

@@ -0,0 +1,64 @@
+#!/usr/bin/env python3
+"""Pure evidence and state helpers for Xiaohongshu Creator login."""
+
+from __future__ import annotations
+
+from typing import Iterable
+
+
+DASHBOARD_KEYWORDS = (
+    "创作服务平台",
+    "首页",
+    "笔记管理",
+    "数据看板",
+    "创作中心",
+    "发布笔记",
+    "我的笔记",
+)
+
+LOGIN_KEYWORDS = ("短信登录", "APP扫一扫登录", "扫码登录", "手机号")
+
+
+def classify_login_evidence(
+    *,
+    url: str,
+    dashboard_evidence: Iterable[str],
+    login_form_detected: bool,
+    qr_detected: bool,
+) -> str:
+    """Classify login without trusting URL alone.
+
+    Xiaohongshu's SPA may retain /login after rendering the authenticated
+    dashboard, so strong dashboard DOM plus absence of login UI wins.
+    """
+
+    dashboard = {item for item in dashboard_evidence if item}
+    backend_route = "/new/" in url or "/creator" in url
+    strong_dashboard = len(dashboard) >= 2 or (
+        backend_route and len(dashboard) >= 1
+    )
+    login_ui = login_form_detected or qr_detected
+
+    if strong_dashboard and not login_ui:
+        return "logged_in"
+    if login_ui and not strong_dashboard:
+        return "login_required"
+    return "indeterminate"
+
+
+def qr_mode_ready(*, qr_text: bool, qr_image: bool, phone_input: bool) -> bool:
+    """Return true only when the QR UI is visible and SMS inputs are gone."""
+
+    return qr_text and qr_image and not phone_input
+
+
+def scan_poll_schedule() -> tuple[int, int, int]:
+    """Initial wait, poll interval, and maximum poll count."""
+
+    return 12, 2, 30
+
+
+def post_scan_timeout_state() -> str:
+    """Never ask for another scan merely because redirect polling timed out."""
+
+    return "INDETERMINATE"

package/src/media_agent/platforms/xiaohongshu/xiaohongshu_login_ipc.py

@@ -0,0 +1,120 @@
+#!/usr/bin/env python3
+"""Profile-scoped IPC client for the Xiaohongshu login controller."""
+
+from __future__ import annotations
+from media_agent.runtime.paths import runtime_home
+
+import argparse
+import json
+import os
+import socket
+import sys
+import time
+import uuid
+from pathlib import Path
+
+
+BASE = runtime_home()
+
+
+def response_path(profile_id: str) -> Path:
+    return BASE / "signals" / f"{profile_id}_response.json"
+
+
+def wait_for_response(path: Path, request_id: str, timeout: float) -> dict:
+    deadline = time.monotonic() + timeout
+    while time.monotonic() < deadline:
+        if path.exists():
+            try:
+                payload = json.loads(path.read_text())
+            except (OSError, json.JSONDecodeError):
+                payload = {}
+            if payload.get("request_id") == request_id:
+                return payload
+        time.sleep(0.2)
+    return {
+        "state": "IPC_TIMEOUT",
+        "error": "response timeout",
+        "request_id": request_id,
+    }
+
+
+def send(profile_id: str, command: str, timeout: float) -> dict:
+    sock_path = BASE / "controllers" / f"{profile_id}.sock"
+    if not sock_path.exists():
+        return {"state": "CONTROLLER_NOT_FOUND", "error": "no socket"}
+
+    request_id = uuid.uuid4().hex
+    payload = {"command": command, "request_id": request_id, "data": {}}
+    try:
+        client = socket.socket(socket.AF_UNIX, socket.SOCK_STREAM)
+        client.settimeout(5)
+        client.connect(str(sock_path))
+        client.sendall(json.dumps(payload).encode())
+        try:
+            client.shutdown(socket.SHUT_WR)
+        except OSError:
+            # 半关闭只是 EOF 提示；请求已完整发送，对端先关闭时（如 macOS 偶发
+            # ENOTCONN）不得误判 CONTROLLER_DEAD，响应经信号文件交付。
+            pass
+        client.close()
+    except OSError as exc:
+        return {
+            "state": "CONTROLLER_DEAD",
+            "error": str(exc)[:120],
+            "request_id": request_id,
+        }
+
+    return wait_for_response(response_path(profile_id), request_id, timeout)
+
+
+def wait_start(profile_id: str, timeout: float) -> dict:
+    path = response_path(profile_id)
+    deadline = time.monotonic() + timeout
+    while time.monotonic() < deadline:
+        if path.exists():
+            try:
+                payload = json.loads(path.read_text())
+            except (OSError, json.JSONDecodeError):
+                payload = {}
+            if payload.get("event") == "controller_started":
+                return payload
+        time.sleep(0.2)
+    return {"state": "START_TIMEOUT", "error": "controller startup timeout"}
+
+
+def main() -> int:
+    parser = argparse.ArgumentParser()
+    parser.add_argument("profile_id")
+    parser.add_argument(
+        "command",
+        choices=("status", "scan-done", "refresh-qr", "close", "wait-start"),
+    )
+    parser.add_argument("--timeout", type=float)
+    args = parser.parse_args()
+
+    defaults = {
+        "status": 10,
+        "scan-done": 80,
+        "refresh-qr": 15,
+        "close": 15,
+        "wait-start": 45,
+    }
+    timeout = args.timeout or defaults[args.command]
+    if args.command == "wait-start":
+        result = wait_start(args.profile_id, timeout)
+    else:
+        wire_command = {
+            "status": "login-status",
+            "scan-done": "login-scan-done",
+            "refresh-qr": "login-refresh-qr",
+            "close": "login-close",
+        }[args.command]
+        result = send(args.profile_id, wire_command, timeout)
+
+    print(json.dumps(result, indent=2, ensure_ascii=False))
+    return 0 if "error" not in result else 1
+
+
+if __name__ == "__main__":
+    sys.exit(main())