openmd-cli 0.1.0__py3-none-any.whl

openmd/adapters/wechat_moments/adapter.py

@@ -0,0 +1,167 @@
+"""Mock/gated adapter for WeChat Moments person-feed package inputs."""
+
+from __future__ import annotations
+
+import hashlib
+from typing import Any
+from urllib.parse import parse_qs, unquote, urlparse
+
+from openmd.adapters.base import PlatformAdapter
+from openmd.adapters.high_privacy import high_privacy_blocker_result
+from openmd.core.detector import detect_platform
+from openmd.core.models import ContentItem, TranscriptResult
+
+
+class WechatMomentsAdapter(PlatformAdapter):
+    """Resolve explicit Moments person selectors without reading local sessions."""
+
+    def __init__(
+        self,
+        platform_id: str = "wechat_moments",
+        default_backend: str = "opencli.wx.sns-feed",
+    ) -> None:
+        self.id = platform_id
+        self.default_backend = default_backend
+
+    def can_handle(self, input_value: str) -> bool:
+        return detect_platform(input_value) == self.id
+
+    def resolve_items(
+        self,
+        input_value: str,
+        *,
+        limit: int | None = None,
+        all: bool = False,
+    ) -> list[ContentItem]:
+        selector = parse_wechat_moments_selector(input_value)
+        person = selector["person"]
+        since = selector.get("since")
+        until = selector.get("until")
+        return [
+            ContentItem(
+                platform=self.id,
+                input_type="collection",
+                url=input_value.strip(),
+                id=_feed_id(person, since=since, until=until),
+                title=f"WeChat Moments: {person}",
+                source_type="conversation",
+                raw_meta={
+                    "profile": "conversation",
+                    "permission_scope": "user_accessible",
+                    "target_kind": "wechat_moments_person",
+                    "person": person,
+                    "since": since,
+                    "until": until,
+                    "discovery_limit": limit,
+                    "allow_all": all,
+                },
+            )
+        ]
+
+    def extract_text(
+        self,
+        item: ContentItem,
+        *,
+        backend: str | None = None,
+        backend_chain: tuple[str, ...] | None = None,
+        allow_fallback: bool = True,
+    ) -> TranscriptResult:
+        selected = (backend_chain or (backend or self.default_backend,))[0]
+        if selected in {"mock", "wechat_moments.mock"}:
+            posts = _posts_from_meta(item.raw_meta)
+            return TranscriptResult(
+                text=render_wechat_moments_markdown(posts),
+                status="verified",
+                source_level="native_text",
+                backend=selected,
+                title=item.title or "WeChat Moments feed",
+                source_notes=[
+                    "local mock adapter smoke only; no WeChat database, session, OpenCLI, account, or decryption action was attempted",
+                ],
+                metadata={"profile": "conversation", "messages": posts},
+            )
+        return high_privacy_blocker_result(
+            platform=self.id,
+            backend=selected,
+            target_kind=str(item.raw_meta.get("target_kind") or "wechat_moments_person"),
+            state="refresh_needed",
+            error_code="refresh_needed",
+            error_summary=(
+                "Refresh or provide an approved scoped WeChat Moments export/cache before running real acquisition."
+            ),
+            next_action=(
+                "Use an explicitly approved export/cache or rerun collection with an enabled, scoped browser/backend "
+                "after refreshing local WeChat data."
+            ),
+            permission_scope=str(item.raw_meta.get("permission_scope") or "unknown"),
+            title=item.title or "WeChat Moments feed",
+            source_notes=[
+                "wechat moments adapter resolved the explicit person selector only; real acquisition is behind gated discovery/export providers",
+                f"allow_fallback={allow_fallback}",
+            ],
+        )
+
+
+def parse_wechat_moments_selector(value: str) -> dict[str, str | None]:
+    parsed = urlparse(value.strip())
+    if parsed.scheme in {"wx", "wechat"} and parsed.netloc.lower() in {"moments", "sns"}:
+        person = unquote(parsed.path.strip("/"))
+    elif parsed.scheme in {"wx-moments", "wechat-moments"}:
+        person = unquote((parsed.netloc or parsed.path.strip("/")).strip("/"))
+    else:
+        raise ValueError("WeChat Moments selector must use wx://moments/<person>.")
+
+    if not person or person in {"*", "all", "friends", "timeline"}:
+        raise ValueError("WeChat Moments selector must name one explicit person.")
+
+    query = parse_qs(parsed.query)
+    return {
+        "person": person,
+        "since": _first_query_value(query, "since"),
+        "until": _first_query_value(query, "until"),
+    }
+
+
+def render_wechat_moments_markdown(posts: list[dict[str, Any]]) -> str:
+    lines = ["# WeChat Moments feed", ""]
+    for post in posts:
+        timestamp = str(post.get("timestamp") or "unknown-time")
+        speaker = str(post.get("speaker") or post.get("author") or "unknown")
+        text = str(post.get("text") or "").strip()
+        if not text:
+            text = "_No text content._"
+        lines.append(f"- [{timestamp}] {speaker}: {text}")
+        media = post.get("attachments")
+        if isinstance(media, list) and media:
+            lines.append(f"  - Attachments: {len(media)} referenced item(s)")
+    return "\n".join(lines).strip() + "\n"
+
+
+def _posts_from_meta(raw_meta: dict[str, Any]) -> list[dict[str, Any]]:
+    value = raw_meta.get("messages") if isinstance(raw_meta, dict) else None
+    if isinstance(value, list) and value:
+        return [post for post in value if isinstance(post, dict)]
+    person = str(raw_meta.get("person") or "mock-person")
+    return [
+        {
+            "id": "moment_001",
+            "timestamp": "2026-06-23T12:00:00+08:00",
+            "speaker": person,
+            "text": "Mock Moments post scoped to one person.",
+            "attachments": [],
+            "links": [],
+            "source_map": [],
+        }
+    ]
+
+
+def _first_query_value(query: dict[str, list[str]], key: str) -> str | None:
+    values = query.get(key)
+    if not values:
+        return None
+    value = values[0].strip()
+    return value or None
+
+
+def _feed_id(person: str, *, since: str | None, until: str | None) -> str:
+    return hashlib.sha256(f"{person}:{since or ''}:{until or ''}".encode("utf-8")).hexdigest()[:12]

openmd/adapters/wechat_moments/wx_cli.py

@@ -0,0 +1,265 @@
+"""Gated OpenCLI wrapper for WeChat Moments person-feed discovery."""
+
+from __future__ import annotations
+
+import hashlib
+import json
+import shutil
+import subprocess
+from collections.abc import Callable, Iterable
+from typing import Any
+
+from openmd.core.opencli_output import load_opencli_json
+from openmd.adapters.high_privacy import HIGH_PRIVACY_STATUS_KEY, high_privacy_status_metadata
+from openmd.adapters.wechat_moments.adapter import (
+    parse_wechat_moments_selector,
+    render_wechat_moments_markdown,
+)
+from openmd.backends.base import DiscoveryRequest, DiscoveryResult
+from openmd.core.models import ContentItem
+from openmd.core.secrets import sanitize_error_summary
+from openmd.runtime.interpreters import run_interruptibly
+
+
+OPENCLI_WX_SNS_FEED_DISCOVERY_BACKEND = "opencli.wx.sns-feed"
+DEFAULT_WX_SNS_TIMEOUT_SECONDS = 180
+CommandRunner = Callable[[list[str], int], tuple[int, str, str]]
+
+
+class OpenCliWechatMomentsProvider:
+    """Parse sanitized Moments JSON from an explicitly enabled local CLI."""
+
+    name = OPENCLI_WX_SNS_FEED_DISCOVERY_BACKEND
+
+    def __init__(
+        self,
+        *,
+        runner: CommandRunner | None = None,
+        timeout: int = DEFAULT_WX_SNS_TIMEOUT_SECONDS,
+    ) -> None:
+        self._runner = runner or _run_command
+        self.timeout = timeout
+
+    def discover(self, request: DiscoveryRequest) -> DiscoveryResult:
+        try:
+            selector = parse_wechat_moments_selector(request.input_url)
+        except ValueError as exc:
+            return DiscoveryResult.failure(
+                provider=self.name,
+                error_code="target_scope_required",
+                error_summary=sanitize_error_summary(exc),
+                metadata={"platform": request.platform, "limit": request.limit},
+            )
+
+        command = build_opencli_wx_sns_feed_args(
+            str(selector["person"]),
+            since=selector.get("since"),
+            until=selector.get("until"),
+            limit=request.limit,
+        )
+        exit_code, stdout, stderr = self._runner(command, self.timeout)
+        if exit_code != 0:
+            return DiscoveryResult.failure(
+                provider=self.name,
+                error_code=_exit_error_code(exit_code),
+                error_summary=sanitize_error_summary(stderr or stdout) or "opencli wx sns-feed failed.",
+                source_notes=["OpenCLI stdout/stderr was not persisted by Openmd."],
+                metadata={"platform": request.platform, "limit": request.limit},
+            )
+
+        try:
+            posts = parse_opencli_wx_sns_feed_output(stdout)
+        except ValueError as exc:
+            return DiscoveryResult.failure(
+                provider=self.name,
+                error_code="invalid_discovery_output",
+                error_summary=sanitize_error_summary(exc),
+                source_notes=["OpenCLI stdout was invalid JSON and was not persisted."],
+                metadata={"platform": request.platform, "limit": request.limit},
+            )
+        if request.limit is not None and not request.allow_all:
+            posts = posts[: max(0, request.limit)]
+        if not posts:
+            return DiscoveryResult.failure(
+                provider=self.name,
+                error_code="no_delta",
+                error_summary="opencli wx sns-feed returned no scoped Moments posts.",
+                source_notes=["OpenCLI JSON was parsed in memory and was not persisted."],
+                metadata={
+                    "platform": request.platform,
+                    "limit": request.limit,
+                    HIGH_PRIVACY_STATUS_KEY: high_privacy_status_metadata(
+                        platform=request.platform,
+                        target_kind="wechat_moments_person",
+                        state="no_delta",
+                        next_action=(
+                            "If posts are expected, refresh the scoped local WeChat cache/export and rerun the same selector."
+                        ),
+                        permission_scope="user_accessible",
+                    ),
+                },
+            )
+
+        item = _feed_item(
+            person=str(selector["person"]),
+            input_url=request.input_url,
+            posts=posts,
+            since=selector.get("since"),
+            until=selector.get("until"),
+            limit=request.limit,
+        )
+        return DiscoveryResult.success(
+            provider=self.name,
+            items=[item],
+            source_notes=[
+                "OpenCLI wx sns-feed JSON was parsed in memory.",
+                "No broad contacts scan, database read, key extraction, decryption, login, or account mutation was attempted by Openmd.",
+            ],
+            metadata={
+                "platform": request.platform,
+                "limit": request.limit,
+                "normalized_url": request.input_url,
+            },
+        )
+
+
+def build_opencli_wx_sns_feed_args(
+    person: str,
+    *,
+    since: str | None = None,
+    until: str | None = None,
+    limit: int | None = None,
+) -> list[str]:
+    command = ["opencli", "wx", "sns-feed", "--user", person, "--json"]
+    if since:
+        command.extend(["--since", since])
+    if until:
+        command.extend(["--until", until])
+    if limit is not None:
+        command.extend(["--limit", str(max(0, limit))])
+    return command
+
+
+def parse_opencli_wx_sns_feed_output(stdout: str) -> list[dict[str, Any]]:
+    try:
+        payload = load_opencli_json(stdout)
+    except json.JSONDecodeError as exc:
+        raise ValueError("opencli wx sns-feed did not return valid JSON") from exc
+
+    posts: list[dict[str, Any]] = []
+    for index, row in enumerate(_candidate_rows(payload), start=1):
+        if not isinstance(row, dict):
+            continue
+        post = _parse_post_row(row, index=index)
+        if post is not None:
+            posts.append(post)
+    return posts
+
+
+def _candidate_rows(payload: object) -> Iterable[object]:
+    if isinstance(payload, list):
+        return payload
+    if not isinstance(payload, dict):
+        return ()
+    for key in ("moments", "posts", "items", "list", "data", "records", "results"):
+        value = payload.get(key)
+        if isinstance(value, list):
+            return value
+        if isinstance(value, dict):
+            nested = list(_candidate_rows(value))
+            if nested:
+                return nested
+    return ()
+
+
+def _parse_post_row(row: dict[str, Any], *, index: int) -> dict[str, Any] | None:
+    text = _first_string(row, "text", "content", "description", "message")
+    speaker = _first_string(row, "speaker", "author", "user", "nickname", "name")
+    timestamp = _first_string(row, "timestamp", "time", "datetime", "date", "created_at")
+    attachments = _list_or_empty(row.get("attachments") or row.get("media") or row.get("images"))
+    if not text and not attachments:
+        return None
+    return {
+        "id": _first_string(row, "id", "moment_id", "sns_id") or f"moment_{index:04d}",
+        "timestamp": timestamp or "unknown-time",
+        "speaker": speaker or "unknown",
+        "text": text or "",
+        "attachments": attachments,
+        "links": _list_or_empty(row.get("links")),
+        "source_map": [],
+    }
+
+
+def _feed_item(
+    *,
+    person: str,
+    input_url: str,
+    posts: list[dict[str, Any]],
+    since: str | None,
+    until: str | None,
+    limit: int | None,
+) -> ContentItem:
+    return ContentItem(
+        platform="wechat_moments",
+        input_type="collection",
+        url=input_url,
+        id=f"wxm-{_stable_hash(person, since, until)}",
+        title=f"WeChat Moments: {person}",
+        source_type="conversation",
+        raw_meta={
+            "profile": "conversation",
+            "permission_scope": "user_accessible",
+            "person": person,
+            "since": since,
+            "until": until,
+            "messages": posts,
+            "markdown_preview": render_wechat_moments_markdown(posts),
+            "discovery_limit": limit,
+            "discovery_provider": OPENCLI_WX_SNS_FEED_DISCOVERY_BACKEND,
+        },
+    )
+
+
+def _run_command(command: list[str], timeout: int) -> tuple[int, str, str]:
+    resolved = shutil.which(command[0]) or command[0]
+    try:
+        completed = run_interruptibly(
+            [resolved, *command[1:]],
+            capture_output=True,
+            text=True,
+            timeout=timeout,
+            check=False,
+            encoding="utf-8",
+            errors="replace",
+        )
+    except FileNotFoundError:
+        return 127, "", "opencli executable is not available on PATH."
+    except subprocess.TimeoutExpired:
+        return 124, "", f"opencli wx sns-feed timed out after {timeout}s."
+    return completed.returncode, completed.stdout or "", completed.stderr or ""
+
+
+def _first_string(row: dict[str, Any], *keys: str) -> str | None:
+    for key in keys:
+        value = row.get(key)
+        if isinstance(value, str) and value.strip():
+            return value.strip()
+        if isinstance(value, int):
+            return str(value)
+    return None
+
+
+def _list_or_empty(value: object) -> list[Any]:
+    return value if isinstance(value, list) else []
+
+
+def _stable_hash(*parts: str | None) -> str:
+    return hashlib.sha256(":".join(part or "" for part in parts).encode("utf-8")).hexdigest()[:12]
+
+
+def _exit_error_code(exit_code: int) -> str:
+    if exit_code == 127:
+        return "discovery_tool_missing"
+    if exit_code == 124:
+        return "discovery_timeout"
+    return f"discovery_exit_{exit_code}"

openmd/adapters/weixin/__init__.py

@@ -0,0 +1,11 @@
+"""Weixin/WeChat Official Account V1 platform adapter."""
+
+from __future__ import annotations
+
+from openmd.adapters.base import PlatformAdapter
+
+from .adapter import WeixinOfficialAccountAdapter
+
+
+def create_adapter(platform_id: str, default_backend: str) -> PlatformAdapter:
+    return WeixinOfficialAccountAdapter(platform_id, default_backend)

openmd/adapters/weixin/adapter.py

@@ -0,0 +1,148 @@
+"""V1 adapter for WeChat Official Account article inputs.
+
+The adapter is intentionally conservative: it resolves single article URLs and
+author/account collection selectors into ``ContentItem`` records, but real
+network/browser acquisition remains behind the backend/discovery gates.
+"""
+
+from __future__ import annotations
+
+import hashlib
+from urllib.parse import parse_qs, urlparse
+
+from openmd.adapters.base import PlatformAdapter
+from openmd.backends.weixin import normalize_weixin_url
+from openmd.core.detector import detect_platform, extract_first_url
+from openmd.core.models import ContentItem, TranscriptResult
+
+
+WEIXIN_SELECTOR_SCHEMES: frozenset[str] = frozenset(
+    {"weixin", "wechat", "wechat-official", "wx-official"}
+)
+
+
+class WeixinOfficialAccountAdapter(PlatformAdapter):
+    """Resolve Weixin article and account selectors without side effects."""
+
+    def __init__(self, platform_id: str = "weixin", default_backend: str = "weixin.article.local") -> None:
+        self.id = platform_id
+        self.default_backend = default_backend
+
+    def can_handle(self, input_value: str) -> bool:
+        return _is_weixin_article_url(input_value) or _is_weixin_collection_selector(input_value)
+
+    def resolve_items(
+        self,
+        input_value: str,
+        *,
+        limit: int | None = None,
+        all: bool = False,
+    ) -> list[ContentItem]:
+        normalized = normalize_weixin_url(extract_first_url(input_value))
+        if _is_weixin_article_url(normalized):
+            return [_article_item(normalized, platform=self.id)]
+
+        return [
+            ContentItem(
+                platform=self.id,
+                input_type="collection",
+                url=input_value.strip(),
+                id=_stable_id(input_value),
+                source_type="article",
+                raw_meta={
+                    "profile": "article",
+                    "permission_scope": "user_accessible",
+                    "collection_selector": input_value.strip(),
+                    "discovery_limit": limit,
+                    "allow_all": all,
+                },
+            )
+        ]
+
+    def extract_text(
+        self,
+        item: ContentItem,
+        *,
+        backend: str | None = None,
+        backend_chain: tuple[str, ...] | None = None,
+        allow_fallback: bool = True,
+    ) -> TranscriptResult:
+        selected = (backend_chain or (backend or self.default_backend,))[0]
+        if selected in {"mock", "weixin.mock"}:
+            return TranscriptResult(
+                text="# Mock Weixin article\n\nMock official account article content.\n",
+                status="verified",
+                source_level="native_text",
+                backend=selected,
+                title=item.title or "Mock Weixin article",
+                source_notes=["local mock adapter smoke only; no network/browser/account action was attempted"],
+            )
+        return TranscriptResult(
+            text="",
+            status="failed",
+            source_level="partial_extraction",
+            backend=selected,
+            source_notes=[
+                "weixin adapter resolved the item only; real extraction is handled by gated backend providers",
+                f"allow_fallback={allow_fallback}",
+            ],
+            error_code="backend_requires_runtime_gate",
+            error_summary="Enable the appropriate Openmd backend gate before running real Weixin extraction.",
+        )
+
+
+def _article_item(url: str, *, platform: str) -> ContentItem:
+    parsed = urlparse(url)
+    query = parse_qs(parsed.query)
+    title = query.get("title", [None])[0]
+    return ContentItem(
+        platform=platform,
+        input_type="single",
+        url=url,
+        id=_weixin_article_id(url),
+        title=title,
+        source_type="article",
+        raw_meta={
+            "profile": "article",
+            "permission_scope": "user_accessible",
+            "content_id": _weixin_article_id(url),
+        },
+    )
+
+
+def _is_weixin_article_url(input_value: str) -> bool:
+    normalized = normalize_weixin_url(extract_first_url(input_value))
+    parsed = urlparse(normalized)
+    return (
+        parsed.scheme in {"http", "https"}
+        and parsed.netloc.lower() == "mp.weixin.qq.com"
+        and (parsed.path == "/s" or parsed.path.startswith("/s/"))
+    )
+
+
+def _is_weixin_collection_selector(input_value: str) -> bool:
+    value = input_value.strip()
+    parsed = urlparse(value)
+    if parsed.scheme in WEIXIN_SELECTOR_SCHEMES:
+        return bool(parsed.netloc or parsed.path)
+    return detect_platform(value) == "weixin"
+
+
+def _weixin_article_id(url: str) -> str:
+    normalized = normalize_weixin_url(url)
+    parsed = urlparse(normalized)
+    if parsed.path.startswith("/s/"):
+        slug = parsed.path.removeprefix("/s/").strip("/")
+        if slug:
+            return slug
+    query = parse_qs(parsed.query)
+    biz = query.get("__biz", [""])[0]
+    mid = query.get("mid", [""])[0]
+    idx = query.get("idx", [""])[0]
+    if biz and mid and idx:
+        return f"{biz}-{mid}-{idx}"
+    return _stable_id(normalized)
+
+
+def _stable_id(value: str) -> str:
+    return hashlib.sha256(value.strip().encode("utf-8")).hexdigest()[:12]