swarph-cli 0.22.0__tar.gz → 0.23.1__tar.gz

{swarph_cli-0.22.0/src/swarph_cli.egg-info → swarph_cli-0.23.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: swarph-cli
-Version: 0.22.0
+Version: 0.23.1
 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`, session `import`, and a stranded-session `watchdog`.
 Author: Pierre Samson, Claude Opus
 License: MIT

{swarph_cli-0.22.0 → swarph_cli-0.23.1}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "swarph-cli"
-version = "0.22.0"
+version = "0.23.1"
 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`, session `import`, and a stranded-session `watchdog`."
 readme = "README.md"
 license = { text = "MIT" }

{swarph_cli-0.22.0 → swarph_cli-0.23.1}/src/swarph_cli/__init__.py

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

swarph_cli-0.23.1/src/swarph_cli/chain_token.py

@@ -0,0 +1,42 @@
+"""Producer-signed chain-token for event-chaining (spec §5a). Compact HMAC blob the
+producer signs + verifies; the cell only passes it through opaquely (can't forge it)."""
+from __future__ import annotations
+import base64, hashlib, hmac, json
+from typing import Optional
+
+
+def _b64(b: bytes) -> str:
+    return base64.urlsafe_b64encode(b).decode().rstrip("=")
+
+
+def _unb64(s: str) -> bytes:
+    return base64.urlsafe_b64decode(s + "=" * (-len(s) % 4))
+
+
+def sign_chain_token(secret: str, chain_id: str, depth: int, jti: str) -> str:
+    payload = json.dumps({"chain_id": chain_id, "depth": int(depth), "jti": jti},
+                         separators=(",", ":"), sort_keys=True).encode()
+    sig = hmac.new(secret.encode(), payload, hashlib.sha256).digest()
+    return f"{_b64(payload)}.{_b64(sig)}"
+
+
+def verify_chain_token(secret: str, token: str) -> Optional[dict]:
+    # token is opaque untrusted input (network / mesh DM); a non-str value has no
+    # .split and would AttributeError past the except below. Guard explicitly.
+    if not isinstance(token, str):
+        return None
+    try:
+        body_s, sig_s = token.split(".", 1)
+        payload = _unb64(body_s)
+        expected = hmac.new(secret.encode(), payload, hashlib.sha256).digest()
+        if not hmac.compare_digest(_unb64(sig_s), expected):
+            return None
+        d = json.loads(payload)
+        if not isinstance(d, dict) or {"chain_id", "depth", "jti"} - d.keys():
+            return None
+        return {"chain_id": d["chain_id"], "depth": int(d["depth"]), "jti": d["jti"]}
+    except (ValueError, TypeError, KeyError, AttributeError, json.JSONDecodeError):
+        # the known malformed-input paths (split / b64 / json / int / dict /
+        # non-str secret). Fail safe to None. NOT a bare `Exception`: an
+        # unexpected error should surface as a bug, not masquerade as "invalid".
+        return None

swarph_cli-0.23.1/src/swarph_cli/commands/event.py

@@ -0,0 +1,119 @@
+"""``swarph event`` — emit an event to a mesh channel (event-chaining P0).
+
+``swarph event emit <event> <payload> [--chain-token <opaque>] [--channel events]``
+posts to a channel via the shipped channel-post client, carrying an ``event`` tag,
+the payload, and any ``--chain-token`` as an OPAQUE passthrough. The cell never
+signs or parses the chain-token — signing/verifying is the producer's authority
+(the P1 gateway guard). See ``swarph_cli.chain_token`` for the producer-side
+sign/verify helpers.
+"""
+
+from __future__ import annotations
+
+import argparse
+import json
+import sys
+
+from ._gateway_client import (
+    add_common_args,
+    post_json,
+    resolve_self_name,
+    resolve_token,
+)
+
+
+def _build_parser() -> argparse.ArgumentParser:
+    p = argparse.ArgumentParser(
+        prog="swarph event",
+        description="Emit an event to a mesh channel (opaque chain-token passthrough).",
+    )
+    sub = p.add_subparsers(dest="command")
+
+    emit = sub.add_parser("emit", help="emit an event to a channel")
+    emit.add_argument("event", help="event name/tag")
+    emit.add_argument("payload", help="event payload (opaque string)")
+    emit.add_argument(
+        "--chain-token",
+        default=None,
+        help="opaque producer-signed chain token — passed through, never parsed",
+    )
+    emit.add_argument(
+        "--channel",
+        default="events",
+        help="target channel (default: events)",
+    )
+    add_common_args(emit)
+    return p
+
+
+def _post_channel(
+    *,
+    channel: str,
+    event: str,
+    payload: str,
+    chain_token: str | None = None,
+    gateway: str | None = None,
+    self_name: str | None = None,
+    token_file: str | None = None,
+) -> int:
+    """Bridge to the shipped channel-post client (the ``/messages`` channel path
+    that ``swarph channel`` / ``swarph mesh`` post through). Wraps the event tag +
+    payload + (opaque) chain-token into the post body and returns 0 on a 2xx.
+
+    NOTE: the plan's seam is ``_post_channel(**kw)``; the gateway's ``post_json``
+    takes ``(url, body, token)``, so this function resolves identity/token and
+    shapes the body, then delegates to that same shared client — it does NOT
+    reinvent the gateway post path. Tests monkeypatch this function directly.
+    """
+    name = resolve_self_name(self_name)
+    token = resolve_token(name, token_file)
+    from .mesh import _DEFAULT_GATEWAY
+
+    base = (gateway or _DEFAULT_GATEWAY).rstrip("/")
+    ev: dict = {"event": event, "payload": payload}
+    if chain_token is not None:  # carry an explicit "" through; only omit when unset
+        ev["chain_token"] = chain_token
+    # Sentinel-wrapped so P1's guard can UNAMBIGUOUSLY identify an event post: a
+    # normal channel message won't carry the top-level `swarph_event` key, so the
+    # guard keys off `content.swarph_event` — never a false-positive on a plain
+    # message whose content happens to hold an "event" field. kind stays "fyi"
+    # (gateway VALID_KINDS); P1 promotes this to a first-class kind/column when it
+    # touches the gateway.
+    content: dict = {"swarph_event": ev}
+    body = {
+        "from_node": name,
+        "channel": channel,
+        "kind": "fyi",
+        "content": json.dumps(content, separators=(",", ":"), sort_keys=True),
+    }
+    status, resp = post_json(f"{base}/messages", body, token)
+    if 200 <= status < 300:
+        print(f"emitted event={event} channel={channel} id={resp.get('id')}")
+        return 0
+    detail = resp.get("detail", "<gateway error>")
+    print(f"swarph event emit: gateway {status}: {detail}", file=sys.stderr)
+    return 1
+
+
+def run_event(argv: list) -> int:
+    p = _build_parser()
+    args = p.parse_args(argv)
+    if args.command is None:
+        p.print_help()
+        return 0
+    try:
+        if args.command == "emit":
+            return _post_channel(
+                channel=args.channel,
+                event=args.event,
+                payload=args.payload,
+                chain_token=args.chain_token,
+                gateway=args.gateway,
+                self_name=args.self_name,
+                token_file=args.token_file,
+            )
+    except RuntimeError as e:
+        print(f"swarph event: {e}", file=sys.stderr)
+        return 2
+    p.print_help()
+    return 0

{swarph_cli-0.22.0 → swarph_cli-0.23.1}/src/swarph_cli/main.py

@@ -96,6 +96,7 @@ _VERB_HANDLERS: dict[str, str] = {
     "gateway": "swarph_cli.commands.gateway.run_gateway",
     "service": "swarph_cli.commands.service.run_service",
     "channel": "swarph_cli.commands.channel.run_channel",
+    "event": "swarph_cli.commands.event.run_event",
     "schedule": "swarph_cli.commands.schedule.run_schedule",
     "lane": "swarph_cli.commands.lane.run_lane",
     "install-multiplexer": "swarph_cli.commands.install_multiplexer.run_install_multiplexer",

{swarph_cli-0.22.0 → swarph_cli-0.23.1/src/swarph_cli.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: swarph-cli
-Version: 0.22.0
+Version: 0.23.1
 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`, session `import`, and a stranded-session `watchdog`.
 Author: Pierre Samson, Claude Opus
 License: MIT

{swarph_cli-0.22.0 → swarph_cli-0.23.1}/src/swarph_cli.egg-info/SOURCES.txt

@@ -4,6 +4,7 @@ pyproject.toml
 src/swarph_cli/__init__.py
 src/swarph_cli/caller.py
 src/swarph_cli/cell.py
+src/swarph_cli/chain_token.py
 src/swarph_cli/main.py
 src/swarph_cli/multiplexer.py
 src/swarph_cli.egg-info/PKG-INFO
@@ -29,6 +30,7 @@ src/swarph_cli/commands/channel.py
 src/swarph_cli/commands/chat.py
 src/swarph_cli/commands/compress.py
 src/swarph_cli/commands/daemon.py
+src/swarph_cli/commands/event.py
 src/swarph_cli/commands/gateway.py
 src/swarph_cli/commands/highlight.py
 src/swarph_cli/commands/hook_output.py
@@ -87,6 +89,7 @@ tests/test_cell_command_dispatch.py
 tests/test_cell_harden.py
 tests/test_cell_loader.py
 tests/test_cell_verify.py
+tests/test_chain_token.py
 tests/test_channel_command.py
 tests/test_chat_command.py
 tests/test_claude_parser.py
@@ -97,6 +100,7 @@ tests/test_compress_levers.py
 tests/test_compress_marker.py
 tests/test_compress_verify.py
 tests/test_daemon_command.py
+tests/test_event_emit.py
 tests/test_feature_to_uri.py
 tests/test_gateway_client.py
 tests/test_gateway_command.py

swarph_cli-0.23.1/tests/test_chain_token.py

@@ -0,0 +1,34 @@
+import pytest
+from swarph_cli.chain_token import sign_chain_token, verify_chain_token
+
+SECRET = "producer-secret-xyz"
+
+def test_sign_verify_roundtrip():
+    t = sign_chain_token(SECRET, "chain-1", 3, "jti-abc")
+    assert verify_chain_token(SECRET, t) == {"chain_id": "chain-1", "depth": 3, "jti": "jti-abc"}
+
+def test_tampered_payload_rejected():
+    t = sign_chain_token(SECRET, "chain-1", 0, "jti-abc")
+    _, sig = t.split(".")
+    import base64, json
+    # CANONICAL re-encode (same separators/sort_keys the signer uses) with ONLY depth
+    # changed → isolates that the HMAC catches the VALUE change, not a formatting diff.
+    forged = json.dumps({"chain_id": "chain-1", "depth": 99, "jti": "jti-abc"},
+                        separators=(",", ":"), sort_keys=True).encode()
+    bad = base64.urlsafe_b64encode(forged).decode().rstrip("=") + "." + sig
+    assert verify_chain_token(SECRET, bad) is None   # depth 0→99, canonical form, sig mismatch
+
+def test_wrong_secret_rejected():
+    t = sign_chain_token(SECRET, "c", 1, "j")
+    assert verify_chain_token("other-secret", t) is None
+
+def test_malformed_never_raises():
+    for bad in ["", "nodot", "a.b.c", "!!.??", "x."]:
+        assert verify_chain_token(SECRET, bad) is None
+
+def test_non_str_token_fails_safe_not_raises():
+    # opaque tokens arrive from untrusted input (network / mesh DM); a non-str
+    # value (None, bytes, int) must fail safe to None, never AttributeError out
+    # of the caller. Regression for the gateway-copy fix that lagged the CLI.
+    for bad in [None, 123, b"a.b", ["a", "b"], {"chain_id": "x"}]:
+        assert verify_chain_token(SECRET, bad) is None

swarph_cli-0.23.1/tests/test_event_emit.py

@@ -0,0 +1,36 @@
+def test_event_emit_posts_with_tag_and_token(monkeypatch):
+    from swarph_cli.commands import event as evmod
+    captured = {}
+    monkeypatch.setattr(evmod, "_post_channel", lambda **kw: captured.update(kw) or 0)
+    rc = evmod.run_event(["emit", "stage-done", "the output", "--chain-token", "TOK", "--channel", "events"])
+    assert rc == 0
+    assert captured["channel"] == "events"
+    assert captured["event"] == "stage-done"
+    assert captured["payload"] == "the output"
+    assert captured["chain_token"] == "TOK"
+
+def test_event_emit_no_token(monkeypatch):
+    from swarph_cli.commands import event as evmod
+    captured = {}
+    monkeypatch.setattr(evmod, "_post_channel", lambda **kw: captured.update(kw) or 0)
+    evmod.run_event(["emit", "e", "p"])
+    assert captured.get("chain_token") is None  # argparse default=None, not ""
+
+
+def test_event_emit_real_envelope_is_sentinel_wrapped(monkeypatch):
+    # exercise the REAL _post_channel (not the seam) to prove the content envelope is
+    # sentinel-wrapped so P1's guard identifies events unambiguously (a plain channel
+    # message won't carry the top-level `swarph_event` key).
+    import json
+    from swarph_cli.commands import event as evmod
+    monkeypatch.setattr(evmod, "resolve_self_name", lambda *a, **k: "lab-ovh")
+    monkeypatch.setattr(evmod, "resolve_token", lambda *a, **k: "tok")
+    captured = {}
+    monkeypatch.setattr(evmod, "post_json",
+                        lambda url, body, token: (captured.update(body=body) or (200, {"id": 1})))
+    rc = evmod.run_event(["emit", "stage-done", "out", "--chain-token", "TOK"])
+    assert rc == 0
+    content = json.loads(captured["body"]["content"])
+    assert "swarph_event" in content
+    assert content["swarph_event"] == {"event": "stage-done", "payload": "out", "chain_token": "TOK"}
+    assert captured["body"]["kind"] == "fyi"  # VALID_KINDS-safe; P1 promotes to first-class