@passioncode-ai/fabric-agent-adapter 0.40.0 → 0.42.1

package/plugins/fabric-agent-adapter/skills/working-with-fabric/scripts/fabric_session_env.py

@@ -57,7 +57,7 @@ SESSION_ID = re.compile(r"[A-Za-z0-9._:-]{1,128}")
 LOOPBACK_ORIGIN = re.compile(r"http://127\.0\.0\.1:(\d{1,5})")
 
 
-VERSION = "0.40.0"
+VERSION = "0.42.1"
 
 
 HOSTS = {"claude": "Claude Code", "codex": "Codex", "kimi": "Kimi Code",
@@ -401,24 +401,72 @@ def _process(pid: int) -> Tuple[Optional[str], int]:
         return None, 0
 
 
-def launched_by_ancestor(env: Optional[Dict[str, str]] = None, depth: int = 4) -> bool:
+def launched_by_ancestor(env: Optional[Dict[str, str]] = None, depth: int = 4,
+                         process: Optional[Callable[[int], Tuple[Optional[str], int]]] = None,
+                         platform: str = sys.platform) -> Optional[bool]:
     """A Claude Code Fabric launched runs with `--mcp-config <Fabric>/sessions/<id>/mcp.json` (sessionBundle.ts,
-    adapter mcp-config-flag) and no environment marker yet: look for that in this hook's few ancestors. Only the
-    path is matched; nothing read here is kept or logged."""
+    adapter mcp-config-flag) and no environment marker yet: look for that in this hook's few ancestors. True or False
+    once the walk is done; None when a process could not be read (a `ps` that failed or ran out of time), which is
+    "unknown", never "not launched" (FAA-68). Windows has no walk (`_process` reads no process there): False, so
+    only the environment signals count. Only the path is matched; nothing read here is kept or logged."""
+    if process is None and platform == "win32":
+        return False
     marker = os.path.normpath(str(fabric_root(env=env) / "sessions")) + os.sep
+    process = process or _process
     pid = os.getppid()
     for _ in range(depth):
         if pid <= 1:
             return False
-        command, parent = _process(pid)
+        command, parent = process(pid)
         if command is None:
-            return False
+            return None
         if "--mcp-config" in command and marker in command:
             return True
         pid = parent
     return False
 
 
+#: A session rejoins at most once in this span (FAA-53): every rejoin spends Fabric's per-agent request budget, which
+#: every session of the machine shares. The Stop worker and watch-mail both honour and renew the mark (FAA-68).
+REJOIN_MIN_INTERVAL_S = 60.0
+
+
+#: The file in a session's folder that says Fabric launched it: the ancestor walk ran once and found the launcher.
+LAUNCHED_MARK = "launched"
+
+
+#: The file in a session's folder that says Fabric held no session for its id: fabric-mcp --rejoin-only exited 3
+#: (Fabric 0.3.9, TR-11). For NO_SESSION_HOLD_S the hooks spool nothing for that id; after it, one rejoin tries again,
+#: so a Fabric that restarted and enrolled the id again is found (board thread 02bf19c5, ask 4).
+NO_SESSION_MARK = "no-session"
+NO_SESSION_HOLD_S = 15 * 60.0
+
+
+def no_session_held(directory: Path, now: Optional[float] = None) -> bool:
+    """Whether a rejoin found no Fabric session for this id within NO_SESSION_HOLD_S."""
+    try:
+        mark = (directory / NO_SESSION_MARK).stat().st_mtime
+    except OSError:
+        return False
+    age = (time.time() if now is None else now) - mark
+    return 0 <= age < NO_SESSION_HOLD_S
+
+
+def rejoined_recently(directory: Path, now: Optional[float] = None) -> bool:
+    """Whether this session's last rejoin succeeded within REJOIN_MIN_INTERVAL_S (the worker marks it)."""
+    return rejoin_wait(directory, now) > 0
+
+
+def rejoin_wait(directory: Path, now: Optional[float] = None) -> float:
+    """Seconds until this session may rejoin again; 0 when it may now."""
+    try:
+        mark = (directory / "rejoined").stat().st_mtime
+    except OSError:
+        return 0.0
+    age = (time.time() if now is None else now) - mark
+    return REJOIN_MIN_INTERVAL_S - age if 0 <= age < REJOIN_MIN_INTERVAL_S else 0.0
+
+
 def log(line: str, env: Optional[Dict[str, str]] = None) -> None:
     """One structured line, 0600, rotated at 1 MB. Never raises."""
     try:

package/plugins/fabric-agent-adapter/skills/working-with-fabric/scripts/fabric_session_hosts.py

@@ -5,6 +5,7 @@ from __future__ import annotations
 import hashlib
 import json
 import os
+import re
 import sys
 import time
 from pathlib import Path
@@ -101,6 +102,52 @@ def _kimi_block(command: str) -> str:
             "[[hooks]]\nevent = \"SessionStart\"\ncommand = %s\ntimeout = 5\n" % json.dumps(command))
 
 
+_KIMI_COMMENT = _kimi_block("").split("[[hooks]]", 1)[0].lstrip("\n").splitlines(True)  # our two comment lines
+
+
+def _kimi_spans(text: str, host: str) -> List[Tuple[int, int]]:
+    """Where each `[[hooks]]` table whose command is ours sits in `text`, as line ranges [header, end). A table ends at
+    the next header; trailing blank and comment lines belong to what follows. Each table is read on its own with
+    tomllib, so a hand-touched table (another order, a comment, another timeout) is still found by what it runs."""
+    lines = text.splitlines(True)
+    headers = [i for i, line in enumerate(lines) if line.startswith("[")]
+    spans = []
+    for n, start in enumerate(headers):
+        if not re.match(r"\[\[\s*hooks\s*\]\]\s*(#.*)?\Z", lines[start].rstrip("\r\n")):
+            continue
+        end = headers[n + 1] if n + 1 < len(headers) else len(lines)
+        while end > start + 1 and (not lines[end - 1].strip() or lines[end - 1].lstrip().startswith("#")):
+            end -= 1
+        try:
+            table = tomllib.loads("".join(lines[start:end]))["hooks"][0]
+        except (ValueError, KeyError, IndexError, TypeError):
+            continue
+        if isinstance(table, dict) and _is_ours(table.get("command"), host):
+            spans.append((start, end))
+    return spans
+
+
+def _kimi_edit(text: str, host: str, command: Optional[str]) -> str:
+    """`text` with our one `[[hooks]]` table pointed at `command`, or taken out (None) with the comment lines and the
+    blank line `_kimi_block` put before it. Refused when there is not exactly one."""
+    spans = _kimi_spans(text, host)
+    if len(spans) != 1:
+        raise Refused("found %d Fabric hook tables to edit; remove the extra ones by hand" % len(spans))
+    lines = text.splitlines(True)
+    start, end = spans[0]
+    if command is not None:
+        found = [i for i in range(start + 1, end) if re.match(r"\s*command\s*=", lines[i])]
+        if len(found) != 1:
+            raise Refused("the Fabric hook's command could not be found line by line; edit it by hand")
+        lines[found[0]] = "command = %s\n" % json.dumps(command)
+        return "".join(lines)
+    if lines[max(0, start - len(_KIMI_COMMENT)):start] == _KIMI_COMMENT:
+        start -= len(_KIMI_COMMENT)
+    if start > 0 and lines[start - 1] == "\n":
+        start -= 1
+    return "".join(lines[:start] + lines[end:])
+
+
 def _replace_file(path: Path, data: bytes, seen: Optional[bytes]) -> Optional[Path]:
     """Back the file up, then write `data` atomically with the file's own mode. Refused when the file changed
     since it was read. Returns the backup."""
@@ -163,9 +210,14 @@ def install_host_hooks_cli(argv: Sequence[str], env: Optional[Dict[str, str]] =
         path = Path(env.get("CODEX_HOME") or str(_home(env) / ".codex")) / "hooks.json"
     else:
         path = _home(env) / ".kimi-code" / "config.toml"
-    command = hook_command(str(args.script or default_hook_script(env)), args.host)
+    script = Path(args.script).expanduser().absolute() if args.script else default_hook_script(env)
+    command = hook_command(str(script), args.host)
     shifted = 0  # Codex hook groups after ours, whose position a removal moves
+    updated = False  # our own hook was there with another command, and is rewritten (FAA-69)
     try:
+        if not args.remove and not script.is_file():
+            # A hook pointing at nothing fails at every session start; removal needs no script.
+            raise Refused("--script %s is not a file; pass the fabric_session.py of a complete installed skill" % script)
         data = _read_bytes(path)
         digest = _digest(data)
         if args.expect_sha256 and args.expect_sha256 != digest:
@@ -201,37 +253,43 @@ def install_host_hooks_cli(argv: Sequence[str], env: Optional[Dict[str, str]] =
                     out("install-host-hooks: the Fabric preamble hook is already in %s; nothing to change" % path)
                     return 0
                 owned[0]["command"] = command
+                updated = True
                 new = (json.dumps(doc, indent=2) + "\n").encode("utf-8")
             else:
                 doc.setdefault("hooks", {}).setdefault("SessionStart", []).append(entry)
                 new = (json.dumps(doc, indent=2) + "\n").encode("utf-8")
-            change = "remove from hooks.SessionStart" if args.remove else "add to hooks.SessionStart"
+            change = ("remove from" if args.remove else "update in" if updated else "add to") + " hooks.SessionStart"
             shown = json.dumps(entry, indent=2)
         else:
             block = _kimi_block(command)
             text = (data or b"").decode("utf-8", "replace")
-            if not (args.apply or args.remove):
-                present = tomllib is not None and any(_is_ours(h.get("command"), args.host) for h in _kimi_hooks(data))
-            else:
-                present = any(_is_ours(h.get("command"), args.host) for h in _kimi_hooks(data))
+            # Our table is found by what it runs (_is_ours), not by its exact text, so a stale path is repaired and a
+            # hand-touched table is still removed (FAA-69). A dry run without a TOML reader shows the plain append.
+            readable = tomllib is not None or args.apply or args.remove
+            owned = [h for h in _kimi_hooks(data) if _is_ours(h.get("command"), args.host)] if readable else []
+            if len(owned) > 1:
+                raise Refused("multiple Fabric hooks are configured in %s; remove the extra ones by hand" % path)
             if args.remove:
-                if not present:
+                if not owned:
                     out("install-host-hooks: no Fabric preamble hook in %s; nothing to change" % path)
                     return 0
-                if block not in text:
-                    raise Refused("the Fabric hook in %s was edited by hand; remove its [[hooks]] table yourself" % path)
-                new_text = text.replace(block, "", 1)
-            elif present:
+                new_text = _kimi_edit(text, args.host, None)
+            elif owned and owned[0].get("command") == command:
                 out("install-host-hooks: the Fabric preamble hook is already in %s; nothing to change" % path)
                 return 0
+            elif owned:
+                new_text = _kimi_edit(text, args.host, command)
+                updated = True
             else:
                 new_text = text + ("" if not text or text.endswith("\n") else "\n") + block
             new = new_text.encode("utf-8")
             if args.apply or args.remove:
                 after = _kimi_hooks(new)
-                if len(after) != len(_kimi_hooks(data)) + (-1 if args.remove else 1):
+                mine = [h.get("command") for h in after if _is_ours(h.get("command"), args.host)]
+                growth = -1 if args.remove else 0 if updated else 1
+                if len(after) != len(_kimi_hooks(data)) + growth or mine != ([] if args.remove else [command]):
                     raise Refused("the edited file would not read back as expected; nothing was changed")
-            change = "remove from" if args.remove else "append to"
+            change = "remove from" if args.remove else "update in" if updated else "append to"
             shown = block.strip("\n")
         if not (args.apply or args.remove):
             out("install-host-hooks: dry run, nothing is written.")
@@ -248,6 +306,7 @@ def install_host_hooks_cli(argv: Sequence[str], env: Optional[Dict[str, str]] =
             return 0
         backup = _replace_file(path, new, data)
         out("install-host-hooks: %s %s %s." % ("removed the Fabric preamble hook from" if args.remove
+                                              else "updated the Fabric preamble hook in" if updated
                                               else "added the Fabric preamble hook to", path,
                                               "(backup: %s)" % backup if backup else "(new file)"))
         out("Undo: fabric_session.py install-host-hooks --host %s %s" % (args.host, "--apply" if args.remove else "--remove"))

package/plugins/fabric-agent-adapter/skills/working-with-fabric/scripts/fabric_session_mail.py

@@ -15,13 +15,17 @@ from fabric_session_env import (  # noqa: E402 - the kit (FAA-65)
     UNREAD_LINE,
     VERSION,
     WORKER_DEADLINE_S,
+    _write_private,
     claude_registration,
     fabric_launched,
     fabric_root,
     locate_hub,
+    rejoin_wait,
+    session_dir,
 )
 from fabric_session_mcp import (  # noqa: E402 - the kit (FAA-65)
     McpStdio,
+    NoSessionError,
     _wait_for_session_tools,
     board_unread,
 )
@@ -36,9 +40,15 @@ WATCH_MAX_BACKOFF_S = 900
 def poll_unread(session_id: str, cwd: Path, env: Optional[Dict[str, str]] = None,
                 deadline_s: float = WORKER_DEADLINE_S) -> Tuple[str, Any]:
     """One look at the board through `fabric-mcp --rejoin-only`: ("ok", count), ("unavailable", why) when Fabric
-    answers but the board cannot be read, ("down", why) when Fabric cannot be reached. No fabric-mcp starts unless
-    the running Fabric advertises session-hooks/1 (the rejoin)."""
+    answers but the board cannot be read, ("down", why) when Fabric cannot be reached, ("wait", seconds) when the
+    session rejoined within the last minute (the Stop worker's mark, or this one's): the rejoin budget is shared, so
+    no fabric-mcp starts then (FAA-68). No fabric-mcp starts unless the running Fabric advertises session-hooks/1
+    (the rejoin). A successful rejoin renews the mark in the session's folder when the hooks made one."""
     env = dict(os.environ if env is None else env)
+    directory = session_dir(session_id, env)
+    left = rejoin_wait(directory)
+    if left > 0:
+        return "wait", left
     hub = locate_hub(fabric_root(env=env))
     if hub["state"] != "running":
         return "down", "Fabric is not running (%s)" % hub["reason"]
@@ -56,10 +66,17 @@ def poll_unread(session_id: str, cwd: Path, env: Optional[Dict[str, str]] = None
                                       "clientInfo": {"name": "fabric-agent-adapter-watch-mail", "version": VERSION}})
         client.notify("notifications/initialized")
         names = _wait_for_session_tools(client, deadline)
+        if directory.is_dir():  # the hooks made it, after their launch check; never made here
+            try:
+                _write_private(directory / "rejoined", "")
+            except OSError:
+                pass
         if BOARD_STATUS_TOOL not in names:
             return "unavailable", "this Fabric serves no %s" % BOARD_STATUS_TOOL
         unread, said = board_unread(client.request("tools/call", {"name": BOARD_STATUS_TOOL, "arguments": {}}))
         return ("ok", unread) if unread is not None else ("unavailable", "the project board cannot be read (%s)" % said)
+    except NoSessionError:
+        return "down", "Fabric holds no session for this id"
     except TimeoutError:
         return "down", "fabric-mcp did not join this session in time"
     except Exception as exc:  # noqa: BLE001 — a poll never raises
@@ -72,15 +89,18 @@ def poll_unread(session_id: str, cwd: Path, env: Optional[Dict[str, str]] = None
 def watch_mail(session_id: str, cwd: Path, env: Optional[Dict[str, str]] = None, interval: float = 60, *,
                poll: Optional[Callable[[], Tuple[str, Any]]] = None, out: Callable[[str], None] = print,
                wait: Callable[[float], bool], stop: Callable[[], bool], rng: Callable[[], float]) -> int:
-    """Poll the board every `interval` seconds (±20 % jitter, never under WATCH_MIN_INTERVAL_S) and print ONE line each
-    time the unread count rises. While Fabric is down or the board unreadable, say so once and back off, doubling up
-    to WATCH_MAX_BACKOFF_S. `wait(seconds)` returns True when it was told to stop."""
+    """Poll the board every `interval` seconds (±20 % jitter; the delay after jitter stays within WATCH_MIN_INTERVAL_S
+    and WATCH_MAX_BACKOFF_S) and print ONE line each time the unread count rises. While Fabric is down or the board
+    unreadable, say so once and back off, doubling up to WATCH_MAX_BACKOFF_S. A look the shared rejoin mark holds back
+    ("wait") changes nothing and waits it out. `wait(seconds)` returns True when it was told to stop."""
     interval = max(float(WATCH_MIN_INTERVAL_S), float(interval))
     poll = poll or (lambda: poll_unread(session_id, cwd, env))
     last, trouble, backoff = 0, None, interval
     while not stop():
         kind, value = poll()
-        if kind == "ok":
+        if kind == "wait":
+            delay = float(value)
+        elif kind == "ok":
             if value > last:
                 out(UNREAD_LINE % value)
             last, trouble, backoff = value, None, interval
@@ -91,7 +111,8 @@ def watch_mail(session_id: str, cwd: Path, env: Optional[Dict[str, str]] = None,
                 out("watch-mail: %s; trying again, backing off up to %d minutes" % (value, WATCH_MAX_BACKOFF_S // 60))
                 trouble = kind
             delay = backoff
-        if wait(delay * (0.8 + 0.4 * rng())):
+        jittered = delay if kind == "wait" else delay * (0.8 + 0.4 * rng())
+        if wait(min(max(jittered, float(WATCH_MIN_INTERVAL_S)), float(WATCH_MAX_BACKOFF_S))):
             break
     return 0