icdev 0.0.3__py3-none-any.whl

tools/marketplace/license_client.py

@@ -0,0 +1,458 @@
+#!/usr/bin/env python3
+"""ICDEV Marketplace Thin Client — local token verification + SaaS API calls.
+
+Community-first model: 90-day free activation with unlimited renewals.
+Token verification is 100% offline using the public key.
+SaaS API calls are needed for token sync, phone-home, renewal, and feedback.
+"""
+import base64
+import json
+import logging
+import os
+from pathlib import Path
+from typing import Any, Dict, List, Optional
+
+logger = logging.getLogger("marketplace.client")
+
+MARKETPLACE_URL = os.environ.get("ICDEV_MARKETPLACE_URL", "")
+MARKETPLACE_API_KEY = os.environ.get("ICDEV_MARKETPLACE_API_KEY", "")
+PUBLIC_KEY_PATH = os.environ.get(
+    "ICDEV_MARKETPLACE_PUBLIC_KEY_PATH",
+    str(Path(__file__).resolve().parent.parent.parent / "args" / "marketplace_public_key.pem"),
+)
+
+# Phone-home toggle: env var overrides config. Default True.
+# Set ICDEV_PHONE_HOME_ENABLED=false for air-gapped / privacy-sensitive deployments.
+PHONE_HOME_ENABLED = os.environ.get("ICDEV_PHONE_HOME_ENABLED", "true").lower() not in ("false", "0", "no")
+
+
+def _validate_url(url: str) -> str:
+    """Validate marketplace URL uses HTTPS to prevent credential leakage.
+
+    Allows http:// only for localhost/127.0.0.1 (local development).
+    Raises ValueError for non-HTTPS remote URLs.
+    """
+    if not url:
+        return url
+    if url.startswith("http://localhost") or url.startswith("http://127.0.0.1"):
+        return url
+    if not url.startswith("https://"):
+        raise ValueError(
+            f"Marketplace URL must use HTTPS (got: {url[:30]}...). "
+            "Set ICDEV_MARKETPLACE_URL to an https:// URL."
+        )
+    return url
+
+
+# Graceful cryptography import
+try:
+    from cryptography.hazmat.primitives import hashes, serialization
+    from cryptography.hazmat.primitives.asymmetric import padding
+
+    HAS_CRYPTO = True
+except ImportError:
+    HAS_CRYPTO = False
+
+
+def _canonical_payload(token_data: Dict[str, Any]) -> bytes:
+    """Canonical JSON bytes — same algorithm as marketplace SaaS."""
+    payload = {k: v for k, v in token_data.items() if k != "signature"}
+    return json.dumps(payload, sort_keys=True, separators=(",", ":")).encode("utf-8")
+
+
+def verify_token_locally(
+    token_data: Dict[str, Any],
+    public_key_path: Optional[str] = None,
+    mode: Optional[str] = None,
+) -> Dict[str, Any]:
+    """Verify an RSA-signed license token using the public key (offline).
+
+    In SaaS mode, missing cryptography library rejects tokens (security-critical).
+    In OSS mode, missing cryptography is tolerated (all features unlocked anyway).
+
+    Returns: {"valid": bool, "errors": list[str]}
+    """
+    pk_path = Path(public_key_path or PUBLIC_KEY_PATH)
+    errors: List[str] = []
+
+    effective_mode = mode or os.environ.get("ICDEV_MARKETPLACE_MODE", "oss")
+
+    if not HAS_CRYPTO:
+        if effective_mode == "saas":
+            logger.error("cryptography library required in SaaS mode — cannot verify tokens")
+            return {"valid": False, "errors": ["cryptography library required in SaaS mode"]}
+        logger.warning("cryptography unavailable — signature verification skipped (OSS mode)")
+        return {"valid": True, "errors": []}
+
+    sig_b64 = token_data.get("signature")
+    if not sig_b64:
+        errors.append("Token missing 'signature' field")
+        return {"valid": False, "errors": errors}
+
+    if not pk_path.exists():
+        errors.append(f"Public key not found: {pk_path}")
+        return {"valid": False, "errors": errors}
+
+    try:
+        sig_bytes = base64.b64decode(sig_b64)
+    except Exception as exc:
+        errors.append(f"Invalid base64 signature: {exc}")
+        return {"valid": False, "errors": errors}
+
+    try:
+        with open(pk_path, "rb") as fh:
+            public_key = serialization.load_pem_public_key(fh.read())
+        public_key.verify(
+            sig_bytes,
+            _canonical_payload(token_data),
+            padding.PKCS1v15(),
+            hashes.SHA256(),
+        )
+    except Exception as exc:
+        errors.append(f"Signature verification failed: {exc}")
+
+    return {"valid": len(errors) == 0, "errors": errors}
+
+
+def sync_tokens(
+    marketplace_url: Optional[str] = None,
+    api_key: Optional[str] = None,
+    tenant_id: str = "default",
+) -> List[Dict[str, Any]]:
+    """Sync active license tokens from marketplace SaaS.
+
+    Returns list of token dicts, or empty list on failure.
+    """
+    url = marketplace_url or MARKETPLACE_URL
+    key = api_key or MARKETPLACE_API_KEY
+    if not url or not key:
+        return []
+
+    try:
+        import urllib.request
+        import urllib.error
+
+        url = _validate_url(url)
+        req = urllib.request.Request(
+            f"{url.rstrip('/')}/api/v1/licenses/sync",
+            data=json.dumps({"tenant_id": tenant_id}).encode(),
+            headers={
+                "Authorization": f"Bearer {key}",
+                "Content-Type": "application/json",
+            },
+            method="POST",
+        )
+        with urllib.request.urlopen(req, timeout=10) as resp:
+            data = json.loads(resp.read())
+            return data.get("licenses", [])
+
+    except Exception as exc:
+        logger.warning("Token sync failed: %s", exc)
+        return []
+
+
+def phone_home(
+    marketplace_url: Optional[str] = None,
+    api_key: Optional[str] = None,
+    tenant_id: str = "default",
+    license_ids: Optional[List[str]] = None,
+) -> Dict[str, Any]:
+    """Phone-home heartbeat to marketplace SaaS.
+
+    Respects ICDEV_PHONE_HOME_ENABLED env var and marketplace config.
+    When disabled, returns a skip result without making any network call.
+
+    Returns {"updated": N, "revoked": [...]} or {"error": "..."} or {"skipped": True}.
+    """
+    if not PHONE_HOME_ENABLED:
+        logger.info("Phone-home disabled by configuration")
+        return {"skipped": True, "reason": "phone_home_disabled"}
+
+    url = marketplace_url or MARKETPLACE_URL
+    key = api_key or MARKETPLACE_API_KEY
+    if not url or not key:
+        return {"error": "Marketplace URL or API key not configured"}
+
+    try:
+        import urllib.request
+
+        url = _validate_url(url)
+        req = urllib.request.Request(
+            f"{url.rstrip('/')}/api/v1/licenses/phone-home",
+            data=json.dumps({
+                "tenant_id": tenant_id,
+                "license_ids": license_ids or [],
+            }).encode(),
+            headers={
+                "Authorization": f"Bearer {key}",
+                "Content-Type": "application/json",
+            },
+            method="POST",
+        )
+        with urllib.request.urlopen(req, timeout=10) as resp:
+            return json.loads(resp.read())
+
+    except Exception as exc:
+        logger.warning("Phone-home failed: %s", exc)
+        return {"error": str(exc)}
+
+
+def renew_token(
+    slug: str,
+    marketplace_url: Optional[str] = None,
+    api_key: Optional[str] = None,
+    tenant_id: str = "default",
+    feedback: Optional[Dict[str, Any]] = None,
+    feedback_items: Optional[List[Dict[str, str]]] = None,
+    skip_feedback_gate: bool = False,
+) -> Dict[str, Any]:
+    """Renew a community activation token (90-day, unlimited renewals).
+
+    Requires 3+ validated feedback items for renewal (D-MKT-C3 v2).
+    Air-gap grace renewals bypass the feedback gate.
+
+    Args:
+        slug: Module slug to renew.
+        feedback: Legacy unstructured feedback dict (v1 compat).
+        feedback_items: Structured feedback list (v2):
+            [{"text": "...", "category": "bug|feature_request|..."}]
+        skip_feedback_gate: True for air-gap grace renewals (no feedback needed).
+
+    Returns {"token": {...}, "renewed": True} or {"error": "..."}.
+    """
+    url = marketplace_url or MARKETPLACE_URL
+    key = api_key or MARKETPLACE_API_KEY
+    if not url or not key:
+        return {"error": "Marketplace URL or API key not configured"}
+
+    # ── Feedback gate (D-MKT-C3 v2) ──────────────────────────
+    if not skip_feedback_gate and not feedback_items and not feedback:
+        return {
+            "error": "Renewal requires at least 3 meaningful feedback items. "
+            "Use feedback_items=[{text, category}, ...] or call "
+            "validate_and_renew() for the guided flow.",
+            "feedback_required": True,
+        }
+
+    # Validate structured feedback if provided
+    if feedback_items and not skip_feedback_gate:
+        from tools.marketplace.feedback_validator import (
+            validate_feedback_bundle,
+            format_feedback_for_renewal,
+        )
+
+        validation = validate_feedback_bundle(feedback_items, slug)
+        if not validation["valid"]:
+            return {
+                "error": "Feedback validation failed",
+                "validation_errors": validation["errors"],
+                "clarification_questions": validation.get("clarification_questions", []),
+                "feedback_required": True,
+            }
+
+        # Format for renewal payload
+        feedback = format_feedback_for_renewal(feedback_items)
+
+    try:
+        import urllib.request
+
+        url = _validate_url(url)
+        payload: Dict[str, Any] = {
+            "tenant_id": tenant_id,
+            "asset_slug": slug,
+        }
+        if feedback:
+            payload["feedback"] = feedback
+
+        req = urllib.request.Request(
+            f"{url.rstrip('/')}/api/v1/licenses/renew",
+            data=json.dumps(payload).encode(),
+            headers={
+                "Authorization": f"Bearer {key}",
+                "Content-Type": "application/json",
+            },
+            method="POST",
+        )
+        with urllib.request.urlopen(req, timeout=10) as resp:
+            result = json.loads(resp.read())
+
+        # Store feedback locally on success
+        if result.get("renewed") and feedback_items:
+            try:
+                from tools.marketplace.token_store import store_feedback_locally
+
+                local_entry = store_feedback_locally(slug, feedback_items, tenant_id)
+                result["feedback_stored"] = local_entry.get("id")
+            except Exception as exc:
+                logger.warning("Local feedback storage failed: %s", exc)
+
+        return result
+
+    except Exception as exc:
+        logger.warning("Token renewal failed for %s: %s", slug, exc)
+        return {"error": str(exc)}
+
+
+def validate_and_renew(
+    slug: str,
+    feedback_items: List[Dict[str, str]],
+    marketplace_url: Optional[str] = None,
+    api_key: Optional[str] = None,
+    tenant_id: str = "default",
+    run_ai_check: bool = True,
+) -> Dict[str, Any]:
+    """Full guided renewal flow: validate feedback, optionally run AI check, then renew.
+
+    This is the recommended entry point for renewal with feedback.
+
+    Returns:
+        On success: {"renewed": True, "token": {...}, "feedback_stored": "fb-xxx"}
+        On validation failure: {"error": "...", "validation_errors": [...],
+                                "clarification_questions": [...], "feedback_required": True}
+        On AI check failure: {"error": "...", "ai_results": [...], "feedback_required": True}
+    """
+    from tools.marketplace.feedback_validator import (
+        validate_feedback_bundle,
+        ai_substance_check,
+    )
+
+    # Step 1: Structural validation
+    validation = validate_feedback_bundle(feedback_items, slug)
+    if not validation["valid"]:
+        return {
+            "error": "Feedback validation failed",
+            "validation_errors": validation["errors"],
+            "clarification_questions": validation.get("clarification_questions", []),
+            "feedback_required": True,
+        }
+
+    # Step 2: AI substance check (optional, scanner-tier)
+    if run_ai_check:
+        ai_result = ai_substance_check(feedback_items, slug)
+        if not ai_result["passed"]:
+            failed = [
+                r for r in ai_result["results"] if not r.get("is_substantive", True)
+            ]
+            return {
+                "error": "Some feedback items did not pass the substance check",
+                "ai_results": failed,
+                "feedback_required": True,
+            }
+
+    # Step 3: Renew with validated feedback
+    return renew_token(
+        slug=slug,
+        marketplace_url=marketplace_url,
+        api_key=api_key,
+        tenant_id=tenant_id,
+        feedback_items=feedback_items,
+        skip_feedback_gate=False,
+    )
+
+
+def get_feedback_history(
+    slug: Optional[str] = None,
+    marketplace_url: Optional[str] = None,
+    api_key: Optional[str] = None,
+    tenant_id: str = "default",
+    local_only: bool = False,
+) -> Dict[str, Any]:
+    """Retrieve feedback history for a module.
+
+    Checks local cache first, optionally syncs with SaaS backend.
+    Returns {"history": [...], "source": "local"|"saas"|"merged"}.
+    """
+    from tools.marketplace.token_store import get_feedback_history as get_local_history
+
+    local_entries = get_local_history(slug=slug, tenant_id=tenant_id)
+
+    if local_only:
+        return {"history": local_entries, "source": "local"}
+
+    # Try to fetch from SaaS
+    url = marketplace_url or MARKETPLACE_URL
+    key = api_key or MARKETPLACE_API_KEY
+    if not url or not key:
+        return {"history": local_entries, "source": "local"}
+
+    try:
+        import urllib.request
+
+        url = _validate_url(url)
+        params = f"tenant_id={tenant_id}"
+        if slug:
+            params += f"&asset_slug={slug}"
+
+        req = urllib.request.Request(
+            f"{url.rstrip('/')}/api/v1/feedback/history?{params}",
+            headers={
+                "Authorization": f"Bearer {key}",
+                "Content-Type": "application/json",
+            },
+            method="GET",
+        )
+        with urllib.request.urlopen(req, timeout=10) as resp:
+            saas_data = json.loads(resp.read())
+            saas_entries = saas_data.get("history", [])
+
+        # Merge: SaaS is source of truth, local fills gaps
+        local_ids = {e.get("id") for e in local_entries}
+        merged = list(saas_entries)
+        for local in local_entries:
+            if local.get("id") not in {e.get("id") for e in saas_entries}:
+                merged.append(local)
+
+        merged.sort(key=lambda e: e.get("submitted_at", ""), reverse=True)
+        return {"history": merged, "source": "merged"}
+
+    except Exception as exc:
+        logger.warning("SaaS feedback history fetch failed: %s", exc)
+        return {"history": local_entries, "source": "local"}
+
+
+def submit_feedback(
+    slug: str,
+    responses: Dict[str, str],
+    marketplace_url: Optional[str] = None,
+    api_key: Optional[str] = None,
+    tenant_id: str = "default",
+) -> Dict[str, Any]:
+    """Submit feedback for a module (standalone, outside renewal flow).
+
+    Args:
+        slug: Module slug (e.g. "writeguard").
+        responses: Feedback dict, e.g.:
+            {"modules_used": "writeguard, proposalai",
+             "whats_working": "Great compliance output",
+             "feature_requests": "Add PDF export"}
+
+    Returns {"submitted": True} or {"error": "..."}.
+    """
+    url = marketplace_url or MARKETPLACE_URL
+    key = api_key or MARKETPLACE_API_KEY
+    if not url or not key:
+        return {"error": "Marketplace URL or API key not configured"}
+
+    try:
+        import urllib.request
+
+        url = _validate_url(url)
+        req = urllib.request.Request(
+            f"{url.rstrip('/')}/api/v1/feedback",
+            data=json.dumps({
+                "tenant_id": tenant_id,
+                "asset_slug": slug,
+                "responses": responses,
+            }).encode(),
+            headers={
+                "Authorization": f"Bearer {key}",
+                "Content-Type": "application/json",
+            },
+            method="POST",
+        )
+        with urllib.request.urlopen(req, timeout=10) as resp:
+            return json.loads(resp.read())
+
+    except Exception as exc:
+        logger.warning("Feedback submission failed for %s: %s", slug, exc)
+        return {"error": str(exc)}