ksaa 2025.4.17.2__py3-none-any.whl → 2025.4.26.0__py3-none-any.whl

kotonebot/backend/bot.py

@@ -207,6 +207,7 @@ class KotoneBot:
         """
         self.check_backend()
         init_context(config_type=self.config_type)
+        vars.interrupted.clear()
 
         if by_priority:
             tasks = sorted(tasks, key=lambda x: x.priority, reverse=True)
@@ -249,7 +250,14 @@ class KotoneBot:
     def run_all(self) -> None:
         return self.run(list(task_registry.values()), by_priority=True)
 
-    def start_all(self) -> RunStatus:
+    def start(self, tasks: list[Task], *, by_priority: bool = True) -> RunStatus:
+        """
+        在单独的线程中按优先级顺序运行指定的任务。
+
+        :param tasks: 要运行的任务列表
+        :param by_priority: 是否按优先级排序
+        :return: 运行状态对象
+        """
         run_status = RunStatus(running=True)
         def _on_finished():
             run_status.running = False
@@ -271,7 +279,14 @@ class KotoneBot:
 
         self.events.task_status_changed += _on_task_status_changed
         self.events.finished += _on_finished
-        thread = threading.Thread(target=self.run_all)
+        thread = threading.Thread(target=lambda: self.run(tasks, by_priority=by_priority))
         thread.start()
         return run_status
-        
+
+    def start_all(self) -> RunStatus:
+        """
+        在单独的线程中运行所有任务。
+
+        :return: 运行状态对象
+        """
+        return self.start(list(task_registry.values()), by_priority=True)

kotonebot/client/factory.py

@@ -4,12 +4,13 @@ from typing import Literal
 from .implements.adb import AdbImpl
 from .implements.adb_raw import AdbRawImpl
 from .implements.windows import WindowsImpl
+from .implements.remote_windows import RemoteWindowsImpl
 from .implements.uiautomator2 import UiAutomator2Impl
 from .device import Device, AndroidDevice, WindowsDevice
 
 from adbutils import adb
 
-DeviceImpl = Literal['adb', 'adb_raw', 'uiautomator2', 'windows']
+DeviceImpl = Literal['adb', 'adb_raw', 'uiautomator2', 'windows', 'remote_windows']
 
 def create_device(
     addr: str,
@@ -40,4 +41,18 @@ def create_device(
         device = WindowsDevice()
         device._touch = WindowsImpl(device)
         device._screenshot = WindowsImpl(device)
+    elif impl == 'remote_windows':
+        # For remote_windows, addr should be in the format 'host:port'
+        if ':' not in addr:
+            raise ValueError(f"Invalid address format for remote_windows: {addr}. Expected format: 'host:port'")
+        host, port_str = addr.split(':', 1)
+        try:
+            port = int(port_str)
+        except ValueError:
+            raise ValueError(f"Invalid port in address: {port_str}")
+
+        device = WindowsDevice()
+        remote_impl = RemoteWindowsImpl(device, host, port)
+        device._touch = remote_impl
+        device._screenshot = remote_impl
     return device

kotonebot/client/implements/remote_windows.py

@@ -0,0 +1,197 @@
+"""
+Remote Windows implementation using XML-RPC.
+
+This module provides:
+1. RemoteWindowsImpl - Client implementation that connects to a remote Windows machine
+2. RemoteWindowsServer - Server implementation that exposes a WindowsImpl instance via XML-RPC
+"""
+
+import io
+import base64
+import logging
+import xmlrpc.client
+import xmlrpc.server
+from typing import Literal, cast, Any, Tuple
+from functools import cached_property
+from threading import Thread
+
+import cv2
+import numpy as np
+from cv2.typing import MatLike
+
+from kotonebot import logging
+from ..device import Device, WindowsDevice
+from ..protocol import Touchable, Screenshotable
+from .windows import WindowsImpl
+
+logger = logging.getLogger(__name__)
+
+def _encode_image(image: MatLike) -> str:
+    """Encode an image as a base64 string."""
+    success, buffer = cv2.imencode('.png', image)
+    if not success:
+        raise RuntimeError("Failed to encode image")
+    return base64.b64encode(buffer.tobytes()).decode('ascii')
+
+def _decode_image(encoded_image: str) -> MatLike:
+    """Decode a base64 string to an image."""
+    buffer = base64.b64decode(encoded_image)
+    image = cv2.imdecode(np.frombuffer(buffer, np.uint8), cv2.IMREAD_COLOR)
+    if image is None:
+        raise RuntimeError("Failed to decode image")
+    return image
+
+class RemoteWindowsServer:
+    """
+    XML-RPC server that exposes a WindowsImpl instance.
+
+    This class wraps a WindowsImpl instance and exposes its methods via XML-RPC.
+    """
+
+    def __init__(self, host="localhost", port=8000):
+        """Initialize the server with the given host and port."""
+        self.host = host
+        self.port = port
+        self.server = None
+        self.device = WindowsDevice()
+        self.impl = WindowsImpl(self.device)
+        self.device._screenshot = self.impl
+        self.device._touch = self.impl
+
+    def start(self):
+        """Start the XML-RPC server."""
+        self.server = xmlrpc.server.SimpleXMLRPCServer(
+            (self.host, self.port),
+            logRequests=True,
+            allow_none=True
+        )
+        self.server.register_instance(self)
+        logger.info(f"Starting RemoteWindowsServer on {self.host}:{self.port}")
+        self.server.serve_forever()
+
+    def start_in_thread(self):
+        """Start the XML-RPC server in a separate thread."""
+        thread = Thread(target=self.start, daemon=True)
+        thread.start()
+        return thread
+
+    # Screenshotable methods
+
+    def screenshot(self) -> str:
+        """Take a screenshot and return it as a base64-encoded string."""
+        try:
+            image = self.impl.screenshot()
+            return _encode_image(image)
+        except Exception as e:
+            logger.error(f"Error taking screenshot: {e}")
+            raise
+
+    def get_screen_size(self) -> tuple[int, int]:
+        """Get the screen size."""
+        return self.impl.screen_size
+
+    def detect_orientation(self) -> str | None:
+        """Detect the screen orientation."""
+        return self.impl.detect_orientation()
+
+    # Touchable methods
+
+    def click(self, x: int, y: int) -> bool:
+        """Click at the given coordinates."""
+        try:
+            self.impl.click(x, y)
+            return True
+        except Exception as e:
+            logger.error(f"Error clicking at ({x}, {y}): {e}")
+            return False
+
+    def swipe(self, x1: int, y1: int, x2: int, y2: int, duration: float | None = None) -> bool:
+        """Swipe from (x1, y1) to (x2, y2)."""
+        try:
+            self.impl.swipe(x1, y1, x2, y2, duration)
+            return True
+        except Exception as e:
+            logger.error(f"Error swiping from ({x1}, {y1}) to ({x2}, {y2}): {e}")
+            return False
+
+    # Other methods
+
+    def get_scale_ratio(self) -> float:
+        """Get the scale ratio."""
+        return self.impl.scale_ratio
+
+    def ping(self) -> bool:
+        """Check if the server is alive."""
+        return True
+
+
+class RemoteWindowsImpl(Touchable, Screenshotable):
+    """
+    Client implementation that connects to a remote Windows machine via XML-RPC.
+
+    This class implements the same interfaces as WindowsImpl but forwards all
+    method calls to a remote server.
+    """
+
+    def __init__(self, device: Device, host="localhost", port=8000):
+        """Initialize the client with the given device, host, and port."""
+        self.device = device
+        self.host = host
+        self.port = port
+        self.proxy = xmlrpc.client.ServerProxy(
+            f"http://{host}:{port}/",
+            allow_none=True
+        )
+        # Test connection
+        try:
+            if not self.proxy.ping():
+                raise ConnectionError(f"Failed to connect to RemoteWindowsServer at {host}:{port}")
+            logger.info(f"Connected to RemoteWindowsServer at {host}:{port}")
+        except Exception as e:
+            raise ConnectionError(f"Failed to connect to RemoteWindowsServer at {host}:{port}: {e}")
+
+    @cached_property
+    def scale_ratio(self) -> float:
+        """Get the scale ratio from the remote server."""
+        return cast(float, self.proxy.get_scale_ratio())
+
+    @property
+    def screen_size(self) -> tuple[int, int]:
+        """Get the screen size from the remote server."""
+        return cast(Tuple[int, int], self.proxy.get_screen_size())
+
+    def detect_orientation(self) -> None | Literal['portrait'] | Literal['landscape']:
+        """Detect the screen orientation from the remote server."""
+        return cast(None | Literal['portrait'] | Literal['landscape'], self.proxy.detect_orientation())
+
+    def screenshot(self) -> MatLike:
+        """Take a screenshot from the remote server."""
+        encoded_image = cast(str, self.proxy.screenshot())
+        return _decode_image(encoded_image)
+
+    def click(self, x: int, y: int) -> None:
+        """Click at the given coordinates on the remote server."""
+        if not self.proxy.click(x, y):
+            raise RuntimeError(f"Failed to click at ({x}, {y})")
+
+    def swipe(self, x1: int, y1: int, x2: int, y2: int, duration: float | None = None) -> None:
+        """Swipe from (x1, y1) to (x2, y2) on the remote server."""
+        if not self.proxy.swipe(x1, y1, x2, y2, duration):
+            raise RuntimeError(f"Failed to swipe from ({x1}, {y1}) to ({x2}, {y2})")
+
+
+if __name__ == "__main__":
+    import argparse
+
+    parser = argparse.ArgumentParser(description="Remote Windows XML-RPC Server")
+    parser.add_argument("--host", default="0.0.0.0", help="Host to bind to")
+    parser.add_argument("--port", type=int, default=8000, help="Port to bind to")
+    args = parser.parse_args()
+
+    logging.basicConfig(level=logging.INFO)
+
+    server = RemoteWindowsServer(args.host, args.port)
+    try:
+        server.start()
+    except KeyboardInterrupt:
+        logger.info("Server stopped by user")

kotonebot/config/base_config.py

@@ -22,9 +22,11 @@ class BackendConfig(ConfigBaseModel):
     雷电模拟器需要设置正确的模拟器名，否则 自动启动模拟器 功能将无法正常工作。
     其他功能不受影响。
     """
-    screenshot_impl: Literal['adb', 'adb_raw', 'uiautomator2', 'windows'] = 'adb'
+    screenshot_impl: Literal['adb', 'adb_raw', 'uiautomator2', 'windows', 'remote_windows'] = 'adb'
     """
     截图方法。暂时推荐使用【adb】截图方式。
+
+    如果使用 remote_windows，需要在 adb_ip 中填写远程 Windows 的 IP 地址，在 adb_port 中填写远程 Windows 的端口号。
     """
     check_emulator: bool = False
     """
@@ -72,7 +74,7 @@ class UserConfig(ConfigBaseModel, Generic[T]):
 
 
 class RootConfig(ConfigBaseModel, Generic[T]):
-    version: int = 3
+    version: int = 4
     """配置版本。"""
     user_configs: list[UserConfig[T]] = []
     """用户配置。"""