mcpcert-cli 0.1.0__py3-none-any.whl

mcpcert/commands/update_cmd.py

@@ -0,0 +1,96 @@
+"""`mcpcert update`. Mirrors packages/node/src/commands/update.ts."""
+
+from __future__ import annotations
+
+import os
+
+from ..api import ApiClient
+from ..args import ParsedArgs, many, one
+from ..config import discover_config, write_config
+from ..context import resolve_api_base_url
+from ..contract import promotion_url
+from ..credentials import default_credentials_path, get_identity
+from ..errors import CliError
+from ..output import Output
+
+SCALAR_FIELDS = [
+    ("client-name", "client_name"),
+    ("client-uri", "client_uri"),
+    ("logo-uri", "logo_uri"),
+    ("tos-uri", "tos_uri"),
+    ("policy-uri", "policy_uri"),
+    ("scope", "scope"),
+]
+
+
+def run(args: ParsedArgs, output: Output) -> int:
+    cwd = os.getcwd()
+    explicit_config = one(args, "config") or os.environ.get("MCPCERT_CONFIG")
+    discovered = discover_config(cwd, explicit_config)
+    if not discovered.config or not discovered.config_path or not discovered.fmt:
+        raise CliError("config_not_found", "No mcpcert development identity is configured here. Run `mcpcert init` first.")
+    config = discovered.config
+    api_base_url = resolve_api_base_url(args, config)
+
+    patch: dict[str, object] = {}
+    updated_fields: list[str] = []
+    for flag, field in SCALAR_FIELDS:
+        value = one(args, flag)
+        if value is not None:
+            patch[field] = value
+            updated_fields.append(field)
+    redirect_uris = many(args, "redirect-uri")
+    if redirect_uris is not None:
+        patch["redirect_uris"] = redirect_uris
+        updated_fields.append("redirect_uris")
+    contacts = many(args, "contact")
+    if contacts is not None:
+        patch["contacts"] = contacts
+        updated_fields.append("contacts")
+    if not updated_fields:
+        raise CliError("no_update_fields", "Nothing to update. Pass at least one mutable field, e.g. --redirect-uri or --client-name.")
+
+    creds_path = one(args, "credentials") or os.environ.get("MCPCERT_CREDENTIALS") or default_credentials_path(discovered.project_root)
+    identity = get_identity(creds_path, api_base_url, config["appname"])
+    if not identity:
+        raise CliError("claim_token_missing", "No claim token found for this identity. The token is shown once at creation and cannot be recovered.")
+
+    api = ApiClient(api_base_url)
+    updated = api.update(config["appname"], identity["claim_token"], patch)
+
+    next_config = dict(config)
+    if "client_name" in patch:
+        next_config["client_name"] = patch["client_name"]
+    if "redirect_uris" in patch:
+        next_config["redirect_uris"] = patch["redirect_uris"]
+    next_config["client_id"] = updated.get("client_id", config["client_id"])
+    next_config["document_urls"] = updated.get("document_urls", config["document_urls"])
+    next_config["expires_at"] = updated.get("expires_at", config["expires_at"])
+    write_config(discovered.config_path, discovered.fmt, next_config)
+
+    promote = promotion_url(api_base_url, config["appname"])
+    output.success(
+        "update",
+        api_base_url,
+        {
+            "appname": config["appname"],
+            "environment": "development",
+            "application_type": config["application_type"],
+            "client_name": next_config["client_name"],
+            "client_id": next_config["client_id"],
+            "document_urls": next_config["document_urls"],
+            "expires_at": next_config["expires_at"],
+            "promotion_url": promote,
+            "updated_fields": updated_fields,
+            "api_version": api.api_version,
+        },
+        [
+            "Development identity updated",
+            f"Appname:   {config['appname']}",
+            f"Client ID: {next_config['client_id']}",
+            f"Updated:   {', '.join(updated_fields)}",
+            f"Expires:   {next_config['expires_at']}",
+            f"Promote:   {promote}",
+        ],
+    )
+    return 0

mcpcert/config.py

@@ -0,0 +1,318 @@
+"""Config discovery, metadata resolution, and JSON/TOML persistence.
+
+Mirrors packages/node/src/lib/config.ts so both CLIs behave identically.
+"""
+
+from __future__ import annotations
+
+import json
+import os
+import re
+from dataclasses import dataclass
+from typing import Any
+
+from .contract import CONFIG_SCHEMA_VERSION
+from .errors import CliError
+
+try:  # Python 3.11+
+    import tomllib as _toml
+except ModuleNotFoundError:  # Python 3.10
+    import tomli as _toml  # type: ignore[no-redef]
+
+APPNAME_MAX = 63
+CONFIG_KEYS_ORDER = [
+    "schema_version",
+    "appname",
+    "environment",
+    "application_type",
+    "client_name",
+    "project_slug",
+    "redirect_uris",
+    "client_id",
+    "expires_at",
+    "api_base_url",
+]
+
+
+@dataclass
+class ResolvedConfig:
+    config: dict[str, Any] | None
+    config_path: str | None
+    fmt: str | None  # "json" | "toml"
+    project_root: str
+
+
+@dataclass
+class ResolvedMetadata:
+    client_name: str
+    project_slug: str
+
+
+def slugify(value: str) -> str:
+    slug = value.lower()
+    slug = re.sub(r"[^a-z0-9-]+", "-", slug)
+    slug = re.sub(r"-+", "-", slug)
+    slug = slug.strip("-")
+    if len(slug) > APPNAME_MAX:
+        slug = slug[:APPNAME_MAX].rstrip("-")
+    return slug or "mcp-client"
+
+
+def _walk_up(start: str) -> list[str]:
+    dirs: list[str] = []
+    current = os.path.abspath(start)
+    while True:
+        dirs.append(current)
+        parent = os.path.dirname(current)
+        if parent == current:
+            break
+        current = parent
+    return dirs
+
+
+def _read_toml(path: str) -> dict[str, Any] | None:
+    try:
+        with open(path, "rb") as handle:
+            return _toml.load(handle)
+    except (OSError, ValueError, _toml.TOMLDecodeError):  # type: ignore[attr-defined]
+        return None
+
+
+def _read_json(path: str) -> dict[str, Any] | None:
+    try:
+        with open(path, encoding="utf-8") as handle:
+            return json.load(handle)
+    except (OSError, ValueError):
+        return None
+
+
+def _pyproject_name(parsed: dict[str, Any] | None) -> str | None:
+    if not parsed:
+        return None
+    project = parsed.get("project")
+    if isinstance(project, dict) and isinstance(project.get("name"), str):
+        return project["name"]
+    poetry = parsed.get("tool", {}).get("poetry") if isinstance(parsed.get("tool"), dict) else None
+    if isinstance(poetry, dict) and isinstance(poetry.get("name"), str):
+        return poetry["name"]
+    return None
+
+
+def _package_json_name(parsed: dict[str, Any] | None) -> str | None:
+    if not parsed or not isinstance(parsed.get("name"), str):
+        return None
+    return re.sub(r"^@[^/]+/", "", parsed["name"])
+
+
+def resolve_metadata(
+    cwd: str,
+    client_name_flag: str | None,
+    project_name_flag: str | None,
+    config: dict[str, Any] | None,
+) -> ResolvedMetadata:
+    py_name: str | None = None
+    pkg_name: str | None = None
+    for directory in _walk_up(cwd):
+        py_path = os.path.join(directory, "pyproject.toml")
+        if py_name is None and os.path.exists(py_path):
+            py_name = _pyproject_name(_read_toml(py_path))
+        pkg_path = os.path.join(directory, "package.json")
+        if pkg_name is None and os.path.exists(pkg_path):
+            pkg_name = _package_json_name(_read_json(pkg_path))
+        if py_name is not None and pkg_name is not None:
+            break
+    base = (
+        (config.get("client_name") if config else None)
+        or py_name
+        or pkg_name
+        or os.path.basename(os.path.abspath(cwd))
+        or "mcp-client"
+    )
+    client_name = client_name_flag or project_name_flag or base
+    project_slug = slugify(project_name_flag or client_name_flag or base)
+    return ResolvedMetadata(client_name=client_name, project_slug=project_slug)
+
+
+def _coerce_config(raw: dict[str, Any], path: str) -> dict[str, Any]:
+    required = ["appname", "environment", "application_type", "client_name", "client_id", "api_base_url"]
+    for key in required:
+        if raw.get(key) is None:
+            raise CliError("config_invalid", f'Config at {path} is missing required field "{key}".')
+    return raw
+
+
+def _read_mcpcert_from_toml(path: str) -> dict[str, Any] | None:
+    parsed = _read_toml(path)
+    if not parsed:
+        return None
+    section = parsed.get("tool", {}).get("mcpcert") if isinstance(parsed.get("tool"), dict) else None
+    if not isinstance(section, dict):
+        return None
+    return _coerce_config(section, path)
+
+
+def discover_config(cwd: str, explicit_path: str | None = None) -> ResolvedConfig:
+    if explicit_path:
+        if explicit_path.endswith(".toml"):
+            fmt = "toml"
+        elif explicit_path.endswith(".json"):
+            fmt = "json"
+        else:
+            raise CliError("unsupported_config_path", f"--config must point to a .json or .toml file: {explicit_path}")
+        if not os.path.exists(explicit_path):
+            return ResolvedConfig(None, explicit_path, fmt, os.path.dirname(explicit_path))
+        config = _read_mcpcert_from_toml(explicit_path) if fmt == "toml" else _coerce_config(_read_json(explicit_path) or {}, explicit_path)
+        return ResolvedConfig(config, explicit_path, fmt, os.path.dirname(explicit_path))
+
+    for directory in _walk_up(cwd):
+        json_path = os.path.join(directory, "mcpcert.json")
+        toml_path = os.path.join(directory, "pyproject.toml")
+        has_json = os.path.exists(json_path)
+        toml_config = _read_mcpcert_from_toml(toml_path) if os.path.exists(toml_path) else None
+        if not has_json and not toml_config:
+            continue
+        json_config = _coerce_config(_read_json(json_path) or {}, json_path) if has_json else None
+        if json_config and toml_config:
+            if _normalize(json_config) != _normalize(toml_config):
+                raise CliError(
+                    "config_conflict",
+                    f"Both mcpcert.json and [tool.mcpcert] exist in {directory} with different values. Remove one.",
+                )
+            return ResolvedConfig(json_config, json_path, "json", directory)
+        if json_config:
+            return ResolvedConfig(json_config, json_path, "json", directory)
+        return ResolvedConfig(toml_config, toml_path, "toml", directory)
+    return ResolvedConfig(None, None, None, os.path.abspath(cwd))
+
+
+def _normalize(config: dict[str, Any]) -> dict[str, Any]:
+    keys = [
+        "appname",
+        "environment",
+        "application_type",
+        "client_name",
+        "project_slug",
+        "redirect_uris",
+        "client_id",
+        "document_urls",
+        "expires_at",
+        "api_base_url",
+    ]
+    return {key: config.get(key) for key in keys}
+
+
+def choose_write_target(project_root: str, explicit_path: str | None = None) -> tuple[str, str]:
+    if explicit_path:
+        if explicit_path.endswith(".toml"):
+            return explicit_path, "toml"
+        if explicit_path.endswith(".json"):
+            return explicit_path, "json"
+        raise CliError("unsupported_config_path", f"--config must point to a .json or .toml file: {explicit_path}")
+    pyproject = os.path.join(project_root, "pyproject.toml")
+    if os.path.exists(pyproject):
+        parsed = _read_toml(pyproject) or {}
+        if "project" in parsed or (isinstance(parsed.get("tool"), dict) and "poetry" in parsed["tool"]):
+            return pyproject, "toml"
+    return os.path.join(project_root, "mcpcert.json"), "json"
+
+
+def _order_config(config: dict[str, Any]) -> dict[str, Any]:
+    ordered = {key: config.get(key) for key in CONFIG_KEYS_ORDER}
+    ordered["document_urls"] = config.get("document_urls")
+    return ordered
+
+
+def _tstr(value: str) -> str:
+    escaped = value.replace("\\", "\\\\").replace('"', '\\"')
+    return f'"{escaped}"'
+
+
+def _serialize_mcpcert_toml(c: dict[str, Any]) -> str:
+    redirects = ", ".join(_tstr(u) for u in c["redirect_uris"])
+    docs = c["document_urls"]
+    lines = [
+        "[tool.mcpcert]",
+        f"schema_version = {c['schema_version']}",
+        f"appname = {_tstr(c['appname'])}",
+        f"environment = {_tstr(c['environment'])}",
+        f"application_type = {_tstr(c['application_type'])}",
+        f"client_name = {_tstr(c['client_name'])}",
+        f"project_slug = {_tstr(c['project_slug'])}",
+        f"redirect_uris = [{redirects}]",
+        f"client_id = {_tstr(c['client_id'])}",
+        f"expires_at = {_tstr(c['expires_at'])}",
+        f"api_base_url = {_tstr(c['api_base_url'])}",
+        "",
+        "[tool.mcpcert.document_urls]",
+        f"cimd = {_tstr(docs['cimd'])}",
+        f"aasa = {_tstr(docs['aasa'])}",
+        f"assetlinks = {_tstr(docs['assetlinks'])}",
+        "",
+    ]
+    return "\n".join(lines)
+
+
+def _strip_mcpcert_sections(text: str) -> str:
+    if not text:
+        return ""
+    out: list[str] = []
+    skipping = False
+    for line in text.split("\n"):
+        match = re.match(r"^\s*\[\s*([^\]]+?)\s*\]\s*$", line)
+        if match:
+            name = match.group(1)
+            skipping = name == "tool.mcpcert" or name.startswith("tool.mcpcert.")
+        if not skipping:
+            out.append(line)
+    joined = "\n".join(out)
+    joined = re.sub(r"\n{3,}", "\n\n", joined)
+    return joined.rstrip()
+
+
+def write_config(path: str, fmt: str, config: dict[str, Any]) -> None:
+    if fmt == "json":
+        with open(path, "w", encoding="utf-8") as handle:
+            handle.write(json.dumps(_order_config(config), indent=2) + "\n")
+        return
+    existing = ""
+    if os.path.exists(path):
+        with open(path, encoding="utf-8") as handle:
+            existing = handle.read()
+    stripped = _strip_mcpcert_sections(existing)
+    if not stripped:
+        sep = ""
+    elif stripped.endswith("\n\n"):
+        sep = ""
+    elif stripped.endswith("\n"):
+        sep = "\n"
+    else:
+        sep = "\n\n"
+    with open(path, "w", encoding="utf-8") as handle:
+        handle.write(f"{stripped}{sep}{_serialize_mcpcert_toml(config)}")
+
+
+def build_config(
+    *,
+    appname: str,
+    application_type: str,
+    client_name: str,
+    project_slug: str,
+    redirect_uris: list[str],
+    client_id: str,
+    document_urls: dict[str, str],
+    expires_at: str,
+    api_base_url: str,
+) -> dict[str, Any]:
+    return {
+        "schema_version": CONFIG_SCHEMA_VERSION,
+        "appname": appname,
+        "environment": "development",
+        "application_type": application_type,
+        "client_name": client_name,
+        "project_slug": project_slug,
+        "redirect_uris": redirect_uris,
+        "client_id": client_id,
+        "document_urls": document_urls,
+        "expires_at": expires_at,
+        "api_base_url": api_base_url,
+    }