@sophiacyl/dsh-plugin-waves 0.0.0-stage → 0.1.0-beta.2

package/service/rover/models.py

@@ -0,0 +1,92 @@
+import asyncio
+from typing import Any, Dict, List, Literal, Optional, Tuple
+
+from msgspec import Struct
+
+
+class Message(Struct):
+    type: Optional[str] = None
+    data: Optional[Any] = None
+
+
+class MessageReceive(Struct):
+    bot_id: str = "Bot"
+    bot_self_id: str = ""
+    msg_id: str = ""
+    user_type: Literal["group", "direct", "channel", "sub_channel"] = "group"
+    group_id: Optional[str] = None
+    user_id: str = ""
+    sender: Dict[str, Any] = {}
+    user_pm: int = 6
+    content: List[Message] = []
+
+
+class Event(MessageReceive):
+    WS_BOT_ID: Optional[str] = None
+    task_id: str = ""
+    task_event: Optional[asyncio.Event] = None
+    real_bot_id: str = ""
+    raw_text: str = ""
+    command: str = ""
+    text: str = ""
+    image: Optional[str] = None
+    image_list: List[Any] = []
+    image_id: Optional[str] = None
+    image_id_list: List[str] = []
+    audio_id: Optional[str] = None
+    audio_id_list: List[str] = []
+    at: Optional[str] = None
+    at_list: List[Any] = []
+    is_tome: bool = False
+    reply: Optional[str] = None
+    reply_id: Optional[str] = None
+    node: Optional[List[Message]] = None
+    file_name: Optional[str] = None
+    file: Optional[str] = None
+    file_type: Optional[Literal["url", "base64"]] = None
+    regex_group: Tuple[str, ...] = ()
+    regex_dict: Dict[str, str] = {}
+    meta_event_type: Optional[str] = None
+    meta_event_data: Dict[str, Any] = {}
+
+    def __hash__(self) -> int:
+        return hash(
+            (
+                self.WS_BOT_ID,
+                self.bot_id,
+                self.bot_self_id,
+                self.user_id,
+                self.group_id,
+                self.user_type,
+            )
+        )
+
+    def __eq__(self, other: object) -> bool:
+        if not isinstance(other, Event):
+            return NotImplemented
+        return (
+            self.WS_BOT_ID,
+            self.bot_id,
+            self.bot_self_id,
+            self.user_id,
+            self.group_id,
+            self.user_type,
+        ) == (
+            other.WS_BOT_ID,
+            other.bot_id,
+            other.bot_self_id,
+            other.user_id,
+            other.group_id,
+            other.user_type,
+        )
+
+    @property
+    def session_id(self) -> str:
+        ws_bid = self.WS_BOT_ID or self.real_bot_id or self.bot_id or "0"
+        bid = self.bot_id if self.bot_id else "0"
+        bot_self_id = self.bot_self_id if self.bot_self_id else "0"
+        if self.user_type != "direct":
+            gid = self.group_id if self.group_id else "0"
+            return f"{ws_bid}:{bid}:{bot_self_id}:group:{gid}"
+        uid = self.user_id if self.user_id else "0"
+        return f"{ws_bid}:{bid}:{bot_self_id}:private:{uid}"

package/service/rover/native_media.py

@@ -0,0 +1,64 @@
+"""Bounded native image variants for dsh-go's authenticated asset route."""
+import asyncio
+import io
+from pathlib import Path
+from typing import Any, Dict, List
+from urllib.parse import urlparse
+
+from PIL import Image
+
+from rover.logger import logger
+from rover.media import MEDIA_DIR, media_path, render_png
+
+_NATIVE_LOCK = asyncio.Lock()
+# The bridge accepts <= 1 MiB per image. Leave room for future format overhead.
+_MAX_BYTES = 950_000
+
+
+def _image_variant(source: Path) -> Path:
+    target = source.with_name(source.stem + ".native.jpg")
+    if target.is_file() and target.stat().st_mtime >= source.stat().st_mtime:
+        return target
+    with Image.open(source) as raw:
+        image = raw.convert("RGB")
+        image.thumbnail((1600, 4096))
+        if image.width * image.height > 4_000_000:
+            scale = (4_000_000 / (image.width * image.height)) ** .5
+            image = image.resize((max(1, int(image.width * scale)), max(1, int(image.height * scale))))
+        for _ in range(6):
+            for quality in (88, 76, 62, 48):
+                buf = io.BytesIO()
+                image.save(buf, format="JPEG", quality=quality, optimize=True)
+                data = buf.getvalue()
+                if len(data) <= _MAX_BYTES:
+                    target.write_bytes(data)
+                    return target
+            image = image.resize((max(1, int(image.width * .8)), max(1, int(image.height * .8))))
+    raise ValueError("图片过大，请使用文字摘要")
+
+
+async def native_segments(segments: List[Dict[str, Any]]) -> List[Dict[str, Any]]:
+    """Keep the original segments; add images only for local generated media."""
+    out = []
+    for segment in segments:
+        seg = dict(segment)
+        if seg.get("type") == "node":
+            seg["items"] = await native_segments(seg.get("items") or [])
+        elif seg.get("type") in ("html", "image"):
+            url = str(seg.get("url") or "")
+            parsed = urlparse(url)
+            # Never turn model/user-controlled external URLs into server fetches.
+            if not parsed.scheme and not parsed.netloc and parsed.path.startswith("/api/media/"):
+                name = parsed.path.removeprefix("/api/media/")
+                if "/" not in name and "\\" not in name:
+                    try:
+                        async with _NATIVE_LOCK:
+                            source = await render_png(name) if seg["type"] == "html" else media_path(name)
+                            if source is not None:
+                                target = await asyncio.to_thread(_image_variant, source)
+                                seg["native_image"] = target.name
+                    except Exception as error:
+                        logger.warning(f"[原生卡片] 图片生成失败: {error}")
+                        seg["native_error"] = "图片暂不可用，请查看文字摘要"
+        out.append(seg)
+    return out

package/service/rover/ocr.py

@@ -0,0 +1,79 @@
+"""图片卡片的本地 OCR 摘要: 评分/面板等 PIL 出图对纯文本模型不可见, 抽出文字随 summary 给模型。"""
+
+import asyncio
+import hashlib
+from typing import Any, Dict, Optional
+
+from rover.logger import logger
+
+MIN_BYTES = 20 * 1024
+MAX_SIDE = 2000
+DIGEST_LIMIT = 800
+_CACHE_KEEP = 64
+
+_engine: Any = None
+_engine_failed = False
+_cache: Dict[str, str] = {}
+_lock = asyncio.Lock()
+
+
+def _get_engine():
+    global _engine, _engine_failed
+    if _engine is not None or _engine_failed:
+        return _engine
+    try:
+        from rapidocr import RapidOCR
+
+        # Headless OpenCV avoids X11/Qt dependencies on phone hosts. Bound ONNX
+        # worker pools so one screenshot cannot occupy every CPU core.
+        _engine = RapidOCR(params={
+            "EngineConfig.onnxruntime.intra_op_num_threads": 1,
+            "EngineConfig.onnxruntime.inter_op_num_threads": 1,
+            "Global.log_level": "warning",
+        })
+    except Exception as e:  # noqa: BLE001
+        _engine_failed = True
+        logger.warning(f"[OCR] rapidocr 不可用, 图片文字摘要关闭: {e}")
+    return _engine
+
+
+def _run(raw: bytes) -> str:
+    import cv2
+    import numpy as np
+
+    engine = _get_engine()
+    if engine is None:
+        return ""
+    img = cv2.imdecode(np.frombuffer(raw, dtype=np.uint8), cv2.IMREAD_COLOR)
+    if img is None:
+        return ""
+    h, w = img.shape[:2]
+    scale = MAX_SIDE / max(h, w)
+    if scale < 1:
+        img = cv2.resize(img, (int(w * scale), int(h * scale)))
+    result = engine(img)
+    lines = [str(text).strip() for text in result.txts or () if text]
+    text = " ".join(x for x in lines if x)
+    return text[:DIGEST_LIMIT] + " …" if len(text) > DIGEST_LIMIT else text
+
+
+async def image_digest(raw: Optional[bytes]) -> str:
+    """一张卡片图 → 单行文字摘要; 太小的图(头像等)与识别失败返回空串。"""
+    if not raw or len(raw) < MIN_BYTES:
+        return ""
+    key = hashlib.sha1(raw).hexdigest()
+    if key in _cache:
+        return _cache[key]
+    # 串行跑: OCR 吃 CPU, 并发多张反而互相拖慢
+    async with _lock:
+        if key in _cache:
+            return _cache[key]
+        try:
+            text = await asyncio.to_thread(_run, raw)
+        except Exception as e:  # noqa: BLE001
+            logger.warning(f"[OCR] 识别失败: {e}")
+            text = ""
+        if len(_cache) >= _CACHE_KEEP:
+            _cache.pop(next(iter(_cache)))
+        _cache[key] = text
+        return text

package/service/rover/pool.py

@@ -0,0 +1,43 @@
+"""线程池。to_thread 是装饰器：被装饰函数为协程函数时在线程内新建事件循环执行。"""
+
+import asyncio
+import functools
+import inspect
+from concurrent.futures import ThreadPoolExecutor
+from typing import Any, Awaitable, Callable, Coroutine, ParamSpec, TypeVar, cast, overload
+
+T = TypeVar("T")
+P = ParamSpec("P")
+
+_executor = ThreadPoolExecutor(max_workers=10)
+
+
+@overload
+def to_thread(func: Callable[P, Coroutine[Any, Any, T]]) -> Callable[P, Awaitable[T]]: ...
+
+
+@overload
+def to_thread(func: Callable[P, T]) -> Callable[P, Awaitable[T]]: ...
+
+
+def to_thread(func: Callable[..., Any]) -> Callable[..., Awaitable[Any]]:
+    @functools.wraps(func)
+    async def wrapper(*args: Any, **kwargs: Any) -> Any:
+        loop = asyncio.get_running_loop()
+
+        def sync_worker():
+            if inspect.iscoroutinefunction(func):
+                new_loop = asyncio.new_event_loop()
+                try:
+                    asyncio.set_event_loop(new_loop)
+                    return new_loop.run_until_complete(func(*args, **kwargs))
+                finally:
+                    new_loop.close()
+            return func(*args, **kwargs)
+
+        return await loop.run_in_executor(_executor, sync_worker)
+
+    return cast(Callable[..., Awaitable[Any]], wrapper)
+
+
+run_in_thread_pool = to_thread

package/service/rover/restart.py

@@ -0,0 +1,36 @@
+"""进程重启。退出码 75 交给宿主(dsh)重新拉起, 不要 execv。
+
+服务是 Node spawn 的 `python -m rover.main`。execv 用 sys.argv 会变成
+`python rover/main.py`, sys.path 不对, 进程起不来。
+"""
+
+import os
+import sys
+from typing import Any, Optional
+
+from rover.logger import logger
+
+# 与 lib/host/service.js 约定: 75 = 主动重启, 宿主马上再拉起
+RESTART_EXIT = 75
+
+
+async def restart_service(event: Optional[Any] = None, is_send: bool = True) -> None:
+    from rover.server import core_shutdown_execute
+
+    logger.info(f"[重启] 准备重启当前进程 pid={os.getpid()}")
+    if is_send and event is not None:
+        logger.info("[重启] 重启由会话触发，重启后无法回执")
+
+    try:
+        await core_shutdown_execute()
+    except Exception as e:
+        logger.warning(f"[重启] 关闭钩子执行异常: {e}")
+
+    try:
+        sys.stdout.flush()
+        sys.stderr.flush()
+    except Exception:
+        pass
+
+    logger.info(f"[重启] 退出 {RESTART_EXIT}, 由宿主重新拉起")
+    os._exit(RESTART_EXIT)

package/service/rover/segment.py

@@ -0,0 +1,143 @@
+"""消息段构造与归一化。语义对齐上游插件的既有预期, 尤其 List[str] → node。"""
+
+from base64 import b64encode
+from io import BytesIO
+from pathlib import Path
+from typing import List, Optional, Union
+
+import msgspec
+from PIL import Image
+
+from rover.media import HtmlBytes
+from rover.message_models import Button
+from rover.models import Message
+
+
+def process_buttons(
+    buttons: Union[List[Button], List[List[Button]]],
+) -> List[List[Button]]:
+    if not buttons:
+        return []
+    if isinstance(buttons[0], list):
+        return buttons  # type: ignore[return-value]
+    rows: List[List[Button]] = []
+    row: List[Button] = []
+    for btn in buttons:  # type: ignore[assignment]
+        row.append(btn)  # type: ignore[arg-type]
+        if len(row) >= 3:
+            rows.append(row)
+            row = []
+    if row:
+        rows.append(row)
+    return rows
+
+
+class MessageSegment:
+    def __add__(self, other):
+        return [self, other]
+
+    @staticmethod
+    def image(img: Union[str, Image.Image, bytes, Path]) -> Message:
+        if isinstance(img, HtmlBytes):
+            return Message(type="html", data=img.html)
+        if isinstance(img, Image.Image):
+            img = img.convert("RGB")
+            result_buffer = BytesIO()
+            img.save(result_buffer, format="PNG", subsampling=0)
+            img = result_buffer.getvalue()
+        elif isinstance(img, bytes):
+            pass
+        elif isinstance(img, Path):
+            img = img.read_bytes()
+        elif isinstance(img, (bytearray, memoryview)):
+            img = bytes(img)
+        else:
+            if img.startswith("http"):
+                return Message(type="image", data=f"link://{img}")
+            if img.startswith("base64://"):
+                return Message(type="image", data=img)
+            with open(img, "rb") as fp:
+                img = fp.read()
+
+        return Message(type="image", data=f"base64://{b64encode(img).decode()}")
+
+    @staticmethod
+    def text(content: str) -> Message:
+        return Message(type="text", data=content)
+
+    @staticmethod
+    def buttons(
+        buttons: Optional[Union[List[Button], List[List[Button]]]] = None,
+    ) -> Message:
+        if buttons:
+            buttons = process_buttons(buttons)
+        return Message(type="buttons", data=msgspec.to_builtins(buttons))
+
+    @staticmethod
+    def at(user: str) -> Message:
+        return Message(type="at", data=user)
+
+    @staticmethod
+    def node(
+        content_list: Union[List[Message], List[str], List[bytes]],
+    ) -> Message:
+        msg_list: List[Message] = []
+        for msg in content_list:
+            if isinstance(msg, Message):
+                msg_list.append(msg)
+            elif isinstance(msg, (bytes, bytearray, memoryview)):
+                msg_list.append(MessageSegment.image(bytes(msg)))
+            else:
+                if msg.startswith("base64://"):
+                    msg_list.append(Message(type="image", data=msg))
+                elif msg.startswith("http"):
+                    msg_list.append(Message(type="image", data=f"link://{msg}"))
+                else:
+                    msg_list.append(MessageSegment.text(msg))
+        return Message(type="node", data=msg_list)
+
+    @staticmethod
+    def file(content: Union[Path, str, bytes], file_name: str) -> Message:
+        if isinstance(content, Path):
+            file = content.read_bytes()
+        elif isinstance(content, bytes):
+            file = content
+        elif isinstance(content, (bytearray, memoryview)):
+            file = bytes(content)
+        else:
+            if content.startswith("http"):
+                return Message(type="file", data=f"{file_name}|link://{content}")
+            with open(content, "rb") as fp:
+                file = fp.read()
+        return Message(type="file", data=f"{file_name}|{b64encode(file).decode()}")
+
+
+async def _convert_one(message: Union[Message, str, bytes]) -> List[Message]:
+    if isinstance(message, Message):
+        if message.type == "node" and isinstance(message.data, list):
+            return [MessageSegment.node(message.data)]
+        return [message]
+    if isinstance(message, HtmlBytes):
+        return [Message(type="html", data=message.html)]
+    if isinstance(message, str):
+        if message.startswith("base64://"):
+            return [Message(type="image", data=message)]
+        return [Message(type="text", data=message)]
+    if isinstance(message, (bytes, bytearray, memoryview)):
+        return [MessageSegment.image(bytes(message))]
+    return [Message(type="text", data=str(message))]
+
+
+async def convert_message(
+    message: Union[Message, List[Message], List[str], str, bytes],
+    bot_id: str = "",
+    bot_self_id: str = "",
+) -> List[Message]:
+    if isinstance(message, list):
+        if message and all(isinstance(x, str) for x in message):
+            return [MessageSegment.node(message)]
+        _message: List[Message] = []
+        for i in message:
+            _message.extend(await _convert_one(i))
+        return _message
+    return await _convert_one(message)

package/service/rover/server.py

@@ -0,0 +1,131 @@
+"""启动/关闭钩子注册与执行。
+
+三类钩子：
+- on_core_start_before: 阻塞式，服务开始接受连接前必须跑完（数据库迁移等）
+- on_core_start: 启动后执行
+- on_core_shutdown: 关闭前执行
+
+同一 priority 的钩子并发执行，全部完成后再进入下一 priority；单个钩子失败只记日志。
+"""
+
+import asyncio
+from dataclasses import dataclass, field
+from itertools import groupby
+from typing import Any, Callable, List, Optional, Set, TypeVar, overload
+
+from rover.logger import logger
+
+F = TypeVar("F", bound=Callable[..., Any])
+
+
+@dataclass
+class _DefHook:
+    priority: int
+    func: Callable = field(compare=False)
+
+    def __hash__(self) -> int:
+        return hash(self.func)
+
+    def __eq__(self, other: object) -> bool:
+        if isinstance(other, _DefHook):
+            return self.func is other.func
+        return NotImplemented
+
+    def __lt__(self, other: "_DefHook") -> bool:
+        return self.priority < other.priority
+
+
+core_start_def: Set[_DefHook] = set()
+core_start_before_def: Set[_DefHook] = set()
+core_shutdown_def: Set[_DefHook] = set()
+
+
+@overload
+def on_core_start(func: F, /) -> F: ...
+
+
+@overload
+def on_core_start(func: None = None, /, priority: int = 0) -> Callable[[F], F]: ...
+
+
+def on_core_start(func: Optional[Callable] = None, /, priority: int = 0):
+    def decorator(f: Callable) -> Callable:
+        core_start_def.add(_DefHook(priority=priority, func=f))
+        return f
+
+    if func is not None:
+        return decorator(func)
+    return decorator
+
+
+@overload
+def on_core_start_before(func: F, /) -> F: ...
+
+
+@overload
+def on_core_start_before(func: None = None, /, priority: int = 0) -> Callable[[F], F]: ...
+
+
+def on_core_start_before(func: Optional[Callable] = None, /, priority: int = 0):
+    def decorator(f: Callable) -> Callable:
+        core_start_before_def.add(_DefHook(priority=priority, func=f))
+        return f
+
+    if func is not None:
+        return decorator(func)
+    return decorator
+
+
+@overload
+def on_core_shutdown(func: F, /) -> F: ...
+
+
+@overload
+def on_core_shutdown(func: None = None, /, priority: int = 0) -> Callable[[F], F]: ...
+
+
+def on_core_shutdown(func: Optional[Callable] = None, /, priority: int = 0):
+    def decorator(f: Callable) -> Callable:
+        core_shutdown_def.add(_DefHook(priority=priority, func=f))
+        return f
+
+    if func is not None:
+        return decorator(func)
+    return decorator
+
+
+async def _execute(hooks: Set[_DefHook], tag: str) -> None:
+    try:
+        sorted_defs: List[_DefHook] = sorted(hooks)
+    except Exception as e:
+        logger.exception(f"[{tag}] 钩子排序失败: {e}")
+        return
+
+    logger.info(f"[{tag}] 执行钩子: {[hook.func.__name__ for hook in sorted_defs]}")
+    for _, group in groupby(sorted_defs, key=lambda h: h.priority):
+        group_hooks = list(group)
+        results = await asyncio.gather(
+            *[
+                (hook.func() if asyncio.iscoroutinefunction(hook.func) else asyncio.to_thread(hook.func))
+                for hook in group_hooks
+            ],
+            return_exceptions=True,
+        )
+        for hook, result in zip(group_hooks, results):
+            if isinstance(result, BaseException):
+                logger.error(
+                    f"[{tag}] 钩子 {hook.func.__name__} 执行失败: {result}",
+                    exc_info=result,
+                )
+
+
+async def core_start_before_execute() -> None:
+    await _execute(core_start_before_def, "启动前钩子")
+
+
+async def core_start_execute() -> None:
+    await _execute(core_start_def, "启动钩子")
+
+
+async def core_shutdown_execute() -> None:
+    await _execute(core_shutdown_def, "关闭钩子")

package/service/rover/status/models.py

@@ -0,0 +1,10 @@
+"""插件状态结构。"""
+
+from typing import Awaitable, Callable, Dict, TypedDict, Union
+
+from PIL import Image
+
+
+class PluginStatus(TypedDict):
+    icon: Image.Image
+    status: Dict[str, Callable[..., Awaitable[Union[str, int, float]]]]

package/service/rover/status/plugin_status.py

@@ -0,0 +1,17 @@
+"""插件状态注册表。"""
+
+from typing import Awaitable, Callable, Dict, Union
+
+from PIL import Image
+
+from .models import PluginStatus
+
+plugins_status: Dict[str, PluginStatus] = {}
+
+
+def register_status(
+    ICON: Image.Image,
+    plugin_name: str,
+    plugin_status: Dict[str, Callable[..., Awaitable[Union[str, int, float]]]],
+):
+    plugins_status[plugin_name] = {"icon": ICON, "status": plugin_status}