jac-scale 0.1.1__py3-none-any.whl

jac_scale/plugin_config.jac

@@ -0,0 +1,175 @@
+"""Plugin configuration hooks for jac-scale.
+
+This module implements JacPluginConfig hooks to integrate with core's
+configuration system, registering:
+- Plugin metadata (name, version)
+- Config schema for [plugins.scale] section
+"""
+
+import from typing { Any }
+import from jaclang.pycore.runtime { hookimpl }
+
+"""Plugin configuration hooks for jac-scale."""
+class JacScalePluginConfig {
+    """Return plugin metadata."""
+    @hookimpl
+    static def get_plugin_metadata -> dict[str, Any] {
+        return {
+            "name": "scale",
+            "version": "0.1.0",
+            "description": "Jac Scale - Deploy and scale Jac applications with Kubernetes"
+        };
+    }
+
+    """Return the plugin's configuration schema for [plugins.scale]."""
+    @hookimpl
+    static def get_config_schema -> dict[str, Any] {
+        return {
+            "section": "scale",
+            "options": {
+                "jwt": {
+                    "type": "dict",
+                    "default": {},
+                    "description": "JWT authentication configuration",
+                    "nested": {
+                        "secret": {
+                            "type": "string",
+                            "default": "supersecretkey",
+                            "description": "Secret key for JWT signing"
+                        },
+                        "algorithm": {
+                            "type": "string",
+                            "default": "HS256",
+                            "description": "JWT encoding algorithm"
+                        },
+                        "exp_delta_days": {
+                            "type": "int",
+                            "default": 7,
+                            "description": "JWT token expiration in days"
+                        }
+                    }
+                },
+                "sso": {
+                    "type": "dict",
+                    "default": {},
+                    "description": "SSO authentication configuration",
+                    "nested": {
+                        "host": {
+                            "type": "string",
+                            "default": "http://localhost:8000/sso",
+                            "description": "SSO callback host URL"
+                        },
+                        "google": {
+                            "type": "dict",
+                            "default": {},
+                            "description": "Google OAuth configuration",
+                            "nested": {
+                                "client_id": {
+                                    "type": "string",
+                                    "default": "",
+                                    "description": "Google OAuth client ID"
+                                },
+                                "client_secret": {
+                                    "type": "string",
+                                    "default": "",
+                                    "description": "Google OAuth client secret"
+                                }
+                            }
+                        }
+                    }
+                },
+                "database": {
+                    "type": "dict",
+                    "default": {},
+                    "description": "Database connection configuration",
+                    "nested": {
+                        "mongodb_uri": {
+                            "type": "string",
+                            "default": None,
+                            "description": "MongoDB connection URI"
+                        },
+                        "redis_url": {
+                            "type": "string",
+                            "default": None,
+                            "description": "Redis connection URL"
+                        },
+                        "shelf_db_path": {
+                            "type": "string",
+                            "default": ".jac/data/anchor_store.db",
+                            "description": "File-based storage path for ShelfDB fallback"
+                        }
+                    }
+                },
+                "kubernetes": {
+                    "type": "dict",
+                    "default": {},
+                    "description": "Kubernetes deployment configuration",
+                    "nested": {
+                        "app_name": {
+                            "type": "string",
+                            "default": "jaseci",
+                            "description": "Application name for Kubernetes resources"
+                        },
+                        "docker_image_name": {
+                            "type": "string",
+                            "default": "",
+                            "description": "Docker image name (defaults to {app_name}:latest)"
+                        },
+                        "docker_username": {
+                            "type": "string",
+                            "default": "",
+                            "description": "DockerHub username for pushing images"
+                        },
+                        "docker_password": {
+                            "type": "string",
+                            "default": "",
+                            "description": "DockerHub password/token for pushing images"
+                        },
+                        "namespace": {
+                            "type": "string",
+                            "default": "default",
+                            "description": "Kubernetes namespace for deployment"
+                        },
+                        "container_port": {
+                            "type": "int",
+                            "default": 8000,
+                            "description": "Container port for the application"
+                        },
+                        "node_port": {
+                            "type": "int",
+                            "default": 30001,
+                            "description": "NodePort for external access"
+                        },
+                        "mongodb_enabled": {
+                            "type": "bool",
+                            "default": True,
+                            "description": "Enable MongoDB deployment in Kubernetes"
+                        },
+                        "redis_enabled": {
+                            "type": "bool",
+                            "default": True,
+                            "description": "Enable Redis deployment in Kubernetes"
+                        }
+                    }
+                },
+                "server": {
+                    "type": "dict",
+                    "default": {},
+                    "description": "Server configuration",
+                    "nested": {
+                        "port": {
+                            "type": "int",
+                            "default": 8000,
+                            "description": "Server port"
+                        },
+                        "host": {
+                            "type": "string",
+                            "default": "0.0.0.0",
+                            "description": "Server host"
+                        }
+                    }
+                }
+            }
+        };
+    }
+}

jac_scale/providers/database/kubernetes_mongo.jac

@@ -0,0 +1,137 @@
+"""Kubernetes MongoDB provider implementation."""
+import from typing { Any }
+import from jac_scale.abstractions.database_provider { DatabaseProvider }
+import from jac_scale.abstractions.deployment_target { DeploymentTarget }
+
+"""MongoDB provider for Kubernetes deployments."""
+class KubernetesMongoProvider(DatabaseProvider) {
+    has target: (DeploymentTarget | None) = None,
+        config: dict[str, Any] = {},
+        app_name: str = '',
+        connection_string: str = '';
+
+    def init(
+        self: KubernetesMongoProvider,
+        target: (DeploymentTarget | None) = None,
+        config: dict[str, Any] = {}
+    ) -> None {
+        self.target = target;
+        self.config = config;
+        self.app_name = config.get('app_name', 'jaseci');
+    }
+
+    def deploy(
+        self: KubernetesMongoProvider, config: dict[str, Any] = {}
+    ) -> dict[str, Any] {
+        mongodb_name = f"{self.app_name}-mongodb";
+        mongodb_port = 27017;
+        mongodb_service_name = f"{mongodb_name}-service";
+        mongodb_volume_name = f"{self.app_name}-mongo-data";
+
+        mongodb_statefulset = {
+            'apiVersion': 'apps/v1',
+            'kind': 'StatefulSet',
+            'metadata': {'name': mongodb_name},
+            'spec': {
+                'serviceName': mongodb_service_name,
+                'replicas': 1,
+                'selector': {'matchLabels': {'app': mongodb_name}},
+                'template': {
+                    'metadata': {'labels': {'app': mongodb_name}},
+                    'spec': {
+                        'containers': [
+                            {
+                                'name': 'mongodb',
+                                'image': 'mongo:6.0',
+                                'ports': [{'containerPort': mongodb_port}],
+                                'env': [
+                                    {
+                                        'name': 'MONGO_INITDB_ROOT_USERNAME',
+                                        'value': 'admin'
+                                    },
+                                    {
+                                        'name': 'MONGO_INITDB_ROOT_PASSWORD',
+                                        'value': 'password'
+                                    }
+                                ],
+                                'volumeMounts': [
+                                    {
+                                        'name': mongodb_volume_name,
+                                        'mountPath': '/data/db'
+                                    }
+                                ]
+                            }
+                        ]
+                    }
+                },
+                'volumeClaimTemplates': [
+                    {
+                        'metadata': {'name': mongodb_volume_name},
+                        'spec': {
+                            'accessModes': ['ReadWriteOnce'],
+                            'resources': {'requests': {'storage': '1Gi'}}
+                        }
+                    }
+                ]
+            }
+        };
+
+        mongodb_service = {
+            'apiVersion': 'v1',
+            'kind': 'Service',
+            'metadata': {'name': mongodb_service_name},
+            'spec': {
+                'clusterIP': 'None',
+                'selector': {'app': mongodb_name},
+                'ports': [
+                    {
+                        'protocol': 'TCP',
+                        'port': mongodb_port,
+                        'targetPort': mongodb_port
+                    }
+                ]
+            }
+        };
+
+        self.connection_string = f"mongodb://admin:password@{mongodb_service_name}:{mongodb_port}";
+
+        return {
+            'deployment': mongodb_statefulset,
+            'service': mongodb_service,
+            'connection_string': self.connection_string,
+            'service_name': mongodb_service_name
+        };
+    }
+
+    def get_connection_string(self: KubernetesMongoProvider) -> str {
+        if not self.connection_string {
+            # Generate default connection string
+            service_name = f"{self.app_name}-mongodb-service";
+            self.connection_string = f"mongodb://admin:password@{service_name}:27017";
+        }
+        return self.connection_string;
+    }
+
+    def is_available(self: KubernetesMongoProvider) -> bool {
+        # TODO: Implement actual check
+        return True;
+    }
+
+    def cleanup(self: KubernetesMongoProvider) -> None {
+    # Cleanup is handled by the deployment target
+    }
+
+    override def get_init_container(
+        self: KubernetesMongoProvider, app_name: str, wait_image: str
+    ) -> (dict[(str, Any)] | None) {
+        return {
+            'name': 'wait-for-mongodb',
+            'image': wait_image,
+            'command': [
+                'sh',
+                '-c',
+                f"until nc -z {app_name}-mongodb-service 27017; do echo waiting for mongodb; sleep 3; done"
+            ]
+        };
+    }
+}

jac_scale/providers/database/kubernetes_redis.jac

@@ -0,0 +1,110 @@
+"""Kubernetes Redis provider implementation."""
+import from typing { Any }
+import from jac_scale.abstractions.database_provider { DatabaseProvider }
+import from jac_scale.abstractions.deployment_target { DeploymentTarget }
+
+"""Redis provider for Kubernetes deployments."""
+class KubernetesRedisProvider(DatabaseProvider) {
+    has target: (DeploymentTarget | None) = None,
+        config: dict[str, Any] = {},
+        app_name: str = '',
+        connection_string: str = '';
+
+    def init(
+        self: KubernetesRedisProvider,
+        target: (DeploymentTarget | None) = None,
+        config: dict[str, Any] = {}
+    ) -> None {
+        self.target = target;
+        self.config = config;
+        self.app_name = config.get('app_name', 'jaseci');
+    }
+
+    def deploy(
+        self: KubernetesRedisProvider, config: dict[str, Any] = {}
+    ) -> dict[str, Any] {
+        redis_name = f"{self.app_name}-redis";
+        redis_port = 6379;
+        redis_service_name = f"{redis_name}-service";
+
+        redis_deployment = {
+            'apiVersion': 'apps/v1',
+            'kind': 'Deployment',
+            'metadata': {'name': redis_name},
+            'spec': {
+                'replicas': 1,
+                'selector': {'matchLabels': {'app': redis_name}},
+                'template': {
+                    'metadata': {'labels': {'app': redis_name}},
+                    'spec': {
+                        'containers': [
+                            {
+                                'name': 'redis',
+                                'image': 'redis:7.2',
+                                'ports': [{'containerPort': redis_port}],
+                                'args': ['--save', '', '--appendonly', 'no'],
+                                'resources': {
+                                    'requests': {'cpu': '100m', 'memory': '128Mi'},
+                                    'limits': {'cpu': '500m', 'memory': '256Mi'}
+                                }
+                            }
+                        ]
+                    }
+                }
+            }
+        };
+
+        redis_service = {
+            'apiVersion': 'v1',
+            'kind': 'Service',
+            'metadata': {'name': redis_service_name},
+            'spec': {
+                'selector': {'app': redis_name},
+                'ports': [
+                    {'protocol': 'TCP', 'port': redis_port, 'targetPort': redis_port}
+                ]
+            }
+        };
+
+        self.connection_string = f"redis://{redis_service_name}:{redis_port}/0";
+
+        return {
+            'deployment': redis_deployment,
+            'service': redis_service,
+            'connection_string': self.connection_string,
+            'service_name': redis_service_name
+        };
+    }
+
+    def get_connection_string(self: KubernetesRedisProvider) -> str {
+        if not self.connection_string {
+            # Generate default connection string
+            service_name = f"{self.app_name}-redis-service";
+            self.connection_string = f"redis://{service_name}:6379/0";
+        }
+        return self.connection_string;
+    }
+
+    def is_available(self: KubernetesRedisProvider) -> bool {
+        # TODO: Implement actual check
+        return True;
+    }
+
+    def cleanup(self: KubernetesRedisProvider) -> None {
+    # Cleanup is handled by the deployment target
+    }
+
+    override def get_init_container(
+        self: KubernetesRedisProvider, app_name: str, wait_image: str
+    ) -> (dict[(str, Any)] | None) {
+        return {
+            'name': 'wait-for-redis',
+            'image': wait_image,
+            'command': [
+                'sh',
+                '-c',
+                f"until nc -z {app_name}-redis-service 6379; do echo waiting for redis; sleep 3; done"
+            ]
+        };
+    }
+}

jac_scale/providers/registry/dockerhub.jac

@@ -0,0 +1,64 @@
+"""DockerHub registry implementation."""
+import os;
+import docker;
+import from typing { Any }
+import from docker.errors { APIError, BuildError }
+import from jac_scale.abstractions.image_registry { ImageRegistry }
+
+"""DockerHub image registry implementation."""
+class DockerHubRegistry(ImageRegistry) {
+    has config: dict[str, Any] = {},
+        docker_username: str = '',
+        docker_password: str = '';
+
+    def init(self: DockerHubRegistry, config: dict[str, Any] = {}) -> None {
+        self.config = config;
+        self.docker_username = config.get('docker_username', '')
+        or os.getenv('DOCKER_USERNAME', 'juzailmlwork');
+        self.docker_password = config.get('docker_password', '')
+        or os.getenv('DOCKER_PASSWORD', '');
+    }
+
+    def build_image(
+        self: DockerHubRegistry, code_folder: str, image_name: (str | None) = None
+    ) -> str {
+        if not image_name {
+            app_name = self.config.get('app_name', 'jaseci');
+            image_name = self.config.get('docker_image_name') or f"{app_name}:latest";
+        }
+        repository_name = f"{self.docker_username}/{image_name}";
+
+        # Build Docker image using Docker client
+        docker_client = docker.from_env();
+        try {
+            docker_client.images.build(
+                path=code_folder, tag=repository_name, dockerfile='Dockerfile', rm=True
+            );
+        } except BuildError as e {
+            raise RuntimeError(f"Failed to build Docker image: {e}") from e ;
+        }
+
+        return repository_name;
+    }
+
+    def push_image(self: DockerHubRegistry, image_name: str) -> None {
+        # Push Docker image to DockerHub
+        docker_client = docker.from_env();
+        try {
+            docker_client.login(
+                username=self.docker_username, password=self.docker_password
+            );
+            docker_client.images.push(image_name);
+        } except APIError as e {
+            raise RuntimeError(f"Failed to push Docker image: {e}") from e ;
+        }
+    }
+
+    def get_image_url(self: DockerHubRegistry, image_name: str) -> str {
+        # If image_name doesn't include username, add it
+        if '/' not in image_name {
+            return f"{self.docker_username}/{image_name}";
+        }
+        return image_name;
+    }
+}

jac_scale/serve.jac

@@ -0,0 +1,118 @@
+import logging;
+import mimetypes;
+import from collections.abc { Callable }
+import from datetime { UTC, datetime, timedelta }
+import from pathlib { Path }
+import from pydantic { BaseModel, Field }
+import from typing { Any }
+import jwt;
+import from os { getenv }
+import from fastapi.middleware.cors { CORSMiddleware }
+import from fastapi.responses { HTMLResponse, JSONResponse, Response, RedirectResponse }
+import from jac_scale.jserver.jfast_api { JFastApiServer }
+import from jac_scale.jserver.jserver {
+    APIParameter,
+    HTTPMethod,
+    JEndPoint,
+    ParameterType
+}
+import from jaclang.pycore.runtime { JacRuntime as Jac }
+import from jaclang.runtimelib.server { JacAPIServer as JServer }
+import from jaclang.runtimelib.server { JsonValue }
+import from jaclang.runtimelib.transport { TransportResponse, Meta, MessageType }
+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 }
+
+# Load configuration from jac.toml with env var overrides
+glob _jwt_config = get_scale_config().get_jwt_config(),
+     _sso_config = get_scale_config().get_sso_config(),
+     JWT_SECRET = _jwt_config['secret'],
+     JWT_ALGORITHM = _jwt_config['algorithm'],
+     JWT_EXP_DELTA_DAYS = _jwt_config['exp_delta_days'],
+     SSO_HOST = _sso_config['host'],
+     logger = logging.getLogger(__name__);
+
+enum Platforms ( StrEnum ) { GOOGLE = 'google' }
+
+enum Operations ( StrEnum ) { LOGIN = 'login', REGISTER = 'register' }
+
+obj JacAPIServer(JServer) {
+    # HMR (Hot Module Replacement) support fields
+    has _hmr_pending: bool = False,
+        _hot_reloader: Any | 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;
+    def update_username(
+        current_username: str, new_username: str, Authorization: (str | None) = None
+    ) -> TransportResponse;
+
+    def update_password(
+        username: str,
+        current_password: str,
+        new_password: str,
+        Authorization: (str | None) = None
+    ) -> TransportResponse;
+
+    def register_update_username_endpoint -> None;
+    def register_update_password_endpoint -> None;
+    def create_user(username: str, password: str) -> TransportResponse;
+    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
+    ) -> 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 register_functions_endpoints -> None;
+    def render_page_callback -> Callable[..., HTMLResponse];
+    def render_base_route_callback(app_name: str) -> Callable[..., HTMLResponse];
+    def register_page_endpoint -> None;
+    def serve_client_js_callback -> Callable[..., Response];
+    def register_client_js_endpoint -> None;
+    def register_static_file_endpoint -> None;
+    def serve_static_file(file_path: str) -> Response;
+    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;
+    # 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;
+}
+
+class UpdateUsernameRequest(BaseModel) {
+    has current_username: str = Field(..., description='Current username'),
+        new_username: str = Field(..., description='New username');
+}
+
+class UpdatePasswordRequest(BaseModel) {
+    has username: str = Field(..., description='Username'),
+        current_password: str = Field(..., description='Current password'),
+        new_password: str = Field(..., description='New password');
+}