swarph-cli 0.72.5__tar.gz → 0.72.6__tar.gz

{swarph_cli-0.72.5/src/swarph_cli.egg-info → swarph_cli-0.72.6}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: swarph-cli
-Version: 0.72.5
+Version: 0.72.6
 Summary: The `swarph` binary — a multi-LLM CLI and mesh-gateway client + bundled server (`swarph gateway`): one-shot prompts across providers, interactive `chat`, multi-provider `spawn` (claude/codex/antigravity via a ProviderMembrane with subprocess billing-scrub), `mesh` send/inbox/register, `brain-ask` over the swarph-brain (gbrain) semantic memory, git-backed `assisted_memory`, per-invocation `gh` identity routing, a silent DM-wake hook, session `import`, and a stranded-session `watchdog`.
 Author: Pierre Samson, Claude Opus
 License: MIT

{swarph_cli-0.72.5 → swarph_cli-0.72.6}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "swarph-cli"
-version = "0.72.5"
+version = "0.72.6"
 description = "The `swarph` binary — a multi-LLM CLI and mesh-gateway client + bundled server (`swarph gateway`): one-shot prompts across providers, interactive `chat`, multi-provider `spawn` (claude/codex/antigravity via a ProviderMembrane with subprocess billing-scrub), `mesh` send/inbox/register, `brain-ask` over the swarph-brain (gbrain) semantic memory, git-backed `assisted_memory`, per-invocation `gh` identity routing, a silent DM-wake hook, session `import`, and a stranded-session `watchdog`."
 readme = "README.md"
 license = { text = "MIT" }

{swarph_cli-0.72.5 → swarph_cli-0.72.6}/src/swarph_cli/__init__.py

@@ -16,6 +16,6 @@ The architecture splits CLI from substrate so:
 
 from __future__ import annotations
 
-__version__ = "0.72.5"
+__version__ = "0.72.6"
 
 __all__ = ["__version__"]

{swarph_cli-0.72.5 → swarph_cli-0.72.6}/src/swarph_cli/scripts/dm_notify_filter.py

@@ -41,6 +41,12 @@ from typing import IO, Any, Optional
 
 _IDLE_DEFAULT_SECONDS = 1800
 
+# Card #1050: ANY per-line failure is a logged skip, never a process death
+# (a death in --once mode reads as "no DM arrived"). The notice keeps the
+# [MESH DM prefix and goes to stdout so a downstream waker wakes on it;
+# it is ASCII-only so it cannot itself raise on a hostile-errors stdout.
+_SKIP_NOTICE = "[MESH DM] unrenderable line skipped"
+
 
 def _reader(stream: IO[str], q: "queue.Queue[Optional[str]]") -> None:
     """Daemon thread: blocking readline loop, None sentinel on EOF."""
@@ -110,11 +116,16 @@ def run_filter(
             except Exception:
                 d = None
             if isinstance(d, dict):
-                d = d.get("dm") or d
-                rendered = _format_dm(d)
-                if rendered is not None:
-                    print(rendered, file=stdout, flush=True)
-                    quiet = False
+                try:
+                    d = d.get("dm") or d
+                    rendered = _format_dm(d)
+                    if rendered is not None:
+                        print(rendered, file=stdout, flush=True)
+                        quiet = False
+                except BrokenPipeError:
+                    raise  # a closed pipe stays loud (SIGPIPE contract)
+                except Exception:
+                    print(_SKIP_NOTICE, file=stdout, flush=True)
             processed += 1
             if max_lines is not None and processed >= max_lines:
                 return 0
@@ -148,11 +159,16 @@ def run_once(path: str, stdout: IO[str], *, timeout: float = 2.0) -> int:
             except Exception:
                 continue
             if isinstance(d, dict):
-                d = d.get("dm") or d
-                rendered = _format_dm(d) if isinstance(d, dict) else None
-                if rendered is not None:
-                    print(rendered, file=stdout, flush=True)
-                    return 0
+                try:
+                    d = d.get("dm") or d
+                    rendered = _format_dm(d) if isinstance(d, dict) else None
+                    if rendered is not None:
+                        print(rendered, file=stdout, flush=True)
+                        return 0
+                except BrokenPipeError:
+                    raise  # a closed pipe stays loud (SIGPIPE contract)
+                except Exception:
+                    print(_SKIP_NOTICE, file=stdout, flush=True)
         time.sleep(0.05)
     return 1
 
@@ -171,6 +187,13 @@ def main(argv: Optional[list[str]] = None) -> int:
     p.add_argument("--timeout", type=float, default=2.0,
                    help="seconds --once waits for a new DM (default: %(default)s)")
     args = p.parse_args(argv)
+    try:
+        # Card #1050: lone surrogates in DM content must render (as ?) and
+        # continue, never kill the watch on a strict-errors stdout. Set
+        # before EITHER print path: --once and filter mode both emit DMs.
+        sys.stdout.reconfigure(errors="replace")
+    except Exception:
+        pass
     if args.once:
         if not args.inbox:
             print("dm_notify_filter --once needs --inbox", file=sys.stderr)

{swarph_cli-0.72.5 → swarph_cli-0.72.6/src/swarph_cli.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: swarph-cli
-Version: 0.72.5
+Version: 0.72.6
 Summary: The `swarph` binary — a multi-LLM CLI and mesh-gateway client + bundled server (`swarph gateway`): one-shot prompts across providers, interactive `chat`, multi-provider `spawn` (claude/codex/antigravity via a ProviderMembrane with subprocess billing-scrub), `mesh` send/inbox/register, `brain-ask` over the swarph-brain (gbrain) semantic memory, git-backed `assisted_memory`, per-invocation `gh` identity routing, a silent DM-wake hook, session `import`, and a stranded-session `watchdog`.
 Author: Pierre Samson, Claude Opus
 License: MIT

{swarph_cli-0.72.5 → swarph_cli-0.72.6}/src/swarph_cli.egg-info/SOURCES.txt

@@ -193,6 +193,7 @@ tests/test_1006_session_board.py
 tests/test_1010_strand_only.py
 tests/test_1013_spawn_channel.py
 tests/test_1017_muse_tui.py
+tests/test_1050_surrogate_wake.py
 tests/test_124_register_merge.py
 tests/test_126_pending_from_complete.py
 tests/test_132_ensure_monitor_state_dir.py

swarph_cli-0.72.6/tests/test_1050_surrogate_wake.py

@@ -0,0 +1,115 @@
+"""#1050 — a DM whose content holds a lone surrogate escape must not kill
+the wake filter.
+
+Found by drop-on-meta-edge in #1298 (card #1049 Go A/B): a valid JSON line
+carrying e.g. \\ud83d makes the filter raise UnicodeEncodeError on print —
+exit 1, NO deaf-watch line, and every later DM is never surfaced. This is
+the fleet's silent-wake filter (#482): any peer's DM can deafen a cell's
+wake without the deaf alarm firing.
+
+The escape MUST be outside Python's surrogateescape round-trip range
+(DC80-DCFF): \\udcff survives on UTF-8-mode boxes (it round-trips raw
+byte 0xFF through a pipe) and only kills on strict-errors stdouts, while
+\\ud83d (lead) and \\udfff (trail, above DCFF) kill everywhere — measured
+dead on the pre-fix filter under both default and strict stdouts (#1302).
+
+Seam: the process boundary — stdin lines in, stdout lines out — exactly
+what the accept check names.
+"""
+from __future__ import annotations
+
+import os
+import subprocess
+import sys
+
+import pytest
+
+MOD = [sys.executable, "-u", "-m", "swarph_cli.scripts.dm_notify_filter"]
+
+# Lethal on every box (see module docstring for why these, not \\udcff).
+LETHAL_ESCAPES = ("\\ud83d", "\\udfff")
+
+GOOD = '{"id":12,"from_node":"b","kind":"fyi","content":"after bad"}'
+
+
+def _run(payload: bytes) -> "subprocess.CompletedProcess[bytes]":
+    return subprocess.run(
+        MOD + ["--idle-seconds", "3600"],
+        input=payload,
+        capture_output=True,
+        timeout=60,
+        env=dict(os.environ),
+    )
+
+
+def _bad(mid: int, esc: str) -> str:
+    return ('{"id":%d,"from_node":"a","kind":"fyi","content":"AB%scCD"}'
+            % (mid, esc))
+
+
+@pytest.mark.parametrize("esc", LETHAL_ESCAPES)
+def test_lone_surrogate_then_good_dm_survives(esc: str):
+    """The good DM after a lone-surrogate line is printed; the process
+    keeps running to EOF (deaf line) instead of dying on the bad line."""
+    p = _run((_bad(11, esc) + "\n" + GOOD + "\n").encode("ascii"))
+    assert b"id=12" in p.stdout, (
+        f"good DM lost after lone-surrogate line: rc={p.returncode} "
+        f"stdout={p.stdout!r} stderr={p.stderr[-300:]!r}"
+    )
+    assert b"DEAF" in p.stdout, (
+        f"watch died without its deaf-watch line: rc={p.returncode} "
+        f"stderr={p.stderr[-300:]!r}"
+    )
+
+
+def test_lone_surrogate_never_kills_process():
+    """No per-line content may exit the filter: a whole stream of hostile
+    lines still ends at the EOF deaf line, not a traceback."""
+    lines = ([_bad(i, LETHAL_ESCAPES[i % 2]) for i in range(20)]
+             + [GOOD])
+    p = _run(("\n".join(lines) + "\n").encode("ascii"))
+    assert b"id=12" in p.stdout
+    assert b"DEAF" in p.stdout
+    assert b"Traceback" not in p.stderr
+
+
+def test_once_skips_non_string_content_and_wakes_on_next(tmp_path):
+    """#1310: run_once shares the never-die contract. A first-arriving DM
+    whose content is not a string (a number here) must become a logged
+    skip, not a death read as 'no DM arrived'; the next good DM still
+    wakes (exit 0). Seam: the --once process boundary, fed live."""
+    import threading
+    import time
+
+    inbox = tmp_path / "inbox.log"
+    inbox.write_text("")
+    proc = subprocess.Popen(
+        MOD + ["--once", "--inbox", str(inbox), "--timeout", "10"],
+        stdout=subprocess.PIPE,
+        stderr=subprocess.PIPE,
+        env=dict(os.environ),
+    )
+
+    def feed():
+        time.sleep(0.5)
+        with open(inbox, "a") as fh:
+            fh.write('{"id":41,"from_node":"a","kind":"fyi",'
+                     '"content":42}\n')
+        time.sleep(0.5)
+        with open(inbox, "a") as fh:
+            fh.write(GOOD + "\n")
+
+    threading.Thread(target=feed, daemon=True).start()
+    out, err = proc.communicate(timeout=30)
+    assert b"Traceback" not in err, f"run_once died: {err[-300:]!r}"
+    assert b"unrenderable line skipped" in out, (
+        f"numeric content was not a logged skip: rc={proc.returncode} "
+        f"stdout={out!r}"
+    )
+    assert b"id=12" in out, (
+        f"good DM after the skip did not wake: rc={proc.returncode} "
+        f"stdout={out!r}"
+    )
+    assert proc.returncode == 0, (
+        f"wake on the good DM must exit 0, got {proc.returncode}"
+    )