homebridge-agent-atv 0.1.1 → 0.1.2

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "homebridge-agent-atv",
   "displayName": "Agent ATV",
-  "version": "0.1.1",
+  "version": "0.1.2",
   "description": "Control an Apple TV from AI agents: an authenticated HTTP API (pyatv bridge), keyboard input, wait conditions, optional screen reading (focused element, screenshots), and a minimal HomeKit TV accessory.",
   "license": "MIT",
   "author": "AlexDemzz",

package/python/agent_atv_screen/backend_pmd3.py

@@ -17,7 +17,7 @@ from typing import Any, Callable, Dict, Iterator, List, Optional, Tuple
 
 from agent_atv_bridge.errors import BridgeError
 
-from . import image
+from . import image, inbound_queue
 
 _LOGGER = logging.getLogger("agent_atv_screen.pmd3")
 
@@ -245,6 +245,7 @@ class Pmd3Backend:
         self._ax_lock = asyncio.Lock()
         reader = self._pmd3.dtx_reader
         reader.MAX_BUFFERED_SIZE = max(reader.MAX_BUFFERED_SIZE, DTX_MAX_BUFFERED)
+        inbound_queue.install(self._pmd3.userspace_tunnel)
         # The stock no-root provider always starts with usbmux, which an Apple TV (Wi-Fi only) never reaches.
         self._pmd3.userspace_tunnel._create_no_root_tunnel_provider = self._provider
         self._pmd3.tunnel_service.input = self._read_pin

package/python/agent_atv_screen/inbound_queue.py

@@ -0,0 +1,96 @@
+"""Queues the userspace tunnel's inbound packets instead of dropping them (DESIGN.md §6.1 Tunnel).
+
+Without root, Linux caps the tunnel's socketpair buffer far below a screenshot burst, and
+UserspaceTun.write drops whatever does not fit, which stalls the capture on retransmissions. This
+replaces write() with one that queues what does not fit and sends it, in order, once the socket is
+writable again.
+"""
+
+from __future__ import annotations
+
+import asyncio
+import collections
+import errno
+import logging
+from typing import Any, Deque, Optional
+
+_LOGGER = logging.getLogger("agent_atv_screen.pmd3")
+
+# Bounds the memory a stalled stack can pin; past it TCP recovers the drops.
+MAX_QUEUED = 512
+_QUEUE = "_agent_atv_queue"
+_DROPPING = "_agent_atv_dropping"
+_FULL = (errno.EAGAIN, errno.EWOULDBLOCK, errno.ENOBUFS)
+
+
+def install(userspace_tunnel: Any) -> None:
+    tun_class = userspace_tunnel.UserspaceTun
+    if getattr(tun_class.write, "queues_inbound", False):
+        return
+    loopback, ethernet = userspace_tunnel.LOOPBACK_HEADER, userspace_tunnel._ETH_HDR_TO_STACK
+    stock_close = tun_class.close
+
+    def write(self: Any, data: bytes) -> None:
+        ipv6 = data[len(loopback) :] if data[: len(loopback)] == loopback else data
+        _send(self, ethernet + ipv6)
+
+    async def close(self: Any) -> None:
+        # The socketpair closes under the writer otherwise, and its descriptor gets reused.
+        # The stock close() sets _closed before it awaits, so no write() can queue again.
+        _discard(self)
+        await stock_close(self)
+
+    write.queues_inbound = True  # type: ignore[attr-defined]
+    tun_class.write = write
+    tun_class.close = close
+
+
+def _send(tun: Any, frame: bytes) -> None:
+    queue: Optional[Deque[bytes]] = getattr(tun, _QUEUE, None)
+    if queue:
+        if len(queue) < MAX_QUEUED:
+            queue.append(frame)
+        elif not getattr(tun, _DROPPING, False):
+            setattr(tun, _DROPPING, True)
+            _LOGGER.debug("The tunnel's inbound queue is full (%d packets); dropping until it drains", MAX_QUEUED)
+        return
+    try:
+        tun._peer.send(frame)
+        return
+    except OSError as exc:
+        if exc.errno not in _FULL:
+            _failed(tun, exc)
+            return
+    if tun._closed:
+        return
+    setattr(tun, _QUEUE, collections.deque((frame,)))
+    asyncio.get_running_loop().add_writer(tun._peer.fileno(), _flush, tun)
+
+
+def _flush(tun: Any) -> None:
+    queue: Deque[bytes] = getattr(tun, _QUEUE)
+    while queue:
+        try:
+            tun._peer.send(queue[0])
+        except OSError as exc:
+            if exc.errno in _FULL:
+                return
+            _failed(tun, exc)
+        queue.popleft()
+    _discard(tun)
+
+
+def _failed(tun: Any, exc: OSError) -> None:
+    # Like the stock write(): any other error (e.g. EMSGSIZE) drops the packet, logged once per tunnel.
+    if not tun._send_error_logged:
+        tun._send_error_logged = True
+        _LOGGER.debug("The userspace tunnel dropped a packet from the Apple TV: %s", exc)
+
+
+def _discard(tun: Any) -> None:
+    if getattr(tun, _QUEUE, None) is None:
+        return
+    setattr(tun, _QUEUE, None)
+    setattr(tun, _DROPPING, False)
+    if tun._peer.fileno() >= 0:
+        asyncio.get_running_loop().remove_writer(tun._peer.fileno())