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

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

@@ -20,7 +20,7 @@ HOLD_RETRY_MAX_SECONDS = 900.0
 #: Refusals that are about the board session, not one capability: they end recovery and go to the responder's fault.
 SESSION_CODES = frozenset(["unreachable", "session-ended", "not_authorized", "authority_changed", "credential", "no-epoch",
                            "schema-unsupported", "checkpoint", "receipt-shape", "idempotency_conflict", "not-running",
-                           "not-a-hub", "hub-unavailable", "protocol", "not_available"])
+                           "not-a-hub", "hub-unavailable", "protocol", "not_available", "foreign-user"])
 
 _whole = lambda v: int(v) if isinstance(v, float) and v.is_integer() else v  # noqa: E731 - 2.0 is 2, as Node reads it
 
@@ -78,7 +78,7 @@ class SlotKeeper:
                 if _is_int(generation, 1) and (answer.get("repeated") is True or not moved):
                     rest = {"project": self.project, "generation": generation}
             except BoardError as exc:
-                if exc.code in ("unreachable", "session-ended"):
+                if exc.code in ("unreachable", "session-ended", "foreign-user"):  # foreign-user: the earlier ask is unknown
                     raise
                 if exc.code == "idempotency_window_expired":
                     rest = {}  # a retired epoch refuses even a repeat: unknown, so no record (a first start, never a move)

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

@@ -45,6 +45,7 @@ from fabric_jsvalue import (  # noqa: E402 - the core (FAA-65)
     jcs,
 )
 from fabric_paths import atomic_write as _atomic_write  # noqa: E402 - the kit's private writer (FAA-85)
+import fabric_peer_owner as _po  # noqa: E402 - a loopback key set is read from this account's listener only (FAA-255)
 from fabric_mandate import effect_closure  # noqa: E402,F401 - defined once beside the mandate that reads it too (DEC-0125)
 
 REFUSAL_CODES = (
@@ -672,9 +673,21 @@ class _NoRedirect(urllib.request.HTTPRedirectHandler):
         return None
 
 
-def _opener(deadline: Dict[str, Any]) -> urllib.request.OpenerDirector:
+class _CheckedHTTPConnection(_po.CheckedHTTPConnection):
+    """Plain http, which a key set source allows on loopback only (DEC-0154 HA-2, FAA-255): every connect, a reconnect
+    included, tells the server end's owner and refuses (closed, nothing sent) unless it is this OS account's process,
+    so keys another account's listener serves are never read; built the way urllib builds a connection."""
+
+    def __init__(self, host: str, port: Optional[int] = None, timeout: Any = 10.0, **kwargs: Any) -> None:
+        http.client.HTTPConnection.__init__(self, host, port, timeout=timeout, **kwargs)
+        self.expect_pid = None
+        self.vouch_pid = None  # an issuer's URL is never a process this caller started (FAA-267)
+
+
+def _opener(deadline: Dict[str, Any], direct: bool = False) -> urllib.request.OpenerDirector:
     """No redirect, and a timer that shuts the socket down at the deadline: a socket timeout bounds one read, so an
-    issuer trickling a byte a second would otherwise hold the caller for as long as it likes (finding 13)."""
+    issuer trickling a byte a second would otherwise hold the caller for as long as it likes (finding 13). `direct`:
+    a loopback source never goes through a proxy from the environment, so the owner check reads the URL's own port."""
     def watched(base: type) -> type:
         class Watched(base):  # type: ignore[misc, valid-type]
             def connect(self) -> None:
@@ -695,11 +708,13 @@ def _opener(deadline: Dict[str, Any]) -> urllib.request.OpenerDirector:
 
     class Http(urllib.request.HTTPHandler):
         def http_open(self, req: Any) -> Any:
-            return self.do_open(watched(http.client.HTTPConnection), req)
+            return self.do_open(watched(_CheckedHTTPConnection), req)  # http is loopback only (the source check)
 
     class Https(urllib.request.HTTPSHandler):
         def https_open(self, req: Any) -> Any:
             return self.do_open(watched(http.client.HTTPSConnection), req, context=self._context)
+    if direct:
+        return urllib.request.build_opener(urllib.request.ProxyHandler({}), _NoRedirect, Http, Https)
     return urllib.request.build_opener(_NoRedirect, Http, Https)
 
 
@@ -709,7 +724,8 @@ def _fetch(source: str) -> Any:
         request = urllib.request.Request(source.partition("#")[0], headers={"Accept": "application/json"})
         deadline: Dict[str, Any] = {"end": time.monotonic() + JWKS_FETCH_SECONDS, "fired": False, "timer": None}
         try:
-            with _opener(deadline).open(request, timeout=JWKS_FETCH_SECONDS) as response:  # https or loopback http only
+            direct = source.lower().startswith("http://")
+            with _opener(deadline, direct).open(request, timeout=JWKS_FETCH_SECONDS) as response:  # https or loopback http only
                 body = b""
                 while len(body) <= 65536 and not deadline["fired"]:
                     chunk = response.read1(65537 - len(body))
@@ -724,6 +740,8 @@ def _fetch(source: str) -> Any:
             raise
         except http.client.HTTPException as exc:  # a garbage status line or headers: the issuer cannot be read
             raise ConnectionError(type(exc).__name__) from None
+        except _po.ListenerRefused as exc:  # FAA-255: another account's listener, or one that cannot be told
+            raise ConnectionError("foreign-user: %s" % exc) from None
         finally:
             if deadline["timer"] is not None:
                 deadline["timer"].cancel()

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

@@ -18,6 +18,7 @@ from pathlib import Path as _Path  # noqa: E402
 if str(_Path(__file__).resolve().parent) not in _sys.path:  # the kit loads from any working directory (FAA-65)
     _sys.path.insert(0, str(_Path(__file__).resolve().parent))
 from fabric_base import (
+    PRIMARY_CAPABILITY,
     PROTOCOL,
     ServiceError,
     _ID,
@@ -49,7 +50,7 @@ from fabric_usage import (
 DASHBOARD_EXTENSION_KEY = "https://fabric.passioncode.ai/agent-contract/extensions/dashboard/0.1"
 
 
-DASHBOARD_KIT = "fabric-dashboard-kit@1.1.5"
+DASHBOARD_KIT = "fabric-dashboard-kit@1.1.6"
 
 
 REFERENCE_THEMES = ("graphite", "fabric", "paper", "forest", "ocean", "ember", "contrast")
@@ -628,6 +629,11 @@ def configuration_problems(doc: Any) -> List[str]:
     return problems
 
 
+#: FAA-244: DEC-0140 PR-1 reserves the primary responder's capability; a service never publishes it.
+_RESERVED = ("%%s: %s is reserved for a Project's primary responder, a session (DEC-0140 PR-1); a service never "
+             "serves it as a tool or declares it." % PRIMARY_CAPABILITY)
+
+
 def build_well_known(*, service_id: str, instance: str, name: str, version: str, build: Dict[str, Any],
                      started_at: str, status: str, degraded: Sequence[Dict[str, str]],
                      surfaces: Dict[str, Any], summary: Optional[Sequence[Dict[str, Any]]] = None,
@@ -664,6 +670,10 @@ def build_well_known(*, service_id: str, instance: str, name: str, version: str,
         problems = a2a_surface_problems(surfaces["a2a"])
         if problems:
             raise ServiceError("surfaces.a2a: %s." % "; ".join(problems))
+    mcp_surface = surfaces.get("mcp")
+    listed = mcp_surface.get("capabilities") if isinstance(mcp_surface, dict) else None
+    if isinstance(listed, list) and PRIMARY_CAPABILITY in listed:
+        raise ServiceError(_RESERVED % "surfaces.mcp.capabilities")
     doc: Dict[str, Any] = {
         "protocol": PROTOCOL,
         "service": {"id": service_id, "instance": instance, "name": name, "version": version, "build": build},
@@ -698,6 +708,9 @@ def build_well_known(*, service_id: str, instance: str, name: str, version: str,
                                                 "surfaces": surfaces})
             if findings:
                 raise ServiceError("Actions declaration: %s." % "; ".join(f["message"] for f in findings))
+            if any(isinstance(a, dict) and a.get("tool") == PRIMARY_CAPABILITY
+                   for a in extensions[ACTIONS_EXTENSION_KEY].get("actions") or []):
+                raise ServiceError(_RESERVED % "an action's tool")
         doc["extensions"] = dict(extensions)
     if configuration is not None:
         problems = configuration_problems(configuration)

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

@@ -73,8 +73,42 @@ class InstanceLock:
     #: a file is allowed there).
     WINDOWS_LOCK_OFFSET = 1 << 30
 
+    #: How many times acquire re-opens service.lock when the file it locked is no longer the file at its path (a
+    #: folder swapped under it by a data import), before it gives up with an error naming the path (FAA-293).
+    INODE_RETRIES = 3
+
     def acquire(self) -> "InstanceLock":
         ensure_private_dir(self.path.parent)
+        for _ in range(self.INODE_RETRIES):
+            if self._acquire_once():
+                return self
+        raise ServiceError("%s kept moving while it was locked (a folder swapped under the data folder?): no copy "
+                           "holds a file that is no longer at its path; start again once the folder is settled." % self.path)
+
+    def _locked_file_is_at_path(self, fd: int) -> bool:
+        """The inode this copy locked is the file at the path now (FAA-293). Windows does not rename a folder holding
+        an open file, and its lock is a byte range on this handle, so the check is POSIX only."""
+        if WINDOWS:
+            return True
+        try:
+            here, held = os.stat(str(self.path)), os.fstat(fd)
+        except FileNotFoundError:
+            return False
+        return (here.st_dev, here.st_ino) == (held.st_dev, held.st_ino)
+
+    def _let_go(self, fd: int) -> None:
+        try:
+            os.close(fd)
+        except OSError:
+            pass
+        name, self._name = self._name, None
+        if name is not None:
+            try:
+                _drop_lock_name(name)
+            except OSError:
+                pass
+
+    def _acquire_once(self) -> bool:
         fd = os.open(str(self.path), os.O_RDWR | os.O_CREAT | _O_BINARY, 0o600)
         try:
             if WINDOWS:
@@ -92,6 +126,9 @@ class InstanceLock:
             if exc.errno in (errno.EWOULDBLOCK, errno.EAGAIN, errno.EACCES, getattr(errno, "EDEADLOCK", -1)):
                 raise AlreadyRunning(_read_pid(self.path), self.path) from None
             raise
+        if not self._locked_file_is_at_path(fd):  # another copy may hold the file at the path: re-open that one
+            os.close(fd)
+            return False
         try:
             self._name = _hold_lock_name(self.path)
         except BaseException:
@@ -114,8 +151,11 @@ class InstanceLock:
                     except OSError:  # as with the close: nothing to add to the first error
                         pass
             raise
+        if not self._locked_file_is_at_path(fd):  # swapped while the pid was written: this copy holds nothing real
+            self._let_go(fd)
+            return False
         self._fd = fd
-        return self
+        return True
 
     def release(self) -> None:
         if self._fd is not None:

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

@@ -366,6 +366,10 @@ class Client:
                 if answer is not None:
                     answer["attempts"] = attempts
                     return answer
+                if outcome == "foreign-user":  # FAA-257: the fallback would go to the same refused listener
+                    raise OpenRouterError("The base URL's port is held by another OS account's process, or its owner "
+                                          "cannot be told; nothing was sent (DEC-0154 HA-2)", kind="foreign-user",
+                                          attempts=attempts)
                 if outcome in _STOP_AT_ONCE.values():
                     raise OpenRouterError("OpenRouter refused the key or the request (%s)" % status, kind=outcome,
                                           attempts=attempts)
@@ -390,6 +394,8 @@ class Client:
                 # the provider may have billed a call whose answer never arrived whole (a cut connection looks the
                 # same as a refused one from here): counted, never as $0; over-counting is the safe side
                 self.ledger.record(self._unmeasured(asked, task_run_id, worst))
+            if err.kind == "foreign-user":  # nothing was sent: nothing billed, and no other model there (FAA-257)
+                return "foreign-user", err.status, None, None
             return ("retry" if err.kind in ("connection", "timeout") else "refused"), err.status, None, None
         status = response.status
         if status in _STOP_AT_ONCE:

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

@@ -22,6 +22,7 @@ from fabric_time import DAY_MS as _DAY_MS, utc_date_ms as _utc_date_ms  # noqa:
 from fabric_base import (  # noqa: F401
     PROTOCOL,
     EXTENSION_KEY,
+    PRIMARY_CAPABILITY,
     SUPERVISOR_ENV,
     DRAIN_SECONDS,
     _ID,
@@ -319,6 +320,9 @@ from fabric_supervisors import (  # noqa: F401
     launchd_loaded,
     launchd_pid,
     fetch_well_known,
+    well_known_of,
+    job_well_known_of,
+    ForeignUserAnswer,
     _OVERRIDE_ROW,
     launchd_override,
     launchd_install,

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
@@ -383,6 +384,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 +415,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 +544,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 +637,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 +652,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 +737,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 +755,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: