@11agents/cli 0.1.24 → 0.1.26

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

@@ -0,0 +1,60 @@
+from __future__ import annotations
+
+import sys
+
+from .cli import main
+
+
+def publish_reddit() -> None:
+    sys.argv = ["groupctl", "publish-reddit", *sys.argv[1:]]
+    main()
+
+
+def publish_facebook() -> None:
+    sys.argv = ["groupctl", "publish-facebook", *sys.argv[1:]]
+    main()
+
+
+def publish_instagram() -> None:
+    sys.argv = ["groupctl", "publish-instagram", *sys.argv[1:]]
+    main()
+
+
+def publish_tiktok() -> None:
+    sys.argv = ["groupctl", "publish-tiktok", *sys.argv[1:]]
+    main()
+
+
+def publish_x() -> None:
+    sys.argv = ["groupctl", "publish-x", *sys.argv[1:]]
+    main()
+
+
+def publish_xiaohongshu() -> None:
+    sys.argv = ["groupctl", "publish-xiaohongshu", *sys.argv[1:]]
+    main()
+
+
+def copy_xiaohongshu_link() -> None:
+    sys.argv = ["groupctl", "copy-xiaohongshu-link", *sys.argv[1:]]
+    main()
+
+
+def ensure_appium() -> None:
+    sys.argv = ["groupctl", "ensure-appium", *sys.argv[1:]]
+    main()
+
+
+def stop_appium() -> None:
+    sys.argv = ["groupctl", "stop-appium", *sys.argv[1:]]
+    main()
+
+
+def collect_tiktok_account_metrics() -> None:
+    sys.argv = ["groupctl", "collect-tiktok-account-metrics-adb", *sys.argv[1:]]
+    main()
+
+
+def collect_tiktok_video_metrics() -> None:
+    sys.argv = ["groupctl", "collect-tiktok-video-metrics-adb", *sys.argv[1:]]
+    main()

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

@@ -0,0 +1,162 @@
+from __future__ import annotations
+
+import json
+import os
+import tempfile
+import uuid
+from contextlib import contextmanager
+from datetime import datetime, timezone
+from typing import Any
+
+
+class DeviceLockError(RuntimeError):
+    """Raised when a device is already controlled by another process."""
+
+
+class PublishSlotError(DeviceLockError):
+    """Raised when the global publish concurrency cap is already reached."""
+
+
+def _lock_path(device_id: str) -> str:
+    safe = "".join(ch if ch.isalnum() or ch in ("-", "_") else "_" for ch in device_id)
+    return os.path.join(tempfile.gettempdir(), f"groupctl-device-{safe}.lock")
+
+
+def _publish_slot_path(slot: int) -> str:
+    return os.path.join(tempfile.gettempdir(), f"groupctl-publish-slot-{slot}.lock")
+
+
+def _pid_running(pid: int) -> bool:
+    if pid <= 0:
+        return False
+    try:
+        os.kill(pid, 0)
+    except ProcessLookupError:
+        return False
+    except PermissionError:
+        return True
+    except OSError:
+        return False
+    return True
+
+
+def _read_lock(path: str) -> dict[str, Any]:
+    try:
+        with open(path, "r", encoding="utf-8") as handle:
+            data = json.load(handle)
+            if isinstance(data, dict):
+                return data
+    except Exception:
+        pass
+    return {}
+
+
+def _write_lock(path: str, payload: dict[str, Any]) -> None:
+    fd = os.open(path, os.O_CREAT | os.O_EXCL | os.O_WRONLY, 0o600)
+    with os.fdopen(fd, "w", encoding="utf-8") as handle:
+        json.dump(payload, handle, ensure_ascii=False)
+
+
+def _remove_stale_lock(path: str) -> tuple[bool, dict[str, Any]]:
+    data = _read_lock(path)
+    pid = data.get("pid")
+    if isinstance(pid, int) and _pid_running(pid):
+        return False, data
+    try:
+        os.remove(path)
+    except FileNotFoundError:
+        pass
+    except OSError:
+        return False, data
+    return True, data
+
+
+def _conflict_message(device_id: str, data: dict[str, Any]) -> str:
+    pid = data.get("pid")
+    started_at = data.get("started_at")
+    if isinstance(pid, int):
+        detail = f"pid={pid}"
+        if isinstance(started_at, str) and started_at:
+            detail += f", started_at={started_at}"
+        return f"device {device_id} is already locked ({detail})"
+    return f"device {device_id} is already locked"
+
+
+@contextmanager
+def device_lock(device_id: str):
+    """Acquire an inter-process lock for one physical device."""
+    path = _lock_path(device_id)
+    token = uuid.uuid4().hex
+    payload = {
+        "pid": os.getpid(),
+        "device_id": device_id,
+        "started_at": datetime.now(timezone.utc).isoformat(),
+        "token": token,
+    }
+
+    for attempt in range(2):
+        try:
+            _write_lock(path, payload)
+            break
+        except FileExistsError:
+            removed, data = _remove_stale_lock(path)
+            if removed and attempt == 0:
+                continue
+            raise DeviceLockError(_conflict_message(device_id, data))
+    else:
+        raise DeviceLockError(f"could not acquire device lock for {device_id}")
+
+    try:
+        yield
+    finally:
+        try:
+            current = _read_lock(path)
+            if current.get("token") == token:
+                os.remove(path)
+        except FileNotFoundError:
+            pass
+        except OSError:
+            pass
+
+
+@contextmanager
+def publish_slot(max_slots: int):
+    """Acquire one global inter-process publishing slot."""
+    token = uuid.uuid4().hex
+    payload_base = {
+        "pid": os.getpid(),
+        "started_at": datetime.now(timezone.utc).isoformat(),
+        "token": token,
+    }
+    acquired_path = ""
+
+    for slot in range(max_slots):
+        path = _publish_slot_path(slot)
+        payload = {**payload_base, "slot": slot, "max_slots": max_slots}
+        for attempt in range(2):
+            try:
+                _write_lock(path, payload)
+                acquired_path = path
+                break
+            except FileExistsError:
+                removed, _data = _remove_stale_lock(path)
+                if removed and attempt == 0:
+                    continue
+                break
+        if acquired_path:
+            break
+
+    if not acquired_path:
+        raise PublishSlotError(f"global publish concurrency limit reached (max_slots={max_slots})")
+
+    try:
+        yield
+    finally:
+        try:
+            current = _read_lock(acquired_path)
+            if current.get("token") == token:
+                os.remove(acquired_path)
+        except FileNotFoundError:
+            pass
+        except OSError:
+            pass

package/mobile-runtime/python/src/device_control/metrics/__init__.py

@@ -0,0 +1,33 @@
+from .collectors import (
+    InstagramGraphApiCollector,
+    MetricsCollectionError,
+    MetricsCollector,
+    RedditPublicJsonCollector,
+    TikTokDisplayApiCollector,
+    build_manual_snapshot,
+    collect_with_default_collector,
+    parse_platform_post_id,
+)
+from .tiktok_account_adb import (
+    TikTokAccountMetricsAdbCollector,
+    parse_manual_values_json,
+)
+from .tiktok_video_adb import (
+    TikTokVideoMetricsAdbCollector,
+    parse_manual_video_values_json,
+)
+
+__all__ = [
+    "InstagramGraphApiCollector",
+    "MetricsCollectionError",
+    "MetricsCollector",
+    "RedditPublicJsonCollector",
+    "TikTokAccountMetricsAdbCollector",
+    "TikTokDisplayApiCollector",
+    "TikTokVideoMetricsAdbCollector",
+    "build_manual_snapshot",
+    "collect_with_default_collector",
+    "parse_manual_values_json",
+    "parse_manual_video_values_json",
+    "parse_platform_post_id",
+]

package/mobile-runtime/python/src/device_control/metrics/collectors.py

@@ -0,0 +1,320 @@
+from __future__ import annotations
+
+import json
+import os
+import re
+import ssl
+import urllib.error
+import urllib.parse
+import urllib.request
+from abc import ABC, abstractmethod
+from typing import Any
+
+from device_control.models import PublishRecord, VideoMetricsSnapshot, new_id, utc_now_iso
+
+
+class MetricsCollectionError(RuntimeError):
+    pass
+
+
+class MetricsCollector(ABC):
+    platform: str
+
+    @abstractmethod
+    def collect(self, record: PublishRecord) -> VideoMetricsSnapshot:
+        """Collect one metrics snapshot for a published post."""
+
+
+def build_manual_snapshot(
+    record: PublishRecord,
+    *,
+    views: int | None = None,
+    likes: int | None = None,
+    comments: int | None = None,
+    shares: int | None = None,
+    saves: int | None = None,
+    score: int | None = None,
+    raw: dict[str, Any] | None = None,
+) -> VideoMetricsSnapshot:
+    return VideoMetricsSnapshot(
+        snapshot_id=new_id("met"),
+        record_id=record.record_id,
+        platform=record.platform,
+        account_id=record.account_id,
+        platform_post_id=record.platform_post_id,
+        platform_permalink=record.platform_permalink,
+        fetched_at=utc_now_iso(),
+        source="manual",
+        views=views,
+        likes=likes,
+        comments=comments,
+        shares=shares,
+        saves=saves,
+        score=score,
+        raw=raw or {},
+    )
+
+
+class TikTokDisplayApiCollector(MetricsCollector):
+    platform = "tiktok"
+
+    def __init__(self, access_token: str, api_base: str = "https://open.tiktokapis.com") -> None:
+        self.access_token = access_token
+        self.api_base = api_base.rstrip("/")
+
+    def collect(self, record: PublishRecord) -> VideoMetricsSnapshot:
+        post_id = _require_post_id(record)
+        fields = ",".join(
+            [
+                "id",
+                "create_time",
+                "cover_image_url",
+                "share_url",
+                "video_description",
+                "duration",
+                "height",
+                "width",
+                "title",
+                "like_count",
+                "comment_count",
+                "share_count",
+                "view_count",
+            ]
+        )
+        url = f"{self.api_base}/v2/video/query/?fields={urllib.parse.quote(fields, safe=',')}"
+        payload = {"filters": {"video_ids": [post_id]}}
+        data = _request_json(
+            "POST",
+            url,
+            payload,
+            {
+                "Authorization": f"Bearer {self.access_token}",
+                "Content-Type": "application/json",
+            },
+        )
+        videos = (data.get("data") or {}).get("videos") or []
+        if not videos:
+            raise MetricsCollectionError(f"TikTok returned no video for post_id={post_id}")
+        item = videos[0]
+        return VideoMetricsSnapshot(
+            snapshot_id=new_id("met"),
+            record_id=record.record_id,
+            platform=record.platform,
+            account_id=record.account_id,
+            platform_post_id=post_id,
+            platform_permalink=record.platform_permalink or str(item.get("share_url", "")),
+            fetched_at=utc_now_iso(),
+            source="tiktok_display_api",
+            views=_optional_int(item.get("view_count")),
+            likes=_optional_int(item.get("like_count")),
+            comments=_optional_int(item.get("comment_count")),
+            shares=_optional_int(item.get("share_count")),
+            raw=item,
+        )
+
+
+class InstagramGraphApiCollector(MetricsCollector):
+    platform = "instagram"
+
+    def __init__(
+        self,
+        access_token: str,
+        graph_base: str | None = None,
+        metrics: tuple[str, ...] = ("views", "reach", "saved", "shares", "total_interactions"),
+    ) -> None:
+        self.access_token = access_token
+        version = os.environ.get("META_GRAPH_API_VERSION", "v23.0")
+        self.graph_base = (graph_base or f"https://graph.facebook.com/{version}").rstrip("/")
+        self.metrics = metrics
+
+    def collect(self, record: PublishRecord) -> VideoMetricsSnapshot:
+        post_id = _require_post_id(record)
+        media_url = f"{self.graph_base}/{urllib.parse.quote(post_id)}"
+        media = _request_json(
+            "GET",
+            _url_with_params(
+                media_url,
+                {
+                    "fields": "id,permalink,like_count,comments_count,caption,timestamp,media_product_type",
+                    "access_token": self.access_token,
+                },
+            ),
+            None,
+            {},
+        )
+        insights: dict[str, Any] = {}
+        try:
+            insights_url = f"{self.graph_base}/{urllib.parse.quote(post_id)}/insights"
+            insights = _request_json(
+                "GET",
+                _url_with_params(
+                    insights_url,
+                    {
+                        "metric": ",".join(self.metrics),
+                        "access_token": self.access_token,
+                    },
+                ),
+                None,
+                {},
+            )
+        except MetricsCollectionError as exc:
+            insights = {"error": str(exc)}
+
+        insight_values = _flatten_instagram_insights(insights)
+        return VideoMetricsSnapshot(
+            snapshot_id=new_id("met"),
+            record_id=record.record_id,
+            platform=record.platform,
+            account_id=record.account_id,
+            platform_post_id=post_id,
+            platform_permalink=record.platform_permalink or str(media.get("permalink", "")),
+            fetched_at=utc_now_iso(),
+            source="instagram_graph_api",
+            views=_optional_int(insight_values.get("views")),
+            likes=_optional_int(media.get("like_count")),
+            comments=_optional_int(media.get("comments_count")),
+            shares=_optional_int(insight_values.get("shares")),
+            saves=_optional_int(insight_values.get("saved")),
+            raw={"media": media, "insights": insights},
+        )
+
+
+class RedditPublicJsonCollector(MetricsCollector):
+    platform = "reddit"
+
+    def collect(self, record: PublishRecord) -> VideoMetricsSnapshot:
+        url = _reddit_json_url(record)
+        data = _request_json(
+            "GET",
+            url,
+            None,
+            {"User-Agent": os.environ.get("REDDIT_USER_AGENT", "elevenagents-mobile-runtime/0.1")},
+        )
+        post = _extract_reddit_post(data)
+        permalink = record.platform_permalink or f"https://www.reddit.com{post.get('permalink', '')}"
+        return VideoMetricsSnapshot(
+            snapshot_id=new_id("met"),
+            record_id=record.record_id,
+            platform=record.platform,
+            account_id=record.account_id,
+            platform_post_id=record.platform_post_id or str(post.get("id", "")),
+            platform_permalink=permalink,
+            fetched_at=utc_now_iso(),
+            source="reddit_public_json",
+            likes=_optional_int(post.get("ups")),
+            comments=_optional_int(post.get("num_comments")),
+            score=_optional_int(post.get("score")),
+            raw=post,
+        )
+
+
+def collect_with_default_collector(record: PublishRecord) -> VideoMetricsSnapshot:
+    if record.platform == "tiktok":
+        _require_post_id(record)
+        token = _token_for(record, "TIKTOK_ACCESS_TOKEN")
+        if not token:
+            raise MetricsCollectionError("Missing TikTok access token. Set TIKTOK_ACCESS_TOKEN or TIKTOK_ACCESS_TOKEN_<ACCOUNT_ID>.")
+        return TikTokDisplayApiCollector(token).collect(record)
+    if record.platform == "instagram":
+        _require_post_id(record)
+        token = _token_for(record, "INSTAGRAM_ACCESS_TOKEN")
+        if not token:
+            raise MetricsCollectionError(
+                "Missing Instagram access token. Set INSTAGRAM_ACCESS_TOKEN or INSTAGRAM_ACCESS_TOKEN_<ACCOUNT_ID>."
+            )
+        return InstagramGraphApiCollector(token).collect(record)
+    if record.platform == "reddit":
+        return RedditPublicJsonCollector().collect(record)
+    raise MetricsCollectionError(f"No metrics collector for platform={record.platform}")
+
+
+def _request_json(method: str, url: str, payload: dict[str, Any] | None, headers: dict[str, str]) -> dict[str, Any]:
+    body = json.dumps(payload).encode("utf-8") if payload is not None else None
+    req = urllib.request.Request(url, data=body, headers=headers, method=method)
+    try:
+        with urllib.request.urlopen(req, timeout=30, context=_ssl_context()) as resp:
+            return json.loads(resp.read().decode("utf-8"))
+    except urllib.error.HTTPError as exc:
+        detail = exc.read().decode("utf-8", errors="replace")
+        raise MetricsCollectionError(f"HTTP {exc.code} from {url}: {detail}") from exc
+    except Exception as exc:
+        raise MetricsCollectionError(f"Request failed for {url}: {exc}") from exc
+
+
+def _ssl_context() -> ssl.SSLContext | None:
+    try:
+        import certifi
+    except Exception:
+        return None
+    return ssl.create_default_context(cafile=certifi.where())
+
+
+def _url_with_params(url: str, params: dict[str, str]) -> str:
+    return f"{url}?{urllib.parse.urlencode(params)}"
+
+
+def _token_for(record: PublishRecord, base_key: str) -> str:
+    account_key = re.sub(r"[^A-Za-z0-9_]", "_", record.account_id).upper()
+    return os.environ.get(f"{base_key}_{account_key}") or os.environ.get(base_key, "")
+
+
+def _require_post_id(record: PublishRecord) -> str:
+    post_id = record.platform_post_id or parse_platform_post_id(record.platform, record.platform_permalink)
+    if not post_id:
+        raise MetricsCollectionError(f"record_id={record.record_id} missing platform_post_id")
+    return post_id
+
+
+def parse_platform_post_id(platform: str, permalink: str) -> str:
+    if not permalink:
+        return ""
+    if platform == "tiktok":
+        match = re.search(r"/video/(\d+)", permalink)
+        return match.group(1) if match else ""
+    if platform == "reddit":
+        match = re.search(r"/comments/([A-Za-z0-9_]+)", permalink)
+        return match.group(1) if match else ""
+    return ""
+
+
+def _optional_int(value: Any) -> int | None:
+    if value in (None, ""):
+        return None
+    return int(value)
+
+
+def _flatten_instagram_insights(data: dict[str, Any]) -> dict[str, int]:
+    values: dict[str, int] = {}
+    for item in data.get("data") or []:
+        metric_name = item.get("name")
+        metric_values = item.get("values") or []
+        if metric_name and metric_values:
+            values[str(metric_name)] = int(metric_values[-1].get("value", 0))
+    return values
+
+
+def _reddit_json_url(record: PublishRecord) -> str:
+    if record.platform_permalink:
+        url = record.platform_permalink
+        if not url.startswith("http"):
+            url = f"https://www.reddit.com{url}"
+        if not url.endswith(".json"):
+            url = url.rstrip("/") + ".json"
+        return url
+    if record.platform_post_id:
+        post_id = record.platform_post_id
+        if post_id.startswith("t3_"):
+            post_id = post_id[3:]
+        return f"https://www.reddit.com/by_id/t3_{post_id}.json"
+    raise MetricsCollectionError(f"record_id={record.record_id} missing platform_permalink or platform_post_id")
+
+
+def _extract_reddit_post(data: Any) -> dict[str, Any]:
+    if isinstance(data, list) and data:
+        listing = data[0]
+    else:
+        listing = data
+    children = ((listing.get("data") or {}).get("children") or []) if isinstance(listing, dict) else []
+    if not children:
+        raise MetricsCollectionError("Reddit response did not contain a post")
+    return dict(children[0].get("data") or {})