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

jac_client/plugin/cli.jac

@@ -426,15 +426,15 @@ def _handle_start_target(ctx: HookContext) -> None {
             ctx.set_data("cancel_return_code", 1);
             return;
         }
-        # Check if --dev flag is set
         dev_mode = ctx.get_arg("dev", False);
+        api_port = ctx.get_arg("port", 8000);
         try {
             if dev_mode {
                 # Desktop target with --dev: launch Tauri dev mode (hot reload)
-                target.dev(entry_path, project_dir);
+                target.dev(entry_path, project_dir, api_port=api_port);
             } else {
                 # Desktop target without --dev: build web bundle and launch Tauri with built bundle
-                target.start(entry_path, project_dir);
+                target.start(entry_path, project_dir, api_port=api_port);
             }
             ctx.set_data("cancel_execution", True);
             ctx.set_data("cancel_return_code", 0);

jac_client/plugin/client_runtime.cl.jac

@@ -4,7 +4,7 @@ import from 'react' { * as React }
 import from 'react' { useState as reactUseState, useEffect as reactUseEffect }
 import from 'react-dom/client' { * as ReactDOM }
 import from 'react-router-dom' {
-    HashRouter as ReactRouterHashRouter,
+    BrowserRouter as ReactRouterBrowserRouter,
     Routes as ReactRouterRoutes,
     Route as ReactRouterRoute,
     Link as ReactRouterLink,
@@ -21,7 +21,7 @@ def:pub __jacJsx(tag: any, props: dict = {}, children: any = []) -> any;
 glob:
     pub useState = reactUseState,
      useEffect = reactUseEffect,
-     Router = ReactRouterHashRouter,
+     Router = ReactRouterBrowserRouter,
      Routes = ReactRouterRoutes,
      Route = ReactRouterRoute,
      Link = ReactRouterLink,
@@ -40,6 +40,7 @@ async def:pub jacSignup(username: str, password: str) -> dict;
 async def:pub jacLogin(username: str, password: str) -> bool;
 def:pub jacLogout -> None;
 def:pub jacIsLoggedIn -> bool;
+def:pub __getApiBaseUrl -> str;
 def:pub __getLocalStorage(key: str) -> str;
 def:pub __setLocalStorage(key: str, value: str) -> None;
 def:pub __removeLocalStorage(key: str) -> None;

jac_client/plugin/impl/client_runtime.impl.jac

@@ -42,14 +42,22 @@ impl useRouter -> dict {
 }
 
 impl navigate(path: str) -> None {
-    window.location.hash = "#" + path;
+    window.history.pushState({}, "", path);
+    window.dispatchEvent(Reflect.construct(PopStateEvent, ["popstate"]));
+}
+
+impl __getApiBaseUrl -> str {
+    # globalThis.__JAC_API_BASE_URL__ is replaced by Vite's define at build time.
+    # Falls back to empty string (same-origin) when not configured.
+    return globalThis.__JAC_API_BASE_URL__ || "";
 }
 
 impl __jacSpawn(left: str, right: str = "", fields: dict = {}) -> any {
     token = __getLocalStorage("jac_token");
-    url = f"/walker/{left}";
+    base_url = __getApiBaseUrl();
+    url = f"{base_url}/walker/{left}";
     if right != "" {
-        url = f"/walker/{left}/{right}";
+        url = f"{base_url}/walker/{left}/{right}";
     }
     response = await fetch(
         url,
@@ -78,8 +86,9 @@ impl jacSpawn(left: str, right: str = "", fields: dict = {}) -> any {
 
 impl __jacCallFunction(function_name: str, args: dict = {}) -> any {
     token = __getLocalStorage("jac_token");
+    base_url = __getApiBaseUrl();
     response = await fetch(
-        f"/function/{function_name}",
+        f"{base_url}/function/{function_name}",
         {
             "method": "POST",
             "headers": {
@@ -104,8 +113,9 @@ impl __jacCallFunction(function_name: str, args: dict = {}) -> any {
 }
 
 impl jacSignup(username: str, password: str) -> dict {
+    base_url = __getApiBaseUrl();
     response = await fetch(
-        "/user/register",
+        f"{base_url}/user/register",
         {
             "method": "POST",
             "headers": {"Content-Type": "application/json"},
@@ -140,8 +150,9 @@ impl jacSignup(username: str, password: str) -> dict {
 }
 
 impl jacLogin(username: str, password: str) -> bool {
+    base_url = __getApiBaseUrl();
     response = await fetch(
-        "/user/login",
+        f"{base_url}/user/login",
         {
             "method": "POST",
             "headers": {"Content-Type": "application/json"},

jac_client/plugin/src/compiler.jac

@@ -63,4 +63,8 @@ class ViteCompiler {
     def compile_and_bundle(
         self: ViteCompiler, module: ModuleType, module_path: Path
     ) -> tuple[str, str, list[str], list[str]];
+
+    def compile(
+        self: ViteCompiler, module: ModuleType, module_path: Path
+    ) -> tuple[list[str], list[str]];
 }

jac_client/plugin/src/config_loader.jac

@@ -19,6 +19,7 @@ class JacClientConfig(PluginConfigBase) {
     override def get_default_config(self: JacClientConfig) -> dict[str, Any];
     override def load(self: JacClientConfig) -> dict[str, Any];
     def save(self: JacClientConfig) -> None;
+    def get_api_config(self: JacClientConfig) -> dict[str, Any];
     def get_vite_config(self: JacClientConfig) -> dict[str, Any];
     def get_ts_config(self: JacClientConfig) -> dict[str, Any];
     def get_configs(self: JacClientConfig) -> dict[str, Any];

jac_client/plugin/src/impl/compiler.impl.jac

@@ -12,10 +12,10 @@ impl ViteCompiler._get_client_dir(self: ViteCompiler) -> Path {
     return self.project_dir / '.jac' / 'client';
 }
 
-"""Compile module and dependencies, then bundle with Vite."""
-impl ViteCompiler.compile_and_bundle(
+"""Compile module and dependencies without bundling (for dev mode)."""
+impl ViteCompiler.compile(
     self: ViteCompiler, module: ModuleType, module_path: Path
-) -> tuple[str, str, list[str], list[str]] {
+) -> tuple[list[str], list[str]] {
     (module_js, mod, module_manifest) = self.jac_compiler.compile_module(module_path);
     collected_exports: set[str] = set(
         self.jac_compiler.extract_exports(module_manifest)
@@ -32,13 +32,22 @@ impl ViteCompiler.compile_and_bundle(
     self.compile_runtime_utils();
     self.copy_root_assets();
     self.create_entry_file(module_path);
+    # Return exports and globals without bundling
+    client_exports = sorted(collected_exports);
+    client_globals = list(collected_globals.keys());
+    return (client_exports, client_globals);
+}
+
+"""Compile module and dependencies, then bundle with Vite."""
+impl ViteCompiler.compile_and_bundle(
+    self: ViteCompiler, module: ModuleType, module_path: Path
+) -> tuple[str, str, list[str], list[str]] {
+    (client_exports, client_globals) = self.compile(module, module_path);
     # Vite handles JSX/TSX transpilation natively with Bun - no Babel needed
     # Vite builds directly from compiled/ directory
     entry_file = self.compiled_dir / '_entry.js';
     self.vite_bundler.build(entry_file=entry_file);
     (bundle_code, bundle_hash) = self.vite_bundler.read_bundle();
-    client_exports = sorted(collected_exports);
-    client_globals = list(collected_globals.keys());
     return (bundle_code, bundle_hash, client_exports, client_globals);
 }
 
@@ -187,20 +196,7 @@ impl ViteCompiler.compile_dependencies_recursively(
         output_path = self.compiled_dir / name;
     }
     output_path.parent.mkdir(parents=True, exist_ok=True);
-    # Add source file header comment for better error messages
     source_header = f"/* Source: {module_path} */\n";
-    # Add ES module exports so Vite can resolve named imports between modules
-    module_export_names = sorted(set(exports_list + list(non_root_globals.keys())));
-    if module_export_names {
-        import re;
-        # Strip any existing export declarations to avoid duplicates
-        clean_combined_js = re.sub(r'\nexport\s*\{[^}]*\}\s*;?\s*', '\n', combined_js);
-        clean_combined_js = re.sub(
-            r'\bexport\s+(let|const|var|function|class)\b', r'\1', clean_combined_js
-        );
-        export_stmt = f"\nexport {{ {', '.join(module_export_names)} }};\n";
-        combined_js = clean_combined_js + export_stmt;
-    }
     output_path.write_text(source_header + combined_js, encoding='utf-8');
     if (not manifest or not manifest.imports) {
         return;
@@ -240,34 +236,15 @@ impl ViteCompiler.compile_runtime_utils(self: ViteCompiler) -> tuple[str, list[s
     runtimeutils_exports_list = self.jac_compiler.extract_exports(
         runtimeutils_manifest
     );
-    # Include both function exports and glob exports (e.g., useState, useEffect)
     glob_names = list(runtimeutils_manifest.globals) if runtimeutils_manifest else [];
     all_exports = sorted(
         set(runtimeutils_exports_list + self.ROUTER_EXPORTS + glob_names)
     );
-    # Strip all existing export statements from compiled JS to avoid duplicates.
-    # The codegen produces `export let`, `export function`, `export class`, and
-    # `export { ... }` forms. We remove the export keyword from declarations and
-    # remove export blocks entirely, then add one comprehensive export at the end.
-    import re;
-    clean_js = re.sub(r'\nexport\s*\{[^}]*\}\s*;?\s*', '\n', runtimeutils_js);
-    clean_js = re.sub(r'\bexport\s+(let|const|var|function|class)\b', r'\1', clean_js);
-    # Append single comprehensive ES module export for Vite to resolve @jac/runtime
-    export_names = [
-        e
-        for e in all_exports
-        if not e.startswith('_')
-    ];
-    # Also include internal names that are imported by compiled modules
-    internal_exports = ['__jacJsx', '__jacSpawn', '__jacCallFunction'];
-    all_export_names = sorted(set(export_names + internal_exports));
-    export_stmt = f"\nexport {{ {', '.join(all_export_names)} }};\n";
-    combined_runtime_utils_js = clean_js + export_stmt;
     self.compiled_dir.mkdir(parents=True, exist_ok=True);
     (self.compiled_dir / 'client_runtime.js').write_text(
-        combined_runtime_utils_js, encoding='utf-8'
+        runtimeutils_js, encoding='utf-8'
     );
-    return (combined_runtime_utils_js, all_exports);
+    return (runtimeutils_js, all_exports);
 }
 
 """Initialize the Vite compiler."""

jac_client/plugin/src/impl/config_loader.impl.jac

@@ -19,6 +19,7 @@ impl JacClientConfig.get_plugin_name(self: JacClientConfig) -> str {
 """Get default configuration structure for client."""
 impl JacClientConfig.get_default_config(self: JacClientConfig) -> dict[str, Any] {
     return {
+        'api': {'base_url': ''},
         'vite': {
             'plugins': [],
             'lib_imports': [],
@@ -60,6 +61,7 @@ impl JacClientConfig.load(self: JacClientConfig) -> dict[str, Any] {
     else {};
     # Build user config in the expected internal format
     user_config: dict[str, Any] = {
+        'api': client_config.get('api', {}),
         'vite': client_config.get('vite', {}),
         'ts': client_config.get('ts', {}),
         'configs': client_config.get('configs', {}),
@@ -81,6 +83,12 @@ impl JacClientConfig.get_package_config(self: JacClientConfig) -> dict[str, Any]
     return config.get('package', {});
 }
 
+"""Get API configuration (base_url for backend)."""
+impl JacClientConfig.get_api_config(self: JacClientConfig) -> dict[str, Any] {
+    config = self.load();
+    return config.get('api', {});
+}
+
 """Get Vite-specific configuration."""
 impl JacClientConfig.get_vite_config(self: JacClientConfig) -> dict[str, Any] {
     config = self.load();

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

@@ -216,6 +216,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 +237,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 +375,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
@@ -555,15 +578,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 +630,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
   }},

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;
 }