@11agents/cli 0.1.24 → 0.1.26

package/mobile-runtime/python/src/device_control/adapters/x.py

@@ -0,0 +1,29 @@
+from __future__ import annotations
+
+from device_control.models import PublishTask
+
+from .base import PlatformAdapter
+
+
+class XAdapter(PlatformAdapter):
+    platform = "x"
+    package_names = ("com.twitter.android",)
+    supported_post_types = ("text", "link", "image")
+
+    def plan(self, task: PublishTask) -> list[str]:
+        steps = [
+            "wake device",
+            "open X app",
+            "tap bottom-right compose plus; scroll timeline and retry if the plus is hidden",
+            f"choose content flow for post_type={task.post_type}",
+        ]
+        if task.body:
+            steps.append("fill post text")
+        if task.caption:
+            steps.append(f"fill caption: {task.caption}")
+        if task.link_url:
+            steps.append(f"append link: {task.link_url}")
+        if task.media_path:
+            steps.append(f"push/select image: {task.media_path}")
+        steps.extend(["capture pre-publish screenshot", "publish or stop at dry-run", "capture result screenshot"])
+        return steps

package/mobile-runtime/python/src/device_control/adapters/xiaohongshu.py

@@ -0,0 +1,26 @@
+from __future__ import annotations
+
+from device_control.models import PublishTask
+
+from .base import PlatformAdapter
+
+
+class XiaohongshuAdapter(PlatformAdapter):
+    platform = "xiaohongshu"
+    package_names = ("com.xingin.xhs",)
+    supported_post_types = ("image", "video")
+
+    def plan(self, task: PublishTask) -> list[str]:
+        steps = [
+            "wake device",
+            "open Xiaohongshu app",
+            f"choose content flow for post_type={task.post_type}",
+        ]
+        if task.media_path:
+            steps.append(f"push/select media: {task.media_path}")
+        if task.title:
+            steps.append(f"fill title: {task.title}")
+        if task.caption:
+            steps.append(f"fill caption: {task.caption}")
+        steps.extend(["capture pre-publish screenshot", "publish or stop at dry-run", "capture result screenshot"])
+        return steps

package/mobile-runtime/python/src/device_control/adb.py

@@ -0,0 +1,161 @@
+from __future__ import annotations
+
+import os
+import shutil
+import subprocess
+import time
+from dataclasses import dataclass
+from pathlib import Path
+
+
+@dataclass(frozen=True)
+class CommandResult:
+    code: int
+    stdout: str
+    stderr: str
+
+    @property
+    def ok(self) -> bool:
+        return self.code == 0
+
+
+class AdbClient:
+    def __init__(self, adb_bin: str | None = None, timeout_s: int = 30) -> None:
+        self.adb_bin = adb_bin or resolve_adb_bin()
+        self.timeout_s = timeout_s
+
+    def run(self, *args: str, timeout_s: int | None = None) -> CommandResult:
+        proc = subprocess.run(
+            [self.adb_bin, *args],
+            capture_output=True,
+            text=True,
+            check=False,
+            timeout=timeout_s or self.timeout_s,
+        )
+        return CommandResult(proc.returncode, proc.stdout.strip(), proc.stderr.strip())
+
+    def list_devices(self) -> list[str]:
+        result = self.run("devices")
+        devices: list[str] = []
+        for line in result.stdout.splitlines()[1:]:
+            parts = line.split()
+            if len(parts) >= 2 and parts[1] == "device":
+                devices.append(parts[0])
+        return devices
+
+    def connect(self, serial: str) -> CommandResult:
+        return self.run("connect", serial, timeout_s=10)
+
+    def shell(self, serial: str, *args: str) -> CommandResult:
+        return self.run("-s", serial, "shell", *args)
+
+    def wake(self, serial: str) -> CommandResult:
+        return self.shell(serial, "input", "keyevent", "KEYCODE_WAKEUP")
+
+    def keyevent(self, serial: str, keycode: str) -> CommandResult:
+        return self.shell(serial, "input", "keyevent", keycode)
+
+    def tap(self, serial: str, x: int, y: int) -> CommandResult:
+        return self.shell(serial, "input", "tap", str(x), str(y))
+
+    def swipe(self, serial: str, x1: int, y1: int, x2: int, y2: int, duration_ms: int = 400) -> CommandResult:
+        return self.shell(serial, "input", "swipe", str(x1), str(y1), str(x2), str(y2), str(duration_ms))
+
+    def input_text(self, serial: str, text: str) -> CommandResult:
+        escaped = text.replace("%", "%25").replace("#", r"\#").replace(" ", "%s")
+        return self.shell(serial, "input", "text", escaped)
+
+    def launch_package(self, serial: str, package: str) -> CommandResult:
+        return self.shell(
+            serial,
+            "monkey",
+            "-p",
+            package,
+            "-c",
+            "android.intent.category.LAUNCHER",
+            "1",
+        )
+
+    def push(self, serial: str, local_path: str | Path, remote_path: str) -> CommandResult:
+        return self.run("-s", serial, "push", str(local_path), remote_path, timeout_s=120)
+
+    def media_scan(self, serial: str, remote_path: str) -> CommandResult:
+        return self.shell(
+            serial,
+            "am",
+            "broadcast",
+            "-a",
+            "android.intent.action.MEDIA_SCANNER_SCAN_FILE",
+            "-d",
+            f"file://{remote_path}",
+        )
+
+    def screenshot(self, serial: str, out_path: str | Path) -> CommandResult:
+        out = Path(out_path)
+        out.parent.mkdir(parents=True, exist_ok=True)
+        remote = "/sdcard/_groupctl_screen.png"
+        shot = self.shell(serial, "screencap", "-p", remote)
+        if not shot.ok:
+            return shot
+        pull = self.run("-s", serial, "pull", remote, str(out), timeout_s=60)
+        self.shell(serial, "rm", remote)
+        return pull
+
+    def dump_ui(self, serial: str, out_path: str | Path) -> CommandResult:
+        out = Path(out_path)
+        out.parent.mkdir(parents=True, exist_ok=True)
+        remote = "/data/local/tmp/_groupctl_ui.xml"
+        last = CommandResult(1, "", "ui dump was not attempted")
+        for _attempt in range(3):
+            self.shell(serial, "rm", "-f", remote)
+            dump = self.shell(serial, "uiautomator", "dump", remote)
+            if not dump.ok:
+                last = dump
+                time.sleep(0.8)
+                continue
+            pull = self.run("-s", serial, "pull", remote, str(out), timeout_s=60)
+            self.shell(serial, "rm", "-f", remote)
+            if pull.ok:
+                return pull
+            last = pull
+            time.sleep(0.8)
+        return last
+
+    def getprop(self, serial: str, prop: str) -> str:
+        return self.shell(serial, "getprop", prop).stdout
+
+    def battery_level(self, serial: str) -> str:
+        result = self.shell(serial, "dumpsys", "battery")
+        for line in result.stdout.splitlines():
+            text = line.strip()
+            if text.startswith("level:"):
+                return text.split(":", 1)[1].strip()
+        return "unknown"
+
+    def current_focus(self, serial: str) -> str:
+        result = self.shell(serial, "dumpsys", "window")
+        for line in result.stdout.splitlines():
+            if "mCurrentFocus" in line or "mFocusedApp" in line:
+                return line.strip()
+        return "unknown"
+
+
+def resolve_adb_bin() -> str:
+    env_path = os.environ.get("ADB_BIN")
+    if env_path:
+        return env_path
+
+    path_adb = shutil.which("adb")
+    if path_adb:
+        return path_adb
+
+    candidates = [
+        Path.home() / "Library/Android/sdk/platform-tools/adb",
+        Path("/usr/local/bin/adb"),
+        Path("/opt/homebrew/bin/adb"),
+    ]
+    for candidate in candidates:
+        if candidate.exists():
+            return str(candidate)
+
+    return "adb"

package/mobile-runtime/python/src/device_control/appium_client.py

@@ -0,0 +1,131 @@
+from __future__ import annotations
+
+import base64
+import json
+import urllib.error
+import urllib.request
+from pathlib import Path
+from typing import Any
+
+
+class AppiumError(RuntimeError):
+    pass
+
+
+class AppiumClient:
+    def __init__(self, server_url: str = "http://127.0.0.1:4723") -> None:
+        self.server_url = server_url.rstrip("/")
+        self.session_id = ""
+
+    def start_session(self, capabilities: dict[str, Any]) -> str:
+        response = self._request("POST", "/session", {"capabilities": {"alwaysMatch": capabilities}})
+        value = response.get("value", {})
+        session_id = value.get("sessionId") or response.get("sessionId")
+        if not session_id:
+            raise AppiumError(f"Appium did not return sessionId: {response}")
+        self.session_id = str(session_id)
+        return self.session_id
+
+    def delete_session(self) -> None:
+        if self.session_id:
+            self._request("DELETE", f"/session/{self.session_id}")
+            self.session_id = ""
+
+    def find_element(self, using: str, value: str) -> str:
+        response = self._request("POST", f"/session/{self.session_id}/element", {"using": using, "value": value})
+        return _element_id(response["value"])
+
+    def click(self, element_id: str) -> None:
+        self._request("POST", f"/session/{self.session_id}/element/{element_id}/click", {})
+
+    def clear(self, element_id: str) -> None:
+        self._request("POST", f"/session/{self.session_id}/element/{element_id}/clear", {})
+
+    def send_keys(self, element_id: str, text: str) -> None:
+        payload = {"text": text, "value": list(text)}
+        self._request("POST", f"/session/{self.session_id}/element/{element_id}/value", payload)
+
+    def execute_script(self, script: str, args: list[Any] | None = None) -> Any:
+        response = self._request("POST", f"/session/{self.session_id}/execute/sync", {"script": script, "args": args or []})
+        return response.get("value")
+
+    def set_clipboard(self, text: str, content_type: str = "plaintext", label: str = "text") -> None:
+        raw = base64.b64encode(text.encode("utf-8")).decode("ascii")
+        payload = {"content": raw, "contentType": content_type, "label": label}
+        try:
+            self._request("POST", f"/session/{self.session_id}/appium/device/set_clipboard", payload)
+        except AppiumError:
+            self.execute_script("mobile: setClipboard", [payload])
+
+    def tap(self, x: int, y: int) -> None:
+        payload = {
+            "actions": [
+                {
+                    "type": "pointer",
+                    "id": "finger1",
+                    "parameters": {"pointerType": "touch"},
+                    "actions": [
+                        {"type": "pointerMove", "duration": 0, "x": x, "y": y},
+                        {"type": "pointerDown", "button": 0},
+                        {"type": "pause", "duration": 100},
+                        {"type": "pointerUp", "button": 0},
+                    ],
+                }
+            ]
+        }
+        self._request("POST", f"/session/{self.session_id}/actions", payload)
+
+    def window_rect(self) -> dict[str, int]:
+        value = self._request("GET", f"/session/{self.session_id}/window/rect")["value"]
+        return {key: int(value[key]) for key in ("x", "y", "width", "height")}
+
+    def source(self, out_path: str | Path | None = None) -> str:
+        source = str(self._request("GET", f"/session/{self.session_id}/source")["value"])
+        if out_path:
+            out = Path(out_path)
+            out.parent.mkdir(parents=True, exist_ok=True)
+            out.write_text(source, encoding="utf-8")
+        return source
+
+    def screenshot(self, out_path: str | Path) -> None:
+        raw = str(self._request("GET", f"/session/{self.session_id}/screenshot")["value"])
+        out = Path(out_path)
+        out.parent.mkdir(parents=True, exist_ok=True)
+        out.write_bytes(base64.b64decode(raw))
+
+    def get_clipboard(self, content_type: str = "plaintext") -> str:
+        response = self._request(
+            "POST",
+            f"/session/{self.session_id}/appium/device/get_clipboard",
+            {"contentType": content_type},
+        )
+        raw = str(response.get("value", "") or "")
+        if not raw:
+            return ""
+        try:
+            return base64.b64decode(raw).decode("utf-8", errors="replace").strip()
+        except Exception:
+            return raw.strip()
+
+    def _request(self, method: str, path: str, payload: dict[str, Any] | None = None) -> dict[str, Any]:
+        data = json.dumps(payload).encode() if payload is not None else None
+        req = urllib.request.Request(
+            self.server_url + path,
+            data=data,
+            headers={"Content-Type": "application/json"},
+            method=method,
+        )
+        try:
+            with urllib.request.urlopen(req, timeout=90) as resp:
+                raw = resp.read().decode()
+        except urllib.error.HTTPError as exc:
+            raw = exc.read().decode(errors="replace")
+            raise AppiumError(f"HTTP {exc.code}: {raw}") from exc
+        return json.loads(raw) if raw else {}
+
+
+def _element_id(value: dict[str, Any]) -> str:
+    element_id = value.get("element-6066-11e4-a52e-4f735466cecf") or value.get("ELEMENT")
+    if not element_id:
+        raise AppiumError(f"Element response did not include an element id: {value}")
+    return str(element_id)