@11agents/cli 0.1.24 → 0.1.25

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

@@ -0,0 +1,636 @@
+from __future__ import annotations
+
+import re
+import time
+from dataclasses import dataclass
+from datetime import datetime
+from pathlib import Path
+from zoneinfo import ZoneInfo
+
+from device_control.adb import AdbClient
+from device_control.appium_client import AppiumClient
+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
+
+
+X_PACKAGE = "com.twitter.android"
+X_MAIN_ACTIVITY = "com.twitter.app.main.MainActivity"
+X_COMPOSER_ACTIVITY = "com.twitter.composer.ComposerActivity"
+X_PROFILE_ACTIVITY = "com.twitter.app.profiles.ProfileActivity"
+X_GRADUATED_ACCESS_ACTIVITY = "com.twitter.feature.graduatedaccess.GraduatedAccessPromptActivity"
+
+BLOCKING_TEXT_MARKERS = {
+    "登录",
+    "注册",
+    "Sign in",
+    "Log in",
+    "Create account",
+    "验证码",
+    "验证你的身份",
+    "verify your identity",
+    "locked",
+    "suspended",
+    "unusual activity",
+}
+
+POST_PUBLISH_NOTICE_MARKERS = {
+    "解锁 X 上的更多精彩",
+    "解锁X上的更多精彩",
+    "unlock more on x",
+}
+
+
+class NeedsHumanError(RuntimeError):
+    pass
+
+
+@dataclass
+class XAdbPublishResult:
+    device_id: str
+    status: str
+    record_id: str
+    started_at: str
+    ended_at: str
+    duration_seconds: int
+    post_type: str
+    text: str
+    screenshot_path: str
+    remote_media_path: str = ""
+    link_url: str = ""
+    error: str = ""
+
+
+class XAdbPublisher:
+    """X text/link publisher for the Android POC device flow."""
+
+    def __init__(
+        self,
+        adb: AdbClient,
+        *,
+        appium_server: str = "http://127.0.0.1:4723",
+        records_path: str | Path = "data/publish_records.jsonl",
+        artifact_root: str | Path = "artifacts/screenshots",
+    ) -> None:
+        self.adb = adb
+        self.appium_server = appium_server
+        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_post(
+        self,
+        device: Device,
+        *,
+        post_type: str,
+        text: str = "",
+        link_url: str = "",
+        media_path: str | Path | None = None,
+        account_id: str,
+        dry_run: bool = False,
+        text_input: str = "auto",
+        verify_profile: bool = True,
+    ) -> XAdbPublishResult:
+        post_type = _normalize_post_type(post_type)
+        if text_input not in {"auto", "appium", "adb"}:
+            raise ValueError("text_input must be one of: auto, appium, adb")
+        if post_type == "link":
+            ui.require_adb_text_safe(link_url, "link_url")
+        publish_text = _x_text_body(text=text, link_url=link_url)
+        if not publish_text.strip():
+            raise ValueError("X post text is required")
+        if text_input == "adb":
+            ui.require_adb_text_safe(publish_text, "text")
+        local: Path | None = Path(media_path).expanduser() if media_path else None
+        if post_type == "image":
+            if local is None or not local.exists():
+                raise FileNotFoundError(f"image not found: {media_path}")
+            if ui.media_kind_from_path(local) != "image":
+                raise ValueError(f"post_type=image requires an image file: {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}-x-{stamp}"
+        run_dir.mkdir(parents=True, exist_ok=True)
+        record_id = f"pub_{stamp.replace('-', '')}_{device.device_id.lower()}_x"
+        remote = ""
+        if local is not None:
+            remote = f"/sdcard/DCIM/Camera/groupctl-{device.device_id}-x-{stamp}{local.suffix}"
+
+        try:
+            self._prepare_device(device)
+            if local is not None:
+                self.media_helper._push_media(device, local, remote)
+            self._open_home(device, run_dir)
+            self._open_compose(device, run_dir)
+            self._input_text(device, publish_text, run_dir, text_input)
+            if post_type == "image":
+                self._attach_image(device, run_dir)
+
+            if dry_run:
+                final_shot = run_dir / "dry-run-compose-form.png"
+                self.adb.screenshot(device.adb_serial, final_shot)
+                status = "dry_run"
+            else:
+                self._tap_post(device, run_dir)
+                final_shot = self._wait_for_publish_complete(device, run_dir, publish_text, verify_profile=verify_profile)
+                status = "published"
+                append_publish_record(
+                    self.records_path,
+                    PublishRecord(
+                        record_id=record_id,
+                        platform="x",
+                        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,
+                        caption=publish_text,
+                        platform_permalink="",
+                        published_at=utc_now_iso(),
+                        result_screenshot_path=str(final_shot),
+                        status="published",
+                    ),
+                )
+
+            return XAdbPublishResult(
+                device_id=device.device_id,
+                status=status,
+                record_id=record_id,
+                started_at=started_at,
+                ended_at=_now_shanghai(),
+                duration_seconds=int(time.time()) - started_epoch,
+                post_type=post_type,
+                text=publish_text,
+                remote_media_path=remote,
+                link_url=link_url,
+                screenshot_path=str(final_shot),
+            )
+        except NeedsHumanError as exc:
+            return self._failure_result(
+                device,
+                run_dir,
+                record_id,
+                started_at,
+                started_epoch,
+                publish_text,
+                post_type=post_type,
+                remote_media_path=remote,
+                link_url=link_url,
+                status="needs_human",
+                error=str(exc),
+            )
+        except Exception as exc:
+            return self._failure_result(
+                device,
+                run_dir,
+                record_id,
+                started_at,
+                started_epoch,
+                publish_text,
+                post_type=post_type,
+                remote_media_path=remote,
+                link_url=link_url,
+                status="failed",
+                error=str(exc),
+            )
+
+    def _failure_result(
+        self,
+        device: Device,
+        run_dir: Path,
+        record_id: str,
+        started_at: str,
+        started_epoch: int,
+        text: str,
+        *,
+        post_type: str,
+        remote_media_path: str = "",
+        link_url: str = "",
+        status: str,
+        error: str,
+    ) -> XAdbPublishResult:
+        failure_shot = run_dir / f"{status}.png"
+        self.adb.screenshot(device.adb_serial, failure_shot)
+        return XAdbPublishResult(
+            device_id=device.device_id,
+            status=status,
+            record_id=record_id,
+            started_at=started_at,
+            ended_at=_now_shanghai(),
+            duration_seconds=int(time.time()) - started_epoch,
+            post_type=post_type,
+            text=text,
+            remote_media_path=remote_media_path,
+            link_url=link_url,
+            screenshot_path=str(failure_shot),
+            error=error,
+        )
+
+    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_home(self, device: Device, run_dir: Path) -> None:
+        ui.grant_publish_permissions(self.adb, device, X_PACKAGE)
+        self.adb.shell(device.adb_serial, "am", "force-stop", X_PACKAGE)
+        time.sleep(1)
+        self._ok(self.adb.launch_package(device.adb_serial, X_PACKAGE), "launch X")
+        time.sleep(6)
+        self.adb.screenshot(device.adb_serial, run_dir / "home.png")
+        focus = self.adb.current_focus(device.adb_serial)
+        if X_PACKAGE not in focus:
+            raise NeedsHumanError("X is not foreground after launch; check install/login/verification state")
+        self._raise_if_blocked(device, run_dir / "home.xml")
+
+    def _open_compose(self, device: Device, run_dir: Path) -> None:
+        if self._is_compose_open(device, run_dir / "compose-check-initial.xml"):
+            return
+
+        for attempt in range(3):
+            root = ui.dump_ui(self.adb, device, run_dir / f"before-compose-{attempt}.xml")
+            node = ui.find_node(
+                root,
+                ids={f"{X_PACKAGE}:id/composer_write"},
+                id_suffixes={"composer_write"},
+                descs={"新帖子", "New post", "Post", "Tweet"},
+                partial_texts={"发帖"},
+                clickable_only=False,
+            )
+            if node is not None:
+                ui.tap_node(self.adb, device, node, sleep_s=1.5)
+                if self._is_compose_open(device, run_dir / f"compose-after-tap-{attempt}.xml"):
+                    self.adb.screenshot(device.adb_serial, run_dir / "compose-form.png")
+                    return
+
+                # X may first expand the bottom-right plus menu. Tap the post item again.
+                menu_root = ui.dump_ui(self.adb, device, run_dir / f"compose-menu-{attempt}.xml")
+                menu_label = ui.find_node(
+                    menu_root,
+                    texts={"发帖", "Post", "Tweet"},
+                    partial_texts={"发帖"},
+                    clickable_only=False,
+                )
+                if menu_label is not None:
+                    x, y = ui.center(menu_label)
+                    self._ok(self.adb.tap(device.adb_serial, x + 170, y), "tap X post menu item")
+                    time.sleep(3)
+                    if self._is_compose_open(device, run_dir / f"compose-after-menu-label-{attempt}.xml"):
+                        self.adb.screenshot(device.adb_serial, run_dir / "compose-form.png")
+                        return
+
+                menu_node = ui.find_node(
+                    menu_root,
+                    ids={f"{X_PACKAGE}:id/composer_write"},
+                    id_suffixes={"composer_write"},
+                    descs={"新帖子", "New post", "Post", "Tweet"},
+                    partial_texts={"发帖"},
+                    clickable_only=False,
+                )
+                if menu_node is not None:
+                    ui.tap_node(self.adb, device, menu_node, sleep_s=3)
+                    if self._is_compose_open(device, run_dir / f"compose-after-menu-{attempt}.xml"):
+                        self.adb.screenshot(device.adb_serial, run_dir / "compose-form.png")
+                        return
+
+            self._reveal_compose_button(device)
+
+        self.adb.screenshot(device.adb_serial, run_dir / "compose-entry-missing.png")
+        raise NeedsHumanError("X compose button was not found after scrolling the timeline")
+
+    def _reveal_compose_button(self, device: Device) -> None:
+        # X hides the bottom-right plus after the timeline sits idle or during scroll.
+        self.adb.swipe(device.adb_serial, 540, 980, 540, 1460, 250)
+        time.sleep(0.8)
+        self.adb.swipe(device.adb_serial, 540, 1460, 540, 1180, 200)
+        time.sleep(0.8)
+
+    def _is_compose_open(self, device: Device, xml_path: Path) -> bool:
+        focus = self.adb.current_focus(device.adb_serial)
+        if X_COMPOSER_ACTIVITY in focus:
+            return True
+        try:
+            root = ui.dump_ui(self.adb, device, xml_path)
+        except Exception:
+            return False
+        return ui.find_node(root, ids={f"{X_PACKAGE}:id/tweet_text"}, id_suffixes={"tweet_text"}) is not None
+
+    def _input_text(self, device: Device, text: str, run_dir: Path, text_input: str) -> None:
+        use_appium = text_input == "appium" or (text_input == "auto" and not ui.adb_text_safe(text))
+        if use_appium:
+            self._input_text_appium(device, text, run_dir)
+            return
+
+        ui.require_adb_text_safe(text, "text")
+        root = ui.dump_ui(self.adb, device, run_dir / "before-text.xml")
+        field = ui.find_node(root, ids={f"{X_PACKAGE}:id/tweet_text"}, id_suffixes={"tweet_text"}, clickable_only=False)
+        if field is None:
+            raise NeedsHumanError("X compose text field was not found")
+        ui.tap_node(self.adb, device, field, sleep_s=0.5)
+        result = self.adb.input_text(device.adb_serial, text)
+        if not result.ok:
+            self.adb.screenshot(device.adb_serial, run_dir / "text-input-failed.png")
+            raise RuntimeError(f"text input failed: {result.stderr or result.stdout}")
+        time.sleep(1)
+        self.adb.keyevent(device.adb_serial, "KEYCODE_BACK")
+        time.sleep(1)
+        self.adb.screenshot(device.adb_serial, run_dir / "after-text.png")
+
+    def _input_text_appium(self, device: Device, text: str, run_dir: Path) -> None:
+        appium = AppiumClient(self.appium_server)
+        try:
+            appium.start_session(_capabilities(device.adb_serial))
+            field = appium.find_element("id", f"{X_PACKAGE}:id/tweet_text")
+            appium.click(field)
+            time.sleep(0.5)
+            appium.send_keys(field, text)
+            time.sleep(1)
+            self.adb.screenshot(device.adb_serial, run_dir / "after-text.png")
+        except Exception as exc:
+            self.adb.screenshot(device.adb_serial, run_dir / "text-input-appium-failed.png")
+            raise RuntimeError(f"Appium text input failed: {exc}") from exc
+        finally:
+            try:
+                appium.delete_session()
+            except Exception:
+                pass
+
+    def _attach_image(self, device: Device, run_dir: Path) -> None:
+        root = ui.dump_ui(self.adb, device, run_dir / "before-gallery.xml")
+        gallery = ui.find_node(root, ids={f"{X_PACKAGE}:id/gallery"}, id_suffixes={"gallery"}, descs={"相片", "Photo", "Photos"})
+        if gallery is None:
+            raise NeedsHumanError("X gallery button was not found on compose form")
+        ui.tap_node(self.adb, device, gallery, sleep_s=3)
+        self._tap_permission_if_present(device, run_dir / "gallery-permission.xml")
+
+        grid_root = ui.dump_ui(self.adb, device, run_dir / "gallery-grid.xml")
+        image_node = _find_first_gallery_image(grid_root)
+        if image_node is None:
+            self.adb.screenshot(device.adb_serial, run_dir / "gallery-image-missing.png")
+            raise NeedsHumanError("X gallery did not expose a selectable image")
+        ui.tap_node(self.adb, device, image_node, sleep_s=1.5)
+        self.adb.screenshot(device.adb_serial, run_dir / "gallery-selected.png")
+
+        selected_root = ui.dump_ui(self.adb, device, run_dir / "gallery-selected.xml")
+        if _has_attached_media(selected_root):
+            return
+        done = ui.find_node(
+            selected_root,
+            ids={f"{X_PACKAGE}:id/add_images"},
+            id_suffixes={"add_images"},
+            texts={"完成", "Add", "Done"},
+            descs={"完成", "Add", "Done"},
+        )
+        if done is None:
+            self.adb.screenshot(device.adb_serial, run_dir / "gallery-done-missing.png")
+            raise NeedsHumanError("X gallery Done/Add button was not found")
+        ui.tap_node(self.adb, device, done, sleep_s=3)
+        self.adb.screenshot(device.adb_serial, run_dir / "after-image.png")
+
+    def _tap_permission_if_present(self, device: Device, xml_path: Path) -> None:
+        ui.tap_permission_prompt_if_present(self.adb, device, xml_path)
+
+    def _tap_post(self, device: Device, run_dir: Path) -> None:
+        root = ui.dump_ui(self.adb, device, run_dir / "before-post.xml")
+        node = ui.find_node(root, ids={f"{X_PACKAGE}:id/button_tweet"}, id_suffixes={"button_tweet"}, texts={"发帖", "Post", "Tweet"})
+        if node is None:
+            raise NeedsHumanError("X post button was not found on compose form")
+        if node.attrib.get("enabled") != "true":
+            raise NeedsHumanError("X post button is disabled; check text/media/content declaration")
+        ui.tap_node(self.adb, device, node, sleep_s=2)
+
+    def _wait_for_publish_complete(self, device: Device, run_dir: Path, publish_text: str, *, verify_profile: bool) -> Path:
+        deadline = time.time() + 45
+        poll = 0
+        after_post_shot = run_dir / "after-post.png"
+        while time.time() < deadline:
+            poll += 1
+            focus = self.adb.current_focus(device.adb_serial)
+            if X_PACKAGE in focus and X_COMPOSER_ACTIVITY not in focus:
+                root = ui.dump_ui(self.adb, device, run_dir / f"post-state-{poll}.xml")
+                text = ui.all_text(root)
+                if ui.contains_any(text, BLOCKING_TEXT_MARKERS):
+                    self.adb.screenshot(device.adb_serial, run_dir / "post-blocked.png")
+                    raise NeedsHumanError("X showed a verification/account restriction prompt after tapping post")
+                self.adb.screenshot(device.adb_serial, after_post_shot)
+                if not verify_profile:
+                    return after_post_shot
+                self._dismiss_post_publish_notice_if_present(device, run_dir / "post-publish-notice.xml")
+                return self._verify_post_on_profile(device, run_dir, publish_text)
+            root = ui.dump_ui(self.adb, device, run_dir / f"post-poll-{poll}.xml")
+            text = ui.all_text(root)
+            if ui.contains_any(text, BLOCKING_TEXT_MARKERS):
+                raise NeedsHumanError("X showed a verification/account restriction prompt after tapping post")
+            time.sleep(2)
+        self.adb.screenshot(device.adb_serial, run_dir / "post-timeout.png")
+        raise RuntimeError("X still appears to be on the compose screen after tapping post")
+
+    def _dismiss_post_publish_notice_if_present(self, device: Device, xml_path: Path) -> None:
+        focus = self.adb.current_focus(device.adb_serial)
+        try:
+            root = ui.dump_ui(self.adb, device, xml_path)
+        except Exception:
+            return
+        text = ui.all_text(root)
+        if X_GRADUATED_ACCESS_ACTIVITY not in focus and not ui.contains_any(text, POST_PUBLISH_NOTICE_MARKERS):
+            return
+        button = ui.find_node(
+            root,
+            texts={"明白了", "Got it", "OK"},
+            partial_texts={"明白了", "got it"},
+            clickable_only=False,
+        )
+        if button is not None:
+            ui.tap_node(self.adb, device, button, sleep_s=2)
+
+    def _verify_post_on_profile(self, device: Device, run_dir: Path, publish_text: str) -> Path:
+        self._open_profile(device, run_dir)
+        for attempt in range(6):
+            root = ui.dump_ui(self.adb, device, run_dir / f"profile-verify-{attempt + 1}.xml")
+            if _profile_has_post(root, publish_text):
+                final_shot = run_dir / "profile-post-confirmed.png"
+                self.adb.screenshot(device.adb_serial, final_shot)
+                return final_shot
+            self.adb.swipe(device.adb_serial, 540, 1800, 540, 760, 350)
+            time.sleep(2)
+
+        self.adb.screenshot(device.adb_serial, run_dir / "profile-post-missing.png")
+        raise NeedsHumanError("X publish completed, but the expected post text was not found on the profile page")
+
+    def _open_profile(self, device: Device, run_dir: Path) -> None:
+        if self._is_profile_open(device):
+            return
+
+        if X_PACKAGE not in self.adb.current_focus(device.adb_serial):
+            self._ok(self.adb.launch_package(device.adb_serial, X_PACKAGE), "launch X")
+            time.sleep(5)
+        self._dismiss_post_publish_notice_if_present(device, run_dir / "profile-open-notice.xml")
+        if self._is_profile_open(device):
+            return
+
+        for attempt in range(3):
+            root = ui.dump_ui(self.adb, device, run_dir / f"profile-open-home-{attempt + 1}.xml")
+            if _is_drawer_open(root):
+                current_profile = _find_profile_menu_item(root)
+                if current_profile is not None:
+                    ui.tap_node(self.adb, device, current_profile, sleep_s=3)
+                    if self._is_profile_open(device):
+                        self.adb.screenshot(device.adb_serial, run_dir / "profile.png")
+                        return
+
+            nav = ui.find_node(
+                root,
+                descs={"显示导航栏", "Open navigation drawer", "Show navigation drawer", "Navigation menu"},
+                partial_texts={"显示导航栏", "navigation drawer", "navigation menu"},
+                clickable_only=False,
+            )
+            if nav is None:
+                nav = _find_top_left_clickable(root)
+            if nav is None:
+                self.adb.keyevent(device.adb_serial, "KEYCODE_BACK")
+                time.sleep(1)
+                continue
+            ui.tap_node(self.adb, device, nav, sleep_s=1.5)
+
+            drawer_root = ui.dump_ui(self.adb, device, run_dir / f"profile-drawer-{attempt + 1}.xml")
+            profile = _find_profile_menu_item(drawer_root)
+            if profile is None:
+                self.adb.screenshot(device.adb_serial, run_dir / f"profile-menu-missing-{attempt + 1}.png")
+                self.adb.keyevent(device.adb_serial, "KEYCODE_BACK")
+                time.sleep(1)
+                continue
+            ui.tap_node(self.adb, device, profile, sleep_s=3)
+            if self._is_profile_open(device):
+                self.adb.screenshot(device.adb_serial, run_dir / "profile.png")
+                return
+
+        self.adb.screenshot(device.adb_serial, run_dir / "profile-open-failed.png")
+        raise NeedsHumanError("X profile page could not be opened from the navigation drawer")
+
+    def _is_profile_open(self, device: Device) -> bool:
+        return X_PROFILE_ACTIVITY in self.adb.current_focus(device.adb_serial)
+
+    def _raise_if_blocked(self, device: Device, xml_path: Path) -> None:
+        try:
+            root = ui.dump_ui(self.adb, device, xml_path)
+        except Exception:
+            return
+        text = ui.all_text(root)
+        if ui.contains_any(text, BLOCKING_TEXT_MARKERS):
+            raise NeedsHumanError("X login, verification, or account restriction prompt is visible")
+
+    @staticmethod
+    def _ok(result, action: str) -> None:
+        if not result.ok:
+            raise RuntimeError(f"{action} failed: {result.stderr or result.stdout}")
+
+
+def _normalize_post_type(value: str) -> str:
+    normalized = value.strip().lower().replace("_", "-")
+    if normalized in {"text", "post", "tweet"}:
+        return "text"
+    if normalized == "link":
+        return "link"
+    if normalized in {"image", "photo"}:
+        return "image"
+    raise ValueError("X post_type must be one of: text, link, image")
+
+
+def _x_text_body(*, text: str, link_url: str) -> str:
+    parts = [item.strip() for item in (text, link_url) if item and item.strip()]
+    return " ".join(parts)
+
+
+def _find_first_gallery_image(root) -> object | None:
+    candidates = []
+    for node in root.iter("node"):
+        if node.attrib.get("clickable") != "true":
+            continue
+        desc = node.attrib.get("content-desc", "").lower()
+        if desc not in {"图像", "image", "photo"}:
+            continue
+        value = ui.bounds(node)
+        if not value:
+            continue
+        candidates.append(node)
+    return ui.sorted_visible_nodes(candidates)[0] if candidates else None
+
+
+def _has_attached_media(root) -> bool:
+    return ui.find_node(root, ids={f"{X_PACKAGE}:id/media_attachments"}, id_suffixes={"media_attachments"}) is not None
+
+
+def _profile_has_post(root, expected_text: str) -> bool:
+    expected = _normalize_for_match(expected_text)
+    if not expected:
+        return False
+    haystack = _normalize_for_match(ui.all_text(root))
+    if expected in haystack:
+        return True
+    if len(expected) >= 80 and expected[:60] in haystack:
+        return True
+    return False
+
+
+def _normalize_for_match(value: str) -> str:
+    return re.sub(r"\s+", " ", value).strip()
+
+
+def _find_top_left_clickable(root) -> object | None:
+    candidates = []
+    for node in root.iter("node"):
+        if node.attrib.get("clickable") != "true":
+            continue
+        value = ui.bounds(node)
+        if not value:
+            continue
+        left, top, right, bottom = value
+        if left <= 180 and right <= 240 and top <= 320 and bottom <= 360:
+            candidates.append(node)
+    return ui.sorted_visible_nodes(candidates)[0] if candidates else None
+
+
+def _is_drawer_open(root) -> bool:
+    return ui.find_node(root, ids={f"{X_PACKAGE}:id/drawer"}, id_suffixes={"drawer"}) is not None
+
+
+def _find_profile_menu_item(root) -> object | None:
+    candidates = []
+    for node in root.iter("node"):
+        text = node.attrib.get("text", "")
+        desc = node.attrib.get("content-desc", "")
+        if text not in {"个人资料", "Profile"} and desc not in {"个人资料", "Profile"}:
+            continue
+        value = ui.bounds(node)
+        if not value:
+            continue
+        left, top, right, _bottom = value
+        if left <= 300 and 500 <= top <= 1200 and right <= 1000:
+            candidates.append(node)
+    return ui.sorted_visible_nodes(candidates)[0] if candidates else None
+
+
+def _capabilities(serial: str) -> dict:
+    return {
+        "platformName": "Android",
+        "appium:automationName": "UiAutomator2",
+        "appium:udid": serial,
+        "appium:noReset": True,
+        "appium:dontStopAppOnReset": True,
+        "appium:newCommandTimeout": 120,
+        "appium:disableWindowAnimation": True,
+        "appium:skipDeviceInitialization": True,
+        "appium:ignoreHiddenApiPolicyError": True,
+        "appium:disableSuppressAccessibilityService": True,
+        "appium:settings[enableNotificationListener]": False,
+        "appium:appPackage": X_PACKAGE,
+        "appium:appActivity": X_COMPOSER_ACTIVITY,
+    }
+
+
+def _now_shanghai() -> str:
+    return datetime.now(ZoneInfo("Asia/Shanghai")).strftime("%Y-%m-%d %H:%M:%S %z")