Nur noch, was zum Installieren und Betreiben von TESM noetig ist

Entfernt: Tests, Architekturdokumentation und die Serverhaelfte des
Lizenzprotokolls. Beides liegt im Entwicklungsrepository alientim/TESM-DEV.

Das Lizenzprotokoll ist geteilt. TESM braucht nur die gemeinsame Haelfte
(tesm-licensing): Lizenzen verifizieren, Status bewerten, Anfragen stellen,
Antworten pruefen. Ausstellen, erneuern, Antworten signieren und
Schluesselerzeugung liegen jetzt in tesm-licensing-server und damit
ausschliesslich beim Lizenzserver -- ein Client soll den Code zum Ausstellen
nicht einmal mitbringen. Nachgeprueft: kein Modul von TESM oder tesm-core
importiert eine der verschobenen Funktionen.

install.sh installiert entsprechend je Anwendung nur die noetigen Pakete und
bricht mit klarer Meldung ab, wenn die verlangte Anwendung nicht im Baum liegt.

Co-Authored-By: Claude Opus 5 <noreply@anthropic.com>

packages/tesm-licensing/src/tesm_licensing/license.py

@@ -34,7 +34,7 @@ from dataclasses import dataclass, field
 from datetime import datetime, timedelta, timezone
 from typing import Any, Iterable, Mapping, Sequence
 
-from .canonical import SIG_CONTEXT_LICENSE, generate_keypair, sign, verify
+from .canonical import SIG_CONTEXT_LICENSE, sign, verify
 from .errors import InvalidLicenseFile, SignatureInvalid, UntrustedIssuer
 
 FORMAT_VERSION = 2
@@ -147,110 +147,10 @@ class LicenseStatus:
         return self.modules_active and name in self.modules
 
 
-def _validate_issue_args(
-    license_type: str, role: str, modules: Sequence[str], lifetime: bool
-) -> None:
-    if license_type not in LICENSE_TYPES:
-        raise ValueError(f"Unbekannter Lizenztyp: {license_type!r}")
-    if role not in LICENSE_ROLES:
-        raise ValueError(f"Unbekannte Rolle: {role!r}")
-    unknown = sorted(set(modules) - set(ALL_MODULES))
-    if unknown:
-        raise ValueError(f"Unbekannte Module: {', '.join(unknown)}")
-    if lifetime and license_type == "trial":
-        # Dritte und letzte Absicherung derselben Regel (UI + Service pruefen
-        # vorher schon): eine unbefristete Trial-Lizenz waere eine permanente
-        # Lizenz ohne Module -- ein sinnloser Zustand.
-        raise ValueError("Trial-Lizenzen koennen nicht unbefristet sein")
-    if role != "customer" and modules:
-        raise ValueError("Lizenzserver-Lizenzen tragen keine TESM-Module")
 
 
-def issue_license(
-    *,
-    customer: Mapping[str, Any],
-    license_type: str,
-    modules: Iterable[str],
-    valid_days: int,
-    master_private_key_b64: str,
-    master_public_key_b64: str,
-    master_endpoint: str,
-    vendor: Mapping[str, Any],
-    license_id: str | None = None,
-    role: str = "customer",
-    lifetime: bool = False,
-    seq: int = 1,
-    now: datetime | None = None,
-) -> tuple[dict[str, Any], str]:
-    """Stellt eine Lizenz aus.
-
-    Rueckgabe: ``(bundle, license_public_key)``. ``bundle`` ist die Datei, die
-    an den Kunden geht; ``license_public_key`` wandert in die Master-Datenbank,
-    damit der Master spaeter Client-Anfragen dieser Lizenz verifizieren kann.
-    """
-    module_list = sorted({str(m) for m in modules})
-    _validate_issue_args(license_type, role, module_list, lifetime)
-    if not lifetime and int(valid_days) <= 0:
-        raise ValueError("valid_days muss positiv sein")
-
-    moment = now or utcnow()
-    client_private, client_public = generate_keypair()
-    payload: dict[str, Any] = {
-        "fmt": FORMAT_VERSION,
-        "license_id": license_id or str(uuid.uuid4()),
-        "seq": int(seq),
-        "customer": dict(customer),
-        "type": license_type,
-        "role": role,
-        "modules": module_list,
-        "lifetime": bool(lifetime),
-        "issued_at": iso(moment),
-        "not_before": iso(moment),
-        "expires_at": LIFETIME_EXPIRES_AT
-        if lifetime
-        else iso(moment + timedelta(days=int(valid_days))),
-        "license_pubkey": client_public,
-        "master_pubkey": master_public_key_b64,
-        "master_key_id": key_id(master_public_key_b64),
-        "master_endpoint": (master_endpoint or "").rstrip("/"),
-        "vendor": dict(vendor),
-    }
-    signature = sign(payload, master_private_key_b64, SIG_CONTEXT_LICENSE)
-    document = {**payload, "signature": signature}
-    bundle = {
-        "kind": "tesm-license-bundle",
-        "fmt": FORMAT_VERSION,
-        "license": document,
-        "client_key": client_private,
-    }
-    return bundle, client_public
 
 
-def resign_license(
-    document: Mapping[str, Any],
-    *,
-    master_private_key_b64: str,
-    changes: Mapping[str, Any],
-    now: datetime | None = None,
-) -> dict[str, Any]:
-    """Erzeugt eine neu signierte Revision eines bestehenden Lizenzdokuments.
-
-    Wird fuer ``license_update`` im Heartbeat gebraucht (z. B. nachtraeglich
-    erweiterte Module oder verlaengerte Laufzeit). ``seq`` steigt dabei zwingend,
-    damit der Client eine aeltere Revision nicht als Update akzeptiert.
-    """
-    payload = {k: v for k, v in document.items() if k != "signature"}
-    payload.update(changes)
-    payload["seq"] = int(document.get("seq") or 1) + 1
-    payload["issued_at"] = iso(now or utcnow())
-    _validate_issue_args(
-        str(payload.get("type")),
-        str(payload.get("role")),
-        [str(m) for m in payload.get("modules") or ()],
-        bool(payload.get("lifetime")),
-    )
-    payload["signature"] = sign(payload, master_private_key_b64, SIG_CONTEXT_LICENSE)
-    return payload
 
 
 def split_bundle(bundle: Mapping[str, Any]) -> tuple[dict[str, Any], str]: