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

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

@@ -1,6 +1,6 @@
 """peer_owner: which OS account owns each end of a loopback TCP connection.
 
-    peer_owner 1.1.0+kit.3: Observatory's peer_owner 1.1.0, vendored into the Fabric service kit as `fabric_peer_owner` (layer L0;
+    peer_owner 1.1.0+kit.4: Observatory's peer_owner 1.1.0, vendored into the Fabric service kit as `fabric_peer_owner` (layer L0;
     DEC-0154 HA-2, FAA-226) from Project Observatory's `observatory/engine/peer_owner.py` at
     commit f86f0622 (passioncode-ai/project-observatory-dashboard, the same licence). It differs
     from that file in this paragraph, in `Owner` and `Row` (NamedTuples here where it has
@@ -19,7 +19,8 @@
     macOS: the sysctl calibration also requires a child process's listener, an empty netstat reads as
     `TABLE_RESTRICTED`, and a caller may vouch for a listener with a pid it started (`pid_listens`,
     `parse_lsof_listeners`, `LSOF`, `CheckedHTTPConnection(vouch_pid=...)`, `own_connection(vouch_pid=...)`); since kit.3
-    the child's port is waited on with `selectors` and read under one deadline (FAA-273).
+    the child's port is waited on with `selectors` and read under one deadline (FAA-273); since kit.4 a number is ASCII
+    digits only and a netstat with only its header reads as `TABLE_RESTRICTED` (FAA-273 items 3 and 4).
     A limit /proc sets: it carries a socket's creator and no pid, so a listening socket that root
     created and handed to another account (systemd socket activation with User=) reads as root's. Standard library only, no import of another kit module.
     The kit's tests are `test/test_fabric_peer_owner.py`, over `test/fixtures/peer-owner/`;
@@ -110,7 +111,7 @@ import time
 from typing import NamedTuple, Optional, Tuple
 
 # This file's own version, for projects that copy it; not the engine's (that is configuration.VERSION).
-PEER_OWNER_VERSION = "1.1.0+kit.3"  # Observatory's 1.1.0 with the kit's differences above
+PEER_OWNER_VERSION = "1.1.0+kit.4"  # Observatory's 1.1.0 with the kit's differences above
 
 THIS_ACCOUNT = "this-account"
 ANOTHER_ACCOUNT = "another-account"
@@ -231,6 +232,11 @@ def classify(uid: Optional[int], pid: Optional[int], *, method: str, own_uid: Op
 
 # -- parsers: pure functions over captured text or bytes (the tests' fixtures) ---------------------------------------
 
+def _ascii_digits(text: str) -> bool:
+    """`[0-9]+` as the Node twin reads a number; `str.isdigit` also takes `٤` and `²` (FAA-273 item 4)."""
+    return text != "" and text.isascii() and text.isdigit()
+
+
 def parse_netstat(text: str) -> list[Row]:
     """`netstat -anv -p tcp` on macOS. Process names may hold spaces ("Some App:123"), so the
     `process:pid` column is what is left between the leading and the trailing columns, both
@@ -246,6 +252,10 @@ def parse_netstat(text: str) -> list[Row]:
     # "Local Address" and "Foreign Address" are two header words each and one data column each.
     leading = at - sum(1 for w in names[:at] if w == "Address")
     trailing = len(names) - at - 1
+    if not any(line.split()[:1] and line.split()[0].startswith("tcp") for line in lines[header + 1:]):
+        # The caller's own connection is in any table it can see: a header and no tcp row is the restricted table
+        # (FAA-273 item 3), not `no-row`.
+        raise TableUnreadable(f"{TABLE_RESTRICTED}: netstat printed only its header to this process")
     rows: list[Row] = []
     for line in lines[header + 1:]:
         tok = line.split()
@@ -259,7 +269,7 @@ def parse_netstat(text: str) -> list[Row]:
         pid = None
         if ":" in process:
             tail = process.rsplit(":", 1)[1]
-            pid = int(tail) if tail.isdigit() else None
+            pid = int(tail) if _ascii_digits(tail) else None
         rows.append(Row(local, remote, tok[5] == "LISTEN", None, pid, tok[5] == "TIME_WAIT"))
     return rows
 
@@ -283,7 +293,7 @@ def parse_lsof_listeners(text: str) -> list[tuple[str, int]]:
         if not line.startswith("n") or ":" not in line:
             continue
         host, port = line[1:].rsplit(":", 1)
-        if port.isdigit():
+        if _ascii_digits(port):
             found.append((norm_host(host.strip("[]")), int(port)))
     return found
 
@@ -291,7 +301,7 @@ def parse_lsof_listeners(text: str) -> list[tuple[str, int]]:
 def parse_ps_uid(text: str) -> Optional[int]:
     """`ps -o uid= -p PID`: one number, or nothing when the process is gone."""
     text = text.strip()
-    return int(text) if text.isdigit() else None
+    return int(text) if _ascii_digits(text) else None
 
 
 def parse_proc_net_tcp(text: str, *, family: int, byteorder: Optional[str] = None) -> list[Row]:
@@ -540,7 +550,7 @@ def _child_listener_seen(rows_of) -> Optional[bool]:
     port = None
     try:
         line = _child_line(child, deadline)
-        if line is None or not line.strip().isdigit():
+        if line is None or not _ascii_digits(line.strip()):
             return None
         port = int(line.strip())
         try:

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

@@ -6,6 +6,7 @@ only. The dashboard kit's fabric-button.js carries its own copy of the name and
 
 It reads as the contract's ECMAScript does (FAA-136): ECMAScript's whitespace (Python's `\\s` also takes U+0085 and
 U+001C to U+001F, and not U+FEFF), `.` stopping at every line terminator, ASCII case folding, an ASCII word boundary."""
+# Example URLs write their scheme in angle brackets: read `<https>` as `https` (FAA-212).
 
 from __future__ import annotations
 
@@ -142,7 +143,7 @@ def _percent_encode(text: str, also: str) -> str:
     return "".join(out)
 
 
-def _url_parts(value: str) -> Tuple[str, str, str]:
+def url_parts(value: str) -> Tuple[str, str, str]:
     """The password, query and fragment of an absolute URL as WHATWG URL parsing splits them, read by hand: urlsplit
     refuses a `[` or `]` outside an IPv6 host (`<https>://u:p[w@h/`), where `new URL` reads the password (0.56.0 unit
     r7). The fragment starts at the first `#`, the query at the first `?` before it. A special scheme's authority starts
@@ -166,6 +167,9 @@ def _url_parts(value: str) -> Tuple[str, str, str]:
             _percent_encode(fragment, "`"))
 
 
+_url_parts = url_parts  # the name before FAA-250, kept for code that reached it
+
+
 def secret_url(value: str) -> bool:
     """Whether a URL an MCP entry or a launch names carries a credential (LC-21): anything secret_argument finds, a
     password in its user information, or a query or fragment parameter whose name can only carry a credential and has
@@ -177,7 +181,7 @@ def secret_url(value: str) -> bool:
     value = re.sub(r"[\t\n\r]", "", value.strip(_C0_OR_SPACE))
     if not _SCHEME.match(value):
         return False  # not an absolute URL (WHATWG URL parsing refuses it)
-    password, query, fragment = _url_parts(value)
+    password, query, fragment = url_parts(value)
     if password:
         return True
     for part in (query, fragment):

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

@@ -197,6 +197,24 @@ from fabric_connections import (  # noqa: F401
     connections_rules,
     connections_view,
 )
+from fabric_load import (  # noqa: F401 - the call queue and the load report (DEC-0104, FAA-289)
+    LOAD_EXTENSION_KEY,
+    LOAD_REPORT_TYPE,
+    QUEUE_FULL_MESSAGE,
+    QUEUE_LENGTH_MAX,
+    DEFAULT_RETRY_AFTER_SECONDS,
+    job_caller_key,
+    next_queued_job,
+    admit_job,
+    queue_status_message,
+    read_queue_position,
+    job_queue_rules,
+    load_report_rules,
+    load_report_problems,
+    load_view,
+    load_extension_rules,
+    load_extension,
+)
 from fabric_descriptor import (  # noqa: F401
     DASHBOARD_EXTENSION_KEY,
     DASHBOARD_KIT,
@@ -231,7 +249,9 @@ from fabric_descriptor import (  # noqa: F401
     fabric_button_presence,
     placement_of,
     remote_origin_problems,
+    port_listener_refusal,
     port_of,
+    port_owner,
     NO_SOURCE_REPOSITORY,
     NoSourceRepositoryWarning,
     names_repository,

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

@@ -141,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):
@@ -163,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
 
 
@@ -227,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)
@@ -248,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:
@@ -368,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():

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)