@11agents/cli 0.1.41 → 0.1.43

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

@@ -1,6 +1,7 @@
 from __future__ import annotations
 
 import base64
+import re
 import shlex
 import time
 from dataclasses import dataclass
@@ -50,6 +51,16 @@ TIKTOK_PREVIEW_TEXTS = (
     "一键成片",
     "AutoCut",
 )
+TIKTOK_SHARE_TEXTS = (
+    "分享视频",
+    "分享",
+    "Share video",
+    "Share",
+)
+TIKTOK_COPY_LINK_TEXTS = (
+    "复制链接",
+    "Copy link",
+)
 
 
 class TikTokAutomationBlockedError(RuntimeError):
@@ -66,6 +77,23 @@ class TikTokAdbPublishResult:
     duration_seconds: int
     remote_media_path: str
     screenshot_path: str
+    platform_permalink: str = ""
+    platform_post_id: str = ""
+    link_status: str = ""
+    link_error: str = ""
+    link_screenshot_path: str = ""
+    clipboard_method: str = ""
+    error: str = ""
+
+
+@dataclass
+class TikTokAdbLinkResult:
+    device_id: str
+    status: str
+    platform_permalink: str
+    screenshot_path: str
+    platform_post_id: str = ""
+    clipboard_method: str = ""
     error: str = ""
 
 
@@ -76,10 +104,12 @@ class TikTokAdbPublisher:
         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)
 
@@ -104,6 +134,7 @@ class TikTokAdbPublisher:
         run_dir.mkdir(parents=True, exist_ok=True)
         remote = f"/sdcard/DCIM/Camera/groupctl-{device.device_id}-tiktok-{stamp}{local.suffix or '.mp4'}"
         record_id = f"pub_{stamp.replace('-', '')}_{device.device_id.lower()}_tiktok"
+        link_result: TikTokAdbLinkResult | None = None
 
         try:
             self._prepare_device(device)
@@ -123,6 +154,18 @@ class TikTokAdbPublisher:
             else:
                 self._tap_publish(device, run_dir)
                 final_shot = self._wait_for_publish_confirmation(device, run_dir)
+                link_result = self.copy_current_or_latest_video_link(
+                    device,
+                    run_dir=run_dir / "link",
+                    video_order=1,
+                    close_after_recovery=True,
+                )
+                if link_result.status != "retrieved" or not link_result.platform_permalink:
+                    raise RuntimeError(
+                        "TikTok post-publish link recovery failed: "
+                        f"{link_result.error or link_result.status}"
+                    )
+                final_shot = Path(link_result.screenshot_path)
                 status = "published"
 
             ended_epoch = int(time.time())
@@ -136,13 +179,14 @@ class TikTokAdbPublisher:
                     post_type="video",
                     local_media_path=str(local),
                     remote_media_path=remote,
+                    platform_post_id=link_result.platform_post_id if link_result else "",
+                    platform_permalink=link_result.platform_permalink if link_result else "",
                     caption=caption,
                     published_at=utc_now_iso(),
                     result_screenshot_path=str(final_shot),
                     status="published",
                 )
                 append_publish_record(self.records_path, record)
-                self._close_tiktok_best_effort(device, run_dir)
             return TikTokAdbPublishResult(
                 device_id=device.device_id,
                 status=status,
@@ -152,11 +196,18 @@ class TikTokAdbPublisher:
                 duration_seconds=ended_epoch - started_epoch,
                 remote_media_path=remote,
                 screenshot_path=str(final_shot),
+                platform_permalink=link_result.platform_permalink if link_result else "",
+                platform_post_id=link_result.platform_post_id if link_result else "",
+                link_status=link_result.status if link_result else "",
+                link_error=link_result.error if link_result else "",
+                link_screenshot_path=link_result.screenshot_path if link_result else "",
+                clipboard_method=link_result.clipboard_method if link_result else "",
             )
         except TikTokAutomationBlockedError as exc:
             ended_epoch = int(time.time())
             failure_shot = run_dir / "failed.png"
             self.adb.screenshot(device.adb_serial, failure_shot)
+            self._close_tiktok_best_effort(device, run_dir)
             return TikTokAdbPublishResult(
                 device_id=device.device_id,
                 status="failed",
@@ -166,12 +217,19 @@ class TikTokAdbPublisher:
                 duration_seconds=ended_epoch - started_epoch,
                 remote_media_path=remote,
                 screenshot_path=str(failure_shot),
+                platform_permalink=link_result.platform_permalink if link_result else "",
+                platform_post_id=link_result.platform_post_id if link_result else "",
+                link_status=link_result.status if link_result else "",
+                link_error=link_result.error if link_result else "",
+                link_screenshot_path=link_result.screenshot_path if link_result else "",
+                clipboard_method=link_result.clipboard_method if link_result else "",
                 error=str(exc),
             )
         except Exception as exc:
             ended_epoch = int(time.time())
             failure_shot = run_dir / "failed.png"
             self.adb.screenshot(device.adb_serial, failure_shot)
+            self._close_tiktok_best_effort(device, run_dir)
             return TikTokAdbPublishResult(
                 device_id=device.device_id,
                 status="failed",
@@ -181,8 +239,429 @@ class TikTokAdbPublisher:
                 duration_seconds=ended_epoch - started_epoch,
                 remote_media_path=remote,
                 screenshot_path=str(failure_shot),
+                platform_permalink=link_result.platform_permalink if link_result else "",
+                platform_post_id=link_result.platform_post_id if link_result else "",
+                link_status=link_result.status if link_result else "",
+                link_error=link_result.error if link_result else "",
+                link_screenshot_path=link_result.screenshot_path if link_result else "",
+                clipboard_method=link_result.clipboard_method if link_result else "",
+                error=str(exc),
+            )
+
+    def copy_latest_video_link(
+        self,
+        device: Device,
+        *,
+        run_dir: Path | None = None,
+        prepare: bool = True,
+        video_order: int = 1,
+        close_after_recovery: bool = True,
+    ) -> TikTokAdbLinkResult:
+        if run_dir is None:
+            stamp = datetime.now(ZoneInfo("Asia/Shanghai")).strftime("%Y%m%d-%H%M%S")
+            run_dir = self.artifact_root / f"{device.device_id}-tiktok-link-{stamp}"
+        run_dir.mkdir(parents=True, exist_ok=True)
+
+        try:
+            self._open_latest_own_video_for_link(
+                device,
+                run_dir,
+                prepare=prepare,
+                video_order=video_order,
+            )
+            self._tap_share_from_video_detail(device, run_dir)
+            self._tap_copy_link(device, run_dir)
+            time.sleep(1.5)
+            final_shot = run_dir / "after-copy-link.png"
+            self.adb.screenshot(device.adb_serial, final_shot)
+            permalink, method, error = self._read_copied_link(device, run_dir)
+            post_id = _tiktok_post_id(permalink)
+            if permalink:
+                return TikTokAdbLinkResult(
+                    device_id=device.device_id,
+                    status="retrieved",
+                    platform_permalink=permalink,
+                    platform_post_id=post_id,
+                    screenshot_path=str(final_shot),
+                    clipboard_method=method,
+                )
+            return TikTokAdbLinkResult(
+                device_id=device.device_id,
+                status="failed",
+                platform_permalink="",
+                screenshot_path=str(final_shot),
+                error=error or "copied link to device clipboard, but automatic clipboard read returned no URL",
+            )
+        except Exception as exc:
+            failure_shot = run_dir / "failed-copy-link.png"
+            self.adb.screenshot(device.adb_serial, failure_shot)
+            return TikTokAdbLinkResult(
+                device_id=device.device_id,
+                status="failed",
+                platform_permalink="",
+                screenshot_path=str(failure_shot),
                 error=str(exc),
             )
+        finally:
+            if close_after_recovery:
+                self._close_tiktok_best_effort(device, run_dir)
+
+    def copy_current_or_latest_video_link(
+        self,
+        device: Device,
+        *,
+        run_dir: Path | None = None,
+        video_order: int = 1,
+        close_after_recovery: bool = True,
+    ) -> TikTokAdbLinkResult:
+        if run_dir is None:
+            stamp = datetime.now(ZoneInfo("Asia/Shanghai")).strftime("%Y%m%d-%H%M%S")
+            run_dir = self.artifact_root / f"{device.device_id}-tiktok-link-{stamp}"
+        run_dir.mkdir(parents=True, exist_ok=True)
+
+        current = self.copy_current_visible_video_link(
+            device,
+            run_dir=run_dir / "current",
+            close_after_recovery=False,
+        )
+        current_copy_link_was_visible = current.error != "current TikTok page does not show a copy link action"
+        if current_copy_link_was_visible:
+            if close_after_recovery:
+                self._close_tiktok_best_effort(device, run_dir)
+            return current
+
+        latest = self.copy_latest_video_link(
+            device,
+            run_dir=run_dir / "latest",
+            prepare=True,
+            video_order=video_order,
+            close_after_recovery=False,
+        )
+        if close_after_recovery:
+            self._close_tiktok_best_effort(device, run_dir)
+        return latest
+
+    def copy_current_visible_video_link(
+        self,
+        device: Device,
+        *,
+        run_dir: Path | None = None,
+        close_after_recovery: bool = True,
+    ) -> TikTokAdbLinkResult:
+        if run_dir is None:
+            stamp = datetime.now(ZoneInfo("Asia/Shanghai")).strftime("%Y%m%d-%H%M%S")
+            run_dir = self.artifact_root / f"{device.device_id}-tiktok-current-link-{stamp}"
+        run_dir.mkdir(parents=True, exist_ok=True)
+
+        try:
+            root = self._dump_and_check(device, run_dir, "current-before-copy-link")
+            node = _find_tiktok_copy_link_node(root)
+            if node is None:
+                self.adb.screenshot(device.adb_serial, run_dir / "current-copy-link-missing.png")
+                return TikTokAdbLinkResult(
+                    device_id=device.device_id,
+                    status="failed",
+                    platform_permalink="",
+                    screenshot_path=str(run_dir / "current-copy-link-missing.png"),
+                    error="current TikTok page does not show a copy link action",
+                )
+            self.adb.screenshot(device.adb_serial, run_dir / "current-copy-link-visible.png")
+            ui.tap_node(self.adb, device, node, sleep_s=1.5)
+            final_shot = run_dir / "after-copy-link.png"
+            self.adb.screenshot(device.adb_serial, final_shot)
+            permalink, method, error = self._read_copied_link(device, run_dir)
+            post_id = _tiktok_post_id(permalink)
+            if permalink:
+                return TikTokAdbLinkResult(
+                    device_id=device.device_id,
+                    status="retrieved",
+                    platform_permalink=permalink,
+                    platform_post_id=post_id,
+                    screenshot_path=str(final_shot),
+                    clipboard_method=method,
+                )
+            return TikTokAdbLinkResult(
+                device_id=device.device_id,
+                status="failed",
+                platform_permalink="",
+                screenshot_path=str(final_shot),
+                error=error or "copied link to device clipboard, but automatic clipboard read returned no URL",
+            )
+        except Exception as exc:
+            failure_shot = run_dir / "failed-current-copy-link.png"
+            self.adb.screenshot(device.adb_serial, failure_shot)
+            return TikTokAdbLinkResult(
+                device_id=device.device_id,
+                status="failed",
+                platform_permalink="",
+                screenshot_path=str(failure_shot),
+                error=str(exc),
+            )
+        finally:
+            if close_after_recovery:
+                self._close_tiktok_best_effort(device, run_dir)
+
+    def _open_latest_own_video_for_link(
+        self,
+        device: Device,
+        run_dir: Path,
+        *,
+        prepare: bool,
+        video_order: int,
+    ) -> None:
+        from device_control.metrics.tiktok_video_adb import TikTokVideoMetricsAdbCollector
+
+        collector = TikTokVideoMetricsAdbCollector(self.adb, artifact_root=self.artifact_root)
+        width, height = self._screen_size(device)
+        if prepare:
+            self._prepare_device(device)
+            self._launch_tiktok(device)
+        else:
+            self._ok(self.adb.wake(device.adb_serial), "wake device")
+            if TIKTOK_PACKAGE not in self.adb.current_focus(device.adb_serial):
+                self._launch_tiktok(device)
+
+        # Use the same profile-grid route as the TikTok video metrics collector, but stop at
+        # the owned video page so the share sheet can expose a stable public link.
+        self._tap(device, int(width * 0.92), int(height * 0.96), 0)
+        time.sleep(3)
+        self.adb.screenshot(device.adb_serial, run_dir / "profile.png")
+        collector._dismiss_profile_prompt_if_present(device, run_dir, width, height)
+        collector._select_profile_posts_tab(device, run_dir, width, height)
+        time.sleep(10)
+        self.adb.screenshot(device.adb_serial, run_dir / "profile-posts-after-load-wait.png")
+        self._wait_for_profile_video_grid(device, run_dir, width, height)
+        collector._open_profile_video_by_order(device, run_dir, width, height, video_order)
+        time.sleep(3)
+        self.adb.screenshot(device.adb_serial, run_dir / "latest-video-open.png")
+
+    def _wait_for_profile_video_grid(self, device: Device, run_dir: Path, width: int, height: int) -> None:
+        from device_control.metrics.tiktok_video_adb import _find_profile_video_nodes
+
+        for attempt in range(6):
+            root = self._dump_or_none(device, run_dir / f"profile-video-grid-wait-{attempt + 1}.xml")
+            nodes = _find_profile_video_nodes(root, width, height) if root is not None else []
+            if nodes:
+                return
+            time.sleep(2)
+            self.adb.screenshot(device.adb_serial, run_dir / f"profile-video-grid-wait-{attempt + 1}.png")
+
+    def _tap_share_from_video_detail(self, device: Device, run_dir: Path) -> None:
+        width, height = self._screen_size(device)
+        fallback_points = (
+            (int(width * 0.92), int(height * 0.72)),
+            (int(width * 0.92), int(height * 0.66)),
+            (int(width * 0.92), int(height * 0.78)),
+        )
+        for attempt in range(6):
+            root = self._dump_and_check(device, run_dir, f"video-before-share-{attempt + 1}")
+            node = _find_tiktok_share_button(root, width, height)
+            if node is not None:
+                ui.tap_node(self.adb, device, node, sleep_s=2)
+                self.adb.screenshot(device.adb_serial, run_dir / "share-sheet.png")
+                return
+
+            if attempt < len(fallback_points):
+                x, y = fallback_points[attempt]
+                self._tap(device, x, y, 2)
+                self.adb.screenshot(device.adb_serial, run_dir / f"share-fallback-{attempt + 1}.png")
+                share_root = self._dump_and_check(device, run_dir, f"share-fallback-{attempt + 1}")
+                if _find_tiktok_copy_link_node(share_root) is not None:
+                    self.adb.screenshot(device.adb_serial, run_dir / "share-sheet.png")
+                    return
+                self.adb.keyevent(device.adb_serial, "KEYCODE_BACK")
+                time.sleep(1)
+                continue
+
+            time.sleep(1)
+
+        self.adb.screenshot(device.adb_serial, run_dir / "share-icon-missing.png")
+        raise RuntimeError("TikTok share action was not found on the video detail page")
+
+    def _tap_copy_link(self, device: Device, run_dir: Path) -> None:
+        width, height = self._screen_size(device)
+        for attempt in range(6):
+            root = self._dump_and_check(device, run_dir, f"share-sheet-{attempt + 1}")
+            if attempt == 0:
+                self.adb.screenshot(device.adb_serial, run_dir / "share-sheet.png")
+            node = _find_tiktok_copy_link_node(root)
+            if node is not None:
+                ui.tap_node(self.adb, device, node, sleep_s=1)
+                return
+            time.sleep(1)
+
+        self._tap(device, int(width * 0.14), int(height * 0.87), 1)
+        self.adb.screenshot(device.adb_serial, run_dir / "copy-link-fallback.png")
+
+    def _read_copied_link(self, device: Device, run_dir: Path) -> tuple[str, str, str]:
+        errors: list[str] = []
+
+        result = self.adb.shell(device.adb_serial, "cmd", "clipboard", "get")
+        if result.ok:
+            link = _extract_tiktok_url(result.stdout)
+            if link:
+                return link, "adb_cmd_clipboard", ""
+            errors.append("adb_cmd_clipboard returned no TikTok URL")
+        else:
+            errors.append(f"adb_cmd_clipboard failed: {_short(result.stderr or result.stdout)}")
+
+        result = self.adb.shell(device.adb_serial, "dumpsys", "clipboard")
+        if result.ok:
+            link = _extract_tiktok_url(result.stdout)
+            if link:
+                return link, "adb_dumpsys_clipboard", ""
+            errors.append("adb_dumpsys_clipboard returned no TikTok URL")
+        else:
+            errors.append(f"adb_dumpsys_clipboard failed: {_short(result.stderr or result.stdout)}")
+
+        link = self._read_link_by_launcher_search_paste_probe(device, run_dir)
+        if link:
+            return link, "launcher_search_paste_probe_ui_dump", ""
+        errors.append("launcher_search_paste_probe_ui_dump returned no TikTok URL")
+
+        link = self._read_link_by_tiktok_search_paste_probe(device, run_dir)
+        if link:
+            return link, "tiktok_search_paste_probe_ui_dump", ""
+        errors.append("tiktok_search_paste_probe_ui_dump returned no TikTok URL")
+
+        return "", "", "; ".join(errors)
+
+    def _read_link_by_launcher_search_paste_probe(self, device: Device, run_dir: Path) -> str:
+        try:
+            self._close_tiktok_best_effort(device, run_dir)
+            self.adb.keyevent(device.adb_serial, "KEYCODE_HOME")
+            time.sleep(1)
+            width, height = self._screen_size(device)
+            self._tap(device, int(width * 0.50), int(height * 0.91), 1)
+            self.adb.screenshot(device.adb_serial, run_dir / "launcher-search-probe-open.png")
+
+            root = self._dump_and_check(device, run_dir, "launcher-search-probe-open")
+            input_node = _find_launcher_search_input(root)
+            if input_node is None:
+                self._tap(device, int(width * 0.50), int(height * 0.09), 0.5)
+                root = self._dump_and_check(device, run_dir, "launcher-search-probe-input")
+                input_node = _find_launcher_search_input(root)
+            if input_node is not None:
+                existing = _launcher_search_input_text(input_node)
+                if existing:
+                    clear_node = _find_launcher_search_clear_node(root, width, height)
+                    if clear_node is not None:
+                        ui.tap_node(self.adb, device, clear_node, sleep_s=0.4)
+                    else:
+                        self._tap(device, int(width * 0.93), int(height * 0.09), 0.4)
+                    root = self._dump_or_none(device, run_dir / "launcher-search-probe-after-clear.xml") or root
+                    input_node = _find_launcher_search_input(root) or input_node
+                ui.tap_node(self.adb, device, input_node, sleep_s=0.4)
+            else:
+                self._tap(device, int(width * 0.50), int(height * 0.09), 0.4)
+
+            self.adb.keyevent(device.adb_serial, "KEYCODE_PASTE")
+            time.sleep(0.8)
+            self.adb.screenshot(device.adb_serial, run_dir / "launcher-search-probe-after-paste.png")
+            root = self._dump_and_check(device, run_dir, "launcher-search-probe-after-paste")
+            link = _extract_tiktok_url(ui.all_text(root))
+            if link:
+                return link
+
+            # Some keyboards show the copied URL in a suggestion strip instead of honoring KEYCODE_PASTE.
+            self._tap(device, int(width * 0.40), int(height * 0.742), 0.8)
+            self.adb.screenshot(device.adb_serial, run_dir / "launcher-search-probe-after-clipboard-suggestion.png")
+            root = self._dump_and_check(device, run_dir, "launcher-search-probe-after-clipboard-suggestion")
+            link = _extract_tiktok_url(ui.all_text(root))
+            if link:
+                return link
+
+            input_node = _find_launcher_search_input(root)
+            if input_node is not None:
+                self._long_press_node(device, input_node)
+                time.sleep(0.5)
+                paste_root = self._dump_and_check(device, run_dir, "launcher-search-probe-paste-menu")
+                paste = ui.find_node(
+                    paste_root,
+                    texts={"粘贴", "Paste"},
+                    descs={"粘贴", "Paste"},
+                    partial_texts={"粘贴", "paste"},
+                )
+                if paste is not None:
+                    ui.tap_node(self.adb, device, paste, sleep_s=0.8)
+                    self.adb.screenshot(device.adb_serial, run_dir / "launcher-search-probe-after-menu-paste.png")
+                    root = self._dump_and_check(device, run_dir, "launcher-search-probe-after-menu-paste")
+                    return _extract_tiktok_url(ui.all_text(root))
+            return ""
+        except Exception:
+            return ""
+        finally:
+            self.adb.keyevent(device.adb_serial, "KEYCODE_BACK")
+            time.sleep(0.2)
+            self.adb.keyevent(device.adb_serial, "KEYCODE_HOME")
+            time.sleep(0.5)
+
+    def _read_link_by_tiktok_search_paste_probe(self, device: Device, run_dir: Path) -> str:
+        try:
+            self._launch_tiktok(device)
+            width, height = self._screen_size(device)
+            root = self._dump_and_check(device, run_dir, "tiktok-before-search-probe")
+            search_node = _find_tiktok_search_node(root, width, height)
+            if search_node is None:
+                self._tap(device, int(width * 0.08), int(height * 0.96), 1.5)
+                root = self._dump_and_check(device, run_dir, "tiktok-search-probe-home")
+                search_node = _find_tiktok_search_node(root, width, height)
+            if search_node is not None:
+                ui.tap_node(self.adb, device, search_node, sleep_s=1.5)
+            else:
+                self._tap(device, int(width * 0.92), int(height * 0.075), 1.5)
+            self.adb.screenshot(device.adb_serial, run_dir / "tiktok-search-probe-open.png")
+
+            for attempt in range(3):
+                root = self._dump_and_check(device, run_dir, f"tiktok-search-probe-before-paste-{attempt + 1}")
+                input_node = _find_tiktok_search_input(root)
+                if input_node is not None:
+                    ui.tap_node(self.adb, device, input_node, sleep_s=0.5)
+                else:
+                    self._tap(device, int(width * 0.50), int(height * 0.075), 0.5)
+                self.adb.keyevent(device.adb_serial, "KEYCODE_PASTE")
+                time.sleep(1)
+                self.adb.screenshot(device.adb_serial, run_dir / f"tiktok-search-probe-after-paste-{attempt + 1}.png")
+                root = self._dump_and_check(device, run_dir, f"tiktok-search-probe-after-paste-{attempt + 1}")
+                link = _extract_tiktok_url(ui.all_text(root))
+                if link:
+                    return link
+                input_node = _find_tiktok_search_input(root)
+                if input_node is None:
+                    continue
+                self._long_press_node(device, input_node)
+                time.sleep(0.5)
+                paste_root = self._dump_and_check(device, run_dir, f"tiktok-search-probe-paste-menu-{attempt + 1}")
+                paste = ui.find_node(paste_root, texts={"粘贴", "Paste"}, descs={"粘贴", "Paste"}, partial_texts={"粘贴", "paste"})
+                if paste is not None:
+                    ui.tap_node(self.adb, device, paste, sleep_s=1)
+                    self.adb.screenshot(device.adb_serial, run_dir / f"tiktok-search-probe-after-menu-paste-{attempt + 1}.png")
+                    root = self._dump_and_check(device, run_dir, f"tiktok-search-probe-after-menu-paste-{attempt + 1}")
+                    link = _extract_tiktok_url(ui.all_text(root))
+                    if link:
+                        return link
+            return ""
+        except Exception:
+            return ""
+        finally:
+            self._close_tiktok_best_effort(device, run_dir)
+
+    def _long_press_node(self, device: Device, node) -> None:
+        left, top, right, bottom = ui.bounds(node) or (0, 0, 0, 0)
+        x = (left + right) // 2
+        y = min(max((top + bottom) // 2, top + 8), bottom - 8)
+        self.adb.swipe(device.adb_serial, x, y, x, y, 900)
+
+    def _screen_size(self, device: Device) -> tuple[int, int]:
+        result = self.adb.shell(device.adb_serial, "wm", "size")
+        if result.ok:
+            for part in result.stdout.split():
+                if "x" not in part:
+                    continue
+                left, right = part.split("x", 1)
+                if left.isdigit() and right.isdigit():
+                    return int(left), int(right)
+        return (1080, 2245)
 
     def _prepare_device(self, device: Device) -> None:
         self._ok(self.adb.wake(device.adb_serial), "wake device")
@@ -278,19 +757,22 @@ class TikTokAdbPublisher:
     def _open_gallery(self, device: Device, run_dir: Path) -> None:
         # D01 and D02 currently expose different create-page entry points.
         # Try the D01 bottom-left upload first, then the D02 right-side album icon.
+        width, height = self._screen_size(device)
         root = self._dump_and_check(device, run_dir, "before-gallery-tap")
         upload_node = ui.find_node(root, id_suffixes={"upload_hot_area"}, clickable_only=True)
         if upload_node is None:
-            self._tap(device, 105, 2050, 0)
+            self._tap(device, int(width * 0.09), int(height * 0.92), 0)
         else:
             ui.tap_node(self.adb, device, upload_node)
         time.sleep(2)
         shot = run_dir / "after-gallery-tap-1.png"
         self.adb.screenshot(device.adb_serial, shot)
-        self._assert_not_home_or_wrong_surface(
-            self._dump_and_check(device, run_dir, "after-gallery-tap-1"),
-            "open TikTok gallery",
-        )
+        root = self._dump_and_check(device, run_dir, "after-gallery-tap-1")
+        if _is_tiktok_create_home_surface(root):
+            self._tap(device, int(width * 0.09), int(height * 0.955), 2)
+            self.adb.screenshot(device.adb_serial, run_dir / "after-gallery-tap-retry.png")
+            root = self._dump_and_check(device, run_dir, "after-gallery-tap-retry")
+        self._assert_not_home_or_wrong_surface(root, "open TikTok gallery")
         ui.tap_permission_prompt_if_present(self.adb, device, run_dir / "gallery-permission.xml")
         if device.device_id == "D02":
             self._tap(device, 985, 610, 3)
@@ -344,12 +826,15 @@ class TikTokAdbPublisher:
         self.adb.screenshot(device.adb_serial, run_dir / "after-caption.png")
 
     def _tap_publish(self, device: Device, run_dir: Path) -> None:
+        width, height = self._screen_size(device)
         root = self._dump_and_check(device, run_dir, "before-publish")
-        node = self._find_visible_text_node(root, ("发布", "Post"), clickable_only=True)
+        node = self._find_visible_text_node(root, ("发布", "Post"), clickable_only=False)
         if node is None:
-            self._tap(device, 790, 2208, 0)
+            self._tap(device, int(width * 0.75), int(height * 0.92), 0)
         else:
             ui.tap_node(self.adb, device, node)
+        time.sleep(2)
+        self.adb.screenshot(device.adb_serial, run_dir / "after-publish-tap.png")
 
     def _tap_next_button(
         self,
@@ -412,26 +897,34 @@ class TikTokAdbPublisher:
         return has_video_actions and has_recent_timestamp
 
     def _wait_for_publish_confirmation(self, device: Device, run_dir: Path) -> Path:
-        deadline = time.time() + 60
+        deadline = time.time() + 90
         last_shot = run_dir / "after-post.png"
         last_text = ""
         while time.time() < deadline:
             time.sleep(2)
             self.adb.screenshot(device.adb_serial, last_shot)
-            root = self._dump_and_check(device, run_dir, "after-post")
-            last_text = ui.all_text(root)
+            try:
+                root = self._dump_and_check(device, run_dir, "after-post")
+                last_text = ui.all_text(root)
+            except TikTokAutomationBlockedError:
+                raise
+            except Exception as exc:
+                last_text = f"ui dump unavailable while waiting for TikTok publish completion: {exc}"
+                continue
             if ui.tap_permission_prompt_if_present(self.adb, device, run_dir / "after-post-permission.xml"):
                 time.sleep(2)
                 self.adb.screenshot(device.adb_serial, last_shot)
                 continue
             if _contains_any(last_text, TIKTOK_PUBLISH_CONFIRMATION_TEXTS):
                 return last_shot
+            if _find_tiktok_copy_link_node(root) is not None:
+                return last_shot
             if self._is_published_video_surface(root):
                 return last_shot
             if _contains_any(last_text, TIKTOK_STORY_TEXTS):
                 raise RuntimeError("TikTok publish route is on story/thoughts surface, not the video post flow")
         raise RuntimeError(
-            "TikTok publish completion was not confirmed within 60s; "
+            "TikTok publish completion was not confirmed within 90s; "
             "not writing a published record. Last UI text: "
             f"{_short_text(last_text)}"
         )
@@ -447,11 +940,19 @@ class TikTokAdbPublisher:
             raise RuntimeError("TikTok opened the LIVE microphone permission surface, not the video publish flow")
         return root
 
+    def _dump_or_none(self, device: Device, path: Path):
+        try:
+            return ui.dump_ui(self.adb, device, path)
+        except Exception:
+            return None
+
     def _assert_not_home_or_wrong_surface(self, root, action: str) -> None:
         text = ui.all_text(root)
         story = _first_contained(text, TIKTOK_STORY_TEXTS)
         if story and not _contains_any(text, TIKTOK_NEXT_TEXTS):
             raise RuntimeError(f"{action} failed: TikTok opened story/thoughts surface ({story}), not video publish")
+        if _is_tiktok_create_home_surface(root):
+            raise RuntimeError(f"{action} failed: TikTok is still on the create camera/template surface")
         home_matches = [part for part in TIKTOK_HOME_TEXTS if part in text]
         if len(home_matches) >= 3:
             raise RuntimeError(f"{action} failed: TikTok is still on home/feed UI ({', '.join(home_matches)})")
@@ -484,6 +985,172 @@ def _first_contained(text: str, needles: tuple[str, ...]) -> str:
     return ""
 
 
+def _find_tiktok_share_button(root, width: int, height: int):
+    candidates = []
+    for node in root.iter("node"):
+        if not ui.is_visible(node):
+            continue
+        text = node.attrib.get("text", "")
+        desc = node.attrib.get("content-desc", "")
+        haystack = f"{text}\n{desc}".lower()
+        if not any(marker.lower() in haystack for marker in TIKTOK_SHARE_TEXTS):
+            continue
+        if any(marker.lower() in haystack for marker in TIKTOK_COPY_LINK_TEXTS):
+            continue
+        value = ui.bounds(node)
+        if not value:
+            continue
+        left, top, right, bottom = value
+        center_x = (left + right) // 2
+        center_y = (top + bottom) // 2
+        if center_x < int(width * 0.70):
+            continue
+        if center_y < int(height * 0.35) or center_y > int(height * 0.90):
+            continue
+        candidates.append(node)
+    sorted_candidates = ui.sorted_visible_nodes(candidates)
+    return sorted_candidates[-1] if sorted_candidates else None
+
+
+def _find_tiktok_copy_link_node(root):
+    return ui.find_node(
+        root,
+        texts=set(TIKTOK_COPY_LINK_TEXTS),
+        descs=set(TIKTOK_COPY_LINK_TEXTS),
+        partial_texts={"复制链接", "copy link"},
+        clickable_only=False,
+    )
+
+
+def _find_tiktok_search_node(root, width: int, height: int):
+    candidates = []
+    for node in root.iter("node"):
+        if not ui.is_visible(node) or node.attrib.get("clickable") != "true":
+            continue
+        text = node.attrib.get("text", "")
+        desc = node.attrib.get("content-desc", "")
+        resource_id = node.attrib.get("resource-id", "")
+        haystack = f"{text}\n{desc}\n{resource_id}".lower()
+        if not any(marker in haystack for marker in ("搜索", "search", "discover")):
+            continue
+        bounds = ui.bounds(node)
+        if not bounds:
+            continue
+        left, top, right, bottom = bounds
+        center_y = (top + bottom) // 2
+        if center_y > int(height * 0.28):
+            continue
+        candidates.append(node)
+    sorted_candidates = ui.sorted_visible_nodes(candidates)
+    return sorted_candidates[0] if sorted_candidates else None
+
+
+def _find_tiktok_search_input(root):
+    candidates = []
+    for node in root.iter("node"):
+        if not ui.is_visible(node):
+            continue
+        class_name = node.attrib.get("class", "")
+        text = node.attrib.get("text", "")
+        desc = node.attrib.get("content-desc", "")
+        resource_id = node.attrib.get("resource-id", "")
+        haystack = f"{text}\n{desc}\n{resource_id}".lower()
+        if "edittext" in class_name.lower():
+            candidates.append(node)
+            continue
+        if any(marker in haystack for marker in ("搜索", "search")):
+            candidates.append(node)
+    sorted_candidates = ui.sorted_visible_nodes(candidates)
+    return sorted_candidates[0] if sorted_candidates else None
+
+
+def _find_launcher_search_input(root):
+    candidates = []
+    for node in root.iter("node"):
+        if not ui.is_visible(node):
+            continue
+        class_name = node.attrib.get("class", "")
+        resource_id = node.attrib.get("resource-id", "")
+        text = node.attrib.get("text", "")
+        desc = node.attrib.get("content-desc", "")
+        haystack = f"{resource_id}\n{text}\n{desc}".lower()
+        if "edittext" in class_name.lower():
+            candidates.append(node)
+            continue
+        if any(marker in haystack for marker in ("search_box", "quicksearch", "搜索本机", "搜索")):
+            candidates.append(node)
+    sorted_candidates = ui.sorted_visible_nodes(candidates)
+    return sorted_candidates[0] if sorted_candidates else None
+
+
+def _launcher_search_input_text(node) -> str:
+    text = (node.attrib.get("text", "") or "").strip()
+    placeholder_markers = ("搜索本机", "搜索", "search")
+    if any(marker.lower() in text.lower() for marker in placeholder_markers):
+        return ""
+    return text
+
+
+def _find_launcher_search_clear_node(root, width: int, height: int):
+    candidates = []
+    for node in root.iter("node"):
+        if not ui.is_visible(node):
+            continue
+        text = node.attrib.get("text", "")
+        desc = node.attrib.get("content-desc", "")
+        resource_id = node.attrib.get("resource-id", "")
+        haystack = f"{text}\n{desc}\n{resource_id}".lower()
+        if any(marker in haystack for marker in ("清除", "clear", "delete", "close")):
+            bounds = ui.bounds(node)
+            if not bounds:
+                continue
+            left, top, right, bottom = bounds
+            center_x = (left + right) // 2
+            center_y = (top + bottom) // 2
+            if center_x < int(width * 0.65) or center_y > int(height * 0.18):
+                continue
+            candidates.append(node)
+    sorted_candidates = ui.sorted_visible_nodes(candidates)
+    return sorted_candidates[-1] if sorted_candidates else None
+
+
+def _is_tiktok_create_home_surface(root) -> bool:
+    text = ui.all_text(root)
+    markers = (
+        "CREATE",
+        "模板",
+        "新视频",
+        "草稿",
+        "照片编辑器",
+        "一键成片",
+        "添加音乐",
+    )
+    return sum(1 for marker in markers if marker.lower() in text.lower()) >= 3
+
+
+def _extract_tiktok_url(text: str) -> str:
+    urls = []
+    for raw in re.findall(r"https?://[^\s\"'<>]+", text or ""):
+        url = raw.rstrip(").,;，。]")
+        if url:
+            urls.append(url)
+    for url in urls:
+        lowered = url.lower()
+        if "tiktok.com/" in lowered or "tiktokv.com/" in lowered:
+            return url
+    return ""
+
+
+def _tiktok_post_id(permalink: str) -> str:
+    match = re.search(r"/video/(\d+)", permalink or "")
+    return match.group(1) if match else ""
+
+
+def _short(text: str, limit: int = 220) -> str:
+    compact = " ".join((text or "").split())
+    return compact if len(compact) <= limit else compact[: limit - 3] + "..."
+
+
 def _short_text(text: str, limit: int = 240) -> str:
     compact = " ".join(part.strip() for part in text.splitlines() if part.strip())
     return compact[:limit]