city-cli 0.9.2__tar.gz → 0.9.4__tar.gz

{city_cli-0.9.2 → city_cli-0.9.4}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: city-cli
-Version: 0.9.2
+Version: 0.9.4
 Summary: Milano Agentic City CLI (city): init, dev, conform, and deploy.
 Project-URL: Homepage, https://github.com/projectnandaitaly/agentic-city
 Project-URL: Repository, https://github.com/projectnandaitaly/agentic-city
@@ -17,7 +17,7 @@ Classifier: Programming Language :: Python :: 3.12
 Classifier: Topic :: Software Development :: Libraries
 Classifier: Typing :: Typed
 Requires-Python: >=3.12
-Requires-Dist: city-sdk>=0.9.2
+Requires-Dist: city-sdk>=0.9.4
 Requires-Dist: cryptography>=43
 Requires-Dist: fastapi>=0.115
 Requires-Dist: httpx>=0.27
@@ -56,8 +56,8 @@ This provides the `city` command. It depends on [`city-sdk`](https://pypi.org/pr
 export CITY_DEPLOY_URL=https://deploy.projectnandaitaly.ai
 
 city login --team t07
-city keys init
-city init --role cup --name demo
+city init agent demo
+# edit card.yaml role if needed (cup|facility|mmg|b2b)
 city card validate
 city deploy --promote
 city status agent:t07/demo
@@ -80,7 +80,7 @@ city --json --api-url "$CITY_DEPLOY_URL" status agent:t07/demo
 If `CITY_DEPLOY_URL` / `--api-url` is unset, `city` uses an **in-process** Deploy service (useful for `init`, `dev`, and offline checks).
 
 ```bash
-city init --role cup --name demo
+city init agent demo
 city dev
 city conform --profile fast
 ```
@@ -89,13 +89,13 @@ city conform --profile fast
 
 | Command | Purpose |
 |---|---|
-| `city login` | Device-flow team session; stores token under `.city/` |
-| `city keys init` | Local controller key + register public key |
-| `city init` | Scaffold `cup` / `facility` / `mmg` / `b2b` template |
-| `city card validate` | Basic card.yaml checks |
+| `city login` | Device-flow team session; stores token and ensures Team Controller Key under `.city/` |
+| `city keys init` | Escape hatch: regenerate controller key + register public key |
+| `city init agent <name>` | Scaffold project (`--template cup\|facility\|mmg\|b2b`); agent type is `card.yaml` `role` |
+| `city card validate` | Validate `card.yaml` against the MHM card schema (base roles only) |
 | `city dev` | One local need through the harness |
 | `city conform` | Conformance suite (`--profile full\|fast`, or `--url`) |
-| `city deploy` | Upload + pipeline (`--promote`, `--runtime`) |
+| `city deploy` | Upload + pipeline; rejects non-base `role` before build (`--promote`, `--runtime`) |
 | `city promote` / `rollback` / `status` / `retire` | Lifecycle |
 | `city secrets set` / `city scale` / `city llm key rotate` | Ops |
 | `city compliance` / `city verify` | Receipts and offline verify |

{city_cli-0.9.2 → city_cli-0.9.4}/README.md

@@ -27,8 +27,8 @@ This provides the `city` command. It depends on [`city-sdk`](https://pypi.org/pr
 export CITY_DEPLOY_URL=https://deploy.projectnandaitaly.ai
 
 city login --team t07
-city keys init
-city init --role cup --name demo
+city init agent demo
+# edit card.yaml role if needed (cup|facility|mmg|b2b)
 city card validate
 city deploy --promote
 city status agent:t07/demo
@@ -51,7 +51,7 @@ city --json --api-url "$CITY_DEPLOY_URL" status agent:t07/demo
 If `CITY_DEPLOY_URL` / `--api-url` is unset, `city` uses an **in-process** Deploy service (useful for `init`, `dev`, and offline checks).
 
 ```bash
-city init --role cup --name demo
+city init agent demo
 city dev
 city conform --profile fast
 ```
@@ -60,13 +60,13 @@ city conform --profile fast
 
 | Command | Purpose |
 |---|---|
-| `city login` | Device-flow team session; stores token under `.city/` |
-| `city keys init` | Local controller key + register public key |
-| `city init` | Scaffold `cup` / `facility` / `mmg` / `b2b` template |
-| `city card validate` | Basic card.yaml checks |
+| `city login` | Device-flow team session; stores token and ensures Team Controller Key under `.city/` |
+| `city keys init` | Escape hatch: regenerate controller key + register public key |
+| `city init agent <name>` | Scaffold project (`--template cup\|facility\|mmg\|b2b`); agent type is `card.yaml` `role` |
+| `city card validate` | Validate `card.yaml` against the MHM card schema (base roles only) |
 | `city dev` | One local need through the harness |
 | `city conform` | Conformance suite (`--profile full\|fast`, or `--url`) |
-| `city deploy` | Upload + pipeline (`--promote`, `--runtime`) |
+| `city deploy` | Upload + pipeline; rejects non-base `role` before build (`--promote`, `--runtime`) |
 | `city promote` / `rollback` / `status` / `retire` | Lifecycle |
 | `city secrets set` / `city scale` / `city llm key rotate` | Ops |
 | `city compliance` / `city verify` | Receipts and offline verify |

city_cli-0.9.4/VERSION

@@ -0,0 +1 @@
+0.9.4

{city_cli-0.9.2 → city_cli-0.9.4}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "city-cli"
-version = "0.9.2"
+version = "0.9.4"
 description = "Milano Agentic City CLI (city): init, dev, conform, and deploy."
 readme = "README.md"
 requires-python = ">=3.12"
@@ -17,7 +17,7 @@ classifiers = [
     "Typing :: Typed",
 ]
 dependencies = [
-    "city-sdk>=0.9.2",
+    "city-sdk>=0.9.4",
     "cryptography>=43",
     "fastapi>=0.115",
     "httpx>=0.27",

city_cli-0.9.4/src/city_deploy/card_schema.py

@@ -0,0 +1,128 @@
+"""Load and validate MHM agent cards from project ``card.yaml``."""
+
+from __future__ import annotations
+
+import json
+from collections.abc import Mapping
+from functools import cache
+from pathlib import Path
+from typing import Any
+
+import yaml  # type: ignore[import-untyped]
+from cap.core.errors import CapError
+from jsonschema import Draft202012Validator
+from referencing import Registry, Resource
+from referencing.jsonschema import DRAFT202012
+
+_PLACEHOLDER_X = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA"
+
+
+def specs_root() -> Path:
+    here = Path(__file__).resolve()
+    for parent in here.parents:
+        candidate = parent / "specs" / "profiles" / "mhm" / "1.0" / "card.json"
+        if candidate.is_file():
+            return parent / "specs"
+    raise CapError("SCHEMA_INVALID", "specs")
+
+
+def _schema_files() -> list[Path]:
+    root = specs_root()
+    files: list[Path] = []
+    for base in (root / "cap", root / "profiles", root / "events"):
+        if base.is_dir():
+            files.extend(sorted(base.rglob("*.json")))
+    return files
+
+
+@cache
+def _registry() -> Registry:
+    resources: list[tuple[str, Resource[object]]] = []
+    for path in _schema_files():
+        contents = json.loads(path.read_text(encoding="utf-8"))
+        schema_id = contents.get("$id")
+        if isinstance(schema_id, str):
+            resources.append(
+                (schema_id, Resource.from_contents(contents, default_specification=DRAFT202012))
+            )
+    return Registry().with_resources(resources)
+
+
+@cache
+def _mhm_validator() -> Draft202012Validator:
+    schema = json.loads(
+        (specs_root() / "profiles" / "mhm" / "1.0" / "card.json").read_text(encoding="utf-8")
+    )
+    return Draft202012Validator(
+        schema,
+        registry=_registry(),
+        format_checker=Draft202012Validator.FORMAT_CHECKER,
+    )
+
+
+def load_card_yaml(text: str) -> dict[str, Any]:
+    loaded = yaml.safe_load(text)
+    if not isinstance(loaded, dict):
+        raise CapError("SCHEMA_INVALID", "card")
+    return loaded
+
+
+def card_from_yaml(text: str, public: Mapping[str, Any] | None = None) -> dict[str, Any]:
+    """Build a deployable card dict from ``card.yaml``, injecting agent keys."""
+    raw = load_card_yaml(text)
+    agent_id = raw.get("agent_id")
+    team = raw.get("team")
+    name = raw.get("name") or "agent"
+    version = raw.get("version")
+    role = raw.get("role")
+    service_types = raw.get("service_types")
+    no_clinical = raw.get("no_clinical_advice")
+    if not isinstance(agent_id, str) or not isinstance(team, str) or not isinstance(version, str):
+        raise CapError("SCHEMA_INVALID", "card")
+    if not isinstance(role, str):
+        raise CapError("SCHEMA_INVALID", "role")
+    if not isinstance(service_types, list) or not service_types:
+        raise CapError("SCHEMA_INVALID", "service_types")
+    if no_clinical is not True:
+        raise CapError("SCHEMA_INVALID", "no_clinical_advice")
+    if public is None:
+        key = {
+            "kid": f"{agent_id}#k1",
+            "kty": "OKP",
+            "crv": "Ed25519",
+            "x": _PLACEHOLDER_X,
+        }
+    else:
+        key = {
+            "kid": f"{agent_id}#k1",
+            "kty": public["kty"],
+            "crv": public["crv"],
+            "x": public["x"],
+        }
+    card: dict[str, Any] = {
+        "agent_id": agent_id,
+        "team": team,
+        "name": name,
+        "version": version,
+        "cap_versions": raw.get("cap_versions") or ["1.0"],
+        "profiles": raw.get("profiles") or ["mhm/1.0"],
+        "keys": [key],
+        "endpoints": raw.get("endpoints") or {"mailbox": agent_id},
+        "role": role,
+        "service_types": service_types,
+        "no_clinical_advice": True,
+    }
+    for optional in ("municipi", "languages", "accessibility"):
+        if optional in raw:
+            card[optional] = raw[optional]
+    return card
+
+
+def validate_mhm_card(card: Mapping[str, Any]) -> None:
+    role = card.get("role")
+    if role not in {"cup", "facility", "mmg", "b2b"}:
+        raise CapError("SCHEMA_INVALID", "role")
+    errors = sorted(_mhm_validator().iter_errors(dict(card)), key=lambda err: str(list(err.path)))
+    if errors:
+        path = ".".join(str(part) for part in errors[0].absolute_path) or "card"
+        raise CapError("SCHEMA_INVALID", path)

{city_cli-0.9.2 → city_cli-0.9.4}/src/city_deploy/cli.py

@@ -6,7 +6,6 @@ import asyncio
 import json
 import os
 import sys
-from collections.abc import Mapping
 from datetime import UTC, datetime, timedelta
 from pathlib import Path
 from typing import Any
@@ -16,23 +15,25 @@ import typer
 from cap.core.envelope import verify
 from cap.core.errors import CapError
 from cap.core.grant import issue
-from cap.core.keys import PrivateKey, PublicKey
+from cap.core.keys import PublicKey
 from cap.core.timeutil import format_time
-from cryptography.hazmat.primitives import serialization
-from cryptography.hazmat.primitives.asymmetric.ed25519 import Ed25519PrivateKey
 from httpx import ASGITransport
 
 from city_deploy.api import create_app
+from city_deploy.card_schema import card_from_yaml, validate_mhm_card
 from city_deploy.conform import select_profile
+from city_deploy.controller import ensure_controller_key, load_controller
 from city_deploy.local import flat_field, init_project, run_local_need
 from city_deploy.service import DeployService
 
 app = typer.Typer(no_args_is_help=True, add_completion=False)
+init_app = typer.Typer(no_args_is_help=True, add_completion=False)
 keys_app = typer.Typer(no_args_is_help=True, add_completion=False)
 card_app = typer.Typer(no_args_is_help=True, add_completion=False)
 secrets_app = typer.Typer(no_args_is_help=True, add_completion=False)
 llm_app = typer.Typer(no_args_is_help=True, add_completion=False)
 llm_key_app = typer.Typer(no_args_is_help=True, add_completion=False)
+app.add_typer(init_app, name="init")
 app.add_typer(keys_app, name="keys")
 app.add_typer(card_app, name="card")
 app.add_typer(secrets_app, name="secrets")
@@ -77,6 +78,16 @@ def login(
     token_path = _token_path(root)
     token_path.parent.mkdir(parents=True, exist_ok=True)
     token_path.write_text(str(polled["token"]), encoding="utf-8")
+    authed = _client(ctx, root)
+    try:
+        ensure_controller_key(
+            root,
+            lambda public: authed.post("/keys/register", {"jwk": public}),
+            overwrite=False,
+        )
+    except CapError as exc:
+        typer.echo(exc.body()["code"])
+        raise typer.Exit(code=1) from exc
     _emit(ctx, {"team_id": polled["team_id"]}, f"logged in as {polled['team_id']}")
 
 
@@ -85,22 +96,16 @@ def keys_init(
     ctx: typer.Context,
     root: Path = typer.Option(Path("."), "--root"),
 ) -> None:
-    raw = Ed25519PrivateKey.generate()
-    private = PrivateKey(raw)
-    public = private.public_key().to_jwk()
-    city = root / ".city"
-    city.mkdir(parents=True, exist_ok=True)
-    pem = raw.private_bytes(
-        encoding=serialization.Encoding.PEM,
-        format=serialization.PrivateFormat.PKCS8,
-        encryption_algorithm=serialization.NoEncryption(),
-    )
-    key_path = city / "controller.pem"
-    key_path.write_bytes(pem)
-    key_path.chmod(0o600)
-    (city / "controller.jwk").write_text(json.dumps(public), encoding="utf-8")
-    response = _client(ctx, root).post("/keys/register", {"jwk": public})
-    _raise_for_status(response)
+    client = _client(ctx, root)
+    try:
+        public = ensure_controller_key(
+            root,
+            lambda jwk: client.post("/keys/register", {"jwk": jwk}),
+            overwrite=True,
+        )
+    except CapError as exc:
+        typer.echo(exc.body()["code"])
+        raise typer.Exit(code=1) from exc
     _emit(ctx, public, "controller public key registered")
 
 
@@ -130,7 +135,7 @@ def keys_rotate(
         "not_before": _stamp(ctx, hours=-1),
         "not_after": _stamp(ctx, hours=1),
     }
-    signed = issue(_load_controller(root), grant, kid=f"team:{team}#controller")
+    signed = issue(load_controller(root), grant, kid=f"team:{team}#controller")
     response = client.post(
         f"/agents/{agent}/keys/rotate",
         {"grant": signed.grant, "jws": signed.jws},
@@ -139,19 +144,19 @@ def keys_rotate(
     _emit(ctx, response.json(), "agent key rotated")
 
 
-@app.command("init")
-def init(
+@init_app.command("agent")
+def init_agent(
     ctx: typer.Context,
-    role: str = typer.Option(..., "--role"),
-    name: str = typer.Option(..., "--name"),
+    name: str = typer.Argument(...),
+    template: str = typer.Option("cup", "--template"),
     root: Path = typer.Option(Path("."), "--root"),
 ) -> None:
     try:
-        payload = init_project(root, role, name)
+        payload = init_project(root, name, template=template)
     except CapError as exc:
         typer.echo(exc.body()["code"])
         raise typer.Exit(code=1) from exc
-    _emit(ctx, payload, f"initialized {role} {name}")
+    _emit(ctx, payload, f"initialized agent {name}")
 
 
 @card_app.command("validate")
@@ -160,20 +165,19 @@ def card_validate(
     root: Path = typer.Option(Path("."), "--root"),
 ) -> None:
     text = (root / "card.yaml").read_text(encoding="utf-8")
-    agent_id = flat_field(text, "agent_id")
-    team = flat_field(text, "team")
-    version = flat_field(text, "version")
-    ok = (
-        agent_id is not None
-        and agent_id.startswith("agent:")
-        and team is not None
-        and version is not None
-        and "keys:" in text
-    )
-    payload = {"valid": ok, "agent_id": agent_id, "team": team}
-    if not ok:
+    try:
+        card = card_from_yaml(text)
+        validate_mhm_card(card)
+    except CapError as exc:
+        payload = {"valid": False, "code": exc.body()["code"]}
         _emit(ctx, payload, "card invalid")
-        raise typer.Exit(code=1)
+        raise typer.Exit(code=1) from exc
+    payload = {
+        "valid": True,
+        "agent_id": card["agent_id"],
+        "team": card["team"],
+        "role": card["role"],
+    }
     _emit(ctx, payload, "card valid")
 
 
@@ -238,16 +242,21 @@ def deploy(
     runtime: str = typer.Option("memory", "--runtime"),
 ) -> None:
     text = (root / "card.yaml").read_text(encoding="utf-8")
-    agent_id = flat_field(text, "agent_id")
-    version = flat_field(text, "version")
-    team_field = flat_field(text, "team")
-    if agent_id is None or version is None or team_field is None:
-        raise typer.Exit(code=1)
+    try:
+        preview = card_from_yaml(text)
+        validate_mhm_card(preview)
+    except CapError as exc:
+        typer.echo(exc.body()["code"])
+        raise typer.Exit(code=1) from exc
+    agent_id = str(preview["agent_id"])
+    version = str(preview["version"])
+    team_field = str(preview["team"])
     client = _client(ctx, root)
     minted = client.post(f"/agents/{agent_id}/keys", {})
     _raise_for_status(minted)
     public = minted.json()
-    card = _card_from_yaml(text, public)
+    card = card_from_yaml(text, public)
+    validate_mhm_card(card)
     team = team_field.removeprefix("team:")
     slug = agent_id.split("/", 1)[1]
     grant = {
@@ -259,7 +268,7 @@ def deploy(
         "not_before": _stamp(ctx, hours=-1),
         "not_after": _stamp(ctx, hours=1),
     }
-    signed = issue(_load_controller(root), grant, kid=f"team:{team}#controller")
+    signed = issue(load_controller(root), grant, kid=f"team:{team}#controller")
     created = client.post(
         "/deployments",
         {
@@ -484,14 +493,6 @@ def _token_path(root: Path) -> Path:
     return root / ".city" / "token"
 
 
-def _load_controller(root: Path) -> PrivateKey:
-    data = (root / ".city" / "controller.pem").read_bytes()
-    loaded = serialization.load_pem_private_key(data, password=None)
-    if not isinstance(loaded, Ed25519PrivateKey):
-        raise CapError("KEY_UNKNOWN", "controller")
-    return PrivateKey(loaded)
-
-
 def _team_from_root(root: Path) -> str:
     text = (root / "card.yaml").read_text(encoding="utf-8")
     team = flat_field(text, "team")
@@ -522,32 +523,6 @@ def _service(ctx: typer.Context) -> DeployService:
     return deploy
 
 
-def _card_from_yaml(text: str, public: Mapping[str, Any]) -> dict[str, Any]:
-    agent_id = flat_field(text, "agent_id")
-    team = flat_field(text, "team")
-    name = flat_field(text, "name") or "agent"
-    version = flat_field(text, "version")
-    if agent_id is None or team is None or version is None:
-        raise CapError("SCHEMA_INVALID", "card")
-    return {
-        "agent_id": agent_id,
-        "team": team,
-        "name": name,
-        "version": version,
-        "cap_versions": ["1.0"],
-        "profiles": ["mhm/1.0"],
-        "keys": [
-            {
-                "kid": agent_id + "#k1",
-                "kty": public["kty"],
-                "crv": public["crv"],
-                "x": public["x"],
-            }
-        ],
-        "endpoints": {"mailbox": agent_id},
-    }
-
-
 def _raise_for_status(response: httpx.Response) -> None:
     if response.status_code >= 400:
         typer.echo(response.text)

city_cli-0.9.4/src/city_deploy/controller.py

@@ -0,0 +1,62 @@
+"""Team Controller Key helpers for the city CLI."""
+
+from __future__ import annotations
+
+import json
+from collections.abc import Callable
+from pathlib import Path
+from typing import Any
+
+import httpx
+from cap.core.errors import CapError
+from cap.core.keys import PrivateKey
+from cryptography.hazmat.primitives import serialization
+from cryptography.hazmat.primitives.asymmetric.ed25519 import Ed25519PrivateKey
+
+
+def controller_pem_path(root: Path) -> Path:
+    return root / ".city" / "controller.pem"
+
+
+def load_controller(root: Path) -> PrivateKey:
+    data = controller_pem_path(root).read_bytes()
+    loaded = serialization.load_pem_private_key(data, password=None)
+    if not isinstance(loaded, Ed25519PrivateKey):
+        raise CapError("KEY_UNKNOWN", "controller")
+    return PrivateKey(loaded)
+
+
+def ensure_controller_key(
+    root: Path,
+    register: Callable[[dict[str, Any]], httpx.Response],
+    *,
+    overwrite: bool,
+) -> dict[str, Any]:
+    """Ensure a local controller key exists and register its public JWK.
+
+    When ``overwrite`` is false and a PEM already exists, reuse it (login path).
+    When ``overwrite`` is true, always generate a new key (``city keys init``).
+    """
+    city = root / ".city"
+    city.mkdir(parents=True, exist_ok=True)
+    key_path = controller_pem_path(root)
+    jwk_path = city / "controller.jwk"
+    if key_path.is_file() and not overwrite:
+        public = load_controller(root).public_key().to_jwk()
+        jwk_path.write_text(json.dumps(public), encoding="utf-8")
+    else:
+        raw = Ed25519PrivateKey.generate()
+        private = PrivateKey(raw)
+        public = private.public_key().to_jwk()
+        pem = raw.private_bytes(
+            encoding=serialization.Encoding.PEM,
+            format=serialization.PrivateFormat.PKCS8,
+            encryption_algorithm=serialization.NoEncryption(),
+        )
+        key_path.write_bytes(pem)
+        key_path.chmod(0o600)
+        jwk_path.write_text(json.dumps(public), encoding="utf-8")
+    response = register(public)
+    if response.status_code >= 400:
+        raise CapError("KEY_UNKNOWN", "register")
+    return public

{city_cli-0.9.2 → city_cli-0.9.4}/src/city_deploy/local.py

@@ -12,7 +12,7 @@ from city_sdk.layers import preserve_order
 from city_sdk.market import Market, Need, Peer
 from city_sdk.ports import MemoryAttest, MemoryIndex, MemoryLedger, MemoryRelay
 
-_ROLES = frozenset({"cup", "facility", "mmg", "b2b"})
+_TEMPLATES = frozenset({"cup", "facility", "mmg", "b2b"})
 _SLUGS = {
     "cup": "cup-rapido",
     "facility": "osp-x",
@@ -32,12 +32,14 @@ def templates_root() -> Path:
     raise CapError("SCHEMA_INVALID", "templates")
 
 
-def init_project(root: Path, role: str, name: str) -> dict[str, str]:
-    if role not in _ROLES or re.fullmatch(r"[a-z0-9-]+", name) is None:
-        raise CapError("SCHEMA_INVALID", "role")
-    source = templates_root() / role
+def init_project(root: Path, name: str, *, template: str = "cup") -> dict[str, str]:
+    if template not in _TEMPLATES:
+        raise CapError("SCHEMA_INVALID", "template")
+    if re.fullmatch(r"[a-z0-9-]+", name) is None:
+        raise CapError("SCHEMA_INVALID", "name")
+    source = templates_root() / template
     root.mkdir(parents=True, exist_ok=True)
-    slug = _SLUGS[role]
+    slug = _SLUGS[template]
     for path in source.rglob("*"):
         if not path.is_file() or "__pycache__" in path.parts:
             continue
@@ -47,7 +49,7 @@ def init_project(root: Path, role: str, name: str) -> dict[str, str]:
         if path.suffix in {".yaml", ".yml", ".md"} or path.name == "Dockerfile":
             text = text.replace(slug, name)
         target.write_text(text, encoding="utf-8")
-    return {"role": role, "name": name, "path": str(root)}
+    return {"template": template, "name": name, "path": str(root)}
 
 
 def flat_field(text: str, key: str) -> str | None:

city_cli-0.9.2/VERSION

@@ -1 +0,0 @@
-0.9.2