roborock-cli 0.1.1__py3-none-any.whl

roborock_cli/__init__.py

@@ -0,0 +1,3 @@
+"""roborock-cli - CLI 控制工具，让 Claude 或用户控制石头扫地机"""
+
+__version__ = "0.1.1"

roborock_cli/__main__.py

@@ -0,0 +1,76 @@
+"""
+CLI 入口
+
+主入口模式：
+  roborock-cli              → 显示帮助（CLI 为主）
+  roborock-cli auth         → 交互式认证
+  roborock-cli devices      → 列出设备
+  roborock-cli status       → 获取状态
+  ...
+  roborock-cli mcp          → 启动 MCP stdio server（降级为子命令）
+"""
+
+import argparse
+import sys
+
+from . import __version__
+
+
+def main():
+    parser = argparse.ArgumentParser(
+        prog="roborock-cli",
+        description="Roborock 扫地机控制工具",
+        epilog="使用 'roborock-cli <command> --help' 查看子命令详情",
+    )
+    parser.add_argument("--version", "-V", action="version", version=f"%(prog)s {__version__}")
+    subparsers = parser.add_subparsers(dest="command")
+
+    # CLI 子命令（主入口）
+    from .cli import add_cli_subparsers
+    add_cli_subparsers(subparsers)
+
+    # MCP 子命令（降级）
+    mcp_parser = subparsers.add_parser("mcp", help="启动 MCP stdio server")
+    mcp_parser.set_defaults(func=cmd_mcp)
+
+    args = parser.parse_args()
+
+    if args.command is None:
+        # 无参数时显示帮助
+        parser.print_help()
+        sys.exit(0)
+    elif hasattr(args, "func"):
+        # 执行子命令
+        from .cli import CLIError, format_error
+        try:
+            args.func(args)
+        except CLIError as e:
+            print(format_error(e))
+            sys.exit(e.exit_code)
+        except KeyboardInterrupt:
+            sys.exit(130)
+    else:
+        parser.error(f"未知子命令: {args.command}")
+
+
+def cmd_mcp(args):
+    """启动 MCP stdio server"""
+    import anyio
+    from .server import mcp
+
+    # Windows 的 ProactorEventLoop 不支持 add_reader/add_writer，
+    # 而 aiomqtt (paho-mqtt) 依赖这些方法。
+    # mcp.run() 内部调用 anyio.run() 但不传 loop_factory，
+    # 所以直接调用 anyio.run() 显式指定 SelectorEventLoop。
+    # MCP stdio transport 用 anyio.wrap_file()（线程模式），不受影响。
+    if sys.platform == "win32":
+        import asyncio
+        backend_options = {"loop_factory": asyncio.SelectorEventLoop}
+    else:
+        backend_options = {}
+
+    anyio.run(mcp.run_stdio_async, backend_options=backend_options)
+
+
+if __name__ == "__main__":
+    main()

roborock_cli/_vendor/VERSION

@@ -0,0 +1,6 @@
+python-roborock version: 4.20.0
+Updated at: 2026-03-12T14:10:00+08:00
+
+Applied patches:
+- v1_channel_callback.patch: 修复 V1Channel.unsub() 未清除 callback
+- file_cache_empty_file.patch: 修复空缓存文件导致 EOFError

roborock_cli/_vendor/roborock/__init__.py

@@ -0,0 +1,27 @@
+"""Roborock API.
+
+.. include:: ../README.md
+"""
+
+from roborock_cli._vendor.roborock.data import *
+from roborock_cli._vendor.roborock.exceptions import *
+from roborock_cli._vendor.roborock.roborock_typing import *
+
+from . import (
+    const,
+    data,
+    devices,
+    exceptions,
+    roborock_typing,
+    web_api,
+)
+
+__all__ = [
+    "devices",
+    "data",
+    "map",
+    "web_api",
+    "roborock_typing",
+    "exceptions",
+    "const",
+]

roborock_cli/_vendor/roborock/broadcast_protocol.py

@@ -0,0 +1,114 @@
+from __future__ import annotations
+
+import asyncio
+import hashlib
+import json
+import logging
+from asyncio import BaseTransport, Lock
+
+from construct import (  # type: ignore
+    Bytes,
+    Checksum,
+    GreedyBytes,
+    Int16ub,
+    Int32ub,
+    Prefixed,
+    RawCopy,
+    Struct,
+)
+from Crypto.Cipher import AES
+
+from roborock_cli._vendor.roborock import RoborockException
+from roborock_cli._vendor.roborock.data import BroadcastMessage
+from roborock_cli._vendor.roborock.protocol import EncryptionAdapter, Utils, _Parser
+
+_LOGGER = logging.getLogger(__name__)
+
+BROADCAST_TOKEN = b"qWKYcdQWrbm9hPqe"
+
+
+class RoborockProtocol(asyncio.DatagramProtocol):
+    def __init__(self, timeout: int = 5):
+        self.timeout = timeout
+        self.transport: BaseTransport | None = None
+        self.devices_found: list[BroadcastMessage] = []
+        self._mutex = Lock()
+
+    def datagram_received(self, data: bytes, _):
+        """Handle incoming broadcast datagrams."""
+        try:
+            version = data[:3]
+            if version == b"L01":
+                [parsed_msg], _ = L01Parser.parse(data)
+                encrypted_payload = parsed_msg.payload
+                if encrypted_payload is None:
+                    raise RoborockException("No encrypted payload found in broadcast message")
+                ciphertext = encrypted_payload[:-16]
+                tag = encrypted_payload[-16:]
+
+                key = hashlib.sha256(BROADCAST_TOKEN).digest()
+                iv_digest_input = data[:9]
+                digest = hashlib.sha256(iv_digest_input).digest()
+                iv = digest[:12]
+
+                cipher = AES.new(key, AES.MODE_GCM, nonce=iv)
+                decrypted_payload_bytes = cipher.decrypt_and_verify(ciphertext, tag)
+                json_payload = json.loads(decrypted_payload_bytes)
+                parsed_message = BroadcastMessage(duid=json_payload["duid"], ip=json_payload["ip"], version=version)
+                _LOGGER.debug(f"Received L01 broadcast: {parsed_message}")
+                self.devices_found.append(parsed_message)
+            else:
+                # Fallback to the original protocol parser for other versions
+                [broadcast_message], _ = BroadcastParser.parse(data)
+                if broadcast_message.payload:
+                    json_payload = json.loads(broadcast_message.payload)
+                    parsed_message = BroadcastMessage(duid=json_payload["duid"], ip=json_payload["ip"], version=version)
+                    _LOGGER.debug(f"Received broadcast: {parsed_message}")
+                    self.devices_found.append(parsed_message)
+        except Exception as e:
+            _LOGGER.warning(f"Failed to decode message: {data!r}. Error: {e}")
+
+    async def discover(self) -> list[BroadcastMessage]:
+        async with self._mutex:
+            try:
+                loop = asyncio.get_event_loop()
+                self.transport, _ = await loop.create_datagram_endpoint(lambda: self, local_addr=("0.0.0.0", 58866))
+                await asyncio.sleep(self.timeout)
+                return self.devices_found
+            finally:
+                self.close()
+                self.devices_found = []
+
+    def close(self):
+        self.transport.close() if self.transport else None
+
+
+_BroadcastMessage = Struct(
+    "message"
+    / RawCopy(
+        Struct(
+            "version" / Bytes(3),
+            "seq" / Int32ub,
+            "protocol" / Int16ub,
+            "payload" / EncryptionAdapter(lambda ctx: BROADCAST_TOKEN),
+        )
+    ),
+    "checksum" / Checksum(Int32ub, Utils.crc, lambda ctx: ctx.message.data),
+)
+
+_L01BroadcastMessage = Struct(
+    "message"
+    / RawCopy(
+        Struct(
+            "version" / Bytes(3),
+            "field1" / Bytes(4),  # Unknown field
+            "field2" / Bytes(2),  # Unknown field
+            "payload" / Prefixed(Int16ub, GreedyBytes),  # Encrypted payload with length prefix
+        )
+    ),
+    "checksum" / Checksum(Int32ub, Utils.crc, lambda ctx: ctx.message.data),
+)
+
+
+BroadcastParser: _Parser = _Parser(_BroadcastMessage, False)
+L01Parser: _Parser = _Parser(_L01BroadcastMessage, False)

roborock_cli/_vendor/roborock/callbacks.py

@@ -0,0 +1,130 @@
+"""Module for managing callback utility functions."""
+
+import logging
+from collections.abc import Callable
+from typing import Generic, TypeVar
+
+_LOGGER = logging.getLogger(__name__)
+
+K = TypeVar("K")
+V = TypeVar("V")
+
+
+def safe_callback(
+    callback: Callable[[V], None], logger: logging.Logger | logging.LoggerAdapter | None = None
+) -> Callable[[V], None]:
+    """Wrap a callback to catch and log exceptions.
+
+    This is useful for ensuring that errors in callbacks do not propagate
+    and cause unexpected behavior. Any failures during callback execution will be logged.
+    """
+
+    if logger is None:
+        logger = _LOGGER
+
+    def wrapper(value: V) -> None:
+        try:
+            callback(value)
+        except Exception as ex:  # noqa: BLE001
+            logger.error("Uncaught error in callback '%s': %s", callback.__name__, ex)
+
+    return wrapper
+
+
+class CallbackMap(Generic[K, V]):
+    """A mapping of callbacks for specific keys.
+
+    This allows for registering multiple callbacks for different keys and invoking them
+    when a value is received for a specific key.
+    """
+
+    def __init__(self, logger: logging.Logger | logging.LoggerAdapter | None = None) -> None:
+        self._callbacks: dict[K, list[Callable[[V], None]]] = {}
+        self._logger = logger or _LOGGER
+
+    def keys(self) -> list[K]:
+        """Get all keys in the callback map."""
+        return list(self._callbacks.keys())
+
+    def add_callback(self, key: K, callback: Callable[[V], None]) -> Callable[[], None]:
+        """Add a callback for a specific key.
+
+        Any failures during callback execution will be logged.
+
+        Returns a callable that can be used to remove the callback.
+        """
+        self._callbacks.setdefault(key, []).append(callback)
+
+        def remove_callback() -> None:
+            """Remove the callback for the specific key."""
+            if cb_list := self._callbacks.get(key):
+                cb_list.remove(callback)
+                if not cb_list:
+                    del self._callbacks[key]
+
+        return remove_callback
+
+    def get_callbacks(self, key: K) -> list[Callable[[V], None]]:
+        """Get all callbacks for a specific key."""
+        return self._callbacks.get(key, [])
+
+    def __call__(self, key: K, value: V) -> None:
+        """Invoke all callbacks for a specific key."""
+        for callback in self.get_callbacks(key):
+            safe_callback(callback, self._logger)(value)
+
+
+class CallbackList(Generic[V]):
+    """A list of callbacks that can be invoked.
+
+    This combines a list of callbacks into a single callable. Callers can add
+    additional callbacks to the list at any time.
+    """
+
+    def __init__(self, logger: logging.Logger | logging.LoggerAdapter | None = None) -> None:
+        self._callbacks: list[Callable[[V], None]] = []
+        self._logger = logger or _LOGGER
+
+    def add_callback(self, callback: Callable[[V], None]) -> Callable[[], None]:
+        """Add a callback to the list.
+
+        Any failures during callback execution will be logged.
+
+        Returns a callable that can be used to remove the callback.
+        """
+        self._callbacks.append(callback)
+
+        return lambda: self._callbacks.remove(callback)
+
+    def __call__(self, value: V) -> None:
+        """Invoke all callbacks in the list."""
+        for callback in self._callbacks:
+            safe_callback(callback, self._logger)(value)
+
+
+def decoder_callback(
+    decoder: Callable[[K], list[V]],
+    callback: Callable[[V], None],
+    logger: logging.Logger | logging.LoggerAdapter | None = None,
+) -> Callable[[K], None]:
+    """Create a callback that decodes messages using a decoder and invokes a callback.
+
+    The decoder converts a value into a list of values. The callback is then invoked
+    for each value in the list.
+
+    Any failures during decoding or invoking the callbacks will be logged.
+    """
+    if logger is None:
+        logger = _LOGGER
+
+    safe_cb = safe_callback(callback, logger)
+
+    def wrapper(data: K) -> None:
+        if not (messages := decoder(data)):
+            logger.debug("Failed to decode message: %s", data)
+            return
+        for message in messages:
+            logger.debug("Decoded message: %s", message)
+            safe_cb(message)
+
+    return wrapper