@11agents/cli 0.1.23 → 0.1.25

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

@@ -0,0 +1,439 @@
+from __future__ import annotations
+
+from dataclasses import dataclass, field
+from datetime import datetime, timezone
+from typing import Any
+from uuid import uuid4
+
+
+@dataclass(frozen=True)
+class Device:
+    device_id: str
+    adb_serial: str
+    ip_address: str
+    brand: str = ""
+    model: str = ""
+    android_version: str = ""
+    status: str = "active"
+    notes: str = ""
+
+
+@dataclass(frozen=True)
+class PlatformAccount:
+    account_id: str
+    platform: str
+    username: str
+    bound_device_id: str
+    login_status: str = "unknown"
+    status: str = "active"
+    notes: str = ""
+
+
+@dataclass
+class PublishTask:
+    task_id: str
+    action: str
+    platform: str
+    post_type: str
+    account_id: str
+    device_id: str
+    target: str | None = None
+    title: str | None = None
+    body: str | None = None
+    link_url: str | None = None
+    media_path: str | None = None
+    caption: str | None = None
+    hashtags: list[str] = field(default_factory=list)
+    dry_run: bool = True
+    require_human_confirm: bool = True
+    status: str = "pending"
+
+    @classmethod
+    def from_dict(cls, data: dict[str, Any]) -> "PublishTask":
+        return cls(
+            task_id=str(data["task_id"]),
+            action=str(data.get("action", "publish_content")),
+            platform=str(data["platform"]).lower(),
+            post_type=str(data["post_type"]).lower(),
+            account_id=str(data["account_id"]),
+            device_id=str(data["device_id"]),
+            target=data.get("target"),
+            title=data.get("title"),
+            body=data.get("body"),
+            link_url=data.get("link_url"),
+            media_path=data.get("media_path"),
+            caption=data.get("caption"),
+            hashtags=list(data.get("hashtags") or []),
+            dry_run=bool(data.get("dry_run", True)),
+            require_human_confirm=bool(data.get("require_human_confirm", True)),
+            status=str(data.get("status", "pending")),
+        )
+
+
+def utc_now_iso() -> str:
+    return datetime.now(timezone.utc).replace(microsecond=0).isoformat()
+
+
+def new_id(prefix: str) -> str:
+    return f"{prefix}_{datetime.now(timezone.utc).strftime('%Y%m%d%H%M%S')}_{uuid4().hex[:8]}"
+
+
+@dataclass
+class PublishRecord:
+    record_id: str
+    platform: str
+    account_id: str
+    device_id: str
+    post_type: str
+    published_at: str
+    task_id: str = ""
+    local_media_path: str = ""
+    remote_media_path: str = ""
+    platform_post_id: str = ""
+    platform_permalink: str = ""
+    caption: str = ""
+    result_screenshot_path: str = ""
+    status: str = "published"
+    created_at: str = field(default_factory=utc_now_iso)
+
+    @classmethod
+    def from_dict(cls, data: dict[str, Any]) -> "PublishRecord":
+        return cls(
+            record_id=str(data["record_id"]),
+            task_id=str(data.get("task_id", "")),
+            platform=str(data["platform"]).lower(),
+            account_id=str(data["account_id"]),
+            device_id=str(data["device_id"]),
+            post_type=str(data.get("post_type", "video")).lower(),
+            local_media_path=str(data.get("local_media_path", "")),
+            remote_media_path=str(data.get("remote_media_path", "")),
+            platform_post_id=str(data.get("platform_post_id", "")),
+            platform_permalink=str(data.get("platform_permalink", "")),
+            caption=str(data.get("caption", "")),
+            published_at=str(data["published_at"]),
+            result_screenshot_path=str(data.get("result_screenshot_path", "")),
+            status=str(data.get("status", "published")),
+            created_at=str(data.get("created_at", utc_now_iso())),
+        )
+
+    def to_dict(self) -> dict[str, Any]:
+        return {
+            "record_id": self.record_id,
+            "task_id": self.task_id,
+            "platform": self.platform,
+            "account_id": self.account_id,
+            "device_id": self.device_id,
+            "post_type": self.post_type,
+            "local_media_path": self.local_media_path,
+            "remote_media_path": self.remote_media_path,
+            "platform_post_id": self.platform_post_id,
+            "platform_permalink": self.platform_permalink,
+            "caption": self.caption,
+            "published_at": self.published_at,
+            "result_screenshot_path": self.result_screenshot_path,
+            "status": self.status,
+            "created_at": self.created_at,
+        }
+
+
+@dataclass
+class VideoMetricsSnapshot:
+    snapshot_id: str
+    record_id: str
+    platform: str
+    account_id: str
+    fetched_at: str
+    source: str
+    platform_post_id: str = ""
+    platform_permalink: str = ""
+    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] = field(default_factory=dict)
+
+    @classmethod
+    def from_dict(cls, data: dict[str, Any]) -> "VideoMetricsSnapshot":
+        return cls(
+            snapshot_id=str(data["snapshot_id"]),
+            record_id=str(data["record_id"]),
+            platform=str(data["platform"]).lower(),
+            account_id=str(data["account_id"]),
+            platform_post_id=str(data.get("platform_post_id", "")),
+            platform_permalink=str(data.get("platform_permalink", "")),
+            fetched_at=str(data["fetched_at"]),
+            source=str(data.get("source", "unknown")),
+            views=_optional_int(data.get("views")),
+            likes=_optional_int(data.get("likes")),
+            comments=_optional_int(data.get("comments")),
+            shares=_optional_int(data.get("shares")),
+            saves=_optional_int(data.get("saves")),
+            score=_optional_int(data.get("score")),
+            raw=dict(data.get("raw") or {}),
+        )
+
+    def to_dict(self) -> dict[str, Any]:
+        return {
+            "snapshot_id": self.snapshot_id,
+            "record_id": self.record_id,
+            "platform": self.platform,
+            "account_id": self.account_id,
+            "platform_post_id": self.platform_post_id,
+            "platform_permalink": self.platform_permalink,
+            "fetched_at": self.fetched_at,
+            "source": self.source,
+            "views": self.views,
+            "likes": self.likes,
+            "comments": self.comments,
+            "shares": self.shares,
+            "saves": self.saves,
+            "score": self.score,
+            "raw": self.raw,
+        }
+
+
+@dataclass
+class TikTokAccountMetricsPeriod:
+    period_key: str
+    period_days: int
+    date_range: str = ""
+    video_views: int | None = None
+    profile_views: int | None = None
+    total_likes: int | None = None
+    total_comments: int | None = None
+    shares: int | None = None
+    screenshot_path: str = ""
+    ui_dump_path: str = ""
+    extraction_method: str = "manual_required"
+    raw: dict[str, Any] = field(default_factory=dict)
+
+    @classmethod
+    def from_dict(cls, data: dict[str, Any]) -> "TikTokAccountMetricsPeriod":
+        return cls(
+            period_key=str(data["period_key"]),
+            period_days=int(data["period_days"]),
+            date_range=str(data.get("date_range", "")),
+            video_views=_optional_int(data.get("video_views")),
+            profile_views=_optional_int(data.get("profile_views")),
+            total_likes=_optional_int(data.get("total_likes")),
+            total_comments=_optional_int(data.get("total_comments")),
+            shares=_optional_int(data.get("shares")),
+            screenshot_path=str(data.get("screenshot_path", "")),
+            ui_dump_path=str(data.get("ui_dump_path", "")),
+            extraction_method=str(data.get("extraction_method", "manual_required")),
+            raw=dict(data.get("raw") or {}),
+        )
+
+    def to_dict(self) -> dict[str, Any]:
+        return {
+            "period_key": self.period_key,
+            "period_days": self.period_days,
+            "date_range": self.date_range,
+            "video_views": self.video_views,
+            "profile_views": self.profile_views,
+            "total_likes": self.total_likes,
+            "total_comments": self.total_comments,
+            "shares": self.shares,
+            "screenshot_path": self.screenshot_path,
+            "ui_dump_path": self.ui_dump_path,
+            "extraction_method": self.extraction_method,
+            "raw": self.raw,
+        }
+
+    def has_all_metrics(self) -> bool:
+        return all(
+            value is not None
+            for value in (
+                self.video_views,
+                self.profile_views,
+                self.total_likes,
+                self.total_comments,
+                self.shares,
+            )
+        )
+
+
+@dataclass
+class TikTokAccountMetricsSnapshot:
+    snapshot_id: str
+    platform: str
+    account_id: str
+    device_id: str
+    fetched_at: str
+    source: str
+    status: str = "needs_human"
+    periods: dict[str, TikTokAccountMetricsPeriod] = field(default_factory=dict)
+    artifact_dir: str = ""
+    started_at: str = ""
+    ended_at: str = ""
+    duration_seconds: int | None = None
+    raw: dict[str, Any] = field(default_factory=dict)
+
+    @classmethod
+    def from_dict(cls, data: dict[str, Any]) -> "TikTokAccountMetricsSnapshot":
+        periods = {
+            str(key): TikTokAccountMetricsPeriod.from_dict(dict(value))
+            for key, value in dict(data.get("periods") or {}).items()
+        }
+        return cls(
+            snapshot_id=str(data["snapshot_id"]),
+            platform=str(data.get("platform", "tiktok")).lower(),
+            account_id=str(data["account_id"]),
+            device_id=str(data["device_id"]),
+            fetched_at=str(data["fetched_at"]),
+            source=str(data.get("source", "unknown")),
+            status=str(data.get("status", "needs_human")),
+            periods=periods,
+            artifact_dir=str(data.get("artifact_dir", "")),
+            started_at=str(data.get("started_at", "")),
+            ended_at=str(data.get("ended_at", "")),
+            duration_seconds=_optional_int(data.get("duration_seconds")),
+            raw=dict(data.get("raw") or {}),
+        )
+
+    def to_dict(self) -> dict[str, Any]:
+        return {
+            "snapshot_id": self.snapshot_id,
+            "platform": self.platform,
+            "account_id": self.account_id,
+            "device_id": self.device_id,
+            "fetched_at": self.fetched_at,
+            "source": self.source,
+            "status": self.status,
+            "periods": {key: period.to_dict() for key, period in self.periods.items()},
+            "artifact_dir": self.artifact_dir,
+            "started_at": self.started_at,
+            "ended_at": self.ended_at,
+            "duration_seconds": self.duration_seconds,
+            "raw": self.raw,
+        }
+
+
+@dataclass
+class TikTokVideoMetricsSnapshot:
+    snapshot_id: str
+    platform: str
+    account_id: str
+    device_id: str
+    fetched_at: str
+    source: str
+    status: str = "needs_human"
+    published_at: str = ""
+    published_at_raw: str = ""
+    video_order: int | None = None
+    video_views: int | None = None
+    likes: int | None = None
+    comments: int | None = None
+    shares: int | None = None
+    saves: int | None = None
+    total_play_time_seconds: int | None = None
+    total_play_time_raw: str = ""
+    average_watch_time_seconds: float | None = None
+    average_watch_time_raw: str = ""
+    completion_rate: float | None = None
+    completion_rate_raw: str = ""
+    new_followers: int | None = None
+    screenshot_path: str = ""
+    ui_dump_path: str = ""
+    artifact_dir: str = ""
+    started_at: str = ""
+    ended_at: str = ""
+    duration_seconds: int | None = None
+    raw: dict[str, Any] = field(default_factory=dict)
+
+    @classmethod
+    def from_dict(cls, data: dict[str, Any]) -> "TikTokVideoMetricsSnapshot":
+        raw = dict(data.get("raw") or {})
+        top_counters = dict(raw.get("top_counters") or {})
+        return cls(
+            snapshot_id=str(data["snapshot_id"]),
+            platform=str(data.get("platform", "tiktok")).lower(),
+            account_id=str(data["account_id"]),
+            device_id=str(data["device_id"]),
+            fetched_at=str(data["fetched_at"]),
+            source=str(data.get("source", "unknown")),
+            status=str(data.get("status", "needs_human")),
+            published_at=str(data.get("published_at", "")),
+            published_at_raw=str(data.get("published_at_raw", "")),
+            video_order=_optional_int(data.get("video_order")),
+            video_views=_optional_int(data.get("video_views", top_counters.get("views"))),
+            likes=_optional_int(data.get("likes", top_counters.get("likes"))),
+            comments=_optional_int(data.get("comments", top_counters.get("comments"))),
+            shares=_optional_int(data.get("shares", top_counters.get("shares"))),
+            saves=_optional_int(data.get("saves", top_counters.get("saves"))),
+            total_play_time_seconds=_optional_int(data.get("total_play_time_seconds")),
+            total_play_time_raw=str(data.get("total_play_time_raw", "")),
+            average_watch_time_seconds=_optional_float(data.get("average_watch_time_seconds")),
+            average_watch_time_raw=str(data.get("average_watch_time_raw", "")),
+            completion_rate=_optional_float(data.get("completion_rate")),
+            completion_rate_raw=str(data.get("completion_rate_raw", "")),
+            new_followers=_optional_int(data.get("new_followers")),
+            screenshot_path=str(data.get("screenshot_path", "")),
+            ui_dump_path=str(data.get("ui_dump_path", "")),
+            artifact_dir=str(data.get("artifact_dir", "")),
+            started_at=str(data.get("started_at", "")),
+            ended_at=str(data.get("ended_at", "")),
+            duration_seconds=_optional_int(data.get("duration_seconds")),
+            raw=raw,
+        )
+
+    def to_dict(self) -> dict[str, Any]:
+        return {
+            "snapshot_id": self.snapshot_id,
+            "platform": self.platform,
+            "account_id": self.account_id,
+            "device_id": self.device_id,
+            "fetched_at": self.fetched_at,
+            "source": self.source,
+            "status": self.status,
+            "published_at": self.published_at,
+            "published_at_raw": self.published_at_raw,
+            "video_order": self.video_order,
+            "video_views": self.video_views,
+            "likes": self.likes,
+            "comments": self.comments,
+            "shares": self.shares,
+            "saves": self.saves,
+            "total_play_time_seconds": self.total_play_time_seconds,
+            "total_play_time_raw": self.total_play_time_raw,
+            "average_watch_time_seconds": self.average_watch_time_seconds,
+            "average_watch_time_raw": self.average_watch_time_raw,
+            "completion_rate": self.completion_rate,
+            "completion_rate_raw": self.completion_rate_raw,
+            "new_followers": self.new_followers,
+            "screenshot_path": self.screenshot_path,
+            "ui_dump_path": self.ui_dump_path,
+            "artifact_dir": self.artifact_dir,
+            "started_at": self.started_at,
+            "ended_at": self.ended_at,
+            "duration_seconds": self.duration_seconds,
+            "raw": self.raw,
+        }
+
+    def has_key_metrics(self) -> bool:
+        return bool(self.published_at) and all(
+            value is not None
+            for value in (
+                self.video_views,
+                self.likes,
+                self.comments,
+                self.shares,
+                self.saves,
+                self.average_watch_time_seconds,
+                self.completion_rate,
+            )
+        )
+
+
+def _optional_int(value: Any) -> int | None:
+    if value in (None, ""):
+        return None
+    return int(value)
+
+
+def _optional_float(value: Any) -> float | None:
+    if value in (None, ""):
+        return None
+    return float(value)

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

@@ -0,0 +1,173 @@
+from __future__ import annotations
+
+import json
+from dataclasses import dataclass, field
+from pathlib import Path
+from typing import Any
+
+
+DEFAULT_PUBLISH_POLICY_PATH = "configs/publish_policy.json"
+
+
+@dataclass(frozen=True)
+class XiaohongshuPublishPolicyDecision:
+    approval_bridge_applied: bool
+    approval_state: str
+    source_lifecycle_state: str
+    commercial_disclosure_decision: str
+    auto_confirm_no_disclosure_needed: bool
+    blockers: list[str] = field(default_factory=list)
+
+
+def load_publish_policy(path: str | Path = DEFAULT_PUBLISH_POLICY_PATH) -> dict[str, Any]:
+    policy_path = Path(path).expanduser()
+    if not policy_path.exists():
+        return {}
+    with policy_path.open(encoding="utf-8") as handle:
+        loaded = json.load(handle)
+    if not isinstance(loaded, dict):
+        raise ValueError(f"publish policy must be a JSON object: {policy_path}")
+    return loaded
+
+
+def explicit_live_publish_auto_confirm(policy: dict[str, Any] | None = None) -> bool:
+    global_policy = _mapping((policy or {}).get("global"))
+    return bool(global_policy.get("explicit_live_publish_auto_confirm", False))
+
+
+def should_auto_confirm_instagram_reels_public(policy: dict[str, Any] | None = None) -> bool:
+    if not explicit_live_publish_auto_confirm(policy):
+        return False
+    instagram_policy = _mapping((policy or {}).get("instagram"))
+    return bool(instagram_policy.get("auto_confirm_reels_public", True))
+
+
+def should_auto_confirm_xiaohongshu_no_disclosure(policy: dict[str, Any] | None = None) -> bool:
+    if not explicit_live_publish_auto_confirm(policy):
+        return False
+    xhs_policy = _mapping((policy or {}).get("xiaohongshu"))
+    disclosure_policy = _mapping(xhs_policy.get("commercial_disclosure"))
+    return bool(
+        disclosure_policy.get(
+            "auto_confirm_no_disclosure_needed",
+            xhs_policy.get("auto_confirm_no_disclosure_needed", False),
+        )
+    )
+
+
+def should_trust_xiaohongshu_explicit_publish_request(policy: dict[str, Any] | None = None) -> bool:
+    if not explicit_live_publish_auto_confirm(policy):
+        return False
+    xhs_policy = _mapping((policy or {}).get("xiaohongshu"))
+    disclosure_policy = _mapping(xhs_policy.get("commercial_disclosure"))
+    return bool(disclosure_policy.get("trust_explicit_publish_request", True))
+
+
+def xiaohongshu_package_disclosure_is_strict(policy: dict[str, Any] | None = None) -> bool:
+    xhs_policy = _mapping((policy or {}).get("xiaohongshu"))
+    disclosure_policy = _mapping(xhs_policy.get("commercial_disclosure"))
+    return bool(disclosure_policy.get("strict_package_disclosure_decision", False))
+
+
+def decide_xiaohongshu_publish_package_policy(
+    package: dict[str, Any],
+    policy: dict[str, Any] | None = None,
+) -> XiaohongshuPublishPolicyDecision:
+    xhs_policy = dict((policy or {}).get("xiaohongshu") or {})
+    approval_policy = dict(xhs_policy.get("approval_bridge") or {})
+    disclosure_policy = dict(xhs_policy.get("commercial_disclosure") or {})
+    approval = dict(package.get("approval") or {})
+    disclosure = dict(package.get("disclosure") or {})
+
+    approval_state = _normalize(
+        approval.get("content_approval_state")
+        or approval.get("approval_state")
+        or approval.get("state")
+        or approval.get("lifecycle_state")
+    )
+    source_lifecycle_state = _normalize(
+        approval.get("source_lifecycle_state")
+        or approval.get("lifecycle_state")
+        or approval.get("source_approval_state")
+    )
+    explicit_publish_states = _normalized_set(
+        approval_policy.get("explicit_publish_states"),
+        default={
+            "approved_for_publish",
+            "approved_to_publish",
+            "approved_to_publish_by_request",
+            "publish_requested_by_member_comment",
+            "publish_requested_for_series_by_member_comment",
+            "publish_requested_for_single_post_by_member_comment",
+        },
+    )
+    approval_bridge_applied = bool(approval_policy.get("enabled", True)) and approval_state in explicit_publish_states
+
+    disclosure_decision = _normalize(
+        approval.get("commercial_disclosure_decision")
+        or approval.get("content_disclosure_decision")
+        or disclosure.get("commercial_disclosure_decision")
+        or disclosure.get("decision")
+    )
+    no_disclosure_decisions = _normalized_set(
+        disclosure_policy.get("no_disclosure_decisions"),
+        default={"no_disclosure_needed", "not_required", "not_needed", "none"},
+    )
+    requires_disclosure_decisions = _normalized_set(
+        disclosure_policy.get("requires_disclosure_decisions"),
+        default={"disclosure_required", "commercial_disclosure_required", "content_declaration_required", "required"},
+    )
+    default_decision = _normalize(disclosure_policy.get("default_decision") or "")
+    auto_confirm_enabled = bool(disclosure_policy.get("auto_confirm_no_disclosure_needed", False))
+    unresolved_follows_default = bool(disclosure_policy.get("unresolved_decisions_follow_default", False))
+    trust_explicit_publish = should_trust_xiaohongshu_explicit_publish_request(policy)
+
+    blockers: list[str] = []
+    if disclosure_decision in requires_disclosure_decisions:
+        if auto_confirm_enabled and trust_explicit_publish:
+            auto_confirm = True
+        else:
+            blockers.append(f"xiaohongshu disclosure decision requires declaration: {disclosure_decision}")
+            auto_confirm = False
+    elif disclosure_decision in no_disclosure_decisions:
+        auto_confirm = auto_confirm_enabled
+    elif not disclosure_decision or disclosure_decision in {"unresolved", "unknown", "pending"}:
+        auto_confirm = auto_confirm_enabled and (
+            (unresolved_follows_default and default_decision in no_disclosure_decisions)
+            or trust_explicit_publish
+        )
+        if not auto_confirm:
+            blockers.append("xiaohongshu disclosure decision is unresolved")
+    else:
+        if auto_confirm_enabled and trust_explicit_publish:
+            auto_confirm = True
+        else:
+            auto_confirm = False
+            blockers.append(f"unknown xiaohongshu disclosure decision: {disclosure_decision}")
+
+    return XiaohongshuPublishPolicyDecision(
+        approval_bridge_applied=approval_bridge_applied,
+        approval_state=approval_state,
+        source_lifecycle_state=source_lifecycle_state,
+        commercial_disclosure_decision=disclosure_decision or default_decision,
+        auto_confirm_no_disclosure_needed=auto_confirm,
+        blockers=blockers,
+    )
+
+
+def _normalize(value: Any) -> str:
+    return str(value or "").strip().lower().replace("-", "_")
+
+
+def _normalized_set(value: Any, *, default: set[str]) -> set[str]:
+    if value is None:
+        return set(default)
+    if not isinstance(value, list):
+        return set(default)
+    return {_normalize(item) for item in value if _normalize(item)}
+
+
+def _mapping(value: Any) -> dict[str, Any]:
+    if isinstance(value, dict):
+        return value
+    return {}

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

@@ -0,0 +1,24 @@
+from .facebook_adb import FacebookAdbPublishResult, FacebookAdbPublisher
+from .instagram_adb import InstagramAdbPublishResult, InstagramAdbPublisher
+from .reddit_adb import RedditAdbPublishResult, RedditAdbPublisher
+from .tiktok_adb import TikTokAdbPublishResult, TikTokAdbPublisher
+from .tiktok_appium import TikTokAppiumPublishResult, TikTokAppiumPublisher
+from .x_adb import XAdbPublishResult, XAdbPublisher
+from .xiaohongshu_adb import XiaohongshuAdbPublishResult, XiaohongshuAdbPublisher
+
+__all__ = [
+    "FacebookAdbPublishResult",
+    "FacebookAdbPublisher",
+    "InstagramAdbPublishResult",
+    "InstagramAdbPublisher",
+    "RedditAdbPublishResult",
+    "RedditAdbPublisher",
+    "TikTokAdbPublishResult",
+    "TikTokAdbPublisher",
+    "TikTokAppiumPublishResult",
+    "TikTokAppiumPublisher",
+    "XAdbPublishResult",
+    "XAdbPublisher",
+    "XiaohongshuAdbPublishResult",
+    "XiaohongshuAdbPublisher",
+]