@smilintux/skcapstone 0.1.0 → 0.2.3

package/src/skcapstone/cli/test_cmd.py

@@ -0,0 +1,234 @@
+"""Test runner command — unified pytest across all ecosystem packages.
+
+Usage:
+    skcapstone test                     # run all packages
+    skcapstone test --package skcomm   # run one package
+    skcapstone test --fast              # stop on first failure
+    skcapstone test --json-out          # machine-readable JSON output
+    skcapstone test --verbose           # pass -v to pytest
+"""
+
+from __future__ import annotations
+
+import json
+import sys
+from pathlib import Path
+
+import click
+
+from ._common import console
+from ..testrunner import ECOSYSTEM_PACKAGES, run_all_tests, TestReport, PackageResult
+
+
+def _monorepo_root() -> Path:
+    """Locate the monorepo root (parent of the skcapstone package dir).
+
+    Walks up from this file until we find a directory that contains
+    the skcapstone sub-package, then returns its parent.
+
+    Returns:
+        Path to the monorepo root.
+    """
+    # src/skcapstone/cli/test_cmd.py → go up 4 levels
+    candidate = Path(__file__).resolve().parent.parent.parent.parent.parent
+    # candidate is now smilintux-org/skcapstone/src → go one more up to skcapstone pkg root,
+    # then one more up to monorepo root
+    # Path layout: monorepo/skcapstone/src/skcapstone/cli/test_cmd.py
+    # parents[0] = cli/, [1] = skcapstone (pkg), [2] = src/, [3] = skcapstone (repo), [4] = monorepo
+    monorepo = Path(__file__).resolve().parents[4]
+    if (monorepo / "skcapstone").is_dir():
+        return monorepo
+    # Fallback: cwd
+    return Path.cwd()
+
+
+def _render_table(report: TestReport) -> None:
+    """Print a Rich table summarising per-package results.
+
+    Args:
+        report: Completed test report.
+    """
+    from rich.table import Table
+    from rich.panel import Panel
+
+    table = Table(title="Ecosystem Test Results", show_lines=False, expand=True)
+    table.add_column("Package", style="bold", min_width=16)
+    table.add_column("Status", min_width=10)
+    table.add_column("Passed", justify="right", min_width=7)
+    table.add_column("Failed", justify="right", min_width=7)
+    table.add_column("Errors", justify="right", min_width=7)
+    table.add_column("Skipped", justify="right", min_width=7)
+    table.add_column("Duration", justify="right", min_width=9)
+
+    for r in report.results:
+        if not r.available:
+            table.add_row(
+                r.name,
+                "[dim]N/A[/]",
+                "-", "-", "-", "-",
+                "[dim]—[/]",
+            )
+            continue
+
+        if r.success:
+            status = "[bold green]PASS[/]"
+        else:
+            status = "[bold red]FAIL[/]"
+
+        failed_str = f"[red]{r.failed}[/]" if r.failed else "0"
+        errors_str = f"[red]{r.errors}[/]" if r.errors else "0"
+        skipped_str = f"[yellow]{r.skipped}[/]" if r.skipped else "0"
+
+        table.add_row(
+            r.name,
+            status,
+            str(r.passed),
+            failed_str,
+            errors_str,
+            skipped_str,
+            f"{r.duration_s:.1f}s",
+        )
+
+    console.print()
+    console.print(table)
+
+    # Footer summary
+    total_pass = report.total_passed
+    total_fail = report.total_failed
+    total_err = report.total_errors
+    pkgs_tested = report.packages_tested
+    overall_duration = f"{report.duration_s:.1f}s"
+
+    if report.all_passed:
+        summary_color = "green"
+        verdict = "ALL PASSED"
+    else:
+        summary_color = "red"
+        verdict = "FAILURES DETECTED"
+
+    console.print(
+        Panel(
+            f"[bold {summary_color}]{verdict}[/]  "
+            f"[green]{total_pass} passed[/]  "
+            + (f"[red]{total_fail} failed[/]  " if total_fail else "")
+            + (f"[red]{total_err} errors[/]  " if total_err else "")
+            + f"across {pkgs_tested} package(s)  "
+            f"in {overall_duration}",
+            border_style=summary_color,
+            expand=False,
+        )
+    )
+    console.print()
+
+
+def _render_failures(report: TestReport) -> None:
+    """Print abbreviated pytest output for any failed package.
+
+    Args:
+        report: Completed test report.
+    """
+    for r in report.results:
+        if r.available and not r.success and r.output.strip():
+            console.print(f"\n[bold red]── {r.name} output ──[/]\n")
+            console.print(r.output)
+
+
+def register_test_commands(main: click.Group) -> None:
+    """Register the `skcapstone test` command.
+
+    Args:
+        main: Root Click group.
+    """
+
+    @main.command("test")
+    @click.option(
+        "--package", "-p",
+        "packages",
+        multiple=True,
+        metavar="NAME",
+        help="Restrict to one or more packages (repeat for multiple).",
+    )
+    @click.option(
+        "--fast", is_flag=True,
+        help="Stop after the first failing package.",
+    )
+    @click.option(
+        "--verbose", "-v", is_flag=True,
+        help="Pass -v to pytest for detailed output.",
+    )
+    @click.option(
+        "--json-out", is_flag=True,
+        help="Emit machine-readable JSON instead of a Rich table.",
+    )
+    @click.option(
+        "--timeout", default=120, show_default=True, type=int,
+        help="Per-package timeout in seconds.",
+    )
+    @click.option(
+        "--root", default=None, type=click.Path(),
+        help="Override monorepo root path (auto-detected by default).",
+    )
+    @click.option(
+        "--show-output", is_flag=True,
+        help="Print pytest output for failing packages.",
+    )
+    def test_cmd(
+        packages: tuple[str, ...],
+        fast: bool,
+        verbose: bool,
+        json_out: bool,
+        timeout: int,
+        root: str | None,
+        show_output: bool,
+    ) -> None:
+        """Run pytest across all ecosystem packages and show a summary table.
+
+        Discovers packages in the monorepo (skcapstone, capauth, skcomm,
+        skchat, skmemory, cloud9-python) and runs their test suites in
+        sequence, then renders a consolidated Rich table.
+
+        \b
+        Examples:
+            skcapstone test
+            skcapstone test --package skcomm
+            skcapstone test -p skcomm -p skchat
+            skcapstone test --fast --verbose
+            skcapstone test --json-out | jq .
+        """
+        monorepo = Path(root).expanduser() if root else _monorepo_root()
+
+        pkg_filter = list(packages) if packages else None
+
+        valid_names = {p["name"] for p in ECOSYSTEM_PACKAGES}
+        if pkg_filter:
+            invalid = [n for n in pkg_filter if n not in valid_names]
+            if invalid:
+                console.print(
+                    f"[red]Unknown package(s): {', '.join(invalid)}[/]\n"
+                    f"Valid: {', '.join(sorted(valid_names))}"
+                )
+                sys.exit(1)
+
+        if not json_out:
+            names_str = ", ".join(pkg_filter) if pkg_filter else "all packages"
+            console.print(f"\n  [cyan]Running tests for:[/] {names_str}")
+            console.print(f"  [dim]Monorepo root: {monorepo}[/]\n")
+
+        report = run_all_tests(
+            monorepo_root=monorepo,
+            packages=pkg_filter,
+            fail_fast=fast,
+            verbose=verbose,
+            timeout=timeout,
+        )
+
+        if json_out:
+            click.echo(json.dumps(report.to_dict(), indent=2))
+            sys.exit(0 if report.all_passed else 1)
+
+        _render_table(report)
+
+        if show_output:
+            _render_failures(report)
+
+        sys.exit(0 if report.all_passed else 1)

package/src/skcapstone/cli/test_connection.py

@@ -0,0 +1,253 @@
+"""test-connection command — ping a peer via SKComm and measure latency.
+
+Usage:
+    skcapstone test-connection <peer>
+    skcapstone test-connection <peer> --timeout 5
+    skcapstone test-connection <peer> --count 3
+"""
+
+from __future__ import annotations
+
+import json
+import time
+import uuid
+from pathlib import Path
+
+import click
+
+from ._common import AGENT_HOME, console
+from ..chat import AgentChat
+
+
+# Payload type markers
+_PING_KEY = "skchat_ping"
+_PONG_KEY = "skchat_pong"
+
+
+def _make_ping_payload(nonce: str, sender: str) -> str:
+    """Serialize a ping message.
+
+    Args:
+        nonce: Unique identifier for this ping/pong round-trip.
+        sender: Sending agent name.
+
+    Returns:
+        str: JSON payload string.
+    """
+    return json.dumps({_PING_KEY: True, "nonce": nonce, "sender": sender})
+
+
+def _is_pong_for(payload: str, nonce: str) -> bool:
+    """Return True if *payload* is a pong matching *nonce*.
+
+    Args:
+        payload: Raw message content string.
+        nonce: The nonce sent in the corresponding ping.
+
+    Returns:
+        bool: True when the payload is a valid matching pong.
+    """
+    try:
+        data = json.loads(payload)
+        return bool(data.get(_PONG_KEY)) and data.get("nonce") == nonce
+    except (json.JSONDecodeError, TypeError, AttributeError):
+        return False
+
+
+def _is_ping(payload: str) -> tuple[bool, str, str]:
+    """Parse an incoming ping payload.
+
+    Args:
+        payload: Raw message content string.
+
+    Returns:
+        tuple: (is_ping, nonce, sender) — nonce/sender are empty strings
+        when the payload is not a ping.
+    """
+    try:
+        data = json.loads(payload)
+        if data.get(_PING_KEY):
+            return True, data.get("nonce", ""), data.get("sender", "")
+    except (json.JSONDecodeError, TypeError, AttributeError):
+        pass
+    return False, "", ""
+
+
+def _make_pong_payload(nonce: str, sender: str) -> str:
+    """Serialize a pong reply.
+
+    Args:
+        nonce: The nonce received from the ping.
+        sender: Replying agent name.
+
+    Returns:
+        str: JSON payload string.
+    """
+    return json.dumps({_PONG_KEY: True, "nonce": nonce, "sender": sender})
+
+
+def ping_peer(
+    peer: str,
+    home: Path,
+    identity: str,
+    timeout: float = 10.0,
+) -> dict:
+    """Send a ping to *peer* and wait for a matching pong.
+
+    Sends a structured ping message via AgentChat and polls the inbox
+    for a pong response with a matching nonce. Times out after *timeout*
+    seconds.
+
+    Args:
+        peer: Peer agent name or identity.
+        home: Agent home directory.
+        identity: Local agent name used as sender.
+        timeout: Maximum seconds to wait for a pong.
+
+    Returns:
+        dict with keys:
+            - ``reachable`` (bool): True if pong was received in time.
+            - ``latency_ms`` (float | None): Round-trip time in milliseconds,
+              or None on timeout.
+            - ``transport`` (str | None): Transport that delivered the ping.
+            - ``error`` (str | None): Error message, if any.
+    """
+    result: dict = {
+        "reachable": False,
+        "latency_ms": None,
+        "transport": None,
+        "error": None,
+    }
+
+    nonce = str(uuid.uuid4())
+    agent_chat = AgentChat(home=home, identity=identity)
+
+    # Send the ping
+    t0 = time.monotonic()
+    send_result = agent_chat.send(peer, _make_ping_payload(nonce, identity))
+
+    if not send_result.get("delivered") and not send_result.get("stored"):
+        result["error"] = send_result.get("error") or "send failed (no transport)"
+        return result
+
+    result["transport"] = send_result.get("transport")
+
+    # If we only stored locally (no live transport), report accordingly
+    if not send_result.get("delivered"):
+        result["error"] = "ping stored locally — no live transport available"
+        return result
+
+    # Poll for pong
+    deadline = t0 + timeout
+    poll_interval = 0.25  # seconds
+
+    while time.monotonic() < deadline:
+        messages = agent_chat.receive(limit=20)
+        for msg in messages:
+            content = msg.get("content", "")
+            sender_name = msg.get("sender", "")
+            if sender_name == peer and _is_pong_for(content, nonce):
+                elapsed_ms = (time.monotonic() - t0) * 1000.0
+                result["reachable"] = True
+                result["latency_ms"] = round(elapsed_ms, 2)
+                return result
+        time.sleep(poll_interval)
+
+    result["error"] = f"timeout after {timeout:.0f}s — no pong received"
+    return result
+
+
+def register_test_connection_commands(main: click.Group) -> None:
+    """Register the test-connection command on *main*."""
+
+    @main.command("test-connection")
+    @click.argument("peer")
+    @click.option(
+        "--timeout", "-t",
+        default=10.0,
+        show_default=True,
+        help="Seconds to wait for a pong response.",
+    )
+    @click.option(
+        "--count", "-c",
+        default=1,
+        show_default=True,
+        help="Number of pings to send (reports min/avg/max when > 1).",
+    )
+    @click.option("--home", default=AGENT_HOME, type=click.Path())
+    def test_connection(peer: str, timeout: float, count: int, home: str) -> None:
+        """Test connectivity to a peer by sending a ping via SKComm.
+
+        Sends a ping message, waits for the peer to reply with a pong,
+        and reports the round-trip latency. Exits with code 1 when the
+        peer is unreachable.
+
+        \b
+        Examples:
+          skcapstone test-connection lumina
+          skcapstone test-connection opus --timeout 5
+          skcapstone test-connection jarvis --count 3
+        """
+        from ..runtime import get_runtime
+
+        home_path = Path(home).expanduser()
+        try:
+            runtime = get_runtime(home_path)
+            identity = runtime.manifest.name or "unknown"
+        except Exception:
+            identity = "unknown"
+
+        console.print()
+        console.print(
+            f"  PING [cyan]{peer}[/]  (timeout={timeout:.0f}s, count={count})"
+        )
+        console.print()
+
+        latencies: list[float] = []
+        last_error: str | None = None
+        last_transport: str | None = None
+
+        for i in range(count):
+            result = ping_peer(peer, home_path, identity, timeout=timeout)
+            last_transport = result.get("transport") or last_transport
+
+            if result["reachable"]:
+                ms = result["latency_ms"]
+                latencies.append(ms)
+                console.print(
+                    f"  [{i + 1}/{count}]  [green]pong from {peer}[/]  "
+                    f"latency=[bold]{ms:.1f} ms[/]"
+                )
+            else:
+                last_error = result.get("error") or "unreachable"
+                console.print(
+                    f"  [{i + 1}/{count}]  [red]no pong[/]  {last_error}"
+                )
+
+        console.print()
+
+        if latencies:
+            if count > 1:
+                lo = min(latencies)
+                hi = max(latencies)
+                avg = sum(latencies) / len(latencies)
+                console.print(
+                    f"  [bold green]REACHABLE[/]  "
+                    f"min={lo:.1f}ms  avg={avg:.1f}ms  max={hi:.1f}ms  "
+                    f"({len(latencies)}/{count} received)"
+                )
+            else:
+                console.print(
+                    f"  [bold green]REACHABLE[/]  "
+                    f"latency={latencies[0]:.1f} ms"
+                )
+            if last_transport:
+                console.print(f"  transport: [dim]{last_transport}[/]")
+        else:
+            console.print(
+                f"  [bold red]UNREACHABLE[/]  {last_error or 'no pong received'}"
+            )
+            console.print()
+            raise SystemExit(1)
+
+        console.print()

package/src/skcapstone/cli/token.py

@@ -0,0 +1,207 @@
+"""Capability token commands: issue, list, verify, revoke, export."""
+
+from __future__ import annotations
+
+import sys
+from pathlib import Path
+
+import click
+
+from ._common import AGENT_HOME, console
+from ._validators import validate_agent_name, validate_task_id
+from ..pillars.security import audit_event
+
+from rich.table import Table
+
+
+def register_token_commands(main: click.Group) -> None:
+    """Register the token command group."""
+
+    @main.group()
+    def token():
+        """Manage capability tokens.
+
+        Issue, verify, list, and revoke PGP-signed capability
+        tokens for fine-grained agent authorization.
+        """
+
+    @token.command("issue")
+    @click.option("--home", default=AGENT_HOME, type=click.Path())
+    @click.option("--subject", required=True, help="Who the token is for.")
+    @click.option("--cap", multiple=True, required=True, help="Capabilities to grant.")
+    @click.option("--ttl", default=24, help="Hours until expiry (0 = no expiry).")
+    @click.option("--type", "token_type", default="capability", help="Token type.")
+    @click.option("--no-sign", is_flag=True, help="Skip PGP signing.")
+    def token_issue(home, subject, cap, ttl, token_type, no_sign):
+        """Issue a new capability token."""
+        from ..tokens import TokenType, issue_token
+
+        validate_agent_name(subject)
+
+        home_path = Path(home).expanduser()
+        if not home_path.exists():
+            console.print("[bold red]No agent found.[/] Run skcapstone init first.")
+            sys.exit(1)
+
+        try:
+            tt = TokenType(token_type)
+        except ValueError:
+            console.print(f"[red]Invalid token type:[/] {token_type}")
+            sys.exit(1)
+
+        ttl_hours = ttl if ttl > 0 else None
+        capabilities = list(cap)
+
+        console.print(f"\n  Issuing [cyan]{tt.value}[/] token for [bold]{subject}[/]...")
+        signed = issue_token(
+            home=home_path, subject=subject, capabilities=capabilities,
+            token_type=tt, ttl_hours=ttl_hours, sign=not no_sign,
+        )
+
+        console.print(f"  [green]Token issued:[/] {signed.payload.token_id[:16]}...")
+        console.print(f"  Capabilities: {', '.join(capabilities)}")
+        if signed.payload.expires_at:
+            console.print(f"  Expires: {signed.payload.expires_at.isoformat()}")
+        else:
+            console.print("  Expires: [yellow]never[/]")
+        if signed.signature:
+            console.print("  [green]PGP signed[/]")
+        else:
+            console.print("  [yellow]Unsigned[/]")
+
+        audit_event(home_path, "TOKEN_ISSUE", f"Token {signed.payload.token_id[:16]} for {subject}")
+        console.print()
+
+    @token.command("list")
+    @click.option("--home", default=AGENT_HOME, type=click.Path())
+    def token_list(home):
+        """List all issued tokens."""
+        from ..tokens import is_revoked, list_tokens
+
+        home_path = Path(home).expanduser()
+        if not home_path.exists():
+            console.print("[bold red]No agent found.[/]")
+            sys.exit(1)
+
+        tokens = list_tokens(home_path)
+        if not tokens:
+            console.print("\n  [dim]No tokens issued yet.[/]\n")
+            return
+
+        table = Table(title="Capability Tokens", show_lines=True)
+        table.add_column("ID", style="cyan", max_width=16)
+        table.add_column("Type", style="bold")
+        table.add_column("Subject")
+        table.add_column("Capabilities")
+        table.add_column("Status")
+        table.add_column("Expires")
+
+        for t in tokens:
+            p = t.payload
+            revoked = is_revoked(home_path, p.token_id)
+            if revoked:
+                st = "[red]REVOKED[/]"
+            elif p.is_expired:
+                st = "[yellow]EXPIRED[/]"
+            elif t.signature:
+                st = "[green]SIGNED[/]"
+            else:
+                st = "[dim]UNSIGNED[/]"
+
+            exp_str = p.expires_at.strftime("%m/%d %H:%M") if p.expires_at else "never"
+            table.add_row(p.token_id[:16], p.token_type.value, p.subject,
+                          ", ".join(p.capabilities), st, exp_str)
+
+        console.print()
+        console.print(table)
+        console.print()
+
+    @token.command("verify")
+    @click.argument("token_id")
+    @click.option("--home", default=AGENT_HOME, type=click.Path())
+    def token_verify(token_id, home):
+        """Verify a token's signature and validity."""
+        from ..tokens import is_revoked, list_tokens, verify_token
+
+        validate_task_id(token_id)  # token IDs are hex UUIDs
+
+        home_path = Path(home).expanduser()
+        tokens = list_tokens(home_path)
+
+        target = None
+        for t in tokens:
+            if t.payload.token_id.startswith(token_id):
+                target = t
+                break
+
+        if not target:
+            console.print(f"[red]Token not found:[/] {token_id}")
+            sys.exit(1)
+
+        if is_revoked(home_path, target.payload.token_id):
+            console.print(f"\n  [red]REVOKED[/] Token {token_id[:16]} has been revoked.\n")
+            sys.exit(1)
+
+        valid = verify_token(target, home_path)
+        if valid:
+            console.print(f"\n  [green]VALID[/] Token {token_id[:16]}")
+            console.print(f"  Subject: {target.payload.subject}")
+            console.print(f"  Capabilities: {', '.join(target.payload.capabilities)}")
+        else:
+            console.print(f"\n  [red]INVALID[/] Token {token_id[:16]}")
+            if target.payload.is_expired:
+                console.print("  Reason: expired")
+            else:
+                console.print("  Reason: signature verification failed")
+        console.print()
+
+    @token.command("revoke")
+    @click.argument("token_id")
+    @click.option("--home", default=AGENT_HOME, type=click.Path())
+    def token_revoke(token_id, home):
+        """Revoke a previously issued token."""
+        from ..tokens import list_tokens, revoke_token
+
+        validate_task_id(token_id)  # token IDs are hex UUIDs
+
+        home_path = Path(home).expanduser()
+        tokens = list_tokens(home_path)
+
+        full_id = None
+        for t in tokens:
+            if t.payload.token_id.startswith(token_id):
+                full_id = t.payload.token_id
+                break
+
+        if not full_id:
+            console.print(f"[red]Token not found:[/] {token_id}")
+            sys.exit(1)
+
+        revoke_token(home_path, full_id)
+        console.print(f"\n  [red]REVOKED[/] Token {token_id[:16]}...")
+        audit_event(home_path, "TOKEN_REVOKE", f"Token {token_id[:16]} revoked")
+        console.print()
+
+    @token.command("export")
+    @click.argument("token_id")
+    @click.option("--home", default=AGENT_HOME, type=click.Path())
+    def token_export(token_id, home):
+        """Export a token as portable JSON."""
+        from ..tokens import export_token, list_tokens
+
+        validate_task_id(token_id)  # token IDs are hex UUIDs
+
+        home_path = Path(home).expanduser()
+        tokens = list_tokens(home_path)
+
+        target = None
+        for t in tokens:
+            if t.payload.token_id.startswith(token_id):
+                target = t
+                break
+
+        if not target:
+            console.print(f"[red]Token not found:[/] {token_id}")
+            sys.exit(1)
+
+        console.print(export_token(target))