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

jac_scale/plugin_config.jac

@@ -34,7 +34,7 @@ class JacScalePluginConfig {
                     "nested": {
                         "secret": {
                             "type": "string",
-                            "default": "supersecretkey",
+                            "default": "supersecretkey_for_testing_only!",
                             "description": "Secret key for JWT signing"
                         },
                         "algorithm": {
@@ -149,6 +149,33 @@ class JacScalePluginConfig {
                             "type": "bool",
                             "default": True,
                             "description": "Enable Redis deployment in Kubernetes"
+                        },
+                        "plugin_versions": {
+                            "type": "dict",
+                            "default": {},
+                            "description": "Package versions for PyPI installation (default mode). Use 'latest' or specific version.",
+                            "nested": {
+                                "jaclang": {
+                                    "type": "string",
+                                    "default": "latest",
+                                    "description": "jaclang package version"
+                                },
+                                "jac_scale": {
+                                    "type": "string",
+                                    "default": "latest",
+                                    "description": "jac-scale package version"
+                                },
+                                "jac_client": {
+                                    "type": "string",
+                                    "default": "latest",
+                                    "description": "jac-client package version"
+                                },
+                                "jac_byllm": {
+                                    "type": "string",
+                                    "default": "latest",
+                                    "description": "jac-byllm package version (use 'none' to skip)"
+                                }
+                            }
                         }
                     }
                 },

jac_scale/serve.jac

@@ -6,7 +6,9 @@ import from pathlib { Path }
 import from pydantic { BaseModel, Field }
 import from typing { Any }
 import jwt;
+import json;
 import from os { getenv }
+import from fastapi { Request }
 import from fastapi.middleware.cors { CORSMiddleware }
 import from fastapi.responses { HTMLResponse, JSONResponse, Response, RedirectResponse }
 import from jac_scale.jserver.jfast_api { JFastApiServer }
@@ -24,6 +26,10 @@ import from enum { StrEnum }
 import from fastapi_sso.sso.google { GoogleSSO }
 import from jac_scale.utils { generate_random_password }
 import from jac_scale.config_loader { get_scale_config }
+import from jac_scale.webhook { ApiKeyManager, WebhookUtils }
+import from typing { AsyncGenerator }
+import from inspect { isgenerator }
+import from fastapi.responses { StreamingResponse }
 
 # Load configuration from jac.toml with env var overrides
 glob _jwt_config = get_scale_config().get_jwt_config(),
@@ -38,14 +44,14 @@ enum Platforms ( StrEnum ) { GOOGLE = 'google' }
 
 enum Operations ( StrEnum ) { LOGIN = 'login', REGISTER = 'register' }
 
+enum TransportType ( StrEnum ) { HTTP = 'http', WEBHOOK = 'webhook' }
+
 obj JacAPIServer(JServer) {
     # HMR (Hot Module Replacement) support fields
     has _hmr_pending: bool = False,
-        _hot_reloader: Any | None = None;
+        _hot_reloader: Any | None = None,
+        _api_key_manager: ApiKeyManager | None = None;
 
-    static def create_jwt_token(username: str) -> str;
-    static def validate_jwt_token(token: str) -> (str | None);
-    static def refresh_jwt_token(token: str) -> (str | None);
     def postinit -> None;
     def login(username: str, password: str) -> TransportResponse;
     def register_login_endpoint -> None;
@@ -66,27 +72,21 @@ obj JacAPIServer(JServer) {
     def refresh_token(token: (str | None) = None) -> TransportResponse;
     def register_create_user_endpoint -> None;
     def register_refresh_token_endpoint -> None;
-    def get_sso(platform: str, operation: str) -> (GoogleSSO | None);
-    async def sso_initiate(
-        platform: str, operation: str
-    ) -> (Response | TransportResponse);
-
-    async def sso_callback(
-        request: Request, platform: str, operation: str
-    ) -> TransportResponse;
-
     def register_sso_endpoints -> None;
     def create_walker_callback(
         walker_name: str, has_node_param: bool = False
     ) -> Callable[..., TransportResponse];
 
     def create_walker_parameters(
-        walker_name: str, invoke_on_root: bool
+        walker_name: str, invoke_on_root: bool, method: HTTPMethod = HTTPMethod.POST
     ) -> list[APIParameter];
 
     def register_walkers_endpoints -> None;
     def create_function_callback(func_name: str) -> Callable[..., TransportResponse];
-    def create_function_parameters(func_name: str) -> list[APIParameter];
+    def create_function_parameters(
+        func_name: str, method: HTTPMethod = HTTPMethod.POST
+    ) -> list[APIParameter];
+
     def register_functions_endpoints -> None;
     def render_page_callback -> Callable[..., HTMLResponse];
     def render_base_route_callback(app_name: str) -> Callable[..., HTMLResponse];
@@ -98,12 +98,29 @@ obj JacAPIServer(JServer) {
     def register_root_asset_endpoint -> None;
     def serve_root_asset(file_path: str) -> Response;
     def _configure_openapi_security -> None;
-    def start(dev: bool = False) -> None;
+    def start(dev: bool = False, no_client: bool = False) -> None;
     # HMR (Hot Module Replacement) dynamic routing methods
     def enable_hmr(hot_reloader: Any) -> None;
     def register_dynamic_walker_endpoint -> None;
     def register_dynamic_function_endpoint -> None;
     def register_dynamic_introspection_endpoints -> None;
+    # Webhook support methods
+    def get_api_key_manager -> ApiKeyManager;
+    def create_api_key(
+        name: str, expiry_days: int | None = None, Authorization: str | None = None
+    ) -> TransportResponse;
+
+    def list_api_keys(Authorization: str | None = None) -> TransportResponse;
+    def revoke_api_key(
+        api_key_id: str, Authorization: str | None = None
+    ) -> TransportResponse;
+
+    def register_api_key_endpoints -> None;
+    def register_webhook_endpoints -> None;
+    def create_webhook_callback(walker_name: str) -> Callable[..., TransportResponse];
+    def create_webhook_parameters(walker_name: str) -> list[APIParameter];
+    def register_dynamic_webhook_endpoint -> None;
+    def get_transport_type_for_walker(walker_name: str) -> str;
 }
 
 class UpdateUsernameRequest(BaseModel) {

jac_scale/sso_provider.jac

@@ -0,0 +1,72 @@
+"""SSO Provider Abstraction for jac-scale.
+
+This module defines the abstract interface for SSO providers, enabling
+easy addition of new authentication vendors (Google, Microsoft, GitHub, SAML, etc.).
+"""
+
+import from typing { Any }
+import from fastapi { Request, Response }
+import from dataclasses { dataclass }
+
+"""Standardized user information from SSO providers."""
+@dataclass
+class SSOUserInfo {
+    has email: str,
+        external_id: str,
+        platform: str,
+        display_name: (str | None) = None;
+}
+
+"""Abstract base class for SSO providers.
+
+All SSO provider implementations must inherit from this class and implement
+the required methods. This abstraction enables:
+
+1. Consistent interface across all SSO vendors
+2. Easy addition of new providers (just implement this interface)
+3. Testability through mock implementations
+4. Standardized user information format
+
+Example:
+    To add a new SSO provider (e.g., Microsoft):
+
+    ```jac
+    obj MicrosoftSSOProvider(SSOProvider) {
+        # Implement the three required methods
+        async def initiate_auth(operation: str) -> Response;
+        async def handle_callback(request: Request) -> SSOUserInfo;
+        def get_platform_name() -> str;
+    }
+    ```
+"""
+obj SSOProvider {
+    """Initialize SSO authentication flow.
+
+    Args:
+        operation: The operation type ('login' or 'register')
+
+    Returns:
+        Response object (typically a redirect to the SSO provider's auth page)
+    """
+    async def initiate_auth(operation: str) -> Response;
+
+    """Handle the OAuth callback from the SSO provider.
+
+    Args:
+        request: The FastAPI request object containing the OAuth callback data
+
+    Returns:
+        SSOUserInfo: Standardized user information from the provider
+
+    Raises:
+        Exception: If authentication fails or user info cannot be retrieved
+    """
+    async def handle_callback(request: Request) -> SSOUserInfo;
+
+    """Get the platform identifier for this provider.
+
+    Returns:
+        str: Platform name (e.g., 'google', 'microsoft', 'github')
+    """
+    def get_platform_name -> str;
+}

jac_scale/targets/kubernetes/kubernetes_config.jac

@@ -34,12 +34,12 @@ class KubernetesConfig(BaseConfig) {
         app_mount_path: str = '/app',
         code_mount_path: str = '/code',
         workspace_path: str = '/code/workspace',
-        # Runtime environment (defaults to official Jaseci repo)
         jaseci_repo_url: str = 'https://github.com/jaseci-labs/jaseci.git',
         jaseci_branch: str = 'main',
         jaseci_commit: (str | None) = None,
         install_jaseci: bool = True,
-        additional_packages: list[str] = [];
+        additional_packages: list[str] = [],
+        plugin_versions: dict[str, str] = {};
 
     def init(
         self: KubernetesConfig,
@@ -75,12 +75,8 @@ class KubernetesConfig(BaseConfig) {
         jaseci_branch: str = 'main',
         jaseci_commit: (str | None) = None,
         install_jaseci: bool = True,
-        additional_packages: list[str] = []
-        # Runtime configuration
-        # Storage configuration
-        # Timing configuration
-        # Paths
-        # Runtime environment
+        additional_packages: list[str] = [],
+        plugin_versions: dict[str, str] = {}
     ) -> None {
         self.app_name = app_name;
         self.namespace = namespace;
@@ -121,6 +117,7 @@ class KubernetesConfig(BaseConfig) {
         self.jaseci_commit = jaseci_commit;
         self.install_jaseci = install_jaseci;
         self.additional_packages = additional_packages;
+        self.plugin_versions = plugin_versions;
     }
 
     override def to_dict(self: KubernetesConfig) -> dict[str, Any] {
@@ -162,7 +159,8 @@ class KubernetesConfig(BaseConfig) {
                 'jaseci_branch': self.jaseci_branch,
                 'jaseci_commit': self.jaseci_commit,
                 'install_jaseci': self.install_jaseci,
-                'additional_packages': self.additional_packages
+                'additional_packages': self.additional_packages,
+                'plugin_versions': self.plugin_versions
             }
         );
         return base;
@@ -204,12 +202,8 @@ class KubernetesConfig(BaseConfig) {
             jaseci_branch=config.get('jaseci_branch', 'main'),
             jaseci_commit=config.get('jaseci_commit'),
             install_jaseci=config.get('install_jaseci', True),
-            additional_packages=config.get('additional_packages', [])
-            # Runtime configuration
-            # Storage configuration
-            # Timing configuration
-            # Paths
-            # Runtime environment
+            additional_packages=config.get('additional_packages', []),
+            plugin_versions=config.get('plugin_versions', {})
         );
     }
 }

jac_scale/targets/kubernetes/kubernetes_target.jac

@@ -174,10 +174,7 @@ class KubernetesTarget(DeploymentTarget) {
         return service;
     }
 
-    """Build the bash command for setting up Jaseci runtime environment.
-
-    This replaces the hard-coded command with a configurable version.
-    """
+    """Build the bash command for setting up Jaseci runtime environment."""
     def _build_runtime_setup_command(
         self: KubernetesTarget, app_config: AppConfig
     ) -> list[str] {
@@ -188,36 +185,61 @@ class KubernetesTarget(DeploymentTarget) {
         commands.append('export DEBIAN_FRONTEND=noninteractive');
         commands.append('apt-get update');
 
-        # Install base packages
-        base_packages = ['git', 'npm', 'nodejs'];
+        # Install base packages (curl and unzip needed for Bun installation)
+        base_packages = ['git', 'curl', 'unzip'];
         if config.additional_packages {
             base_packages.extend(config.additional_packages);
         }
         commands.append(f"apt-get install -y {' '.join(base_packages)}");
 
-        # Clone and setup Jaseci if enabled
-        if config.install_jaseci {
+        # Install Bun (required for jac-client frontend builds)
+        commands.append('curl -fsSL https://bun.sh/install | bash');
+        commands.append('export BUN_INSTALL="$HOME/.bun"');
+        commands.append('export PATH="$BUN_INSTALL/bin:$PATH"');
+
+        if app_config.experimental {
             commands.append('rm -rf jaseci');
-            # Clone repository
             clone_cmd = f"git clone --branch {config.jaseci_branch} --single-branch {config.jaseci_repo_url}";
             commands.append(clone_cmd);
             commands.append('cd ./jaseci');
-            # Checkout specific commit if provided
             if config.jaseci_commit {
                 commands.append(f"git checkout {config.jaseci_commit}");
             }
-            # Update submodules
             commands.append('git submodule update --init --recursive');
-            # Setup virtual environment
-            commands.append('python -m venv venv');
-            commands.append('source venv/bin/activate');
-            # Install Jaseci components
             commands.append('pip install pluggy');
             commands.append('pip install -e ./jac');
             commands.append('pip install -e ./jac-scale');
             commands.append('pip install -e ./jac-client');
             commands.append('pip install -e ./jac-byllm');
             commands.append('cd ..');
+        } else {
+            packages = config.plugin_versions or {};
+            jaclang_v = packages.get('jaclang', 'latest');
+            scale_v = packages.get('jac_scale', 'latest');
+            client_v = packages.get('jac_client', 'latest');
+            byllm_v = packages.get('jac_byllm', 'latest');
+            if jaclang_v == 'latest' {
+                commands.append('pip install jaclang');
+            } else {
+                commands.append(f'pip install jaclang=={jaclang_v}');
+            }
+            if scale_v == 'latest' {
+                commands.append('pip install jac-scale');
+            } else {
+                commands.append(f'pip install jac-scale=={scale_v}');
+            }
+            if client_v == 'latest' {
+                commands.append('pip install jac-client');
+            } else {
+                commands.append(f'pip install jac-client=={client_v}');
+            }
+            if byllm_v and byllm_v != 'none' {
+                if byllm_v == 'latest' {
+                    commands.append('pip install byllm');
+                } else {
+                    commands.append(f'pip install byllm=={byllm_v}');
+                }
+            }
         }
 
         # Change to app directory (project is already copied there via volume mount)
@@ -641,6 +663,135 @@ class KubernetesTarget(DeploymentTarget) {
         );
     }
 
+    """Wait for resources to be completely deleted."""
+    def _wait_for_deletion(
+        self: KubernetesTarget,
+        app_name: str,
+        namespace: str,
+        apps_v1: Any,
+        core_v1: Any,
+        max_wait: int = 60,
+        poll_interval: float = 1.0
+    ) -> None {
+        elapsed = 0.0;
+        while elapsed < max_wait {
+            resources_exist = False;
+
+            # Check deployment
+            try {
+                apps_v1.read_namespaced_deployment(name=app_name, namespace=namespace);
+                resources_exist = True;
+            } except ApiException as e {
+                if e.status != 404 {
+                    raise ;
+                }
+            }
+
+            # Check service
+            try {
+                core_v1.read_namespaced_service(
+                    name=f"{app_name}-service", namespace=namespace
+                );
+                resources_exist = True;
+            } except ApiException as e {
+                if e.status != 404 {
+                    raise ;
+                }
+            }
+
+            # Check MongoDB resources if enabled
+            if self.k8s_config.mongodb_enabled {
+                mongodb_name = f"{app_name}-mongodb";
+                try {
+                    apps_v1.read_namespaced_stateful_set(
+                        name=mongodb_name, namespace=namespace
+                    );
+                    resources_exist = True;
+                } except ApiException as e {
+                    if e.status != 404 {
+                        raise ;
+                    }
+                }
+                try {
+                    core_v1.read_namespaced_service(
+                        name=f"{mongodb_name}-service", namespace=namespace
+                    );
+                    resources_exist = True;
+                } except ApiException as e {
+                    if e.status != 404 {
+                        raise ;
+                    }
+                }
+            }
+
+            # Check Redis resources if enabled
+            if self.k8s_config.redis_enabled {
+                redis_name = f"{app_name}-redis";
+                try {
+                    apps_v1.read_namespaced_deployment(
+                        name=redis_name, namespace=namespace
+                    );
+                    resources_exist = True;
+                } except ApiException as e {
+                    if e.status != 404 {
+                        raise ;
+                    }
+                }
+                try {
+                    core_v1.read_namespaced_service(
+                        name=f"{redis_name}-service", namespace=namespace
+                    );
+                    resources_exist = True;
+                } except ApiException as e {
+                    if e.status != 404 {
+                        raise ;
+                    }
+                }
+            }
+
+            # Check PVCs
+            try {
+                pvcs = core_v1.list_namespaced_persistent_volume_claim(namespace);
+                for pvc in pvcs.items {
+                    if pvc.metadata.name.startswith(app_name) {
+                        resources_exist = True;
+                        break;
+                    }
+                }
+            } except Exception { }
+
+            # Check code sync pod
+            try {
+                core_v1.read_namespaced_pod(
+                    name=f"{app_name}-code-sync", namespace=namespace
+                );
+                resources_exist = True;
+            } except ApiException as e {
+                if e.status != 404 {
+                    raise ;
+                }
+            }
+
+            # If no resources exist, deletion is complete
+            if not resources_exist {
+                if self.logger {
+                    self.logger.info(
+                        f"All resources for '{app_name}' have been deleted"
+                    );
+                }
+                return;
+            }
+            time.sleep(poll_interval);
+            elapsed = elapsed + poll_interval;
+        }
+
+        if self.logger {
+            self.logger.warn(
+                f"Timeout waiting for resources to be deleted after {max_wait} seconds"
+            );
+        }
+    }
+
     """Destroy all enabled databases."""
     def _destroy_databases(
         self: KubernetesTarget,
@@ -727,6 +878,14 @@ class KubernetesTarget(DeploymentTarget) {
                 }
             }
 
+            # Wait for all resources to be completely deleted
+            if self.logger {
+                self.logger.info(
+                    f"Waiting for all resources to be deleted for '{app_name}'..."
+                );
+            }
+            self._wait_for_deletion(app_name, namespace, apps_v1, core_v1);
+
             if self.logger {
                 self.logger.info(f"Application '{app_name}' destroyed successfully");
             }

jac_scale/tests/fixtures/scale-feats/components/Button.cl.jac

@@ -0,0 +1,32 @@
+"""Button component for the Jac client application."""
+
+def:pub Button(label: str, onClick: any, variant: str = "primary", disabled: bool = False) -> any {
+    base_styles = {
+        "padding": "0.75rem 1.5rem",
+        "fontSize": "1rem",
+        "fontWeight": "600",
+        "borderRadius": "0.5rem",
+        "border": "none",
+        "cursor": "not-allowed" if disabled else "pointer",
+        "transition": "all 0.2s ease"
+    };
+
+    variant_styles = {
+        "primary": {
+            "backgroundColor": "#9ca3af" if disabled else "#3b82f6",
+            "color": "#ffffff"
+        },
+        "secondary": {
+            "backgroundColor": "#e5e7eb" if disabled else "#6b7280",
+            "color": "#ffffff"
+        }
+    };
+
+    return <button
+        style={{**base_styles, **variant_styles[variant]}}
+        onClick={onClick}
+        disabled={disabled}
+    >
+        {label}
+    </button>;
+}