jac-scale 0.1.0__tar.gz → 0.1.1__tar.gz

{jac_scale-0.1.0 → jac_scale-0.1.1}/PKG-INFO

@@ -1,10 +1,10 @@
 Metadata-Version: 2.4
 Name: jac-scale
-Version: 0.1.0
+Version: 0.1.1
 Author-email: Jason Mars <jason@mars.ninja>
 Requires-Python: >=3.12
 Description-Content-Type: text/markdown
-Requires-Dist: jaclang>=0.9.9
+Requires-Dist: jaclang>=0.9.10
 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

{jac_scale-0.1.0 → jac_scale-0.1.1}/jac_scale/impl/memory_hierarchy.main.impl.jac

@@ -31,7 +31,7 @@ impl ScaleTieredMemory.init(use_cache: bool = True) -> None {
         # Show subtle message (optional - uncomment to enable)
         try {
             import from jaclang.cli.console { console }
-            console.print("  ✔ Using MongoDB for persistence", style="muted");
+            logger.debug("  ✔ Using MongoDB for persistence", style="muted");
         } except Exception { }
     } else {
         # Fall back to jaclang's SqliteMemory using configured path
@@ -41,7 +41,7 @@ impl ScaleTieredMemory.init(use_cache: bool = True) -> None {
         # Show subtle message
         try {
             import from jaclang.cli.console { console }
-            console.print("  ✔ Using SQLite for persistence", style="muted");
+            logger.debug("  ✔ Using SQLite for persistence", style="muted");
         } except Exception { }
     }
 }

{jac_scale-0.1.0 → jac_scale-0.1.1}/jac_scale/impl/serve.impl.jac

@@ -57,7 +57,7 @@ def _transport_response_to_json_response(
     );
 }
 
-impl JacAPIServer.start(self: JacAPIServer, dev: bool = False) -> None {
+impl JacAPIServer.start(dev: bool = False) -> None {
     self.introspector.load();
     # Eagerly build client bundle if there are client exports (skip in dev mode)
     if not dev {
@@ -112,7 +112,7 @@ impl JacAPIServer.start(self: JacAPIServer, dev: bool = False) -> None {
 }
 
 """Configure OpenAPI security scheme to only apply to walker endpoints that require auth."""
-impl JacAPIServer._configure_openapi_security(self: JacAPIServer) -> None {
+impl JacAPIServer._configure_openapi_security -> None {
     import from fastapi.openapi.utils { get_openapi }
     def custom_openapi -> dict[str, Any] {
         if self.server.app.openapi_schema {
@@ -178,7 +178,7 @@ impl JacAPIServer._configure_openapi_security(self: JacAPIServer) -> None {
 }
 
 """Serve root-level assets like /img.png, /icons/logo.svg, etc."""
-impl JacAPIServer.serve_root_asset(self: JacAPIServer, file_path: str) -> Response {
+impl JacAPIServer.serve_root_asset(file_path: str) -> Response {
     allowed_extensions = {'.png','.jpg','.jpeg','.gif','.webp','.svg','.ico','.woff','.woff2','.ttf','.otf','.eot','.mp4','.webm','.mp3','.wav','.css','.js','.json','.pdf','.txt','.xml'};
     file_ext = Path(file_path).suffix.lower();
     if (not file_ext or (file_ext not in allowed_extensions)) {
@@ -235,7 +235,7 @@ impl JacAPIServer.serve_root_asset(self: JacAPIServer, file_path: str) -> Respon
 }
 
 """Register root-level asset serving endpoint for files like /img.png, /logo.svg"""
-impl JacAPIServer.register_root_asset_endpoint(self: JacAPIServer) -> None {
+impl JacAPIServer.register_root_asset_endpoint -> None {
     self.server.add_endpoint(
         JEndPoint(
             method=HTTPMethod.GET,
@@ -260,7 +260,7 @@ impl JacAPIServer.register_root_asset_endpoint(self: JacAPIServer) -> None {
 }
 
 """Serve a static file given its path."""
-impl JacAPIServer.serve_static_file(self: JacAPIServer, file_path: str) -> Response {
+impl JacAPIServer.serve_static_file(file_path: str) -> Response {
     try {
         # Find project root (where jac.toml is) instead of using base_path_dir
         # base_path_dir might be src/ when serving src/app.jac, but we need project root
@@ -338,7 +338,7 @@ impl JacAPIServer.serve_static_file(self: JacAPIServer, file_path: str) -> Respo
 }
 
 """Register the static file serving endpoint using JEndPoint."""
-impl JacAPIServer.register_static_file_endpoint(self: JacAPIServer) -> None {
+impl JacAPIServer.register_static_file_endpoint -> None {
     self.server.add_endpoint(
         JEndPoint(
             method=HTTPMethod.GET,
@@ -363,7 +363,7 @@ impl JacAPIServer.register_static_file_endpoint(self: JacAPIServer) -> None {
 }
 
 """Register the client.js serving endpoint using JEndPoint."""
-impl JacAPIServer.register_client_js_endpoint(self: JacAPIServer) -> None {
+impl JacAPIServer.register_client_js_endpoint -> None {
     self.server.add_endpoint(
         JEndPoint(
             method=HTTPMethod.GET,
@@ -379,9 +379,7 @@ impl JacAPIServer.register_client_js_endpoint(self: JacAPIServer) -> None {
 }
 
 """Create callback to serve the client.js file."""
-impl JacAPIServer.serve_client_js_callback(
-    self: JacAPIServer
-) -> Callable[..., Response] {
+impl JacAPIServer.serve_client_js_callback -> Callable[..., Response] {
     def callback -> Response {
         try {
             self.introspector.load();
@@ -398,7 +396,7 @@ impl JacAPIServer.serve_client_js_callback(
 }
 
 """Register the page rendering endpoint using JEndPoint."""
-impl JacAPIServer.register_page_endpoint(self: JacAPIServer) -> None {
+impl JacAPIServer.register_page_endpoint -> None {
     import from jaclang.project.config { get_config }
     config = get_config();
     cl_route_prefix = config.serve.cl_route_prefix if config else "cl";
@@ -443,9 +441,7 @@ impl JacAPIServer.register_page_endpoint(self: JacAPIServer) -> None {
 }
 
 """Create callback that extracts all query parameters from FastAPI Request."""
-impl JacAPIServer.render_page_callback(
-    self: JacAPIServer
-) -> Callable[..., HTMLResponse] {
+impl JacAPIServer.render_page_callback -> Callable[..., HTMLResponse] {
     """Render a page by name with all query parameters.""";
     def callback(page_name: str, **kwargs: JsonValue) -> HTMLResponse {
         try {
@@ -467,7 +463,7 @@ impl JacAPIServer.render_page_callback(
 
 """Create callback for base route app rendering."""
 impl JacAPIServer.render_base_route_callback(
-    self: JacAPIServer, app_name: str
+    app_name: str
 ) -> Callable[..., HTMLResponse] {
     """Render the base route app.""";
     def callback(**kwargs: JsonValue) -> HTMLResponse {
@@ -488,7 +484,7 @@ impl JacAPIServer.render_base_route_callback(
     return callback;
 }
 
-impl JacAPIServer.register_functions_endpoints(self: JacAPIServer) -> None {
+impl JacAPIServer.register_functions_endpoints -> None {
     for func_name in self.get_functions() {
         self.server.add_endpoint(
             JEndPoint(
@@ -505,9 +501,7 @@ impl JacAPIServer.register_functions_endpoints(self: JacAPIServer) -> None {
     }
 }
 
-impl JacAPIServer.create_function_parameters(
-    self: JacAPIServer, func_name: str
-) -> list[APIParameter] {
+impl JacAPIServer.create_function_parameters(func_name: str) -> list[APIParameter] {
     parameters: list[APIParameter] = [];
     if self.introspector.is_auth_required_for_function(func_name) {
         parameters.append(
@@ -548,7 +542,7 @@ impl JacAPIServer.create_function_parameters(
 }
 
 impl JacAPIServer.create_function_callback(
-    self: JacAPIServer, func_name: str
+    func_name: str
 ) -> Callable[..., TransportResponse] {
     import from jaclang.runtimelib.transport { TransportResponse, Meta }
     requires_auth = self.introspector.is_auth_required_for_function(func_name);
@@ -592,7 +586,7 @@ impl JacAPIServer.create_function_callback(
     return callback;
 }
 
-impl JacAPIServer.register_walkers_endpoints(self: JacAPIServer) -> None {
+impl JacAPIServer.register_walkers_endpoints -> None {
     for walker_name in self.get_walkers() {
         self.server.add_endpoint(
             JEndPoint(
@@ -626,7 +620,7 @@ impl JacAPIServer.register_walkers_endpoints(self: JacAPIServer) -> None {
 }
 
 impl JacAPIServer.create_walker_parameters(
-    self: JacAPIServer, walker_name: str, invoke_on_root: bool
+    walker_name: str, invoke_on_root: bool
 ) -> list[APIParameter] {
     parameters: list[APIParameter] = [];
     if self.introspector.is_auth_required_for_walker(walker_name) {
@@ -673,7 +667,7 @@ impl JacAPIServer.create_walker_parameters(
 }
 
 impl JacAPIServer.create_walker_callback(
-    self: JacAPIServer, walker_name: str, has_node_param: bool = False
+    walker_name: str, has_node_param: bool = False
 ) -> Callable[..., TransportResponse] {
     import from jaclang.runtimelib.transport { TransportResponse, Meta }
     requires_auth = self.introspector.is_auth_required_for_walker(walker_name);
@@ -721,7 +715,7 @@ impl JacAPIServer.create_walker_callback(
     return callback;
 }
 
-impl JacAPIServer.register_refresh_token_endpoint(self: JacAPIServer) -> None {
+impl JacAPIServer.register_refresh_token_endpoint -> None {
     self.server.add_endpoint(
         JEndPoint(
             method=HTTPMethod.POST,
@@ -745,7 +739,7 @@ impl JacAPIServer.register_refresh_token_endpoint(self: JacAPIServer) -> None {
     );
 }
 
-impl JacAPIServer.register_create_user_endpoint(self: JacAPIServer) -> None {
+impl JacAPIServer.register_create_user_endpoint -> None {
     self.server.add_endpoint(
         JEndPoint(
             method=HTTPMethod.POST,
@@ -777,9 +771,7 @@ impl JacAPIServer.register_create_user_endpoint(self: JacAPIServer) -> None {
     );
 }
 
-impl JacAPIServer.refresh_token(
-    self: JacAPIServer, token: (str | None) = None
-) -> TransportResponse {
+impl JacAPIServer.refresh_token(token: (str | None) = None) -> TransportResponse {
     import from jaclang.runtimelib.transport { TransportResponse, Meta }
     if (not token) {
         return TransportResponse.fail(
@@ -805,9 +797,7 @@ impl JacAPIServer.refresh_token(
     );
 }
 
-impl JacAPIServer.create_user(
-    self: JacAPIServer, username: str, password: str
-) -> TransportResponse {
+impl JacAPIServer.create_user(username: str, password: str) -> TransportResponse {
     import traceback;
     import from jaclang.runtimelib.transport { TransportResponse, Meta }
     try {
@@ -835,10 +825,7 @@ impl JacAPIServer.create_user(
 }
 
 impl JacAPIServer.update_username(
-    self: JacAPIServer,
-    current_username: str,
-    new_username: str,
-    Authorization: (str | None) = None
+    current_username: str, new_username: str, Authorization: (str | None) = None
 ) -> TransportResponse {
     import from jaclang.runtimelib.transport { TransportResponse, Meta }
     # Validate token and extract username
@@ -889,7 +876,6 @@ impl JacAPIServer.update_username(
 }
 
 impl JacAPIServer.update_password(
-    self: JacAPIServer,
     username: str,
     current_password: str,
     new_password: str,
@@ -943,7 +929,7 @@ impl JacAPIServer.update_password(
     );
 }
 
-impl JacAPIServer.register_update_username_endpoint(self: JacAPIServer) -> None {
+impl JacAPIServer.register_update_username_endpoint -> None {
     import from fastapi { Request }
     async def update_username_handler(
         request: Request, current_username: str, new_username: str
@@ -982,7 +968,7 @@ impl JacAPIServer.register_update_username_endpoint(self: JacAPIServer) -> None
     );
 }
 
-impl JacAPIServer.register_update_password_endpoint(self: JacAPIServer) -> None {
+impl JacAPIServer.register_update_password_endpoint -> None {
     import from fastapi { Request }
     async def update_password_handler(
         request: Request, username: str, current_password: str, new_password: str
@@ -1031,7 +1017,7 @@ impl JacAPIServer.register_update_password_endpoint(self: JacAPIServer) -> None
     );
 }
 
-impl JacAPIServer.register_login_endpoint(self: JacAPIServer) -> None {
+impl JacAPIServer.register_login_endpoint -> None {
     self.server.add_endpoint(
         JEndPoint(
             method=HTTPMethod.POST,
@@ -1063,9 +1049,7 @@ impl JacAPIServer.register_login_endpoint(self: JacAPIServer) -> None {
     );
 }
 
-impl JacAPIServer.login(
-    self: JacAPIServer, username: str, password: str
-) -> TransportResponse {
+impl JacAPIServer.login(username: str, password: str) -> TransportResponse {
     import from jaclang.runtimelib.transport { TransportResponse, Meta }
     if (not username or not password) {
         return TransportResponse.fail(
@@ -1088,10 +1072,8 @@ impl JacAPIServer.login(
     );
 }
 
-impl JacAPIServer.init(
-    self: JacAPIServer, module_name: str, port: int = 8000, base_path: str = ""
-) -> None {
-    super.init(module_name, port, base_path);
+impl JacAPIServer.postinit -> None {
+    super.postinit();
     self.server.app.add_middleware(
         CORSMiddleware,
         allow_origins=['*'],
@@ -1104,7 +1086,7 @@ impl JacAPIServer.init(
     import from starlette.middleware.base { BaseHTTPMiddleware }
     import from pathlib { Path }
     # Use base_path to find the correct jac.toml for this project
-    start_path = Path(base_path) if base_path else None;
+    start_path = Path(self.base_path) if self.base_path else None;
     config = JacConfig.discover(start_path);
     custom_headers: dict = {};
     if config
@@ -1184,9 +1166,7 @@ impl JacAPIServer.create_jwt_token(username: str) -> str {
     return jwt.encode(payload, JWT_SECRET, algorithm=JWT_ALGORITHM);
 }
 
-impl JacAPIServer.get_sso(
-    self: JacAPIServer, platform: str, operation: str
-) -> (GoogleSSO | None) {
+impl JacAPIServer.get_sso(platform: str, operation: str) -> (GoogleSSO | None) {
     if (platform not in self.SUPPORTED_PLATFORMS) {
         return None;
     }
@@ -1204,7 +1184,7 @@ impl JacAPIServer.get_sso(
 }
 
 impl JacAPIServer.sso_initiate(
-    self: JacAPIServer, platform: str, operation: str
+    platform: str, operation: str
 ) -> (Response | TransportResponse) {
     import from jaclang.runtimelib.transport { TransportResponse, Meta }
     if (platform not in [p.value for p in Platforms]) {
@@ -1244,7 +1224,7 @@ impl JacAPIServer.sso_initiate(
 }
 
 impl JacAPIServer.sso_callback(
-    self: JacAPIServer, request: Request, platform: str, operation: str
+    request: Request, platform: str, operation: str
 ) -> TransportResponse {
     import from jaclang.runtimelib.transport { TransportResponse, Meta }
     if (platform not in [p.value for p in Platforms]) {
@@ -1344,7 +1324,7 @@ impl JacAPIServer.sso_callback(
     }
 }
 
-impl JacAPIServer.register_sso_endpoints(self: JacAPIServer) -> None {
+impl JacAPIServer.register_sso_endpoints -> None {
     self.server.add_endpoint(
         JEndPoint(
             method=HTTPMethod.GET,
@@ -1409,7 +1389,7 @@ impl JacAPIServer.register_sso_endpoints(self: JacAPIServer) -> None {
 # HMR (Hot Module Replacement) Dynamic Routing Support
 # ============================================================================
 """Enable HMR mode - file changes trigger reload on next request."""
-impl JacAPIServer.enable_hmr(self: JacAPIServer, hot_reloader: Any) -> None {
+impl JacAPIServer.enable_hmr(hot_reloader: Any) -> None {
     self._hot_reloader = hot_reloader;
     # Callback when file changes - sets pending flag
     def on_change(event: Any) -> None {
@@ -1427,7 +1407,7 @@ Instead of pre-registering /walker/WalkerA, /walker/WalkerB, etc.,
 we register catch-all routes that look up walkers at request time.
 This enables HMR since introspector.load() is called per-request.
 """
-impl JacAPIServer.register_dynamic_walker_endpoint(self: JacAPIServer) -> None {
+impl JacAPIServer.register_dynamic_walker_endpoint -> None {
     import from jaclang.runtimelib.transport { TransportResponse, Meta }
     import from fastapi { Request }
     # Dynamic handler that looks up walker at request time
@@ -1579,7 +1559,7 @@ impl JacAPIServer.register_dynamic_walker_endpoint(self: JacAPIServer) -> None {
 
 Similar to dynamic walker routing, this enables HMR for functions.
 """
-impl JacAPIServer.register_dynamic_function_endpoint(self: JacAPIServer) -> None {
+impl JacAPIServer.register_dynamic_function_endpoint -> None {
     import from fastapi.responses { JSONResponse }
     import from fastapi { Request }
     import from jaclang.runtimelib.transport { TransportResponse, Meta }
@@ -1685,7 +1665,7 @@ impl JacAPIServer.register_dynamic_function_endpoint(self: JacAPIServer) -> None
 These endpoints allow clients to discover what walkers and functions are available,
 which is especially useful in HMR mode where the list can change dynamically.
 """
-impl JacAPIServer.register_dynamic_introspection_endpoints(self: JacAPIServer) -> None {
+impl JacAPIServer.register_dynamic_introspection_endpoints -> None {
     import from fastapi.responses { JSONResponse }
     def list_walkers -> dict[str, Any] {
         # Reload introspector if files changed (HMR)

{jac_scale-0.1.0 → jac_scale-0.1.1}/jac_scale/jserver/impl/jfast_api.impl.jac

@@ -1,3 +1,5 @@
+import logging;
+
 """Helper function to convert TransportResponse to JSONResponse (similar to HTTPTransport.send)."""
 def _convert_transport_response_to_json_response(
     transport_response: TransportResponse
@@ -53,13 +55,59 @@ def _convert_transport_response_to_json_response(
     return JSONResponse(status_code=status, content=response_body);
 }
 
+"""Custom logging handler that routes logs to jac-super console."""
+class ConsoleLogHandler(logging.Handler) {
+    """A logging handler that forwards log messages to jac-super's console."""
+    def emit(self: ConsoleLogHandler, record: logging.LogRecord) -> None {
+        import from jaclang.cli.console { console }
+        message = self.format(record);
+        console.print(f"  {message}");
+    }
+}
+
 """Run the FastAPI server using Uvicorn."""
 impl JFastApiServer.run_server(
     self: JFastApiServer, host: str = '0.0.0.0', port: int = 8000
 ) -> None {
     app = self.create_server();
-    # Suppress INFO logs to avoid duplicate server messages (we show our own JAC DEV SERVER banner)
-    uvicorn.run(app, host=host, port=port, log_level="warning");
+    # Create custom handler for console logging
+    console_handler = ConsoleLogHandler();
+    console_handler.setFormatter(logging.Formatter("%(message)s"));
+    # Suppress startup logs but route access logs through jac-super console
+    log_config = {
+        "version": 1,
+        "disable_existing_loggers": False,
+        "formatters": {
+            "default": {"format": "%(message)s"},
+            "access": {"format": "%(message)s"},
+
+        },
+        "handlers": {
+            "default": {
+                "formatter": "default",
+                "class": "logging.StreamHandler",
+                "stream": "ext://sys.stderr"
+            },
+            "access": {"()": lambda : console_handler },
+
+        },
+        "loggers": {
+            "uvicorn": {
+                "handlers": ["default"],
+                "level": "WARNING",
+                "propagate": False
+            },
+            "uvicorn.error": {"level": "WARNING", "propagate": False},
+            "uvicorn.access": {
+                "handlers": ["access"],
+                "level": "INFO",
+                "propagate": False
+            },
+
+        },
+
+    };
+    uvicorn.run(app, host=host, port=port, log_config=log_config);
 }
 
 """Get the underlying FastAPI application instance."""

{jac_scale-0.1.0 → jac_scale-0.1.1}/jac_scale/jserver/jfast_api.jac

@@ -18,6 +18,7 @@ Advanced Features:
 """
 
 import inspect;
+import logging;
 import uvicorn;
 import from collections.abc { Callable }
 import from typing { Any, Optional, TypeAlias, get_type_hints }

jac_scale-0.1.1/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');
+}

jac_scale-0.1.1/jac_scale/utilities/loggers/standard_logger.jac

@@ -0,0 +1,40 @@
+"""Standard logger implementation using jac console."""
+import from typing { Any }
+import from jac_scale.abstractions.logger { Logger }
+import from jaclang.cli.console { console }
+
+"""Standard logger using jac console for Rich-styled output."""
+class StandardLogger(Logger) {
+    def init(self: StandardLogger, config: dict[str, Any] = {}) -> None { }
+    def info(self: StandardLogger, message: str, context: dict[str, Any] = {}) -> None {
+        if context {
+            console.info(f"{message} | Context: {context}");
+        } else {
+            console.info(message);
+        }
+    }
+
+    def error(self: StandardLogger, message: str, context: dict[str, Any] = {}) -> None {
+        if context {
+            console.error(f"{message} | Context: {context}");
+        } else {
+            console.error(message);
+        }
+    }
+
+    def warn(self: StandardLogger, message: str, context: dict[str, Any] = {}) -> None {
+        if context {
+            console.warning(f"{message} | Context: {context}");
+        } else {
+            console.warning(message);
+        }
+    }
+
+    def debug(self: StandardLogger, message: str, context: dict[str, Any] = {}) -> None {
+        if context {
+            console.print(f"[DEBUG] {message} | Context: {context}", style="muted");
+        } else {
+            console.print(f"[DEBUG] {message}", style="muted");
+        }
+    }
+}

{jac_scale-0.1.0 → jac_scale-0.1.1}/jac_scale.egg-info/PKG-INFO

@@ -1,10 +1,10 @@
 Metadata-Version: 2.4
 Name: jac-scale
-Version: 0.1.0
+Version: 0.1.1
 Author-email: Jason Mars <jason@mars.ninja>
 Requires-Python: >=3.12
 Description-Content-Type: text/markdown
-Requires-Dist: jaclang>=0.9.9
+Requires-Dist: jaclang>=0.9.10
 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

{jac_scale-0.1.0 → jac_scale-0.1.1}/jac_scale.egg-info/requires.txt

@@ -1,4 +1,4 @@
-jaclang>=0.9.9
+jaclang>=0.9.10
 python-dotenv<2.0.0,>=1.2.1
 docker<8.0.0,>=7.1.0
 kubernetes<35.0.0,>=34.1.0

{jac_scale-0.1.0 → jac_scale-0.1.1}/pyproject.toml

@@ -1,12 +1,12 @@
 [project]
 name = "jac-scale"
-version = "0.1.0"
+version = "0.1.1"
 description = ""
 authors = [{ name = "Jason Mars", email = "jason@mars.ninja" }]
 readme = "README.md"
 requires-python = ">=3.12"
 dependencies = [
-    "jaclang>=0.9.9",
+    "jaclang>=0.9.10",
     "python-dotenv>=1.2.1,<2.0.0",
     "docker>=7.1.0,<8.0.0",
     "kubernetes>=34.1.0,<35.0.0",

jac_scale-0.1.0/jac_scale/serve.jac

@@ -1,148 +0,0 @@
-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__);
-
-class Platforms(StrEnum) {
-    has GOOGLE: str = 'google';
-}
-
-class Operations(StrEnum) {
-    has LOGIN: str = 'login',
-        REGISTER: str = 'register';
-}
-
-class 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 init(
-        self: JacAPIServer, module_name: str, port: int = 8000, base_path: str = ""
-    ) -> None;
-
-    def login(self: JacAPIServer, username: str, password: str) -> TransportResponse;
-    def register_login_endpoint(self: JacAPIServer) -> None;
-    def update_username(
-        self: JacAPIServer,
-        current_username: str,
-        new_username: str,
-        Authorization: (str | None) = None
-    ) -> TransportResponse;
-
-    def update_password(
-        self: JacAPIServer,
-        username: str,
-        current_password: str,
-        new_password: str,
-        Authorization: (str | None) = None
-    ) -> TransportResponse;
-
-    def register_update_username_endpoint(self: JacAPIServer) -> None;
-    def register_update_password_endpoint(self: JacAPIServer) -> None;
-    def create_user(
-        self: JacAPIServer, username: str, password: str
-    ) -> TransportResponse;
-
-    def refresh_token(
-        self: JacAPIServer, token: (str | None) = None
-    ) -> TransportResponse;
-
-    def register_create_user_endpoint(self: JacAPIServer) -> None;
-    def register_refresh_token_endpoint(self: JacAPIServer) -> None;
-    def get_sso(
-        self: JacAPIServer, platform: str, operation: str
-    ) -> (GoogleSSO | None);
-
-    async def sso_initiate(
-        self: JacAPIServer, platform: str, operation: str
-    ) -> (Response | TransportResponse);
-
-    async def sso_callback(
-        self: JacAPIServer, request: Request, platform: str, operation: str
-    ) -> TransportResponse;
-
-    def register_sso_endpoints(self: JacAPIServer) -> None;
-    def create_walker_callback(
-        self: JacAPIServer, walker_name: str, has_node_param: bool = False
-    ) -> Callable[..., TransportResponse];
-
-    def create_walker_parameters(
-        self: JacAPIServer, walker_name: str, invoke_on_root: bool
-    ) -> list[APIParameter];
-
-    def register_walkers_endpoints(self: JacAPIServer) -> None;
-    def create_function_callback(
-        self: JacAPIServer, func_name: str
-    ) -> Callable[..., TransportResponse];
-
-    def create_function_parameters(
-        self: JacAPIServer, func_name: str
-    ) -> list[APIParameter];
-
-    def register_functions_endpoints(self: JacAPIServer) -> None;
-    def render_page_callback(self: JacAPIServer) -> Callable[..., HTMLResponse];
-    def render_base_route_callback(
-        self: JacAPIServer, app_name: str
-    ) -> Callable[..., HTMLResponse];
-
-    def register_page_endpoint(self: JacAPIServer) -> None;
-    def serve_client_js_callback(self: JacAPIServer) -> Callable[..., Response];
-    def register_client_js_endpoint(self: JacAPIServer) -> None;
-    def register_static_file_endpoint(self: JacAPIServer) -> None;
-    def serve_static_file(self: JacAPIServer, file_path: str) -> Response;
-    def register_root_asset_endpoint(self: JacAPIServer) -> None;
-    def serve_root_asset(self: JacAPIServer, file_path: str) -> Response;
-    def _configure_openapi_security(self: JacAPIServer) -> None;
-    def start(self: JacAPIServer, dev: bool = False) -> None;
-    # HMR (Hot Module Replacement) dynamic routing methods
-    def enable_hmr(self: JacAPIServer, hot_reloader: Any) -> None;
-    def register_dynamic_walker_endpoint(self: JacAPIServer) -> None;
-    def register_dynamic_function_endpoint(self: JacAPIServer) -> None;
-    def register_dynamic_introspection_endpoints(self: JacAPIServer) -> 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');
-}

jac_scale-0.1.0/jac_scale/utilities/loggers/standard_logger.jac

@@ -1,56 +0,0 @@
-"""Standard logger implementation using Python logging."""
-import logging;
-import from typing { Any }
-import from jac_scale.abstractions.logger { Logger }
-
-"""Standard logger using Python's logging module."""
-class StandardLogger(Logger) {
-    has logger: logging.Logger;
-
-    def init(self: StandardLogger, config: dict[str, Any] = {}) -> None {
-        name = config.get('name', 'jac_scale');
-        level = config.get('level', 'INFO');
-        self.logger = logging.getLogger(name);
-        self.logger.setLevel(getattr(logging, level.upper(), logging.INFO));
-        if not self.logger.handlers {
-            handler = logging.StreamHandler();
-            formatter = logging.Formatter(
-                '%(asctime)s - %(name)s - %(levelname)s - %(message)s'
-            );
-            handler.setFormatter(formatter);
-            self.logger.addHandler(handler);
-        }
-    }
-
-    def info(self: StandardLogger, message: str, context: dict[str, Any] = {}) -> None {
-        if context {
-            self.logger.info(f"{message} | Context: {context}");
-        } else {
-            self.logger.info(message);
-        }
-    }
-
-    def error(self: StandardLogger, message: str, context: dict[str, Any] = {}) -> None {
-        if context {
-            self.logger.error(f"{message} | Context: {context}");
-        } else {
-            self.logger.error(message);
-        }
-    }
-
-    def warn(self: StandardLogger, message: str, context: dict[str, Any] = {}) -> None {
-        if context {
-            self.logger.warn(f"{message} | Context: {context}");
-        } else {
-            self.logger.warn(message);
-        }
-    }
-
-    def debug(self: StandardLogger, message: str, context: dict[str, Any] = {}) -> None {
-        if context {
-            self.logger.debug(f"{message} | Context: {context}");
-        } else {
-            self.logger.debug(message);
-        }
-    }
-}