dailo-devtools 0.1.3__tar.gz → 0.1.5__tar.gz

{dailo_devtools-0.1.3/src/dailo_devtools.egg-info → dailo_devtools-0.1.5}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: dailo-devtools
-Version: 0.1.3
+Version: 0.1.5
 Summary: 通过代劳 DevTools 调试单台 Android 设备的 Python API 与 CLI
 License-Expression: MIT
 Project-URL: Script SDK, https://pypi.org/project/dailo-sdk/
@@ -19,7 +19,7 @@ Dynamic: license-file
 
 # Dailo DevTools
 
-在电脑上运行和调试代劳 Android 自动化脚本。提供 `dailo-dev` 命令行工具和异步 Python 客户端，可执行脚本、读取文字与控件、保存截图和查看日志。
+在电脑上运行和调试代劳 Android 与 Windows 自动化脚本。提供 `dailo-dev` 命令行工具与 Python 客户端，可执行脚本、读取文字与控件、保存截图和查看日志。
 
 - 命令行执行 Python 文件或短代码。
 - Python API 支持连接设备、截图、观察和停止运行。
@@ -55,6 +55,28 @@ dailo-dev serve --connection connection.json
 
 保持服务运行，在另一个终端执行后续命令。连接文件包含访问设备的凭据，请保存在本机；链接过期或重新连接时，从 App 获取新链接。
 
+## Windows 本机调试
+
+Windows 使用代劳安装目录中的 `runtime/windows-x64`，复用产品的 Rust 宿主和脚本执行通路，无需安装 Python 系统或视觉库。`--hwnd` 或 `--executable` 选择目标；省略时观察当前显示桌面。
+
+```sh
+dailo-dev windows --runtime "C:\Apps\代劳\runtime\windows-x64" applications
+dailo-dev windows --runtime "C:\Apps\代劳\runtime\windows-x64" desktops
+dailo-dev windows --runtime "C:\Apps\代劳\runtime\windows-x64" --hwnd 123456 inspect
+dailo-dev windows --runtime "C:\Apps\代劳\runtime\windows-x64" --hwnd 123456 screenshot screen.png
+dailo-dev windows --runtime "C:\Apps\代劳\runtime\windows-x64" --hwnd 123456 exec --file main.py --timeout 300
+```
+
+Python 客户端提供同一能力；`cancel()` 可由调用方其他线程停止正在执行的脚本：
+
+```python
+from dailo_devtools import Windows
+
+device = Windows(r"C:\Apps\代劳\runtime\windows-x64", hwnd=123456)
+print(device.inspect())
+device.run_file("main.py", config={"rounds": 5})
+```
+
 ## 运行脚本
 
 执行一段代码：
@@ -71,6 +93,13 @@ dailo-dev exec --file main.py --config settings.json
 
 脚本可使用 [dailo-sdk](https://pypi.org/project/dailo-sdk/) 的文字、控件和图片定位 API。文件模式会自动上传脚本目录中的 Python 模块和 `assets/`；`--timeout` 设置执行时限，单位为秒，默认 300。
 
+只携带本次所需资源时，使用 `--assets` 指定相对脚本目录的文件或目录；设备上保留相同相对路径。省略此参数时携带整个 `assets/`，单独使用 `--assets` 时不携带资源。Python 模块始终自动携带。
+
+```sh
+dailo-dev exec --file main.py --assets assets/battle.png assets/maps
+dailo-dev exec --code "from dailo import text; print(text())" --assets
+```
+
 ## 常用命令
 
 | 命令 | 用途 |
@@ -109,6 +138,19 @@ asyncio.run(main())
 
 `Device` 还提供 `run_file(path, config=...)`、`inspect()` 和 `cancel()`。使用 Python 客户端时无需启动 `dailo-dev serve`；异步上下文管理器负责建立和关闭连接。
 
+Android执行超时后请求停止；收到终态时直接返回原结果并标记`transportDeadlineExceeded`，可核`errorCode`和日志。停止后仍未收到结果或连接中断时才抛异常，保留未确认记录，不自动重放。
+
+`run_file()` 和 `execute()` 的 `assets=None` 默认携带 `assets/`。传入显式列表会只携带选定资源，`assets=[]` 不携带资源，例如：
+
+```python
+await device.run_file("main.py", assets=["assets/battle.png", "assets/maps"])
+await device.execute("from dailo import text; print(text())", assets=[])
+```
+
+Windows 的 `run_file()`、`execute()` 每次生成独立 `devtools:windows:…` 执行 ID，脚本通过 `execution()` 读取。明确续接某次失败时传入 `retry_of_execution_id=原执行ID`；新调用默认不关联旧父。调试 ID 不代表产品任务记录。
+
+Android 的同名参数沿用Host提供的本父真实执行ID，只设置本次重试来源，退出后恢复原上下文。续接连续延期时，传入上一父脚本中`dailo.execution().execution_id`的完整原值；不要传请求短ID、sessionId或自行拼接ID。CLI使用`--retry-of-execution-id`，持久服务的`execute`／`run_file`请求使用`retry_of_execution_id`。省略参数表示新调用，不沿用旧延期链；该参数不修改原延期时间，也不绕过最早执行时间。
+
 ## 许可
 
 MIT。

dailo_devtools-0.1.5/README.md

@@ -0,0 +1,137 @@
+# Dailo DevTools
+
+在电脑上运行和调试代劳 Android 与 Windows 自动化脚本。提供 `dailo-dev` 命令行工具与 Python 客户端，可执行脚本、读取文字与控件、保存截图和查看日志。
+
+- 命令行执行 Python 文件或短代码。
+- Python API 支持连接设备、截图、观察和停止运行。
+- 自动携带脚本目录中的 Python 模块与 `assets/`。
+- 图文日志保存到电脑，可离线查看。
+
+## 安装
+
+需要 Python 3.11 或更新版本，以及已安装代劳 App、开启 DevTools 的 Android 设备。
+
+```sh
+python -m pip install dailo-devtools
+dailo-dev install
+```
+
+`dailo-dev install` 安装后台连接所需的 Chromium 运行时，只需执行一次。
+
+## 连接设备
+
+从代劳 App 的 DevTools 入口复制连接链接，保存为 `connection.json`：
+
+```json
+{
+  "url": "<从代劳 App 复制的 DevTools 链接>"
+}
+```
+
+启动连接服务：
+
+```sh
+dailo-dev serve --connection connection.json
+```
+
+保持服务运行，在另一个终端执行后续命令。连接文件包含访问设备的凭据，请保存在本机；链接过期或重新连接时，从 App 获取新链接。
+
+## Windows 本机调试
+
+Windows 使用代劳安装目录中的 `runtime/windows-x64`，复用产品的 Rust 宿主和脚本执行通路，无需安装 Python 系统或视觉库。`--hwnd` 或 `--executable` 选择目标；省略时观察当前显示桌面。
+
+```sh
+dailo-dev windows --runtime "C:\Apps\代劳\runtime\windows-x64" applications
+dailo-dev windows --runtime "C:\Apps\代劳\runtime\windows-x64" desktops
+dailo-dev windows --runtime "C:\Apps\代劳\runtime\windows-x64" --hwnd 123456 inspect
+dailo-dev windows --runtime "C:\Apps\代劳\runtime\windows-x64" --hwnd 123456 screenshot screen.png
+dailo-dev windows --runtime "C:\Apps\代劳\runtime\windows-x64" --hwnd 123456 exec --file main.py --timeout 300
+```
+
+Python 客户端提供同一能力；`cancel()` 可由调用方其他线程停止正在执行的脚本：
+
+```python
+from dailo_devtools import Windows
+
+device = Windows(r"C:\Apps\代劳\runtime\windows-x64", hwnd=123456)
+print(device.inspect())
+device.run_file("main.py", config={"rounds": 5})
+```
+
+## 运行脚本
+
+执行一段代码：
+
+```sh
+dailo-dev exec --code "from dailo import text; print(text())"
+```
+
+执行 Python 文件并传入任务设置：
+
+```sh
+dailo-dev exec --file main.py --config settings.json
+```
+
+脚本可使用 [dailo-sdk](https://pypi.org/project/dailo-sdk/) 的文字、控件和图片定位 API。文件模式会自动上传脚本目录中的 Python 模块和 `assets/`；`--timeout` 设置执行时限，单位为秒，默认 300。
+
+只携带本次所需资源时，使用 `--assets` 指定相对脚本目录的文件或目录；设备上保留相同相对路径。省略此参数时携带整个 `assets/`，单独使用 `--assets` 时不携带资源。Python 模块始终自动携带。
+
+```sh
+dailo-dev exec --file main.py --assets assets/battle.png assets/maps
+dailo-dev exec --code "from dailo import text; print(text())" --assets
+```
+
+## 常用命令
+
+| 命令 | 用途 |
+| --- | --- |
+| `dailo-dev status` | 查看连接和运行状态 |
+| `dailo-dev inspect` | 读取设备画面的文字与控件 |
+| `dailo-dev screenshot screen.png` | 保存设备截图 |
+| `dailo-dev cancel` | 停止当前脚本 |
+| `dailo-dev reconnect` | 使用持久连接配置重新连接设备 |
+| `dailo-dev logs <日志目录>` | 离线查看图文日志 |
+
+运行 `dailo-dev --help` 或 `dailo-dev exec --help` 查看完整选项。
+
+## Python API
+
+```python
+import asyncio
+import json
+from pathlib import Path
+
+from dailo_devtools import Device, read_logs
+
+
+async def main():
+    connection = json.loads(Path("connection.json").read_text(encoding="utf-8"))
+
+    async with Device(connection) as device:
+        result = await device.execute("from dailo import text; print(text())")
+        await device.screenshot("screen.png")
+        print(result)
+        print(read_logs(result["logDirectory"]))
+
+
+asyncio.run(main())
+```
+
+`Device` 还提供 `run_file(path, config=...)`、`inspect()` 和 `cancel()`。使用 Python 客户端时无需启动 `dailo-dev serve`；异步上下文管理器负责建立和关闭连接。
+
+Android执行超时后请求停止；收到终态时直接返回原结果并标记`transportDeadlineExceeded`，可核`errorCode`和日志。停止后仍未收到结果或连接中断时才抛异常，保留未确认记录，不自动重放。
+
+`run_file()` 和 `execute()` 的 `assets=None` 默认携带 `assets/`。传入显式列表会只携带选定资源，`assets=[]` 不携带资源，例如：
+
+```python
+await device.run_file("main.py", assets=["assets/battle.png", "assets/maps"])
+await device.execute("from dailo import text; print(text())", assets=[])
+```
+
+Windows 的 `run_file()`、`execute()` 每次生成独立 `devtools:windows:…` 执行 ID，脚本通过 `execution()` 读取。明确续接某次失败时传入 `retry_of_execution_id=原执行ID`；新调用默认不关联旧父。调试 ID 不代表产品任务记录。
+
+Android 的同名参数沿用Host提供的本父真实执行ID，只设置本次重试来源，退出后恢复原上下文。续接连续延期时，传入上一父脚本中`dailo.execution().execution_id`的完整原值；不要传请求短ID、sessionId或自行拼接ID。CLI使用`--retry-of-execution-id`，持久服务的`execute`／`run_file`请求使用`retry_of_execution_id`。省略参数表示新调用，不沿用旧延期链；该参数不修改原延期时间，也不绕过最早执行时间。
+
+## 许可
+
+MIT。

{dailo_devtools-0.1.3 → dailo_devtools-0.1.5}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "dailo-devtools"
-version = "0.1.3"
+version = "0.1.5"
 description = "通过代劳 DevTools 调试单台 Android 设备的 Python API 与 CLI"
 readme = "README.md"
 requires-python = ">=3.11"

{dailo_devtools-0.1.3 → dailo_devtools-0.1.5}/src/dailo_devtools/__init__.py

@@ -4,10 +4,13 @@ from typing import TYPE_CHECKING
 if TYPE_CHECKING:
     from .device import Device, DevtoolsError, read_logs
 
-__all__ = ["Device", "DevtoolsError", "read_logs"]
+__all__ = ["Device", "DevtoolsError", "read_logs", "Windows"]
 
 
 def __getattr__(name: str):
+    if name == 'Windows':
+        from .windows import Windows
+        return Windows
     if name not in __all__:
         raise AttributeError(f"module {__name__!r} has no attribute {name!r}")
     from .device import Device, DevtoolsError, read_logs

{dailo_devtools-0.1.3 → dailo_devtools-0.1.5}/src/dailo_devtools/cli.py

@@ -76,12 +76,44 @@ def main():
     source.add_argument("--code")
     source.add_argument("--file")
     execute.add_argument("--config", help="脚本配置 JSON 文件")
-    execute.add_argument("--assets", action="append", default=[])
+    execute.add_argument("--assets", action="extend", nargs="*", default=None,
+                         help="仅携带指定资源；省略时携带 assets/，不提供路径时不携带资源")
     execute.add_argument("--directory", default=".", help="内联代码所属仓库，默认当前目录")
     execute.add_argument("--timeout", type=float, default=300, help="整个开发运行的传输时限，单位秒")
+    execute.add_argument("--retry-of-execution-id", help="明确续接的上一父真实执行ID；省略时新建延期链")
     raw = sub.add_parser("request", help="直接发送当前 DevTools 协议 JSON")
     raw.add_argument("body")
+    windows = sub.add_parser('windows', help='通过代劳随包 Rust 宿主调试本机 Windows')
+    windows.add_argument('--runtime', required=True, help='代劳安装目录中的 runtime/windows-x64')
+    windows.add_argument('--executable')
+    windows.add_argument('--hwnd', type=lambda value: int(value, 0))
+    commands = windows.add_subparsers(dest='windows_command', required=True)
+    commands.add_parser('applications')
+    commands.add_parser('desktops')
+    commands.add_parser('inspect')
+    commands.add_parser('screenshot').add_argument('path')
+    run = commands.add_parser('exec')
+    source = run.add_mutually_exclusive_group(required=True)
+    source.add_argument('--file')
+    source.add_argument('--code')
+    run.add_argument('--directory', default='.')
+    run.add_argument('--config')
+    run.add_argument('--timeout', type=float, default=300)
     args = parser.parse_args()
+    if args.command == 'windows':
+        from .windows import Windows
+        device = Windows(args.runtime, executable=args.executable, hwnd=args.hwnd)
+        if args.windows_command == 'exec':
+            config = json.loads(Path(args.config).read_text(encoding='utf-8')) if args.config else {}
+            callback = lambda value: print(json.dumps(value, ensure_ascii=False), flush=True)
+            events = (device.run_file(args.file, config=config, timeout=args.timeout, on_event=callback)
+                      if args.file else device.execute(args.code, directory=args.directory,
+                                config=config, timeout=args.timeout, on_event=callback))
+            sys.exit(0 if events[-1].get('status') == 'success' else 1)
+        result = (device.screenshot(args.path) if args.windows_command == 'screenshot'
+                  else getattr(device, args.windows_command)())
+        print(json.dumps(result, ensure_ascii=False, indent=2))
+        return
     if args.command == "logs":
         from .device import read_logs
         print(json.dumps(read_logs(args.directory), ensure_ascii=False, indent=2))
@@ -108,7 +140,7 @@ def main():
     elif args.command == "inspect":
         body.update(pixels=args.pixels, nodes=not args.no_nodes, text=not args.no_text, raw=args.raw)
     elif args.command == "exec":
-        body.update(timeout=args.timeout, assets=args.assets)
+        body.update(timeout=args.timeout, assets=args.assets, retry_of_execution_id=args.retry_of_execution_id)
         if args.config:
             body["config"] = json.loads(Path(args.config).read_text(encoding="utf-8"))
         if args.file:

{dailo_devtools-0.1.3 → dailo_devtools-0.1.5}/src/dailo_devtools/device.py

@@ -21,14 +21,30 @@ from urllib.parse import parse_qs, quote, urlencode, urlsplit
 import aiohttp
 from playwright.async_api import async_playwright
 
+CLIENT_SOURCE_SHA256 = hashlib.sha256(Path(__file__).read_bytes()).hexdigest()
 
-TRANSPORT = """async (iceServers) => {
+
+TRANSPORT = """async ({iceServers, localIceAddresses}) => {
   const peer = window.peer = new RTCPeerConnection({iceServers});
+  window.localIceAddresses = localIceAddresses;
   window.localCandidates = [];
   peer.onicecandidate = event => {
     if (event.candidate) {
+      if (localIceAddresses !== undefined && event.candidate.type !== 'host') return;
       const {candidate, sdpMid, sdpMLineIndex} = event.candidate;
       window.localCandidates.push({candidate, sdpMid, sdpMLineIndex});
+      window.transportSignal('ice', {candidate: {candidate, sdpMid, sdpMLineIndex}});
+      if (event.candidate.protocol === 'udp' && event.candidate.type === 'host'
+          && event.candidate.address?.endsWith('.local')) {
+        for (const address of localIceAddresses ?? []) {
+          window.transportSignal('ice', {candidate: {
+            candidate: candidate.replace(` ${event.candidate.address} `, ` ${address} `),
+            sdpMid, sdpMLineIndex
+          }});
+        }
+      }
+    } else {
+      window.transportSignal('ice_complete', {});
     }
   };
   const channels = window.channels = {};
@@ -51,20 +67,17 @@ TRANSPORT = """async (iceServers) => {
   };
 } """
 
-CREATE_OFFER = """async () => {
+CREATE_OFFER = r"""async () => {
   await peer.setLocalDescription(await peer.createOffer());
-  if (peer.iceGatheringState !== 'complete') await new Promise(resolve => {
-    peer.addEventListener('icegatheringstatechange', () => {
-      if (peer.iceGatheringState === 'complete') resolve();
-    });
-  });
-  return {sdp: peer.localDescription.sdp, candidates: window.localCandidates};
+  const sdp = peer.localDescription.sdp;
+  return {sdp: window.localIceAddresses === undefined ? sdp : sdp.split('\r\n').filter(line =>
+    !line.startsWith('a=candidate:') || line.split(' ')[7] === 'host').join('\r\n'), candidates: []};
 } """
 
 SEND_REQUEST = """async wire => {
   const channel = channels.inspection;
   const bytes = new TextEncoder().encode(wire);
-  const upload = window.devtoolsUpload = {totalBytes: bytes.length, queuedBytes: 0, terminatorSent: false};
+  const upload = window.devtoolsUpload = {requestId: JSON.parse(wire).id, totalBytes: bytes.length, queuedBytes: 0, terminatorSent: false};
   channel.bufferedAmountLowThreshold = 65536;
   for (let offset = 0; offset < bytes.length; offset += 16384) {
     if (channel.readyState !== 'open') throw new Error('DevTools inspection channel closed');
@@ -99,6 +112,15 @@ TRANSPORT_SNAPSHOT = """() => ({
   upload: window.devtoolsUpload
 })"""
 
+CANCEL_UPLOAD = """requestId => {
+  const upload = window.devtoolsUpload;
+  if (!upload || upload.requestId !== requestId || upload.terminatorSent) return null;
+  upload.cancelled = true;
+  const receipt = {...upload};
+  peer.close();
+  return receipt;
+}"""
+
 
 def _transport_error(error: Exception) -> str:
     # 与持久serve一致，传输证据不保存带认证参数的连接URL。
@@ -145,6 +167,7 @@ class Device:
         self.failure: Exception | None = None
         self.failure_events: list[dict[str, Any]] = []
         self.session_timeout = 1800.0
+        self.signal_activity: dict[str, Any] = {"pingCount": 0, "pongCount": 0}
 
     async def __aenter__(self) -> Device:
         await self.connect()
@@ -165,12 +188,19 @@ class Device:
             self.browser = await self.playwright.chromium.launch(headless=True)
             self.browser.on("disconnected", lambda _: self._fail(DevtoolsError("DevTools 后台浏览器已关闭"), source="browser"))
             self.page = await self.browser.new_page()
+            self.offer_sent = asyncio.Event()
             await self.page.expose_function("transportEvent", self._transport_event)
             await self.page.expose_function("transportMessage", self._message)
-            ice = [] if local else [{"urls": "stun:stun.cloudflare.com:3478"}]
-            await self.page.evaluate(TRANSPORT, ice)
+            await self.page.expose_function("transportSignal", self._local_signal)
+            ice = [] if local or self.local_ice_addresses is not None else [{"urls": "stun:stun.cloudflare.com:3478"}]
+            transport_config = {"iceServers": ice}
+            if self.local_ice_addresses is not None:
+                transport_config["localIceAddresses"] = self.local_ice_addresses
+            await self.page.evaluate(TRANSPORT, transport_config)
 
             self.socket = await self.http.ws_connect(signal_url)
+            self.signal_activity = {"connectedAt": datetime.now(timezone.utc).isoformat(),
+                "requestedSessionTimeoutSeconds": self.session_timeout, "pingCount": 0, "pongCount": 0}
             self.tasks.extend([
                 asyncio.create_task(self._signals()),
                 asyncio.create_task(self._keepalive()),
@@ -178,7 +208,9 @@ class Device:
             try:
                 await asyncio.wait_for(self.ready.wait(), 30)
             except TimeoutError:
-                raise DevtoolsError("WebRTC 通道在 30 秒内未建立，请检查设备内 DevTools 服务与信令连接。") from None
+                failure = DevtoolsError("WebRTC 通道在 30 秒内未建立，请检查设备内 DevTools 服务与信令连接。")
+                self._fail(failure, source="connect_timeout", details=(await self.status())["diagnostics"])
+                raise failure from None
             if self.failure:
                 raise self.failure
         except BaseException:
@@ -192,12 +224,14 @@ class Device:
             params = parse_qs(parsed.fragment)
             admission = {key: params[key][0] for key in ("sessionId", "capability", "deviceId")}
             local = bool(params.get("signalBaseUrl"))
+            self.local_ice_addresses = params.get("localIceAddress")
             base = (params.get("signalBaseUrl") or params.get("signalFleetBaseUrl") or
                     [f"{parsed.scheme}://{parsed.netloc}"])[0]
         else:
             base = conf["baseUrl"].rstrip("/")
             device_id = conf["deviceId"]
             local = bool(conf.get("local"))
+            self.local_ice_addresses = conf.get("localIceAddresses")
             if conf.get("operatorCredential"):
                 path = f"/api/operations/devices/{quote(device_id, safe='')}/sessions"
                 headers = {"X-Dailo-Operator": conf["operatorCredential"]}
@@ -215,7 +249,10 @@ class Device:
             async with self.http.post(base + path, json=body, headers=headers) as response:
                 value = await response.json()
                 if response.status >= 400:
-                    raise DevtoolsError(value.get("error", f"DevTools 入场失败 HTTP {response.status}"))
+                    request_id = response.headers.get("cf-ray")
+                    request = f"（CF-Ray {request_id}）" if request_id else ""
+                    raise DevtoolsError(f"DevTools 入场失败 HTTP {response.status}{request}: "
+                                        + value.get("error", "服务未提供错误详情"))
                 admission = {**value, "deviceId": device_id}
         parsed = urlsplit(base)
         route = "/api/session/ws" if local else "/api/fleet/session"
@@ -241,7 +278,12 @@ class Device:
         if event == "ready":
             self.ready.set()
         else:
+            first_failure = self.failure is None
             self._fail(DevtoolsError("DevTools 通道已关闭"), source="transport", details=details)
+            if first_failure:
+                task = asyncio.create_task(self._close_failed_peer())
+                self.log_tasks.add(task)
+                task.add_done_callback(self.log_tasks.discard)
 
     async def status(self) -> dict[str, Any]:
         """读取连接状态与当前运行标识。"""
@@ -251,15 +293,27 @@ class Device:
             if self.failure is None:
                 raise
             transport = {"errorClass": type(error).__name__, "error": _transport_error(error)}
+        try:
+            rtc_stats = await asyncio.wait_for(self.page.evaluate("""async () => {
+                const stats = await peer.getStats();
+                return Array.from(stats.values()).filter(value =>
+                    ['transport','candidate-pair','local-candidate','remote-candidate',
+                     'data-channel','sctp-transport'].includes(value.type));
+            }"""), 1)
+        except Exception as error:
+            rtc_stats = {'errorClass': type(error).__name__, 'error': _transport_error(error)}
         signal_error = self.socket.exception()
         return {"deviceId": self.device_id, "sessionId": self.session_id,
                 "connectionState": "closed" if self.failure else transport["connectionState"],
                 "activeRun": self.active_python,
                 "error": _transport_error(self.failure) if self.failure else None,
                 "diagnostics": {"failureEvents": self.failure_events.copy(), "transport": transport,
+                    "rtcStats": rtc_stats,
+                    "client": {"file": __file__, "sha256": CLIENT_SOURCE_SHA256},
                     "signal": {"closed": self.socket.closed, "closeCode": self.socket.close_code,
                         "exceptionClass": type(signal_error).__name__ if signal_error else None,
-                        "exception": _transport_error(signal_error) if signal_error else None}}}
+                        "exception": _transport_error(signal_error) if signal_error else None,
+                        **self.signal_activity}}}
 
     def _fail(self, failure, *, source="device", details=None):
         self.failure_events.append({"recordedAt": datetime.now(timezone.utc).isoformat(),
@@ -287,13 +341,35 @@ class Device:
         socket_error = self.socket.exception()
         return {"phase": phase, "closed": self.socket.closed, "localCloseCode": self.socket.close_code,
                 "socketExceptionClass": type(socket_error).__name__ if socket_error else None,
-                "exceptionChain": _exception_chain(error if error is not None else socket_error)}
+                "exceptionChain": _exception_chain(error if error is not None else socket_error),
+                **self.signal_activity}
+
+    async def _keep_established_rtc(self, phase, error=None):
+        """信令异常断开不撤销已建立的RTC；授权期限仍由Agent执行。"""
+        if self.failure or self.socket.close_code != 1006:
+            return False
+        try:
+            transport = await self.page.evaluate(TRANSPORT_SNAPSHOT)
+        except Exception:
+            return False
+        if (transport["connectionState"] != "connected" or
+                not all(channel["readyState"] == "open" for channel in transport["channels"].values())):
+            return False
+        self.signal_activity.setdefault("interruptedAt", datetime.now(timezone.utc).isoformat())
+        self.signal_activity["interruption"] = {
+            "phase": phase, "transport": transport,
+            "exceptionChain": _exception_chain(error if error is not None else self.socket.exception()),
+        }
+        return True
 
     async def _signals(self):
         offered = False
         try:
             async for message in self.socket:
+                self.signal_activity["lastReceivedAt"] = datetime.now(timezone.utc).isoformat()
                 if message.type == aiohttp.WSMsgType.ERROR:
+                    if await self._keep_established_rtc("receive_error", message.data):
+                        return
                     self._fail(DevtoolsError(f"信令连接错误（{type(message.data).__name__}）：{_transport_error(message.data)}"),
                         source="signaling", details={"messageType": "ERROR", "exceptionClass": type(message.data).__name__,
                             "exception": _transport_error(message.data),
@@ -302,6 +378,8 @@ class Device:
                 if message.type != aiohttp.WSMsgType.TEXT:
                     continue
                 if message.data == "dailo:signaling:pong":
+                    self.signal_activity["lastPongReceivedAt"] = self.signal_activity["lastReceivedAt"]
+                    self.signal_activity["pongCount"] += 1
                     continue
                 envelope = json.loads(message.data)["payload"]
                 signal = envelope["payload"]
@@ -313,8 +391,13 @@ class Device:
                         offered = True
                         offer = await self.page.evaluate(CREATE_OFFER)
                         await self._signal("offer", offer)
+                        self.offer_sent.set()
                 elif kind == "answer":
-                    await self.page.evaluate("sdp => peer.setRemoteDescription({type:'answer', sdp})", payload["sdp"])
+                    sdp = payload['sdp']
+                    if self.local_ice_addresses is not None:
+                        sdp = '\r\n'.join(line for line in sdp.split('\r\n')
+                            if not line.startswith('a=candidate:') or line.split(' ')[7] == 'host')
+                    await self.page.evaluate("sdp => peer.setRemoteDescription({type:'answer', sdp})", sdp)
                     for candidate in payload["candidates"]:
                         await self._candidate(candidate)
                 elif kind == "ice":
@@ -325,6 +408,8 @@ class Device:
                     raise DevtoolsError("设备结束了开发会话")
             code = self.socket.close_code
             error = self.socket.exception()
+            if await self._keep_established_rtc("iterator_ended", error):
+                return
             self._fail(DevtoolsError(
                 "开发会话授权已到期。"
                 if code == 4008 else f"信令连接已关闭（{code}）" +
@@ -340,18 +425,32 @@ class Device:
                 # 信令已失效时立即关闭旧通道，不等下一条命令才释放。
                 await self._close_failed_peer()
 
+    async def _local_signal(self, kind, payload):
+        # ICE 可持续收集；候选地址必须在 offer 发出后逐个送达设备。
+        await self.offer_sent.wait()
+        await self._signal(kind, payload)
+
     async def _candidate(self, value):
+        if self.local_ice_addresses is not None and value['candidate'].split(' ')[7] != 'host':
+            return
         await self.page.evaluate("candidate => peer.addIceCandidate(candidate)", value)
 
     async def _keepalive(self):
         try:
             while True:
                 await asyncio.sleep(30)
+                if self.signal_activity.get("interruption"):
+                    return
                 await self.socket.send_str("dailo:signaling:ping")
+                self.signal_activity["lastPingSentAt"] = datetime.now(timezone.utc).isoformat()
+                self.signal_activity["pingCount"] += 1
         except asyncio.CancelledError:
             raise
         except Exception as error:
-            self._fail(DevtoolsError(f"信令保活发送失败（{type(error).__name__}）：{_transport_error(error)}"), source="signaling_keepalive")
+            if await self._keep_established_rtc("keepalive_send_failed", error):
+                return
+            self._fail(DevtoolsError(f"信令保活发送失败（{type(error).__name__}）：{_transport_error(error)}"),
+                source="signaling_keepalive", details=self._signal_details("keepalive_send_failed", error))
             await self._close_failed_peer()
 
     def _message(self, wire):
@@ -454,9 +553,9 @@ class Device:
             return result
         except TimeoutError:
             if body["kind"] == "python":
-                await self.page.evaluate("wire => channels.control.send(wire)", json.dumps({
-                    "kind": "python_cancel", "id": uuid.uuid4().hex, "requestId": request_id}))
                 try:
+                    await self.page.evaluate("wire => channels.control.send(wire)", json.dumps({
+                        "kind": "python_cancel", "id": uuid.uuid4().hex, "requestId": request_id}))
                     # 保留原响应future，接收停止后的stdout、栈和同帧日志。
                     result = await asyncio.wait_for(future, 30)
                 except TimeoutError:
@@ -464,17 +563,15 @@ class Device:
                     self._fail(failure, source="python_timeout")
                     with contextlib.suppress(Exception):
                         await self.page.evaluate("peer.close()")
-                    raise failure from None
+                    raise self._record_interruption(failure, request_id, request_evidence) from None
                 except Exception as error:
-                    if self.failure:
-                        raise self._record_interruption(error, request_id, request_evidence) from None
-                    raise
+                    raise self._record_interruption(error, request_id, request_evidence) from None
+                result['transportDeadlineExceeded'] = True
                 self._finish_logs(result, request_id)
-                path = Path(result['logDirectory']) / 'execution.json'
-                raise DevtoolsError(f"开发运行在 {timeout:g} 秒内未结束，停止结果已保存：{path}") from None
+                return result
             raise DevtoolsError(f"设备未响应 {body['kind']}（{timeout:g} 秒超时）。") from None
         except Exception as error:
-            if body["kind"] == "python" and self.failure:
+            if body["kind"] == "python":
                 raise self._record_interruption(error, request_id, request_evidence) from None
             raise
         finally:
@@ -484,15 +581,22 @@ class Device:
     def _record_interruption(self, error, request_id, request_evidence):
         folder = self._log_folder(request_id)
         path = folder / 'interruption.json'
-        path.write_text(json.dumps({
+        upload = (request_evidence.get('transport') or {}).get('upload') or {}
+        upload_cancelled = (upload.get('requestId') == request_id
+                            and upload.get('cancelled') and not upload.get('terminatorSent'))
+        record = {
             "recordedAt": datetime.now(timezone.utc).isoformat(),
             "requestId": request_id, "sessionId": self.session_id,
-            "deviceId": self.device_id, "outcome": "unconfirmed",
-            "error": _transport_error(error), "failureEvents": self.failure_events.copy(),
+            "deviceId": self.device_id, "outcome": "cancelled_before_dispatch" if upload_cancelled else "unconfirmed",
+            "error": _transport_error(error), "exceptionClass": type(error).__name__,
+            "failureEvents": self.failure_events.copy(),
             "request": request_evidence,
             "logDirectory": str(folder), "logsPath": str(folder / 'logs.json'),
-        }, ensure_ascii=False, indent=2), encoding='utf-8')
-        return DevtoolsError(f"{error}；运行结果未确认，断线记录已保存：{path}")
+        }
+        path.write_text(json.dumps(record, ensure_ascii=False, indent=2), encoding='utf-8')
+        self._finish_logs({"ok": False, **record, "interruptionPath": str(path)}, request_id)
+        outcome = "上传已取消，脚本未提交" if upload_cancelled else "运行结果未确认"
+        return DevtoolsError(f"{record['error']}；{outcome}，断线记录已保存：{path}")
 
     async def _execute(self, source: str, *, timeout: float = 300) -> dict[str, Any]:
         """执行 Python，返回运行结果；result 含 stdout、stderr 和执行状态。"""
@@ -516,8 +620,10 @@ class Device:
         folder = self._log_folder(request_id)
         picture = entry.get('image')
         if picture:
-            path = folder / (hashlib.sha256(entry['logId'].encode()).hexdigest() + '.png')
-            path.write_bytes(base64.b64decode(picture.pop('dataBase64')))
+            path = folder / (picture['sha256'] + '.png')
+            data = picture.pop('dataBase64')
+            if not path.exists():
+                path.write_bytes(base64.b64decode(data))
             picture['path'] = str(path)
         path = folder / 'logs.json'
         if not path.exists():
@@ -543,9 +649,14 @@ class Device:
         (folder / 'execution.json').write_text(json.dumps(result, ensure_ascii=False, indent=2), encoding='utf-8')
 
     async def cancel(self) -> dict[str, Any]:
-        """停止当前开发脚本，保持连接。"""
+        """停止开发脚本；未提交的上传关闭旧通道，避免半包留到下一请求。"""
         if self.active_python:
-            return await self.request({"kind": "python_cancel", "requestId": self.active_python})
+            request_id = self.active_python
+            upload = await self.page.evaluate(CANCEL_UPLOAD, request_id)
+            if upload:
+                return {"ok": True, "running": False, "cancelRequested": True,
+                        "requestId": request_id, "uploadAborted": True, "upload": upload}
+            return await self.request({"kind": "python_cancel", "requestId": request_id})
         return {"ok": True, "running": False}
 
     async def screenshot(self, path: str | Path) -> dict[str, Any]:
@@ -576,30 +687,36 @@ class Device:
         return value
 
     async def run_file(self, path: str | Path, *, config: Mapping[str, Any] | None = None,
-                       assets: Iterable[str | Path] = (), timeout: float = 300) -> dict[str, Any]:
-        """运行入口，自动携带仓库 Python 模块和 assets；保留设备缓存，重跑加载新源码。"""
+                       assets: Iterable[str | Path] | None = None, timeout: float = 300,
+                       retry_of_execution_id: str | None = None) -> dict[str, Any]:
+        """携带仓库 Python 模块；assets=None 默认携带 assets/，显式列表仅携带指定资源。"""
         path = Path(path).resolve()
-        return await self._run_workspace(path, path.read_text(encoding="utf-8"), config, assets, timeout)
+        return await self._run_workspace(path, path.read_text(encoding="utf-8"), config, assets, timeout,
+                                         retry_of_execution_id)
 
     async def execute(self, source: str, *, directory: str | Path | None = None,
                       config: Mapping[str, Any] | None = None,
-                      assets: Iterable[str | Path] = (), timeout: float = 300) -> dict[str, Any]:
+                      assets: Iterable[str | Path] | None = None, timeout: float = 300,
+                      retry_of_execution_id: str | None = None) -> dict[str, Any]:
         """在当前仓库的设备工作目录执行代码；模块、相对路径和 assets 与 run_file 一致。"""
         folder = Path(directory or Path.cwd()).resolve()
-        return await self._run_workspace(folder / ".dailo-repl.py", source, config, assets, timeout)
+        return await self._run_workspace(folder / ".dailo-repl.py", source, config, assets, timeout,
+                                         retry_of_execution_id)
 
     async def _run_workspace(self, path: Path, source: str, config: Mapping[str, Any] | None,
-                             assets: Iterable[str | Path], timeout: float) -> dict[str, Any]:
+                             assets: Iterable[str | Path] | None, timeout: float,
+                             retry_of_execution_id: str | None) -> dict[str, Any]:
         config = dict(config or {})
         archive = io.BytesIO()
         with zipfile.ZipFile(archive, "w", zipfile.ZIP_DEFLATED) as bundle:
             files = set()
             for folder, directories, names in os.walk(path.parent):
                 directories[:] = [name for name in directories if name not in {
-                    '.git', '.venv', 'node_modules', 'downloads', 'data', 'state', '__pycache__', 'dist',
+                    '.git', '.venv', 'node_modules', 'downloads', 'data', 'state', '__pycache__', 'dist', 'assets',
+                    'artifacts', 'target',
                 }]
                 files.update(Path(folder) / name for name in names if name.endswith('.py'))
-            for entry in [path.parent / 'assets', *assets]:
+            for entry in ['assets'] if assets is None else assets:
                 asset = (path.parent / entry).resolve()
                 for item in (asset.rglob("*") if asset.is_dir() else [asset]):
                     if item.is_file():
@@ -613,9 +730,10 @@ class Device:
         program = f'''def __run_local_file():
     import os, sys, io, json, base64, zipfile, importlib.util
     from pathlib import Path
-    from dailo._runtime import bind, host, config as get_config
+    from dailo._runtime import bind, host, config as get_config, execution as get_execution
     native_host = host()
     previous_config = get_config()
+    previous_execution = get_execution()
     workspace = json.loads(native_host._app_operation(json.dumps({{"operation":"workspace", "name":{workspace!r}}})))
     if not workspace['ok']:
         raise RuntimeError(workspace['error'])
@@ -655,7 +773,8 @@ class Device:
                    if not Path(entry or previous_dir).resolve().is_relative_to(workspace_root)]
     previous_path = sys.path.copy()
     os.chdir(folder)
-    bind(native_host, {config or {}!r})
+    bind(native_host, {config or {}!r}, {{**previous_execution,
+         'retry_of_execution_id': {retry_of_execution_id!r}}})
     try:
         scope = {{'__file__': os.path.join(folder, {path.name!r}), '__name__': '__main__'}}
         sys.path.insert(0, folder)
@@ -668,7 +787,7 @@ class Device:
             scope.clear()
     finally:
         os.chdir(previous_dir)
-        bind(native_host, previous_config)
+        bind(native_host, previous_config, previous_execution)
 try:
     __run_local_file()
 finally:
@@ -678,6 +797,10 @@ finally:
 
     async def close(self) -> None:
         """结束开发会话并关闭后台 Chromium。"""
+        if hasattr(self, "socket") and not self.socket.closed:
+            self.signal_activity["localCloseRequestedAt"] = datetime.now(timezone.utc).isoformat()
+        if hasattr(self, "socket"):
+            await self.socket.close()
         tasks = [*self.tasks, *self.log_tasks]
         for task in tasks:
             task.cancel()
@@ -687,8 +810,6 @@ finally:
         self.tasks.clear()
         self.log_tasks.clear()
         self.chunks.clear()
-        if hasattr(self, "socket"):
-            await self.socket.close()
         if hasattr(self, "browser"):
             await self.browser.close()
         if hasattr(self, "playwright"):

dailo_devtools-0.1.5/src/dailo_devtools/windows.py

@@ -0,0 +1,80 @@
+"""Windows 调试复用代劳随包 Rust 宿主，无需安装系统或视觉库。"""
+from __future__ import annotations
+import base64
+import json
+from pathlib import Path
+import subprocess
+import tempfile
+import time
+import uuid
+
+
+class Windows:
+    def __init__(self, runtime, *, executable=None, hwnd=None):
+        self.runtime = Path(runtime).resolve()
+        self.target = {'executable': str(Path(executable).resolve()) if executable else None, 'hwnd': hwnd}
+        self._process = None
+
+    def _call(self, operation, *, on_event=None, **payload):
+        request = {'operation': operation, 'runtime': str(self.runtime), 'target': self.target, **payload}
+        events = []
+        with subprocess.Popen([str(self.runtime/'python.exe'), '-u', '-m', 'dailo.windows._worker'],
+                stdin=subprocess.PIPE, stdout=subprocess.PIPE, stderr=subprocess.PIPE,
+                text=True, encoding='utf-8', creationflags=subprocess.CREATE_NO_WINDOW) as process:
+            self._process = process
+            try:
+                process.stdin.write(json.dumps(request, ensure_ascii=False)+'\n')
+                process.stdin.flush()
+                for line in process.stdout:
+                    event = json.loads(line)
+                    events.append(event)
+                    if on_event:
+                        on_event(event)
+                    if event['type'] == 'finished' or operation in ('inventory', 'desktops'):
+                        break
+                process.stdin.close()
+                process.wait()
+                if process.returncode:
+                    raise RuntimeError(f"Windows 宿主退出（{process.returncode}）：{process.stderr.read().strip()}")
+            finally:
+                self._process = None
+        return events
+
+    def applications(self):
+        return self._call('inventory')[0]['windows']
+
+    def desktops(self):
+        return self._call('desktops')[0]['desktops']
+
+    def inspect(self):
+        return next(e for e in self._call('inspect') if e['type'] == 'inspect')
+
+    def screenshot(self, path):
+        image = next(e['image'] for e in self._call('preview') if e['type'] == 'preview')
+        Path(path).write_bytes(base64.b64decode(image['dataBase64']))
+        return {'path': str(Path(path).resolve()), 'width': image['width'], 'height': image['height']}
+
+    def run_file(self, path, *, config=None, timeout=300, on_event=None, retry_of_execution_id=None):
+        path = Path(path).resolve()
+        return self._call('execute', scriptRoot=str(path.parent), entryPoint=path.name,
+                execution=self._execution(config, timeout, retry_of_execution_id),
+                on_event=on_event)
+
+    def execute(self, source, *, directory='.', config=None, timeout=300, on_event=None, retry_of_execution_id=None):
+        with tempfile.TemporaryDirectory(prefix='dailo-dev-') as temporary:
+            path = Path(temporary)/'main.py'
+            path.write_text(source, encoding='utf-8')
+            return self._call('execute', scriptRoot=str(Path(directory).resolve()), entryPoint=str(path),
+                    execution=self._execution(config, timeout, retry_of_execution_id),
+                    on_event=on_event)
+
+    @staticmethod
+    def _execution(config, timeout, retry_of_execution_id):
+        return {'executionId': 'devtools:windows:' + uuid.uuid4().hex,
+                'retryOfExecutionId': retry_of_execution_id,
+                'config': config or {}, 'deadlineAtMs': round((time.time()+timeout)*1000)}
+
+    def cancel(self):
+        if self._process is not None:
+            self._process.stdin.write('{"type":"cancel"}\n')
+            self._process.stdin.flush()

{dailo_devtools-0.1.3 → dailo_devtools-0.1.5/src/dailo_devtools.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: dailo-devtools
-Version: 0.1.3
+Version: 0.1.5
 Summary: 通过代劳 DevTools 调试单台 Android 设备的 Python API 与 CLI
 License-Expression: MIT
 Project-URL: Script SDK, https://pypi.org/project/dailo-sdk/
@@ -19,7 +19,7 @@ Dynamic: license-file
 
 # Dailo DevTools
 
-在电脑上运行和调试代劳 Android 自动化脚本。提供 `dailo-dev` 命令行工具和异步 Python 客户端，可执行脚本、读取文字与控件、保存截图和查看日志。
+在电脑上运行和调试代劳 Android 与 Windows 自动化脚本。提供 `dailo-dev` 命令行工具与 Python 客户端，可执行脚本、读取文字与控件、保存截图和查看日志。
 
 - 命令行执行 Python 文件或短代码。
 - Python API 支持连接设备、截图、观察和停止运行。
@@ -55,6 +55,28 @@ dailo-dev serve --connection connection.json
 
 保持服务运行，在另一个终端执行后续命令。连接文件包含访问设备的凭据，请保存在本机；链接过期或重新连接时，从 App 获取新链接。
 
+## Windows 本机调试
+
+Windows 使用代劳安装目录中的 `runtime/windows-x64`，复用产品的 Rust 宿主和脚本执行通路，无需安装 Python 系统或视觉库。`--hwnd` 或 `--executable` 选择目标；省略时观察当前显示桌面。
+
+```sh
+dailo-dev windows --runtime "C:\Apps\代劳\runtime\windows-x64" applications
+dailo-dev windows --runtime "C:\Apps\代劳\runtime\windows-x64" desktops
+dailo-dev windows --runtime "C:\Apps\代劳\runtime\windows-x64" --hwnd 123456 inspect
+dailo-dev windows --runtime "C:\Apps\代劳\runtime\windows-x64" --hwnd 123456 screenshot screen.png
+dailo-dev windows --runtime "C:\Apps\代劳\runtime\windows-x64" --hwnd 123456 exec --file main.py --timeout 300
+```
+
+Python 客户端提供同一能力；`cancel()` 可由调用方其他线程停止正在执行的脚本：
+
+```python
+from dailo_devtools import Windows
+
+device = Windows(r"C:\Apps\代劳\runtime\windows-x64", hwnd=123456)
+print(device.inspect())
+device.run_file("main.py", config={"rounds": 5})
+```
+
 ## 运行脚本
 
 执行一段代码：
@@ -71,6 +93,13 @@ dailo-dev exec --file main.py --config settings.json
 
 脚本可使用 [dailo-sdk](https://pypi.org/project/dailo-sdk/) 的文字、控件和图片定位 API。文件模式会自动上传脚本目录中的 Python 模块和 `assets/`；`--timeout` 设置执行时限，单位为秒，默认 300。
 
+只携带本次所需资源时，使用 `--assets` 指定相对脚本目录的文件或目录；设备上保留相同相对路径。省略此参数时携带整个 `assets/`，单独使用 `--assets` 时不携带资源。Python 模块始终自动携带。
+
+```sh
+dailo-dev exec --file main.py --assets assets/battle.png assets/maps
+dailo-dev exec --code "from dailo import text; print(text())" --assets
+```
+
 ## 常用命令
 
 | 命令 | 用途 |
@@ -109,6 +138,19 @@ asyncio.run(main())
 
 `Device` 还提供 `run_file(path, config=...)`、`inspect()` 和 `cancel()`。使用 Python 客户端时无需启动 `dailo-dev serve`；异步上下文管理器负责建立和关闭连接。
 
+Android执行超时后请求停止；收到终态时直接返回原结果并标记`transportDeadlineExceeded`，可核`errorCode`和日志。停止后仍未收到结果或连接中断时才抛异常，保留未确认记录，不自动重放。
+
+`run_file()` 和 `execute()` 的 `assets=None` 默认携带 `assets/`。传入显式列表会只携带选定资源，`assets=[]` 不携带资源，例如：
+
+```python
+await device.run_file("main.py", assets=["assets/battle.png", "assets/maps"])
+await device.execute("from dailo import text; print(text())", assets=[])
+```
+
+Windows 的 `run_file()`、`execute()` 每次生成独立 `devtools:windows:…` 执行 ID，脚本通过 `execution()` 读取。明确续接某次失败时传入 `retry_of_execution_id=原执行ID`；新调用默认不关联旧父。调试 ID 不代表产品任务记录。
+
+Android 的同名参数沿用Host提供的本父真实执行ID，只设置本次重试来源，退出后恢复原上下文。续接连续延期时，传入上一父脚本中`dailo.execution().execution_id`的完整原值；不要传请求短ID、sessionId或自行拼接ID。CLI使用`--retry-of-execution-id`，持久服务的`execute`／`run_file`请求使用`retry_of_execution_id`。省略参数表示新调用，不沿用旧延期链；该参数不修改原延期时间，也不绕过最早执行时间。
+
 ## 许可
 
 MIT。

{dailo_devtools-0.1.3 → dailo_devtools-0.1.5}/src/dailo_devtools.egg-info/SOURCES.txt

@@ -5,6 +5,7 @@ src/dailo_devtools/__init__.py
 src/dailo_devtools/cli.py
 src/dailo_devtools/device.py
 src/dailo_devtools/py.typed
+src/dailo_devtools/windows.py
 src/dailo_devtools.egg-info/PKG-INFO
 src/dailo_devtools.egg-info/SOURCES.txt
 src/dailo_devtools.egg-info/dependency_links.txt

dailo_devtools-0.1.3/README.md

@@ -1,95 +0,0 @@
-# Dailo DevTools
-
-在电脑上运行和调试代劳 Android 自动化脚本。提供 `dailo-dev` 命令行工具和异步 Python 客户端，可执行脚本、读取文字与控件、保存截图和查看日志。
-
-- 命令行执行 Python 文件或短代码。
-- Python API 支持连接设备、截图、观察和停止运行。
-- 自动携带脚本目录中的 Python 模块与 `assets/`。
-- 图文日志保存到电脑，可离线查看。
-
-## 安装
-
-需要 Python 3.11 或更新版本，以及已安装代劳 App、开启 DevTools 的 Android 设备。
-
-```sh
-python -m pip install dailo-devtools
-dailo-dev install
-```
-
-`dailo-dev install` 安装后台连接所需的 Chromium 运行时，只需执行一次。
-
-## 连接设备
-
-从代劳 App 的 DevTools 入口复制连接链接，保存为 `connection.json`：
-
-```json
-{
-  "url": "<从代劳 App 复制的 DevTools 链接>"
-}
-```
-
-启动连接服务：
-
-```sh
-dailo-dev serve --connection connection.json
-```
-
-保持服务运行，在另一个终端执行后续命令。连接文件包含访问设备的凭据，请保存在本机；链接过期或重新连接时，从 App 获取新链接。
-
-## 运行脚本
-
-执行一段代码：
-
-```sh
-dailo-dev exec --code "from dailo import text; print(text())"
-```
-
-执行 Python 文件并传入任务设置：
-
-```sh
-dailo-dev exec --file main.py --config settings.json
-```
-
-脚本可使用 [dailo-sdk](https://pypi.org/project/dailo-sdk/) 的文字、控件和图片定位 API。文件模式会自动上传脚本目录中的 Python 模块和 `assets/`；`--timeout` 设置执行时限，单位为秒，默认 300。
-
-## 常用命令
-
-| 命令 | 用途 |
-| --- | --- |
-| `dailo-dev status` | 查看连接和运行状态 |
-| `dailo-dev inspect` | 读取设备画面的文字与控件 |
-| `dailo-dev screenshot screen.png` | 保存设备截图 |
-| `dailo-dev cancel` | 停止当前脚本 |
-| `dailo-dev reconnect` | 使用持久连接配置重新连接设备 |
-| `dailo-dev logs <日志目录>` | 离线查看图文日志 |
-
-运行 `dailo-dev --help` 或 `dailo-dev exec --help` 查看完整选项。
-
-## Python API
-
-```python
-import asyncio
-import json
-from pathlib import Path
-
-from dailo_devtools import Device, read_logs
-
-
-async def main():
-    connection = json.loads(Path("connection.json").read_text(encoding="utf-8"))
-
-    async with Device(connection) as device:
-        result = await device.execute("from dailo import text; print(text())")
-        await device.screenshot("screen.png")
-        print(result)
-        print(read_logs(result["logDirectory"]))
-
-
-asyncio.run(main())
-```
-
-`Device` 还提供 `run_file(path, config=...)`、`inspect()` 和 `cancel()`。使用 Python 客户端时无需启动 `dailo-dev serve`；异步上下文管理器负责建立和关闭连接。
-
-## 许可
-
-MIT。