chp-adapter-launchd 0.10.0__py3-none-any.whl

chp_adapter_launchd/__init__.py

@@ -0,0 +1,21 @@
+"""chp-adapter-launchd — govern macOS launchd services as CHP capabilities.
+
+Manage long-running LaunchAgent services (list/status/start/stop/install/uninstall)
+with evidence. Scoped by a managed label prefix (default ``com.chp.``) so it only
+touches CHP's own services. launchctl + plist I/O is isolated in ``_backends.py``.
+
+Usage::
+
+    from chp_core import LocalCapabilityHost, register_adapter
+    from chp_adapter_launchd import LaunchdAdapter, LaunchdConfig
+
+    host = LocalCapabilityHost()
+    register_adapter(host, LaunchdAdapter(LaunchdConfig()))
+    result = host.invoke("chp.adapters.launchd.list", {})
+"""
+
+from __future__ import annotations
+
+from .adapter import LaunchdAdapter, LaunchdConfig
+
+__all__ = ["LaunchdAdapter", "LaunchdConfig"]

chp_adapter_launchd/_backends.py

@@ -0,0 +1,145 @@
+"""launchd backend — the only file that touches launchctl and the filesystem.
+
+Isolated here (the CLI-adapter convention used by git/radicle/process) so
+adapter.py contains no subprocess or file I/O in its capability bodies and stays
+conformance-clean. The adapter depends only on the LaunchdBackend protocol.
+"""
+
+from __future__ import annotations
+
+import os
+import plistlib
+import subprocess
+from pathlib import Path
+from typing import Any, Protocol, runtime_checkable
+
+_LAUNCHCTL = "/bin/launchctl"
+_TIMEOUT = 30.0
+
+
+@runtime_checkable
+class LaunchdBackend(Protocol):
+    def list_services(self, prefix: str) -> list[dict]: ...
+    def status(self, label: str) -> dict: ...
+    def start(self, label: str, plist_path: str | None) -> dict: ...
+    def stop(self, label: str) -> dict: ...
+    def install(self, label: str, spec: dict) -> dict: ...
+    def uninstall(self, label: str) -> dict: ...
+
+
+def _domain() -> str:
+    return f"gui/{os.getuid()}"
+
+
+def _agents_dir() -> Path:
+    return Path.home() / "Library" / "LaunchAgents"
+
+
+def _plist_path(label: str) -> Path:
+    return _agents_dir() / f"{label}.plist"
+
+
+def _run(args: list[str]) -> subprocess.CompletedProcess:
+    return subprocess.run(args, capture_output=True, text=True, timeout=_TIMEOUT)
+
+
+class _RealLaunchdBackend:
+    """Wraps launchctl + plistlib for managing user LaunchAgents."""
+
+    def _list_raw(self) -> list[dict]:
+        proc = _run([_LAUNCHCTL, "list"])
+        services: list[dict] = []
+        for line in proc.stdout.splitlines()[1:]:  # skip header "PID Status Label"
+            parts = line.split("\t")
+            if len(parts) != 3:
+                continue
+            pid_s, status_s, label = parts
+            pid = int(pid_s) if pid_s.lstrip("-").isdigit() and pid_s != "-" else None
+            try:
+                last_exit = int(status_s)
+            except ValueError:
+                last_exit = None
+            services.append({
+                "label": label,
+                "pid": pid,
+                "running": pid is not None,
+                "last_exit_code": last_exit,
+            })
+        return services
+
+    def list_services(self, prefix: str) -> list[dict]:
+        return [s for s in self._list_raw() if s["label"].startswith(prefix)]
+
+    def status(self, label: str) -> dict:
+        match = next((s for s in self._list_raw() if s["label"] == label), None)
+        plist_exists = _plist_path(label).exists()
+        if match is None:
+            return {"label": label, "loaded": False, "running": False, "pid": None,
+                    "last_exit_code": None, "plist_exists": plist_exists}
+        return {"label": label, "loaded": True, "running": match["running"],
+                "pid": match["pid"], "last_exit_code": match["last_exit_code"],
+                "plist_exists": plist_exists}
+
+    def start(self, label: str, plist_path: str | None) -> dict:
+        loaded = any(s["label"] == label for s in self._list_raw())
+        if loaded:
+            proc = _run([_LAUNCHCTL, "kickstart", "-k", f"{_domain()}/{label}"])
+            action = "kickstart"
+        else:
+            path = plist_path or str(_plist_path(label))
+            if not Path(path).exists():
+                raise FileNotFoundError(f"No plist for {label!r} at {path}; install it first.")
+            proc = _run([_LAUNCHCTL, "bootstrap", _domain(), path])
+            action = "bootstrap"
+        ok = proc.returncode == 0
+        return {"label": label, "action": action, "ok": ok,
+                "returncode": proc.returncode, "stderr": proc.stderr.strip()[:300]}
+
+    def stop(self, label: str) -> dict:
+        proc = _run([_LAUNCHCTL, "bootout", f"{_domain()}/{label}"])
+        return {"label": label, "action": "bootout", "ok": proc.returncode == 0,
+                "returncode": proc.returncode, "stderr": proc.stderr.strip()[:300]}
+
+    def install(self, label: str, spec: dict) -> dict:
+        program: str = spec["program"]
+        args: list[str] = spec.get("args") or []
+        plist: dict[str, Any] = {
+            "Label": label,
+            "ProgramArguments": [program, *args],
+            "RunAtLoad": bool(spec.get("run_at_load", True)),
+            "KeepAlive": bool(spec.get("keep_alive", True)),
+        }
+        if spec.get("env"):
+            plist["EnvironmentVariables"] = dict(spec["env"])
+        if spec.get("working_dir"):
+            plist["WorkingDirectory"] = spec["working_dir"]
+        if spec.get("stdout_path"):
+            plist["StandardOutPath"] = spec["stdout_path"]
+        if spec.get("stderr_path"):
+            plist["StandardErrorPath"] = spec["stderr_path"]
+
+        _agents_dir().mkdir(parents=True, exist_ok=True)
+        path = _plist_path(label)
+        with open(path, "wb") as fh:
+            plistlib.dump(plist, fh)
+
+        # Re-bootstrap: bootout first if already loaded (ignore failure), then bootstrap.
+        _run([_LAUNCHCTL, "bootout", f"{_domain()}/{label}"])
+        proc = _run([_LAUNCHCTL, "bootstrap", _domain(), str(path)])
+        return {"label": label, "plist_path": str(path), "ok": proc.returncode == 0,
+                "returncode": proc.returncode, "stderr": proc.stderr.strip()[:300],
+                "env_keys": sorted((spec.get("env") or {}).keys())}
+
+    def uninstall(self, label: str) -> dict:
+        boot = _run([_LAUNCHCTL, "bootout", f"{_domain()}/{label}"])
+        path = _plist_path(label)
+        removed = False
+        if path.exists():
+            path.unlink()
+            removed = True
+        return {"label": label, "booted_out": boot.returncode == 0,
+                "plist_removed": removed, "plist_path": str(path)}
+
+
+def make_backend() -> _RealLaunchdBackend:
+    return _RealLaunchdBackend()

chp_adapter_launchd/adapter.py

@@ -0,0 +1,393 @@
+"""LaunchdAdapter — govern macOS launchd (LaunchAgent) services as CHP capabilities.
+
+Manage long-running local services — start, stop, status, and install/uninstall
+persistent LaunchAgents — with evidence. Built for CHP's own infrastructure
+services (e.g. the TEI and vLLM Metal servers) so they survive reboot and can be
+governed through the capability host.
+
+All launchctl + plist I/O is isolated in _backends.py (the CLI-adapter convention
+used by git/radicle/process); the adapter delegates and emits.
+
+Evidence policy:
+  Emitted: label, operation, pid, returncode, plist path, env *keys*, latency.
+  NOT emitted: environment variable VALUES (may hold tokens), plist file contents.
+"""
+
+from __future__ import annotations
+
+import asyncio
+import time
+from dataclasses import dataclass, field
+from typing import Any
+
+from chp_core import BaseAdapter, capability
+
+from ._backends import LaunchdBackend, make_backend
+
+_EMITS = [
+    "launchd_listed",
+    "launchd_status_checked",
+    "launchd_start_started",
+    "launchd_start_completed",
+    "launchd_start_failed",
+    "launchd_stop_started",
+    "launchd_stop_completed",
+    "launchd_stop_failed",
+    "launchd_install_started",
+    "launchd_install_completed",
+    "launchd_install_failed",
+    "launchd_uninstall_completed",
+    "service_health_checked",
+]
+
+_HTTP_CAP = "chp.adapters.http.request"
+
+# Default model-server readiness probes; overridable in LaunchdConfig.
+_DEFAULT_MODEL_PROBES = [
+    {"name": "tei", "url": "http://localhost:8090/health", "expect_status": 200},
+    {"name": "vllm", "url": "http://localhost:8092/v1/models", "expect_status": 200},
+    {"name": "scout", "url": "http://localhost:8094/health", "expect_status": 200},
+]
+
+_DEFAULT_PREFIX = "com.chp."
+
+
+@dataclass
+class LaunchdConfig:
+    """Config for LaunchdAdapter.
+
+    ``managed_prefix`` — only labels with this prefix may be managed (safety: the
+    adapter will not touch arbitrary system services). ``list`` is also scoped to it.
+    ``model_probes`` — list of {name, url, expect_status} dicts for service_health
+    readiness checks (defaults to TEI + vllm at their standard ports).
+    """
+    managed_prefix: str = _DEFAULT_PREFIX
+    model_probes: list[dict] = field(default_factory=lambda: list(_DEFAULT_MODEL_PROBES))
+    _backend: Any = field(default=None, repr=False)
+
+
+class LaunchdAdapter(BaseAdapter):
+    """Manage macOS LaunchAgent services as governed CHP capabilities."""
+
+    adapter_id = "chp.adapters.launchd"
+    adapter_name = "Launchd"
+    adapter_description = (
+        "Govern macOS launchd LaunchAgent services: list, status, start, stop, "
+        "install (generate plist + bootstrap), uninstall."
+    )
+    adapter_category = "infrastructure"
+    adapter_tags = ["launchd", "launchctl", "service", "macos", "daemon", "infrastructure"]
+
+    def __init__(self, config: LaunchdConfig | None = None) -> None:
+        self._config = config or LaunchdConfig()
+        self.__backend: LaunchdBackend | None = None
+
+    def _backend(self) -> LaunchdBackend:
+        if self._config._backend is not None:
+            return self._config._backend
+        if self.__backend is None:
+            self.__backend = make_backend()
+        return self.__backend
+
+    def _check_managed(self, label: str) -> None:
+        if not label.startswith(self._config.managed_prefix):
+            raise ValueError(
+                f"Label {label!r} is not managed by this adapter "
+                f"(must start with {self._config.managed_prefix!r})."
+            )
+
+    # ------------------------------------------------------------------
+    # list
+    # ------------------------------------------------------------------
+
+    @capability(
+        id="chp.adapters.launchd.list",
+        version="1.0.0",
+        description="List CHP-managed launchd services (scoped to the managed label prefix).",
+        category="infrastructure",
+        provider="launchd",
+        risk="low",
+        emits=_EMITS,
+        input_schema={"type": "object", "properties": {}, "additionalProperties": False},
+    )
+    async def list(self, ctx: Any, payload: dict) -> dict:
+        t0 = time.monotonic()
+        services = await asyncio.to_thread(self._backend().list_services, self._config.managed_prefix)
+        latency_ms = round((time.monotonic() - t0) * 1000)
+        ctx.emit("launchd_listed", {"service_count": len(services), "latency_ms": latency_ms}, redacted=False)
+        return {"services": services, "service_count": len(services), "latency_ms": latency_ms}
+
+    # ------------------------------------------------------------------
+    # status
+    # ------------------------------------------------------------------
+
+    @capability(
+        id="chp.adapters.launchd.status",
+        version="1.0.0",
+        description="Report whether a launchd service is loaded/running, its pid, and last exit code.",
+        category="infrastructure",
+        provider="launchd",
+        risk="low",
+        emits=_EMITS,
+        input_schema={
+            "type": "object",
+            "properties": {"label": {"type": "string", "description": "Service label, e.g. com.chp.tei"}},
+            "required": ["label"],
+            "additionalProperties": False,
+        },
+    )
+    async def status(self, ctx: Any, payload: dict) -> dict:
+        label = payload["label"]
+        self._check_managed(label)
+        t0 = time.monotonic()
+        result = await asyncio.to_thread(self._backend().status, label)
+        latency_ms = round((time.monotonic() - t0) * 1000)
+        ctx.emit("launchd_status_checked", {
+            "label": label, "loaded": result.get("loaded"), "running": result.get("running"),
+            "pid": result.get("pid"), "latency_ms": latency_ms,
+        }, redacted=False)
+        return {**result, "latency_ms": latency_ms}
+
+    # ------------------------------------------------------------------
+    # start
+    # ------------------------------------------------------------------
+
+    @capability(
+        id="chp.adapters.launchd.start",
+        version="1.0.0",
+        description="Start (bootstrap) a service if not loaded, or restart it (kickstart -k) if already loaded.",
+        category="infrastructure",
+        provider="launchd",
+        risk="medium",
+        side_effects=["process_start"],
+        emits=_EMITS,
+        input_schema={
+            "type": "object",
+            "properties": {
+                "label": {"type": "string"},
+                "plist_path": {"type": "string", "description": "Plist path (defaults to ~/Library/LaunchAgents/<label>.plist)"},
+            },
+            "required": ["label"],
+            "additionalProperties": False,
+        },
+    )
+    async def start(self, ctx: Any, payload: dict) -> dict:
+        label = payload["label"]
+        self._check_managed(label)
+        plist_path = payload.get("plist_path")
+        ctx.emit("launchd_start_started", {"label": label}, redacted=False)
+        t0 = time.monotonic()
+        try:
+            result = await asyncio.to_thread(self._backend().start, label, plist_path)
+        except Exception as exc:
+            ctx.emit("launchd_start_failed", {"label": label, "error": str(exc)[:300]}, redacted=False)
+            raise
+        latency_ms = round((time.monotonic() - t0) * 1000)
+        ctx.emit("launchd_start_completed", {
+            "label": label, "action": result.get("action"), "ok": result.get("ok"),
+            "returncode": result.get("returncode"), "latency_ms": latency_ms,
+        }, redacted=False)
+        return {**result, "latency_ms": latency_ms}
+
+    # ------------------------------------------------------------------
+    # stop
+    # ------------------------------------------------------------------
+
+    @capability(
+        id="chp.adapters.launchd.stop",
+        version="1.0.0",
+        description="Stop (bootout) a loaded launchd service.",
+        category="infrastructure",
+        provider="launchd",
+        risk="medium",
+        side_effects=["process_stop"],
+        emits=_EMITS,
+        input_schema={
+            "type": "object",
+            "properties": {"label": {"type": "string"}},
+            "required": ["label"],
+            "additionalProperties": False,
+        },
+    )
+    async def stop(self, ctx: Any, payload: dict) -> dict:
+        label = payload["label"]
+        self._check_managed(label)
+        ctx.emit("launchd_stop_started", {"label": label}, redacted=False)
+        t0 = time.monotonic()
+        try:
+            result = await asyncio.to_thread(self._backend().stop, label)
+        except Exception as exc:
+            ctx.emit("launchd_stop_failed", {"label": label, "error": str(exc)[:300]}, redacted=False)
+            raise
+        latency_ms = round((time.monotonic() - t0) * 1000)
+        ctx.emit("launchd_stop_completed", {
+            "label": label, "ok": result.get("ok"), "returncode": result.get("returncode"),
+            "latency_ms": latency_ms,
+        }, redacted=False)
+        return {**result, "latency_ms": latency_ms}
+
+    # ------------------------------------------------------------------
+    # install
+    # ------------------------------------------------------------------
+
+    @capability(
+        id="chp.adapters.launchd.install",
+        version="1.0.0",
+        description=(
+            "Generate a LaunchAgent plist from a service spec, write it to "
+            "~/Library/LaunchAgents, and bootstrap it. Environment values are written "
+            "to the plist but never recorded in evidence (only env keys)."
+        ),
+        category="infrastructure",
+        provider="launchd",
+        risk="high",
+        side_effects=["file_write", "process_start"],
+        emits=_EMITS,
+        input_schema={
+            "type": "object",
+            "properties": {
+                "label": {"type": "string", "description": "Service label (must match the managed prefix)"},
+                "program": {"type": "string", "description": "Absolute path to the executable"},
+                "args": {"type": "array", "items": {"type": "string"}, "description": "Program arguments"},
+                "env": {"type": "object", "additionalProperties": {"type": "string"}, "description": "Environment variables (values not evidenced)"},
+                "working_dir": {"type": "string"},
+                "stdout_path": {"type": "string"},
+                "stderr_path": {"type": "string"},
+                "run_at_load": {"type": "boolean", "default": True},
+                "keep_alive": {"type": "boolean", "default": True},
+            },
+            "required": ["label", "program"],
+            "additionalProperties": False,
+        },
+    )
+    async def install(self, ctx: Any, payload: dict) -> dict:
+        label = payload["label"]
+        self._check_managed(label)
+        spec = {k: payload[k] for k in payload if k != "label"}
+        env_keys = sorted((payload.get("env") or {}).keys())
+        ctx.emit("launchd_install_started", {
+            "label": label, "program": payload["program"], "env_keys": env_keys,
+        }, redacted=False)
+        t0 = time.monotonic()
+        try:
+            result = await asyncio.to_thread(self._backend().install, label, spec)
+        except Exception as exc:
+            ctx.emit("launchd_install_failed", {"label": label, "error": str(exc)[:300]}, redacted=False)
+            raise
+        latency_ms = round((time.monotonic() - t0) * 1000)
+        ctx.emit("launchd_install_completed", {
+            "label": label, "plist_path": result.get("plist_path"), "ok": result.get("ok"),
+            "env_keys": result.get("env_keys"), "latency_ms": latency_ms,
+        }, redacted=False)
+        return {**result, "latency_ms": latency_ms}
+
+    # ------------------------------------------------------------------
+    # uninstall
+    # ------------------------------------------------------------------
+
+    @capability(
+        id="chp.adapters.launchd.uninstall",
+        version="1.0.0",
+        description="Bootout a service and remove its LaunchAgent plist.",
+        category="infrastructure",
+        provider="launchd",
+        risk="high",
+        side_effects=["file_delete", "process_stop"],
+        emits=_EMITS,
+        input_schema={
+            "type": "object",
+            "properties": {"label": {"type": "string"}},
+            "required": ["label"],
+            "additionalProperties": False,
+        },
+    )
+    async def uninstall(self, ctx: Any, payload: dict) -> dict:
+        label = payload["label"]
+        self._check_managed(label)
+        t0 = time.monotonic()
+        result = await asyncio.to_thread(self._backend().uninstall, label)
+        latency_ms = round((time.monotonic() - t0) * 1000)
+        ctx.emit("launchd_uninstall_completed", {
+            "label": label, "booted_out": result.get("booted_out"),
+            "plist_removed": result.get("plist_removed"), "latency_ms": latency_ms,
+        }, redacted=False)
+        return {**result, "latency_ms": latency_ms}
+
+    # ------------------------------------------------------------------
+    # service_health
+    # ------------------------------------------------------------------
+
+    @capability(
+        id="chp.adapters.launchd.service_health",
+        version="1.0.0",
+        description=(
+            "Report combined health: all com.chp.* launchd services (running/stopped) "
+            "and model-server readiness probes (TEI, vllm) via the http transport."
+        ),
+        category="infrastructure",
+        provider="launchd",
+        risk="low",
+        emits=_EMITS,
+        input_schema={"type": "object", "properties": {}, "additionalProperties": False},
+    )
+    async def service_health(self, ctx: Any, payload: dict) -> dict:
+        t0 = time.monotonic()
+
+        # 1. Launchd service states
+        services = await asyncio.to_thread(self._backend().list_services, self._config.managed_prefix)
+        running_count = sum(1 for s in services if s.get("running"))
+
+        # 2. Model-server readiness probes (fast, parallel, via http transport)
+        model_results: list[dict] = []
+        probe_tasks = [
+            self._probe_model_server(ctx, p)
+            for p in self._config.model_probes
+        ]
+        for coro in asyncio.as_completed(probe_tasks):
+            model_results.append(await coro)
+
+        overall_ok = (
+            all(s.get("running") for s in services if s.get("label", "").endswith((".tei", ".vllm", ".mac")))
+            and all(r["reachable"] for r in model_results)
+        )
+
+        latency_ms = round((time.monotonic() - t0) * 1000)
+        ctx.emit("service_health_checked", {
+            "service_count": len(services),
+            "running_count": running_count,
+            "model_probe_count": len(model_results),
+            "ok": overall_ok,
+            "latency_ms": latency_ms,
+        }, redacted=False)
+
+        return {
+            "ok": overall_ok,
+            "services": services,
+            "model_servers": sorted(model_results, key=lambda r: r["name"]),
+            "latency_ms": latency_ms,
+        }
+
+    async def _probe_model_server(self, ctx: Any, probe: dict) -> dict:
+        """Probe one model server endpoint via the http transport (non-fatal on failure)."""
+        name = probe["name"]
+        url = probe["url"]
+        expect = probe.get("expect_status", 200)
+        t0 = time.monotonic()
+        try:
+            result = await ctx.ainvoke(_HTTP_CAP, {"method": "GET", "url": url, "timeout": 3.0})
+            if getattr(result, "success", False):
+                status = result.data.get("status_code")
+                reachable = status == expect
+            else:
+                reachable = False
+                status = None
+        except Exception:
+            reachable = False
+            status = None
+        return {
+            "name": name,
+            "url": url,
+            "reachable": reachable,
+            "status_code": status,
+            "latency_ms": round((time.monotonic() - t0) * 1000),
+        }

chp_adapter_launchd-0.10.0.dist-info/METADATA

@@ -0,0 +1,65 @@
+Metadata-Version: 2.4
+Name: chp-adapter-launchd
+Version: 0.10.0
+Summary: CHP capability adapter — govern macOS launchd (LaunchAgent) services
+Author: Auxo
+License: Apache-2.0
+Keywords: adapter,capability-host-protocol,chp,launchctl,launchd,macos,service
+Classifier: Development Status :: 3 - Alpha
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: Apache Software License
+Classifier: Operating System :: MacOS
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Requires-Python: >=3.10
+Requires-Dist: chp-core>=0.7.0
+Provides-Extra: dev
+Requires-Dist: pytest-asyncio>=0.23; extra == 'dev'
+Requires-Dist: pytest>=8.0; extra == 'dev'
+Description-Content-Type: text/markdown
+
+# chp-adapter-launchd
+
+Govern macOS **launchd** LaunchAgent services as CHP capabilities. Built so CHP
+can manage its own long-running infrastructure (e.g. the TEI and vLLM Metal
+servers) — making them persistent across reboot and controllable through the
+capability host with a full evidence trail.
+
+## Capabilities
+
+| Capability | Description |
+|---|---|
+| `chp.adapters.launchd.list` | List CHP-managed services (scoped to the managed prefix). |
+| `chp.adapters.launchd.status` | Loaded/running state, pid, last exit code, plist presence. |
+| `chp.adapters.launchd.start` | Bootstrap if unloaded, else `kickstart -k` (restart). |
+| `chp.adapters.launchd.stop` | Bootout a loaded service. |
+| `chp.adapters.launchd.install` | Generate a plist from a spec, write it, and bootstrap. |
+| `chp.adapters.launchd.uninstall` | Bootout and remove the plist. |
+
+## Safety
+
+The adapter only manages labels matching `LaunchdConfig.managed_prefix` (default
+`com.chp.`) — it will refuse to touch arbitrary system services. `launchctl` and
+plist I/O are isolated in `_backends.py`.
+
+## Install a service (example: the TEI server)
+
+```json
+{
+  "label": "com.chp.tei",
+  "program": "/opt/homebrew/bin/text-embeddings-router",
+  "args": ["--model-id", "sentence-transformers/all-MiniLM-L6-v2", "--port", "8090"],
+  "stdout_path": "/Users/me/.chp/logs/tei.log",
+  "stderr_path": "/Users/me/.chp/logs/tei.err",
+  "keep_alive": true,
+  "run_at_load": true
+}
+```
+
+## Evidence policy
+
+Emitted: label, operation, pid, returncode, plist path, environment **keys**, latency.
+Never emitted: environment variable **values** (may hold tokens) or plist file contents.

chp_adapter_launchd-0.10.0.dist-info/RECORD

@@ -0,0 +1,7 @@
+chp_adapter_launchd/__init__.py,sha256=LjDXIa3JHYcPTL2l4lmzUGbrvrDj7O9zFA7mr-VdIyc,758
+chp_adapter_launchd/_backends.py,sha256=MYtpmV1xjh3OC13wduURIF66nyZBwpAusIx6D6pdseo,5708
+chp_adapter_launchd/adapter.py,sha256=SA-jAm-yzJogUCSxum85h5-MnfXJQb3qZd4uz99vGvg,15955
+chp_adapter_launchd-0.10.0.dist-info/METADATA,sha256=V1wZVMgsOrvUbYQcUMSgvRN8_OnlBnli6T58V7fJGUo,2553
+chp_adapter_launchd-0.10.0.dist-info/WHEEL,sha256=mffPy8wBnZQn2VnJUU5jE99KsxaSfiyMHV9Yt0aLVxs,87
+chp_adapter_launchd-0.10.0.dist-info/entry_points.txt,sha256=FeNq-AHCOumE5FsVGhg7929YS2vOed-35UHwOOk3-2g,60
+chp_adapter_launchd-0.10.0.dist-info/RECORD,,

chp_adapter_launchd-0.10.0.dist-info/WHEEL

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

chp_adapter_launchd-0.10.0.dist-info/entry_points.txt

@@ -0,0 +1,2 @@
+[chp.adapters]
+launchd = chp_adapter_launchd:LaunchdAdapter