openmd-cli 0.1.0__py3-none-any.whl

openmd/core/filename.py

@@ -0,0 +1,64 @@
+"""Windows-safe title filename helpers."""
+
+from __future__ import annotations
+
+import hashlib
+import re
+from pathlib import Path
+
+
+INVALID_FILENAME_CHARS_RE = re.compile(r'[<>:"/\\|?*\x00-\x1f]')
+WHITESPACE_RE = re.compile(r"\s+")
+
+
+def short_hash(value: str | None, *, length: int = 8) -> str:
+    seed = value or "openmd"
+    return hashlib.sha1(seed.encode("utf-8", errors="ignore")).hexdigest()[:length]
+
+
+def safe_filename(value: str | None, *, fallback: str = "untitled", max_length: int = 120) -> str:
+    text = value or fallback
+    text = INVALID_FILENAME_CHARS_RE.sub(" ", text)
+    text = WHITESPACE_RE.sub(" ", text).strip(" .")
+    if not text:
+        text = fallback
+    if len(text) > max_length:
+        text = text[:max_length].rstrip(" .")
+    return text or "untitled"
+
+
+def filename_base_for_item(
+    title: str | None,
+    *,
+    item_id: str | None = None,
+    url: str | None = None,
+    max_length: int = 120,
+) -> str:
+    fallback = item_id or short_hash(url)
+    return safe_filename(title, fallback=fallback, max_length=max_length)
+
+
+def unique_markdown_path(
+    directory: Path,
+    filename_base: str,
+    *,
+    collision_key: str | None = None,
+    overwrite: bool = False,
+) -> Path:
+    directory.mkdir(parents=True, exist_ok=True)
+    base = safe_filename(filename_base)
+    candidate = directory / f"{base}.md"
+    if overwrite or not candidate.exists():
+        return candidate
+
+    suffix = short_hash(collision_key or base)
+    candidate = directory / f"{base}-{suffix}.md"
+    if not candidate.exists():
+        return candidate
+
+    counter = 2
+    while True:
+        candidate = directory / f"{base}-{suffix}-{counter}.md"
+        if not candidate.exists():
+            return candidate
+        counter += 1

openmd/core/input_validation.py

@@ -0,0 +1,91 @@
+"""Daily-input classification and bounded, best-effort public URL preflight."""
+
+from __future__ import annotations
+
+import queue
+import socket
+import threading
+from urllib.parse import urlparse
+import urllib.error
+import urllib.request
+
+from .detector import _local_path_for_detection
+
+
+INPUT_HINT = "请粘贴 http(s) 链接或本地文件路径"
+
+
+def valid_daily_input(value: str) -> bool:
+    try:
+        parsed = urlparse(value)
+        if parsed.scheme in {"http", "https"}:
+            return bool(parsed.hostname) and not any(ch.isspace() for ch in value)
+        path = _local_path_for_detection(value)
+        return path is not None and path.is_file()
+    except (OSError, ValueError):
+        return False
+
+
+def _probe_url(url: str) -> str | None:
+    parsed = urlparse(url)
+    host = (parsed.hostname or "").rstrip(".").lower()
+    # RFC-reserved invalid names stay invalid even under a fake-DNS proxy.
+    if host == "invalid" or host.endswith(".invalid"):
+        return "域名无法访问"
+    proxies = urllib.request.getproxies()
+    # A configured proxy may resolve the origin remotely. Local DNS must not
+    # veto that route or consume its short preflight budget.
+    if not (proxies.get(parsed.scheme) or proxies.get("all")):
+        try:
+            socket.getaddrinfo(parsed.hostname, parsed.port or (443 if parsed.scheme == "https" else 80), type=socket.SOCK_STREAM)
+        except socket.gaierror as exc:
+            if exc.errno in {socket.EAI_NONAME, getattr(socket, "EAI_NODATA", socket.EAI_NONAME)}:
+                return "域名无法访问"
+            return None
+        except (OSError, ValueError):
+            return None
+    # urllib supplies HTTP(S)_PROXY/NO_PROXY handling, but ALL_PROXY needs an
+    # explicit scheme fallback. Do not persist proxy URLs or credentials.
+    if proxies.get("all"):
+        proxies.setdefault("http", proxies["all"])
+        proxies.setdefault("https", proxies["all"])
+    opener = urllib.request.build_opener(urllib.request.ProxyHandler(proxies))
+    # A proxied TLS round trip regularly takes 2-4s here, so a 2s HEAD followed
+    # by a 2s GET timed out before either answered. Spend the budget on one
+    # HEAD; fall back to GET only when the server answered but rejected HEAD.
+    for method, timeout in (("HEAD", 4.0), ("GET", 2.0)):
+        try:
+            request = urllib.request.Request(url, method=method, headers={"User-Agent": "Openmd/0.0.1"})
+            with opener.open(request, timeout=timeout):
+                return None
+        except urllib.error.HTTPError as exc:
+            code = exc.code
+            exc.close()
+            if code in {400, 404, 410, 414, 422}:
+                label = "页面不存在" if code in {404, 410} else "页面无法访问"
+                return f"{label}（{code}）"
+        except (OSError, ValueError):
+            return None
+    return None
+
+
+def network_preflight(url: str, *, timeout: float = 4.8) -> str | None:
+    """Stop only on a positive DNS/not-found signal, never on uncertainty.
+
+    DNS resolution itself has no portable socket timeout. Keep its worker a
+    daemon and bound the entire wait so a slow resolver cannot stall the CLI.
+    No response body or credentials are read or persisted.
+    """
+    results: queue.Queue[str | None] = queue.Queue(maxsize=1)
+
+    def probe() -> None:
+        try:
+            results.put(_probe_url(url))
+        except Exception:
+            results.put(None)
+
+    threading.Thread(target=probe, name="openmd-url-preflight", daemon=True).start()
+    try:
+        return results.get(timeout=timeout)
+    except queue.Empty:
+        return None

openmd/core/local_config.py

@@ -0,0 +1,96 @@
+"""Machine-local tool locations shared by the controller and isolated workers."""
+
+from __future__ import annotations
+
+import json
+import os
+import re
+from pathlib import Path
+from typing import Any
+
+
+SCHEMA = "openmd.local/v1"
+DEFAULT_QWEN3_BATCH_SIZE = 4  # user decision 2026-11-09: ~2.1x faster; not byte-identical to batch 1
+MAX_QWEN3_BATCH_SIZE = 32
+_PRIVATE_KEY = re.compile(r"cookie|token|auth|session|password|secret|credential|api.?key", re.I)
+
+
+def checkout_root() -> Path | None:
+    root = Path(__file__).resolve().parents[3]
+    return root if (root / "pyproject.toml").is_file() and (root / "src/openmd").is_dir() else None
+
+
+def local_config_path() -> Path | None:
+    explicit = os.environ.get("OPENMD_CONFIG")
+    if explicit:
+        return Path(explicit).expanduser().resolve()
+    root = checkout_root()
+    if root is not None and (root / "out/local-config.json").is_file():
+        return root / "out/local-config.json"
+    default = Path.home() / ".openmd/local.json"
+    return default if default.is_file() else None
+
+
+def _check_keys(value: Any) -> None:
+    if isinstance(value, dict):
+        for key, child in value.items():
+            if _PRIVATE_KEY.search(key):
+                raise ValueError("local_config_private_field: credentials do not belong in Openmd location configuration")
+            _check_keys(child)
+    elif isinstance(value, list):
+        for child in value:
+            _check_keys(child)
+
+
+def load_local_config() -> dict[str, Any]:
+    """Return optional location metadata; explicit malformed configuration fails closed."""
+    path = local_config_path()
+    if path is None:
+        return {}
+    if not path.is_file():
+        raise ValueError("local_config_missing: OPENMD_CONFIG must name an existing local JSON file")
+    if path.stat().st_size > 128 * 1024:
+        raise ValueError("local_config_too_large")
+    try:
+        value = json.loads(path.read_text(encoding="utf-8-sig"))
+    except (OSError, ValueError) as exc:
+        raise ValueError("local_config_invalid: expected local position configuration JSON") from exc
+    if not isinstance(value, dict) or value.get("schema") != SCHEMA:
+        raise ValueError("local_config_schema: expected openmd.local/v1")
+    _check_keys(value)
+    if set(value) - {"schema", "asr_python", "qwen3_batch_size", "ocr_python", "ollama_url", "ocr", "soffice", "model_roots", "tools", "route_overlay"}:
+        raise ValueError("local_config_unknown_field")
+    if "qwen3_batch_size" in value:
+        if type(value["qwen3_batch_size"]) is not int:
+            raise ValueError("local_config_qwen3_batch_size_invalid: expected an integer")
+        validate_qwen3_batch_size(value["qwen3_batch_size"])
+    if "asr_python" in value and not isinstance(value["asr_python"], str):
+        raise ValueError("local_config_asr_python_invalid")
+    for key in ("ocr_python", "ollama_url", "soffice"):
+        if key in value and not isinstance(value[key], str):
+            raise ValueError(f"local_config_{key}_invalid")
+    if "ocr" in value and not isinstance(value["ocr"], dict):
+        raise ValueError("local_config_ocr_invalid")
+    if "model_roots" in value and (not isinstance(value["model_roots"], list) or not all(isinstance(p, str) for p in value["model_roots"])):
+        raise ValueError("local_config_model_roots_invalid")
+    if "tools" in value and not isinstance(value["tools"], dict):
+        raise ValueError("local_config_tools_invalid")
+    if "route_overlay" in value and not isinstance(value["route_overlay"], str):
+        raise ValueError("local_config_route_overlay_invalid")
+    return value
+
+
+def validate_qwen3_batch_size(value: object) -> int:
+    """Validate a bounded batch size without importing the GPU stack."""
+    if isinstance(value, str) and re.fullmatch(r"[0-9]+", value.strip()):
+        value = int(value.strip())
+    if type(value) is not int or not 1 <= value <= MAX_QWEN3_BATCH_SIZE:
+        raise ValueError(f"qwen3_batch_size_invalid: expected an integer from 1 to {MAX_QWEN3_BATCH_SIZE}")
+    return value
+
+
+def qwen3_batch_size() -> int:
+    """Environment overrides local JSON; scalar inference is the safe default."""
+    local = load_local_config()
+    value = os.environ.get("OPENMD_QWEN3_BATCH_SIZE", local.get("qwen3_batch_size", DEFAULT_QWEN3_BATCH_SIZE))
+    return validate_qwen3_batch_size(value)

openmd/core/manifest.py

@@ -0,0 +1,156 @@
+"""Discovery manifest writer for collection workflows."""
+
+from __future__ import annotations
+
+import json
+from pathlib import Path
+from typing import Any
+from urllib.parse import urlparse
+
+from .filename import safe_filename, short_hash
+from .models import ContentItem
+from .secrets import sanitize_for_logging, sanitize_url
+
+
+def default_manifest_path(
+    out_dir: str | Path,
+    *,
+    platform: str,
+    collection_url: str,
+) -> Path:
+    """Return a stable per-collection JSONL manifest path."""
+    slug = _collection_slug(collection_url) or short_hash(collection_url)
+    filename = safe_filename(
+        f"{platform}_{slug}-{short_hash(collection_url)}",
+        fallback=f"{platform}_{short_hash(collection_url)}",
+        max_length=120,
+    )
+    return Path(out_dir) / "manifests" / f"{filename}.jsonl"
+
+
+def write_discovery_manifest(
+    *,
+    out_dir: str | Path,
+    platform: str,
+    collection_url: str,
+    provider: str,
+    items: list[ContentItem],
+    limit: int | None = None,
+) -> Path:
+    """Append newly discovered items to a per-collection manifest.
+
+    The manifest uses generic ``content_id``/``content_url`` fields while
+    retaining the legacy video aliases. Existing keys are not appended again,
+    so repeated smoke runs stay resumable without growing duplicate rows.
+    """
+    manifest_path = default_manifest_path(
+        out_dir,
+        platform=platform,
+        collection_url=collection_url,
+    )
+    manifest_path.parent.mkdir(parents=True, exist_ok=True)
+
+    existing_keys = _read_existing_manifest_keys(manifest_path)
+    with manifest_path.open("a", encoding="utf-8", newline="\n") as file:
+        for item in items:
+            row = discovery_manifest_row(
+                item,
+                collection_url=collection_url,
+                provider=provider,
+                limit=limit,
+            )
+            key = _manifest_key(row)
+            if key in existing_keys:
+                continue
+            existing_keys.add(key)
+            safe_row = sanitize_for_logging(row)
+            file.write(json.dumps(safe_row, ensure_ascii=False, sort_keys=True) + "\n")
+    return manifest_path
+
+
+def discovery_manifest_row(
+    item: ContentItem,
+    *,
+    collection_url: str,
+    provider: str,
+    limit: int | None = None,
+) -> dict[str, Any]:
+    """Build one normalized discovery manifest row."""
+    raw_meta = item.raw_meta
+    return {
+        "platform": item.platform,
+        "collection_url": sanitize_url(collection_url),
+        "playlist_id": raw_meta.get("playlist_id"),
+        "channel_id": raw_meta.get("channel_id"),
+        "channel_title": raw_meta.get("channel_title") or item.author,
+        "content_id": item.id,
+        "content_url": sanitize_url(item.url),
+        "video_id": item.id,
+        "video_url": sanitize_url(item.url),
+        "resource_id": raw_meta.get("resource_id") or item.id,
+        "resource_type": raw_meta.get("resource_type"),
+        "resource_label": raw_meta.get("resource_label"),
+        "resource_kind": raw_meta.get("resource_kind"),
+        "container": raw_meta.get("container", False),
+        "canonical_url_available": raw_meta.get(
+            "canonical_url_available", bool(item.url)
+        ),
+        "title": item.title,
+        "author": item.author,
+        "published_at": item.published_at,
+        "published_hint": raw_meta.get("published_hint"),
+        "duration": raw_meta.get("duration"),
+        "view_count": raw_meta.get("view_count") or raw_meta.get("views"),
+        "caption_status": raw_meta.get("caption_status") or "unknown",
+        "process_status": raw_meta.get("process_status") or "discovered",
+        "discovery_only": True,
+        "source_type": item.source_type,
+        "media_kind": raw_meta.get("media_kind"),
+        "aweme_type": raw_meta.get("aweme_type"),
+        "image_count": raw_meta.get("image_count"),
+        "discovery_provider": provider,
+        "discovery_limit": limit,
+        "source_exhausted": raw_meta.get("source_exhausted"),
+        "page_count": raw_meta.get("page_count"),
+        "empty_page_count": raw_meta.get("empty_page_count"),
+        "duplicate_page_count": raw_meta.get("duplicate_page_count"),
+        "pagination_retry_count": raw_meta.get("pagination_retry_count"),
+    }
+
+
+def _collection_slug(collection_url: str) -> str | None:
+    parsed = urlparse(collection_url if "://" in collection_url else f"https://{collection_url}")
+    path_parts = [part for part in parsed.path.split("/") if part]
+    if path_parts:
+        if path_parts[0].startswith("@"):
+            return path_parts[0].lstrip("@")
+        if len(path_parts) >= 2 and path_parts[0] in {"channel", "c", "user"}:
+            return path_parts[1]
+    return parsed.netloc or None
+
+
+def _read_existing_manifest_keys(path: Path) -> set[str]:
+    if not path.exists():
+        return set()
+    keys: set[str] = set()
+    for line in path.read_text(encoding="utf-8", errors="replace").splitlines():
+        if not line.strip():
+            continue
+        try:
+            row = json.loads(line)
+        except json.JSONDecodeError:
+            continue
+        if isinstance(row, dict):
+            keys.add(_manifest_key(row))
+    return keys
+
+
+def _manifest_key(row: dict[str, Any]) -> str:
+    return str(
+        row.get("content_id")
+        or row.get("video_id")
+        or row.get("content_url")
+        or row.get("video_url")
+        or row.get("title")
+        or ""
+    )

openmd/core/models.py

@@ -0,0 +1,168 @@
+"""Core dataclasses shared by Openmd adapters and renderers."""
+
+from __future__ import annotations
+
+from dataclasses import dataclass, field
+from typing import Any, Literal
+
+
+InputType = Literal["single", "batch", "collection", "generic"]
+SourceType = Literal[
+    "article",
+    "video",
+    "audio",
+    "image_text",
+    "mixed",
+    "document",
+    "conversation",
+    "process",
+]
+Status = Literal["verified", "partial", "failed"]
+ComponentStatus = Literal[
+    "verified",
+    "partial",
+    "failed",
+    "retryable",
+    "unavailable",
+    "not_applicable",
+    "auth_challenge",
+]
+FailureClass = Literal[
+    "user_resolvable",
+    "code_resolvable",
+    "source_unavailable",
+    "runtime_transient",
+]
+SourceLevel = Literal[
+    "native_text",
+    "native_caption",
+    "auto_caption",
+    "platform_transcript",
+    "third_party_extractor",
+    "browser_rendered",
+    "manual_export",
+    "ocr",
+    "asr",
+    "media_asr",
+    "live_capture_asr",
+    "partial_extraction",
+]
+
+STATUS_VALUES: tuple[str, ...] = ("verified", "partial", "failed")
+FAILURE_CLASS_VALUES: tuple[str, ...] = (
+    "user_resolvable",
+    "code_resolvable",
+    "source_unavailable",
+    "runtime_transient",
+)
+SOURCE_LEVEL_VALUES: tuple[str, ...] = (
+    "native_text",
+    "native_caption",
+    "auto_caption",
+    "platform_transcript",
+    "third_party_extractor",
+    "browser_rendered",
+    "manual_export",
+    "ocr",
+    "asr",
+    "media_asr",
+    "live_capture_asr",
+    "partial_extraction",
+)
+COMPONENT_STATUS_VALUES: tuple[str, ...] = (
+    "verified",
+    "partial",
+    "failed",
+    "retryable",
+    "unavailable",
+    "not_applicable",
+    "auth_challenge",
+)
+
+
+@dataclass(frozen=True)
+class ExtractionComponent:
+    """One independently verifiable part of a composite extraction."""
+
+    id: str
+    kind: str
+    status: ComponentStatus
+    source_level: SourceLevel
+    backend: str
+    text_ref: str = "index.md#content"
+    warnings: list[str] = field(default_factory=list)
+    terminal_reason: str | None = None
+    error_code: str | None = None
+    failure_class: FailureClass | None = None
+
+
+@dataclass(frozen=True)
+class ContentItem:
+    platform: str
+    input_type: InputType
+    url: str
+    id: str | None = None
+    title: str | None = None
+    author: str | None = None
+    published_at: str | None = None
+    source_type: SourceType = "article"
+    raw_meta: dict[str, Any] = field(default_factory=dict)
+
+
+@dataclass(frozen=True)
+class TranscriptResult:
+    """V0 normalized extraction result.
+
+    The historical name is kept for CLI stability, but in the backend framework
+    this represents extracted text for video, article, audio, and document
+    sources. Future versions can promote the alias below to a dedicated
+    ExtractionResult model without changing the renderer contract.
+    """
+
+    text: str
+    status: Status
+    source_level: SourceLevel
+    backend: str
+    source_notes: list[str] = field(default_factory=list)
+    error_code: str | None = None
+    error_summary: str | None = None
+    title: str | None = None
+    author: str | None = None
+    published_at: str | None = None
+    metadata: dict[str, Any] = field(default_factory=dict)
+    extraction_contract_version: str | None = None
+    components: list[ExtractionComponent] = field(default_factory=list)
+
+    @property
+    def has_usable_text(self) -> bool:
+        return self.status in {"verified", "partial"} and bool(self.text.strip())
+
+    @property
+    def normalized_components(self) -> list[ExtractionComponent]:
+        if self.components:
+            return list(self.components)
+        return [
+            ExtractionComponent(
+                id="content",
+                kind="text",
+                status=self.status,
+                source_level=self.source_level,
+                backend=self.backend,
+                warnings=list(self.source_notes),
+            )
+        ]
+
+    @property
+    def has_terminal_gaps(self) -> bool:
+        return any(component.status == "unavailable" for component in self.normalized_components)
+
+
+ExtractionResult = TranscriptResult
+
+
+@dataclass(frozen=True)
+class MarkdownDocument:
+    frontmatter: dict[str, Any]
+    title: str
+    content: str
+    source_notes: list[str] = field(default_factory=list)

openmd/core/opencli_output.py

@@ -0,0 +1,34 @@
+"""Single boundary for OpenCLI's machine-readable stdout.
+
+OpenCLI 2.0 wraps JSON output as ``{"ok": true, "data": ...}`` and failures as
+``{"ok": false, "error": {...}}``. Provider parsers should only ever see the
+inner rows, so the envelope is removed here and nowhere else. Older bare JSON
+passes through unchanged, which keeps OpenCLI 1.x output and fixtures readable.
+"""
+
+from __future__ import annotations
+
+import json
+from typing import Any
+
+_ENVELOPE_KEYS = frozenset({"ok", "data", "error"})
+
+
+def is_opencli_envelope(payload: Any) -> bool:
+    return (
+        isinstance(payload, dict)
+        and isinstance(payload.get("ok"), bool)
+        and _ENVELOPE_KEYS.issuperset(payload)
+    )
+
+
+def unwrap_opencli_envelope(payload: Any) -> Any:
+    """Return successful envelope data; failures stay intact for error handling."""
+    if is_opencli_envelope(payload) and payload["ok"] and "data" in payload:
+        return payload["data"]
+    return payload
+
+
+def load_opencli_json(stdout: str) -> Any:
+    """``json.loads`` for OpenCLI stdout; raises ``JSONDecodeError`` the same way."""
+    return unwrap_opencli_envelope(json.loads(stdout))

openmd/core/operation_contract.py

@@ -0,0 +1,60 @@
+"""Static collection permissions shared by planning and CLI execution.
+
+This module must not construct providers or inspect credentials/session state.
+An approved product goal is not permission to run an unsupported operation.
+"""
+
+from __future__ import annotations
+
+from openmd.adapters.wechat_group.wx_cli import OPENCLI_WX_HISTORY_DISCOVERY_BACKEND
+from openmd.adapters.wechat_moments.wx_cli import OPENCLI_WX_SNS_FEED_DISCOVERY_BACKEND
+from openmd.adapters.weixin.discovery import WECHAT_ARTICLE_EXPORTER_HTTP_DISCOVERY_BACKEND
+from openmd.backends.bilibili import BILIBILI_NATIVE_DISCOVERY_BACKEND
+from openmd.backends.douyin import DOUYIN_OPENCLI_USER_VIDEOS_BACKEND, DOUYIN_OPENMD_CREATOR_VIDEOS_BACKEND
+from openmd.backends.xiaoe import OPENCLI_XIAOE_CATALOG_DISCOVERY_BACKEND
+from openmd.backends.xiaohongshu import (
+    OPENCLI_OPENMD_XIAOHONGSHU_CREATOR_NOTES_BACKEND,
+    OPENCLI_XIAOHONGSHU_USER_DISCOVERY_BACKEND,
+)
+from openmd.backends.xiaoyuzhou import OPENCLI_XIAOYUZHOU_EPISODES_DISCOVERY_BACKEND
+from openmd.backends.youtube_discovery import (
+    YOUTUBE_DATA_API_DISCOVERY_BACKEND,
+    YOUTUBE_DATA_API_PLAYLIST_DISCOVERY_BACKEND,
+)
+
+
+SCOPED_ALL_PROVIDERS: dict[str, frozenset[str | None]] = {
+    "weixin": frozenset({None, WECHAT_ARTICLE_EXPORTER_HTTP_DISCOVERY_BACKEND}),
+    "douyin": frozenset({None, DOUYIN_OPENMD_CREATOR_VIDEOS_BACKEND}),
+    "xiaohongshu": frozenset({None, OPENCLI_OPENMD_XIAOHONGSHU_CREATOR_NOTES_BACKEND}),
+}
+_YOUTUBE_ALL_PROVIDERS = frozenset(
+    {None, YOUTUBE_DATA_API_DISCOVERY_BACKEND, YOUTUBE_DATA_API_PLAYLIST_DISCOVERY_BACKEND}
+)
+
+
+def collect_all_allowed(
+    platform: str,
+    *,
+    browser_enabled: bool,
+    network_enabled: bool = False,
+    discovery_provider: str | None = None,
+) -> bool:
+    """Match current scoped CLI support; callers normalize provider aliases."""
+    if platform == "youtube":
+        return network_enabled and discovery_provider in _YOUTUBE_ALL_PROVIDERS
+    return browser_enabled and discovery_provider in SCOPED_ALL_PROVIDERS.get(platform, frozenset())
+
+
+# These are discovery IDs, deliberately separate from extraction bindings.
+COLLECTION_BINDINGS: dict[str, tuple[str, tuple[str, ...]]] = {
+    "bilibili": (BILIBILI_NATIVE_DISCOVERY_BACKEND, ("network",)),
+    "youtube": (YOUTUBE_DATA_API_DISCOVERY_BACKEND, ("network", "account")),
+    "weixin": (WECHAT_ARTICLE_EXPORTER_HTTP_DISCOVERY_BACKEND, ("browser",)),
+    "xiaoyuzhou": (OPENCLI_XIAOYUZHOU_EPISODES_DISCOVERY_BACKEND, ("browser",)),
+    "douyin": (DOUYIN_OPENCLI_USER_VIDEOS_BACKEND, ("browser",)),
+    "xiaoe": (OPENCLI_XIAOE_CATALOG_DISCOVERY_BACKEND, ("browser",)),
+    "xiaohongshu_creator": (OPENCLI_XIAOHONGSHU_USER_DISCOVERY_BACKEND, ("browser",)),
+    "wechat_group": (OPENCLI_WX_HISTORY_DISCOVERY_BACKEND, ("browser",)),
+    "wechat_moments": (OPENCLI_WX_SNS_FEED_DISCOVERY_BACKEND, ("browser",)),
+}