jac-client 0.2.12__py3-none-any.whl → 0.2.14__py3-none-any.whl

jac_client/plugin/src/impl/route_scanner.impl.jac

@@ -0,0 +1,201 @@
+import re;
+import from pathlib { Path }
+import from operator { attrgetter }
+import from jaclang.runtimelib.client_bundle { ClientBundleError }
+
+impl RouteEntry.init(
+    self: RouteEntry,
+    path: str,
+    component_import: str,
+    file_path: Path,
+    auth_required: bool = False,
+    is_layout: bool = False,
+    is_catch_all: bool = False,
+    children: (list[RouteEntry] | None) = None
+) {
+    self.path = path;
+    self.component_import = component_import;
+    self.file_path = file_path;
+    self.auth_required = auth_required;
+    self.is_layout = is_layout;
+    self.is_catch_all = is_catch_all;
+    self.children = children if children is not None else [];
+}
+
+impl RouteScanner.init(self: RouteScanner, project_root: Path) {
+    self.project_root = project_root;
+    self.pages_dir = project_root / self.PAGES_DIR_NAME;
+    self._routes: list[RouteEntry] = [];
+    self._layouts: dict[(str, RouteEntry)] = {};
+    self._page_files: list[Path] = [];
+}
+
+impl RouteScanner.has_pages_dir(self: RouteScanner) -> bool {
+    return self.pages_dir.exists() and self.pages_dir.is_dir();
+}
+
+impl RouteScanner.scan(self: RouteScanner) -> list[RouteEntry] {
+    if not self.has_pages_dir() {
+        return [];
+    }
+    self._routes = [];
+    self._layouts = {};
+    self._page_files = [];
+    self._routes = self._scan_directory(self.pages_dir);
+    self._detect_collisions(self._routes);
+    return self._routes;
+}
+
+"""Return layouts discovered during the last scan, keyed by URL prefix."""
+impl RouteScanner.get_layouts(self: RouteScanner) -> dict[(str, RouteEntry)] {
+    return self._layouts;
+}
+
+impl RouteScanner.get_page_files(self: RouteScanner) -> list[Path] {
+    return self._page_files;
+}
+
+impl RouteScanner._scan_directory(
+    self: RouteScanner,
+    dir_path: Path,
+    url_prefix: str = "",
+    auth_required: bool = False
+) -> list[RouteEntry] {
+    routes: list[RouteEntry] = [];
+    # Collect and sort entries for deterministic route ordering
+    entries = sorted(dir_path.iterdir(), key=attrgetter('name'));
+    for entry in entries {
+        if entry.is_dir() {
+            dir_name = entry.name;
+            # Route groups: (public), (auth), etc.
+            group_match = re.match(r'^\((\w+)\)$', dir_name);
+            if group_match {
+                group_name = group_match.group(1);
+                group_auth = auth_required or (group_name == self.AUTH_GROUP_NAME);
+                # Route groups don't add to the URL path
+                child_routes = self._scan_directory(entry, url_prefix, group_auth);
+                routes.extend(child_routes);
+            } else {
+                # Regular subdirectory — adds to URL path
+                child_prefix = f"{url_prefix}/{dir_name}";
+                child_routes = self._scan_directory(entry, child_prefix, auth_required);
+                routes.extend(child_routes);
+            }
+        } elif entry.is_file() and entry.suffix == '.jac' {
+            if any(suffix in entry.name for suffix in self.SKIP_SUFFIXES) {
+                continue;
+            }
+            stem = entry.stem;
+            # layout.jac — not a route, it's a layout wrapper
+            if stem == self.LAYOUT_FILENAME {
+                layout_key = url_prefix or "/";
+                if layout_key in self._layouts {
+                    raise ClientBundleError(
+                        f"Layout collision: '{layout_key}' has layouts from both "
+                        f"'{self._layouts[layout_key].file_path}' and '{entry}'. "
+                        f"Remove one of them."
+                    ) ;
+                }
+                component_name = self._file_to_component_name(entry);
+                layout_entry = RouteEntry(
+                    path=layout_key,
+                    component_import=component_name,
+                    file_path=entry,
+                    is_layout=True
+                );
+                self._layouts[layout_key] = layout_entry;
+                self._page_files.append(entry);
+                continue;
+            }
+            route_segment = self._file_to_route_path(stem);
+            is_catch_all = stem.startswith('[...');
+            if stem == self.INDEX_FILENAME {
+                # index.jac maps to the directory path
+                route_path = url_prefix or "/";
+            } else {
+                route_path = f"{url_prefix}/{route_segment}";
+            }
+            component_name = self._file_to_component_name(entry);
+            route = RouteEntry(
+                path=route_path,
+                component_import=component_name,
+                file_path=entry,
+                auth_required=auth_required,
+                is_catch_all=is_catch_all
+            );
+            routes.append(route);
+            self._page_files.append(entry);
+        }
+    }
+    return routes;
+}
+
+"""Convert a filename stem to a React Router route path segment.
+
+    index       → (empty, handled by caller)
+    about       → about
+    [id]        → :id
+    [...slug]   → *
+"""
+impl RouteScanner._file_to_route_path(self: RouteScanner, filename: str) -> str {
+    # Catch-all: [...slug] → *
+    catch_all_match = re.match(r'^\[\.\.\.(\w+)\]$', filename);
+    if catch_all_match {
+        return "*";
+    }
+    # Dynamic segment: [id] → :id
+    dynamic_match = re.match(r'^\[(\w+)\]$', filename);
+    if dynamic_match {
+        return f":{dynamic_match.group(1)}";
+    }
+    # Static segment
+    return filename;
+}
+
+"""Generate a unique component import name from a page file path.
+
+    pages/index.jac             → PagesIndex
+    pages/about.jac             → PagesAbout
+    pages/(auth)/dashboard.jac  → PagesDashboard
+    pages/users/[id].jac        → PagesUsersId
+    pages/[...slug].jac         → PagesSlug
+"""
+impl RouteScanner._file_to_component_name(self: RouteScanner, file_path: Path) -> str {
+    try {
+        relative = file_path.relative_to(self.pages_dir);
+    } except ValueError {
+        relative = Path(file_path.name);
+    }
+    parts: list[str] = [];
+    for part in relative.with_suffix('').parts {
+        # Skip route group directories like (auth), (public)
+        if re.match(r'^\(\w+\)$', part) {
+            continue;
+        }
+        # Strip catch-all prefix: [...slug] → slug
+        clean = re.sub(r'^\[\.\.\.(\w+)\]$', r'\1', part);
+        # Strip dynamic brackets: [id] → id
+        clean = re.sub(r'^\[(\w+)\]$', r'\1', clean);
+        parts.append(clean[0].upper() + clean[1:] if len(clean) > 0 else clean);
+    }
+    return self.COMPONENT_PREFIX + "".join(parts);
+}
+
+impl RouteScanner._detect_collisions(
+    self: RouteScanner, routes: list[RouteEntry]
+) -> None {
+    seen: dict[(str, Path)] = {};
+    for route in routes {
+        if route.is_layout {
+            continue;
+        }
+        if route.path in seen {
+            raise ClientBundleError(
+                f"Route collision: '{route.path}' is defined by both "
+                f"'{seen[route.path]}' and '{route.file_path}'. "
+                f"Remove one of them."
+            ) ;
+        }
+        seen[route.path] = route.file_path;
+    }
+}

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

@@ -1,11 +1,17 @@
+import from jaclang.cli.console { console }
+
 """Get the client build directory from project config."""
 impl ViteBundler._get_client_dir(self: ViteBundler) -> Path {
-    # Try to get from project config
+    # Try to get from project config, but only if it matches our project dir
     try {
         import from jaclang.project.config { get_config }
         config = get_config();
         if config is not None {
-            return config.get_client_dir();
+            config_root = config.project_root;
+            if config_root is not None
+            and config_root.resolve() == self.project_dir.resolve() {
+                return config.get_client_dir();
+            }
         }
     } except ImportError { }
     # Fallback to default
@@ -216,6 +222,19 @@ impl ViteBundler._format_plugin_options(self: ViteBundler, options: dict) -> str
     return '{ ' + ', '.join(items) + ' }';
 }
 
+"""Resolve the API base URL using a consistent priority chain.
+
+Priority: jac.toml base_url > direct override > env var (desktop start) > "" (same-origin)
+"""
+impl ViteBundler._resolve_api_base_url(
+    self: ViteBundler, api_base_url_override: str = ""
+) -> str {
+    api_config_data = self.config_loader.get_api_config();
+    toml_base_url = api_config_data.get('base_url', '');
+    env_override = os.environ.get(API_BASE_URL_ENV_VAR, '');
+    return toml_base_url or api_base_url_override or env_override;
+}
+
 """Get a valid JavaScript variable name from plugin module name."""
 impl ViteBundler._get_plugin_var_name(self: ViteBundler, plugin_name: str) -> str {
     name = plugin_name.split('/')[-1];
@@ -224,13 +243,20 @@ impl ViteBundler._get_plugin_var_name(self: ViteBundler, plugin_name: str) -> st
     return name;
 }
 
-"""Create vite.config.js from config.json during bundling."""
-impl ViteBundler.create_vite_config(self: ViteBundler, entry_file: Path) -> Path {
+"""Create vite.config.js from config.json during bundling.
+
+api_base_url_override: overrides jac.toml base_url for desktop targets
+    where the CLI knows the backend port at startup time.
+"""
+impl ViteBundler.create_vite_config(
+    self: ViteBundler, entry_file: Path, api_base_url_override: str = ""
+) -> Path {
     build_dir = self._get_client_dir();
     build_dir.mkdir(parents=True, exist_ok=True);
     configs_dir = build_dir / 'configs';
     configs_dir.mkdir(exist_ok=True);
     vite_config_data = self.config_loader.get_vite_config();
+    api_base_url = self._resolve_api_base_url(api_base_url_override);
     config_path = configs_dir / 'vite.config.js';
     # TypeScript is always enabled by default
     try {
@@ -355,6 +381,9 @@ function jacSourceMapper() {{
  */
 
 export default defineConfig({{
+  define: {{
+    'globalThis.__JAC_API_BASE_URL__': '"{api_base_url}"',
+  }},
   plugins: [
     jacSourceMapper(),{(newline + plugins_str + newline + '  ') if plugins_str else ''}],
   root: buildDir, // base folder (.jac/client/) so vite can find node_modules
@@ -459,7 +488,7 @@ impl ViteBundler.build(self: ViteBundler, entry_file: Optional[Path] = None) ->
             }
             try {
                 # Install to .jac/client/node_modules with progress feedback
-                print("\n  ⏳ Installing dependencies...\n", flush=True);
+                console.print("\n  ⏳ Installing dependencies...\n");
                 start_time = time.time();
                 result = subprocess.run(
                     ['bun', 'install'],
@@ -474,7 +503,7 @@ impl ViteBundler.build(self: ViteBundler, entry_file: Optional[Path] = None) ->
                     error_msg = f"Dependency installation failed after {elapsed:.1f}s\n\n{error_output}\nCommand: bun install";
                     raise ClientBundleError(error_msg) from None ;
                 }
-                print(f"\n  ✔ Dependencies installed ({elapsed:.1f}s)", flush=True);
+                console.print(f"\n  ✔ Dependencies installed ({elapsed:.1f}s)");
             } except FileNotFoundError {
                 # This shouldn't happen since we check for bun at the start
                 raise ClientBundleError(
@@ -507,7 +536,7 @@ impl ViteBundler.build(self: ViteBundler, entry_file: Optional[Path] = None) ->
             command = ['bun', 'run', 'build'];
         }
         # Run vite from client build directory so it can find node_modules
-        print("\n  ⏳ Building client bundle...\n", flush=True);
+        console.print("\n  ⏳ Building client bundle...\n");
         start_time = time.time();
         result = subprocess.run(
             command, cwd=build_dir, check=False, text=True, capture_output=True
@@ -520,7 +549,7 @@ impl ViteBundler.build(self: ViteBundler, entry_file: Optional[Path] = None) ->
             )}";
             raise ClientBundleError(error_msg) from None ;
         }
-        print(f"\n  ✔ Client bundle built ({elapsed:.1f}s)", flush=True);
+        console.print(f"\n  ✔ Client bundle built ({elapsed:.1f}s)");
     } finally {
         # Clean up temporary package.json in client build dir
         build_package_json = build_dir / 'package.json';
@@ -555,15 +584,23 @@ impl ViteBundler.init(
     self.output_dir = output_dir or (self._get_client_dir() / 'dist');
 }
 
-"""Create a dev-mode vite config with API proxy for HMR."""
+"""Create a dev-mode vite config with API proxy for HMR.
+
+api_base_url_override: when set, API calls go directly to this URL
+    instead of via proxy (used by desktop targets).
+"""
 impl ViteBundler.create_dev_vite_config(
-    self: ViteBundler, entry_file: Path, api_port: int = 8000
+    self: ViteBundler,
+    entry_file: Path,
+    api_port: int = 8000,
+    api_base_url_override: str = ""
 ) -> Path {
     build_dir = self._get_client_dir();
     build_dir.mkdir(parents=True, exist_ok=True);
     configs_dir = build_dir / 'configs';
     configs_dir.mkdir(exist_ok=True);
     config_path = configs_dir / 'vite.dev.config.js';
+    api_base_url = self._resolve_api_base_url(api_base_url_override);
     # Get entry file relative path
     try {
         entry_relative = entry_file.relative_to(build_dir).as_posix();
@@ -599,9 +636,13 @@ const projectRoot = path.resolve(__dirname, "../../..");
  * Proxies API routes to Python server at localhost:{api_port}
  */
 export default defineConfig({{
+  define: {{
+    'globalThis.__JAC_API_BASE_URL__': '"{api_base_url}"',
+  }},
   plugins: [react()],
   root: buildDir,
   publicDir: false,
+  appType: 'spa',
   build: {{
     sourcemap: true, // Enable source maps for better error messages
   }},
@@ -731,19 +772,17 @@ impl ViteBundler.start_dev_server(self: ViteBundler, port: int = 3000) -> Any {
             shutil.copy2(generated_package_json, build_package_json);
         }
         try {
-            print("\n  ⏳ Installing dependencies...\n", flush=True);
+            console.print("\n  ⏳ Installing dependencies...\n");
             start_time = time.time();
             result = subprocess.run(
                 ['bun', 'install'], cwd=build_dir, check=False, text=True
             );
             elapsed = time.time() - start_time;
             if result.returncode != 0 {
-                print(
-                    f"\n  ✖ bun install failed after {elapsed:.1f}s", file=sys.stderr
-                );
+                console.error(f"\n  ✖ bun install failed after {elapsed:.1f}s");
                 raise ClientBundleError("Failed to install dependencies") ;
             }
-            print(f"\n  ✔ Dependencies installed ({elapsed:.1f}s)", flush=True);
+            console.print(f"\n  ✔ Dependencies installed ({elapsed:.1f}s)");
         } finally {
             # Clean up temp package.json
             if build_package_json.exists() {

jac_client/plugin/src/route_scanner.jac

@@ -0,0 +1,44 @@
+"""File-based route scanner for pages/ directory convention."""
+import from pathlib { Path }
+
+"""A single route entry derived from a file in pages/."""
+class RouteEntry {
+    def init(
+        self: RouteEntry,
+        path: str,
+        component_import: str,
+        file_path: Path,
+        auth_required: bool = False,
+        is_layout: bool = False,
+        is_catch_all: bool = False,
+        children: (list[RouteEntry] | None) = None
+    );
+}
+
+"""Scans a pages/ directory and produces a route tree."""
+class RouteScanner {
+    with entry {
+        PAGES_DIR_NAME = 'pages';
+        LAYOUT_FILENAME = 'layout';
+        INDEX_FILENAME = 'index';
+        AUTH_GROUP_NAME = 'auth';
+        COMPONENT_PREFIX = 'Pages';
+        SKIP_SUFFIXES = ['.cl.', '.impl.', '.test.'];
+    }
+
+    def init(self: RouteScanner, project_root: Path);
+    def has_pages_dir(self: RouteScanner) -> bool;
+    def scan(self: RouteScanner) -> list[RouteEntry];
+    def get_layouts(self: RouteScanner) -> dict[(str, RouteEntry)];
+    def get_page_files(self: RouteScanner) -> list[Path];
+    def _scan_directory(
+        self: RouteScanner,
+        dir_path: Path,
+        url_prefix: str = "",
+        auth_required: bool = False
+    ) -> list[RouteEntry];
+
+    def _file_to_route_path(self: RouteScanner, filename: str) -> str;
+    def _file_to_component_name(self: RouteScanner, file_path: Path) -> str;
+    def _detect_collisions(self: RouteScanner, routes: list[RouteEntry]) -> None;
+}

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

@@ -11,7 +11,7 @@ Usage:
 
 Options:
     --module-path PATH    Path to the .jac module file (default: main.jac)
-    --port PORT          Port to bind the API server (default: 8000)
+    --port PORT          Port to bind the API server (default: 8000, 0 = auto)
     --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
@@ -20,10 +20,16 @@ Options:
 from __future__ import annotations
 
 import argparse
+import socket
 import sys
 from pathlib import Path
 
-from jaclang.cli.console import console
+
+def _find_free_port(host: str = "127.0.0.1") -> int:
+    """Find and return a free port on the given host."""
+    with socket.socket(socket.AF_INET, socket.SOCK_STREAM) as s:
+        s.bind((host, 0))
+        return s.getsockname()[1]
 
 
 def main():
@@ -41,7 +47,7 @@ def main():
         "--port",
         type=int,
         default=8000,
-        help="Port to bind the API server (default: 8000)",
+        help="Port to bind the API server (default: 8000, 0 = auto-assign free port)",
     )
     parser.add_argument(
         "--base-path",
@@ -58,6 +64,10 @@ def main():
 
     args = parser.parse_args()
 
+    port = args.port
+    if port == 0:
+        port = _find_free_port(args.host)
+
     # Determine base path
     if args.base_path:
         base_path = Path(args.base_path).resolve()
@@ -75,8 +85,9 @@ def main():
         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)
+        # Console not yet available (jaclang not imported)
+        sys.stderr.write(f"Error: Module file not found: {module_path}\n")
+        sys.stderr.write(f"  Base path: {base_path}\n")
         sys.exit(1)
 
     # Extract module name (without .jac extension)
@@ -88,25 +99,25 @@ def main():
         # 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
-        )
+        # Console not available (jaclang import failed)
+        sys.stderr.write(f"Error: Failed to import Jac runtime: {e}\n")
+        sys.stderr.write("  Make sure jaclang is installed: pip install jaclang\n")
         sys.exit(1)
 
+    # Get the console now that jaclang is available
+    from jaclang.cli.console import console
+
     # 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)
+            console.error("Failed to compile module:")
             for error in Jac.program.errors_had:
-                console.print(f"  {error}", file=sys.stderr)
+                console.print(f"  {error}", style="error")
             sys.exit(1)
     except Exception as e:
-        console.print(
-            f"Error: Failed to load module '{module_name}': {e}", file=sys.stderr
-        )
+        console.error(f"Failed to load module '{module_name}': {e}")
         import traceback
 
         traceback.print_exc()
@@ -117,23 +128,31 @@ def main():
         # 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)
+            module_name=module_name, port=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")
+        # MUST be raw stdout — Tauri host reads this line to discover the port.
+        # Cannot use console here; Tauri parses this exact format.
+        sys.stdout.write(f"JAC_SIDECAR_PORT={port}\n")
+        sys.stdout.flush()
+
+        # stderr: Tauri drops the stdout pipe after reading the port marker,
+        # so any further stdout writes raise BrokenPipeError.
+        console.print("Jac Sidecar starting...", style="bold")
+        console.print(f"  Module: {module_name}", style="muted")
+        console.print(f"  Base path: {base_path}", style="muted")
+        console.print(f"  Server: http://{args.host}:{port}", style="muted")
+        console.print("")
 
         # Start the server (blocks until interrupted)
-        server.start(dev=False)
+        # no_client=True: client bundle is already embedded in the Tauri webview
+        server.start(dev=False, no_client=True)
 
     except KeyboardInterrupt:
-        console.print("\nShutting down sidecar...")
+        console.print("\nShutting down sidecar...", style="muted")
         sys.exit(0)
     except Exception as e:
-        console.print(f"Error: Server failed to start: {e}", file=sys.stderr)
+        console.error(f"Server failed to start: {e}")
         import traceback
 
         traceback.print_exc()

jac_client/plugin/src/targets/desktop_target.jac

@@ -28,10 +28,12 @@ class DesktopTarget(ClientTarget) {
     ) -> 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;
+    override def dev(
+        self: DesktopTarget, entry_file: Path, project_dir: Path, api_port: int = 8000
+    ) -> None;
 
     """Start desktop app - build web bundle and launch Tauri with built bundle."""
     override def start(
-        self: DesktopTarget, entry_file: Path, project_dir: Path
+        self: DesktopTarget, entry_file: Path, project_dir: Path, api_port: int = 8000
     ) -> None;
 }