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

jac_client/plugin/src/targets/impl/desktop_target.impl.jac

@@ -3,6 +3,8 @@ import from pathlib { Path }
 import from typing { Optional, Any }
 import from jaclang.cli.console { console }
 import from jaclang.project.config { get_config }
+import from jac_client.plugin.src.config_loader { JacClientConfig }
+import from jac_client.plugin.src.vite_bundler { API_BASE_URL_ENV_VAR }
 import subprocess;
 import json;
 import shutil;
@@ -10,6 +12,15 @@ import os;
 import platform;
 import stat;
 
+def _make_localhost_url(port: int) -> str {
+    return f"http://127.0.0.1:{port}";
+}
+
+def _get_toml_api_base_url(project_dir: Path) -> str {
+    config_loader = JacClientConfig(project_dir);
+    return config_loader.get_api_config().get('base_url', '');
+}
+
 """Setup desktop target - scaffold Tauri project structure."""
 impl DesktopTarget.setup(self: DesktopTarget, project_dir: Path) -> None {
     # Define tauri_dir early so we can use it in error handling
@@ -242,20 +253,7 @@ def _generate_tauri_config(
             "devUrl": "http://localhost:5173",
             "frontendDist": "../.jac/client/dist"
         },
-        "app": {
-            "windows": [
-                {
-                    "title": name,
-                    "width": 1200,
-                    "height": 800,
-                    "minWidth": 800,
-                    "minHeight": 600,
-                    "resizable": True,
-                    "fullscreen": False
-                }
-            ],
-            "security": {"csp": None}
-        },
+        "app": {"windows": [], "security": {"csp": None}},
         "bundle": {"active": True, "targets": "all", "icon": []},
         "plugins": {}
     };
@@ -462,154 +460,265 @@ except ImportError:
     );
 }
 
-"""Generate main.rs."""
-def _generate_main_rs(tauri_dir: Path) -> None {
-    main_rs = '''// Prevents additional console window on Windows in release, DO NOT REMOVE!!
+"""Generate main.rs.
+
+api_base_url: embed this URL and skip sidecar port discovery.
+    Empty string means dynamic discovery at runtime.
+"""
+def _generate_main_rs(tauri_dir: Path, api_base_url: str = "") -> None {
+    import json;
+
+    # Read window config from tauri.conf.json (before we clear windows array)
+    config_path = tauri_dir / "tauri.conf.json";
+    win_title = "Jac App";
+    win_width = 1200;
+    win_height = 800;
+    win_min_width = 800;
+    win_min_height = 600;
+    win_resizable = "true";
+
+    if config_path.exists() {
+        with open(config_path, "r") as f {
+            config = json.load(f);
+        }
+        windows = config.get("app", {}).get("windows", []);
+        if windows {
+            win = windows[0];
+            win_title = win.get("title", win_title);
+            win_width = win.get("width", win_width);
+            win_height = win.get("height", win_height);
+            win_min_width = win.get("minWidth", win_min_width);
+            win_min_height = win.get("minHeight", win_min_height);
+            win_resizable = "true" if win.get("resizable", True) else "false";
+        } else {
+            # No windows in config — fall back to productName for title
+            win_title = config.get("productName", win_title);
+        }
+    }
+
+    main_rs = f'''// Prevents additional console window on Windows in release, DO NOT REMOVE!!
 #![cfg_attr(not(debug_assertions), windows_subsystem = "windows")]
 
-use std::process::{Command, Child};
+use std::io::{{BufRead, BufReader}};
+use std::process::{{Command, Child, Stdio}};
 use std::sync::Mutex;
 use tauri::Manager;
 
 // Global storage for sidecar process
 static SIDECAR_PROCESS: Mutex<Option<Child>> = Mutex::new(None);
+static API_BASE_URL: Mutex<Option<String>> = Mutex::new(None);
+
+/// User-configured base URL from jac.toml (empty = dynamic discovery)
+const CONFIGURED_BASE_URL: &str = "{api_base_url}";
+
+fn find_and_start_sidecar(app: &tauri::AppHandle) -> Result<(), Box<dyn std::error::Error>> {{
+    // Skip sidecar launch — user manages their own backend
+    if !CONFIGURED_BASE_URL.is_empty() {{
+        let mut url = API_BASE_URL.lock().unwrap();
+        *url = Some(CONFIGURED_BASE_URL.to_string());
+        eprintln!("Using configured API base URL: {{}}", CONFIGURED_BASE_URL);
+        return Ok(());
+    }}
 
-fn find_and_start_sidecar(app: &tauri::AppHandle) -> Result<(), Box<dyn std::error::Error>> {
     // Try to find the sidecar in bundled resources
     let resource_dir = app.path().resource_dir()?;
 
     // Possible sidecar names
-    let sidecar_names = if cfg!(windows) {
+    let sidecar_names = if cfg!(windows) {{
         vec!["binaries/jac-sidecar.exe", "binaries/jac-sidecar.bat"]
-    } else {
+    }} else {{
         vec!["binaries/jac-sidecar", "binaries/jac-sidecar.sh"]
-    };
+    }};
 
     let mut sidecar_path = None;
-    for name in &sidecar_names {
+    for name in &sidecar_names {{
         let path = resource_dir.join(name);
-        if path.exists() {
+        if path.exists() {{
             sidecar_path = Some(path);
             break;
-        }
-    }
+        }}
+    }}
 
     // If not found in resources, try relative to executable
-    if sidecar_path.is_none() {
-        if let Ok(exe_path) = std::env::current_exe() {
-            if let Some(exe_dir) = exe_path.parent() {
+    if sidecar_path.is_none() {{
+        if let Ok(exe_path) = std::env::current_exe() {{
+            if let Some(exe_dir) = exe_path.parent() {{
                 let exe_dir = exe_dir.to_path_buf();
-                for name in &sidecar_names {
+                for name in &sidecar_names {{
                     let path = exe_dir.join(name);
-                    if path.exists() {
+                    if path.exists() {{
                         sidecar_path = Some(path);
                         break;
-                    }
-                }
-            }
-        }
-    }
+                    }}
+                }}
+            }}
+        }}
+    }}
 
-    if let Some(sidecar_path) = sidecar_path {
+    if let Some(sidecar_path) = sidecar_path {{
         // Determine module path (try to find main.jac relative to app)
-        let module_path = if let Ok(exe_path) = std::env::current_exe() {
-            if let Some(exe_dir) = exe_path.parent() {
+        let module_path = if let Ok(exe_path) = std::env::current_exe() {{
+            if let Some(exe_dir) = exe_path.parent() {{
                 // Look for main.jac in parent directories
                 let mut current = exe_dir.to_path_buf();
-                loop {
+                loop {{
                     let main_jac = current.join("main.jac");
-                    if main_jac.exists() {
+                    if main_jac.exists() {{
                         break Some(main_jac);
-                    }
-                    if !current.pop() {
+                    }}
+                    if !current.pop() {{
                         break None;
-                    }
-                }
-            } else {
+                    }}
+                }}
+            }} else {{
                 None
-            }
-        } else {
+            }}
+        }} else {{
             None
-        };
+        }};
 
         // Build command to start sidecar
-        let mut cmd = if cfg!(windows) {
-            if sidecar_path.extension().and_then(|s| s.to_str()) == Some("bat") {
+        let mut cmd = if cfg!(windows) {{
+            if sidecar_path.extension().and_then(|s| s.to_str()) == Some("bat") {{
                 let mut c = Command::new("cmd");
                 c.arg("/C");
                 c.arg(&sidecar_path);
                 c
-            } else {
+            }} else {{
                 Command::new(&sidecar_path)
-            }
-        } else {
-            if sidecar_path.extension().and_then(|s| s.to_str()) == Some("sh") {
+            }}
+        }} else {{
+            if sidecar_path.extension().and_then(|s| s.to_str()) == Some("sh") {{
                 let mut c = Command::new("sh");
                 c.arg(&sidecar_path);
                 c
-            } else {
+            }} else {{
                 Command::new(&sidecar_path)
-            }
-        };
+            }}
+        }};
 
         // Add arguments
-        if let Some(ref mp) = module_path {
+        if let Some(ref mp) = module_path {{
             cmd.arg("--module-path").arg(mp);
-        } else {
+        }} else {{
             cmd.arg("--module-path").arg("main.jac");
-        }
-        cmd.arg("--port").arg("8000");
+        }}
+        cmd.arg("--port").arg("0"); // OS assigns free port
         cmd.arg("--host").arg("127.0.0.1");
 
-        // Spawn sidecar process
-        match cmd.spawn() {
-            Ok(child) => {
+        cmd.stdout(Stdio::piped());
+        cmd.stderr(Stdio::inherit());
+
+        match cmd.spawn() {{
+            Ok(mut child) => {{
+                let mut discovered_port: Option<u16> = None;
+                if let Some(stdout) = child.stdout.take() {{
+                    let reader = BufReader::new(stdout);
+                    for line in reader.lines() {{
+                        match line {{
+                            Ok(line) => {{
+                                eprintln!("[sidecar] {{}}", line);
+                                if let Some(port_str) = line.strip_prefix("JAC_SIDECAR_PORT=") {{
+                                    if let Ok(port) = port_str.trim().parse::<u16>() {{
+                                        discovered_port = Some(port);
+                                        break;
+                                    }}
+                                }}
+                            }}
+                            Err(_) => break,
+                        }}
+                    }}
+                }}
+
                 let mut process = SIDECAR_PROCESS.lock().unwrap();
                 *process = Some(child);
-                eprintln!("Sidecar started successfully");
+
+                if let Some(port) = discovered_port {{
+                    let base_url = format!("http://127.0.0.1:{{}}", port);
+                    eprintln!("Sidecar started on {{}}", base_url);
+                    let mut url = API_BASE_URL.lock().unwrap();
+                    *url = Some(base_url);
+                }} else {{
+                    eprintln!("Error: Sidecar started but did not report its port.");
+                    eprintln!("       Expected JAC_SIDECAR_PORT=<port> on stdout.");
+                    return Err("Sidecar port discovery failed".into());
+                }}
                 Ok(())
-            }
-            Err(e) => {
-                eprintln!("Failed to start sidecar: {}", e);
+            }}
+            Err(e) => {{
+                eprintln!("Failed to start sidecar: {{}}", e);
                 Err(Box::new(e))
-            }
-        }
-    } else {
+            }}
+        }}
+    }} else {{
         eprintln!("Sidecar not found in resources, skipping auto-start");
         Ok(())
-    }
-}
+    }}
+}}
 
-fn stop_sidecar() {
+fn stop_sidecar() {{
     let mut process = SIDECAR_PROCESS.lock().unwrap();
-    if let Some(mut child) = process.take() {
+    if let Some(mut child) = process.take() {{
         let _ = child.kill();
         let _ = child.wait();
         eprintln!("Sidecar stopped");
-    }
-}
+    }}
+}}
 
-fn main() {
+fn main() {{
     tauri::Builder::default()
-        .setup(|app| {
-            // Try to start sidecar on app startup
-            if let Err(e) = find_and_start_sidecar(app.handle()) {
-                eprintln!("Warning: Could not start sidecar: {}", e);
-            }
+        .setup(|app| {{
+            // Start sidecar to discover dynamic port
+            if let Err(e) = find_and_start_sidecar(app.handle()) {{
+                eprintln!("Warning: Could not start sidecar: {{}}", e);
+            }}
+
+            // Build initialization script with API base URL
+            let init_js = {{
+                let url = API_BASE_URL.lock().unwrap();
+                match *url {{
+                    Some(ref base_url) => {{
+                        eprintln!("Injecting API base URL: {{}}", base_url);
+                        format!(
+                            "globalThis.__JAC_API_BASE_URL__ = '{{}}';",
+                            base_url
+                        )
+                    }}
+                    None => String::new(),
+                }}
+            }};
+
+            // Create window with initialization_script (runs BEFORE page JS)
+            let mut builder = tauri::WebviewWindowBuilder::new(
+                app,
+                "main",
+                tauri::WebviewUrl::App("index.html".into())
+            )
+            .title("{win_title}")
+            .inner_size({win_width}.0, {win_height}.0)
+            .min_inner_size({win_min_width}.0, {win_min_height}.0)
+            .resizable({win_resizable});
+
+            if !init_js.is_empty() {{
+                builder = builder.initialization_script(&init_js);
+            }}
+
+            builder.build()?;
+
             Ok(())
-        })
-        .on_window_event(|_window, event| {
+        }})
+        .on_window_event(|_window, event| {{
             // Clean up sidecar when last window closes
-            if matches!(event, tauri::WindowEvent::CloseRequested { .. }) {
+            if matches!(event, tauri::WindowEvent::CloseRequested {{ .. }}) {{
                 stop_sidecar();
-            }
-        })
+            }}
+        }})
         .run(tauri::generate_context!())
         .expect("error while running tauri application");
 
     // Ensure sidecar is stopped on exit
     stop_sidecar();
-}
+}}
 ''';
 
     main_path = tauri_dir / "src" / "main.rs";
@@ -1423,11 +1532,22 @@ impl DesktopTarget.build(
     if not tauri_dir.exists() {
         raise RuntimeError("Desktop target not set up. Run 'jac setup desktop' first.") ;
     }
+    # Bake TOML base_url into the bundle; otherwise sidecar discovers port at runtime.
+    toml_base_url = _get_toml_api_base_url(project_dir);
+    if toml_base_url {
+        os.environ[API_BASE_URL_ENV_VAR] = toml_base_url;
+    }
     # Step 1: Build web bundle first (reuse existing pipeline)
     console.print("  Step 1: Building web bundle...", style="muted");
     web_target = WebTarget();
-    web_bundle_path = web_target.build(entry_file, project_dir, platform);
+    try {
+        web_bundle_path = web_target.build(entry_file, project_dir, platform);
+    } finally {
+        os.environ.pop(API_BASE_URL_ENV_VAR, None);
+    }
     console.print(f"  ✔ Web bundle built: {web_bundle_path}", style="success");
+    # Regenerate main.rs with latest TOML config (base_url may have changed since setup)
+    _generate_main_rs(tauri_dir, api_base_url=toml_base_url);
     # Step 1.5: Bundle sidecar (optional - can be skipped if not needed)
     # This bundles the Jac backend as an executable for local use
     sidecar_bundled = False;
@@ -1653,6 +1773,9 @@ def _update_tauri_config_for_build(
         del config["build"]["beforeBuildCommand"];
     }
 
+    # main.rs creates the window via WebviewWindowBuilder (for initialization_script)
+    config.setdefault("app", {})["windows"] = [];
+
     # Populate icon array if empty or missing
     _populate_icon_array(tauri_dir, config);
 
@@ -2017,7 +2140,7 @@ exec python -m jac_client.plugin.src.targets.desktop.sidecar.main "$@"
 
 """Start desktop dev server - start web dev server and launch tauri dev."""
 impl DesktopTarget.dev(
-    self: DesktopTarget, entry_file: Path, project_dir: Path
+    self: DesktopTarget, entry_file: Path, project_dir: Path, api_port: int = 8000
 ) -> None {
     import from jac_client.plugin.src.vite_bundler { ViteBundler }
     import signal;
@@ -2068,8 +2191,12 @@ impl DesktopTarget.dev(
     console.print("  ✔ Module compiled for dev mode", style="success");
     # Step 2: Start web dev server
     console.print("  Starting web dev server...", style="muted");
-    # Create dev vite config
-    dev_config_path = bundler.create_dev_vite_config(entry_file, api_port=8000);
+    # Desktop webview needs an explicit backend URL (same-origin doesn't work)
+    dev_config_path = bundler.create_dev_vite_config(
+        entry_file,
+        api_port=api_port,
+        api_base_url_override=_make_localhost_url(api_port)
+    );
     # Start Vite dev server
     vite_process = bundler.start_dev_server(port=vite_port);
     if not vite_process {
@@ -2078,8 +2205,22 @@ impl DesktopTarget.dev(
     console.print(
         f"  ✔ Web dev server running on http://localhost:{vite_port}", style="success"
     );
-    # Step 3: Launch tauri dev
-    console.print("  Launching Tauri dev window...", style="muted");
+    # Step 3: Start backend API server
+    toml_base_url = _get_toml_api_base_url(project_dir);
+    server_port = _resolve_server_port(toml_base_url, api_port);
+    # Regenerate main.rs with the actual backend URL so sidecar is skipped
+    _generate_main_rs(
+        tauri_dir, api_base_url=toml_base_url or _make_localhost_url(server_port)
+    );
+    console.print(
+        f"  Step 3: Starting backend server on port {server_port}...", style="muted"
+    );
+    server_process = _start_backend_server(entry_file, project_dir, server_port);
+    console.print(
+        f"  ✔ Backend server starting on port {server_port}", style="success"
+    );
+    # Step 4: Launch tauri dev
+    console.print("  Step 4: Launching Tauri dev window...", style="muted");
     console.print("  (Press Ctrl+C to stop)", style="muted");
     # Setup signal handlers for cleanup
     def cleanup -> None {
@@ -2092,6 +2233,14 @@ impl DesktopTarget.dev(
                 vite_process.kill();
             }
         }
+        if server_process {
+            try {
+                server_process.terminate();
+                server_process.wait(timeout=5);
+            } except Exception {
+                server_process.kill();
+            }
+        }
         console.print("  ✔ Dev servers stopped", style="success");
     }
     def signal_handler(signum: int, frame: Any) -> None {
@@ -2155,6 +2304,9 @@ def _update_tauri_config_for_dev(tauri_dir: Path) -> None {
         del config["build"]["beforeBuildCommand"];
     }
 
+    # main.rs creates the window via WebviewWindowBuilder (for initialization_script)
+    config.setdefault("app", {})["windows"] = [];
+
     # Populate icon array if empty or missing
     _populate_icon_array(tauri_dir, config);
 
@@ -2273,33 +2425,104 @@ def _run_tauri_dev(tauri_dir: Path) -> subprocess.Popen {
     }
 }
 
+"""Start backend API server as a subprocess, returning the Popen handle."""
+def _start_backend_server(entry_file: Path, project_dir: Path, port: int) -> Any {
+    import subprocess;
+    import sys;
+    server_process = subprocess.Popen(
+        [
+            sys.executable,
+            "-m",
+            "jaclang",
+            "start",
+            str(entry_file),
+            "--port",
+            str(port),
+            "--no_client"
+        ],
+        cwd=str(project_dir),
+        stdout=None,
+        stderr=None
+    );
+    return server_process;
+}
+
+"""Resolve the API server port from toml_base_url or fall back to api_port."""
+def _resolve_server_port(toml_base_url: str, api_port: int) -> int {
+    if toml_base_url {
+        import from urllib.parse { urlparse }
+        parsed = urlparse(toml_base_url);
+        return parsed.port or api_port;
+    }
+    return api_port;
+}
+
 """Start desktop app - build web bundle and launch Tauri with built bundle."""
 impl DesktopTarget.start(
-    self: DesktopTarget, entry_file: Path, project_dir: Path
+    self: DesktopTarget, entry_file: Path, project_dir: Path, api_port: int = 8000
 ) -> None {
     import from jac_client.plugin.src.targets.web_target { WebTarget }
     import signal;
     import sys;
+    import os;
     console.print("\n🖥️  Starting desktop app (Tauri)", style="bold");
     # Check if setup has been run
     tauri_dir = project_dir / "src-tauri";
     if not tauri_dir.exists() {
         raise RuntimeError("Desktop target not set up. Run 'jac setup desktop' first.") ;
     }
-    # Step 1: Build web bundle first
+    # Step 1: Build web bundle with explicit backend URL for desktop webview.
+    toml_base_url = _get_toml_api_base_url(project_dir);
+    if not toml_base_url {
+        os.environ[API_BASE_URL_ENV_VAR] = _make_localhost_url(api_port);
+    }
     console.print("  Step 1: Building web bundle...", style="muted");
     web_target = WebTarget();
-    web_bundle_path = web_target.build(entry_file, project_dir, None);
+    try {
+        web_bundle_path = web_target.build(entry_file, project_dir, None);
+    } finally {
+        os.environ.pop(API_BASE_URL_ENV_VAR, None);
+    }
     console.print(f"  ✔ Web bundle built: {web_bundle_path}", style="success");
     # Step 2: Update tauri.conf.json to point to web bundle
     console.print("  Step 2: Updating Tauri configuration...", style="muted");
     _update_tauri_config_for_build(tauri_dir, project_dir, web_bundle_path);
-    # Step 3: Launch tauri dev (which will use the built bundle)
-    console.print("  Step 3: Launching Tauri app...", style="muted");
+    # Step 3: Start backend API server
+    server_port = _resolve_server_port(toml_base_url, api_port);
+    # Regenerate main.rs with the actual backend URL so sidecar is skipped
+    _generate_main_rs(
+        tauri_dir, api_base_url=toml_base_url or _make_localhost_url(server_port)
+    );
+    console.print(
+        f"  Step 3: Starting backend server on port {server_port}...", style="muted"
+    );
+    server_process = _start_backend_server(entry_file, project_dir, server_port);
+    console.print(
+        f"  ✔ Backend server starting on port {server_port}", style="success"
+    );
+    # Step 4: Launch tauri dev (which will use the built bundle)
+    console.print("  Step 4: Launching Tauri app...", style="muted");
     console.print("  (Press Ctrl+C to stop)", style="muted");
     # Setup signal handlers for cleanup
+    tauri_process = None;
     def cleanup -> None {
         console.print("\n  Stopping app...", style="muted");
+        if tauri_process {
+            try {
+                tauri_process.terminate();
+                tauri_process.wait(timeout=5);
+            } except Exception {
+                tauri_process.kill();
+            }
+        }
+        if server_process {
+            try {
+                server_process.terminate();
+                server_process.wait(timeout=5);
+            } except Exception {
+                server_process.kill();
+            }
+        }
         console.print("  ✔ App stopped", style="success");
     }
     def signal_handler(signum: int, frame: Any) -> None {
@@ -2308,7 +2531,6 @@ impl DesktopTarget.start(
     }
     signal.signal(signal.SIGINT, signal_handler);
     signal.signal(signal.SIGTERM, signal_handler);
-    tauri_process = None;
     try {
         # Run tauri dev (it will use the built bundle from distDir)
         tauri_process = _run_tauri_dev(tauri_dir);
@@ -2327,16 +2549,6 @@ impl DesktopTarget.start(
         console.print(
             "\n  Keyboard interrupt detected. Stopping app...", style="muted"
         );
-        if tauri_process {
-            try {
-                tauri_process.terminate();
-                tauri_process.wait(timeout=5);
-            } except Exception {
-                if tauri_process {
-                    tauri_process.kill();
-                }
-            }
-        }
     } except Exception as e {
         console.error(f"  Error starting desktop app: {e}");
         import traceback;

jac_client/plugin/src/vite_bundler.jac

@@ -2,6 +2,7 @@
 import hashlib;
 import json;
 import logging;
+import os;
 import shutil;
 import subprocess;
 import from pathlib { Path }
@@ -9,7 +10,9 @@ import from typing { Any, Optional }
 import from jaclang.runtimelib.client_bundle { ClientBundleError }
 import from .config_loader { JacClientConfig }
 
-glob logger = logging.getLogger(__name__);
+glob logger = logging.getLogger(__name__),
+     API_BASE_URL_ENV_VAR = "JAC_CLIENT_API_BASE_URL";
+
 """Handles Vite bundling operations."""
 class ViteBundler {
     def init(
@@ -26,7 +29,14 @@ class ViteBundler {
     def find_css(self: ViteBundler) -> Optional[Path];
     def read_bundle(self: ViteBundler) -> tuple[str, str];
     def _has_typescript_support(self: ViteBundler) -> bool;
-    def create_vite_config(self: ViteBundler, entry_file: Path) -> Path;
+    def _resolve_api_base_url(
+        self: ViteBundler, api_base_url_override: str = ""
+    ) -> str;
+
+    def create_vite_config(
+        self: ViteBundler, entry_file: Path, api_base_url_override: str = ""
+    ) -> Path;
+
     def _get_plugin_var_name(self: ViteBundler, plugin_name: str) -> str;
     def _format_plugin_options(self: ViteBundler, options: dict) -> str;
     def _format_config_object(self: ViteBundler, config: dict, indent: int = 0) -> str;
@@ -42,9 +52,14 @@ class ViteBundler {
 
     """Create a dev-mode vite config with API proxy for HMR."""
     def 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;
 
     """Start Vite dev server as a subprocess."""
     def start_dev_server(self: ViteBundler, port: int = 3000) -> Any;
 }
+# Env var used to pass API base URL through deep call chains
+# (e.g., DesktopTarget.start -> WebTarget.build -> ViteBundler.create_vite_config)