openmd-cli 0.1.0__py3-none-any.whl

openmd/backends/screenshot.py

@@ -0,0 +1,79 @@
+"""Runtime providers for long screenshot OCR inputs."""
+
+from __future__ import annotations
+
+from openmd.adapters.screenshot.adapter import ScreenshotOcrAdapter
+from openmd.adapters.screenshot.backends.rapidocr import RapidOCRBackend
+from openmd.adapters.screenshot.ocr import MissingOCRBackend, MockOCRBackend
+from openmd.backends.base import (
+    BackendCapability,
+    BackendDescriptor,
+    BackendExtractRequest,
+    BackendHealth,
+)
+from openmd.backends.executor import BackendProviderRegistry
+from openmd.backends.registry import BackendRuntimeOptions
+from openmd.core.models import TranscriptResult
+
+
+class ScreenshotOCRProvider:
+    def __init__(self, backend) -> None:
+        self.backend = backend
+        self.name = backend.name
+
+    def descriptor(self) -> BackendDescriptor:
+        source_level = "ocr" if isinstance(self.backend, MockOCRBackend) else "partial_extraction"
+        return BackendDescriptor(
+            name=self.name,
+            layer="local",
+            capabilities=(
+                BackendCapability(
+                    platforms=("screenshot",),
+                    source_types=("image_text",),
+                    input_types=("single", "batch", "collection", "generic"),
+                    source_levels=(source_level,),
+                    requires_network=False,
+                    requires_credentials=False,
+                ),
+            ),
+            description="Long screenshot OCR provider.",
+            provider="openmd.screenshot",
+        )
+
+    def health(self) -> BackendHealth:
+        is_available = getattr(self.backend, "is_available", None)
+        if callable(is_available) and not is_available():
+            return BackendHealth(
+                ok=False,
+                error_code="ocr_backend_missing",
+                error_summary=f"{self.name} is not installed or enabled.",
+            )
+        if isinstance(self.backend, MissingOCRBackend):
+            return BackendHealth(
+                ok=False,
+                error_code="ocr_backend_missing",
+                error_summary=f"{self.name} is not installed or enabled.",
+            )
+        return BackendHealth(ok=True, dependencies={self.name: "ok"})
+
+    def extract(self, request: BackendExtractRequest) -> TranscriptResult:
+        adapter = ScreenshotOcrAdapter("screenshot", request.primary_backend)
+        return adapter.extract_text(
+            request.item,
+            backend=request.primary_backend,
+            backend_chain=(request.primary_backend,),
+            allow_fallback=False,
+        )
+
+
+def register_backend_providers(
+    registry: BackendProviderRegistry,
+    options: BackendRuntimeOptions,
+) -> None:
+    from openmd.backends.ocr import register_ocr_providers
+
+    register_ocr_providers(registry, options)
+    registry.register("screenshot.mock", ScreenshotOCRProvider(MockOCRBackend()))
+    registry.register("ocr.rapidocr", ScreenshotOCRProvider(RapidOCRBackend()))
+    registry.register("ocr.paddle", ScreenshotOCRProvider(MissingOCRBackend("ocr.paddle")))
+    registry.register("ocr.tesseract", ScreenshotOCRProvider(MissingOCRBackend("ocr.tesseract")))

openmd/backends/video_metadata.py

@@ -0,0 +1,167 @@
+"""Optional public video metadata, separate from transcript acquisition.
+
+Only the explicit public-network gate permits a request. Browser permission
+alone never enables these requests, and metadata failure cannot lose text.
+"""
+
+from __future__ import annotations
+
+import json
+import re
+from collections.abc import Callable
+from dataclasses import replace
+from datetime import datetime, timezone
+from typing import Any
+from urllib.parse import urlencode
+from urllib.request import Request, urlopen
+
+from openmd.core.filename import short_hash
+from openmd.core.models import ContentItem, TranscriptResult
+
+from .youtube_transcript import extract_youtube_video_id
+
+
+MetadataFetcher = Callable[[str, int], Any]
+_YOUTUBE_ID = re.compile(r"^[A-Za-z0-9_-]{11}$")
+_BILIBILI_ID = re.compile(r"BV[A-Za-z0-9]{10}")
+_PLACEHOLDER_TITLES = frozenset({"untitled", "unknown", "video", "audio"})
+_MAX_RESPONSE_BYTES = 512 * 1024
+
+
+def _value(value: object, *, limit: int = 512) -> str | None:
+    if not isinstance(value, str):
+        return None
+    cleaned = " ".join(value.split()).strip()
+    return cleaned[:limit] if cleaned else None
+
+
+def _identity(item: ContentItem, result: TranscriptResult) -> tuple[str, str | None]:
+    if item.platform == "youtube":
+        for candidate in (item.id, result.metadata.get("video_id"), extract_youtube_video_id(item.url)):
+            if isinstance(candidate, str) and _YOUTUBE_ID.fullmatch(candidate):
+                return candidate, candidate
+    else:
+        for candidate in (item.id, result.metadata.get("bvid"), item.url):
+            match = _BILIBILI_ID.search(candidate) if isinstance(candidate, str) else None
+            if match:
+                return match.group(), match.group()
+    return short_hash(item.url), None
+
+
+def _source_title(value: object, *, identifier: str, platform: str) -> str | None:
+    title = _value(value)
+    if title is None or title.casefold() in _PLACEHOLDER_TITLES:
+        return None
+    if title.casefold() in {identifier.casefold(), f"{platform} · {identifier}".casefold()}:
+        return None
+    return title
+
+
+def _fetch_public_json(url: str, timeout: int) -> Any:
+    # These fixed public endpoints do not receive session state or credentials.
+    request = Request(url, headers={"User-Agent": "Openmd/0.0", "Accept": "application/json"})
+    with urlopen(request, timeout=timeout) as response:
+        if not 200 <= int(getattr(response, "status", 200)) < 300:
+            raise ValueError("metadata_http_error")
+        raw = response.read(_MAX_RESPONSE_BYTES + 1)
+    if len(raw) > _MAX_RESPONSE_BYTES:
+        raise ValueError("metadata_response_too_large")
+    return json.loads(raw.decode("utf-8-sig"))
+
+
+def _public_metadata(platform: str, identifier: str, fetch: MetadataFetcher, timeout: int) -> dict[str, str | None]:
+    if platform == "youtube":
+        url = "https://www.youtube.com/oembed?" + urlencode({
+            "url": f"https://www.youtube.com/watch?v={identifier}", "format": "json",
+        })
+        payload = fetch(url, timeout)
+        if not isinstance(payload, dict):
+            raise ValueError("metadata_payload_invalid")
+        return {
+            "title": _value(payload.get("title")),
+            "author": _value(payload.get("author_name"), limit=256),
+            "published_at": None,  # oEmbed does not establish a publication date.
+        }
+
+    payload = fetch("https://api.bilibili.com/x/web-interface/view?" + urlencode({"bvid": identifier}), timeout)
+    if not isinstance(payload, dict) or payload.get("code") not in (0, "0"):
+        raise ValueError("metadata_payload_invalid")
+    data = payload.get("data")
+    if not isinstance(data, dict):
+        raise ValueError("metadata_payload_invalid")
+    owner = data.get("owner")
+    pubdate = data.get("pubdate")
+    published_at = None
+    if isinstance(pubdate, (int, float)) and not isinstance(pubdate, bool) and pubdate > 0:
+        try:
+            published_at = datetime.fromtimestamp(pubdate, timezone.utc).date().isoformat()
+        except (OverflowError, OSError, ValueError):
+            pass
+    return {
+        "title": _value(data.get("title")),
+        "author": _value(owner.get("name"), limit=256) if isinstance(owner, dict) else None,
+        "published_at": published_at,
+    }
+
+
+def enrich_video_result(
+    item: ContentItem,
+    result: TranscriptResult,
+    *,
+    network_enabled: bool = False,
+    fetch_json: MetadataFetcher | None = None,
+    timeout: int = 8,
+) -> TranscriptResult:
+    """Fill absent video title/author, preserving all extraction evidence.
+
+    At most one bounded public request is made per call, only for a usable
+    YouTube/Bilibili result missing title or author and with network enabled.
+    Existing source metadata takes priority. No video title is inferred from
+    transcript words. ``fetch_json`` is an injectable JSON transport for local
+    verification; it obeys the same gate as the default transport.
+    """
+    if item.platform not in {"youtube", "bilibili"} or not result.has_usable_text or result.backend == "mock":
+        return result
+    identifier, fetch_identifier = _identity(item, result)
+    title = _source_title(result.title, identifier=identifier, platform=item.platform) or _source_title(
+        item.title, identifier=identifier, platform=item.platform,
+    )
+    author = _value(result.author, limit=256) or _value(item.author, limit=256)
+    published_at = result.published_at or item.published_at
+    status = "already_present" if title and author else "not_requested"
+    source = None
+    if not (title and author) and network_enabled and fetch_identifier:
+        try:
+            public = _public_metadata(item.platform, fetch_identifier, fetch_json or _fetch_public_json, timeout)
+            title = title or _source_title(public["title"], identifier=identifier, platform=item.platform)
+            author = author or public["author"]
+            published_at = published_at or public["published_at"]
+            status = "available" if title and author else "partial"
+            source = "youtube.oembed" if item.platform == "youtube" else "bilibili.public_view"
+        except Exception:
+            # A good transcript remains a good transcript even when metadata
+            # is blocked, times out, or has an unexpected shape. Never retain
+            # upstream payloads, URLs, headers or exception text in this note.
+            status = "unavailable"
+    missing = [field for field, value in (("title", title), ("author", author)) if not value]
+    notes = list(result.source_notes)
+    if not title:
+        label = "YouTube" if item.platform == "youtube" else "Bilibili"
+        title = f"{label} · {identifier}"
+        note = "视频标题未取得；保留已提取文字，以平台和视频 ID 命名。"
+        if note not in notes:
+            notes.append(note)
+    elif not author:
+        note = "视频作者未取得；保留已提取文字。"
+        if note not in notes:
+            notes.append(note)
+    return replace(
+        result,
+        title=title,
+        author=author,
+        published_at=published_at,
+        source_notes=notes,
+        metadata={**result.metadata, "video_metadata": {
+            "status": status, "source": source, "missing_fields": missing,
+        }},
+    )

openmd/backends/web_article.py

@@ -0,0 +1,363 @@
+"""Generic web article extraction providers.
+
+The primary provider wraps ``trafilatura`` as an optional local library. It is
+registered only after ``--enable-network-backends`` because it fetches remote
+pages. Browser/session fallbacks such as OpenCLI stay behind
+``--enable-browser-backends``.
+"""
+
+from __future__ import annotations
+
+import shutil
+import subprocess
+from collections.abc import Callable
+from typing import Any
+
+from openmd.backends.base import (
+    BackendCapability,
+    BackendDescriptor,
+    BackendExtractRequest,
+    BackendHealth,
+)
+from openmd.backends.executor import BackendProviderRegistry
+from openmd.backends.registry import BackendRuntimeOptions
+from openmd.core.models import TranscriptResult
+from openmd.core.secrets import sanitize_error_summary
+from openmd.runtime.interpreters import run_interruptibly
+
+
+WEB_ARTICLE_TRAFILATURA_BACKEND = "web_article.trafilatura"
+OPENCLI_WEB_READ_BACKEND = "opencli.web.read"
+CRAWL4AI_WEB_ARTICLE_BACKEND = "crawl4ai.web_article"
+DEFAULT_MIN_ARTICLE_CHARS = 40
+
+CommandRunner = Callable[[list[str], int], tuple[int, str, str]]
+TrafilaturaFetcher = Callable[[str], object]
+TrafilaturaExtractor = Callable[..., str | None]
+TrafilaturaMetadataExtractor = Callable[[object], object]
+
+
+def register_backend_providers(
+    registry: BackendProviderRegistry,
+    options: BackendRuntimeOptions,
+) -> None:
+    """Register web article providers behind explicit runtime gates."""
+    requested = options.backend_override
+    from openmd.backends.discourse import DISCOURSE_BACKEND, DiscourseProvider
+
+    if (options.enable_network_backends or options.enable_browser_backends) and requested in {None, DISCOURSE_BACKEND}:
+        registry.register(DISCOURSE_BACKEND, DiscourseProvider(options))
+    if options.enable_network_backends and requested in {None, WEB_ARTICLE_TRAFILATURA_BACKEND}:
+        registry.register(WEB_ARTICLE_TRAFILATURA_BACKEND, WebArticleTrafilaturaProvider())
+
+    if options.enable_browser_backends and requested in {None, OPENCLI_WEB_READ_BACKEND}:
+        registry.register(OPENCLI_WEB_READ_BACKEND, OpenCliWebReadProvider())
+
+
+class WebArticleTrafilaturaProvider:
+    """Extract generic static articles through the optional trafilatura API."""
+
+    name = WEB_ARTICLE_TRAFILATURA_BACKEND
+
+    def __init__(
+        self,
+        *,
+        fetcher: TrafilaturaFetcher | None = None,
+        extractor: TrafilaturaExtractor | None = None,
+        metadata_extractor: TrafilaturaMetadataExtractor | None = None,
+        min_article_chars: int = DEFAULT_MIN_ARTICLE_CHARS,
+    ) -> None:
+        self._fetcher = fetcher
+        self._extractor = extractor
+        self._metadata_extractor = metadata_extractor
+        self.min_article_chars = max(0, min_article_chars)
+
+    def descriptor(self) -> BackendDescriptor:
+        capability = BackendCapability(
+            platforms=("web_article",),
+            source_types=("article",),
+            input_types=("single", "batch"),
+            source_levels=("native_text", "partial_extraction"),
+            requires_network=True,
+            requires_credentials=False,
+            optional_config=("trafilatura",),
+        )
+        return BackendDescriptor(
+            name=self.name,
+            layer="L1 specialized extractor",
+            capabilities=(capability,),
+            description="Fetch and extract static web articles with optional local trafilatura.",
+            provider="openmd.backends.web_article",
+        )
+
+    def health(self) -> BackendHealth:
+        if self._fetcher is not None and self._extractor is not None:
+            return BackendHealth(ok=True, dependencies={"trafilatura": "injected"})
+        try:
+            import trafilatura  # type: ignore[import-not-found]  # noqa: F401
+        except ModuleNotFoundError:
+            return BackendHealth(
+                ok=False,
+                dependencies={"trafilatura": "missing"},
+                error_code="backend_dependency_missing",
+                error_summary="Install trafilatura or use a browser fallback backend.",
+            )
+        return BackendHealth(ok=True, dependencies={"trafilatura": "available"})
+
+    def extract(self, request: BackendExtractRequest) -> TranscriptResult:
+        item = request.item
+        if item.platform != "web_article":
+            return _failed(
+                self.name,
+                "unsupported_platform",
+                f"trafilatura web article provider only supports web_article, got {item.platform}.",
+            )
+
+        try:
+            fetcher, extractor, metadata_extractor = self._resolve_api()
+        except ModuleNotFoundError:
+            return _failed(
+                self.name,
+                "backend_dependency_missing",
+                "trafilatura is not installed; install it or enable browser fallback.",
+            )
+
+        try:
+            downloaded = fetcher(item.url)
+        except Exception as exc:
+            downloaded, fetch_error = None, exc
+        else:
+            fetch_error = None
+        if downloaded is None and self._fetcher is None:
+            # trafilatura's urllib3 client ignores system/SOCKS proxy settings;
+            # stdlib urllib honors HTTP(S)_PROXY and the Windows proxy.
+            try:
+                downloaded = _urllib_fetch(item.url)
+            except Exception as exc:  # network errors are reported below
+                fetch_error = fetch_error or exc
+        if downloaded is None:
+            if fetch_error is not None:
+                return _failed(self.name, "web_article_fetch_failed", fetch_error)
+            return _failed(self.name, "web_article_fetch_empty", "trafilatura.fetch_url returned no document.")
+
+        try:
+            markdown = extractor(
+                downloaded,
+                output_format="markdown",
+                # Metadata is read separately below; True would embed a YAML
+                # block inside the body, duplicating the rendered front matter.
+                with_metadata=False,
+                include_images=True,
+                include_links=True,
+                url=item.url,
+            )
+        except Exception as exc:
+            return _failed(self.name, "web_article_extract_failed", exc)
+
+        text = (markdown or "").strip()
+        if len("".join(text.split())) < self.min_article_chars:
+            return _failed(
+                self.name,
+                "web_article_empty_content",
+                "trafilatura returned no usable article body.",
+            )
+
+        metadata = _metadata_dict(metadata_extractor, downloaded)
+        return TranscriptResult(
+            text=text.rstrip() + "\n",
+            status="verified",
+            source_level="native_text",
+            backend=self.name,
+            title=_metadata_value(metadata, "title"),
+            author=_metadata_value(metadata, "author"),
+            published_at=_metadata_value(metadata, "date", "published", "published_at"),
+            source_notes=[
+                "trafilatura extracted article Markdown locally from fetched HTML.",
+                "include_images=True and include_links=True were requested.",
+                "No browser, cloud API, media download, or ASR action was attempted.",
+            ],
+            metadata={"strategy": "trafilatura_api"},
+        )
+
+    def _resolve_api(
+        self,
+    ) -> tuple[TrafilaturaFetcher, TrafilaturaExtractor, TrafilaturaMetadataExtractor | None]:
+        if self._fetcher is not None and self._extractor is not None:
+            return self._fetcher, self._extractor, self._metadata_extractor
+
+        from trafilatura import extract, extract_metadata, fetch_url  # type: ignore[import-not-found]
+
+        return fetch_url, extract, extract_metadata
+
+
+class OpenCliWebReadProvider:
+    """Browser/session fallback for generic web pages through OpenCLI."""
+
+    name = OPENCLI_WEB_READ_BACKEND
+
+    def __init__(self, *, runner: CommandRunner | None = None, timeout: int = 180) -> None:
+        self._runner = runner or _run_command
+        self.timeout = timeout
+
+    def descriptor(self) -> BackendDescriptor:
+        capability = BackendCapability(
+            platforms=("web_article", "weixin"),
+            source_types=("article",),
+            input_types=("single", "batch"),
+            source_levels=("third_party_extractor", "partial_extraction"),
+            requires_network=True,
+        )
+        return BackendDescriptor(
+            name=self.name,
+            layer="L3 browser/session fallback",
+            capabilities=(capability,),
+            description="Use OpenCLI browser extraction and return Markdown from stdout.",
+            provider="opencli.web",
+            is_fallback=True,
+        )
+
+    def health(self) -> BackendHealth:
+        if self._runner is not _run_command:
+            return BackendHealth(ok=True, dependencies={"opencli": "injected"})
+        if shutil.which("opencli") is None and shutil.which("opencli.cmd") is None:
+            return BackendHealth(
+                ok=False,
+                dependencies={"opencli": "missing"},
+                error_code="backend_dependency_missing",
+                error_summary="opencli executable is not available on PATH.",
+            )
+        return BackendHealth(ok=True, dependencies={"opencli": "available"})
+
+    def extract(self, request: BackendExtractRequest) -> TranscriptResult:
+        item = request.item
+        command = [
+            "opencli",
+            "web",
+            "read",
+            "--url",
+            item.url,
+            "--stdout",
+            "true",
+            "--download-images",
+            "false",
+            "--window",
+            "background",
+            "--keep-tab",
+            "false",
+            "-f",
+            "md",
+        ]
+        exit_code, stdout, stderr = self._runner(command, self.timeout)
+        if exit_code != 0:
+            return _failed(self.name, f"backend_exit_{exit_code}", stderr or stdout)
+
+        text = stdout.strip()
+        if not text:
+            return _failed(self.name, "empty_result", "OpenCLI web read returned no Markdown text.")
+
+        return TranscriptResult(
+            text=text.rstrip() + "\n",
+            status="verified",
+            source_level="third_party_extractor",
+            backend=self.name,
+            title=_markdown_title(text) or item.title,
+            source_notes=[
+                "OpenCLI web read returned Markdown from browser/session fallback.",
+                "--download-images false was used; Openmd owns optional asset localization.",
+                "No raw stdout/stderr artifact was persisted by the provider.",
+            ],
+        )
+
+
+def _urllib_fetch(url: str, timeout: int = 30) -> str | bytes | None:
+    import urllib.request
+
+    request = urllib.request.Request(url, headers={"User-Agent": "Mozilla/5.0 (compatible; Openmd)", "Accept-Language": "zh-CN,zh;q=0.9,en;q=0.8"})
+    with urllib.request.urlopen(request, timeout=timeout) as response:  # noqa: S310 - http(s) only, checked by input validation
+        body = response.read(20 * 1024 * 1024)
+        charset = response.headers.get_content_charset()
+    if not body:
+        return None
+    # Without a declared charset, hand bytes to trafilatura (it sniffs <meta charset>, e.g. GBK).
+    return body.decode(charset, errors="replace") if charset else body
+
+
+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 as exc:
+        return 127, "", sanitize_error_summary(exc) or "command not found"
+    except subprocess.TimeoutExpired as exc:
+        return (
+            124,
+            exc.stdout if isinstance(exc.stdout, str) else "",
+            f"command timed out after {timeout}s",
+        )
+    return completed.returncode, completed.stdout or "", completed.stderr or ""
+
+
+def _metadata_dict(
+    metadata_extractor: TrafilaturaMetadataExtractor | None,
+    downloaded: object,
+) -> dict[str, Any]:
+    if metadata_extractor is None:
+        return {}
+    try:
+        metadata = metadata_extractor(downloaded)
+    except Exception:
+        return {}
+    if metadata is None:
+        return {}
+    if isinstance(metadata, dict):
+        return dict(metadata)
+    as_dict = getattr(metadata, "as_dict", None)
+    if callable(as_dict):
+        try:
+            value = as_dict()
+        except Exception:
+            value = None
+        if isinstance(value, dict):
+            return value
+    result: dict[str, Any] = {}
+    for key in ("title", "author", "date", "published", "published_at"):
+        value = getattr(metadata, key, None)
+        if value:
+            result[key] = value
+    return result
+
+
+def _metadata_value(metadata: dict[str, Any], *keys: str) -> str | None:
+    for key in keys:
+        value = metadata.get(key)
+        if value is not None and str(value).strip():
+            return str(value).strip()
+    return None
+
+
+def _markdown_title(markdown: str) -> str | None:
+    for line in markdown.splitlines():
+        stripped = line.strip()
+        if stripped.startswith("# "):
+            return stripped.removeprefix("# ").strip() or None
+    return None
+
+
+def _failed(backend: str, code: str, error: object) -> TranscriptResult:
+    return TranscriptResult(
+        text="",
+        status="failed",
+        source_level="partial_extraction",
+        backend=backend,
+        source_notes=["web article provider returned structured failure"],
+        error_code=code,
+        error_summary=sanitize_error_summary(error),
+    )

openmd/backends/wechat_group.py

@@ -0,0 +1,35 @@
+"""Runtime registration for WeChat group discovery providers."""
+
+from __future__ import annotations
+
+from openmd.adapters.wechat_group.wx_cli import (
+    OPENCLI_WX_HISTORY_DISCOVERY_BACKEND,
+    OpenCliWechatGroupHistoryProvider,
+)
+from openmd.backends.executor import BackendProviderRegistry, DiscoveryProviderRegistry
+from openmd.backends.registry import BackendRuntimeOptions
+
+
+def register_backend_providers(
+    registry: BackendProviderRegistry,
+    options: BackendRuntimeOptions,
+) -> None:
+    """WeChat group extraction is intentionally not registered in mock/gated V1."""
+    return None
+
+
+def register_discovery_providers(
+    registry: DiscoveryProviderRegistry,
+    options: BackendRuntimeOptions,
+) -> None:
+    """Register OpenCLI WeChat group history only behind explicit browser gate."""
+    if not options.enable_browser_backends:
+        return
+    requested = options.requested_discovery_provider
+    if requested in {None, OPENCLI_WX_HISTORY_DISCOVERY_BACKEND}:
+        registry.register(
+            OPENCLI_WX_HISTORY_DISCOVERY_BACKEND,
+            OpenCliWechatGroupHistoryProvider(),
+            platforms=("wechat_group",),
+            default_for_platforms=requested is None,
+        )

openmd/backends/wechat_moments.py

@@ -0,0 +1,35 @@
+"""Runtime registration for WeChat Moments discovery providers."""
+
+from __future__ import annotations
+
+from openmd.adapters.wechat_moments.wx_cli import (
+    OPENCLI_WX_SNS_FEED_DISCOVERY_BACKEND,
+    OpenCliWechatMomentsProvider,
+)
+from openmd.backends.executor import BackendProviderRegistry, DiscoveryProviderRegistry
+from openmd.backends.registry import BackendRuntimeOptions
+
+
+def register_backend_providers(
+    registry: BackendProviderRegistry,
+    options: BackendRuntimeOptions,
+) -> None:
+    """WeChat Moments extraction is intentionally not registered in mock/gated V1."""
+    return None
+
+
+def register_discovery_providers(
+    registry: DiscoveryProviderRegistry,
+    options: BackendRuntimeOptions,
+) -> None:
+    """Register OpenCLI Moments discovery only behind explicit browser gate."""
+    if not options.enable_browser_backends:
+        return
+    requested = options.requested_discovery_provider
+    if requested in {None, OPENCLI_WX_SNS_FEED_DISCOVERY_BACKEND}:
+        registry.register(
+            OPENCLI_WX_SNS_FEED_DISCOVERY_BACKEND,
+            OpenCliWechatMomentsProvider(),
+            platforms=("wechat_moments",),
+            default_for_platforms=requested is None,
+        )