ksaa 2025.6.8.0__py3-none-any.whl → 2025.6.23.0__py3-none-any.whl

kotonebot/client/host/mumu12_host.py

@@ -2,13 +2,15 @@ import os
 import json
 import subprocess
 from functools import lru_cache
-from typing import Any
+from typing import Any, cast
 from typing_extensions import override
 
 from kotonebot import logging
 from kotonebot.client import DeviceImpl, Device
+from kotonebot.client.registration import AdbBasedImpl, create_device
+from kotonebot.client.implements.adb import AdbImplConfig
 from kotonebot.util import Countdown, Interval
-from .protocol import HostProtocol, Instance, copy_type
+from .protocol import HostProtocol, Instance, copy_type, AdbHostConfig
 
 logger = logging.getLogger(__name__)
 
@@ -19,7 +21,7 @@ else:
         """Stub for read_reg on non-Windows platforms."""
         return default
 
-class Mumu12Instance(Instance):
+class Mumu12Instance(Instance[AdbHostConfig]):
     @copy_type(Instance.__init__)
     def __init__(self, *args, **kwargs):
         super().__init__(*args, **kwargs)
@@ -70,6 +72,26 @@ class Mumu12Instance(Instance):
     def running(self) -> bool:
         return self.is_android_started
 
+    @override
+    def create_device(self, impl: DeviceImpl, host_config: AdbHostConfig) -> Device:
+        """为MuMu12模拟器实例创建 Device。"""
+        if self.adb_port is None:
+            raise ValueError("ADB port is not set and is required.")
+
+        # 为 ADB 相关的实现创建配置
+        if impl in ['adb', 'adb_raw', 'uiautomator2']:
+            config = AdbImplConfig(
+                addr=f'{self.adb_ip}:{self.adb_port}',
+                connect=True,
+                disconnect=True,
+                device_serial=self.adb_name,
+                timeout=host_config.timeout
+            )
+            impl = cast(AdbBasedImpl, impl) # make pylance happy
+            return create_device(impl, config)
+        else:
+            raise ValueError(f'Unsupported device implementation for MuMu12: {impl}')
+
 class Mumu12Host(HostProtocol):
     @staticmethod
     @lru_cache(maxsize=1)

kotonebot/client/host/protocol.py

@@ -1,14 +1,15 @@
 import time
 import socket
 from abc import ABC, abstractmethod
-from typing_extensions import ParamSpec, Concatenate
-from typing import Callable, TypeVar, Generic, Protocol, runtime_checkable, Type, Any
+from typing import Callable, TypeVar, Protocol, Any, Generic
+from dataclasses import dataclass
 
 from adbutils import adb, AdbTimeout, AdbError
 from adbutils._device import AdbDevice
 
 from kotonebot import logging
-from kotonebot.client import Device, create_device, DeviceImpl
+from kotonebot.client import Device, DeviceImpl
+
 from kotonebot.util import Countdown, Interval
 
 logger = logging.getLogger(__name__)
@@ -17,6 +18,28 @@ _T = TypeVar("_T")
 def copy_type(_: _T) -> Callable[[Any], _T]:
     return lambda x: x
 
+# --- 定义专用的 HostConfig 数据类 ---
+@dataclass
+class AdbHostConfig:
+    """由外部为基于 ADB 的主机提供的配置。"""
+    timeout: float = 180
+
+@dataclass
+class WindowsHostConfig:
+    """由外部为 Windows 实现提供配置。"""
+    window_title: str
+    ahk_exe_path: str
+
+@dataclass
+class RemoteWindowsHostConfig:
+    """由外部为远程 Windows 实现提供配置。"""
+    windows_host_config: WindowsHostConfig
+    host: str
+    port: int
+
+# --- 使用泛型改造 Instance 协议 ---
+T_HostConfig = TypeVar("T_HostConfig")
+
 def tcp_ping(host: str, port: int, timeout: float = 1.0) -> bool:
     """
     通过 TCP ping 检查主机和端口是否可达。
@@ -36,7 +59,11 @@ def tcp_ping(host: str, port: int, timeout: float = 1.0) -> bool:
         return False
 
 
-class Instance(ABC):
+class Instance(Generic[T_HostConfig], ABC):
+    """
+    代表一个可运行环境的实例（如一个模拟器）。
+    使用泛型来约束 create_device 方法的配置参数类型。
+    """
     def __init__(self,
         id: str,
         name: str,
@@ -68,7 +95,7 @@ class Instance(ABC):
         启动模拟器实例。
         """
         raise NotImplementedError()
-    
+
     @abstractmethod
     def stop(self):
         """
@@ -80,21 +107,16 @@ class Instance(ABC):
     def running(self) -> bool:
         raise NotImplementedError()
 
-    def create_device(self, impl: DeviceImpl, *, timeout: float = 180) -> Device:
+    @abstractmethod
+    def create_device(self, impl: DeviceImpl, host_config: T_HostConfig) -> Device:
         """
-        创建 Device 实例，可用于控制模拟器系统。
-        
-        :return: Device 实例
+        根据实现名称和类型化的主机配置创建设备。
+
+        :param impl: 设备实现的名称。
+        :param host_config: 一个类型化的数据对象，包含创建所需的所有外部配置。
+        :return: 配置好的 Device 实例。
         """
-        if self.adb_port is None:
-            raise ValueError("ADB port is not set and is required.")
-        return create_device(
-            addr=f'{self.adb_ip}:{self.adb_port}',
-            impl=impl,
-            device_serial=self.adb_name,
-            connect=True,
-            timeout=timeout
-        )
+        raise NotImplementedError()
 
     def wait_available(self, timeout: float = 180):
         logger.info('Starting to wait for emulator %s(127.0.0.1:%d) to be available...', self.name, self.adb_port)

kotonebot/client/implements/__init__.py

@@ -0,0 +1,6 @@
+# 导入所有内置实现，以触发它们的 @register_impl 装饰器
+from . import adb  # noqa: F401
+from . import adb_raw  # noqa: F401
+from . import remote_windows  # noqa: F401
+from . import uiautomator2  # noqa: F401
+from . import windows  # noqa: F401

kotonebot/client/implements/adb.py

@@ -5,16 +5,27 @@ from typing_extensions import override
 import cv2
 import numpy as np
 from cv2.typing import MatLike
+from adbutils._device import AdbDevice as AdbUtilsDevice
 
-from ..device import Device
-from ..protocol import Commandable, Touchable, Screenshotable
+from ..device import AndroidDevice
+from ..protocol import AndroidCommandable, Touchable, Screenshotable
+from ..registration import register_impl, ImplConfig
+from dataclasses import dataclass
 
 logger = logging.getLogger(__name__)
 
-class AdbImpl(Commandable, Touchable, Screenshotable):
-    def __init__(self, device: Device):
-        self.device = device
-        self.adb = device.adb
+# 定义配置模型
+@dataclass
+class AdbImplConfig(ImplConfig):
+    addr: str
+    connect: bool = True
+    disconnect: bool = True
+    device_serial: str | None = None
+    timeout: float = 180
+
+class AdbImpl(AndroidCommandable, Touchable, Screenshotable):
+    def __init__(self, adb_connection: AdbUtilsDevice):
+        self.adb = adb_connection
 
     @override
     def launch_app(self, package_name: str) -> None:
@@ -36,6 +47,10 @@ class AdbImpl(Commandable, Touchable, Screenshotable):
         package = activity.split('/')[0]
         return package
 
+    def adb_shell(self, cmd: str) -> str:
+        """执行 ADB shell 命令"""
+        return cast(str, self.adb.shell(cmd))
+
     @override
     def detect_orientation(self):
         # 判断方向：https://stackoverflow.com/questions/10040624/check-if-device-is-landscape-via-adb
@@ -50,7 +65,9 @@ class AdbImpl(Commandable, Touchable, Screenshotable):
     def screen_size(self) -> tuple[int, int]:
         ret = cast(str, self.adb.shell("wm size")).strip('Physical size: ')
         spiltted = tuple(map(int, ret.split("x")))
-        landscape = self.device.orientation == 'landscape'
+        # 检测当前方向
+        orientation = self.detect_orientation()
+        landscape = orientation == 'landscape'
         spiltted = tuple(sorted(spiltted, reverse=landscape))
         if len(spiltted) != 2:
             raise ValueError(f"Invalid screen size: {ret}")
@@ -66,3 +83,46 @@ class AdbImpl(Commandable, Touchable, Screenshotable):
         if duration is not None:
             logger.warning("Swipe duration is not supported with AdbDevice. Ignoring duration.")
         self.adb.shell(f"input touchscreen swipe {x1} {y1} {x2} {y2}")
+
+
+def _create_adb_device_base(config: AdbImplConfig, impl_class: type) -> AndroidDevice:
+    """
+    通用的 ADB 设备创建工厂函数。
+    其他任意基于 ADB 的 Impl 可以直接复用这个函数。
+
+    :param config: ADB 实现配置
+    :param impl_class: 实现类或工厂函数。构造函数接收 adb_connection 参数。
+    """
+    from adbutils import adb
+
+    if config.disconnect:
+        logger.debug('adb disconnect %s', config.addr)
+        adb.disconnect(config.addr)
+    if config.connect:
+        logger.debug('adb connect %s', config.addr)
+        result = adb.connect(config.addr)
+        if 'cannot connect to' in result:
+            raise ValueError(result)
+    serial = config.device_serial or config.addr
+    logger.debug('adb wait for %s', serial)
+    adb.wait_for(serial, timeout=config.timeout)
+    devices = adb.device_list()
+    logger.debug('adb device_list: %s', devices)
+    d = [d for d in devices if d.serial == serial]
+    if len(d) == 0:
+        raise ValueError(f"Device {config.addr} not found")
+    d = d[0]
+
+    device = AndroidDevice(d)
+    impl = impl_class(d)
+    device._touch = impl
+    device._screenshot = impl
+    device.commands = impl
+
+    return device
+
+
+@register_impl('adb', config_model=AdbImplConfig)
+def create_adb_device(config: AdbImplConfig) -> AndroidDevice:
+    """AdbImpl 工厂函数"""
+    return _create_adb_device_base(config, AdbImpl)

kotonebot/client/implements/adb_raw.py

@@ -11,8 +11,9 @@ import numpy as np
 from cv2.typing import MatLike
 from adbutils._utils import adb_path
 
-from .adb import AdbImpl
-from ..device import Device
+from .adb import AdbImpl, AdbImplConfig, _create_adb_device_base
+from adbutils._device import AdbDevice as AdbUtilsDevice
+from ..registration import register_impl
 from kotonebot import logging
 
 logger = logging.getLogger(__name__)
@@ -27,8 +28,8 @@ done
 """
 
 class AdbRawImpl(AdbImpl):
-    def __init__(self, device: Device):
-        super().__init__(device)
+    def __init__(self, adb_connection: AdbUtilsDevice):
+        super().__init__(adb_connection)
         self.__worker: Thread | None = None
         self.__process: subprocess.Popen | None = None
         self.__data: MatLike | None = None
@@ -156,4 +157,10 @@ class AdbRawImpl(AdbImpl):
         logger.verbose(f"adb raw screenshot wait time: {time.time() - start_time:.4f}s")
         data = self.__data
         self.__data = None
-        return data
+        return data
+
+
+@register_impl('adb_raw', config_model=AdbImplConfig)
+def create_adb_raw_device(config: AdbImplConfig):
+    """AdbRawImpl 工厂函数"""
+    return _create_adb_device_base(config, AdbRawImpl)

kotonebot/client/implements/remote_windows.py

@@ -14,6 +14,7 @@ import xmlrpc.server
 from typing import Literal, cast, Any, Tuple
 from functools import cached_property
 from threading import Thread
+from dataclasses import dataclass
 
 import cv2
 import numpy as np
@@ -22,10 +23,18 @@ from cv2.typing import MatLike
 from kotonebot import logging
 from ..device import Device, WindowsDevice
 from ..protocol import Touchable, Screenshotable
-from .windows import WindowsImpl
+from ..registration import register_impl, ImplConfig
+from .windows import WindowsImpl, WindowsImplConfig, create_windows_device
 
 logger = logging.getLogger(__name__)
 
+# 定义配置模型
+@dataclass
+class RemoteWindowsImplConfig(ImplConfig):
+    windows_impl_config: WindowsImplConfig
+    host: str = "localhost"
+    port: int = 8000
+
 def _encode_image(image: MatLike) -> str:
     """Encode an image as a base64 string."""
     success, buffer = cv2.imencode('.png', image)
@@ -48,13 +57,13 @@ class RemoteWindowsServer:
     This class wraps a WindowsImpl instance and exposes its methods via XML-RPC.
     """
 
-    def __init__(self, host="localhost", port=8000):
+    def __init__(self, windows_impl_config: WindowsImplConfig, 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.impl = create_windows_device(windows_impl_config)
         self.device._screenshot = self.impl
         self.device._touch = self.impl
 
@@ -180,18 +189,11 @@ class RemoteWindowsImpl(Touchable, Screenshotable):
             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")
+# 编写并注册创建函数
+@register_impl('remote_windows', config_model=RemoteWindowsImplConfig)
+def create_remote_windows_device(config: RemoteWindowsImplConfig) -> Device:
+    device = WindowsDevice()
+    remote_impl = RemoteWindowsImpl(device, config.host, config.port)
+    device._touch = remote_impl
+    device._screenshot = remote_impl
+    return device

kotonebot/client/implements/uiautomator2.py

@@ -8,6 +8,8 @@ from cv2.typing import MatLike
 from kotonebot import logging
 from ..device import Device
 from ..protocol import Screenshotable, Commandable, Touchable
+from ..registration import register_impl
+from .adb import AdbImplConfig, _create_adb_device_base
 
 logger = logging.getLogger(__name__)
 
@@ -83,3 +85,9 @@ class UiAutomator2Impl(Screenshotable, Commandable, Touchable):
         滑动屏幕
         """
         self.u2_client.swipe(x1, y1, x2, y2, duration=duration or 0.1)
+
+
+@register_impl('uiautomator2', config_model=AdbImplConfig)
+def create_uiautomator2_device(config: AdbImplConfig) -> Device:
+    """UiAutomator2Impl 工厂函数"""
+    return _create_adb_device_base(config, UiAutomator2Impl)

kotonebot/client/implements/windows.py

@@ -2,6 +2,7 @@ from ctypes import windll
 from typing import Literal
 from importlib import resources
 from functools import cached_property
+from dataclasses import dataclass
 
 import cv2
 import win32ui
@@ -10,14 +11,21 @@ import numpy as np
 from ahk import AHK, MsgBoxIcon
 from cv2.typing import MatLike
 
-from ..device import Device
+from ..device import Device, WindowsDevice
 from ..protocol import Commandable, Touchable, Screenshotable
+from ..registration import register_impl, ImplConfig
+
+# 1. 定义配置模型
+@dataclass
+class WindowsImplConfig(ImplConfig):
+    window_title: str
+    ahk_exe_path: str
 
 class WindowsImpl(Touchable, Screenshotable):
-    def __init__(self, device: Device):
+    def __init__(self, device: Device, window_title: str, ahk_exe_path: str):
         self.__hwnd: int | None = None
-        # TODO: 硬编码路径
-        self.ahk = AHK(executable_path=str(resources.files('kaa.res.bin') / 'AutoHotkey.exe'))
+        self.window_title = window_title
+        self.ahk = AHK(executable_path=ahk_exe_path)
         self.device = device
 
         # 设置 DPI aware，否则高缩放显示器上返回的坐标会错误
@@ -55,9 +63,9 @@ class WindowsImpl(Touchable, Screenshotable):
     @property
     def hwnd(self) -> int:
         if self.__hwnd is None:
-            self.__hwnd = win32gui.FindWindow(None, 'gakumas')
+            self.__hwnd = win32gui.FindWindow(None, self.window_title)
             if self.__hwnd is None or self.__hwnd == 0:
-                raise RuntimeError('Failed to find window')
+                raise RuntimeError(f'Failed to find window: {self.window_title}')
         return self.__hwnd
 
     def __client_rect(self) -> tuple[int, int, int, int]:
@@ -73,8 +81,8 @@ class WindowsImpl(Touchable, Screenshotable):
         return win32gui.ClientToScreen(hwnd, (x, y))
 
     def screenshot(self) -> MatLike:
-        if not self.ahk.win_is_active('gakumas'):
-            self.ahk.win_activate('gakumas')
+        if not self.ahk.win_is_active(self.window_title):
+            self.ahk.win_activate(self.window_title)
         hwnd = self.hwnd
 
         # TODO: 需要检查下面这些 WinAPI 的返回结果
@@ -130,7 +138,7 @@ class WindowsImpl(Touchable, Screenshotable):
             return 720, 1280
 
     def detect_orientation(self) -> None | Literal['portrait'] | Literal['landscape']:
-        pos = self.ahk.win_get_position('gakumas')
+        pos = self.ahk.win_get_position(self.window_title)
         if pos is None:
             return None
         w, h = pos.width, pos.height
@@ -147,24 +155,39 @@ class WindowsImpl(Touchable, Screenshotable):
         if y == 0:
             y = 2
         x, y = int(x / self.scale_ratio), int(y / self.scale_ratio)
-        if not self.ahk.win_is_active('gakumas'):
-            self.ahk.win_activate('gakumas')
+        if not self.ahk.win_is_active(self.window_title):
+            self.ahk.win_activate(self.window_title)
         self.ahk.click(x, y)
 
     def swipe(self, x1: int, y1: int, x2: int, y2: int, duration: float | None = None) -> None:
-        if not self.ahk.win_is_active('gakumas'):
-            self.ahk.win_activate('gakumas')
+        if not self.ahk.win_is_active(self.window_title):
+            self.ahk.win_activate(self.window_title)
         x1, y1 = int(x1 / self.scale_ratio), int(y1 / self.scale_ratio)
         x2, y2 = int(x2 / self.scale_ratio), int(y2 / self.scale_ratio)
         # TODO: 这个 speed 的单位是什么？
         self.ahk.mouse_drag(x2, y2, from_position=(x1, y1), coord_mode='Client', speed=10)
 
 
+# 3. 编写并注册创建函数
+@register_impl('windows', config_model=WindowsImplConfig)
+def create_windows_device(config: WindowsImplConfig) -> Device:
+    device = WindowsDevice()
+    impl = WindowsImpl(
+        device,
+        window_title=config.window_title,
+        ahk_exe_path=config.ahk_exe_path
+    )
+    device._touch = impl
+    device._screenshot = impl
+    return device
+
+
 if __name__ == '__main__':
     from ..device import Device
-    from time import sleep
     device = Device()
-    impl = WindowsImpl(device)
+    # 在测试环境中直接使用默认路径
+    ahk_path = str(resources.files('kaa.res.bin') / 'AutoHotkey.exe')
+    impl = WindowsImpl(device, window_title='gakumas', ahk_exe_path=ahk_path)
     device._screenshot = impl
     device._touch = impl
     device.swipe_scaled(0.5, 0.8, 0.5, 0.2)

kotonebot/client/protocol.py

@@ -28,6 +28,19 @@ class Commandable(Protocol):
     def launch_app(self, package_name: str) -> None: ...
     def current_package(self) -> str | None: ...
 
+@runtime_checkable
+class AndroidCommandable(Protocol):
+    """定义 Android 平台的特定命令"""
+    def launch_app(self, package_name: str) -> None: ...
+    def current_package(self) -> str | None: ...
+    def adb_shell(self, cmd: str) -> str: ...
+
+@runtime_checkable
+class WindowsCommandable(Protocol):
+    """定义 Windows 平台的特定命令"""
+    def get_foreground_window(self) -> tuple[int, str]: ...
+    def exec_command(self, command: str) -> tuple[int, str, str]: ...
+
 @runtime_checkable
 class Screenshotable(Protocol):
     def __init__(self, device: 'Device'): ...

kotonebot/client/registration.py

@@ -0,0 +1,89 @@
+from dataclasses import dataclass
+from typing import TypeVar, Callable, Dict, Type, Any, overload, Literal, cast, TYPE_CHECKING
+
+from ..errors import KotonebotError
+from .device import Device
+if TYPE_CHECKING:
+    from .implements.adb import AdbImplConfig
+    from .implements.remote_windows import RemoteWindowsImplConfig
+    from .implements.windows import WindowsImplConfig
+
+AdbBasedImpl = Literal['adb', 'adb_raw', 'uiautomator2']
+DeviceImpl = str | AdbBasedImpl | Literal['windows', 'remote_windows']
+
+# --- 核心类型定义 ---
+
+class ImplRegistrationError(KotonebotError):
+    """与 impl 注册相关的错误"""
+    pass
+
+@dataclass
+class ImplConfig:
+    """所有设备实现配置模型的名义上的基类，便于类型约束。"""
+    pass
+
+T_Config = TypeVar("T_Config", bound=ImplConfig)
+
+# 定义两种创建者函数类型
+CreatorWithConfig = Callable[[Any], Device]
+CreatorWithoutConfig = Callable[[], Device]
+
+# --- 底层 API: 公开的注册表 ---
+
+# 注册表结构: {'impl_name': (创建函数, 配置模型类 或 None)}
+DEVICE_CREATORS: Dict[str, tuple[Callable[..., Device], Type[ImplConfig] | None]] = {}
+
+
+def register_impl(name: str, config_model: Type[ImplConfig] | None = None) -> Callable[..., Any]:
+    """
+    一个统一的装饰器，用于向 DEVICE_CREATORS 注册表中注册一个设备实现。
+
+    :param name: 实现的名称 (e.g., 'windows', 'adb')
+    :param config_model: (可选) 与该实现关联的 dataclass 配置模型
+    """
+    def decorator(creator_func: Callable[..., Device]) -> Callable[..., Device]:
+        if name in DEVICE_CREATORS:
+            raise ImplRegistrationError(f"实现 '{name}' 已被注册。")
+        DEVICE_CREATORS[name] = (creator_func, config_model)
+        return creator_func
+    return decorator
+
+
+# --- 高层 API: 带 overload 的便利函数 ---
+
+# 为需要配置的已知 impl 提供 overload
+@overload
+def create_device(impl_name: Literal['windows'], config: 'WindowsImplConfig') -> Device: ...
+
+@overload
+def create_device(impl_name: Literal['remote_windows'], config: 'RemoteWindowsImplConfig') -> Device: ...
+
+@overload
+def create_device(impl_name: AdbBasedImpl, config: 'AdbImplConfig') -> Device: ...
+
+# 函数的实际实现
+def create_device(impl_name: DeviceImpl, config: ImplConfig | None = None) -> Device:
+    """
+    根据名称和可选的配置对象，统一创建设备。
+    """
+    creator_tuple = DEVICE_CREATORS.get(impl_name)
+    if not creator_tuple:
+        raise ImplRegistrationError(f"未找到名为 '{impl_name}' 的实现。")
+
+    creator_func, registered_config_model = creator_tuple
+
+    # 情况 A: 实现需要配置
+    if registered_config_model is not None:
+        creator_with_config = cast(CreatorWithConfig, creator_func)
+        if config is None:
+            raise ValueError(f"实现 '{impl_name}' 需要一个配置对象，但传入的是 None。")
+        if not isinstance(config, registered_config_model):
+            raise TypeError(f"为 '{impl_name}' 传入的配置类型错误，应为 '{registered_config_model.__name__}'，实际为 '{type(config).__name__}'。")
+        return creator_with_config(config)
+    
+    # 情况 B: 实现无需配置
+    else:
+        creator_without_config = cast(CreatorWithoutConfig, creator_func)
+        if config is not None:
+            print(f"提示：实现 '{impl_name}' 无需配置，但你提供了一个配置对象，它将被忽略。")
+        return creator_without_config()

kotonebot/config/base_config.py

@@ -3,7 +3,7 @@ from typing import Generic, TypeVar, Literal
 
 from pydantic import BaseModel, ConfigDict
 
-from kotonebot.client.factory import DeviceImpl
+from kotonebot.client import DeviceImpl
 
 T = TypeVar('T')
 BackendType = Literal['custom', 'mumu12', 'leidian', 'dmm']
@@ -44,6 +44,10 @@ class BackendConfig(ConfigBaseModel):
     """模拟器 exe 文件路径"""
     emulator_args: str = ""
     """模拟器启动时的命令行参数"""
+    windows_window_title: str = 'gakumas'
+    """Windows 截图方式的窗口标题"""
+    windows_ahk_path: str | None = None
+    """Windows 截图方式的 AutoHotkey 可执行文件路径，为 None 时使用默认路径"""
 
 class PushConfig(ConfigBaseModel):
     """推送配置。"""

kotonebot/debug_entry.py

@@ -17,10 +17,15 @@ def run_script(script_path: str) -> None:
 
     print(f"正在运行脚本: {script_path}")
     # 运行脚本
-    from kotonebot.backend.context import init_context
+    from kotonebot.backend.context import init_context, manual_context
+    from kotonebot.kaa.main.kaa import Kaa
     logging.basicConfig(level=logging.INFO, format='[%(asctime)s] [%(levelname)s] [%(name)s] [%(funcName)s] [%(lineno)d] %(message)s')
     logging.getLogger('kotonebot').setLevel(logging.DEBUG)
-    init_context(config_type=BaseConfig)
+    config_path = './config.json'
+    kaa_instance = Kaa(config_path)
+    init_context(config_type=BaseConfig, target_device=kaa_instance._on_create_device())
+    kaa_instance._on_after_init_context()
+    manual_context().begin()
     runpy.run_module(module_name, run_name="__main__")
 
 def main():

kotonebot/kaa/clear_logs.py

@@ -28,7 +28,4 @@ def clear_logs():
     logger.info('Clearing logs done.')
 
 if __name__ == '__main__':
-    from kotonebot.backend.context import init_context, manual_context
-    init_context()
-    manual_context().begin()
     clear_logs()