agentnode-sdk 0.22.0__tar.gz → 0.23.0__tar.gz

{agentnode_sdk-0.22.0 → agentnode_sdk-0.23.0}/CHANGELOG.md

@@ -1,5 +1,25 @@
 # Changelog
 
+## 0.23.0 — Prove MCP package ownership from the terminal
+
+### Added
+
+- `agentnode mcp ownership challenge --registry npm|pypi <package>` issues a
+  one-time challenge: the server returns a token and a keyword
+  (`agentnode-ownership-<token>`). Add the keyword to your package's metadata
+  and publish a new version — only someone with publish rights can do that. The
+  token is shown once and is stored server-side only as a hash; it is never
+  written to local config.
+- `agentnode mcp ownership verify --registry npm|pypi <package>` checks the
+  latest published version for the keyword and, on a match, records strong
+  ownership evidence. It reports `verified` / `pending` / expired / no-challenge
+  / package-not-found / registry-unavailable clearly, and exits non-zero until
+  ownership is verified (CI-gateable).
+
+Verifying ownership does **not** publish anything: MCP listings still remain
+review-gated until the sandbox-smoke gate is built. The same flow is available
+in the browser on `/mcp/submit`.
+
 ## 0.22.0 — MCP from the terminal + refreshed compatibility
 
 ### Added

{agentnode_sdk-0.22.0 → agentnode_sdk-0.23.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: agentnode-sdk
-Version: 0.22.0
+Version: 0.23.0
 Summary: Python SDK for AgentNode — the open upgrade and discovery infrastructure for AI agents.
 Project-URL: Homepage, https://agentnode.net
 Project-URL: Repository, https://github.com/agentnode-ai/agentnode

{agentnode_sdk-0.22.0 → agentnode_sdk-0.23.0}/agentnode_sdk/__init__.py

@@ -38,7 +38,7 @@ from agentnode_sdk.runtime import AgentNodeRuntime
 Client = AgentNodeClient
 ToolError = AgentNodeToolError
 
-__version__ = "0.22.0"
+__version__ = "0.23.0"
 __all__ = [
     "AgentNode",
     "AsyncAgentNode",

{agentnode_sdk-0.22.0 → agentnode_sdk-0.23.0}/agentnode_sdk/cli/main.py

@@ -61,6 +61,19 @@ def main(argv: list[str] | None = None) -> int:
     mcp_revoke_p.add_argument("--key", default=None, help="Revoke only this consent_key")
     mcp_grants_p = mcp_sub.add_parser("grants", help="List stored consent grants (metadata only)")
     mcp_grants_p.add_argument("--json", dest="json_output", action="store_true", help="JSON output")
+    # Slice 2b-2: prove package ownership via a publish-challenge (npm/PyPI).
+    mcp_own_p = mcp_sub.add_parser("ownership", help="Prove package ownership (publish-challenge)")
+    mcp_own_sub = mcp_own_p.add_subparsers(dest="ownership_command")
+    mcp_own_ch = mcp_own_sub.add_parser("challenge", help="Issue a one-time publish-challenge token")
+    mcp_own_ch.add_argument("package", help="Package name on the registry")
+    mcp_own_ch.add_argument("--registry", required=True, choices=["npm", "pypi"], help="Package registry")
+    mcp_own_ch.add_argument("--token", default=None, help="API key (default: AGENTNODE_API_KEY)")
+    mcp_own_ch.add_argument("--json", dest="json_output", action="store_true", help="JSON output")
+    mcp_own_vf = mcp_own_sub.add_parser("verify", help="Verify a pending publish-challenge")
+    mcp_own_vf.add_argument("package", help="Package name on the registry")
+    mcp_own_vf.add_argument("--registry", required=True, choices=["npm", "pypi"], help="Package registry")
+    mcp_own_vf.add_argument("--token", default=None, help="API key (default: AGENTNODE_API_KEY)")
+    mcp_own_vf.add_argument("--json", dest="json_output", action="store_true", help="JSON output")
 
     # reset
     sub.add_parser("reset", help="Reset configuration")
@@ -268,6 +281,21 @@ def main(argv: list[str] | None = None) -> int:
             if args.mcp_command == "grants":
                 from agentnode_sdk.cli.mcp_commands import cmd_mcp_grants
                 return cmd_mcp_grants(json_output=args.json_output)
+            if args.mcp_command == "ownership":
+                from agentnode_sdk.cli.mcp_ownership import (
+                    cmd_mcp_ownership_challenge,
+                    cmd_mcp_ownership_verify,
+                )
+                if args.ownership_command == "challenge":
+                    return cmd_mcp_ownership_challenge(
+                        args.registry, args.package, token=args.token, json_output=args.json_output
+                    )
+                if args.ownership_command == "verify":
+                    return cmd_mcp_ownership_verify(
+                        args.registry, args.package, token=args.token, json_output=args.json_output
+                    )
+                mcp_own_p.print_help()
+                return 0
             mcp_parser.print_help()
             return 0
         if args.command == "sandbox":

agentnode_sdk-0.23.0/agentnode_sdk/cli/mcp_ownership.py

@@ -0,0 +1,207 @@
+"""Publish-challenge ownership for MCP packages (Slice 2b-2 UX).
+
+Two verbs let a publisher prove they control an npm/PyPI package:
+
+  agentnode mcp ownership challenge --registry npm|pypi <package>
+  agentnode mcp ownership verify    --registry npm|pypi <package>
+
+`challenge` asks the backend for a one-time token + keyword; the publisher adds
+the keyword to their package's metadata and publishes a new version. `verify`
+then asks the backend to look at the latest published version and confirm the
+keyword -- only someone with publish rights can put it there, so a match is
+strong ownership evidence.
+
+The token is never written to disk here -- it is shown once, straight from the
+API response. Verifying ownership does NOT publish anything: MCP listings stay
+review-gated until the sandbox-smoke gate is built.
+"""
+from __future__ import annotations
+
+import json
+import os
+import sys
+
+import httpx
+
+_REVIEW_NOTE = (
+    "  Ownership can be verified, but MCP listings still remain review-gated\n"
+    "  until the sandbox-smoke gate is built."
+)
+
+
+def _resolve_api_base() -> str:
+    from agentnode_sdk.client import DEFAULT_BASE_URL
+    return os.environ.get("AGENTNODE_API_URL", DEFAULT_BASE_URL).rstrip("/")
+
+
+def _api_key(token: str | None) -> str:
+    return token or os.environ.get("AGENTNODE_API_KEY", "")
+
+
+def _no_key() -> int:
+    print(
+        "  Error: No AgentNode API key configured.\n"
+        "  Set AGENTNODE_API_KEY or pass --token <key>.",
+        file=sys.stderr,
+    )
+    return 1
+
+
+def _handle_error(resp: httpx.Response, json_output: bool) -> int:
+    """Print a clear error for a non-2xx response and return 1.
+
+    Backend error messages are already user-facing (expired challenge, no
+    challenge, package not found, registry unavailable), so we surface them
+    directly rather than re-inventing copy per status code.
+    """
+    try:
+        err = resp.json()
+        code = err.get("code", "")
+        message = err.get("message", resp.text)
+    except Exception:
+        err = None
+        code = ""
+        message = resp.text
+
+    if json_output and err is not None:
+        print(json.dumps(err, indent=2))
+        return 1
+
+    if resp.status_code == 401:
+        print("  Error: Authentication failed. Check your API key.", file=sys.stderr)
+    elif resp.status_code == 403:
+        if "PUBLISHER" in code:
+            print("  Error: You need a publisher profile.", file=sys.stderr)
+            print("  Create one at https://agentnode.net/dashboard", file=sys.stderr)
+        else:
+            print(f"  Error: {message}", file=sys.stderr)
+    else:
+        print(f"  Error ({resp.status_code}): {message}", file=sys.stderr)
+    return 1
+
+
+def cmd_mcp_ownership_challenge(
+    registry: str,
+    package: str,
+    *,
+    token: str | None = None,
+    json_output: bool = False,
+) -> int:
+    """Issue a one-time publish-challenge for a package."""
+    api_key = _api_key(token)
+    if not api_key:
+        return _no_key()
+
+    registry = (registry or "").strip().lower()
+    url = f"{_resolve_api_base()}/v1/mcp/ownership/challenge"
+    try:
+        resp = httpx.post(
+            url,
+            json={"registry": registry, "package_name": package},
+            headers={"Authorization": f"Bearer {api_key}"},
+            timeout=30,
+        )
+    except Exception as e:
+        print(f"  Error: Connection failed: {e}", file=sys.stderr)
+        return 1
+
+    if resp.status_code != 200:
+        return _handle_error(resp, json_output)
+
+    data = resp.json()
+    if json_output:
+        print(json.dumps(data, indent=2))
+        return 0
+
+    keyword = data.get("keyword", "")
+    tok = data.get("token", "")
+    expires = (data.get("expires_at") or "")[:10]
+    verify_cmd = f"agentnode mcp ownership verify --registry {registry} {package}"
+
+    print()
+    print("  AgentNode Ownership Challenge")
+    print("  " + "-" * 29)
+    print(f"  Registry: {registry}")
+    print(f"  Package:  {package}")
+    print()
+    print("  Prove package ownership by publishing this keyword in your package")
+    print("  metadata. Only someone with publish rights can do that.")
+    print()
+    print(f"  Token (shown once):  {tok}")
+    print(f"  Keyword:             {keyword}")
+    if expires:
+        print(f"  Expires:             {expires}")
+    print()
+    print("  Next steps:")
+    print(f'    1. Add "{keyword}" to your package\'s keywords.')
+    print(f"    2. Publish a new version to {registry}.")
+    print(f"    3. Run: {verify_cmd}")
+    print()
+    print("  The token is shown only once and is stored only as a hash. If you")
+    print("  lose it, just issue a new challenge -- that replaces the old one.")
+    print()
+    print(_REVIEW_NOTE)
+    print()
+    return 0
+
+
+def cmd_mcp_ownership_verify(
+    registry: str,
+    package: str,
+    *,
+    token: str | None = None,
+    json_output: bool = False,
+) -> int:
+    """Verify a pending publish-challenge against the published package."""
+    api_key = _api_key(token)
+    if not api_key:
+        return _no_key()
+
+    registry = (registry or "").strip().lower()
+    url = f"{_resolve_api_base()}/v1/mcp/ownership/challenge/verify"
+    try:
+        resp = httpx.post(
+            url,
+            json={"registry": registry, "package_name": package},
+            headers={"Authorization": f"Bearer {api_key}"},
+            timeout=30,
+        )
+    except Exception as e:
+        print(f"  Error: Connection failed: {e}", file=sys.stderr)
+        return 1
+
+    if resp.status_code != 200:
+        return _handle_error(resp, json_output)
+
+    data = resp.json()
+    verified = bool(data.get("verified"))
+    if json_output:
+        print(json.dumps(data, indent=2))
+        return 0 if verified else 1
+
+    status = data.get("status", "?")
+    message = data.get("message", "")
+    version = data.get("version")
+
+    print()
+    print("  AgentNode Ownership Verify")
+    print("  " + "-" * 26)
+    print(f"  Registry: {registry}")
+    print(f"  Package:  {package}")
+    print(f"  Status:   {status}")
+    if version:
+        print(f"  Version:  {version}")
+    print()
+    if message:
+        print(f"  {message}")
+    if verified:
+        print("  Strong ownership evidence recorded for this package.")
+    else:
+        print(
+            f"  Not verified yet. Publish a version carrying the challenge keyword, "
+            f"then run:\n    agentnode mcp ownership verify --registry {registry} {package}"
+        )
+    print()
+    print(_REVIEW_NOTE)
+    print()
+    return 0 if verified else 1

{agentnode_sdk-0.22.0 → agentnode_sdk-0.23.0}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "agentnode-sdk"
-version = "0.22.0"
+version = "0.23.0"
 description = "Python SDK for AgentNode — the open upgrade and discovery infrastructure for AI agents."
 readme = "README.md"
 requires-python = ">=3.10"

agentnode_sdk-0.23.0/tests/test_mcp_ownership_cli.py

@@ -0,0 +1,243 @@
+"""Tests for the `agentnode mcp ownership challenge|verify` CLI (Slice 2b-2 UX).
+
+The two verbs drive the live publish-challenge endpoints. These tests mock httpx
+at the CLI boundary — no real network / registry call — and assert the parser
+wiring, auth/URL handling, human output, and every error case. They also pin the
+honesty line: the CLI never claims auto-publish.
+"""
+from __future__ import annotations
+
+from unittest.mock import MagicMock, patch
+
+from agentnode_sdk.cli import mcp_ownership
+from agentnode_sdk.cli.main import main
+
+
+def _resp(status_code: int, payload: dict) -> MagicMock:
+    r = MagicMock()
+    r.status_code = status_code
+    r.json.return_value = payload
+    r.text = str(payload)
+    return r
+
+
+# --- parser wiring -----------------------------------------------------------
+
+
+def test_parser_routes_challenge(monkeypatch):
+    monkeypatch.setenv("AGENTNODE_API_KEY", "key-1")
+    with patch(
+        "agentnode_sdk.cli.mcp_ownership.cmd_mcp_ownership_challenge", return_value=0
+    ) as fn:
+        rc = main(["mcp", "ownership", "challenge", "--registry", "npm", "my-mcp"])
+    assert rc == 0
+    fn.assert_called_once()
+    args, kwargs = fn.call_args
+    assert args[0] == "npm" and args[1] == "my-mcp"
+
+
+def test_parser_routes_verify(monkeypatch):
+    monkeypatch.setenv("AGENTNODE_API_KEY", "key-1")
+    with patch(
+        "agentnode_sdk.cli.mcp_ownership.cmd_mcp_ownership_verify", return_value=0
+    ) as fn:
+        rc = main(["mcp", "ownership", "verify", "--registry", "pypi", "my-pkg"])
+    assert rc == 0
+    args, _ = fn.call_args
+    assert args[0] == "pypi" and args[1] == "my-pkg"
+
+
+def test_invalid_registry_rejected_by_parser(monkeypatch):
+    # argparse choices=[npm,pypi] -> exits before the handler runs.
+    monkeypatch.setenv("AGENTNODE_API_KEY", "key-1")
+    try:
+        main(["mcp", "ownership", "challenge", "--registry", "cargo", "x"])
+        raise AssertionError("expected SystemExit for an invalid registry")
+    except SystemExit as e:
+        assert e.code == 2
+
+
+# --- auth / URL --------------------------------------------------------------
+
+
+def test_challenge_requires_api_key(monkeypatch, capsys):
+    monkeypatch.delenv("AGENTNODE_API_KEY", raising=False)
+    rc = mcp_ownership.cmd_mcp_ownership_challenge("npm", "x", token=None)
+    assert rc == 1
+    assert "api key" in capsys.readouterr().err.lower()
+
+
+def test_challenge_uses_api_url_and_bearer(monkeypatch):
+    monkeypatch.setenv("AGENTNODE_API_URL", "https://api.example.test")
+    ok = _resp(
+        200,
+        {
+            "token": "tok-secret",
+            "keyword": "agentnode-ownership-tok-secret",
+            "registry": "npm",
+            "package_name": "my-mcp",
+            "expires_at": "2026-08-09T10:00:00+00:00",
+            "instructions": "...",
+        },
+    )
+    with patch("agentnode_sdk.cli.mcp_ownership.httpx.post", return_value=ok) as post:
+        rc = mcp_ownership.cmd_mcp_ownership_challenge("npm", "my-mcp", token="key-9")
+    assert rc == 0
+    url = post.call_args.args[0]
+    assert url == "https://api.example.test/v1/mcp/ownership/challenge"
+    headers = post.call_args.kwargs["headers"]
+    assert headers["Authorization"] == "Bearer key-9"
+    body = post.call_args.kwargs["json"]
+    assert body == {"registry": "npm", "package_name": "my-mcp"}
+
+
+# --- challenge output --------------------------------------------------------
+
+
+def test_challenge_success_shows_token_keyword_instructions(capsys):
+    ok = _resp(
+        200,
+        {
+            "token": "tok-secret",
+            "keyword": "agentnode-ownership-tok-secret",
+            "registry": "npm",
+            "package_name": "my-mcp",
+            "expires_at": "2026-08-09T10:00:00+00:00",
+            "instructions": "...",
+        },
+    )
+    with patch("agentnode_sdk.cli.mcp_ownership.httpx.post", return_value=ok):
+        rc = mcp_ownership.cmd_mcp_ownership_challenge("npm", "my-mcp", token="key-9")
+    assert rc == 0
+    out = capsys.readouterr().out
+    assert "tok-secret" in out  # token shown
+    assert "agentnode-ownership-tok-secret" in out  # keyword shown
+    assert "shown once" in out.lower()
+    assert "verify --registry npm my-mcp" in out
+    assert "2026-08-09" in out  # expiry (date only)
+    # honesty line, no auto-publish claim
+    assert "review-gated" in out.lower()
+    for bad in ("auto-publish", "publishes automatically", "goes live after verify"):
+        assert bad not in out.lower()
+
+
+def test_challenge_json_output(capsys):
+    ok = _resp(
+        200,
+        {"token": "t", "keyword": "agentnode-ownership-t", "registry": "npm",
+         "package_name": "p", "expires_at": "2026-08-09T00:00:00+00:00", "instructions": "x"},
+    )
+    with patch("agentnode_sdk.cli.mcp_ownership.httpx.post", return_value=ok):
+        rc = mcp_ownership.cmd_mcp_ownership_challenge(
+            "npm", "p", token="k", json_output=True
+        )
+    assert rc == 0
+    import json
+
+    parsed = json.loads(capsys.readouterr().out)
+    assert parsed["keyword"] == "agentnode-ownership-t"
+
+
+# --- verify output -----------------------------------------------------------
+
+
+def test_verify_success_is_strong_and_exit_zero(capsys):
+    ok = _resp(
+        200,
+        {
+            "verified": True,
+            "status": "verified",
+            "message": "Ownership verified via a published version — strong evidence.",
+            "version": "1.1.0",
+        },
+    )
+    with patch("agentnode_sdk.cli.mcp_ownership.httpx.post", return_value=ok):
+        rc = mcp_ownership.cmd_mcp_ownership_verify("npm", "my-mcp", token="key-9")
+    assert rc == 0
+    out = capsys.readouterr().out
+    assert "verified" in out.lower()
+    assert "1.1.0" in out
+    assert "strong ownership evidence" in out.lower()
+    assert "review-gated" in out.lower()
+    assert "auto-publish" not in out.lower()
+
+
+def test_verify_pending_tells_user_to_publish_and_retry(capsys):
+    pending = _resp(
+        200,
+        {
+            "verified": False,
+            "status": "pending",
+            "message": (
+                "Token not found in the latest published version's keywords yet. "
+                "Publish a version with the keyword, then verify again."
+            ),
+        },
+    )
+    with patch("agentnode_sdk.cli.mcp_ownership.httpx.post", return_value=pending):
+        rc = mcp_ownership.cmd_mcp_ownership_verify("npm", "my-mcp", token="key-9")
+    # not verified -> non-zero, so CI can gate on it
+    assert rc == 1
+    out = capsys.readouterr().out
+    assert "verify again" in out.lower()
+    assert "not verified yet" in out.lower()
+
+
+# --- error cases -------------------------------------------------------------
+
+
+def test_verify_no_challenge_404(capsys):
+    err = _resp(
+        404, {"code": "MCP_NO_CHALLENGE", "message": "No publish-challenge to verify — issue one first."}
+    )
+    with patch("agentnode_sdk.cli.mcp_ownership.httpx.post", return_value=err):
+        rc = mcp_ownership.cmd_mcp_ownership_verify("npm", "x", token="k")
+    assert rc == 1
+    assert "issue one first" in capsys.readouterr().err.lower()
+
+
+def test_verify_package_not_found_404(capsys):
+    err = _resp(
+        404, {"code": "MCP_PACKAGE_NOT_FOUND", "message": "Package 'x' not found on npm."}
+    )
+    with patch("agentnode_sdk.cli.mcp_ownership.httpx.post", return_value=err):
+        rc = mcp_ownership.cmd_mcp_ownership_verify("npm", "x", token="k")
+    assert rc == 1
+    assert "not found on npm" in capsys.readouterr().err.lower()
+
+
+def test_verify_expired_400(capsys):
+    err = _resp(
+        400, {"code": "MCP_CHALLENGE_EXPIRED", "message": "The challenge has expired — issue a new one."}
+    )
+    with patch("agentnode_sdk.cli.mcp_ownership.httpx.post", return_value=err):
+        rc = mcp_ownership.cmd_mcp_ownership_verify("npm", "x", token="k")
+    assert rc == 1
+    assert "expired" in capsys.readouterr().err.lower()
+
+
+def test_verify_registry_unavailable_503(capsys):
+    err = _resp(
+        503,
+        {"code": "MCP_REGISTRY_UNAVAILABLE", "message": "The registry is temporarily unavailable — try verify again shortly."},
+    )
+    with patch("agentnode_sdk.cli.mcp_ownership.httpx.post", return_value=err):
+        rc = mcp_ownership.cmd_mcp_ownership_verify("npm", "x", token="k")
+    assert rc == 1
+    assert "temporarily unavailable" in capsys.readouterr().err.lower()
+
+
+def test_challenge_401_auth_failed(capsys):
+    err = _resp(401, {"code": "UNAUTHORIZED", "message": "bad token"})
+    with patch("agentnode_sdk.cli.mcp_ownership.httpx.post", return_value=err):
+        rc = mcp_ownership.cmd_mcp_ownership_challenge("npm", "x", token="k")
+    assert rc == 1
+    assert "authentication failed" in capsys.readouterr().err.lower()
+
+
+def test_challenge_403_needs_publisher(capsys):
+    err = _resp(403, {"code": "PUBLISHER_REQUIRED", "message": "publisher profile required"})
+    with patch("agentnode_sdk.cli.mcp_ownership.httpx.post", return_value=err):
+        rc = mcp_ownership.cmd_mcp_ownership_challenge("npm", "x", token="k")
+    assert rc == 1
+    assert "publisher profile" in capsys.readouterr().err.lower()