@passioncode-ai/fabric-agent-adapter 0.78.0 → 0.80.2

package/plugins/fabric-agent-adapter/skills/building-fabric-services/scripts/fabric_supervisors.py

@@ -4,6 +4,7 @@ removed without touching what the operator turned off; release pruning (LC-15).
 from __future__ import annotations
 
 import http.client
+import ipaddress
 import json
 import os
 import plistlib
@@ -140,12 +141,40 @@ def _check(result: Any, what: str) -> None:
         raise ServiceError("%s failed: %s" % (what, (getattr(result, "stderr", "") or getattr(result, "stdout", "") or "").strip()[:200]))
 
 
+def _poll_installed(origin: str, service_id: Optional[str], instance: str, timeout: float,
+                    read: Optional[Callable[[str], Any]], sleep: Callable[[float], None], clock: Callable[[], float]) -> Any:
+    """Poll the well-known answer at `origin` until this OS account's listener answers as `service_id`.`instance`, as
+    launchd_install does (the pinned contract's Install row: every supervisor polls, FAA-253). Another account's listener,
+    or one whose owner cannot be told, is never a successful install (DEC-0154 HA-2)."""
+    if not service_id:
+        raise ServiceError("polling the install at %s needs the service_id it must answer as" % origin)
+    read = read or well_known_of
+    deadline = clock() + max(0.0, timeout)
+    while True:
+        doc = read(origin)
+        foreign = doc.reason if isinstance(doc, ForeignUserAnswer) else None
+        if not foreign and _answers(doc, service_id, instance):
+            return doc
+        if clock() >= deadline:
+            break
+        sleep(0.5)
+    if foreign:
+        raise ServiceError("%s is not this service's: %s (DEC-0154 HA-2); the port is another OS account's or its owner "
+                           "cannot be told." % (origin, foreign))
+    raise ServiceError("%s did not answer as %s.%s within %.0f s; read its log." % (origin, service_id, instance, timeout))
+
+
 def systemd_install(unit: str, text: str, *, unit_dir: Optional[Path] = None, run: Callable[..., Any] = subprocess.run,
-                    system: str = sys.platform, force_enable: bool = False) -> Path:
+                    system: str = sys.platform, force_enable: bool = False, origin: Optional[str] = None,
+                    service_id: Optional[str] = None, instance: str = "default", timeout: float = 40.0,
+                    fetch_well_known: Optional[Callable[[str], Any]] = None, sleep: Callable[[float], None] = time.sleep,
+                    clock: Callable[[], float] = time.monotonic) -> Path:
     """Write the user unit, enable it so it comes back after a login, and (re)start it so the new unit is what runs.
 
     The operator's intent wins (LC-14): a unit already installed and disabled stays off — the file is rewritten, so
-    the new version is what starts once they enable it — unless ``force_enable`` (the operator asked for it on)."""
+    the new version is what starts once they enable it — unless ``force_enable`` (the operator asked for it on).
+    With ``origin`` (and ``service_id``), it then polls the well-known answer as ``launchd_install`` does, until this
+    account's listener answers within ``timeout`` (FAA-253); ``fetch_well_known(origin)`` reads it as ``well_known_of``."""
     if not system.startswith("linux"):
         raise ServiceError("systemd is the supervisor on Linux only")
     if not _UNIT.match(unit):
@@ -162,6 +191,8 @@ def systemd_install(unit: str, text: str, *, unit_dir: Optional[Path] = None, ru
         return path
     _check(run(["systemctl", "--user", "enable", unit], capture_output=True, text=True), "systemctl --user enable")
     _check(run(["systemctl", "--user", "restart", unit], capture_output=True, text=True), "systemctl --user restart")
+    if origin is not None:
+        _poll_installed(origin, service_id, instance, timeout, fetch_well_known, sleep, clock)
     return path
 
 
@@ -226,9 +257,13 @@ _TASK_DISABLED = re.compile(r"<Settings>(?:(?!</Settings>).)*<Enabled>false</Ena
 
 
 def task_install(task: str, xml_text: str, *, run: Callable[..., Any] = subprocess.run, system: str = sys.platform,
-                 force_enable: bool = False) -> None:
+                 force_enable: bool = False, origin: Optional[str] = None, service_id: Optional[str] = None,
+                 instance: str = "default", timeout: float = 40.0, fetch_well_known: Optional[Callable[[str], Any]] = None,
+                 sleep: Callable[[float], None] = time.sleep, clock: Callable[[], float] = time.monotonic) -> Any:
     """Create (or replace) the task from its XML without administrator rights, then (re)start it so the new
-    definition is what runs. A task already installed and disabled stays off (LC-14) unless ``force_enable``."""
+    definition is what runs. A task already installed and disabled stays off (LC-14) unless ``force_enable``.
+    With ``origin`` (and ``service_id``), it then polls the well-known answer as ``launchd_install`` does and returns it
+    (FAA-253); without, it returns None as before."""
     if system != "win32":
         raise ServiceError("Task Scheduler is the supervisor on Windows only")
     query = run(["schtasks", "/Query", "/TN", task, "/XML"], capture_output=True, text=True)
@@ -247,6 +282,9 @@ def task_install(task: str, xml_text: str, *, run: Callable[..., Any] = subproce
     if existed:
         run(["schtasks", "/End", "/TN", task], capture_output=True, text=True)
     _check(run(["schtasks", "/Run", "/TN", task], capture_output=True, text=True), "schtasks /Run")
+    if origin is not None:
+        return _poll_installed(origin, service_id, instance, timeout, fetch_well_known, sleep, clock)
+    return None
 
 
 def task_uninstall(task: str, *, run: Callable[..., Any] = subprocess.run, system: str = sys.platform) -> None:
@@ -367,13 +405,16 @@ def launchd_loaded(label: str, domain: Optional[str] = None) -> bool:
     return _launchctl("print", "%s/%s" % (launchd_domain(domain=domain), label)).returncode == 0
 
 
-_PID_ROW = re.compile(r"^\s*pid\s*=\s*(\d+)\s*\Z")
+_PID_ROW = re.compile(r"^\s*pid\s*=\s*([0-9]+)\s*\Z")  # ASCII digits, as Node reads them (FAA-273)
 
 
 def launchd_pid(label: str, domain: Optional[str] = None) -> Optional[int]:
     """The running pid of this account's launchd job ``label`` (with ``domain="system"``, of the LaunchDaemon), or
     None (not running, or not readable). Reading needs no root."""
-    result = _launchctl("print", "%s/%s" % (launchd_domain(domain=domain), label))
+    try:
+        result = _launchctl("print", "%s/%s" % (launchd_domain(domain=domain), label))
+    except subprocess.TimeoutExpired:
+        return None  # a launchctl that hangs is a pid not read, never an error out of an install's poll (FAA-273)
     if result.returncode != 0:
         return None
     for line in (result.stdout or "").splitlines():
@@ -383,6 +424,29 @@ def launchd_pid(label: str, domain: Optional[str] = None) -> Optional[int]:
     return None
 
 
+def _loopback_host(host: Optional[str]) -> bool:
+    """Whether `host` (urlsplit's hostname: lower-case, no brackets) names this machine: localhost, 127/8 or ::1."""
+    if not host:
+        return False
+    if host == "localhost":
+        return True
+    try:
+        return ipaddress.ip_address(host).is_loopback
+    except ValueError:
+        return False
+
+
+class ForeignUserAnswer:
+    """A refused listener (DEC-0154 HA-2), as `well_known_of` answers it: never a document, whatever keys a service's JSON
+    carries. `reason` starts with `foreign-user` or `table-restricted` (the Node twin's class, FAA-259)."""
+
+    def __init__(self, reason: str) -> None:
+        self.reason = reason
+
+    def __repr__(self) -> str:
+        return "ForeignUserAnswer(%r)" % self.reason
+
+
 def _read_well_known(origin: str, timeout: float = 2.0,
                      vouch_pid: Optional[int] = None) -> Tuple[Optional[Dict[str, Any]], Optional[str]]:
     """(the well-known answer or None, why the listener was refused or None). A loopback origin is read only on a
@@ -391,10 +455,16 @@ def _read_well_known(origin: str, timeout: float = 2.0,
     table hides other processes. `vouch_pid`, the pid of a launchd job this
     caller started, proves the listener when the socket table hides other processes (FAA-267)."""
     parts = urllib.parse.urlsplit(origin)
-    if parts.scheme == "http" and parts.hostname == "127.0.0.1" and parts.port:
-        conn = _po.CheckedHTTPConnection("127.0.0.1", parts.port, timeout=timeout, vouch_pid=vouch_pid)
+    try:
+        port = parts.port or (80 if parts.scheme == "http" else None)  # no port is http's 80, as in the Node twin
+    except ValueError:  # a port out of range
+        port = None
+    if parts.scheme == "http" and port and _loopback_host(parts.hostname):
+        # every loopback spelling (127.0.0.1, another 127/8 address, localhost, [::1]) goes on a checked connection,
+        # never the unchecked way (FAA-257)
+        conn = _po.CheckedHTTPConnection(parts.hostname, port, timeout=timeout, vouch_pid=vouch_pid)
         try:
-            conn.request("GET", "/.well-known/fabric-service", headers={"Host": "127.0.0.1:%d" % parts.port})
+            conn.request("GET", "/.well-known/fabric-service", headers={"Host": parts.netloc.rpartition("@")[2]})
             response = conn.getresponse()
             return (json.loads(response.read().decode()) if response.status == 200 else None), None
         except _po.ListenerRefused as exc:
@@ -514,10 +584,24 @@ def _read_job_well_known(origin: str, job_pid: int, job_uid: Optional[int] = Non
 
 def fetch_well_known(origin: str, timeout: float = 2.0) -> Optional[Dict[str, Any]]:
     """The well-known answer at `origin`, or None: nothing answers, the answer is not JSON, or the listener is not this
-    OS account's process (DEC-0154 HA-2)."""
+    OS account's process (DEC-0154 HA-2). `well_known_of` tells the last two apart."""
     return _read_well_known(origin, timeout)[0]
 
 
+def well_known_of(origin: str, timeout: float = 2.0, vouch_pid: Optional[int] = None) -> Any:
+    """The well-known answer at `origin` as the Node `wellKnownOf` gives it (FAA-259): the document; None when nothing
+    answers or the answer is not JSON (down); a `ForeignUserAnswer` when the listener is another OS account's process or
+    its owner cannot be told. So a status reads HA-2's order: down, foreign-user, foreign, status."""
+    doc, why = _read_well_known(origin, timeout, vouch_pid=vouch_pid)
+    return ForeignUserAnswer(why) if why else doc
+
+
+def job_well_known_of(origin: str, job_pid: int, job_uid: Optional[int] = None, timeout: float = 2.0) -> Any:
+    """As `well_known_of`, for a LaunchDaemon whose job `job_pid` (running as `job_uid`) must hold the listener."""
+    doc, why = _read_job_well_known(origin, job_pid, job_uid)
+    return ForeignUserAnswer(why) if why else doc
+
+
 _OVERRIDE_ROW = re.compile(r'^\s*"([^"]+)"\s*=>\s*(\S+)\s*\Z')
 
 
@@ -593,7 +677,9 @@ def _refuse_held_label(label: str, plist_path: Path) -> None:
 
 def launchd_install(label: str, plist_path: Path, plist_bytes: bytes, *, origin: str,
                     service_id: str, instance: str = "default", timeout: float = 40.0,
-                    force_enable: bool = False, domain: Optional[str] = None) -> Dict[str, Any]:
+                    force_enable: bool = False, domain: Optional[str] = None,
+                    fetch_well_known: Optional[Callable[..., Any]] = None,
+                    fetch_job_well_known: Optional[Callable[..., Any]] = None) -> Dict[str, Any]:
     """Write + lint the plist, bootout and WAIT for unload, bootstrap (retry EIO 5), then
     poll the well-known document until it answers with this identity.
 
@@ -606,7 +692,13 @@ def launchd_install(label: str, plist_path: Path, plist_bytes: bytes, *, origin:
     A plist in ``/Library/LaunchDaemons`` (or ``domain="system"``) is a LaunchDaemon in launchd's system domain, started
     at boot with no login (FAA-278): only root installs it, refused before anything is written otherwise, and the
     answer counts only when launchd's own job accepted the connection (its ``UserName``, not the installer, owns it).
-    A ``gui/<uid>`` bootstrap with no GUI session (SSH, a headless Mac after a FileVault restart) says so."""
+    A ``gui/<uid>`` bootstrap with no GUI session (SSH, a headless Mac after a FileVault restart) says so.
+
+    ``fetch_well_known(origin, vouch_pid=...)`` and ``fetch_job_well_known(origin, job_pid, job_uid)`` read the answer as
+    ``well_known_of`` and ``job_well_known_of`` do (the document, None, or a ``ForeignUserAnswer``); a caller may inject
+    its own, as the Node ``launchdInstall`` takes ``fetchWellKnown`` (FAA-259)."""
+    read_answer = fetch_well_known or (lambda origin_, vouch_pid=None: well_known_of(origin_, vouch_pid=vouch_pid))
+    read_job = fetch_job_well_known or job_well_known_of
     plist_path = Path(plist_path)
     dom = launchd_domain(plist_path, domain)
     which = "system" if dom == "system" else None
@@ -685,9 +777,10 @@ def launchd_install(label: str, plist_path: Path, plist_bytes: bytes, *, origin:
         foreign = None
         while time.time() < deadline:
             job = launchd_pid(label, "system")
-            doc, why = _read_job_well_known(origin, job, job_uid) if job else (None, None)
+            doc = read_job(origin, job, job_uid) if job else None
+            why = doc.reason if isinstance(doc, ForeignUserAnswer) else None
             foreign = why or foreign  # the last refusal stays the reason while launchd shows no pid
-            if _answers(doc, service_id, instance):
+            if not why and _answers(doc, service_id, instance):
                 return doc
             time.sleep(0.5)
         loaded = ("; the job stays loaded and its plist starts it again at boot: as root, `launchctl bootout system/%s` "
@@ -702,10 +795,11 @@ def launchd_install(label: str, plist_path: Path, plist_bytes: bytes, *, origin:
                            % (origin, service_id, instance, timeout, loaded))
     foreign = vouch = None
     while time.time() < deadline:
-        doc, foreign = _read_well_known(origin, vouch_pid=vouch)
+        doc = read_answer(origin, vouch_pid=vouch)
+        foreign = doc.reason if isinstance(doc, ForeignUserAnswer) else None
         if foreign and foreign.startswith(_po.TABLE_RESTRICTED):
             vouch = launchd_pid(label)  # only a restricted table needs the job's pid (FAA-267)
-        if _answers(doc, service_id, instance):
+        if not foreign and _answers(doc, service_id, instance):
             return doc
         time.sleep(0.5)
     if foreign:

package/plugins/fabric-agent-adapter/skills/building-fabric-services/scripts/fabric_usage.py

@@ -137,7 +137,7 @@ def _by_project(receipts: List[Dict[str, Any]], first: str, last: str) -> List[D
     out = []
     for key in sorted(projects):
         row = projects[key]
-        runs = [_close_totals(run) for _, run in sorted(row.pop("_runs").items())]
+        runs = [_close_run(run) for _, run in sorted(row.pop("_runs").items())]
         row = _close_totals(row)
         if runs:
             row["taskRuns"] = runs
@@ -167,6 +167,17 @@ def _round_usd(value: float) -> float:
     return whole / 1e6
 
 
+def _close_run(run: Dict[str, Any]) -> Dict[str, Any]:
+    """A task run's totals, its cost rounded as `_round_usd` rounds but never above the exact cost: each run and its
+    project round apart, so many runs rounding up summed past the project and failed FAC-SEM-025 (board request
+    f5753c5a). Rounded this way the runs' sum stays within the project's rounded cost by construction."""
+    exact = run["_cost"]
+    run = _close_totals(run)
+    if run["costUsd"] is not None and run["costUsd"] > exact:
+        run["costUsd"] = _round_usd(run["costUsd"] - 0.000001)
+    return run
+
+
 def _close_totals(row: Dict[str, Any]) -> Dict[str, Any]:
     cost = row.pop("_cost")
     row["costUsd"] = None if row["calls"] and row["unpricedCalls"] == row["calls"] else _round_usd(cost)