@pheem49/mint 1.16.0 → 1.18.0

package/crates/mint-cli/src/commands/agent.rs

@@ -1,4 +1,4 @@
-use std::path::PathBuf;
+use std::path::{Path, PathBuf};
 
 use anyhow::Result;
 use clap::Subcommand;
@@ -182,6 +182,78 @@ pub enum AvatarCommand {
     Disable,
 }
 
+pub fn is_mint_root(p: &Path) -> bool {
+    if !p.join("package.json").exists() {
+        return false;
+    }
+    if p.join("vite.config.web.ts").exists()
+        || p.join("out").join("web").join("index-web.html").exists()
+        || p.join("crates").join("mint-cli").exists()
+    {
+        return true;
+    }
+    if let Ok(contents) = std::fs::read_to_string(p.join("package.json")) {
+        if contents.contains("\"@pheem49/mint\"") || contents.contains("\"dev:web\"") {
+            return true;
+        }
+    }
+    false
+}
+
+pub fn find_mint_root() -> Result<PathBuf> {
+    // 1. Explicit override via environment variables
+    for var in ["MINT_ROOT", "MINT_PROJECT_ROOT", "MINT_WEB_ROOT"] {
+        if let Some(val) = std::env::var_os(var) {
+            let path = PathBuf::from(val);
+            if is_mint_root(&path) {
+                return Ok(path);
+            }
+        }
+    }
+
+    // 2. Traversal up from current executable
+    if let Ok(exe_path) = std::env::current_exe() {
+        if let Some(root) = exe_path.ancestors().find(|p| is_mint_root(p)) {
+            return Ok(root.to_path_buf());
+        }
+    }
+
+    // 3. Compile-time directory (where mint was built / cargo installed)
+    let compile_dir = Path::new(env!("CARGO_MANIFEST_DIR"));
+    if let Some(root) = compile_dir.ancestors().find(|p| is_mint_root(p)) {
+        return Ok(root.to_path_buf());
+    }
+
+    // 4. Current working directory ancestors (ONLY if it's genuinely Mint's root, not another repo)
+    if let Ok(cwd) = std::env::current_dir() {
+        if let Some(root) = cwd.ancestors().find(|p| is_mint_root(p)) {
+            return Ok(root.to_path_buf());
+        }
+    }
+
+    // 5. Standard user/system installation locations
+    if let Some(home) = dirs::home_dir() {
+        let candidates = [
+            home.join(".mint"),
+            home.join(".local/share/mint"),
+            home.join("vscode/Project/Mint-CLI"),
+        ];
+        for candidate in candidates {
+            if is_mint_root(&candidate) {
+                return Ok(candidate);
+            }
+        }
+    }
+
+    anyhow::bail!(
+        "Failed to find Mint Web assets (package.json and vite.config.web.ts).\n\
+        To use 'mint web':\n\
+        • Install via npm: npm install -g @pheem49/mint\n\
+        • Or set MINT_ROOT to your Mint source checkout path (e.g. export MINT_ROOT=/path/to/Mint)\n\
+        • Or use the Mint Desktop application or web app at https://mint.aemeth.xyz"
+    )
+}
+
 pub(crate) async fn launch_mint_target(target: String, dev: bool) -> Result<()> {
     match target.as_str() {
         "cli" => {
@@ -197,34 +269,7 @@ pub(crate) async fn launch_mint_target(target: String, dev: bool) -> Result<()>
         "web" => {
             let config = load_config()?;
             print_welcome_banner(&config);
-            let project_root = {
-                let mut found = None;
-                if let Ok(exe_path) = std::env::current_exe() {
-                    let mut path = exe_path.parent();
-                    while let Some(p) = path {
-                        if p.join("package.json").exists() {
-                            found = Some(p.to_path_buf());
-                            break;
-                        }
-                        path = p.parent();
-                    }
-                }
-                if found.is_none()
-                    && let Ok(cwd) = std::env::current_dir()
-                {
-                    let mut path = Some(cwd.as_path());
-                    while let Some(p) = path {
-                        if p.join("package.json").exists() {
-                            found = Some(p.to_path_buf());
-                            break;
-                        }
-                        path = p.parent();
-                    }
-                }
-                found.ok_or_else(|| {
-                    anyhow::anyhow!("Failed to find project root directory containing package.json")
-                })?
-            };
+            let project_root = find_mint_root()?;
             let dist_web_out = project_root.join("out").join("web").join("index-web.html");
             let dist_web_legacy = project_root
                 .join("out")
@@ -240,6 +285,7 @@ pub(crate) async fn launch_mint_target(target: String, dev: bool) -> Result<()>
             let frontend = mint_core::bg_shell::start_web_frontend(&project_root, &config, web_cmd)
                 .map_err(|e| anyhow::anyhow!("Failed to launch web app: {e}"))?;
             mint_core::bg_shell::watch_web_owner();
+            mint_core::companion::navigation::configure_web("http://localhost:9000/".into());
 
             println!("\n{MINT}✔ Mint Web is running!{RESET}\n");
             println!("    {BLUE}Web UI:{RESET}     {MINT}http://localhost:9000{RESET}");
@@ -257,6 +303,10 @@ pub(crate) async fn launch_mint_target(target: String, dev: bool) -> Result<()>
 
             println!("{DIM}Press Ctrl+C to stop{RESET}\n");
             tokio::select! {
+                _ = wait_for_shutdown_signal() => {
+                    let _ = mint_core::bg_shell::kill_job(&frontend.id);
+                    println!("\n{MINT}✔ Mint Web stopped.{RESET}");
+                }
                 result = mint_core::start_api_server(3000) => result?,
                 result = async {
                     loop {
@@ -366,103 +416,59 @@ pub fn handle_rewind(step: Option<usize>, chat_id: String) -> Result<()> {
     Ok(())
 }
 
-pub async fn handle_auto() -> Result<()> {
-    let config = load_config()?;
-    print_welcome_banner(&config);
-    println!("\n🚀 Starting Mint Browser Automation Environment...");
-    mint_core::spawn_automation_browser(&config)
-        .await
-        .map_err(anyhow::Error::msg)?;
-
-    // Enable the browser tools if they are disabled
-    let mut config_mut = config.clone();
-    if mint_core::enable_browser_tools(&mut config_mut) {
-        mint_core::save_config(&config_mut)?;
-        println!(
-            "✅ Enabled browser automation tools in config: browser_open, browser_click, browser_type, browser_read, browser_mouse_move, browser_mouse_click, browser_key_press, browser_screenshot, browser_tabs, browser_observe, browser_fill, browser_select, browser_scroll, browser_wait"
-        );
-    }
-
-    println!(
-        "🌐 Isolated browser running with remote debugging on {}",
-        config
-            .extra
-            .get("browserDebugUrl")
-            .and_then(serde_json::Value::as_str)
-            .unwrap_or("http://127.0.0.1:9222/json/list")
-    );
-    println!("💬 Keep this terminal open while you want Mint to automate browser tasks.");
-    println!("Press Ctrl+C to terminate the automation browser session.");
-    println!("----------------------------------------------------------------------");
-
-    // Start tailing the log file in a background task
-    let log_dir = dirs::config_dir()
-        .unwrap_or_else(std::env::temp_dir)
-        .join("mint");
-    let log_file = log_dir.join("browser-automation.log");
-
-    // Clear existing log file on startup
-    let _ = std::fs::remove_file(&log_file);
-
-    let log_file_clone = log_file.clone();
-    tokio::spawn(async move {
-        use std::io::{BufRead, BufReader, Seek, SeekFrom};
-        let mut file_pos = 0;
+async fn wait_for_web(urls: &[&str], timeout: std::time::Duration) -> Result<()> {
+    let client = reqwest::Client::builder()
+        .no_proxy()
+        .redirect(reqwest::redirect::Policy::none())
+        .timeout(std::time::Duration::from_secs(1))
+        .build()?;
+    tokio::time::timeout(timeout, async {
         loop {
-            if log_file_clone.exists()
-                && let Ok(mut file) = std::fs::File::open(&log_file_clone)
-                && file.seek(SeekFrom::Start(file_pos)).is_ok()
-            {
-                let reader = BufReader::new(file);
-                for line_str in reader.lines().map_while(Result::ok) {
-                    if line_str.contains("[NAVIGATE]") || line_str.contains("[NAVIGATE_SUCCESS]") {
-                        println!("🌐 {line_str}");
-                    } else if line_str.contains("[CLICK]") || line_str.contains("[CLICK_SUCCESS]") {
-                        println!("🖱️ {line_str}");
-                    } else if line_str.contains("[TYPE]") || line_str.contains("[TYPE_SUCCESS]") {
-                        println!("⌨️ {line_str}");
-                    } else if line_str.contains("[READ]") || line_str.contains("[READ_SUCCESS]") {
-                        println!("📖 {line_str}");
-                    } else if line_str.contains("[MOUSE_MOVE]")
-                        || line_str.contains("[MOUSE_MOVE_SUCCESS]")
-                    {
-                        println!("🖱️  {line_str}");
-                    } else if line_str.contains("[MOUSE_CLICK]")
-                        || line_str.contains("[MOUSE_CLICK_SUCCESS]")
-                    {
-                        println!("🖱️ ● {line_str}");
-                    } else if line_str.contains("[KEY_PRESS]")
-                        || line_str.contains("[KEY_PRESS_SUCCESS]")
-                    {
-                        println!("⌨️  {line_str}");
-                    } else if line_str.contains("[SCREENSHOT]")
-                        || line_str.contains("[SCREENSHOT_SUCCESS]")
-                    {
-                        println!("📸 {line_str}");
-                    } else if line_str.contains("_ERROR]") {
-                        println!("❌ {line_str}");
-                    } else {
-                        println!("📝 {line_str}");
-                    }
-                }
-                if let Ok(pos) = log_file_clone.metadata().map(|m| m.len()) {
-                    file_pos = pos;
+            let mut ready = true;
+            for url in urls {
+                if !client
+                    .get(*url)
+                    .send()
+                    .await
+                    .is_ok_and(|r| r.status().is_success())
+                {
+                    ready = false;
+                    break;
                 }
             }
-            tokio::time::sleep(std::time::Duration::from_millis(100)).await;
+            if ready {
+                return;
+            }
+            tokio::time::sleep(std::time::Duration::from_millis(250)).await;
         }
-    });
-
-    tokio::signal::ctrl_c().await.ok();
-    println!("\n👋 Terminating Mint Browser Automation Environment...");
-    Ok(())
+    })
+    .await
+    .map_err(|_| {
+        anyhow::anyhow!("Mint Web did not become ready before the browser-opening timeout")
+    })
 }
 
-pub async fn handle_web(dev: bool, tailscale: bool) -> Result<()> {
+pub async fn handle_web(dev: bool, tailscale: bool, open: bool) -> Result<()> {
     if tailscale {
         return super::tailnet_web::run().await;
     }
-    launch_mint_target("web".into(), dev).await
+    let browser = open.then(|| tokio::spawn(async {
+        let result = async {
+            wait_for_web(
+                &["http://127.0.0.1:9000/", "http://127.0.0.1:3000/api/status"],
+                std::time::Duration::from_secs(120),
+            ).await?;
+            actions::open_system_handler("http://localhost:9000")
+        }.await;
+        if let Err(error) = result {
+            eprintln!("Could not open Mint Web automatically: {error}. Open http://localhost:9000 manually once ready.");
+        }
+    }));
+    let result = launch_mint_target("web".into(), dev).await;
+    if let Some(browser) = browser {
+        browser.abort();
+    }
+    result
 }
 
 pub async fn handle_api(port: u16) -> Result<()> {
@@ -1113,3 +1119,103 @@ pub async fn handle_avatar(command: AvatarCommand) -> Result<()> {
     }
     Ok(())
 }
+
+#[cfg(test)]
+mod web_readiness_tests {
+    use super::*;
+    use std::sync::{
+        Arc,
+        atomic::{AtomicBool, Ordering},
+    };
+    use tokio::io::{AsyncReadExt, AsyncWriteExt};
+
+    async fn server(ready: Arc<AtomicBool>) -> (String, tokio::task::JoinHandle<()>) {
+        let listener = tokio::net::TcpListener::bind("127.0.0.1:0").await.unwrap();
+        let url = format!("http://{}/", listener.local_addr().unwrap());
+        let task = tokio::spawn(async move {
+            loop {
+                let (mut stream, _) = listener.accept().await.unwrap();
+                let mut request = [0; 4096];
+                let bytes_read = stream.read(&mut request).await.unwrap();
+                if bytes_read == 0 {
+                    continue;
+                }
+                let status = if ready.load(Ordering::Acquire) {
+                    "200 OK"
+                } else {
+                    "503 Service Unavailable"
+                };
+                let response =
+                    format!("HTTP/1.1 {status}\r\nContent-Length: 0\r\nConnection: close\r\n\r\n");
+                let _ = stream.write_all(response.as_bytes()).await;
+            }
+        });
+        (url, task)
+    }
+
+    #[tokio::test]
+    async fn waits_for_both_frontend_and_api_to_succeed() {
+        let (frontend, frontend_task) = server(Arc::new(AtomicBool::new(true))).await;
+        let api_ready = Arc::new(AtomicBool::new(false));
+        let (api, api_task) = server(api_ready.clone()).await;
+        let urls = [frontend.as_str(), api.as_str()];
+        let ready = wait_for_web(&urls, std::time::Duration::from_secs(3));
+        tokio::pin!(ready);
+        assert!(
+            tokio::time::timeout(std::time::Duration::from_millis(350), &mut ready)
+                .await
+                .is_err()
+        );
+        api_ready.store(true, Ordering::Release);
+        ready.await.unwrap();
+        frontend_task.abort();
+        api_task.abort();
+    }
+
+    #[tokio::test]
+    async fn unavailable_web_times_out_instead_of_opening_early() {
+        let (url, server_task) = server(Arc::new(AtomicBool::new(false))).await;
+        assert!(
+            wait_for_web(&[&url], std::time::Duration::from_millis(100))
+                .await
+                .is_err()
+        );
+        server_task.abort();
+    }
+
+    #[test]
+    fn is_mint_root_validates_structure_and_rejects_arbitrary_projects() {
+        let unique = format!(
+            "mint-test-root-{}",
+            std::time::SystemTime::now()
+                .duration_since(std::time::UNIX_EPOCH)
+                .unwrap()
+                .as_nanos()
+        );
+        let temp = std::env::temp_dir().join(unique);
+        std::fs::create_dir_all(&temp).unwrap();
+
+        assert!(!is_mint_root(&temp));
+
+        let foreign_pkg = temp.join("package.json");
+        std::fs::write(
+            &foreign_pkg,
+            r#"{"name": "foreign-app", "scripts": {"test": "echo test"}}"#,
+        )
+        .unwrap();
+        assert!(!is_mint_root(&temp));
+
+        let vite_config = temp.join("vite.config.web.ts");
+        std::fs::write(&vite_config, "// vite config").unwrap();
+        assert!(is_mint_root(&temp));
+
+        let _ = std::fs::remove_dir_all(&temp);
+    }
+
+    #[test]
+    fn find_mint_root_honors_env_and_resolves_compile_time() {
+        let root = find_mint_root().expect("Should locate current Mint workspace root");
+        assert!(root.join("package.json").exists());
+        assert!(root.join("vite.config.web.ts").exists());
+    }
+}

package/crates/mint-cli/src/commands/browser.rs

@@ -0,0 +1,114 @@
+use anyhow::{Context, Result};
+use clap::Subcommand;
+use mint_core::{Capability, MintConfig};
+use std::path::PathBuf;
+
+#[derive(Debug, Subcommand)]
+pub enum BrowserCommand {
+    /// Run a JSON workflow in one isolated headless browser session.
+    Run {
+        #[arg(long)]
+        file: PathBuf,
+    },
+}
+
+pub async fn handle(command: BrowserCommand, config: &MintConfig, plan_mode: bool) -> Result<()> {
+    let BrowserCommand::Run { file } = command;
+    let mut config = config.clone();
+    if let Ok(policy) = std::env::var("MINT_BROWSER_POLICY") {
+        let policy: serde_json::Value =
+            serde_json::from_str(&policy).context("Invalid parent browser policy")?;
+        if let Some(disabled) = policy["disabledTools"].as_array() {
+            for tool in disabled.iter().filter_map(|s| s.as_str()) {
+                if !config.disabled_tools.iter().any(|t| t == tool) {
+                    config.disabled_tools.push(tool.into());
+                }
+            }
+        }
+        for key in [
+            "browserExecutable",
+            "browserViewportWidth",
+            "browserViewportHeight",
+            "browserLaunchArgs",
+        ] {
+            if !policy[key].is_null() {
+                config.extra.insert(key.into(), policy[key].clone());
+            }
+        }
+        if let Some(safety) = policy["safetyEnabled"].as_bool() {
+            config.safety_enabled = safety;
+        }
+        if let Some(paths) = policy.get("allowedReadPaths") {
+            config.allowed_read_paths = serde_json::from_value(paths.clone())?;
+        }
+        if let Some(paths) = policy.get("allowedWritePaths") {
+            config.allowed_write_paths = serde_json::from_value(paths.clone())?;
+        }
+    }
+    let file = mint_core::assert_path_capability(&file, Capability::Read, &config)?;
+    anyhow::ensure!(
+        std::fs::metadata(&file)?.len() <= 1_048_576,
+        "Workflow file exceeds 1 MiB"
+    );
+    let workflow: mint_core::browser::workflow::BrowserWorkflow =
+        serde_json::from_slice(&std::fs::read(file)?)?;
+    mint_core::browser::workflow::validate(&workflow, &config, plan_mode)
+        .map_err(anyhow::Error::msg)?;
+    let root =
+        mint_core::assert_path_capability(&std::env::current_dir()?, Capability::Write, &config)?;
+    let report_path = std::env::var_os("MINT_BROWSER_REPORT")
+        .map(PathBuf::from)
+        .unwrap_or_else(|| {
+            root.join(".mint/browser-runs")
+                .join(format!(
+                    "{}",
+                    chrono::Utc::now().timestamp_nanos_opt().unwrap_or_default()
+                ))
+                .join("report.json")
+        });
+    let output = report_path.parent().context("Invalid report path")?;
+    anyhow::ensure!(
+        output.starts_with(&root),
+        "Browser output must be inside the workflow workspace"
+    );
+    std::fs::create_dir_all(output)?;
+    let output = output.canonicalize()?;
+    anyhow::ensure!(
+        output.starts_with(root.canonicalize()?),
+        "Browser output resolves outside the workspace"
+    );
+    let run = mint_core::browser::workflow::run(&config, workflow, &output, plan_mode, |message| {
+        eprintln!("{message}")
+    });
+    let report = tokio::select! {
+        result=run=>result.map_err(anyhow::Error::msg)?,
+        _=cancellation_signal()=>anyhow::bail!("Browser workflow cancelled; input completion may be unconfirmed"),
+    };
+    let encoded = serde_json::to_vec_pretty(&report)?;
+    std::fs::write(output.join("report.json"), &encoded)?;
+    println!("{}", String::from_utf8(encoded)?);
+    anyhow::ensure!(
+        report.status == "succeeded",
+        "Browser workflow {}: {}",
+        report.status,
+        report.error.as_deref().unwrap_or("Inspect the report")
+    );
+    Ok(())
+}
+
+async fn cancellation_signal() {
+    #[cfg(unix)]
+    {
+        if let Ok(mut terminate) =
+            tokio::signal::unix::signal(tokio::signal::unix::SignalKind::terminate())
+        {
+            tokio::select! { _=tokio::signal::ctrl_c()=>{}, _=terminate.recv()=>{} }
+        } else {
+            let _ = tokio::signal::ctrl_c().await;
+        }
+    }
+    #[cfg(not(unix))]
+    {
+        let _ = tokio::signal::ctrl_c().await;
+    }
+}

package/crates/mint-cli/src/commands/config.rs

@@ -112,7 +112,20 @@ pub fn handle_update(check: bool, dry_run: bool, approve: bool) -> Result<()> {
 }
 
 pub async fn handle_onboard() -> Result<()> {
-    onboard::run().await
+    match onboard::run().await? {
+        onboard::OnboardOutcome::SavedAndLaunch => {
+            println!("\x1b[32m✔ Configuration saved. Launching Mint...\x1b[0m");
+            crate::interactive::run_interactive_chat_with_session(None, false, false, None, true)
+                .await?;
+        }
+        onboard::OnboardOutcome::SavedAndExit => {
+            println!("\x1b[32m✔ Configuration saved successfully!\x1b[0m");
+        }
+        onboard::OnboardOutcome::Cancelled => {
+            println!("\x1b[33mOnboarding cancelled.\x1b[0m");
+        }
+    }
+    Ok(())
 }
 
 pub async fn handle_setup() -> Result<()> {

package/crates/mint-cli/src/commands/integrations.rs

@@ -13,10 +13,10 @@ pub enum McpCommand {
     Add {
         name: String,
         command: String,
-        /// Repeatable: one value per `--args` occurrence (e.g. `--args -y --args --header`).
-        #[arg(long, num_args = 1, allow_hyphen_values = true)]
+        /// Repeatable: one value per `--args` occurrence (e.g. `--args -y` or `-a -y`).
+        #[arg(long, short = 'a', num_args = 1, allow_hyphen_values = true)]
         args: Vec<String>,
-        #[arg(long, num_args = 1, allow_hyphen_values = true)]
+        #[arg(long, short = 'e', num_args = 1, allow_hyphen_values = true)]
         env: Vec<String>,
         /// Immediately allow the agent to call every tool on the new server
         /// (`allow <name> *`). Off by default — tools are opt-in per server.

package/crates/mint-cli/src/commands/knowledge.rs

@@ -285,9 +285,23 @@ pub fn handle_learn(path: Option<PathBuf>, list: bool, delete: Option<String>) -
         let unique_skills =
             mint_core::skill_inventory::list_available_skills(&memory, root.as_deref())?;
         if unique_skills.is_empty() {
-            println!("No learned skills found.");
+            if let Some(ref workspace_root) = root {
+                println!(
+                    "No learned skills found in workspace: {}",
+                    workspace_root.display()
+                );
+            } else {
+                println!("No learned skills found.");
+            }
         } else {
-            println!("Learned AI Skills:");
+            if let Some(ref workspace_root) = root {
+                println!(
+                    "Learned AI Skills (Workspace: {}):",
+                    workspace_root.display()
+                );
+            } else {
+                println!("Learned AI Skills:");
+            }
             for entry in &unique_skills {
                 let skill = &entry.skill;
                 let name = &skill.name;

package/crates/mint-cli/src/commands/mod.rs

@@ -5,6 +5,7 @@ use clap::Subcommand;
 use mint_core::MintConfig;
 
 pub mod agent;
+pub mod browser;
 pub mod config;
 pub mod eval;
 pub mod git;
@@ -117,10 +118,16 @@ pub enum Command {
         /// Optional session ID to resume directly (omitting opens the interactive picker).
         id: Option<String>,
     },
-    /// Start the browser automation environment and enable browser actions.
-    Auto,
+    /// Run browser automation workflows using the shared Mint Browser engine.
+    Browser {
+        #[command(subcommand)]
+        command: browser::BrowserCommand,
+    },
     /// Launch the web UI and local API server.
     Web {
+        /// Open the default browser once the web UI and API are ready.
+        #[arg(long, default_value_t = false, conflicts_with = "tailscale")]
+        open: bool,
         /// Force development mode with Hot Module Replacement (HMR)
         #[arg(long, default_value_t = false, conflicts_with = "tailscale")]
         dev: bool,
@@ -351,8 +358,12 @@ pub async fn dispatch(cmd: Command, config: &mut MintConfig, cli: &crate::Cli) -
             .await?;
             Ok(())
         }
-        Command::Auto => agent::handle_auto().await,
-        Command::Web { dev, tailscale } => agent::handle_web(dev, tailscale).await,
+        Command::Browser { command } => browser::handle(command, config, cli.plan).await,
+        Command::Web {
+            dev,
+            tailscale,
+            open,
+        } => agent::handle_web(dev, tailscale, open).await,
         Command::Api { port } => agent::handle_api(port).await,
         Command::Gateway { command } => agent::handle_gateway(command).await,
         Command::Chat {

package/crates/mint-cli/src/commands/tailnet_web.rs

@@ -22,13 +22,7 @@ impl Drop for ChildGuard {
 }
 
 fn project_root() -> Result<PathBuf> {
-    let cwd = std::env::current_dir()?;
-    let exe = std::env::current_exe()?;
-    exe.ancestors()
-        .chain(cwd.ancestors())
-        .find(|path| path.join("package.json").exists())
-        .map(PathBuf::from)
-        .context("Could not find the Mint project root (package.json)")
+    super::agent::find_mint_root()
 }
 
 fn tailscale(args: &[&str]) -> Result<String> {
@@ -138,6 +132,7 @@ pub async fn run() -> Result<()> {
         Command::new("node")
             .current_dir(&root)
             .env("MINT_TAILSCALE_HOST", url.trim_start_matches("https://"))
+            .env("VITE_CONFIG_NATIVE_IGNORE_WARNING", "true")
             .arg(vite)
             .args([
                 "preview",
@@ -152,6 +147,7 @@ pub async fn run() -> Result<()> {
             .context("Could not start the production Web UI")?,
     );
     wait_for_port(9000).await?;
+    mint_core::companion::navigation::configure_web(url.clone());
 
     let api_addr = SocketAddr::new(IpAddr::V4(Ipv4Addr::LOCALHOST), 3000);
     let mut api = tokio::spawn(mint_core::api_server::start_api_server_on(api_addr));