headroid 0.1.0a1__py3-none-any.whl

headroid/__init__.py

@@ -0,0 +1,20 @@
+# Copyright 2026 Anand S Kale and the headroid contributors
+# SPDX-License-Identifier: Apache-2.0
+"""headroid: host-side SDK for the headroid device server."""
+
+from .adb import Adb, AdbError
+from .device import Device, Display
+from .rpc import RpcClient, RpcError
+from .server import ServerProcess
+
+__version__ = "0.1.0a1"
+__all__ = [
+    "Adb",
+    "AdbError",
+    "Device",
+    "Display",
+    "RpcClient",
+    "RpcError",
+    "ServerProcess",
+    "__version__",
+]

headroid/_server/LICENSE

@@ -0,0 +1,202 @@
+
+                                 Apache License
+                           Version 2.0, January 2004
+                        http://www.apache.org/licenses/
+
+   TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
+
+   1. Definitions.
+
+      "License" shall mean the terms and conditions for use, reproduction,
+      and distribution as defined by Sections 1 through 9 of this document.
+
+      "Licensor" shall mean the copyright owner or entity authorized by
+      the copyright owner that is granting the License.
+
+      "Legal Entity" shall mean the union of the acting entity and all
+      other entities that control, are controlled by, or are under common
+      control with that entity. For the purposes of this definition,
+      "control" means (i) the power, direct or indirect, to cause the
+      direction or management of such entity, whether by contract or
+      otherwise, or (ii) ownership of fifty percent (50%) or more of the
+      outstanding shares, or (iii) beneficial ownership of such entity.
+
+      "You" (or "Your") shall mean an individual or Legal Entity
+      exercising permissions granted by this License.
+
+      "Source" form shall mean the preferred form for making modifications,
+      including but not limited to software source code, documentation
+      source, and configuration files.
+
+      "Object" form shall mean any form resulting from mechanical
+      transformation or translation of a Source form, including but
+      not limited to compiled object code, generated documentation,
+      and conversions to other media types.
+
+      "Work" shall mean the work of authorship, whether in Source or
+      Object form, made available under the License, as indicated by a
+      copyright notice that is included in or attached to the work
+      (an example is provided in the Appendix below).
+
+      "Derivative Works" shall mean any work, whether in Source or Object
+      form, that is based on (or derived from) the Work and for which the
+      editorial revisions, annotations, elaborations, or other modifications
+      represent, as a whole, an original work of authorship. For the purposes
+      of this License, Derivative Works shall not include works that remain
+      separable from, or merely link (or bind by name) to the interfaces of,
+      the Work and Derivative Works thereof.
+
+      "Contribution" shall mean any work of authorship, including
+      the original version of the Work and any modifications or additions
+      to that Work or Derivative Works thereof, that is intentionally
+      submitted to Licensor for inclusion in the Work by the copyright owner
+      or by an individual or Legal Entity authorized to submit on behalf of
+      the copyright owner. For the purposes of this definition, "submitted"
+      means any form of electronic, verbal, or written communication sent
+      to the Licensor or its representatives, including but not limited to
+      communication on electronic mailing lists, source code control systems,
+      and issue tracking systems that are managed by, or on behalf of, the
+      Licensor for the purpose of discussing and improving the Work, but
+      excluding communication that is conspicuously marked or otherwise
+      designated in writing by the copyright owner as "Not a Contribution."
+
+      "Contributor" shall mean Licensor and any individual or Legal Entity
+      on behalf of whom a Contribution has been received by Licensor and
+      subsequently incorporated within the Work.
+
+   2. Grant of Copyright License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      copyright license to reproduce, prepare Derivative Works of,
+      publicly display, publicly perform, sublicense, and distribute the
+      Work and such Derivative Works in Source or Object form.
+
+   3. Grant of Patent License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      (except as stated in this section) patent license to make, have made,
+      use, offer to sell, sell, import, and otherwise transfer the Work,
+      where such license applies only to those patent claims licensable
+      by such Contributor that are necessarily infringed by their
+      Contribution(s) alone or by combination of their Contribution(s)
+      with the Work to which such Contribution(s) was submitted. If You
+      institute patent litigation against any entity (including a
+      cross-claim or counterclaim in a lawsuit) alleging that the Work
+      or a Contribution incorporated within the Work constitutes direct
+      or contributory patent infringement, then any patent licenses
+      granted to You under this License for that Work shall terminate
+      as of the date such litigation is filed.
+
+   4. Redistribution. You may reproduce and distribute copies of the
+      Work or Derivative Works thereof in any medium, with or without
+      modifications, and in Source or Object form, provided that You
+      meet the following conditions:
+
+      (a) You must give any other recipients of the Work or
+          Derivative Works a copy of this License; and
+
+      (b) You must cause any modified files to carry prominent notices
+          stating that You changed the files; and
+
+      (c) You must retain, in the Source form of any Derivative Works
+          that You distribute, all copyright, patent, trademark, and
+          attribution notices from the Source form of the Work,
+          excluding those notices that do not pertain to any part of
+          the Derivative Works; and
+
+      (d) If the Work includes a "NOTICE" text file as part of its
+          distribution, then any Derivative Works that You distribute must
+          include a readable copy of the attribution notices contained
+          within such NOTICE file, excluding those notices that do not
+          pertain to any part of the Derivative Works, in at least one
+          of the following places: within a NOTICE text file distributed
+          as part of the Derivative Works; within the Source form or
+          documentation, if provided along with the Derivative Works; or,
+          within a display generated by the Derivative Works, if and
+          wherever such third-party notices normally appear. The contents
+          of the NOTICE file are for informational purposes only and
+          do not modify the License. You may add Your own attribution
+          notices within Derivative Works that You distribute, alongside
+          or as an addendum to the NOTICE text from the Work, provided
+          that such additional attribution notices cannot be construed
+          as modifying the License.
+
+      You may add Your own copyright statement to Your modifications and
+      may provide additional or different license terms and conditions
+      for use, reproduction, or distribution of Your modifications, or
+      for any such Derivative Works as a whole, provided Your use,
+      reproduction, and distribution of the Work otherwise complies with
+      the conditions stated in this License.
+
+   5. Submission of Contributions. Unless You explicitly state otherwise,
+      any Contribution intentionally submitted for inclusion in the Work
+      by You to the Licensor shall be under the terms and conditions of
+      this License, without any additional terms or conditions.
+      Notwithstanding the above, nothing herein shall supersede or modify
+      the terms of any separate license agreement you may have executed
+      with Licensor regarding such Contributions.
+
+   6. Trademarks. This License does not grant permission to use the trade
+      names, trademarks, service marks, or product names of the Licensor,
+      except as required for reasonable and customary use in describing the
+      origin of the Work and reproducing the content of the NOTICE file.
+
+   7. Disclaimer of Warranty. Unless required by applicable law or
+      agreed to in writing, Licensor provides the Work (and each
+      Contributor provides its Contributions) on an "AS IS" BASIS,
+      WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+      implied, including, without limitation, any warranties or conditions
+      of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
+      PARTICULAR PURPOSE. You are solely responsible for determining the
+      appropriateness of using or redistributing the Work and assume any
+      risks associated with Your exercise of permissions under this License.
+
+   8. Limitation of Liability. In no event and under no legal theory,
+      whether in tort (including negligence), contract, or otherwise,
+      unless required by applicable law (such as deliberate and grossly
+      negligent acts) or agreed to in writing, shall any Contributor be
+      liable to You for damages, including any direct, indirect, special,
+      incidental, or consequential damages of any character arising as a
+      result of this License or out of the use or inability to use the
+      Work (including but not limited to damages for loss of goodwill,
+      work stoppage, computer failure or malfunction, or any and all
+      other commercial damages or losses), even if such Contributor
+      has been advised of the possibility of such damages.
+
+   9. Accepting Warranty or Additional Liability. While redistributing
+      the Work or Derivative Works thereof, You may choose to offer,
+      and charge a fee for, acceptance of support, warranty, indemnity,
+      or other liability obligations and/or rights consistent with this
+      License. However, in accepting such obligations, You may act only
+      on Your own behalf and on Your sole responsibility, not on behalf
+      of any other Contributor, and only if You agree to indemnify,
+      defend, and hold each Contributor harmless for any liability
+      incurred by, or claims asserted against, such Contributor by reason
+      of your accepting any such warranty or additional liability.
+
+   END OF TERMS AND CONDITIONS
+
+   APPENDIX: How to apply the Apache License to your work.
+
+      To apply the Apache License to your work, attach the following
+      boilerplate notice, with the fields enclosed by brackets "[]"
+      replaced with your own identifying information. (Don't include
+      the brackets!)  The text should be enclosed in the appropriate
+      comment syntax for the file format. We also recommend that a
+      file or class name and description of purpose be included on the
+      same "printed page" as the copyright notice for easier
+      identification within third-party archives.
+
+   Copyright [yyyy] [name of copyright owner]
+
+   Licensed under the Apache License, Version 2.0 (the "License");
+   you may not use this file except in compliance with the License.
+   You may obtain a copy of the License at
+
+       http://www.apache.org/licenses/LICENSE-2.0
+
+   Unless required by applicable law or agreed to in writing, software
+   distributed under the License is distributed on an "AS IS" BASIS,
+   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+   See the License for the specific language governing permissions and
+   limitations under the License.

headroid/_server/NOTICE

@@ -0,0 +1,35 @@
+headroid
+Copyright 2026 Anand S Kale and the headroid contributors
+
+This product is licensed under the Apache License, Version 2.0 (see LICENSE).
+
+Third-party components
+----------------------
+
+headroid combines several open-source projects (see docs/adr/0003-compose-open-source-stack.md).
+Files derived from them keep their original copyright headers and state the
+modifications made, as required by section 4 of the Apache License 2.0.
+
+scrcpy (device-server/ is a fork of scrcpy-server v4.1)
+  Copyright (C) 2018 Genymobile
+  Copyright (C) 2018-2026 Romain Vimont
+  Apache License, Version 2.0 - https://github.com/Genymobile/scrcpy
+  Upstream files live under device-server/server/src/main/java/com/genymobile/scrcpy/
+  and the Gradle files in device-server/. Modified lines are marked "headroid:";
+  see device-server/README.md for the list of changes. Upstream licence text:
+  device-server/LICENSE-scrcpy.
+
+ARTEMIS (selected host modules and integrations/artemis/)
+  Copyright 2026 Google LLC
+  Apache License, Version 2.0 - https://github.com/google/artemis
+
+mobile-use (selected host modules and integrations/mobile-use/)
+  Copyright 2025-2026 Minitap, Inc.
+  Apache License, Version 2.0 - https://github.com/minitap-ai/mobile-use
+
+Used as dependencies (not copied):
+  uiautomator2, adbutils - MIT - https://github.com/openatx
+  Model Context Protocol Python SDK - MIT - https://github.com/modelcontextprotocol/python-sdk
+
+Android SDK Platform-Tools (adb) are not redistributed with headroid; users install them
+separately under Google's Android SDK terms.

headroid/adb.py

@@ -0,0 +1,124 @@
+# Copyright 2026 Anand S Kale and the headroid contributors
+# SPDX-License-Identifier: Apache-2.0
+"""Thin wrapper over the adb command line."""
+
+from __future__ import annotations
+
+import re
+import subprocess
+
+
+class AdbError(RuntimeError):
+    """adb failed or was used ambiguously."""
+
+
+def list_devices(adb_path: str = "adb") -> list[dict]:
+    """Returns [{"serial", "state", "model"}] from `adb devices -l`."""
+    try:
+        proc = subprocess.run(
+            [adb_path, "devices", "-l"], capture_output=True, text=True, timeout=30, check=False
+        )
+    except FileNotFoundError as e:
+        raise AdbError(f"adb not found: {adb_path}") from e
+    except subprocess.TimeoutExpired as e:
+        raise AdbError("adb devices timed out") from e
+    devices = []
+    for ln in (proc.stdout or "").splitlines()[1:]:
+        parts = ln.split()
+        if len(parts) < 2:
+            continue
+        m = re.search(r"\bmodel:(\S+)", ln)
+        model = m.group(1).replace("_", " ") if m else ""
+        devices.append({"serial": parts[0], "state": parts[1], "model": model})
+    return devices
+
+
+class Adb:
+    def __init__(self, serial: str | None = None, adb_path: str = "adb"):
+        self.serial = serial
+        self.adb_path = adb_path
+        self._checked = False
+
+    def _base(self) -> list[str]:
+        cmd = [self.adb_path]
+        if self.serial:
+            cmd += ["-s", self.serial]
+        return cmd
+
+    def _devices(self) -> list[str]:
+        try:
+            proc = subprocess.run(
+                [self.adb_path, "devices"], capture_output=True, text=True, timeout=30, check=False
+            )
+        except FileNotFoundError as e:
+            raise AdbError(f"adb not found: {self.adb_path}") from e
+        out = proc.stdout or ""
+        return [ln.split()[0] for ln in out.splitlines()[1:] if re.search(r"\sdevice\b", ln)]
+
+    def relocate(self, hardware_serial: str) -> bool:
+        """Finds this phone again after a reconnect and switches to it.
+
+        A wireless phone can come back under another adb serial (its mDNS name or ip:port), so the attached
+        devices are matched on their hardware serial (ro.serialno). Returns False while it is not attached.
+        """
+        attached = self._devices()
+        if self.serial in attached:
+            return True
+        for serial in attached:
+            try:
+                found = Adb(serial, self.adb_path).shell("getprop ro.serialno").strip()
+            except AdbError:
+                continue
+            if found == hardware_serial:
+                self.serial = serial
+                return True
+        return False
+
+    def _ensure_unambiguous(self) -> None:
+        if self.serial or self._checked:
+            return
+        devices = self._devices()
+        if len(devices) > 1:
+            raise AdbError(
+                "multiple adb devices attached (" + ", ".join(devices) + "); "
+                "pass an explicit serial"
+            )
+        self._checked = True
+
+    def run(self, *args: str, timeout: float = 30) -> str:
+        self._ensure_unambiguous()
+        cmd = self._base() + [str(a) for a in args]
+        try:
+            proc = subprocess.run(cmd, capture_output=True, text=True, timeout=timeout, check=False)
+        except FileNotFoundError as e:
+            raise AdbError(f"adb not found: {self.adb_path}") from e
+        except subprocess.TimeoutExpired as e:
+            raise AdbError(f"adb timed out: {' '.join(cmd)}") from e
+        if proc.returncode != 0:
+            raise AdbError(f"adb failed ({proc.returncode}): {(proc.stderr or proc.stdout).strip()}")
+        return proc.stdout or ""
+
+    def shell(self, cmd: str) -> str:
+        return self.run("shell", cmd)
+
+    def push(self, local: str, remote: str) -> None:
+        self.run("push", str(local), remote, timeout=120)
+
+    def forward(self, remote: str = "localabstract:headroid") -> int:
+        out = self.run("forward", "tcp:0", remote).strip()
+        m = re.search(r"\d+", out)
+        if not m:
+            raise AdbError(f"could not parse forwarded port from adb output: {out!r}")
+        return int(m.group())
+
+    def remove_forward(self, port: int) -> None:
+        self.run("forward", "--remove", f"tcp:{port}")
+
+    def popen_shell(self, cmd: str) -> subprocess.Popen:
+        self._ensure_unambiguous()
+        return subprocess.Popen(
+            self._base() + ["shell", cmd],
+            stdout=subprocess.PIPE,
+            stderr=subprocess.STDOUT,
+            text=True,
+        )

headroid/cli.py

@@ -0,0 +1,88 @@
+# Copyright 2026 Anand S Kale and the headroid contributors
+# SPDX-License-Identifier: Apache-2.0
+"""Command line: headroid devices|doctor|launch|info|screenshot|tree."""
+
+from __future__ import annotations
+
+import argparse
+import json
+import os
+import sys
+import time
+
+from .adb import AdbError, list_devices
+from .device import Device
+from .doctor import ok, run_doctor
+
+
+def _parser() -> argparse.ArgumentParser:
+    p = argparse.ArgumentParser(prog="headroid")
+    sub = p.add_subparsers(dest="cmd", required=True)
+    sub.add_parser("devices", help="list adb devices")
+    s = sub.add_parser("doctor", help="check that this machine and phone are ready")
+    s.add_argument("--serial", default=None)
+    s.add_argument("--jar", default=None)
+    s = sub.add_parser("launch", help="launch an app on a hidden display and screenshot it")
+    s.add_argument("package")
+    s.add_argument("--activity", default=None)
+    s.add_argument("--screenshot", default=None, metavar="OUT.png")
+    s.add_argument("--wait", type=float, default=3.0, metavar="SECONDS")
+    s.add_argument("--serial", default=None)
+    s.add_argument("--jar", default=None)
+    for name in ("info", "screenshot", "tree"):
+        s = sub.add_parser(name)
+        s.add_argument("--serial", default=None)
+        s.add_argument("--jar", default=None)
+        if name == "screenshot":
+            s.add_argument("-o", "--output", default="screenshot.png")
+    return p
+
+
+def _devices() -> int:
+    try:
+        devices = list_devices(os.environ.get("ADB", "adb"))
+    except AdbError as e:
+        print(f"error: {e}", file=sys.stderr)
+        return 1
+    if not devices:
+        print("no devices attached")
+    for d in devices:
+        print(f"{d['serial']}\t{d['state']}\t{d['model']}")
+    return 0
+
+
+def _doctor(args) -> int:
+    checks = run_doctor(args.serial, args.jar, report=lambda c: print(c.line()))
+    return 0 if ok(checks) else 1
+
+
+def main(argv: list[str] | None = None) -> int:
+    args = _parser().parse_args(argv)
+    if args.cmd == "devices":
+        return _devices()
+    if args.cmd == "doctor":
+        return _doctor(args)
+    dev = Device.connect(serial=args.serial, jar=args.jar)
+    try:
+        if args.cmd == "info":
+            print(json.dumps(dev.info(), indent=2))
+        else:
+            display = dev.create_display()
+            if args.cmd == "launch":
+                display.launch(args.package, args.activity)
+                time.sleep(args.wait)
+                out = args.screenshot or "launch.png"
+                data = display.screenshot(out)
+                print(f"wrote {out} ({len(data)} bytes)")
+            elif args.cmd == "screenshot":
+                data = display.screenshot(args.output)
+                print(f"wrote {args.output} ({len(data)} bytes)")
+            else:
+                print(json.dumps(display.tree(), indent=2))
+    finally:
+        dev.close()
+    return 0
+
+
+if __name__ == "__main__":
+    sys.exit(main())

headroid/device.py

@@ -0,0 +1,209 @@
+# Copyright 2026 Anand S Kale and the headroid contributors
+# SPDX-License-Identifier: Apache-2.0
+"""High-level Device and Display objects."""
+
+from __future__ import annotations
+
+import base64
+import os
+import time
+from collections.abc import Callable
+from typing import Self
+
+from .adb import Adb
+from .jar import resolve_jar
+from .rpc import RpcClient, RpcError
+from .server import ServerProcess
+
+
+class Display:
+    def __init__(
+        self,
+        client: RpcClient,
+        info: dict,
+        clock: Callable[[], float] = time.monotonic,
+        sleep: Callable[[float], None] = time.sleep,
+    ):
+        self._c = client
+        self.info = info
+        self.id: int = info["displayId"]
+        self._clock = clock
+        self._sleep = sleep
+
+    def launch(
+        self,
+        package: str,
+        activity: str | None = None,
+        mute: bool = True,
+        mute_notifications: bool = False,
+    ) -> None:
+        """Starts the app on this display.
+
+        mute: silence its sound and vibration (app-ops, restored when the app is stopped or the session ends).
+        mute_notifications: also block its notifications by revoking the notification permission. The app
+        can see this and may ask for the permission again, so it is off by default; skipped if the app is
+        already running.
+        """
+        self._c.call(
+            "app.launch",
+            displayId=self.id,
+            package=package,
+            activity=activity,
+            mute=mute,
+            muteNotifications=mute_notifications,
+        )
+
+    def tap(self, x: int, y: int) -> None:
+        self._c.call("input.tap", displayId=self.id, x=x, y=y)
+
+    def long_press(self, x: int, y: int, duration_ms: int = 600) -> None:
+        self._c.call("input.longPress", displayId=self.id, x=x, y=y, durationMs=duration_ms)
+
+    def swipe(self, x1: int, y1: int, x2: int, y2: int, duration_ms: int = 300) -> None:
+        self._c.call(
+            "input.swipe", displayId=self.id, x1=x1, y1=y1, x2=x2, y2=y2, durationMs=duration_ms
+        )
+
+    def key(self, code: int, meta_state: int = 0) -> None:
+        self._c.call("input.key", displayId=self.id, keyCode=code, metaState=meta_state)
+
+    def type(self, text: str) -> None:
+        self._c.call("input.text", displayId=self.id, text=text)
+
+    def screenshot(self, path: str | None = None, format: str = "png") -> bytes:
+        res = self._c.call("display.screenshot", displayId=self.id, format=format)
+        data = base64.b64decode(res["data"])
+        if path:
+            with open(path, "wb") as f:
+                f.write(data)
+        return data
+
+    def tree(self) -> list[dict]:
+        return self._c.call("ui.tree", displayId=self.id).get("nodes", [])
+
+    def find(
+        self, text: str | None = None, rid: str | None = None, desc: str | None = None
+    ) -> dict | None:
+        if text is None and rid is None and desc is None:
+            return None
+
+        def match(n: dict) -> bool:
+            if text is not None and n.get("text") != text:
+                return False
+            if desc is not None and n.get("desc") != desc:
+                return False
+            if rid is not None:
+                nrid = n.get("rid") or ""
+                if nrid != rid and nrid.rsplit("/", 1)[-1] != rid:
+                    return False
+            return True
+
+        def walk(nodes):
+            for n in nodes:
+                if match(n):
+                    return n
+                found = walk(n.get("children") or [])
+                if found:
+                    return found
+            return None
+
+        return walk(self.tree())
+
+    def _on_screen(self, node: dict) -> bool:
+        left, top, right, bottom = node["bounds"]
+        width, height = self.info["width"], self.info["height"]
+        return 0 <= left < right <= width and 0 <= top < bottom <= height
+
+    def wait_for(
+        self,
+        text: str | None = None,
+        rid: str | None = None,
+        desc: str | None = None,
+        timeout: float = 10.0,
+    ) -> dict:
+        """Waits until the node is visible, fully on the display and at the same bounds on two reads.
+
+        During an activity transition the tree reports the incoming window's nodes at their animated
+        position (shifted by a display width for ~0.8 s), so acting on the first sighting misses.
+        """
+        deadline = self._clock() + timeout
+        last = None
+        while self._clock() < deadline:
+            node = self.find(text=text, rid=rid, desc=desc)
+            if node is not None and node.get("visible", True) and self._on_screen(node):
+                if last is not None and node["bounds"] == last:
+                    return node
+                last = node["bounds"]
+            else:
+                last = None
+            self._sleep(0.2)
+        criteria = {k: v for k, v in (("text", text), ("rid", rid), ("desc", desc)) if v is not None}
+        raise TimeoutError(f"not found on screen and settled within {timeout}s: {criteria}")
+
+    def click(
+        self,
+        text: str | None = None,
+        rid: str | None = None,
+        desc: str | None = None,
+        timeout: float = 10.0,
+    ) -> dict:
+        node = self.wait_for(text=text, rid=rid, desc=desc, timeout=timeout)
+        left, top, right, bottom = node["bounds"]
+        self.tap((left + right) // 2, (top + bottom) // 2)
+        return node
+
+    def fill(
+        self,
+        value: str,
+        text: str | None = None,
+        rid: str | None = None,
+        desc: str | None = None,
+        timeout: float = 10.0,
+    ) -> dict:
+        node = self.click(text=text, rid=rid, desc=desc, timeout=timeout)
+        self.type(value)
+        return node
+
+    def release(self) -> None:
+        self._c.call("display.release", displayId=self.id)
+
+
+class Device:
+    def __init__(self, client: RpcClient, server: ServerProcess | None = None):
+        self.client = client
+        self.server = server
+        self.displays: list[Display] = []
+
+    @classmethod
+    def connect(cls, serial: str | None = None, jar: str | None = None) -> Self:
+        jar = resolve_jar(jar)
+        adb = Adb(serial, os.environ.get("ADB", "adb"))
+        server = ServerProcess(adb, jar)
+        return cls(server.start(), server)
+
+    def info(self) -> dict:
+        return self.client.call("server.info")
+
+    def create_display(self, width: int = 720, height: int = 1600, dpi: int = 320) -> Display:
+        res = self.client.call("display.create", width=width, height=height, dpi=dpi)
+        d = Display(self.client, res)
+        self.displays.append(d)
+        return d
+
+    def close(self) -> None:
+        for d in self.displays:
+            try:
+                d.release()
+            except (OSError, RpcError):
+                pass
+        self.displays.clear()
+        if self.server is not None:
+            self.server.stop()
+        else:
+            self.client.close()
+
+    def __enter__(self) -> Self:
+        return self
+
+    def __exit__(self, *exc) -> None:
+        self.close()

headroid/doctor.py

@@ -0,0 +1,201 @@
+# Copyright 2026 Anand S Kale and the headroid contributors
+# SPDX-License-Identifier: Apache-2.0
+"""`headroid doctor`: ordered environment checks, each with a one-line fix."""
+
+from __future__ import annotations
+
+import os
+import subprocess
+from collections.abc import Callable
+from dataclasses import dataclass
+
+from .adb import Adb, AdbError, list_devices
+from .device import Device
+from .jar import BUILD_HINT, resolve_jar
+from .rpc import RpcError
+
+PASS, FAIL, WARN = "PASS", "FAIL", "WARN"
+MIN_API = 30
+VERIFIED_API = range(34, 37)  # Android 14-16
+PNG_MAGIC = b"\x89PNG\r\n\x1a\n"
+NO_FRAME = -32011
+
+
+@dataclass
+class Check:
+    status: str
+    name: str
+    detail: str = ""
+    fix: str = ""
+
+    def line(self) -> str:
+        s = f"[{self.status}] {self.name}"
+        if self.detail:
+            s += f": {self.detail}"
+        if self.fix:
+            s += f"  -> {self.fix}"
+        return s
+
+
+def run_doctor(
+    serial: str | None = None,
+    jar: str | None = None,
+    adb_path: str | None = None,
+    connect: Callable[..., Device] = Device.connect,
+    report: Callable[[Check], None] = lambda c: None,
+) -> list[Check]:
+    """Runs the checks in order, stopping at a FAIL that makes later checks meaningless."""
+    adb_path = adb_path or os.environ.get("ADB", "adb")
+    checks: list[Check] = []
+
+    def add(status: str, name: str, detail: str = "", fix: str = "") -> Check:
+        c = Check(status, name, detail, fix)
+        checks.append(c)
+        report(c)
+        return c
+
+    # 1. adb on PATH
+    try:
+        proc = subprocess.run(
+            [adb_path, "version"], capture_output=True, text=True, timeout=30, check=False
+        )
+        first = (proc.stdout or "").splitlines()[0] if proc.stdout else "version unknown"
+        add(PASS, "adb on PATH", first)
+    except (FileNotFoundError, subprocess.TimeoutExpired):
+        add(
+            FAIL,
+            "adb on PATH",
+            "not found",
+            "install Android platform-tools and add it to PATH (or set ADB=/path/to/adb)",
+        )
+        return checks
+
+    # 2. device selection
+    try:
+        devices = list_devices(adb_path)
+    except AdbError as e:
+        add(FAIL, "adb devices", str(e), "run `adb start-server` and retry")
+        return checks
+    listing = ", ".join(f"{d['serial']} ({d['state']})" for d in devices)
+    if serial is None:
+        if not devices:
+            add(
+                FAIL,
+                "device attached",
+                "none",
+                "connect the phone with USB debugging on, then run `adb devices`",
+            )
+            return checks
+        if len(devices) > 1:
+            add(
+                FAIL,
+                "device attached",
+                f"{len(devices)} devices: {listing}",
+                "pass --serial <serial>",
+            )
+            return checks
+        serial = devices[0]["serial"]
+    match = next((d for d in devices if d["serial"] == serial), None)
+    if match is None:
+        add(
+            FAIL,
+            "device attached",
+            f"{serial} not listed (attached: {listing or 'none'})",
+            "check the serial with `headroid devices`",
+        )
+        return checks
+    add(PASS, "device attached", f"{serial} {match['model']}".strip())
+
+    # 3. device state
+    state = match["state"]
+    if state == "unauthorized":
+        add(FAIL, "device state", state, "accept the USB debugging prompt on the phone")
+        return checks
+    if state == "offline":
+        add(FAIL, "device state", state, "unplug and reconnect the cable, or run `adb reconnect`")
+        return checks
+    if state != "device":
+        add(FAIL, "device state", state, "make sure the phone shows as `device` in `adb devices`")
+        return checks
+    add(PASS, "device state", state)
+
+    # 4. Android version and manufacturer
+    adb = Adb(serial, adb_path)
+    try:
+        api = int(adb.shell("getprop ro.build.version.sdk").strip())
+        maker = adb.shell("getprop ro.product.manufacturer").strip()
+    except (AdbError, ValueError) as e:
+        add(FAIL, "Android API level", str(e), "check `adb -s <serial> shell getprop`")
+        return checks
+    if api < MIN_API:
+        add(FAIL, "Android API level", f"{api}", "the server needs Android 11 (API 30) or newer")
+        return checks
+    if api not in VERIFIED_API:
+        add(WARN, "Android API level", f"{api}", "only Android 14-16 (API 34-36) are verified")
+    else:
+        add(PASS, "Android API level", f"{api}")
+    if maker.lower() in ("xiaomi", "redmi", "poco"):
+        add(
+            WARN,
+            "manufacturer",
+            maker,
+            "Developer options: enable 'USB debugging (Security settings)' for input "
+            "and 'Install via USB' for installs",
+        )
+
+    # 5. jar
+    try:
+        jar_path = resolve_jar(jar)
+    except FileNotFoundError:
+        add(FAIL, "server jar", "not found", BUILD_HINT)
+        return checks
+    if not os.path.isfile(jar_path):
+        add(FAIL, "server jar", f"{jar_path} does not exist", BUILD_HINT)
+        return checks
+    add(PASS, "server jar", jar_path)
+
+    # 6. server starts and answers, 7. hidden display screenshot
+    try:
+        dev = connect(serial=serial, jar=jar_path)
+    except Exception as e:  # noqa: BLE001 - report any startup failure as a check result
+        add(FAIL, "server starts", str(e), "keep the phone unlocked and retry")
+        return checks
+    try:
+        try:
+            info = dev.info()
+            add(
+                PASS,
+                "server.info",
+                f"sdk={info.get('sdk')} model={info.get('model')} "
+                f"capabilities={info.get('capabilities')}",
+            )
+        except Exception as e:  # noqa: BLE001
+            add(FAIL, "server.info", str(e), "the server started but does not answer")
+            return checks
+        try:
+            display = dev.create_display()
+        except Exception as e:  # noqa: BLE001
+            add(FAIL, "hidden display", str(e), "report this with `adb logcat -s scrcpy`")
+            return checks
+        add(PASS, "hidden display", f"id {display.id}")
+        try:
+            png = display.screenshot()
+            if png[:8] == PNG_MAGIC:
+                add(PASS, "hidden display screenshot", f"{len(png)} bytes PNG")
+            else:
+                add(FAIL, "hidden display screenshot", "not a PNG", "report this with adb logcat")
+        except RpcError as e:
+            if e.code == NO_FRAME:
+                # an empty display draws nothing, so there is no frame until an app is launched on it
+                add(PASS, "hidden display screenshot", "empty display, no frame until an app draws")
+            else:
+                add(FAIL, "hidden display screenshot", str(e), "report this with adb logcat")
+        except Exception as e:  # noqa: BLE001
+            add(FAIL, "hidden display screenshot", str(e), "report this with adb logcat")
+    finally:
+        dev.close()  # releases the display
+    return checks
+
+
+def ok(checks: list[Check]) -> bool:
+    return not any(c.status == FAIL for c in checks)

headroid/jar.py

@@ -0,0 +1,46 @@
+# Copyright 2026 Anand S Kale and the headroid contributors
+# SPDX-License-Identifier: Apache-2.0
+"""Finds the device-server jar: argument, env, wheel bundle, then a source checkout build."""
+
+from __future__ import annotations
+
+import os
+from importlib import resources
+from pathlib import Path
+
+ENV_VAR = "HEADROID_SERVER_JAR"
+JAR_NAME = "headroid-server.jar"
+BUILD_HINT = (
+    "build it with `cd device-server && ./gradlew :server:headroidJar` "
+    f"or point {ENV_VAR} at an existing {JAR_NAME}"
+)
+
+
+def _bundled() -> Path | None:
+    try:
+        res = resources.files("headroid").joinpath("_server", JAR_NAME)
+        with resources.as_file(res) as p:
+            return Path(p) if Path(p).is_file() else None
+    except (FileNotFoundError, ModuleNotFoundError, OSError):
+        return None
+
+
+def _source_checkout() -> Path:
+    repo = Path(__file__).resolve().parents[4]
+    return repo / "device-server" / "server" / "build" / "headroid" / JAR_NAME
+
+
+def resolve_jar(jar: str | None = None) -> str:
+    """Returns the jar path. Order: jar argument, HEADROID_SERVER_JAR, wheel bundle, source build."""
+    if jar:
+        return str(jar)
+    env = os.environ.get(ENV_VAR)
+    if env:
+        return env
+    bundled = _bundled()
+    if bundled is not None:
+        return str(bundled)
+    built = _source_checkout()
+    if built.is_file():
+        return str(built)
+    raise FileNotFoundError(f"headroid server jar not found: {BUILD_HINT}")

headroid/rpc.py

@@ -0,0 +1,53 @@
+# Copyright 2026 Anand S Kale and the headroid contributors
+# SPDX-License-Identifier: Apache-2.0
+"""Newline-delimited JSON-RPC 2.0 client."""
+
+from __future__ import annotations
+
+import json
+import socket
+import threading
+
+
+class RpcError(Exception):
+    def __init__(self, code: int, message: str):
+        super().__init__(f"[{code}] {message}")
+        self.code = code
+        self.message = message
+
+
+class RpcClient:
+    def __init__(self, host: str, port: int, timeout: float = 30):
+        self.sock = socket.create_connection((host, port), timeout=timeout)
+        self.sock.settimeout(timeout)
+        self._file = self.sock.makefile("rb")
+        self._lock = threading.Lock()
+        self._next_id = 0
+        self.events: list[dict] = []
+
+    def call(self, method: str, **params) -> dict:
+        with self._lock:
+            self._next_id += 1
+            rid = self._next_id
+            req = {"jsonrpc": "2.0", "id": rid, "method": method, "params": params}
+            self.sock.sendall(json.dumps(req).encode("utf-8") + b"\n")
+            while True:
+                line = self._file.readline()
+                if not line:
+                    raise ConnectionError("connection closed by server")
+                msg = json.loads(line)
+                if msg.get("method") == "event" and "id" not in msg:
+                    self.events.append(msg.get("params", {}))
+                    continue
+                if msg.get("id") != rid:
+                    continue
+                if msg.get("error") is not None:
+                    err = msg["error"]
+                    raise RpcError(err.get("code", -32000), err.get("message", ""))
+                return msg.get("result") or {}
+
+    def close(self) -> None:
+        try:
+            self._file.close()
+        finally:
+            self.sock.close()

headroid/server.py

@@ -0,0 +1,154 @@
+# Copyright 2026 Anand S Kale and the headroid contributors
+# SPDX-License-Identifier: Apache-2.0
+"""Pushes, starts and stops the headroid device server on the phone."""
+
+from __future__ import annotations
+
+import hashlib
+import secrets
+import time
+
+from .adb import Adb, AdbError
+from .rpc import RpcClient, RpcError
+
+REMOTE_DIR = "/data/local/tmp"
+MAIN_CLASS = "dev.headroid.server.HeadroidServer"
+# How long the server keeps the session (displays, apps, mutes) without a host. Long enough for a wireless adb
+# reconnect or a short laptop sleep; after it the server tears everything down and exits.
+GRACE_S = 60
+
+# Calls that read state only: safe to resend after a reconnect. Actions are not resent, since they may have run.
+SAFE_TO_RETRY = {"server.info", "display.list", "display.screenshot", "ui.tree"}
+
+
+def remote_jar_path(jar_path: str) -> str:
+    """Where the jar goes on the phone, named by its content so a push never overwrites a jar that another
+    running server (another session, another headroid version) still has open."""
+    with open(jar_path, "rb") as f:
+        digest = hashlib.sha256(f.read()).hexdigest()[:12]
+    return f"{REMOTE_DIR}/headroid-server-{digest}.jar"
+
+
+class ReconnectingClient:
+    """An RpcClient that survives a dropped connection (wireless adb reconnect, laptop sleep).
+
+    On a connection error it reconnects to the same server, which kept the session. Read-only calls are then
+    resent; for actions it raises ConnectionError saying the action may or may not have run.
+    """
+
+    def __init__(self, server: ServerProcess, client: RpcClient):
+        self._server = server
+        self._client = client
+
+    @property
+    def events(self) -> list[dict]:
+        return self._client.events
+
+    def call(self, method: str, **params) -> dict:
+        try:
+            return self._client.call(method, **params)
+        except (ConnectionError, OSError) as first:
+            if method == "server.shutdown":
+                raise
+            self._client = self._server.reconnect()
+            if method in SAFE_TO_RETRY:
+                return self._client.call(method, **params)
+            raise ConnectionError(
+                f"connection to the phone dropped during {method} and was restored; "
+                "the action may or may not have run"
+            ) from first
+
+    def close(self) -> None:
+        self._client.close()
+
+
+class ServerProcess:
+    def __init__(
+        self, adb: Adb, jar_path: str, socket: str | None = None, grace_s: float = GRACE_S
+    ):
+        self.adb = adb
+        self.jar_path = jar_path
+        self.socket = socket or f"headroid-{secrets.token_hex(4)}"
+        self.grace_s = grace_s
+        self.port: int | None = None
+        self.client: ReconnectingClient | None = None
+        self.hardware_serial = ""  # ro.serialno, to find the phone again under a new adb serial
+
+    def start(self, connect_timeout: float = 10) -> ReconnectingClient:
+        remote = remote_jar_path(self.jar_path)
+        self.hardware_serial = self.adb.shell("getprop ro.serialno").strip()
+        self.adb.push(self.jar_path, remote)
+        # setsid and closed stdio: the server must outlive this adb shell, so a dropped wireless connection
+        # does not kill it (it would take the session with it); its own watchdog ends it when no host returns.
+        cmd = (
+            f"CLASSPATH={remote} setsid app_process / {MAIN_CLASS} socket={self.socket} "
+            f"grace_ms={int(self.grace_s * 1000)} </dev/null >/dev/null 2>&1 &"
+        )
+        self.adb.shell(cmd)
+        try:
+            client = self._connect(connect_timeout)
+        except TimeoutError as e:
+            self.stop()
+            raise TimeoutError(f"headroid server did not come up in {connect_timeout}s: {e}") from e
+        self.client = ReconnectingClient(self, client)
+        return self.client
+
+    def _connect(self, timeout: float) -> RpcClient:
+        deadline = time.monotonic() + timeout
+        last: Exception | None = None
+        while time.monotonic() < deadline:
+            client = None
+            try:
+                if self.port is None:
+                    if self.hardware_serial and not self.adb.relocate(self.hardware_serial):
+                        raise AdbError("the phone is not attached (yet)")
+                    self.port = self.adb.forward(f"localabstract:{self.socket}")
+                # adb accepts the forwarded connection even before the server listens,
+                # so confirm with a real call.
+                client = RpcClient("127.0.0.1", self.port)
+                client.call("server.info")
+                return client
+            except (OSError, RpcError, ValueError, AdbError) as e:
+                last = e
+                if client is not None:
+                    try:
+                        client.close()
+                    except OSError:
+                        pass
+                time.sleep(0.25)
+        raise TimeoutError(str(last))
+
+    def reconnect(self) -> RpcClient:
+        """Connects again to the same server, for up to the grace period. A new adb transport needs a new
+        port forward, so the old one is dropped first."""
+        if self.port is not None:
+            try:
+                self.adb.remove_forward(self.port)
+            except AdbError:
+                pass
+            self.port = None
+        try:
+            return self._connect(self.grace_s)
+        except TimeoutError as e:
+            raise ConnectionError(
+                f"lost the phone and could not reconnect within {self.grace_s:.0f}s; "
+                f"the server has torn the session down: {e}"
+            ) from e
+
+    def stop(self) -> None:
+        if self.client is not None:
+            try:
+                self.client.call("server.shutdown")
+            except (OSError, RpcError):
+                pass
+            try:
+                self.client.close()
+            except OSError:
+                pass
+            self.client = None
+        if self.port is not None:
+            try:
+                self.adb.remove_forward(self.port)
+            except AdbError:
+                pass
+            self.port = None

headroid-0.1.0a1.dist-info/METADATA

@@ -0,0 +1,125 @@
+Metadata-Version: 2.5
+Name: headroid
+Version: 0.1.0a1
+Summary: Test Android apps on a hidden display of your own phone while you keep using it.
+Project-URL: Homepage, https://github.com/anand-s-kale/headroid
+Project-URL: Documentation, https://github.com/anand-s-kale/headroid/tree/main/packages/headroid#readme
+Project-URL: Issues, https://github.com/anand-s-kale/headroid/issues
+Project-URL: Changelog, https://github.com/anand-s-kale/headroid/blob/main/CHANGELOG.md
+Author: Anand S Kale and the headroid contributors
+License-Expression: Apache-2.0
+Keywords: adb,ai-agents,android,automation,headless,testing,ui-testing,virtual-display
+Classifier: Development Status :: 3 - Alpha
+Classifier: Intended Audience :: Developers
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Topic :: Software Development :: Testing
+Classifier: Topic :: Software Development :: Testing :: Acceptance
+Requires-Python: >=3.11
+Provides-Extra: dev
+Requires-Dist: pytest>=8; extra == 'dev'
+Requires-Dist: ruff; extra == 'dev'
+Description-Content-Type: text/markdown
+
+# headroid (Python host)
+
+Run Android apps on a hidden virtual display and drive them from Python. No runtime dependencies;
+needs `adb` on PATH and an Android 11+ phone with USB debugging on (Android 14-16 are verified).
+
+## 1. Install
+
+```
+pip install --pre headroid
+```
+
+(`--pre` while headroid is an alpha. The wheel is also attached to each
+[GitHub release](https://github.com/anand-s-kale/headroid/releases).)
+
+The wheel bundles the device-server jar, so there is nothing else to build. From a source checkout instead:
+`cd device-server && ./gradlew :server:headroidJar`, then `pip install -e packages/headroid`; the jar is found
+in the build folder (or set `HEADROID_SERVER_JAR`).
+
+## 2. Check your setup
+
+```
+headroid devices
+headroid doctor            # add --serial <serial> when more than one device is attached
+```
+
+`doctor` checks adb, the device and its state, the Android version, the server jar, and that the server can
+create a hidden display and take a screenshot. Each line is PASS, WARN or FAIL with a one-line fix. It exits
+0 unless something FAILed.
+
+**Xiaomi / Redmi / POCO:** in Developer options enable "USB debugging (Security settings)" (needed for
+input) and "Install via USB" (needed to install apps).
+
+## 3. See an app on a hidden display
+
+```
+headroid launch dev.headroid.sample --screenshot shot.png
+```
+
+This creates a hidden display, launches the app on it, waits 3 seconds (`--wait`), saves the screenshot and
+releases the display. Nothing appears on the phone's own screen.
+
+## 4. Drive it from Python
+
+```python
+from headroid import Device
+
+with Device.connect() as dev:                      # jar found automatically
+    d = dev.create_display(720, 1600, 320)         # hidden virtual display
+    d.launch("dev.headroid.sample")
+    d.click(rid="nav_login")                       # waits until the node has settled, then taps it
+    d.fill("demo@headroid.dev", rid="login_email")
+    d.fill("headroid", rid="login_password")
+    d.click(rid="login_submit")
+    d.wait_for(rid="form_name")                    # raises TimeoutError naming what it waited for
+    d.screenshot("form.png")
+```
+
+`click`, `fill` and `wait_for` take `text=`, `rid=` or `desc=` and a `timeout` (default 10 s). They wait
+until the node is visible, fully on the display and at the same position on two reads in a row, because
+during an activity transition nodes are reported at animated positions and an immediate tap misses.
+Lower-level calls (`tap`, `swipe`, `key`, `type`, `tree`, `find`) are also available.
+
+## What stays with you, and what does not
+
+- Taps, typing and the keyboard go to the hidden display only; your screen keeps focus.
+- `launch` mutes the app's **sound and vibration** (app-ops) and restores them when the app is stopped or the
+  session ends, even if the server was killed (the next server start restores them). Pass `mute=False` to hear it.
+  App-ops are per app: while muted, the same app is silent on your screen too.
+- **Notifications** still reach your notification shade by default. `launch(..., mute_notifications=True)` blocks
+  them by revoking the notification permission while the session runs; the app can see that and may ask for the
+  permission again, so it is opt-in, and it is skipped when the app is already running.
+- Toasts, dialogs and permission prompts appear on the hidden display.
+- A Wi-Fi drop does not end the session: the server keeps it for 60 s, the host reconnects (finding the phone even
+  under a new adb serial) and resends reads; an action that was in flight raises `ConnectionError` saying it may or
+  may not have run. If no host returns within 60 s, the server tears everything down and exits.
+- Several sessions can share one phone: each gets its own server socket and its own mute records.
+- At the end, an app is force-stopped only if headroid started it and nobody else has it open. If it was already
+  running (your copy on the phone, or another session's), only the hidden display is closed and the app keeps running.
+- Android has one UiAutomation (used for the UI tree and `setText` typing) for every tool on the phone. headroid holds it
+  only while reading the screen and releases it after 1 s idle; when another tool (Appium, `uiautomator`, Maestro,
+  another session) holds it, a tree read waits up to 10 s, then fails with a message naming the cause.
+
+## Other commands
+
+```
+headroid info | screenshot -o shot.png | tree     # all accept --serial and --jar
+```
+
+`--jar` is optional everywhere. Resolution order: `--jar` / `jar=`, then `HEADROID_SERVER_JAR`, then the
+jar bundled in the wheel, then a source-checkout build.
+
+## Development
+
+```
+python -m venv .venv && .venv/Scripts/python -m pip install -e ".[dev]" && python -m pytest -q
+```
+
+Tests use a fake JSON-RPC server and a fake adb; no phone needed. To build a wheel with the jar bundled:
+build the jar, then `python scripts/build_wheel.py` (needs `pip install build`).

headroid-0.1.0a1.dist-info/RECORD

@@ -0,0 +1,15 @@
+headroid/__init__.py,sha256=luJ2VylxdOLujtcnXtOlP4c1nz0J89CTAAlEp4PvyCw,467
+headroid/adb.py,sha256=AtkwOv5TYDvktPTo_qK8V_qYyxNZUHt3qOQbm0dCx9E,4512
+headroid/cli.py,sha256=DdOYPBkLajzDOgtIyJ6-1RhEYKbOoPCp-R19NHh_5_0,2958
+headroid/device.py,sha256=c12bA3_XcmnL1Z4zPoee5Vmed4I4p39CMgomDXvrd68,7031
+headroid/doctor.py,sha256=q3UgVYcPXpm7vmdU0hN654Dmd4irqGwPFjmm4lj6JIc,7094
+headroid/jar.py,sha256=EzFMXsnlFdxcGlL5hBT6DcYxc2jAr5Edd2JKf3k2ESo,1451
+headroid/rpc.py,sha256=-4r60p4u8cc-ejYRvJO5nLyyfqMILAT52oApWK4cubQ,1827
+headroid/server.py,sha256=FKE5WhyXhH6XlV7cPfgpod1M3Zb7guhedc-pJN5k1bs,6159
+headroid/_server/LICENSE,sha256=z8d0m5b2O9McPEK1xHG_dWgUBT6EfBDz6wA0F7xSPTA,11358
+headroid/_server/NOTICE,sha256=SQgQGkFlyrtXVstRD9bBaD118sxacHoCcwYoaxFYlk4,1567
+headroid/_server/headroid-server.jar,sha256=AbKb5UMLF7NNy34-uvfvgUTxgsCUb7LnGJy10DfrfFo,2360494
+headroid-0.1.0a1.dist-info/METADATA,sha256=jpmsNu8pnG0SYcNZPA8j26XnHPZAHxAs7PBgmwZDgQI,6175
+headroid-0.1.0a1.dist-info/WHEEL,sha256=2iZrJkDIkeDh0k9SikKMqFuRP-ua6mb4Ir1AsER4BEw,87
+headroid-0.1.0a1.dist-info/entry_points.txt,sha256=BUJQpsPibbrP7LnLEYdcH0lGRvHpVCh5_W_jQtMsbYA,47
+headroid-0.1.0a1.dist-info/RECORD,,

headroid-0.1.0a1.dist-info/WHEEL

@@ -0,0 +1,4 @@
+Wheel-Version: 1.0
+Generator: hatchling 1.33.0
+Root-Is-Purelib: true
+Tag: py3-none-any

headroid-0.1.0a1.dist-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+headroid = headroid.cli:main