@11agents/cli 0.1.24 → 0.1.25

package/mobile-runtime/python/src/device_control/publishers/reddit_adb.py

@@ -0,0 +1,595 @@
+from __future__ import annotations
+
+import json
+import re
+import ssl
+import time
+import urllib.error
+import urllib.parse
+import urllib.request
+import xml.etree.ElementTree as ET
+from dataclasses import dataclass
+from datetime import datetime
+from pathlib import Path
+from typing import Any
+from zoneinfo import ZoneInfo
+
+from device_control.adb import AdbClient
+from device_control.models import Device, PublishRecord, utc_now_iso
+from device_control.publishers import ui_helpers as ui
+from device_control.publishers.tiktok_adb import TikTokAdbPublisher
+from device_control.store import append_publish_record
+
+
+REDDIT_PACKAGE = "com.reddit.frontpage"
+REDDIT_USER_AGENT = "elevenagents-mobile-runtime/0.1"
+
+
+@dataclass
+class RedditAdbPublishResult:
+    device_id: str
+    status: str
+    record_id: str
+    started_at: str
+    ended_at: str
+    duration_seconds: int
+    subreddit: str
+    title: str
+    post_type: str
+    screenshot_path: str
+    remote_media_path: str = ""
+    link_url: str = ""
+    platform_post_id: str = ""
+    platform_permalink: str = ""
+    error: str = ""
+
+
+class RedditAdbPublisher:
+    """ADB-only Reddit text-post publisher for the Samsung SM-G9910 POC devices."""
+
+    def __init__(
+        self,
+        adb: AdbClient,
+        *,
+        records_path: str | Path = "data/publish_records.jsonl",
+        artifact_root: str | Path = "artifacts/screenshots",
+    ) -> None:
+        self.adb = adb
+        self.records_path = Path(records_path)
+        self.artifact_root = Path(artifact_root)
+        self.media_helper = TikTokAdbPublisher(adb, records_path=records_path, artifact_root=artifact_root)
+
+    def publish_text(
+        self,
+        device: Device,
+        *,
+        subreddit: str,
+        title: str,
+        body: str = "",
+        account_id: str,
+        reddit_username: str = "",
+        dry_run: bool = False,
+        fetch_permalink: bool = True,
+    ) -> RedditAdbPublishResult:
+        return self.publish_post(
+            device,
+            post_type="text",
+            subreddit=subreddit,
+            title=title,
+            body=body,
+            account_id=account_id,
+            reddit_username=reddit_username,
+            dry_run=dry_run,
+            fetch_permalink=fetch_permalink,
+        )
+
+    def publish_post(
+        self,
+        device: Device,
+        *,
+        post_type: str,
+        subreddit: str,
+        title: str,
+        body: str = "",
+        link_url: str = "",
+        media_path: str | Path | None = None,
+        account_id: str,
+        reddit_username: str = "",
+        dry_run: bool = False,
+        fetch_permalink: bool = True,
+    ) -> RedditAdbPublishResult:
+        post_type = _normalize_post_type(post_type)
+        subreddit = _normalize_subreddit(subreddit)
+        _require_adb_text_safe(title, "title")
+        if body:
+            _require_adb_text_safe(body, "body")
+        if post_type == "link":
+            _require_adb_text_safe(link_url, "link_url")
+        local: Path | None = Path(media_path).expanduser() if media_path else None
+        if post_type in {"image", "video"}:
+            if local is None or not local.exists():
+                raise FileNotFoundError(f"media not found: {media_path}")
+            if ui.media_kind_from_path(local) != post_type:
+                raise ValueError(f"post_type={post_type} does not match media file suffix: {local}")
+
+        started_epoch = int(time.time())
+        started_at = _now_shanghai()
+        stamp = datetime.now(ZoneInfo("Asia/Shanghai")).strftime("%Y%m%d-%H%M%S")
+        run_dir = self.artifact_root / f"{device.device_id}-reddit-{stamp}"
+        run_dir.mkdir(parents=True, exist_ok=True)
+        record_id = f"pub_{stamp.replace('-', '')}_{device.device_id.lower()}_reddit"
+        remote = ""
+        if local is not None:
+            remote = f"/sdcard/DCIM/Camera/groupctl-{device.device_id}-reddit-{stamp}{local.suffix}"
+
+        try:
+            self._prepare_device(device)
+            if local is not None:
+                self.media_helper._push_media(device, local, remote)
+            self._open_submit(device, subreddit)
+            self._select_subreddit(device, subreddit, run_dir)
+            self.adb.screenshot(device.adb_serial, run_dir / "submit-form.png")
+            self._input_title(device, title, run_dir)
+            if post_type == "link":
+                self._select_post_type(device, "link", run_dir)
+                self._input_link(device, link_url, run_dir)
+            elif post_type in {"image", "video"}:
+                self._select_post_type(device, post_type, run_dir)
+                self._attach_media(device, post_type, run_dir)
+            if body:
+                self._input_body(device, body, run_dir)
+
+            if dry_run:
+                final_shot = run_dir / "dry-run-post-form.png"
+                self.adb.screenshot(device.adb_serial, final_shot)
+                status = "dry_run"
+                post_id = ""
+                permalink = ""
+            else:
+                self._tap_post(device)
+                time.sleep(10)
+                self._dismiss_after_post_prompt(device)
+                final_shot = run_dir / "after-post.png"
+                self.adb.screenshot(device.adb_serial, final_shot)
+                self._assert_not_still_editing(device, run_dir)
+                status = "published"
+                post_id = ""
+                permalink = ""
+                lookup_username = reddit_username or account_id
+                if fetch_permalink and lookup_username:
+                    found = _lookup_recent_post(
+                        username=lookup_username,
+                        subreddit=subreddit,
+                        title=title,
+                        body=body,
+                        link_url=link_url if post_type == "link" else "",
+                        min_created_utc=started_epoch - 120,
+                    )
+                    post_id = found.get("id", "")
+                    path = found.get("permalink", "")
+                    permalink = f"https://www.reddit.com{path}" if path.startswith("/") else path
+                    if not post_id or not permalink:
+                        raise RuntimeError("Reddit publish was not confirmed by public JSON lookup")
+
+                record = PublishRecord(
+                    record_id=record_id,
+                    platform="reddit",
+                    account_id=account_id,
+                    device_id=device.device_id,
+                    post_type=post_type,
+                    local_media_path=str(local) if local else "",
+                    remote_media_path=remote,
+                    platform_post_id=post_id,
+                    platform_permalink=permalink,
+                    caption=_caption(title, body or link_url),
+                    published_at=utc_now_iso(),
+                    result_screenshot_path=str(final_shot),
+                    status="published",
+                )
+                append_publish_record(self.records_path, record)
+
+            ended_epoch = int(time.time())
+            return RedditAdbPublishResult(
+                device_id=device.device_id,
+                status=status,
+                record_id=record_id,
+                started_at=started_at,
+                ended_at=_now_shanghai(),
+                duration_seconds=ended_epoch - started_epoch,
+                subreddit=subreddit,
+                title=title,
+                post_type=post_type,
+                screenshot_path=str(final_shot),
+                remote_media_path=remote,
+                link_url=link_url,
+                platform_post_id=post_id,
+                platform_permalink=permalink,
+            )
+        except Exception as exc:
+            ended_epoch = int(time.time())
+            failure_shot = run_dir / "failed.png"
+            self.adb.screenshot(device.adb_serial, failure_shot)
+            return RedditAdbPublishResult(
+                device_id=device.device_id,
+                status="failed",
+                record_id=record_id,
+                started_at=started_at,
+                ended_at=_now_shanghai(),
+                duration_seconds=ended_epoch - started_epoch,
+                subreddit=subreddit,
+                title=title,
+                post_type=post_type,
+                screenshot_path=str(failure_shot),
+                remote_media_path=remote,
+                link_url=link_url,
+                error=str(exc),
+            )
+
+    def _prepare_device(self, device: Device) -> None:
+        self._ok(self.adb.wake(device.adb_serial), "wake device")
+        time.sleep(1)
+        self.adb.swipe(device.adb_serial, 540, 1850, 540, 550, 350)
+        time.sleep(1)
+
+    def _open_submit(self, device: Device, subreddit: str) -> None:
+        url = f"https://www.reddit.com/r/{urllib.parse.quote(subreddit)}/submit"
+        ui.grant_publish_permissions(self.adb, device, REDDIT_PACKAGE)
+        self.adb.shell(device.adb_serial, "am", "force-stop", REDDIT_PACKAGE)
+        time.sleep(1)
+        result = self.adb.shell(
+            device.adb_serial,
+            "am",
+            "start",
+            "-W",
+            "-a",
+            "android.intent.action.VIEW",
+            "-d",
+            url,
+            "-p",
+            REDDIT_PACKAGE,
+        )
+        self._ok(result, f"open Reddit submit URL {url}")
+        time.sleep(5)
+
+    def _select_subreddit(self, device: Device, subreddit: str, run_dir: Path) -> None:
+        current_xml = run_dir / "community-current.xml"
+        current = self.adb.dump_ui(device.adb_serial, current_xml)
+        if current.ok and _find_text_center(current_xml, f"r/{subreddit}"):
+            self.adb.screenshot(device.adb_serial, run_dir / "community-already-selected.png")
+            return
+
+        self._tap(device, 360, 175, 2)
+        self._tap_resource(
+            device,
+            "community_picker_search_bar_tag",
+            run_dir / "community-search-before-input.xml",
+            fallback=(540, 320),
+        )
+        time.sleep(1)
+        result = self.adb.input_text(device.adb_serial, subreddit)
+        if not result.ok:
+            self.adb.screenshot(device.adb_serial, run_dir / "community-input-failed.png")
+            raise RuntimeError(f"community input failed: {result.stderr or result.stdout}")
+
+        xml_path = run_dir / "community-results.xml"
+        last_error = ""
+        for attempt in range(8):
+            time.sleep(2)
+            dump = self.adb.dump_ui(device.adb_serial, xml_path)
+            if not dump.ok:
+                last_error = dump.stderr or dump.stdout
+                continue
+            search_text = _find_resource_text(xml_path, "community_picker_search_bar_tag")
+            if attempt == 0 and search_text != subreddit:
+                self._tap_resource(
+                    device,
+                    "community_picker_search_bar_tag",
+                    run_dir / "community-search-retry.xml",
+                    fallback=(540, 320),
+                )
+                time.sleep(1)
+                self.adb.input_text(device.adb_serial, subreddit)
+                continue
+            center = _find_text_center(xml_path, f"r/{subreddit}")
+            if center:
+                self._tap(device, center[0], center[1], 3)
+                self.adb.screenshot(device.adb_serial, run_dir / "after-community.png")
+                return
+
+        self.adb.screenshot(device.adb_serial, run_dir / "community-not-found.png")
+        detail = f"; last dump error={last_error}" if last_error else ""
+        raise RuntimeError(f"community r/{subreddit} not found in Reddit search results{detail}")
+
+    def _input_title(self, device: Device, title: str, run_dir: Path) -> None:
+        self._tap_resource(device, "post_title_field", run_dir / "before-title.xml", fallback=(180, 460))
+        time.sleep(1)
+        result = self.adb.input_text(device.adb_serial, title)
+        if not result.ok:
+            self.adb.screenshot(device.adb_serial, run_dir / "title-input-failed.png")
+            raise RuntimeError(f"title input failed: {result.stderr or result.stdout}")
+        time.sleep(1)
+        self.adb.screenshot(device.adb_serial, run_dir / "after-title.png")
+
+    def _input_body(self, device: Device, body: str, run_dir: Path) -> None:
+        self._tap_resource(
+            device,
+            "com.reddit.frontpage:id/richtext_edit_text_view",
+            run_dir / "before-body.xml",
+            fallback=(220, 820),
+        )
+        time.sleep(1)
+        result = self.adb.input_text(device.adb_serial, body)
+        if not result.ok:
+            self.adb.screenshot(device.adb_serial, run_dir / "body-input-failed.png")
+            raise RuntimeError(f"body input failed: {result.stderr or result.stdout}")
+        time.sleep(1)
+        self.adb.screenshot(device.adb_serial, run_dir / "after-body.png")
+
+    def _select_post_type(self, device: Device, post_type: str, run_dir: Path) -> None:
+        resource_id = {
+            "link": "link_post_type_button",
+            "image": "image_post_type_button",
+            "video": "video_post_type_button",
+        }[post_type]
+        self._tap_resource(device, resource_id, run_dir / f"before-{post_type}-type.xml", fallback=_post_type_fallback(post_type))
+        time.sleep(2)
+        self.adb.screenshot(device.adb_serial, run_dir / f"after-{post_type}-type.png")
+
+    def _input_link(self, device: Device, link_url: str, run_dir: Path) -> None:
+        xml_path = run_dir / "before-link.xml"
+        dump = self.adb.dump_ui(device.adb_serial, xml_path)
+        center = _find_desc_or_text_center(xml_path, {"submit_link", "输入链接", "Enter link"}) if dump.ok else None
+        x, y = center or (180, 735)
+        self._tap(device, x, y, 1)
+        result = self.adb.input_text(device.adb_serial, link_url)
+        if not result.ok:
+            self.adb.screenshot(device.adb_serial, run_dir / "link-input-failed.png")
+            raise RuntimeError(f"link input failed: {result.stderr or result.stdout}")
+        time.sleep(1)
+        self.adb.screenshot(device.adb_serial, run_dir / "after-link.png")
+
+    def _attach_media(self, device: Device, post_type: str, run_dir: Path) -> None:
+        sheet_xml = run_dir / f"{post_type}-media-sheet.xml"
+        root = self._dump(device, sheet_xml)
+        if ui.tap_permission_prompt_if_present(self.adb, device, run_dir / f"{post_type}-media-permission.xml"):
+            root = self._dump(device, run_dir / f"{post_type}-media-sheet-after-permission.xml")
+        permission = ui.find_node(
+            root,
+            ids={"com.android.permissioncontroller:id/permission_allow_button"},
+            id_suffixes={"permission_allow_button"},
+            texts={"允许", "Allow"},
+            partial_texts={"允许", "Allow"},
+            clickable_only=False,
+        )
+        if permission is not None:
+            ui.tap_node(self.adb, device, permission, sleep_s=3)
+            root = self._dump(device, run_dir / f"{post_type}-media-sheet-after-permission.xml")
+            if ui.find_node(root, id_suffixes={"permission_allow_button"}, partial_texts={"允许", "Allow"}) is not None:
+                self._tap(device, 540, 1368, 3)
+                root = self._dump(device, run_dir / f"{post_type}-media-sheet-after-permission-fallback.xml")
+            self.adb.screenshot(device.adb_serial, run_dir / f"after-{post_type}-permission.png")
+        library_texts = {"照片库", "Photo library", "Gallery"}
+        if post_type == "video":
+            library_texts |= {"视频库", "Video library"}
+        node = ui.find_node(root, texts=library_texts, partial_texts=library_texts)
+        if node is None:
+            self.adb.screenshot(device.adb_serial, run_dir / f"{post_type}-media-sheet-missing.png")
+            raise RuntimeError(f"Reddit {post_type} media library entry not found")
+        ui.tap_node(self.adb, device, node, sleep_s=3)
+
+        picker_xml = run_dir / f"{post_type}-photo-picker.xml"
+        picker = self._dump(device, picker_xml)
+        thumbnails = ui.sorted_visible_nodes(ui.find_nodes(picker, id_suffixes={"icon_thumbnail"}))
+        if not thumbnails:
+            self.adb.screenshot(device.adb_serial, run_dir / f"{post_type}-picker-empty.png")
+            raise RuntimeError(f"Reddit {post_type} picker did not expose media thumbnails")
+        ui.tap_node(self.adb, device, thumbnails[0], sleep_s=1)
+
+        selected_xml = run_dir / f"{post_type}-photo-picker-selected.xml"
+        selected = self._dump(device, selected_xml)
+        add = ui.find_node(
+            selected,
+            ids={"com.android.providers.media.module:id/button_add"},
+            id_suffixes={"button_add"},
+            partial_texts={"添加", "Add"},
+            clickable_only=False,
+        )
+        if add is None:
+            self.adb.screenshot(device.adb_serial, run_dir / f"{post_type}-picker-add-missing.png")
+            raise RuntimeError(f"Reddit {post_type} picker add button not found")
+        ui.tap_node(self.adb, device, add, sleep_s=4)
+        self.adb.screenshot(device.adb_serial, run_dir / f"after-{post_type}-media.png")
+
+    def _tap_post(self, device: Device) -> None:
+        self._tap(device, 945, 175, 0)
+
+    def _dismiss_after_post_prompt(self, device: Device) -> None:
+        # Reddit often shows a post-publish crosspost prompt. Dismiss it if present.
+        time.sleep(2)
+        self.adb.tap(device.adb_serial, 980, 1788)
+        time.sleep(1)
+
+    def _assert_not_still_editing(self, device: Device, run_dir: Path) -> None:
+        xml_path = run_dir / "after-post.xml"
+        dump = self.adb.dump_ui(device.adb_serial, xml_path)
+        if not dump.ok:
+            return
+        root = ET.parse(xml_path).getroot()
+        texts = {node.attrib.get("text", "") for node in root.iter("node")}
+        resource_ids = {node.attrib.get("resource-id", "") for node in root.iter("node")}
+        if "保存草稿？" in texts or "post_submit_screen" in resource_ids or "post_title_field" in resource_ids:
+            raise RuntimeError("Reddit is still on composer/draft screen; publish not confirmed")
+
+    def _tap(self, device: Device, x: int, y: int, sleep_s: int) -> None:
+        self._ok(self.adb.tap(device.adb_serial, x, y), f"tap {x},{y}")
+        if sleep_s:
+            time.sleep(sleep_s)
+
+    def _tap_resource(self, device: Device, resource_id: str, xml_path: Path, *, fallback: tuple[int, int]) -> None:
+        dump = self.adb.dump_ui(device.adb_serial, xml_path)
+        center = _find_resource_center(xml_path, resource_id) if dump.ok else None
+        x, y = center or fallback
+        self._tap(device, x, y, 0)
+
+    def _dump(self, device: Device, xml_path: Path) -> ET.Element:
+        dump = self.adb.dump_ui(device.adb_serial, xml_path)
+        if not dump.ok:
+            raise RuntimeError(f"dump ui failed: {dump.stderr or dump.stdout}")
+        return ET.parse(xml_path).getroot()
+
+    @staticmethod
+    def _ok(result, action: str) -> None:
+        if not result.ok:
+            raise RuntimeError(f"{action} failed: {result.stderr or result.stdout}")
+
+
+def _normalize_subreddit(value: str) -> str:
+    text = value.strip()
+    if text.startswith("/r/"):
+        text = text[3:]
+    if text.lower().startswith("r/"):
+        text = text[2:]
+    if not re.fullmatch(r"[A-Za-z0-9_][A-Za-z0-9_]{1,20}", text):
+        raise ValueError(f"invalid subreddit: {value!r}")
+    return text
+
+
+def _normalize_post_type(value: str) -> str:
+    text = value.strip().lower().replace("_", "-")
+    aliases = {
+        "text": "text",
+        "self": "text",
+        "link": "link",
+        "url": "link",
+        "image": "image",
+        "photo": "image",
+        "video": "video",
+    }
+    if text in aliases:
+        return aliases[text]
+    raise ValueError("Reddit post_type must be one of: text, link, image, video")
+
+
+def _post_type_fallback(post_type: str) -> tuple[int, int]:
+    return {
+        "link": (255, 1470),
+        "image": (399, 1470),
+        "video": (543, 1470),
+    }[post_type]
+
+
+def _require_adb_text_safe(value: str, field_name: str) -> None:
+    if not value.strip():
+        raise ValueError(f"{field_name} is required")
+    if "\n" in value or "\r" in value or "\t" in value:
+        raise ValueError(f"{field_name} must be a single line for the current ADB-only POC")
+    if not value.isascii():
+        raise ValueError(f"{field_name} must be ASCII for the current ADB-only POC")
+
+
+def _lookup_recent_post(
+    *,
+    username: str,
+    subreddit: str,
+    title: str,
+    body: str,
+    link_url: str = "",
+    min_created_utc: int,
+) -> dict[str, str]:
+    safe_user = urllib.parse.quote(username.strip())
+    url = f"https://www.reddit.com/user/{safe_user}/submitted.json?limit=10"
+    req = urllib.request.Request(url, headers={"User-Agent": REDDIT_USER_AGENT})
+    try:
+        with urllib.request.urlopen(req, timeout=30, context=_ssl_context()) as resp:
+            data = json.loads(resp.read().decode("utf-8"))
+    except (urllib.error.URLError, TimeoutError, json.JSONDecodeError):
+        return {}
+
+    children = ((data.get("data") or {}).get("children") or []) if isinstance(data, dict) else []
+    for child in children:
+        post = child.get("data") or {}
+        if str(post.get("subreddit", "")).lower() != subreddit.lower():
+            continue
+        if str(post.get("title", "")) != title:
+            continue
+        if body and str(post.get("selftext", "")) != body:
+            continue
+        if link_url and str(post.get("url", "")) != link_url:
+            continue
+        if int(float(post.get("created_utc") or 0)) < min_created_utc:
+            continue
+        return {
+            "id": str(post.get("id", "")),
+            "permalink": str(post.get("permalink", "")),
+        }
+    return {}
+
+
+def _find_text_center(xml_path: Path, text: str) -> tuple[int, int] | None:
+    root = ET.parse(xml_path).getroot()
+    for node in root.iter("node"):
+        if node.attrib.get("text") != text:
+            continue
+        bounds = node.attrib.get("bounds", "")
+        match = re.fullmatch(r"\[(\d+),(\d+)\]\[(\d+),(\d+)\]", bounds)
+        if not match:
+            continue
+        left, top, right, bottom = [int(part) for part in match.groups()]
+        return ((left + right) // 2, (top + bottom) // 2)
+    return None
+
+
+def _find_resource_center(xml_path: Path, resource_id: str) -> tuple[int, int] | None:
+    root = ET.parse(xml_path).getroot()
+    for node in root.iter("node"):
+        node_resource = node.attrib.get("resource-id", "")
+        if node_resource != resource_id and not node_resource.endswith(f":id/{resource_id}"):
+            continue
+        bounds = node.attrib.get("bounds", "")
+        match = re.fullmatch(r"\[(\d+),(\d+)\]\[(\d+),(\d+)\]", bounds)
+        if not match:
+            continue
+        left, top, right, bottom = [int(part) for part in match.groups()]
+        return ((left + right) // 2, (top + bottom) // 2)
+    return None
+
+
+def _find_desc_or_text_center(xml_path: Path, values: set[str]) -> tuple[int, int] | None:
+    root = ET.parse(xml_path).getroot()
+    for node in root.iter("node"):
+        if node.attrib.get("text") not in values and node.attrib.get("content-desc") not in values:
+            continue
+        bounds = node.attrib.get("bounds", "")
+        match = re.fullmatch(r"\[(\d+),(\d+)\]\[(\d+),(\d+)\]", bounds)
+        if not match:
+            continue
+        left, top, right, bottom = [int(part) for part in match.groups()]
+        if right <= left or bottom <= top:
+            continue
+        return ((left + right) // 2, (top + bottom) // 2)
+    return None
+
+
+def _find_resource_text(xml_path: Path, resource_id: str) -> str:
+    root = ET.parse(xml_path).getroot()
+    for node in root.iter("node"):
+        node_resource = node.attrib.get("resource-id", "")
+        if node_resource == resource_id or node_resource.endswith(f":id/{resource_id}"):
+            return node.attrib.get("text", "")
+    return ""
+
+
+def _ssl_context() -> ssl.SSLContext | None:
+    try:
+        import certifi
+    except Exception:
+        return None
+    return ssl.create_default_context(cafile=certifi.where())
+
+
+def _caption(title: str, body: str) -> str:
+    return f"{title} | {body}" if body else title
+
+
+def _now_shanghai() -> str:
+    return datetime.now(ZoneInfo("Asia/Shanghai")).strftime("%Y-%m-%d %H:%M:%S %z")