jep-cli 0.6.1__tar.gz

jep_cli-0.6.1/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Human Judgment Systems Foundation Ltd.
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

jep_cli-0.6.1/NOTICE.md

@@ -0,0 +1,7 @@
+# Notice
+
+This repository contains an experimental CLI seed for the JEP v0.6 API.
+
+Internet-Draft text and excerpts are governed by the IETF Trust Legal Provisions and BCP 78 / BCP 79.
+
+Implementation code, examples, and tests are provided under the repository license unless otherwise stated.

jep_cli-0.6.1/PKG-INFO

@@ -0,0 +1,141 @@
+Metadata-Version: 2.4
+Name: jep-cli
+Version: 0.6.1
+Summary: Command-line tool for creating and verifying JEP v0.6 events through the JEP API
+Author-email: HJS Spec <signal@humanjudgment.org>
+License: MIT
+Project-URL: Homepage, https://github.com/hjs-spec/cli
+Project-URL: Repository, https://github.com/hjs-spec/cli
+Project-URL: Issues, https://github.com/hjs-spec/cli/issues
+Classifier: Development Status :: 3 - Alpha
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: Python :: 3
+Requires-Python: >=3.9
+Description-Content-Type: text/markdown
+License-File: LICENSE
+License-File: NOTICE.md
+Provides-Extra: dev
+Requires-Dist: pytest>=7.0.0; extra == "dev"
+Dynamic: license-file
+
+# JEP CLI v0.6
+
+Command-line tool for creating and verifying JEP v0.6 events through the JEP API.
+
+This CLI targets:
+
+```text
+POST /events/create
+POST /events/verify
+GET  /health
+```
+
+It is aligned with:
+
+- `draft-wang-jep-judgment-event-protocol-06`
+- `draft-wang-jep-profiles-00`
+- `draft-wang-jep-conformance-00`
+- `hjs-spec/jep-api`
+
+## Status
+
+Experimental implementation seed.
+
+This CLI does not define new JEP-Core semantics and does not determine legal liability, factual truth, regulatory compliance, or complete-log availability.
+
+## Installation
+
+```bash
+pip install -e ".[dev]"
+```
+
+## Configuration
+
+Use flags:
+
+```bash
+jep --base-url http://127.0.0.1:8000 health
+```
+
+Or environment variables:
+
+```bash
+export JEP_API_URL=http://127.0.0.1:8000
+export JEP_API_KEY=
+```
+
+## Commands
+
+### Health
+
+```bash
+jep health
+```
+
+### Create a Judgment event
+
+```bash
+jep create \
+  --verb J \
+  --who did:example:agent-789 \
+  --what '{"claim":"approve","subject":"demo"}' \
+  --aud https://api.example.org
+```
+
+### Create with extensions
+
+```bash
+jep create \
+  --verb J \
+  --who did:example:agent-789 \
+  --what '{"claim":"approve"}' \
+  --ext 'https://example.org/profile={"name":"demo"}' \
+  --ext-crit https://example.org/profile
+```
+
+### Verify an event from a file
+
+```bash
+jep verify event.json --mode archival
+```
+
+### Pipe create response into verify
+
+```bash
+jep create --verb J --who did:example:agent --what '{"claim":"approve"}' > response.json
+jep extract-event response.json > event.json
+jep verify event.json
+```
+
+## Input Rules
+
+`--what` and event arguments may be:
+
+- inline JSON;
+- a plain string;
+- a file path;
+- `-` for stdin.
+
+## Related Repositories
+
+- JEP v0.6: https://github.com/hjs-spec/jep-v06
+- JEP API v0.6: https://github.com/hjs-spec/jep-api
+- JEP Python SDK v0.6: https://github.com/hjs-spec/jep-sdk-py
+- JEP Go SDK v0.6: https://github.com/hjs-spec/jep-sdk-go
+- HJS v0.5: https://github.com/hjs-spec/hjs-05
+- JAC v0.5: https://github.com/hjs-spec/jac-agent-02
+
+## Public Drafts
+
+- JEP-Core: https://datatracker.ietf.org/doc/draft-wang-jep-judgment-event-protocol/
+- JEP-Profiles: https://datatracker.ietf.org/doc/draft-wang-jep-profiles/
+- JEP-Conformance: https://datatracker.ietf.org/doc/draft-wang-jep-conformance/
+
+## License
+
+MIT
+
+## Runtime and verification notes
+
+See [HARDENING.md](HARDENING.md) for supported behavior, regression checks, and compatibility boundaries.

jep_cli-0.6.1/README.md

@@ -0,0 +1,120 @@
+# JEP CLI v0.6
+
+Command-line tool for creating and verifying JEP v0.6 events through the JEP API.
+
+This CLI targets:
+
+```text
+POST /events/create
+POST /events/verify
+GET  /health
+```
+
+It is aligned with:
+
+- `draft-wang-jep-judgment-event-protocol-06`
+- `draft-wang-jep-profiles-00`
+- `draft-wang-jep-conformance-00`
+- `hjs-spec/jep-api`
+
+## Status
+
+Experimental implementation seed.
+
+This CLI does not define new JEP-Core semantics and does not determine legal liability, factual truth, regulatory compliance, or complete-log availability.
+
+## Installation
+
+```bash
+pip install -e ".[dev]"
+```
+
+## Configuration
+
+Use flags:
+
+```bash
+jep --base-url http://127.0.0.1:8000 health
+```
+
+Or environment variables:
+
+```bash
+export JEP_API_URL=http://127.0.0.1:8000
+export JEP_API_KEY=
+```
+
+## Commands
+
+### Health
+
+```bash
+jep health
+```
+
+### Create a Judgment event
+
+```bash
+jep create \
+  --verb J \
+  --who did:example:agent-789 \
+  --what '{"claim":"approve","subject":"demo"}' \
+  --aud https://api.example.org
+```
+
+### Create with extensions
+
+```bash
+jep create \
+  --verb J \
+  --who did:example:agent-789 \
+  --what '{"claim":"approve"}' \
+  --ext 'https://example.org/profile={"name":"demo"}' \
+  --ext-crit https://example.org/profile
+```
+
+### Verify an event from a file
+
+```bash
+jep verify event.json --mode archival
+```
+
+### Pipe create response into verify
+
+```bash
+jep create --verb J --who did:example:agent --what '{"claim":"approve"}' > response.json
+jep extract-event response.json > event.json
+jep verify event.json
+```
+
+## Input Rules
+
+`--what` and event arguments may be:
+
+- inline JSON;
+- a plain string;
+- a file path;
+- `-` for stdin.
+
+## Related Repositories
+
+- JEP v0.6: https://github.com/hjs-spec/jep-v06
+- JEP API v0.6: https://github.com/hjs-spec/jep-api
+- JEP Python SDK v0.6: https://github.com/hjs-spec/jep-sdk-py
+- JEP Go SDK v0.6: https://github.com/hjs-spec/jep-sdk-go
+- HJS v0.5: https://github.com/hjs-spec/hjs-05
+- JAC v0.5: https://github.com/hjs-spec/jac-agent-02
+
+## Public Drafts
+
+- JEP-Core: https://datatracker.ietf.org/doc/draft-wang-jep-judgment-event-protocol/
+- JEP-Profiles: https://datatracker.ietf.org/doc/draft-wang-jep-profiles/
+- JEP-Conformance: https://datatracker.ietf.org/doc/draft-wang-jep-conformance/
+
+## License
+
+MIT
+
+## Runtime and verification notes
+
+See [HARDENING.md](HARDENING.md) for supported behavior, regression checks, and compatibility boundaries.

jep_cli-0.6.1/jep_cli/__init__.py

@@ -0,0 +1,3 @@
+"""JEP CLI v0.6."""
+
+__version__ = "0.6.0"

jep_cli-0.6.1/jep_cli/client.py

@@ -0,0 +1,61 @@
+"""Small HTTP client for JEP CLI v0.6."""
+
+from __future__ import annotations
+
+import json
+from typing import Any, Dict, Optional
+from urllib import request, error
+
+
+class JEPCLIError(Exception):
+    pass
+
+
+class JEPAPIError(JEPCLIError):
+    def __init__(self, status: int, message: str, payload: Optional[Dict[str, Any]] = None):
+        super().__init__(f"JEP API error ({status}): {message}")
+        self.status = status
+        self.message = message
+        self.payload = payload or {}
+
+
+class JEPClient:
+    def __init__(self, base_url: str = "http://127.0.0.1:8000", api_key: str = "", timeout: float = 30.0):
+        self.base_url = base_url.rstrip("/")
+        self.api_key = api_key
+        self.timeout = timeout
+
+    def create_event(self, payload: Dict[str, Any]) -> Dict[str, Any]:
+        return self._json("POST", "/events/create", payload)
+
+    def verify_event(self, payload: Dict[str, Any]) -> Dict[str, Any]:
+        return self._json("POST", "/events/verify", payload)
+
+    def health(self) -> Dict[str, Any]:
+        return self._json("GET", "/health", None)
+
+    def _json(self, method: str, path: str, payload: Optional[Dict[str, Any]]) -> Dict[str, Any]:
+        data = None
+        headers = {
+            "content-type": "application/json",
+            "user-agent": "JEP-CLI/0.6.0",
+        }
+        if self.api_key:
+            headers["authorization"] = f"Bearer {self.api_key}"
+            headers["x-api-key"] = self.api_key
+        if payload is not None:
+            data = json.dumps(payload).encode("utf-8")
+
+        req = request.Request(self.base_url + path, data=data, headers=headers, method=method)
+        try:
+            with request.urlopen(req, timeout=self.timeout) as resp:
+                body = resp.read().decode("utf-8")
+                return json.loads(body) if body else {}
+        except error.HTTPError as exc:
+            body = exc.read().decode("utf-8")
+            try:
+                parsed = json.loads(body)
+            except Exception:
+                parsed = {"message": body}
+            msg = parsed.get("message") or parsed.get("error") or body
+            raise JEPAPIError(exc.code, msg, parsed) from exc

jep_cli-0.6.1/jep_cli/main.py

@@ -0,0 +1,168 @@
+"""JEP CLI v0.6 command line interface."""
+
+from __future__ import annotations
+
+import argparse
+import json
+import os
+import sys
+from pathlib import Path
+from typing import Any, Dict
+
+from .client import JEPClient, JEPCLIError
+
+
+VALID_VERBS = {"J", "D", "T", "V"}
+
+
+def parse_json_value(value: str) -> Any:
+    if value == "-":
+        return json.load(sys.stdin)
+
+    path = Path(value)
+    if path.exists() and path.is_file():
+        return json.loads(path.read_text(encoding="utf-8"))
+
+    try:
+        return json.loads(value)
+    except json.JSONDecodeError:
+        return value
+
+
+def parse_ext_items(items: list[str]) -> Dict[str, Any]:
+    ext: Dict[str, Any] = {}
+    for item in items:
+        if "=" not in item:
+            raise ValueError(f"extension must be key=json_or_string, got: {item}")
+        key, raw = item.split("=", 1)
+        ext[key] = parse_json_value(raw)
+    return ext
+
+
+def print_json(data: Any) -> None:
+    print(json.dumps(data, indent=2, ensure_ascii=False))
+
+
+def build_client(args: argparse.Namespace) -> JEPClient:
+    base_url = args.base_url or os.environ.get("JEP_API_URL", "http://127.0.0.1:8000")
+    api_key = args.api_key or os.environ.get("JEP_API_KEY", "")
+    return JEPClient(base_url=base_url, api_key=api_key, timeout=args.timeout)
+
+
+def cmd_create(args: argparse.Namespace) -> int:
+    if args.verb not in VALID_VERBS:
+        raise ValueError("verb must be J, D, T, or V")
+
+    payload: Dict[str, Any] = {
+        "verb": args.verb,
+        "what": parse_json_value(args.what),
+    }
+    if args.who:
+        payload["who"] = args.who
+    if args.aud:
+        payload["aud"] = args.aud
+    if args.ref:
+        payload["ref"] = parse_json_value(args.ref)
+    if args.ttl_minutes is not None:
+        payload["ttl_minutes"] = args.ttl_minutes
+    if args.digest_only_who:
+        payload["digest_only_who"] = True
+    if args.ext:
+        payload["ext"] = parse_ext_items(args.ext)
+    if args.ext_crit:
+        payload["ext_crit"] = args.ext_crit
+
+    result = build_client(args).create_event(payload)
+    print_json(result)
+    return 0
+
+
+def cmd_verify(args: argparse.Namespace) -> int:
+    event = parse_json_value(args.event)
+    if not isinstance(event, dict):
+        raise ValueError("event must be JSON object or path to JSON event file")
+    payload = {
+        "event": event,
+        "mode": args.mode,
+        "consume_nonce": args.consume_nonce,
+    }
+    if args.expected_audience:
+        payload["expected_audience"] = args.expected_audience
+    if args.mode == "acceptance" and not args.expected_audience:
+        raise ValueError("acceptance mode requires --expected-audience")
+    result = build_client(args).verify_event(payload)
+    print_json(result)
+    return 0 if result.get("valid") is True else 2
+
+
+def cmd_health(args: argparse.Namespace) -> int:
+    result = build_client(args).health()
+    print_json(result)
+    return 0
+
+
+def cmd_extract_event(args: argparse.Namespace) -> int:
+    data = parse_json_value(args.response)
+    if not isinstance(data, dict) or "event" not in data:
+        raise ValueError("response must contain an event field")
+    print_json(data["event"])
+    return 0
+
+
+def build_parser() -> argparse.ArgumentParser:
+    parser = argparse.ArgumentParser(
+        prog="jep",
+        description="JEP CLI v0.6 for creating and verifying JEP-Core events through the JEP API.",
+    )
+    parser.add_argument("--base-url", default="", help="JEP API base URL. Default: JEP_API_URL or http://127.0.0.1:8000")
+    parser.add_argument("--api-key", default="", help="API key. Default: JEP_API_KEY")
+    parser.add_argument("--timeout", type=float, default=30.0, help="HTTP timeout in seconds")
+
+    sub = parser.add_subparsers(dest="command", required=True)
+
+    create = sub.add_parser("create", help="Create a JEP event")
+    create.add_argument("--verb", required=True, choices=sorted(VALID_VERBS), help="JEP verb: J, D, T, or V")
+    create.add_argument("--who", default="", help="Actor identifier")
+    create.add_argument("--what", required=True, help="JSON value, string, file path, or '-' for stdin")
+    create.add_argument("--aud", default="", help="Audience / validation context")
+    create.add_argument("--ref", default="", help="Reference event hash")
+    create.add_argument("--ttl-minutes", type=int, default=None, help="Optional TTL extension in minutes")
+    create.add_argument("--digest-only-who", action="store_true", help="Request digest-only privacy extension")
+    create.add_argument("--ext", action="append", default=[], help="Extension key=json_or_string. May be repeated")
+    create.add_argument("--ext-crit", action="append", default=[], help="Critical extension URI. May be repeated")
+    create.set_defaults(func=cmd_create)
+
+    verify = sub.add_parser("verify", help="Verify a JEP event")
+    verify.add_argument("event", help="Event JSON object, event JSON file path, or '-' for stdin")
+    verify.add_argument("--mode", default="archival", choices=["archival", "acceptance"], help="Validation mode")
+    verify.add_argument("--expected-audience", default="", help="Required receiving audience for acceptance")
+    verify.add_argument("--consume-nonce", action="store_true", help="Ask verifier to consume nonce")
+    verify.set_defaults(func=cmd_verify)
+
+    health = sub.add_parser("health", help="Check JEP API health")
+    health.set_defaults(func=cmd_health)
+
+    extract = sub.add_parser("extract-event", help="Extract event object from /events/create response")
+    extract.add_argument("response", help="Response JSON object, response JSON file path, or '-' for stdin")
+    extract.set_defaults(func=cmd_extract_event)
+
+    return parser
+
+
+def main(argv: list[str] | None = None) -> int:
+    parser = build_parser()
+    try:
+        args = parser.parse_args(argv)
+        return int(args.func(args) or 0)
+    except SystemExit as exc:
+        # Allows tests and embedded callers to receive an exit code instead of
+        # terminating the Python process. The console entry point still exits
+        # via the __main__ block below.
+        return int(exc.code or 0)
+    except (JEPCLIError, ValueError, OSError, json.JSONDecodeError) as exc:
+        print(f"jep: error: {exc}", file=sys.stderr)
+        return 1
+
+
+if __name__ == "__main__":
+    raise SystemExit(main())

jep_cli-0.6.1/jep_cli.egg-info/PKG-INFO

@@ -0,0 +1,141 @@
+Metadata-Version: 2.4
+Name: jep-cli
+Version: 0.6.1
+Summary: Command-line tool for creating and verifying JEP v0.6 events through the JEP API
+Author-email: HJS Spec <signal@humanjudgment.org>
+License: MIT
+Project-URL: Homepage, https://github.com/hjs-spec/cli
+Project-URL: Repository, https://github.com/hjs-spec/cli
+Project-URL: Issues, https://github.com/hjs-spec/cli/issues
+Classifier: Development Status :: 3 - Alpha
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: Python :: 3
+Requires-Python: >=3.9
+Description-Content-Type: text/markdown
+License-File: LICENSE
+License-File: NOTICE.md
+Provides-Extra: dev
+Requires-Dist: pytest>=7.0.0; extra == "dev"
+Dynamic: license-file
+
+# JEP CLI v0.6
+
+Command-line tool for creating and verifying JEP v0.6 events through the JEP API.
+
+This CLI targets:
+
+```text
+POST /events/create
+POST /events/verify
+GET  /health
+```
+
+It is aligned with:
+
+- `draft-wang-jep-judgment-event-protocol-06`
+- `draft-wang-jep-profiles-00`
+- `draft-wang-jep-conformance-00`
+- `hjs-spec/jep-api`
+
+## Status
+
+Experimental implementation seed.
+
+This CLI does not define new JEP-Core semantics and does not determine legal liability, factual truth, regulatory compliance, or complete-log availability.
+
+## Installation
+
+```bash
+pip install -e ".[dev]"
+```
+
+## Configuration
+
+Use flags:
+
+```bash
+jep --base-url http://127.0.0.1:8000 health
+```
+
+Or environment variables:
+
+```bash
+export JEP_API_URL=http://127.0.0.1:8000
+export JEP_API_KEY=
+```
+
+## Commands
+
+### Health
+
+```bash
+jep health
+```
+
+### Create a Judgment event
+
+```bash
+jep create \
+  --verb J \
+  --who did:example:agent-789 \
+  --what '{"claim":"approve","subject":"demo"}' \
+  --aud https://api.example.org
+```
+
+### Create with extensions
+
+```bash
+jep create \
+  --verb J \
+  --who did:example:agent-789 \
+  --what '{"claim":"approve"}' \
+  --ext 'https://example.org/profile={"name":"demo"}' \
+  --ext-crit https://example.org/profile
+```
+
+### Verify an event from a file
+
+```bash
+jep verify event.json --mode archival
+```
+
+### Pipe create response into verify
+
+```bash
+jep create --verb J --who did:example:agent --what '{"claim":"approve"}' > response.json
+jep extract-event response.json > event.json
+jep verify event.json
+```
+
+## Input Rules
+
+`--what` and event arguments may be:
+
+- inline JSON;
+- a plain string;
+- a file path;
+- `-` for stdin.
+
+## Related Repositories
+
+- JEP v0.6: https://github.com/hjs-spec/jep-v06
+- JEP API v0.6: https://github.com/hjs-spec/jep-api
+- JEP Python SDK v0.6: https://github.com/hjs-spec/jep-sdk-py
+- JEP Go SDK v0.6: https://github.com/hjs-spec/jep-sdk-go
+- HJS v0.5: https://github.com/hjs-spec/hjs-05
+- JAC v0.5: https://github.com/hjs-spec/jac-agent-02
+
+## Public Drafts
+
+- JEP-Core: https://datatracker.ietf.org/doc/draft-wang-jep-judgment-event-protocol/
+- JEP-Profiles: https://datatracker.ietf.org/doc/draft-wang-jep-profiles/
+- JEP-Conformance: https://datatracker.ietf.org/doc/draft-wang-jep-conformance/
+
+## License
+
+MIT
+
+## Runtime and verification notes
+
+See [HARDENING.md](HARDENING.md) for supported behavior, regression checks, and compatibility boundaries.

jep_cli-0.6.1/jep_cli.egg-info/SOURCES.txt

@@ -0,0 +1,15 @@
+LICENSE
+NOTICE.md
+README.md
+pyproject.toml
+jep_cli/__init__.py
+jep_cli/client.py
+jep_cli/main.py
+jep_cli.egg-info/PKG-INFO
+jep_cli.egg-info/SOURCES.txt
+jep_cli.egg-info/dependency_links.txt
+jep_cli.egg-info/entry_points.txt
+jep_cli.egg-info/requires.txt
+jep_cli.egg-info/top_level.txt
+tests/test_acceptance.py
+tests/test_cli.py

jep_cli-0.6.1/jep_cli.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

jep_cli-0.6.1/jep_cli.egg-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+jep = jep_cli.main:main

jep_cli-0.6.1/jep_cli.egg-info/requires.txt

@@ -0,0 +1,3 @@
+
+[dev]
+pytest>=7.0.0

jep_cli-0.6.1/jep_cli.egg-info/top_level.txt

@@ -0,0 +1 @@
+jep_cli

jep_cli-0.6.1/pyproject.toml

@@ -0,0 +1,37 @@
+[build-system]
+requires = ["setuptools>=61.0", "wheel"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "jep-cli"
+version = "0.6.1"
+description = "Command-line tool for creating and verifying JEP v0.6 events through the JEP API"
+readme = "README.md"
+license = { text = "MIT" }
+authors = [
+    { name = "HJS Spec", email = "signal@humanjudgment.org" }
+]
+requires-python = ">=3.9"
+dependencies = []
+classifiers = [
+    "Development Status :: 3 - Alpha",
+    "Intended Audience :: Developers",
+    "License :: OSI Approved :: MIT License",
+    "Programming Language :: Python :: 3",
+]
+
+[project.optional-dependencies]
+dev = [
+    "pytest>=7.0.0",
+]
+
+[project.scripts]
+jep = "jep_cli.main:main"
+
+[project.urls]
+Homepage = "https://github.com/hjs-spec/cli"
+Repository = "https://github.com/hjs-spec/cli"
+Issues = "https://github.com/hjs-spec/cli/issues"
+
+[tool.setuptools.packages.find]
+include = ["jep_cli*"]

jep_cli-0.6.1/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+

jep_cli-0.6.1/tests/test_acceptance.py

@@ -0,0 +1,16 @@
+import json
+from jep_cli import main as module
+
+
+def test_acceptance_requires_expected_audience(capsys):
+    assert module.main(["verify", '{"jep":"1"}', "--mode", "acceptance"]) == 1
+    assert "expected-audience" in capsys.readouterr().err
+
+
+def test_verification_failure_returns_nonzero(monkeypatch):
+    class Client:
+        def verify_event(self, payload):
+            assert payload["expected_audience"] == "receiver"
+            return {"valid": False}
+    monkeypatch.setattr(module, "build_client", lambda args: Client())
+    assert module.main(["verify", '{}', "--mode", "acceptance", "--expected-audience", "receiver"]) == 2

jep_cli-0.6.1/tests/test_cli.py

@@ -0,0 +1,154 @@
+"""Tests for JEP CLI v0.6."""
+
+import json
+import threading
+from http.server import BaseHTTPRequestHandler, HTTPServer
+
+import pytest
+
+from jep_cli.main import main, parse_json_value, parse_ext_items
+
+
+class Handler(BaseHTTPRequestHandler):
+    def _json(self, status, payload):
+        body = json.dumps(payload).encode()
+        self.send_response(status)
+        self.send_header("content-type", "application/json")
+        self.send_header("content-length", str(len(body)))
+        self.end_headers()
+        self.wfile.write(body)
+
+    def do_GET(self):
+        if self.path == "/health":
+            self._json(200, {"ok": True, "profile": "jep-core-0.6"})
+        else:
+            self._json(404, {"message": "not found"})
+
+    def do_POST(self):
+        length = int(self.headers.get("content-length", "0"))
+        payload = json.loads(self.rfile.read(length) or b"{}")
+        if self.path == "/events/create":
+            event = {
+                "jep": "1",
+                "verb": payload["verb"],
+                "who": payload.get("who", "did:example:agent"),
+                "when": 1234567890,
+                "what": payload.get("what"),
+                "nonce": "nonce-1",
+                "aud": payload.get("aud"),
+                "ref": payload.get("ref"),
+                "ext": payload.get("ext"),
+                "ext_crit": payload.get("ext_crit"),
+                "sig": "header..sig",
+            }
+            self._json(200, {
+                "event": event,
+                "event_hash": "sha256:abc",
+                "validation": {
+                    "valid": True,
+                    "level": 1,
+                    "mode": "archival",
+                    "profile": "jep-core-0.6",
+                    "event_hash": "sha256:abc",
+                    "warnings": [],
+                    "errors": [],
+                }
+            })
+            return
+        if self.path == "/events/verify":
+            self._json(200, {
+                "valid": True,
+                "level": 1,
+                "mode": payload.get("mode", "archival"),
+                "profile": "jep-core-0.6",
+                "event_hash": "sha256:def",
+                "warnings": [],
+                "errors": [],
+            })
+            return
+        self._json(404, {"message": "not found"})
+
+    def log_message(self, *args):
+        pass
+
+
+@pytest.fixture()
+def api_server():
+    server = HTTPServer(("127.0.0.1", 0), Handler)
+    thread = threading.Thread(target=server.serve_forever, daemon=True)
+    thread.start()
+    try:
+        yield f"http://127.0.0.1:{server.server_port}"
+    finally:
+        server.shutdown()
+        thread.join()
+
+
+def test_parse_json_value_string_and_json(tmp_path):
+    assert parse_json_value('{"a":1}') == {"a": 1}
+    assert parse_json_value("plain") == "plain"
+    f = tmp_path / "data.json"
+    f.write_text('{"b":2}')
+    assert parse_json_value(str(f)) == {"b": 2}
+
+
+def test_parse_ext_items():
+    ext = parse_ext_items(['https://example.org/x={"a":1}', 'https://example.org/y=plain'])
+    assert ext["https://example.org/x"] == {"a": 1}
+    assert ext["https://example.org/y"] == "plain"
+
+
+def test_health(api_server, capsys):
+    code = main(["--base-url", api_server, "health"])
+    out = capsys.readouterr().out
+    assert code == 0
+    assert '"ok": true' in out
+
+
+def test_create(api_server, capsys):
+    code = main([
+        "--base-url", api_server,
+        "create",
+        "--verb", "J",
+        "--who", "did:example:agent",
+        "--what", '{"claim":"approve"}',
+        "--ext", 'https://example.org/profile={"name":"demo"}',
+        "--ext-crit", "https://example.org/profile",
+    ])
+    out = json.loads(capsys.readouterr().out)
+    assert code == 0
+    assert out["event_hash"] == "sha256:abc"
+    assert out["event"]["verb"] == "J"
+    assert out["event"]["ext"]["https://example.org/profile"]["name"] == "demo"
+
+
+def test_verify(api_server, capsys, tmp_path):
+    event = {
+        "jep": "1",
+        "verb": "J",
+        "who": "did:example:agent",
+        "when": 123,
+        "what": "sha256:abc",
+        "nonce": "nonce-1",
+        "sig": "header..sig",
+    }
+    p = tmp_path / "event.json"
+    p.write_text(json.dumps(event))
+    code = main(["--base-url", api_server, "verify", str(p)])
+    out = json.loads(capsys.readouterr().out)
+    assert code == 0
+    assert out["valid"] is True
+
+
+def test_extract_event(capsys, tmp_path):
+    p = tmp_path / "response.json"
+    p.write_text(json.dumps({"event": {"jep": "1", "verb": "J"}}))
+    code = main(["extract-event", str(p)])
+    out = json.loads(capsys.readouterr().out)
+    assert code == 0
+    assert out["verb"] == "J"
+
+
+def test_invalid_verb(capsys):
+    code = main(["create", "--verb", "X", "--what", "x"])
+    assert code != 0