jac-scale 0.1.3__py3-none-any.whl → 0.1.4__py3-none-any.whl

jac_scale/tests/test_serve.py

@@ -3,6 +3,9 @@
 import contextlib
 import gc
 import glob
+import hashlib
+import hmac
+import json
 import socket
 import subprocess
 import time
@@ -260,7 +263,7 @@ class TestJacScaleServe:
     def _create_expired_token(self, username: str, days_ago: int = 1) -> str:
         """Create an expired JWT token for testing."""
         # Use the same secret as the server (default)
-        secret = "supersecretkey"
+        secret = "supersecretkey_for_testing_only!"
         algorithm = "HS256"
 
         past_time = datetime.now(UTC) - timedelta(days=days_ago)
@@ -273,7 +276,7 @@ class TestJacScaleServe:
 
     def _create_very_old_token(self, username: str, days_ago: int = 15) -> str:
         """Create a token that's too old to refresh."""
-        secret = "supersecretkey"
+        secret = "supersecretkey_for_testing_only!"
         algorithm = "HS256"
 
         past_time = datetime.now(UTC) - timedelta(days=days_ago)
@@ -505,7 +508,7 @@ class TestJacScaleServe:
         new_token = refresh_result["token"]
 
         # Decode both tokens and verify username is preserved
-        secret = "supersecretkey"
+        secret = "supersecretkey_for_testing_only!"
         algorithm = "HS256"
 
         original_payload = pyjwt.decode(original_token, secret, algorithms=[algorithm])
@@ -535,7 +538,7 @@ class TestJacScaleServe:
         new_token = refresh_result["token"]
 
         # Decode tokens and compare expiration times
-        secret = "supersecretkey"
+        secret = "supersecretkey_for_testing_only!"
         algorithm = "HS256"
 
         original_payload = pyjwt.decode(original_token, secret, algorithms=[algorithm])
@@ -1561,6 +1564,356 @@ class TestJacScaleServe:
         )
         assert old_password_response.status_code == 401
 
+    # ========================================================================
+    # Webhook Walker Tests
+    # ========================================================================
+
+    def _generate_webhook_signature(self, payload: bytes, secret: str) -> str:
+        """Generate HMAC-SHA256 signature for webhook payload."""
+        return hmac.new(secret.encode("utf-8"), payload, hashlib.sha256).hexdigest()
+
+    def test_webhook_endpoint_exists_for_webhook_walkers(self) -> None:
+        """Test 1: Verify webhook endpoints are registered for walkers with @restspec(webhook=True)."""
+        response = requests.get(f"{self.base_url}/openapi.json", timeout=5)
+        assert response.status_code == 200
+        schema = response.json()
+        paths = schema.get("paths", {})
+
+        # PaymentReceived has @restspec(webhook=True) -> should have /webhook/ endpoint
+        assert "/webhook/PaymentReceived" in paths, (
+            f"Expected /webhook/PaymentReceived in paths: {list(paths.keys())}"
+        )
+        # MinimalWebhook has @restspec(webhook=True) -> should have /webhook/ endpoint
+        assert "/webhook/MinimalWebhook" in paths, (
+            f"Expected /webhook/MinimalWebhook in paths: {list(paths.keys())}"
+        )
+
+    def test_normal_walker_not_in_webhook_endpoint(self) -> None:
+        """Test 2: Verify normal walkers (without @restspec(webhook=True)) are NOT in /webhook/."""
+        response = requests.get(f"{self.base_url}/openapi.json", timeout=5)
+        assert response.status_code == 200
+        schema = response.json()
+        paths = schema.get("paths", {})
+
+        # NormalPayment does NOT have @restspec(webhook=True) -> should NOT have /webhook/ endpoint
+        assert "/webhook/NormalPayment" not in paths, (
+            "NormalPayment should NOT have webhook endpoint but found in paths"
+        )
+        # NormalPayment should be accessible via /walker/ endpoint
+        assert "/walker/NormalPayment" in paths or "/walker/{walker_name}" in paths, (
+            "NormalPayment should be accessible via /walker/ endpoint"
+        )
+
+    def test_normal_walker_accessible_via_walker_endpoint(self) -> None:
+        """Test 2b: Verify NormalPayment (no webhook restspec) works via /walker/ endpoint."""
+        # Create user and get token
+        username = f"normal_walker_user_{uuid.uuid4().hex[:8]}"
+        register_response = requests.post(
+            f"{self.base_url}/user/register",
+            json={"username": username, "password": "password123"},
+            timeout=10,
+        )
+        assert register_response.status_code == 201
+        register_data = cast(
+            dict[str, Any],
+            self._extract_transport_response_data(register_response.json()),
+        )
+        token = register_data["token"]
+
+        # Call NormalPayment via /walker/ endpoint
+        response = requests.post(
+            f"{self.base_url}/walker/NormalPayment",
+            json={
+                "payment_id": "PAY-NORMAL-001",
+                "order_id": "ORD-NORMAL-001",
+                "amount": 50.00,
+                "currency": "EUR",
+            },
+            headers={"Authorization": f"Bearer {token}"},
+            timeout=10,
+        )
+
+        assert response.status_code == 200, (
+            f"Expected 200, got {response.status_code}: {response.text}"
+        )
+        data = cast(
+            dict[str, Any], self._extract_transport_response_data(response.json())
+        )
+        assert "reports" in data
+        report = data["reports"][0]
+        assert report["status"] == "success"
+        assert report["payment_id"] == "PAY-NORMAL-001"
+        assert report["transport"] == "http"
+
+    def test_webhook_requires_api_key(self) -> None:
+        """Test that webhook endpoints require API key authentication."""
+        payload = json.dumps({})
+
+        # Try to call MinimalWebhook without API key
+        response = requests.post(
+            f"{self.base_url}/webhook/MinimalWebhook",
+            data=payload,
+            headers={"Content-Type": "application/json"},
+            timeout=5,
+        )
+
+        # Should fail - 401 (our custom error) or 422 (FastAPI validation for missing header)
+        assert response.status_code in (401, 422), (
+            f"Expected 401 or 422, got {response.status_code}: {response.text}"
+        )
+
+    def test_webhook_invalid_api_key(self) -> None:
+        """Test that webhook endpoints reject invalid API keys."""
+        payload = json.dumps({})
+
+        # Try with invalid API key
+        response = requests.post(
+            f"{self.base_url}/webhook/MinimalWebhook",
+            data=payload,
+            headers={
+                "Content-Type": "application/json",
+                "X-API-Key": "invalid_key_12345",
+            },
+            timeout=5,
+        )
+
+        # Should fail with 401 Unauthorized
+        assert response.status_code == 401, (
+            f"Expected 401, got {response.status_code}: {response.text}"
+        )
+
+    def test_minimal_webhook_with_valid_api_key(self) -> None:
+        """Test 3: MinimalWebhook (with @restspec(webhook=True)) works with valid API key."""
+        # Create user and get auth token
+        username = f"minimal_webhook_user_{uuid.uuid4().hex[:8]}"
+        register_response = requests.post(
+            f"{self.base_url}/user/register",
+            json={"username": username, "password": "password123"},
+            timeout=10,
+        )
+        assert register_response.status_code == 201
+        register_data = cast(
+            dict[str, Any],
+            self._extract_transport_response_data(register_response.json()),
+        )
+        token = register_data["token"]
+
+        # Create API key
+        api_key_response = requests.post(
+            f"{self.base_url}/api-key/create",
+            json={"name": "minimal_webhook_key", "expiry_days": 30},
+            headers={"Authorization": f"Bearer {token}"},
+            timeout=10,
+        )
+        assert api_key_response.status_code == 201, (
+            f"Failed to create API key: {api_key_response.text}"
+        )
+        api_key_data = cast(
+            dict[str, Any],
+            self._extract_transport_response_data(api_key_response.json()),
+        )
+        api_key = api_key_data["api_key"]
+
+        # Call MinimalWebhook with valid API key (empty payload - no fields required)
+        payload = json.dumps({})
+        payload_bytes = payload.encode("utf-8")
+        signature = self._generate_webhook_signature(payload_bytes, api_key)
+        response = requests.post(
+            f"{self.base_url}/webhook/MinimalWebhook",
+            data=payload,
+            headers={
+                "Content-Type": "application/json",
+                "X-API-Key": api_key,
+                "X-Webhook-Signature": signature,
+            },
+            timeout=10,
+        )
+
+        assert response.status_code == 200, (
+            f"Expected 200, got {response.status_code}: {response.text}"
+        )
+        data = cast(
+            dict[str, Any], self._extract_transport_response_data(response.json())
+        )
+        assert "reports" in data
+        assert data["reports"][0]["status"] == "received"
+        assert data["reports"][0]["transport"] == "webhook"
+
+    def test_webhook_payment_received_with_fields(self) -> None:
+        """Test 1: PaymentReceived webhook walker with multiple fields + @restspec(webhook=True)."""
+        # Create user and get API key
+        username = f"payment_user_{uuid.uuid4().hex[:8]}"
+        register_response = requests.post(
+            f"{self.base_url}/user/register",
+            json={"username": username, "password": "password123"},
+            timeout=10,
+        )
+        assert register_response.status_code == 201
+        register_data = cast(
+            dict[str, Any],
+            self._extract_transport_response_data(register_response.json()),
+        )
+        token = register_data["token"]
+
+        api_key_response = requests.post(
+            f"{self.base_url}/api-key/create",
+            json={"name": "payment_webhook_key", "expiry_days": 30},
+            headers={"Authorization": f"Bearer {token}"},
+            timeout=10,
+        )
+        assert api_key_response.status_code == 201
+        api_key_data = cast(
+            dict[str, Any],
+            self._extract_transport_response_data(api_key_response.json()),
+        )
+        api_key = api_key_data["api_key"]
+
+        # Send payment webhook
+        payload = json.dumps(
+            {
+                "payment_id": "PAY-12345",
+                "order_id": "ORD-67890",
+                "amount": 99.99,
+                "currency": "USD",
+            }
+        )
+        payload_bytes = payload.encode("utf-8")
+        signature = self._generate_webhook_signature(payload_bytes, api_key)
+
+        response = requests.post(
+            f"{self.base_url}/webhook/PaymentReceived",
+            data=payload,
+            headers={
+                "Content-Type": "application/json",
+                "X-API-Key": api_key,
+                "X-Webhook-Signature": signature,
+            },
+            timeout=10,
+        )
+
+        assert response.status_code == 200, (
+            f"Expected 200, got {response.status_code}: {response.text}"
+        )
+        data = cast(
+            dict[str, Any], self._extract_transport_response_data(response.json())
+        )
+        assert "reports" in data
+        report = data["reports"][0]
+        assert report["status"] == "success"
+        assert report["payment_id"] == "PAY-12345"
+        assert report["order_id"] == "ORD-67890"
+        assert report["amount"] == 99.99
+        assert report["currency"] == "USD"
+
+    def test_webhook_not_accessible_via_regular_walker_endpoint(self) -> None:
+        """Test that webhook walkers (with @restspec(webhook=True)) are NOT accessible via /walker/."""
+        # Create user and get token
+        username = f"webhook_path_user_{uuid.uuid4().hex[:8]}"
+        register_response = requests.post(
+            f"{self.base_url}/user/register",
+            json={"username": username, "password": "password123"},
+            timeout=10,
+        )
+        assert register_response.status_code == 201
+        register_data = cast(
+            dict[str, Any],
+            self._extract_transport_response_data(register_response.json()),
+        )
+        token = register_data["token"]
+
+        # Try to access PaymentReceived (webhook walker) via /walker/ endpoint
+        response = requests.post(
+            f"{self.base_url}/walker/PaymentReceived",
+            json={
+                "payment_id": "PAY-TEST",
+                "order_id": "ORD-TEST",
+                "amount": 10.00,
+            },
+            headers={"Authorization": f"Bearer {token}"},
+            timeout=10,
+        )
+
+        # Webhook walkers should not be accessible via /walker/ endpoint
+        # In static mode: 404 (Not Found) or 405 (Method Not Allowed - no POST registered)
+        # In dynamic mode: 400 (Bad Request - explicitly rejected)
+        assert response.status_code in (400, 404, 405), (
+            f"Expected 400/404/405, got {response.status_code}: {response.text}"
+        )
+
+    def test_webhook_revoked_api_key(self) -> None:
+        """Test that revoked API keys are rejected."""
+        # Create user and get auth token
+        username = f"webhook_revoke_user_{uuid.uuid4().hex[:8]}"
+        register_response = requests.post(
+            f"{self.base_url}/user/register",
+            json={"username": username, "password": "password123"},
+            timeout=10,
+        )
+        assert register_response.status_code == 201
+        register_data = cast(
+            dict[str, Any],
+            self._extract_transport_response_data(register_response.json()),
+        )
+        token = register_data["token"]
+
+        # Create API key
+        api_key_response = requests.post(
+            f"{self.base_url}/api-key/create",
+            json={"name": "key_to_revoke", "expiry_days": 30},
+            headers={"Authorization": f"Bearer {token}"},
+            timeout=10,
+        )
+        assert api_key_response.status_code == 201
+        api_key_data = cast(
+            dict[str, Any],
+            self._extract_transport_response_data(api_key_response.json()),
+        )
+        api_key = api_key_data["api_key"]
+        api_key_id = api_key_data["api_key_id"]
+
+        # Verify API key works with MinimalWebhook
+        payload = json.dumps({})
+        payload_bytes = payload.encode("utf-8")
+        signature = self._generate_webhook_signature(payload_bytes, api_key)
+        response = requests.post(
+            f"{self.base_url}/webhook/MinimalWebhook",
+            data=payload,
+            headers={
+                "Content-Type": "application/json",
+                "X-API-Key": api_key,
+                "X-Webhook-Signature": signature,
+            },
+            timeout=10,
+        )
+        assert response.status_code == 200
+
+        # Revoke the API key
+        revoke_response = requests.delete(
+            f"{self.base_url}/api-key/{api_key_id}",
+            headers={"Authorization": f"Bearer {token}"},
+            timeout=10,
+        )
+        assert revoke_response.status_code == 200, (
+            f"Failed to revoke key: {revoke_response.text}"
+        )
+
+        # Try to use revoked key (same payload and signature)
+        response = requests.post(
+            f"{self.base_url}/webhook/MinimalWebhook",
+            data=payload,
+            headers={
+                "Content-Type": "application/json",
+                "X-API-Key": api_key,
+                "X-Webhook-Signature": signature,
+            },
+            timeout=10,
+        )
+
+        # Should fail with 401
+        assert response.status_code == 401, (
+            f"Expected 401 for revoked key, got {response.status_code}: {response.text}"
+        )
+
 
 class TestJacScaleServeDevMode:
     """Test jac-scale serve with --dev mode (dynamic routing).

jac_scale/webhook.jac

@@ -0,0 +1,93 @@
+"""Webhook support for Jac Scale.
+
+This module provides webhook-related functionality including:
+- API key generation and management
+- HMAC-SHA256 signature verification for webhook security
+- Webhook configuration and utilities
+
+API keys are generated per-user and can be used to authenticate webhook calls.
+The API key is wrapped in a JWT for secure storage and validation.
+"""
+import hmac;
+import hashlib;
+import secrets;
+import jwt;
+import from datetime { UTC, datetime, timedelta }
+import from typing { Any }
+import from pydantic { BaseModel, Field }
+import from jaclang.runtimelib.transport { TransportResponse, Meta }
+import from jac_scale.config_loader { get_scale_config }
+
+# Load webhook configuration
+glob _webhook_config = get_scale_config().get_webhook_config(),
+     WEBHOOK_SECRET = _webhook_config['secret'],
+     WEBHOOK_SIGNATURE_HEADER = _webhook_config['signature_header'],
+     WEBHOOK_VERIFY_SIGNATURE = _webhook_config['verify_signature'],
+     WEBHOOK_API_KEY_EXPIRY_DAYS = _webhook_config['api_key_expiry_days'];
+
+"""Pydantic model for API key creation request."""
+class CreateApiKeyRequest(BaseModel) {
+    has name: str = Field(..., description='A friendly name for the API key'),
+        expiry_days: int | None = Field(
+            None, description='Number of days until expiry (default from config)'
+        );
+}
+
+"""Pydantic model for API key response."""
+class ApiKeyResponse(BaseModel) {
+    has api_key: str = Field(..., description='The generated API key'),
+        api_key_id: str = Field(..., description='Unique identifier for the API key'),
+        name: str = Field(..., description='Friendly name for the API key'),
+        created_at: str = Field(..., description='ISO timestamp of creation'),
+        expires_at: str | None = Field(
+            None, description='ISO timestamp of expiry, or null if no expiry'
+        );
+}
+
+"""Webhook utilities for signature generation and verification."""
+obj WebhookUtils {
+    """Generate HMAC-SHA256 signature for webhook payload."""
+    static def generate_signature(payload: bytes, secret: str) -> str;
+
+    """Verify HMAC-SHA256 signature for webhook payload."""
+    static def verify_signature(payload: bytes, signature: str, secret: str) -> bool;
+
+    """Generate a new API key."""
+    static def generate_api_key -> str;
+
+    """Create a JWT-wrapped API key token.
+
+    The API key is embedded in a JWT for secure validation and expiry management."""
+    static def create_api_key_token(
+        api_key_id: str, username: str, name: str, expiry_days: int | None = None
+    ) -> str;
+
+    """Validate an API key token and extract user information."""
+    static def validate_api_key(api_key: str) -> dict[str, str] | None;
+
+    """Extract signature from request header value."""
+    static def extract_signature(header_value: str) -> str;
+}
+
+"""Manager for API keys associated with users."""
+obj ApiKeyManager {
+    has _api_keys: dict[str, dict[str, Any]] = {},  # api_key_id -> key info
+        _user_keys: dict[str, list[str]] = {};  # username -> list of api_key_ids
+
+    """Create a new API key for a user."""
+    def create_api_key(
+        username: str, name: str, expiry_days: int | None = None
+    ) -> TransportResponse;
+
+    """List all API keys for a user."""
+    def list_api_keys(username: str) -> TransportResponse;
+
+    """Revoke an API key."""
+    def revoke_api_key(username: str, api_key_id: str) -> TransportResponse;
+
+    """Validate an API key and return the associated username."""
+    def validate_api_key(api_key: str) -> str | None;
+
+    """Check if an API key ID exists and is not revoked."""
+    def is_key_active(api_key_id: str) -> bool;
+}

{jac_scale-0.1.3.dist-info → jac_scale-0.1.4.dist-info}/METADATA

@@ -1,10 +1,10 @@
 Metadata-Version: 2.4
 Name: jac-scale
-Version: 0.1.3
+Version: 0.1.4
 Author-email: Jason Mars <jason@mars.ninja>
 Requires-Python: >=3.12
 Description-Content-Type: text/markdown
-Requires-Dist: jaclang>=0.9.12
+Requires-Dist: jaclang>=0.9.13
 Requires-Dist: python-dotenv<2.0.0,>=1.2.1
 Requires-Dist: docker<8.0.0,>=7.1.0
 Requires-Dist: kubernetes<35.0.0,>=34.1.0
@@ -12,7 +12,7 @@ Requires-Dist: pymongo<5.0.0,>=4.15.4
 Requires-Dist: redis<8.0.0,>=7.1.0
 Requires-Dist: fastapi<0.122.0,>=0.121.3
 Requires-Dist: uvicorn<0.39.0,>=0.38.0
-Requires-Dist: pyjwt
+Requires-Dist: pyjwt<2.11.0,>=2.10.1
 Requires-Dist: fastapi-sso<1.0.0,>=0.18.0
 Requires-Dist: python-multipart<1.0.0,>=0.0.21
 
@@ -491,7 +491,7 @@ async walker FetchData {
 | `MONGODB_URI` | URL of MongoDB database | - |
 | `REDIS_URL` | URL of Redis database | - |
 | `JWT_EXP_DELTA_DAYS` | Number of days until JWT token expires | `7` |
-| `JWT_SECRET` | Secret key used for JWT token signing and verification | `'supersecretkey'` |
+| `JWT_SECRET` | Secret key used for JWT token signing and verification | `'supersecretkey_for_testing_only!'` |
 | `JWT_ALGORITHM` | Algorithm used for JWT token encoding/decoding | `'HS256'` |
 | `SSO_HOST` | SSO host URL | `'http://localhost:8000/sso'` |
 | `SSO_GOOGLE_CLIENT_ID` | Google OAuth client ID | - |

{jac_scale-0.1.3.dist-info → jac_scale-0.1.4.dist-info}/RECORD

@@ -1,14 +1,15 @@
 jac_scale/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-jac_scale/config_loader.jac,sha256=oOOOFcFfEP89Y3A-AI4cLqrEaO6g0jJqZglBsCoKM84,1222
+jac_scale/config_loader.jac,sha256=fG1dN9AS54bzNL5XvPHNS4oMw8kknZnlAZ7ByPT0APU,1298
 jac_scale/context.jac,sha256=SIqQineAlLHJV3yWtYkeTIfcnqS0Oj15n8CWVSIqwJ8,529
 jac_scale/google_sso_provider.jac,sha256=UUTDgQrBHXp0eqHxiw7v_VkQyFMMza0UDM6S4T5e4OM,2473
 jac_scale/memory_hierarchy.jac,sha256=GuydhwujsH71TAkxeJ6Wfutp4v6GjDj23vGMreRj4yg,4533
 jac_scale/plugin.jac,sha256=E1Ou_sQ8RV35emY9-gM295Uu-Eg4w4qSEJYm3TTYsWY,9585
-jac_scale/plugin_config.jac,sha256=Gxvyy8V0uP1I4XARfHaHqoz0oeZ0LbHibri3gi5Odp8,8700
-jac_scale/serve.jac,sha256=IU1a6ijW19FCBx53P_d-fzgukuZzS6MDTdazkhbtuzQ,4430
+jac_scale/plugin_config.jac,sha256=6_cTMzjDhr-7fGh2RMM5LCfjXlfKduGyFs0S0PnHKXQ,8718
+jac_scale/serve.jac,sha256=8xMOHX3X-sJFx6yENolL-7VM7Km1Mg5BPkUtMLUl9O4,5546
 jac_scale/sso_provider.jac,sha256=Kky8cxm5gR2Sbg-CFrWTILKSZrV6Ju-DCEgfG4Akxb8,2092
 jac_scale/user_manager.jac,sha256=UBApt_znhVEyxtfAdJ9sp_gslkHel4GGwXCBcNen_as,1932
 jac_scale/utils.jac,sha256=zpxA08_NlDDSd1oVlbknQ_UOwHWGBbhzjmT_u6UYN04,491
+jac_scale/webhook.jac,sha256=lTpevPoe-CEcj0-MAd8c1fHK7jGUL3YnN4_ouMeq4Ic,3660
 jac_scale/abstractions/database_provider.jac,sha256=NZbFmcESulYsmG-27f8GY9nxVs3JflGIEb3aDDOIPu0,1454
 jac_scale/abstractions/deployment_target.jac,sha256=5rJOd25FUXZZCNmDSUkyMljcXTAVJJDmelKw8WdPZm0,2071
 jac_scale/abstractions/image_registry.jac,sha256=UCOwwuts5e1emsdDIlHJOiyW2ePA7k7D8UJdzd2kN10,1386
@@ -22,17 +23,18 @@ jac_scale/factories/deployment_factory.jac,sha256=1pzQ2HkqpKaeoycbRxdZ05McgTLpgj
 jac_scale/factories/registry_factory.jac,sha256=qWgwEH75EtjXGj3d9NGeg7D9Yx2S_RW9udlCFvOOCqU,1210
 jac_scale/factories/storage_factory.jac,sha256=FVlx-f1BOq6H1yLWXT7OLSG-ZCENvlBPNr0OwFdo-VU,2661
 jac_scale/factories/utility_factory.jac,sha256=64gMv_N_pFeq5E7z3gXrLIqeRGS_RGIF5eLT8RxNl_I,1262
-jac_scale/impl/config_loader.impl.jac,sha256=j8YngI4mdcBKCBtly-8vN0WYXDwzdhwZ6bmmMc9Kza4,4769
-jac_scale/impl/context.impl.jac,sha256=D8B7K-Y1VdbqBfGjYtGA5BDBiizlL8MmvAqxO8xMLwE,1106
+jac_scale/impl/config_loader.impl.jac,sha256=gIcOowYuoMvpilRK6vhAGf5ULYttrkh19fB5zP7KTdI,5668
+jac_scale/impl/context.impl.jac,sha256=3M33iA9L2SCIMT0rQTvb8MkveNCuTEjc7rNknK4Hruk,1071
 jac_scale/impl/memory_hierarchy.main.impl.jac,sha256=Jc4Cy-5cy0TtK2uQ6rdYruxa0ZfZKSYgo3jOoXv4ER4,2339
 jac_scale/impl/memory_hierarchy.mongo.impl.jac,sha256=APh7YloOj7bWGtv6DTBm7ekX13w_fectbZiFY0btwWU,6626
 jac_scale/impl/memory_hierarchy.redis.impl.jac,sha256=x27TzeBI87vz72s7esQvFz8EPk3EfhVMNKU8sP4s2hk,4900
-jac_scale/impl/serve.impl.jac,sha256=UX7GIoB27kHeyq1JxtkM4CYC1BnhGpipCu0qOGaePRM,61376
+jac_scale/impl/serve.impl.jac,sha256=zzWAF0PukDMdKKFmiwP-cupxrCA8YtZ_leYY-Qzcnkc,85767
 jac_scale/impl/user_manager.impl.jac,sha256=7xGoLMweQuoVW-na7XbK3bctfUHaSEnT9nB7DLgSlgw,11817
+jac_scale/impl/webhook.impl.jac,sha256=87IZn9nfSaNXX9RYXVJRJEz-3xzznpC6RhVBoJJA2X8,7504
 jac_scale/jserver/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 jac_scale/jserver/jfast_api.jac,sha256=Ez7EZ883TS9IIACzK8QMqTgVTtNoaOenbmwNKnekBuc,5561
 jac_scale/jserver/jserver.jac,sha256=8gWh22nX9Z5rJp3D1AxOSU8lBhoX4-kBZ0uvJPPNqX8,3356
-jac_scale/jserver/impl/jfast_api.impl.jac,sha256=fJZDFKbFYhpYqIcauPNPd5tpRHx_Xd1DXo49-vTSXQA,26766
+jac_scale/jserver/impl/jfast_api.impl.jac,sha256=bnxoReOOntQL0FHDgLSoaXtQRtCYOOEVWhq-lAXeqI0,26931
 jac_scale/jserver/impl/jserver.impl.jac,sha256=4NOzfys4WQmGt6vttTTh6By12hEJqdvOzCZyCBsUQKk,2224
 jac_scale/providers/database/kubernetes_mongo.jac,sha256=nP43b-ePR8XInhhk7gzdvJvOJMZcTZanm1VALdiCqXA,4952
 jac_scale/providers/database/kubernetes_redis.jac,sha256=qF9HkNLLgiymxiCXbmETbVVDs5Wqs1m4s3O6xFR7jRA,3778
@@ -51,18 +53,18 @@ jac_scale/tests/test_file_upload.py,sha256=JooF-9rgwOqtNkWRfvfHu4W5x-gzk91bHVi13
 jac_scale/tests/test_hooks.py,sha256=TzikM6dd1uKg1G2L1MtgXYzzjY6YhrbAQXZah-TO33Y,1366
 jac_scale/tests/test_k8s_utils.py,sha256=Oqocwl4m2IFgM27Lgsi96WJeHS8hnx9WDOcxq9YkqJU,4613
 jac_scale/tests/test_memory_hierarchy.py,sha256=q_DsKyPIuQymab_sEtXojDW0GOyunRxZJsNTJDrGA7s,8324
-jac_scale/tests/test_restspec.py,sha256=ynkDlu9mHl98hUL49UYwcJNXbsLhBd8yPL9TTw12xN0,6582
-jac_scale/tests/test_serve.py,sha256=LsLgGGS5_52wtB0EyBEsIzX6KwIQ4m5hTVoOq3dYnWc,67299
+jac_scale/tests/test_restspec.py,sha256=fYNpQi7ZhV7KnSoJQ4xH1tJIQeayaeCvFS5GBLAZO1o,10853
+jac_scale/tests/test_serve.py,sha256=xKPjQJLdtWaCISlP3Kirf3A4i1Fxubej_h5oLklKSY8,81244
 jac_scale/tests/test_sso.py,sha256=9h2AUC9JBM74O6xfpyIcl98iXyZWcDIGdKRtlb_5uqo,28104
 jac_scale/tests/test_storage.py,sha256=Y7CIbKrH3OmJQlBeV9A965-7TtxL6nuZtfkfoeqIeS4,10514
-jac_scale/tests/fixtures/test_api.jac,sha256=78tw_0lFR2k7uI0nrU_e8fdJJOcOG2z0J5C47MQ42DU,4744
-jac_scale/tests/fixtures/test_restspec.jac,sha256=bE8-7qyDXkNGGhv0HqQCKFpLWCDa5ciRzrJS-bkqWDo,1173
+jac_scale/tests/fixtures/test_api.jac,sha256=aqfvy4wgc0qPTM9_NYvXUcpemNTSdwW0tp432sdHZI4,6680
+jac_scale/tests/fixtures/test_restspec.jac,sha256=oFqACGtuoGz1xsURAaeXrQe7hkMI-W8hL5IKFDTQHKU,2511
 jac_scale/tests/fixtures/todo_app.jac,sha256=beI6AiRutmXsXxuzU9nIZTE-AuoBBP-WqbRA2ux1pN4,1216
 jac_scale/tests/fixtures/scale-feats/main.jac,sha256=QN8Opodha9jLWdRGCASByIogePr1XKphgKjyE9Pp73c,4205
 jac_scale/tests/fixtures/scale-feats/components/Button.cl.jac,sha256=e8tvNzW_QikFJMSTcbkziKP69NF00DqQVxcjLPkAW-w,903
 jac_scale/utilities/loggers/standard_logger.jac,sha256=6XL5ETAOBwbsFCOp0VN_7TOnqcQDmbLZVzubA-JR3vA,1376
-jac_scale-0.1.3.dist-info/METADATA,sha256=zRQUUOCa0B6p2qC4Fo-sptUZbayDW85aS51iX1SvSI4,20457
-jac_scale-0.1.3.dist-info/WHEEL,sha256=wUyA8OaulRlbfwMtmQsvNngGrxQHAvkKcvRmdizlJi0,92
-jac_scale-0.1.3.dist-info/entry_points.txt,sha256=n-Wm8JEtGOqy_IY_kgIOi3-uYnuVK-iWsvKiLkxlG4E,105
-jac_scale-0.1.3.dist-info/top_level.txt,sha256=PpgR0R8z9qoFbSser2K20r5Is4K6TxVwguoN6LfTEKU,10
-jac_scale-0.1.3.dist-info/RECORD,,
+jac_scale-0.1.4.dist-info/METADATA,sha256=F_sIgqYZVaPGz7cPpx-Sc-EqI0cNX43nEkFWQiUjU5w,20491
+jac_scale-0.1.4.dist-info/WHEEL,sha256=wUyA8OaulRlbfwMtmQsvNngGrxQHAvkKcvRmdizlJi0,92
+jac_scale-0.1.4.dist-info/entry_points.txt,sha256=n-Wm8JEtGOqy_IY_kgIOi3-uYnuVK-iWsvKiLkxlG4E,105
+jac_scale-0.1.4.dist-info/top_level.txt,sha256=PpgR0R8z9qoFbSser2K20r5Is4K6TxVwguoN6LfTEKU,10
+jac_scale-0.1.4.dist-info/RECORD,,