jac-client 0.2.8__py3-none-any.whl → 0.2.10__py3-none-any.whl

jac_client/plugin/src/impl/vite_bundler.impl.jac

@@ -78,6 +78,8 @@ impl ViteBundler.create_package_json(
     }
     # Generate tsconfig.json during build time
     self.create_tsconfig();
+    # Generate config files (postcss, tailwind, etc.) from jac.toml
+    self.create_config_files();
     return package_json_path;
 }
 
@@ -375,6 +377,8 @@ impl ViteBundler.find_bundle(self: ViteBundler) -> Optional[Path] {
 
 """Run Vite build with generated config in .jac/client/configs/."""
 impl ViteBundler.build(self: ViteBundler, entry_file: Optional[Path] = None) -> None {
+    import sys;
+    import time;
     self.output_dir.mkdir(parents=True, exist_ok=True);
     generated_package_json = self._get_client_dir() / 'configs' / 'package.json';
     if not generated_package_json.exists() {
@@ -395,18 +399,31 @@ impl ViteBundler.build(self: ViteBundler, entry_file: Optional[Path] = None) ->
                 shutil.copy2(configs_package_json, build_package_json);
             }
             try {
-                # Install to .jac/client/node_modules
-                subprocess.run(
-                    ['npm', 'install'],
+                # Install to .jac/client/node_modules with progress feedback
+                print(
+                    "  ⏳ Installing npm dependencies (this may take a minute)...",
+                    flush=True
+                );
+                start_time = time.time();
+                result = subprocess.run(
+                    ['npm', 'install', '--progress'],
                     cwd=build_dir,
-                    check=True,
+                    check=False,
                     capture_output=True,
                     text=True
                 );
-            } except subprocess.CalledProcessError as e {
-                raise e from ClientBundleError(
-                    f"Failed to install npm dependencies: {e.stderr}"
-                ) ;
+                elapsed = time.time() - start_time;
+                if result.returncode != 0 {
+                    print(
+                        f"\n  ✖ npm install failed after {elapsed:.1f}s",
+                        file=sys.stderr
+                    );
+                    raise ClientBundleError(
+                        f"Failed to install npm dependencies: {result.stderr
+                        or result.stdout}"
+                    ) ;
+                }
+                print(f"  ✔ Dependencies installed ({elapsed:.1f}s)", flush=True);
             } except FileNotFoundError {
                 raise None from ClientBundleError(
                     'npm command not found. Ensure Node.js and npm are installed.'
@@ -431,15 +448,20 @@ impl ViteBundler.build(self: ViteBundler, entry_file: Optional[Path] = None) ->
             command = ['npm', 'run', 'build'];
         }
         # Run vite from client build directory so it can find node_modules
+        print("  ⏳ Building client bundle...", flush=True);
+        start_time = time.time();
         result = subprocess.run(
             command, cwd=build_dir, check=False, capture_output=True, text=True
         );
+        elapsed = time.time() - start_time;
         if result.returncode != 0 {
+            print(f"\n  ✖ Vite build failed after {elapsed:.1f}s", file=sys.stderr);
             error_msg = result.stderr or result.stdout or 'Unknown error';
             raise ClientBundleError(
                 f"Vite build failed:\n{error_msg}\nCommand: {' '.join(command)}"
             ) from None ;
         }
+        print(f"  ✔ Client bundle built ({elapsed:.1f}s)", flush=True);
     } finally {
         # Clean up temporary package.json in client build dir
         build_package_json = build_dir / 'package.json';
@@ -558,8 +580,54 @@ export default defineConfig({{
     return config_path;
 }
 
+"""Create config files from jac.toml [plugins.client.configs].
+
+Generates JavaScript config files (e.g., postcss.config.js, tailwind.config.js)
+from TOML configuration. Each key in [plugins.client.configs] becomes a config file.
+
+Example jac.toml:
+    [plugins.client.configs.postcss]
+    plugins = ["tailwindcss", "autoprefixer"]
+
+    [plugins.client.configs.tailwind]
+    content = ["./src/**/*.{js,jsx}"]
+
+This generates:
+    - .jac/client/configs/postcss.config.js
+    - .jac/client/configs/tailwind.config.js
+"""
+impl ViteBundler.create_config_files(self: ViteBundler) -> list[Path] {
+    configs = self.config_loader.get_configs();
+    if not configs {
+        return [];
+    }
+    build_dir = self._get_client_dir();
+    configs_dir = build_dir / 'configs';
+    configs_dir.mkdir(parents=True, exist_ok=True);
+    created_files: list[Path] = [];
+    for (config_name, config_data) in configs.items() {
+        config_path = configs_dir / f'{config_name}.config.js';
+
+        # Convert the TOML config to JavaScript module.exports
+        js_content = _toml_config_to_js(config_name, config_data);
+        config_path.write_text(js_content, encoding='utf-8');
+        created_files.append(config_path);
+    }
+    return created_files;
+}
+
+"""Convert TOML config data to JavaScript config file content.
+
+Generates a generic module.exports with the config data as JSON.
+"""
+def _toml_config_to_js(config_name: str, config_data: dict) -> str {
+    return f"module.exports = {json.dumps(config_data, indent=2)};\n";
+}
+
 """Start Vite dev server as a subprocess."""
 impl ViteBundler.start_dev_server(self: ViteBundler, port: int = 3000) -> Any {
+    import sys;
+    import time;
     build_dir = self._get_client_dir();
     node_modules = build_dir / 'node_modules';
     # Create/update index.html for dev server (load from compiled/ for HMR)
@@ -590,17 +658,30 @@ impl ViteBundler.start_dev_server(self: ViteBundler, port: int = 3000) -> Any {
             shutil.copy2(generated_package_json, build_package_json);
         }
         try {
-            print("[Vite] Installing dependencies...");
-            subprocess.run(
-                ['npm', 'install'],
+            print(
+                "  ⏳ Installing npm dependencies (this may take a minute)...",
+                flush=True
+            );
+            start_time = time.time();
+            result = subprocess.run(
+                ['npm', 'install', '--progress'],
                 cwd=build_dir,
-                check=True,
+                check=False,
                 capture_output=True,
                 text=True
             );
-        } except subprocess.CalledProcessError as e {
-            print(f"[Vite] Error installing dependencies: {e.stderr}");
-            raise ;
+            elapsed = time.time() - start_time;
+            if result.returncode != 0 {
+                print(
+                    f"\n  ✖ npm install failed after {elapsed:.1f}s", file=sys.stderr
+                );
+                print(f"  Error: {result.stderr or result.stdout}", file=sys.stderr);
+                raise ClientBundleError(
+                    f"Failed to install npm dependencies: {result.stderr
+                    or result.stdout}"
+                ) ;
+            }
+            print(f"  ✔ Dependencies installed ({elapsed:.1f}s)", flush=True);
         } finally {
             # Clean up temp package.json
             if build_package_json.exists() {
@@ -616,7 +697,7 @@ impl ViteBundler.start_dev_server(self: ViteBundler, port: int = 3000) -> Any {
         ) ;
     }
     config_rel = dev_config.relative_to(build_dir);
-    print(f"[Vite] Starting dev server on port {port}...");
+    logger.debug(f"Starting Vite dev server on port {port}");
     # Start Vite in dev mode (let output go to terminal for HMR visibility)
     process = subprocess.Popen(
         ['npx', 'vite', '--config', str(config_rel), '--port', str(port)],

jac_client/plugin/src/targets/desktop/sidecar/main.py

@@ -0,0 +1,144 @@
+#!/usr/bin/env python3
+"""
+Jac Sidecar Entry Point
+
+This is the entry point for the Jac backend sidecar.
+It launches the Jac runtime and starts an HTTP API server.
+
+Usage:
+    python -m jac_client.plugin.src.targets.desktop.sidecar.main [OPTIONS]
+    # Or via wrapper script: ./jac-sidecar.sh [OPTIONS]
+
+Options:
+    --module-path PATH    Path to the .jac module file (default: main.jac)
+    --port PORT          Port to bind the API server (default: 8000)
+    --base-path PATH     Base path for the project (default: current directory)
+    --host HOST          Host to bind to (default: 127.0.0.1)
+    --help               Show this help message
+"""
+
+from __future__ import annotations
+
+import argparse
+import sys
+from pathlib import Path
+
+from jaclang.cli.console import console
+
+
+def main():
+    """Main entry point for the sidecar."""
+    parser = argparse.ArgumentParser(
+        description="Jac Backend Sidecar - Runs Jac API server in a bundled executable"
+    )
+    parser.add_argument(
+        "--module-path",
+        type=str,
+        default="main.jac",
+        help="Path to the .jac module file (default: main.jac)",
+    )
+    parser.add_argument(
+        "--port",
+        type=int,
+        default=8000,
+        help="Port to bind the API server (default: 8000)",
+    )
+    parser.add_argument(
+        "--base-path",
+        type=str,
+        default=None,
+        help="Base path for the project (default: current directory)",
+    )
+    parser.add_argument(
+        "--host",
+        type=str,
+        default="127.0.0.1",
+        help="Host to bind to (default: 127.0.0.1)",
+    )
+
+    args = parser.parse_args()
+
+    # Determine base path
+    if args.base_path:
+        base_path = Path(args.base_path).resolve()
+    else:
+        # Try to find project root (look for jac.toml)
+        base_path = Path.cwd()
+        for parent in [base_path] + list(base_path.parents):
+            if (parent / "jac.toml").exists():
+                base_path = parent
+                break
+
+    # Resolve module path
+    module_path = Path(args.module_path)
+    if not module_path.is_absolute():
+        module_path = base_path / module_path
+
+    if not module_path.exists():
+        console.print(f"Error: Module file not found: {module_path}", file=sys.stderr)
+        console.print(f"  Base path: {base_path}", file=sys.stderr)
+        sys.exit(1)
+
+    # Extract module name (without .jac extension)
+    module_name = module_path.stem
+    module_base = module_path.parent
+
+    # Import Jac runtime and server
+    try:
+        # Import jaclang (must be installed via pip)
+        from jaclang.pycore.runtime import JacRuntime as Jac
+    except ImportError as e:
+        console.print(f"Error: Failed to import Jac runtime: {e}", file=sys.stderr)
+        console.print(
+            "  Make sure jaclang is installed: pip install jaclang", file=sys.stderr
+        )
+        sys.exit(1)
+
+    # Initialize Jac runtime
+    try:
+        # Import the module
+        Jac.jac_import(target=module_name, base_path=str(module_base), lng="jac")
+        if Jac.program.errors_had:
+            console.print("Error: Failed to compile module:", file=sys.stderr)
+            for error in Jac.program.errors_had:
+                console.print(f"  {error}", file=sys.stderr)
+            sys.exit(1)
+    except Exception as e:
+        console.print(
+            f"Error: Failed to load module '{module_name}': {e}", file=sys.stderr
+        )
+        import traceback
+
+        traceback.print_exc()
+        sys.exit(1)
+
+    # Create and start the API server
+    try:
+        # Get server class (allows plugins like jac-scale to provide enhanced server)
+        server_class = Jac.get_api_server_class()
+        server = server_class(
+            module_name=module_name, port=args.port, base_path=str(base_path)
+        )
+
+        console.print("Jac Sidecar starting...")
+        console.print(f"  Module: {module_name}")
+        console.print(f"  Base path: {base_path}")
+        console.print(f"  Server: http://{args.host}:{args.port}")
+        console.print("\nPress Ctrl+C to stop the server\n")
+
+        # Start the server (blocks until interrupted)
+        server.start(dev=False)
+
+    except KeyboardInterrupt:
+        console.print("\nShutting down sidecar...")
+        sys.exit(0)
+    except Exception as e:
+        console.print(f"Error: Server failed to start: {e}", file=sys.stderr)
+        import traceback
+
+        traceback.print_exc()
+        sys.exit(1)
+
+
+if __name__ == "__main__":
+    main()

jac_client/plugin/src/targets/desktop_target.jac

@@ -0,0 +1,37 @@
+"""Desktop target implementation.
+
+This target will be implemented in Phase 2.
+"""
+import from pathlib { Path }
+import from typing { Optional }
+import from jac_client.plugin.src.targets.registry { ClientTarget }
+
+"""Desktop build target (placeholder for Phase 2)."""
+class DesktopTarget(ClientTarget) {
+    def init(self: DesktopTarget) {
+        self.name = "desktop";
+        self.default = False;
+        self.requires_setup = True;
+        self.config_section = "desktop";
+        self.output_dir = Path("src-tauri/target/release/bundle");
+    }
+
+    """Setup desktop target - scaffold Tauri project structure."""
+    override def setup(self: DesktopTarget, project_dir: Path) -> None;
+
+    """Build desktop app - build web bundle first, then wrap with Tauri."""
+    override def build(
+        self: DesktopTarget,
+        entry_file: Path,
+        project_dir: Path,
+        platform: Optional[str] = None
+    ) -> Path;
+
+    """Start desktop dev server - start web dev server and launch tauri dev."""
+    override def dev(self: DesktopTarget, entry_file: Path, project_dir: Path) -> None;
+
+    """Start desktop app - build web bundle and launch Tauri with built bundle."""
+    override def start(
+        self: DesktopTarget, entry_file: Path, project_dir: Path
+    ) -> None;
+}