chp-adapter-launchd 0.11.0__tar.gz

chp_adapter_launchd-0.11.0/.gitignore

@@ -0,0 +1,36 @@
+node_modules/
+dist/
+.next/
+out/
+.turbo/
+*.tsbuildinfo
+.yalc/
+yalc.lock
+*.tgz
+.env
+.env.*
+coverage/
+dashboard/
+components/
+# ...but the cockpit's app source lives in app/components — never ignore real source.
+!cockpit/app/components/
+!cockpit/app/components/**
+!chp-evidence/app/components/
+!chp-evidence/app/components/**
+.tech-hub-cache/
+__pycache__/
+*.py[cod]
+.pytest_cache/
+.chp/
+.DS_Store
+.coverage
+.forge/
+.hypothesis/
+.claude/
+
+# chp-agent evidence store
+.chp-agent/sessions.sqlite
+.publish-dist/
+
+# matrix-bot runtime session registry (CC session ids)
+matrix-bot/sessions.json

chp_adapter_launchd-0.11.0/PKG-INFO

@@ -0,0 +1,65 @@
+Metadata-Version: 2.4
+Name: chp-adapter-launchd
+Version: 0.11.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.11.0/README.md

@@ -0,0 +1,42 @@
+# 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.11.0/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-0.11.0/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-0.11.0/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.11.0/pyproject.toml

@@ -0,0 +1,41 @@
+[build-system]
+requires = ["hatchling>=1.25"]
+build-backend = "hatchling.build"
+
+[project]
+name = "chp-adapter-launchd"
+version = "0.11.0"
+description = "CHP capability adapter — govern macOS launchd (LaunchAgent) services"
+readme = "README.md"
+requires-python = ">=3.10"
+license = { text = "Apache-2.0" }
+authors = [{ name = "Auxo" }]
+keywords = ["chp", "capability-host-protocol", "launchd", "launchctl", "macos", "service", "adapter"]
+classifiers = [
+    "Development Status :: 3 - Alpha",
+    "Intended Audience :: Developers",
+    "License :: OSI Approved :: Apache Software License",
+    "Operating System :: MacOS",
+    "Programming Language :: Python :: 3",
+    "Programming Language :: Python :: 3.10",
+    "Programming Language :: Python :: 3.11",
+    "Programming Language :: Python :: 3.12",
+    "Programming Language :: Python :: 3.13",
+]
+dependencies = [
+    "chp-core>=0.7.0",
+]
+
+[project.entry-points."chp.adapters"]
+launchd = "chp_adapter_launchd:LaunchdAdapter"
+
+[project.optional-dependencies]
+dev = ["pytest>=8.0", "pytest-asyncio>=0.23"]
+
+[tool.pytest.ini_options]
+testpaths = ["tests"]
+pythonpath = ["."]
+asyncio_mode = "strict"
+
+[tool.hatch.build.targets.wheel]
+packages = ["chp_adapter_launchd"]

chp_adapter_launchd-0.11.0/tests/test_launchd_adapter.py

@@ -0,0 +1,193 @@
+"""Tests for chp-adapter-launchd using a fake backend — no launchctl calls."""
+
+from __future__ import annotations
+
+import asyncio
+from typing import Any
+
+import httpx
+
+from chp_adapter_http import HttpAdapter, HttpConfig
+from chp_adapter_launchd import LaunchdAdapter, LaunchdConfig
+from chp_core import LocalCapabilityHost, register_adapter
+from chp_core.store import SQLiteEvidenceStore
+
+
+class FakeLaunchdBackend:
+    def __init__(self) -> None:
+        self.installed: dict[str, dict] = {}
+
+    def list_services(self, prefix: str) -> list[dict]:
+        return [
+            {"label": "com.chp.tei", "pid": 4242, "running": True, "last_exit_code": 0},
+            {"label": "com.chp.vllm", "pid": None, "running": False, "last_exit_code": 1},
+        ]
+
+    def status(self, label: str) -> dict:
+        return {"label": label, "loaded": True, "running": True, "pid": 4242,
+                "last_exit_code": 0, "plist_exists": True}
+
+    def start(self, label: str, plist_path: str | None) -> dict:
+        return {"label": label, "action": "bootstrap", "ok": True, "returncode": 0, "stderr": ""}
+
+    def stop(self, label: str) -> dict:
+        return {"label": label, "action": "bootout", "ok": True, "returncode": 0, "stderr": ""}
+
+    def install(self, label: str, spec: dict) -> dict:
+        self.installed[label] = spec
+        return {"label": label, "plist_path": f"/fake/LaunchAgents/{label}.plist", "ok": True,
+                "returncode": 0, "stderr": "", "env_keys": sorted((spec.get("env") or {}).keys())}
+
+    def uninstall(self, label: str) -> dict:
+        return {"label": label, "booted_out": True, "plist_removed": True,
+                "plist_path": f"/fake/LaunchAgents/{label}.plist"}
+
+
+def _make_host(
+    fake: FakeLaunchdBackend | None = None,
+    transport: Any = None,
+    model_probes: list[dict] | None = None,
+) -> LocalCapabilityHost:
+    store = SQLiteEvidenceStore(":memory:")
+    host = LocalCapabilityHost(store=store)
+    cfg = LaunchdConfig(_backend=fake or FakeLaunchdBackend())
+    if model_probes is not None:
+        cfg.model_probes = model_probes
+    if transport is not None:
+        register_adapter(host, HttpAdapter(HttpConfig(transport=transport, max_retries=0, backoff_base=0.0)))
+    register_adapter(host, LaunchdAdapter(cfg))
+    return host
+
+
+def _invoke(host: LocalCapabilityHost, cap_id: str, payload: dict | None = None):
+    return asyncio.get_event_loop().run_until_complete(host.ainvoke(cap_id, payload or {}))
+
+
+class TestList:
+    def test_returns_services(self):
+        result = _invoke(_make_host(), "chp.adapters.launchd.list", {})
+        assert result.success
+        assert result.data["service_count"] == 2
+        assert result.data["services"][0]["label"] == "com.chp.tei"
+
+
+class TestStatus:
+    def test_returns_status(self):
+        result = _invoke(_make_host(), "chp.adapters.launchd.status", {"label": "com.chp.tei"})
+        assert result.success
+        assert result.data["running"] is True
+        assert result.data["pid"] == 4242
+
+    def test_unmanaged_label_rejected(self):
+        result = _invoke(_make_host(), "chp.adapters.launchd.status", {"label": "com.apple.something"})
+        assert not result.success
+
+
+class TestStartStop:
+    def test_start(self):
+        result = _invoke(_make_host(), "chp.adapters.launchd.start", {"label": "com.chp.tei"})
+        assert result.success
+        assert result.data["ok"] is True
+
+    def test_stop(self):
+        result = _invoke(_make_host(), "chp.adapters.launchd.stop", {"label": "com.chp.vllm"})
+        assert result.success
+        assert result.data["action"] == "bootout"
+
+    def test_start_unmanaged_rejected(self):
+        result = _invoke(_make_host(), "chp.adapters.launchd.start", {"label": "org.other.svc"})
+        assert not result.success
+
+
+class TestInstall:
+    def test_install_writes_spec(self):
+        fake = FakeLaunchdBackend()
+        result = _invoke(_make_host(fake), "chp.adapters.launchd.install", {
+            "label": "com.chp.tei",
+            "program": "/opt/homebrew/bin/text-embeddings-router",
+            "args": ["--model-id", "x", "--port", "8090"],
+        })
+        assert result.success
+        assert result.data["ok"] is True
+        assert "com.chp.tei" in fake.installed
+        assert fake.installed["com.chp.tei"]["program"].endswith("text-embeddings-router")
+
+    def test_env_values_not_in_evidence(self):
+        host = _make_host()
+        result = _invoke(host, "chp.adapters.launchd.install", {
+            "label": "com.chp.secretsvc",
+            "program": "/bin/echo",
+            "env": {"API_KEY": "SUPER_SECRET_VALUE_123"},
+        })
+        assert result.success
+        # env_keys present, value absent
+        assert result.data["env_keys"] == ["API_KEY"]
+        replay = host.replay(result.invocation_id)
+        for evt in replay:
+            blob = str(evt.get("payload", {}))
+            assert "SUPER_SECRET_VALUE_123" not in blob
+
+    def test_install_unmanaged_rejected(self):
+        result = _invoke(_make_host(), "chp.adapters.launchd.install", {
+            "label": "com.apple.evil", "program": "/bin/sh",
+        })
+        assert not result.success
+
+
+class TestUninstall:
+    def test_uninstall(self):
+        result = _invoke(_make_host(), "chp.adapters.launchd.uninstall", {"label": "com.chp.tei"})
+        assert result.success
+        assert result.data["plist_removed"] is True
+
+
+class TestServiceHealth:
+    def _mock_transport(self, tei_up: bool = True, vllm_up: bool = True) -> httpx.MockTransport:
+        def handler(request: httpx.Request) -> httpx.Response:
+            url = str(request.url)
+            if "8090" in url:
+                return httpx.Response(200 if tei_up else 503, json={"status": "ok"})
+            if "8092" in url:
+                return httpx.Response(200 if vllm_up else 503, json={"data": []})
+            return httpx.Response(404)
+        return httpx.MockTransport(handler)
+
+    def test_service_health_all_up(self):
+        probes = [
+            {"name": "tei", "url": "http://localhost:8090/health", "expect_status": 200},
+            {"name": "vllm", "url": "http://localhost:8092/v1/models", "expect_status": 200},
+        ]
+        host = _make_host(transport=self._mock_transport(True, True), model_probes=probes)
+        result = _invoke(host, "chp.adapters.launchd.service_health", {})
+        assert result.success
+        assert len(result.data["services"]) == 2
+        servers = {s["name"]: s for s in result.data["model_servers"]}
+        assert servers["tei"]["reachable"] is True
+        assert servers["vllm"]["reachable"] is True
+
+    def test_service_health_model_down(self):
+        probes = [
+            {"name": "tei", "url": "http://localhost:8090/health", "expect_status": 200},
+        ]
+        host = _make_host(transport=self._mock_transport(tei_up=False), model_probes=probes)
+        result = _invoke(host, "chp.adapters.launchd.service_health", {})
+        assert result.success
+        servers = {s["name"]: s for s in result.data["model_servers"]}
+        assert servers["tei"]["reachable"] is False
+        assert result.data["ok"] is False
+
+    def test_service_health_no_model_probes(self):
+        host = _make_host(model_probes=[])
+        result = _invoke(host, "chp.adapters.launchd.service_health", {})
+        assert result.success
+        assert result.data["model_servers"] == []
+
+
+class TestConformance:
+    def test_adapter_has_no_violations(self):
+        from chp_adapter_conformance import check_source_file
+        import chp_adapter_launchd.adapter as mod
+        import inspect
+
+        violations = check_source_file(inspect.getfile(mod))
+        assert not violations, f"LaunchdAdapter has conformance violations: {violations}"