openmd-cli 0.1.0__py3-none-any.whl

openmd/adapters/screenshot/ocr.py

@@ -0,0 +1,84 @@
+"""Screenshot OCR backend abstractions."""
+
+from __future__ import annotations
+
+from abc import ABC, abstractmethod
+import re
+
+from openmd.core.models import TranscriptResult
+from openmd.core.secrets import sanitize_error_summary
+
+
+class OCRBackend(ABC):
+    name: str
+
+    @abstractmethod
+    def recognize(self, source_ref: str, *, title: str) -> TranscriptResult:
+        raise NotImplementedError
+
+
+class MockOCRBackend(OCRBackend):
+    name = "screenshot.mock"
+
+    def recognize(self, source_ref: str, *, title: str) -> TranscriptResult:
+        text = f"# {title}\n\nMock OCR text from a long screenshot for Openmd package smoke.\n"
+        return TranscriptResult(
+            text=text,
+            status="verified",
+            source_level="ocr",
+            backend=self.name,
+            source_notes=[
+                "screenshot OCR mock backend only",
+                "raw screenshot file was referenced, not copied into the package",
+            ],
+            title=title or "screenshot",
+            metadata={
+                "profile": classify_ocr_profile(text),
+                "ocr_backend": self.name,
+                "source_ref": source_ref,
+            },
+        )
+
+
+class MissingOCRBackend(OCRBackend):
+    def __init__(self, name: str) -> None:
+        self.name = name
+
+    def recognize(self, source_ref: str, *, title: str) -> TranscriptResult:
+        return TranscriptResult(
+            text="",
+            status="failed",
+            source_level="partial_extraction",
+            backend=self.name,
+            source_notes=[
+                "OCR backend is not installed or not enabled",
+                "no external OCR command was attempted",
+            ],
+            error_code="ocr_backend_missing",
+            error_summary=sanitize_error_summary(
+                f"OCR backend {self.name!r} is not installed or enabled."
+            ),
+            title=title or "screenshot",
+            metadata={"profile": "document", "ocr_backend": self.name, "source_ref": source_ref},
+        )
+
+
+def classify_ocr_profile(text: str) -> str:
+    """Return the likely V1 package profile for OCR text.
+
+    The first mock/gated lane keeps package output document-first. This helper
+    records the intended routing seam for future layout-aware OCR without
+    changing package writer contracts in this lane.
+    """
+
+    if _looks_like_chat_log(text):
+        return "conversation"
+    return "document"
+
+
+def _looks_like_chat_log(text: str) -> bool:
+    lines = [line.strip() for line in text.splitlines() if line.strip()]
+    if len(lines) < 2:
+        return False
+    chat_hint = re.compile(r"(^|\s)(\d{1,2}:\d{2}|上午|下午|AM|PM)(\s|$).{0,40}[:：]")
+    return sum(1 for line in lines if chat_hint.search(line)) >= 2

openmd/adapters/wechat_group/__init__.py

@@ -0,0 +1,11 @@
+"""Wechat group conversation adapter factory."""
+
+from __future__ import annotations
+
+from openmd.adapters.base import PlatformAdapter
+
+from .adapter import WechatGroupAdapter
+
+
+def create_adapter(platform_id: str, default_backend: str) -> PlatformAdapter:
+    return WechatGroupAdapter(platform_id, default_backend)

openmd/adapters/wechat_group/adapter.py

@@ -0,0 +1,160 @@
+"""Mock/gated adapter for WeChat group conversation 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 WechatGroupAdapter(PlatformAdapter):
+    """Resolve explicit WeChat group selectors without reading local sessions."""
+
+    def __init__(self, platform_id: str = "wechat_group", default_backend: str = "opencli.wx.history") -> 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_group_selector(input_value)
+        group_name = selector["group_name"]
+        since = selector.get("since")
+        until = selector.get("until")
+        return [
+            ContentItem(
+                platform=self.id,
+                input_type="collection",
+                url=input_value.strip(),
+                id=_conversation_id(group_name, since=since, until=until),
+                title=f"WeChat group: {group_name}",
+                source_type="conversation",
+                raw_meta={
+                    "profile": "conversation",
+                    "permission_scope": "user_accessible",
+                    "target_kind": "wechat_group",
+                    "group_name": group_name,
+                    "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_group.mock"}:
+            messages = _messages_from_meta(item.raw_meta)
+            return TranscriptResult(
+                text=render_wechat_group_markdown(messages),
+                status="verified",
+                source_level="native_text",
+                backend=selected,
+                title=item.title or "WeChat group conversation",
+                source_notes=[
+                    "local mock adapter smoke only; no WeChat database, session, OpenCLI, account, or decryption action was attempted",
+                ],
+                metadata={"profile": "conversation", "messages": messages},
+            )
+        return high_privacy_blocker_result(
+            platform=self.id,
+            backend=selected,
+            target_kind=str(item.raw_meta.get("target_kind") or "wechat_group"),
+            state="refresh_needed",
+            error_code="refresh_needed",
+            error_summary=(
+                "Refresh or provide an approved scoped WeChat group 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 group conversation",
+            source_notes=[
+                "wechat group adapter resolved the explicit selector only; real acquisition is behind gated discovery/export providers",
+                f"allow_fallback={allow_fallback}",
+            ],
+        )
+
+
+def parse_wechat_group_selector(value: str) -> dict[str, str | None]:
+    parsed = urlparse(value.strip())
+    if parsed.scheme in {"wx", "wechat"} and parsed.netloc.lower() == "group":
+        group_name = unquote(parsed.path.strip("/"))
+    elif parsed.scheme in {"wx-group", "wechat-group"}:
+        group_name = unquote((parsed.netloc or parsed.path.strip("/")).strip("/"))
+    else:
+        raise ValueError("WeChat group selector must use wx://group/<group-name>.")
+
+    if not group_name or group_name in {"*", "all"}:
+        raise ValueError("WeChat group selector must name one explicit group.")
+
+    query = parse_qs(parsed.query)
+    return {
+        "group_name": group_name,
+        "since": _first_query_value(query, "since"),
+        "until": _first_query_value(query, "until"),
+    }
+
+
+def render_wechat_group_markdown(messages: list[dict[str, Any]]) -> str:
+    lines = ["# WeChat group conversation", ""]
+    for message in messages:
+        timestamp = str(message.get("timestamp") or "unknown-time")
+        speaker = str(message.get("speaker") or "unknown")
+        text = str(message.get("text") or "").strip()
+        if not text:
+            text = "_No text content._"
+        lines.append(f"- [{timestamp}] {speaker}: {text}")
+    return "\n".join(lines).strip() + "\n"
+
+
+def _messages_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 [message for message in value if isinstance(message, dict)]
+    group_name = str(raw_meta.get("group_name") or "mock-group")
+    return [
+        {
+            "id": "msg_001",
+            "timestamp": "2026-06-23T10:00:00+08:00",
+            "speaker": "Mock sender",
+            "text": f"Mock message scoped to WeChat group {group_name}.",
+            "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 _conversation_id(group_name: str, *, since: str | None, until: str | None) -> str:
+    return hashlib.sha256(f"{group_name}:{since or ''}:{until or ''}".encode("utf-8")).hexdigest()[:12]

openmd/adapters/wechat_group/wx_cli.py

@@ -0,0 +1,268 @@
+"""Gated OpenCLI wrapper for WeChat group history discovery.
+
+The provider only runs when registered through ``--enable-browser-backends``.
+Tests use fake runners. Openmd does not read WeChat databases, extract DB keys,
+decrypt local stores, open accounts, or persist raw command output here.
+"""
+
+from __future__ import annotations
+
+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_group.adapter import parse_wechat_group_selector, render_wechat_group_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_HISTORY_DISCOVERY_BACKEND = "opencli.wx.history"
+DEFAULT_WX_HISTORY_TIMEOUT_SECONDS = 180
+CommandRunner = Callable[[list[str], int], tuple[int, str, str]]
+
+
+class OpenCliWechatGroupHistoryProvider:
+    """Parse sanitized WeChat group history JSON from an explicitly enabled CLI."""
+
+    name = OPENCLI_WX_HISTORY_DISCOVERY_BACKEND
+
+    def __init__(
+        self,
+        *,
+        runner: CommandRunner | None = None,
+        timeout: int = DEFAULT_WX_HISTORY_TIMEOUT_SECONDS,
+    ) -> None:
+        self._runner = runner or _run_command
+        self.timeout = timeout
+
+    def discover(self, request: DiscoveryRequest) -> DiscoveryResult:
+        try:
+            selector = parse_wechat_group_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_history_args(
+            str(selector["group_name"]),
+            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 history failed.",
+                source_notes=["OpenCLI stdout/stderr was not persisted by Openmd."],
+                metadata={"platform": request.platform, "limit": request.limit},
+            )
+
+        try:
+            messages = parse_opencli_wx_history_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:
+            messages = messages[: max(0, request.limit)]
+        if not messages:
+            return DiscoveryResult.failure(
+                provider=self.name,
+                error_code="no_delta",
+                error_summary="opencli wx history returned no scoped group messages.",
+                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_group",
+                        state="no_delta",
+                        next_action=(
+                            "If messages are expected, refresh the scoped local WeChat cache/export and rerun the same selector."
+                        ),
+                        permission_scope="user_accessible",
+                    ),
+                },
+            )
+
+        item = _conversation_item(
+            group_name=str(selector["group_name"]),
+            input_url=request.input_url,
+            messages=messages,
+            since=selector.get("since"),
+            until=selector.get("until"),
+            limit=request.limit,
+        )
+        return DiscoveryResult.success(
+            provider=self.name,
+            items=[item],
+            source_notes=[
+                "OpenCLI wx history JSON was parsed in memory.",
+                "No WeChat database, key extraction, decryption, login, or broad session scan was attempted by Openmd.",
+            ],
+            metadata={
+                "platform": request.platform,
+                "limit": request.limit,
+                "normalized_url": request.input_url,
+            },
+        )
+
+
+def build_opencli_wx_history_args(
+    group_name: str,
+    *,
+    since: str | None = None,
+    until: str | None = None,
+    limit: int | None = None,
+) -> list[str]:
+    command = ["opencli", "wx", "history", group_name, "--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_history_output(stdout: str) -> list[dict[str, Any]]:
+    try:
+        payload = load_opencli_json(stdout)
+    except json.JSONDecodeError as exc:
+        raise ValueError("opencli wx history did not return valid JSON") from exc
+
+    messages: list[dict[str, Any]] = []
+    for index, row in enumerate(_candidate_rows(payload), start=1):
+        if not isinstance(row, dict):
+            continue
+        message = _parse_message_row(row, index=index)
+        if message is not None:
+            messages.append(message)
+    return messages
+
+
+def _candidate_rows(payload: object) -> Iterable[object]:
+    if isinstance(payload, list):
+        return payload
+    if not isinstance(payload, dict):
+        return ()
+    for key in ("messages", "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_message_row(row: dict[str, Any], *, index: int) -> dict[str, Any] | None:
+    text = _first_string(row, "text", "content", "message", "msg")
+    speaker = _first_string(row, "speaker", "sender", "from", "author", "nickname", "name")
+    timestamp = _first_string(row, "timestamp", "time", "datetime", "date", "created_at")
+    if not text and not row.get("attachments"):
+        return None
+    return {
+        "id": _first_string(row, "id", "msg_id", "message_id") or f"msg_{index:04d}",
+        "timestamp": timestamp or "unknown-time",
+        "speaker": speaker or "unknown",
+        "text": text or "",
+        "attachments": _list_or_empty(row.get("attachments")),
+        "links": _list_or_empty(row.get("links")),
+        "source_map": [],
+    }
+
+
+def _conversation_item(
+    *,
+    group_name: str,
+    input_url: str,
+    messages: list[dict[str, Any]],
+    since: str | None,
+    until: str | None,
+    limit: int | None,
+) -> ContentItem:
+    title = f"WeChat group: {group_name}"
+    return ContentItem(
+        platform="wechat_group",
+        input_type="collection",
+        url=input_url,
+        id=f"wxg-{_stable_hash(group_name, since, until)}",
+        title=title,
+        source_type="conversation",
+        raw_meta={
+            "profile": "conversation",
+            "permission_scope": "user_accessible",
+            "group_name": group_name,
+            "since": since,
+            "until": until,
+            "messages": messages,
+            "markdown_preview": render_wechat_group_markdown(messages),
+            "discovery_limit": limit,
+            "discovery_provider": OPENCLI_WX_HISTORY_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 history 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:
+    import hashlib
+
+    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/wechat_moments/__init__.py

@@ -0,0 +1,11 @@
+"""Wechat Moments conversation adapter factory."""
+
+from __future__ import annotations
+
+from openmd.adapters.base import PlatformAdapter
+
+from .adapter import WechatMomentsAdapter
+
+
+def create_adapter(platform_id: str, default_backend: str) -> PlatformAdapter:
+    return WechatMomentsAdapter(platform_id, default_backend)