verulla-cli 0.0.2__tar.gz

verulla_cli-0.0.2/.gitignore

@@ -0,0 +1,7 @@
+.venv/
+__pycache__/
+*.pyc
+data/
+*.db
+.DS_Store
+output.txt

verulla_cli-0.0.2/PKG-INFO

@@ -0,0 +1,8 @@
+Metadata-Version: 2.5
+Name: verulla-cli
+Version: 0.0.2
+Requires-Python: >=3.12
+Requires-Dist: docker>=7
+Requires-Dist: httpx>=0.27
+Requires-Dist: typer>=0.12
+Requires-Dist: verulla-manifest==0.0.2

verulla_cli-0.0.2/pyproject.toml

@@ -0,0 +1,21 @@
+[project]
+name = "verulla-cli"
+version = "0.0.2"
+requires-python = ">=3.12"
+dependencies = [
+  "verulla-manifest==0.0.2",
+  "typer>=0.12",
+  "httpx>=0.27",
+  "docker>=7",
+]
+
+[project.scripts]
+verulla = "verulla_cli.main:app"
+
+[build-system]
+requires = ["hatchling"]
+build-backend = "hatchling.build"
+
+[tool.deptry]
+known_first_party = ["verulla_cli"]
+extend_exclude = ["tests"]

verulla_cli-0.0.2/tests/test_admin_cmd.py

@@ -0,0 +1,49 @@
+from __future__ import annotations
+
+import httpx
+from typer.testing import CliRunner
+
+from verulla_cli import main as cli_main
+from verulla_cli.main import app
+
+runner = CliRunner()
+
+
+def _patch(monkeypatch, handler):
+    monkeypatch.setattr(cli_main, "get_token", lambda: "tok")
+    real = httpx.get
+
+    def fake_get(url, **kw):
+        with httpx.Client(transport=httpx.MockTransport(handler)) as c:
+            return c.get(url, headers=kw.get("headers"))
+
+    monkeypatch.setattr(httpx, "get", fake_get)
+    return real
+
+
+def test_whoami_prints_identity(monkeypatch) -> None:
+    seen = {}
+
+    def handler(req):
+        seen["url"] = str(req.url)
+        seen["auth"] = req.headers["authorization"]
+        return httpx.Response(200, json={"sub": "u1", "roles": ["operator"], "scopes": ["platform:operator"], "client": "c1"})
+
+    _patch(monkeypatch, handler)
+    r = runner.invoke(app, ["admin", "whoami", "--admin-url", "https://x.ts.net/"])
+    assert r.exit_code == 0, r.output
+    assert seen["url"] == "https://x.ts.net/v1/admin/whoami"
+    assert seen["auth"] == "Bearer tok"
+    assert "operator" in r.output and "platform:operator" in r.output
+
+
+def test_whoami_shows_api_error(monkeypatch) -> None:
+    _patch(monkeypatch, lambda req: httpx.Response(403, text="missing admin scope"))
+    r = runner.invoke(app, ["admin", "whoami", "--admin-url", "https://x.ts.net"])
+    assert r.exit_code == 1
+    assert "403" in r.output and "missing admin scope" in r.output
+
+
+def test_whoami_requires_url(monkeypatch) -> None:
+    monkeypatch.delenv("VERULLA_ADMIN_URL", raising=False)
+    assert runner.invoke(app, ["admin", "whoami"]).exit_code == 2

verulla_cli-0.0.2/tests/test_apps_client.py

@@ -0,0 +1,225 @@
+from __future__ import annotations
+
+import httpx
+import pytest
+
+from verulla_cli.apps_client import (
+    AppsError, activate_app, delete_app, delete_customer, export_customers, get_app_logs, get_auth_policy,
+    get_spend_summary, invite_customer, list_apps, list_customers, lock_customer,
+    get_sketch_events, rollback_app, set_auth_policy, unlock_customer,
+)
+
+
+class FakeClient:
+    def __init__(self, response):
+        self.response = response
+        self.calls = []
+
+    def request(self, method, url, headers, **kwargs):
+        self.calls.append((method, url, headers, kwargs))
+        return self.response
+
+
+def response(status, body):
+    req = httpx.Request("GET", "http://api.test")
+    return httpx.Response(status, json=body, request=req)
+
+
+def test_list_apps_uses_authenticated_apps_endpoint():
+    client = FakeClient(response(200, {"apps": [{"app": "demo"}]}))
+    assert list_apps("http://api.test", "token", client) == [{"app": "demo"}]
+    assert client.calls[0][:3] == ("GET", "http://api.test/v1/apps", {"Authorization": "Bearer token"})
+
+
+
+def test_sketch_events_passes_cursor_and_limit_without_changing_contract():
+    body = {
+        "events": [{
+            "id": "12345678-90ab-cdef-0123-4567890abcde",
+            "type": "sketch.reminder_48h",
+            "app": "demo",
+            "occurred_at": "2026-10-29T12:00:00Z",
+            "payload": {"due_at": "2026-10-29T12:00:00Z"},
+            "cursor": "opaque",
+        }],
+        "next_cursor": "opaque",
+        "has_more": False,
+    }
+    client = FakeClient(response(200, body))
+    result = get_sketch_events("http://api.test", "token", "my app", cursor="opaque", limit=25, client=client)
+    from importlib.util import module_from_spec, spec_from_file_location
+    from pathlib import Path
+
+    contract_path = Path(__file__).resolve().parents[2] / "mcp" / "tests" / "api_contract.py"
+    spec = spec_from_file_location("mcp_api_contract", contract_path)
+    assert spec is not None and spec.loader is not None
+    contract = module_from_spec(spec)
+    spec.loader.exec_module(contract)
+    contract.validate_sketch_event_page(result)
+    assert result == body
+    method, url, headers, kwargs = client.calls[0]
+    assert method == "GET"
+    assert url == "http://api.test/v1/apps/my%20app/events"
+    assert headers["Authorization"] == "Bearer token"
+    assert kwargs["params"] == {"limit": 25, "cursor": "opaque"}
+
+def test_sketch_events_rejects_invalid_response_payload():
+    client = FakeClient(response(200, {"events": [{"type": "sketch.retention_ended"}], "next_cursor": None, "has_more": False}))
+    with pytest.raises(AppsError, match="invalid Sketch event response"):
+        get_sketch_events("http://api.test", "token", "demo", client=client)
+
+
+
+def test_currency_client_calls_preserve_legacy_cent_fields_and_send_topup_currency():
+    client = FakeClient(response(201, {"topup_id": "top-1", "amount_cents": 1500, "currency": "CAD"}))
+    from verulla_cli.apps_client import create_topup, get_usage_summary, get_wallet_summary
+
+    assert create_topup("http://api.test", "token", 1500, "CAD", client)["currency"] == "CAD"
+    assert client.calls[0][0:2] == ("POST", "http://api.test/v1/wallet/topups")
+    assert client.calls[0][3]["json"] == {"amount_cents": 1500, "currency": "CAD"}
+    get_wallet_summary("http://api.test", "token", client)
+    get_usage_summary("http://api.test", "token", client)
+    assert [call[1] for call in client.calls[1:]] == [
+        "http://api.test/v1/wallet", "http://api.test/v1/usage",
+    ]
+
+
+def test_term_usage_client_requests_optional_app_filter():
+    from verulla_cli.apps_client import get_term_usage
+
+    client = FakeClient(response(200, {"currency": "CAD", "apps": []}))
+    assert get_term_usage("http://api.test", "token", client, app="store") == {
+        "currency": "CAD", "apps": []
+    }
+    assert client.calls[0][0:2] == ("GET", "http://api.test/v1/usage/term")
+    assert client.calls[0][3]["params"] == {"app": "store"}
+
+
+
+def test_wallet_currency_conflict_keeps_machine_readable_code():
+    client = FakeClient(response(409, {"detail": {
+        "code": "wallet_currency_mismatch",
+        "message": "wallet currency is immutable after funding",
+    }}))
+    from verulla_cli.apps_client import create_topup
+
+    with pytest.raises(AppsError, match="wallet_currency_mismatch"):
+        create_topup("http://api.test", "token", 1500, "CAD", client)
+
+
+
+def test_delete_and_rollback_use_app_routes():
+    client = FakeClient(response(202, {"status": "deleted"}))
+    delete_app("http://api.test", "token", "demo", client)
+    rollback_app("http://api.test", "token", "demo", client)
+    assert [call[:2] for call in client.calls] == [
+        ("DELETE", "http://api.test/v1/apps/demo"),
+        ("POST", "http://api.test/v1/apps/demo/rollback"),
+    ]
+
+
+def test_get_app_logs_uses_authenticated_logs_endpoint():
+    client = FakeClient(response(200, {"app": "demo", "status": "failed", "build_log_tail": "output"}))
+    result = get_app_logs("http://api.test", "token", "demo", client)
+    assert result["build_log_tail"] == "output"
+    assert client.calls[0][:3] == ("GET", "http://api.test/v1/apps/demo/logs", {"Authorization": "Bearer token"})
+
+
+def test_owner_claim_client_posts_email_with_idempotency_and_safe_status_get():
+    from verulla_cli.apps_client import get_owner_claim_status, issue_owner_claim
+
+    client = FakeClient(response(201, {
+        "status": "pending", "expires_at": "2026-10-31T12:00:00Z",
+        "claim_url": "https://account.verulla.com/claim#one-time",
+    }))
+    issued = issue_owner_claim("http://api.test", "token", "owner@example.test", "request-uuid", client)
+    assert issued["claim_url"].endswith("#one-time")
+    method, url, headers, kwargs = client.calls[0]
+    assert (method, url) == ("POST", "http://api.test/v1/owner-claims")
+    assert headers["Idempotency-Key"] == "request-uuid"
+    assert kwargs["json"] == {"owner_email": "owner@example.test"}
+
+    client.response = response(200, {"status": "pending", "expires_at": "2026-10-31T12:00:00Z"})
+    assert get_owner_claim_status("http://api.test", "token", client) == {
+        "status": "pending", "expires_at": "2026-10-31T12:00:00Z",
+    }
+    assert client.calls[1][:2] == ("GET", "http://api.test/v1/owner-claims/current")
+
+
+def test_owner_claim_api_errors_do_not_echo_email():
+    from verulla_cli.apps_client import issue_owner_claim
+
+    client = FakeClient(response(400, {"detail": "invalid owner@example.test"}))
+    with pytest.raises(AppsError) as exc_info:
+        issue_owner_claim("http://api.test", "token", "owner@example.test", "request-uuid", client)
+    assert "owner@example.test" not in str(exc_info.value)
+
+
+def test_auth_policy_get_and_set_use_versioned_policy_contract():
+    client = FakeClient(response(200, {"app": "demo", "version": 0, "policy": {"signup_mode": "open"}}))
+    assert get_auth_policy("http://api.test", "token", "demo", client)["version"] == 0
+    policy = {"signup_mode": "invite", "password_min_length": 10}
+    set_auth_policy("http://api.test", "token", "demo", 0, policy, client)
+    assert client.calls[0][0:2] == ("GET", "http://api.test/v1/apps/demo/auth")
+    assert client.calls[1][0:2] == ("PUT", "http://api.test/v1/apps/demo/auth")
+    assert client.calls[1][3] == {"params": {"version": 0}, "json": {"policy": policy}}
+
+
+def test_customer_list_search_uses_server_query_parameter():
+    client = FakeClient(response(200, {"customers": [], "total": 0, "limit": 50, "offset": 0}))
+    list_customers("http://api.test", "token", "demo", client, search="ada")
+    assert client.calls[0][3]["params"]["q"] == "ada"
+    assert "search" not in client.calls[0][3]["params"]
+
+
+@pytest.mark.parametrize("status", [200, 204])
+def test_delete_customer_accepts_empty_response(status):
+    client = FakeClient(httpx.Response(status, request=httpx.Request("DELETE", "http://api.test")))
+    assert delete_customer("http://api.test", "token", "demo", "uuid", client) is None
+
+
+def test_customer_actions_use_scoped_routes_and_export_csv():
+    csv_response = httpx.Response(200, text="id,email\\n", request=httpx.Request("GET", "http://api.test"))
+    client = FakeClient(response(200, {"customers": [], "total": 0, "limit": 50, "offset": 0}))
+    list_customers("http://api.test", "token", "demo", client)
+    lock_customer("http://api.test", "token", "demo", "uuid", client)
+    unlock_customer("http://api.test", "token", "demo", "uuid", client)
+    delete_customer("http://api.test", "token", "demo", "uuid", client)
+    invite_customer("http://api.test", "token", "demo", "user@example.com", client)
+    client.response = csv_response
+    assert export_customers("http://api.test", "token", "demo", client) == "id,email\\n"
+    assert [call[0:2] for call in client.calls] == [
+        ("GET", "http://api.test/v1/apps/demo/customers"),
+        ("POST", "http://api.test/v1/apps/demo/customers/uuid/lock"),
+        ("POST", "http://api.test/v1/apps/demo/customers/uuid/unlock"),
+        ("DELETE", "http://api.test/v1/apps/demo/customers/uuid"),
+        ("POST", "http://api.test/v1/apps/demo/customers"),
+        ("GET", "http://api.test/v1/apps/demo/customers/export"),
+    ]
+    assert client.calls[4][3]["json"] == {"email": "user@example.com"}
+
+
+def test_activate_app_posts_idempotency_key():
+    client = FakeClient(response(200, {"app": "demo", "tier_id": "live"}))
+    result = activate_app("http://api.test", "token", "demo", "request-1", client)
+    assert result["tier_id"] == "live"
+    assert client.calls == [("POST", "http://api.test/v1/apps/demo/activate", {
+        "Authorization": "Bearer token", "Idempotency-Key": "request-1",
+    }, {})]
+
+
+def test_activation_402_has_actionable_spending_limit_guidance():
+    client = FakeClient(response(402, {"detail": {"code": "spend_cap_exceeded"}}))
+    with pytest.raises(AppsError, match="Ask the account owner to raise the limit"):
+        activate_app("http://api.test", "token", "demo", "request-2", client)
+
+
+def test_activation_402_explains_required_spending_limit():
+    client = FakeClient(response(402, {"detail": {"code": "spend_cap_required"}}))
+    with pytest.raises(AppsError, match="Set a monthly spending limit before activating Live"):
+        activate_app("http://api.test", "token", "demo", "request-3", client)
+
+
+def test_http_errors_are_reported():
+    with pytest.raises(AppsError, match="404"):
+        list_apps("http://api.test", "token", FakeClient(response(404, {"detail": "missing"})))