@pheem49/mint 1.16.0 → 1.17.0

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

@@ -10,8 +10,8 @@ use ansi_to_tui::IntoText;
 use anyhow::{Result, anyhow};
 use mint_core::{
     AgentApproval, AgentProgress, AgentResult, ApprovalOutcome, AskUserOption, CHAT_CLI_ID,
-    MemoryStore, MintConfig, OrchestrationError, PermissionDecision, PermissionRule,
-    orchestrate_agent_loop, permission_decision_for,
+    ExecutionState, MemoryStore, MintConfig, OrchestrationError, PermissionDecision,
+    PermissionRule, orchestrate_agent_loop, permission_decision_for,
 };
 use syntect::easy::HighlightLines;
 use syntect::highlighting::ThemeSet;
@@ -98,8 +98,9 @@ pub async fn run_code_agent_with_image(
 fn get_field_alias<'a>(input: &'a serde_json::Value, keys: &[&str]) -> Option<&'a str> {
     for &k in keys {
         if let Some(v) = input.get(k).and_then(|v| v.as_str()) {
-            if !v.trim().is_empty() {
-                return Some(v.trim());
+            let trimmed = v.trim();
+            if !trimmed.is_empty() && !mint_core::is_dummy_value(trimmed) {
+                return Some(trimmed);
             }
         }
     }
@@ -132,7 +133,11 @@ fn generic_tool_label(action: &str, input: &serde_json::Value) -> (bool, String)
             )
         }
         "run_shell" => {
-            let command = get_field_alias(input, &["command", "cmd"]).unwrap_or("");
+            let command = get_field_alias(
+                input,
+                &["command", "cmd", "script", "exec", "code", "bash", "sh"],
+            )
+            .unwrap_or("");
             let background = input
                 .get("background")
                 .and_then(|v| v.as_bool())
@@ -196,6 +201,17 @@ fn generic_tool_label(action: &str, input: &serde_json::Value) -> (bool, String)
             let name = input.get("name").and_then(|v| v.as_str()).unwrap_or("");
             (false, format!("[run_plugin] Running plugin: {}...", name))
         }
+        "dispatch_agents" => {
+            let tasks_len = input
+                .get("tasks")
+                .and_then(|v| v.as_array())
+                .map(|a| a.len())
+                .unwrap_or(1);
+            (
+                false,
+                format!("├── [{CYAN}swarm{RESET}] Dispatching {tasks_len} sub-agent(s)..."),
+            )
+        }
         "dispatch_subagent" => {
             let name = input
                 .get("name")
@@ -551,6 +567,48 @@ pub(crate) fn mcp_progress_notes(event: &AgentProgress) -> Option<Vec<String>> {
                 update.message.as_deref().unwrap_or_default()
             )]
         }
+        AgentProgress::ExecutionUpdate { executions, .. } => executions
+            .iter()
+            .map(|e| {
+                let kind = if e.check { "Check" } else { "Command" };
+                let state_str = match e.state {
+                    ExecutionState::Succeeded => {
+                        format!(
+                            "{}Succeeded{RESET}",
+                            crate::terminal_theme::ANSI_ACCENT_BOLD
+                        )
+                    }
+                    ExecutionState::Failed => {
+                        format!("{}Failed{RESET}", crate::terminal_theme::ANSI_ERROR_BOLD)
+                    }
+                    ExecutionState::Running => {
+                        format!("{}Running{RESET}", crate::terminal_theme::ANSI_BLUE_BOLD)
+                    }
+                    ExecutionState::Cancelled => {
+                        format!("{DIM}Cancelled{RESET}")
+                    }
+                    ExecutionState::Unknown => {
+                        format!("{}Unknown{RESET}", crate::terminal_theme::ANSI_WARNING_BOLD)
+                    }
+                };
+                let exit = e
+                    .exit_code
+                    .map(|c| {
+                        if c == 0 {
+                            format!(" · {DIM}exit {c}{RESET}")
+                        } else {
+                            format!(" · {RED}exit {c}{RESET}")
+                        }
+                    })
+                    .unwrap_or_default();
+                let job = e
+                    .job_id
+                    .as_ref()
+                    .map(|j| format!(" · {DIM}job {j}{RESET}"))
+                    .unwrap_or_default();
+                format!("[{kind}] {state_str} · {}{exit}{job}", e.command)
+            })
+            .collect(),
         AgentProgress::ToolArtifacts {
             artifacts,
             warnings,
@@ -566,13 +624,19 @@ pub(crate) fn mcp_progress_notes(event: &AgentProgress) -> Option<Vec<String>> {
                             .display()
                             .to_string()
                     });
-                    format!("[MCP {}] {}: {location}", artifact.kind, artifact.name)
+                    let tag = match artifact.server.as_str() {
+                        "browser" => "Screenshot".into(),
+                        "view_image" => "Viewed image".into(),
+                        other if !other.is_empty() => format!("MCP {other}"),
+                        _ => format!("MCP {}", artifact.kind),
+                    };
+                    format!("[{tag}] {}: {location}", artifact.name)
                 })
                 .collect::<Vec<_>>();
             notes.extend(
                 warnings
                     .iter()
-                    .map(|warning| format!("[MCP warning] {warning}")),
+                    .map(|warning| format!("[Warning] {warning}")),
             );
             notes
         }
@@ -584,6 +648,11 @@ pub(crate) fn publish_mcp_progress(
     tui: Option<&crate::interactive::TuiHandle>,
     event: &AgentProgress,
 ) -> bool {
+    // In Full-Screen TUI, executions are already rendered as interactive ToolActivity cards.
+    // Suppress redundant [Command]/[Check] text notices in TUI while preserving them for Classic CLI.
+    if tui.is_some() && matches!(event, AgentProgress::ExecutionUpdate { .. }) {
+        return false;
+    }
     let Some(notes) = mcp_progress_notes(event) else {
         return false;
     };
@@ -605,18 +674,18 @@ pub(crate) fn run_summary_lines(
         .iter()
         .filter(|record| !record.success)
         .collect();
-    let outcome = if !failed_tools.is_empty() {
-        format!(
-            "{YELLOW}⚠ Completed with {} failure{}{RESET}",
+    let outcome = match summary.outcome.as_str() {
+        "FAILED" => format!("{RED}✗ Failed{RESET}"),
+        "BLOCKED" => format!("{YELLOW}○ Blocked{RESET}"),
+        "UNVERIFIED" => format!("{YELLOW}? Unverified{RESET}"),
+        "ROLLED_BACK" => format!("{YELLOW}↺ Rolled back{RESET}"),
+        _ if !failed_tools.is_empty() => format!(
+            "{YELLOW}⚠ Completed with {} previous failure{}{RESET}",
             failed_tools.len(),
             if failed_tools.len() == 1 { "" } else { "s" }
-        )
-    } else if summary.outcome == "ROLLED_BACK" {
-        format!("{YELLOW}↺ Rolled back{RESET}")
-    } else if summary.outcome == "FAILED" {
-        format!("{RED}✗ Failed{RESET}")
-    } else {
-        format!("{GREEN}✓ Completed{RESET}")
+        ),
+        "VERIFIED" => format!("{GREEN}✓ Verified{RESET}"),
+        _ => format!("{GREEN}✓ Completed{RESET}"),
     };
     let file_count = summary.files_changed.len();
     let mut lines = vec![format!(
@@ -1083,19 +1152,22 @@ pub async fn run_code_agent_with_options(
                         subagent.as_deref(),
                         Instant::now(),
                     );
-                    if phase == "started" {
-                        status.thinking = Some(compaction_label(Duration::ZERO));
-                    } else {
-                        print_timeline_note(&mut status, &message, started_at.elapsed(), None);
-                        status.context_pct = None;
-                        status.thinking = Some(if let Some(started) = status.compaction_started {
-                            compaction_label(started.elapsed())
+                    if subagent.is_none() {
+                        if phase == "started" {
+                            status.thinking = Some(compaction_label(Duration::ZERO));
                         } else {
-                            format!(
-                                "{thinking_verb} ({} • Esc to interrupt)",
-                                format_elapsed(started_at.elapsed())
-                            )
-                        });
+                            print_timeline_note(&mut status, &message, started_at.elapsed(), None);
+                            status.context_pct = None;
+                            status.thinking =
+                                Some(if let Some(started) = status.compaction_started {
+                                    compaction_label(started.elapsed())
+                                } else {
+                                    format!(
+                                        "{thinking_verb} ({} • Esc to interrupt)",
+                                        format_elapsed(started_at.elapsed())
+                                    )
+                                });
+                        }
                     }
                     render_live_status(&mut status);
                 }
@@ -1392,7 +1464,10 @@ pub async fn run_code_agent_with_options(
             AgentProgress::ToolDiscovery { .. }
             | AgentProgress::DeviceState { .. }
             | AgentProgress::ToolProgress { .. }
-            | AgentProgress::ToolArtifacts { .. } => {}
+            | AgentProgress::ToolArtifacts { .. }
+            | AgentProgress::SubagentStarted { .. }
+            | AgentProgress::SubagentFinished { .. }
+            | AgentProgress::ExecutionUpdate { .. } => {}
             AgentProgress::PlanUpdated { plan } => {
                 if let Ok(mut status) = progress_live_status.lock() {
                     status.thinking = None;
@@ -1557,14 +1632,11 @@ pub async fn run_code_agent_with_options(
         if let Ok(mut status) = live_status.lock()
             && !status.web_sources.is_empty()
         {
-            let sources = status
-                .web_sources
-                .drain(..)
-                .enumerate()
-                .map(|(index, (title, url))| format!("{}. {title}\n   {url}", index + 1))
-                .collect::<Vec<_>>()
-                .join("\n");
-            tui.push_notice(format!("Sources:\n{sources}"));
+            let sources = status.web_sources.drain(..).collect::<Vec<_>>();
+            let text = format_tui_web_sources(&sources, MAX_TUI_WEB_SOURCES);
+            if !text.is_empty() {
+                tui.push_notice(text);
+            }
         }
         tui.push_notice(worked_line);
         avatar_bridge.on_talking(false);
@@ -1882,4 +1954,72 @@ mod skill_card_tests {
         let result = "[2026-08-01] You: hi\nMint: hello";
         assert!(skill_names_from_memory_recall(result).is_empty());
     }
+
+    #[test]
+    fn execution_update_progress_notes_highlight_succeeded_and_failed() {
+        use mint_core::{ExecutionEvidence, ExecutionState};
+        let update = AgentProgress::ExecutionUpdate {
+            call_id: "test".into(),
+            executions: vec![
+                ExecutionEvidence {
+                    call_id: "test1".into(),
+                    command: "ls -la".into(),
+                    state: ExecutionState::Succeeded,
+                    exit_code: Some(0),
+                    job_id: None,
+                    revision: 1,
+                    check: false,
+                    condition_verified: None,
+                },
+                ExecutionEvidence {
+                    call_id: "test2".into(),
+                    command: "cargo check".into(),
+                    state: ExecutionState::Failed,
+                    exit_code: Some(1),
+                    job_id: None,
+                    revision: 2,
+                    check: true,
+                    condition_verified: None,
+                },
+            ],
+        };
+        let notes = mcp_progress_notes(&update).expect("should produce notes");
+        assert_eq!(notes.len(), 2);
+        assert!(notes[0].contains("[Command]"));
+        assert!(notes[0].contains("Succeeded"));
+        assert!(notes[0].contains("exit 0"));
+        assert!(notes[1].contains("[Check]"));
+        assert!(notes[1].contains("Failed"));
+        assert!(notes[1].contains("exit 1"));
+    }
+
+    #[test]
+    fn format_tui_web_sources_handles_empty_under_limit_and_over_limit() {
+        assert_eq!(format_tui_web_sources(&[], 5), "");
+
+        let three_items = vec![
+            ("Site 1".into(), "https://example.com/1".into()),
+            ("Site 2".into(), "https://example.com/2".into()),
+            ("Site 3".into(), "https://example.com/3".into()),
+        ];
+        let out = format_tui_web_sources(&three_items, 5);
+        assert!(out.starts_with("Sources:\n"));
+        assert!(out.contains("1. Site 1\n   https://example.com/1"));
+        assert!(out.contains("2. Site 2\n   https://example.com/2"));
+        assert!(out.contains("3. Site 3\n   https://example.com/3"));
+        assert!(!out.contains("more sources"));
+        assert!(!out.contains("Ctrl+O details"));
+
+        let eight_items: Vec<_> = (1..=8)
+            .map(|i| (format!("Site {i}"), format!("https://example.com/{i}")))
+            .collect();
+        let out = format_tui_web_sources(&eight_items, 5);
+        assert!(out.contains("1. Site 1\n   https://example.com/1"));
+        assert!(out.contains("5. Site 5\n   https://example.com/5"));
+        assert!(!out.contains("6. Site 6"));
+        assert!(out.contains("… [+3 more sources] · "));
+        assert!(out.contains("Ctrl+O view web_search"));
+        assert!(out.contains(crate::terminal_theme::ANSI_MUTED));
+        assert!(out.contains(crate::terminal_theme::ANSI_BLUE));
+    }
 }

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}");
@@ -458,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<()> {
@@ -1113,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());
+    }
+}