@pheem49/mint 1.15.0 → 1.17.0

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

@@ -1,9 +1,9 @@
-use std::path::PathBuf;
+use std::path::{Path, PathBuf};
 
 use anyhow::Result;
 use clap::Subcommand;
 use mint_core::{
-    CHAT_CLI_ID, ChatRequest, ImageGenRequest, MintConfig, TaskStore, generate_images, load_config,
+    CHAT_CLI_ID, ChatRequest, ImageGenRequest, MintConfig, TaskStore, load_config,
     orchestrate_chat_with_fallback, save_config,
 };
 
@@ -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")
@@ -237,13 +282,10 @@ pub(crate) async fn launch_mint_target(target: String, dev: bool) -> Result<()>
             } else {
                 "dev:web"
             };
-            std::process::Command::new("npm")
-                .current_dir(&project_root)
-                .args(["run", web_cmd])
-                .stdout(std::process::Stdio::null())
-                .stderr(std::process::Stdio::null())
-                .spawn()
+            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}");
@@ -260,7 +302,20 @@ pub(crate) async fn launch_mint_target(target: String, dev: bool) -> Result<()>
             println!("{DIM}(API Requests & Error logs will be displayed below){RESET}\n");
 
             println!("{DIM}Press Ctrl+C to stop{RESET}\n");
-            mint_core::start_api_server(3000).await?;
+            tokio::select! {
+                result = mint_core::start_api_server(3000) => result?,
+                result = async {
+                    loop {
+                        let job = mint_core::bg_shell::snapshot(&frontend.id)?;
+                        if !matches!(job.status, mint_core::bg_shell::JobStatus::Running | mint_core::bg_shell::JobStatus::Stopping) {
+                            anyhow::bail!("Mint Web frontend stopped ({:?}):\n{}\n{}", job.status, job.stdout, job.stderr);
+                        }
+                        tokio::time::sleep(std::time::Duration::from_millis(100)).await;
+                    }
+                    #[allow(unreachable_code)]
+                    Ok::<(), anyhow::Error>(())
+                } => result?,
+            }
         }
         _ => {}
     }
@@ -449,11 +504,59 @@ pub async fn handle_auto() -> Result<()> {
     Ok(())
 }
 
-pub async fn handle_web(dev: bool, tailscale: bool) -> Result<()> {
+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 {
+            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;
+                }
+            }
+            if ready {
+                return;
+            }
+            tokio::time::sleep(std::time::Duration::from_millis(250)).await;
+        }
+    })
+    .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, 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<()> {
@@ -584,28 +687,49 @@ pub async fn handle_chat(
         .await?;
     } else {
         let image_data_uri = image_path.map(image::load_image_as_data_uri).transpose()?;
-        let (response, _) = orchestrate_chat_with_fallback(
+        let name = image_path
+            .and_then(|path| path.file_name())
+            .map(|name| name.to_string_lossy().into_owned());
+        let receipt = image::prepare_attachments(
             config,
-            &ChatRequest {
-                message: message.clone(),
-                system_instruction: system,
-                chat_id: Some(CHAT_CLI_ID.to_owned()),
-                image_data_uri: image_data_uri.clone(),
-                audio_data_uri: None,
-                video_data_uri: None,
-                document_attachment: None,
-                workspace_path: Some(std::env::current_dir()?.to_string_lossy().into_owned()),
-                agent_id: None,
-                plan_mode: false,
-                pinned_mcp_server: None,
-                messages: None,
-                tools: None,
-                temperature: config.temperature,
-                ..Default::default()
+            CHAT_CLI_ID,
+            &message,
+            image_data_uri.as_deref(),
+            None,
+            name.as_deref(),
+        )
+        .await?;
+        let (response, _) = mint_core::with_turn_start_listener(
+            CHAT_CLI_ID.to_owned(),
+            move |id| {
+                if let Some(receipt) = &receipt
+                    && let Err(error) = receipt.bind(id)
+                {
+                    eprintln!("Library reference: {error}")
+                }
             },
+            orchestrate_chat_with_fallback(
+                config,
+                &ChatRequest {
+                    message: message.clone(),
+                    system_instruction: system,
+                    chat_id: Some(CHAT_CLI_ID.to_owned()),
+                    image_data_uri: image_data_uri.clone(),
+                    audio_data_uri: None,
+                    video_data_uri: None,
+                    document_attachment: None,
+                    workspace_path: Some(std::env::current_dir()?.to_string_lossy().into_owned()),
+                    agent_id: None,
+                    plan_mode: false,
+                    pinned_mcp_server: None,
+                    messages: None,
+                    tools: None,
+                    temperature: config.temperature,
+                    ..Default::default()
+                },
+            ),
         )
         .await?;
-        image::save_sent_image_after_send(image_data_uri.as_deref(), &message, None);
         println!("{}", response.text);
     }
     Ok(())
@@ -643,39 +767,23 @@ pub async fn handle_imagine(
         mask_data_uri: None,
         mode: None,
     };
-    match generate_images(&config, &request).await {
+    match mint_core::image_workflow::generate_and_save_images(&config, &request).await {
         Ok(result) => {
             spinner.finish_and_clear();
             eprintln!("{MINT}✦ Generated {} image(s){RESET}", result.images.len());
-            let data_uris: Vec<String> = result
-                .images
-                .iter()
-                .map(|img| img.data_uri.clone())
-                .collect();
-            match mint_core::save_chat_images(
-                data_uris,
-                Some(result.provider.clone()),
-                Some(prompt.clone()),
-            ) {
-                Ok(saved) => {
-                    for entry in &saved {
-                        println!("{MINT}✓{RESET} Saved: {}", entry.path.display());
-                    }
-                    if let (Some(out_path), Some(first)) = (&output, saved.first()) {
-                        match std::fs::copy(&first.path, out_path) {
-                            Ok(_) => println!("{MINT}✓{RESET} Copied to: {}", out_path.display()),
-                            Err(e) => eprintln!(
-                                "{WARN}Warning: could not copy to output path: {e}{RESET}"
-                            ),
-                        }
-                    }
-                    if let Some(desc) = &result.description
-                        && !desc.is_empty()
-                    {
-                        println!("\n{DIM}{desc}{RESET}");
-                    }
+            for entry in &result.images {
+                println!("{MINT}✓{RESET} Saved: {}", entry.path.display());
+            }
+            if let (Some(out_path), Some(first)) = (&output, result.images.first()) {
+                match std::fs::copy(&first.path, out_path) {
+                    Ok(_) => println!("{MINT}✓{RESET} Copied to: {}", out_path.display()),
+                    Err(e) => eprintln!("{WARN}Warning: could not copy to output path: {e}{RESET}"),
                 }
-                Err(e) => eprintln!("{ERROR}Failed to save images: {e}{RESET}"),
+            }
+            if let Some(desc) = &result.description
+                && !desc.is_empty()
+            {
+                println!("\n{DIM}{desc}{RESET}");
             }
         }
         Err(e) => {
@@ -1099,3 +1207,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,127 @@
+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 browser session (headless by default).
+    Run {
+        #[arg(long)]
+        file: PathBuf,
+        /// Show the browser window for this workflow.
+        #[arg(long)]
+        headed: bool,
+    },
+}
+
+pub async fn handle(command: BrowserCommand, config: &MintConfig, plan_mode: bool) -> Result<()> {
+    let BrowserCommand::Run { file, headed } = 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 [
+            "browserAutomationEnabled",
+            "browserAgentMode",
+            "browserExecutable",
+            "automationBrowser",
+            "browserViewportWidth",
+            "browserViewportHeight",
+            "browserLaunchArgs",
+            "browserDebugUrl",
+            "browserUseExisting",
+        ] {
+            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())?;
+        }
+    }
+    if headed {
+        config
+            .extra
+            .insert("browserAgentMode".into(), serde_json::json!("headed"));
+    }
+    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

@@ -38,6 +38,9 @@ pub enum McpCommand {
     /// Change a configured server in place — only the flags you pass are touched.
     Edit {
         name: String,
+        /// Maximum tool-call duration, including sending and receiving.
+        #[arg(long, value_parser = clap::value_parser!(u64).range(1..=3600))]
+        timeout_secs: Option<u64>,
         #[arg(long)]
         command: Option<String>,
         /// Repeatable; replaces the arg list. Passing none leaves args unchanged.
@@ -215,6 +218,7 @@ pub async fn handle_mcp(command: McpCommand) -> Result<()> {
         }
         McpCommand::Edit {
             name,
+            timeout_secs,
             command,
             args,
             env,
@@ -230,6 +234,9 @@ pub async fn handle_mcp(command: McpCommand) -> Result<()> {
                 icon,
             )?;
             if existed {
+                if let Some(timeout) = timeout_secs {
+                    mint_core::mcp::set_mcp_timeout(&name, timeout)?;
+                }
                 println!("updated {name}");
             } else {
                 println!("{ERROR}not found:{RESET} {name}");